From 7417c48351a04a46c67e1bb8b08223c425944cb6 Mon Sep 17 00:00:00 2001
From: Xavier Routh <xrouth2@illinois.edu>
Date: Wed, 11 Dec 2024 11:34:15 -0600
Subject: [PATCH 01/68] initial fork-opt
---
Cargo.lock | 64 +++++++
Cargo.toml | 4 +-
hercules_ir/src/loops.rs | 12 +-
hercules_opt/Cargo.toml | 1 +
hercules_opt/src/forkify.rs | 19 ++
hercules_opt/src/ivar.rs | 172 ++++++++++++++++++
hercules_opt/src/lib.rs | 5 +
.../hercules_tests/tests/loop_tests.rs | 40 ++++
.../fork_optimization/fork_fission.hir | 0
.../fork_optimization/fork_fusion.hir | 0
.../fork_optimization/fork_interchange.hir | 0
.../fork_optimization/phi_loop0.hir | 12 ++
.../fork_optimization/phi_loop1.hir | 16 ++
.../fork_optimization/phi_loop2.hir | 15 ++
.../fork_optimization/phi_loop3.hir | 16 ++
.../test_inputs/fork_optimization/tiling.hir | 0
.../fork_optimization/untiling.hir | 0
17 files changed, 370 insertions(+), 6 deletions(-)
create mode 100644 hercules_opt/src/ivar.rs
create mode 100644 hercules_test/hercules_tests/tests/loop_tests.rs
create mode 100644 hercules_test/test_inputs/fork_optimization/fork_fission.hir
create mode 100644 hercules_test/test_inputs/fork_optimization/fork_fusion.hir
create mode 100644 hercules_test/test_inputs/fork_optimization/fork_interchange.hir
create mode 100644 hercules_test/test_inputs/fork_optimization/phi_loop0.hir
create mode 100644 hercules_test/test_inputs/fork_optimization/phi_loop1.hir
create mode 100644 hercules_test/test_inputs/fork_optimization/phi_loop2.hir
create mode 100644 hercules_test/test_inputs/fork_optimization/phi_loop3.hir
create mode 100644 hercules_test/test_inputs/fork_optimization/tiling.hir
create mode 100644 hercules_test/test_inputs/fork_optimization/untiling.hir
diff --git a/Cargo.lock b/Cargo.lock
index 1f9d1747..38993637 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -369,6 +369,26 @@ dependencies = [
"powerfmt",
]
+[[package]]
+name = "derive_more"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4a9b99b9cbbe49445b21764dc0625032a89b145a2642e67603e1c936f5458d05"
+dependencies = [
+ "derive_more-impl",
+]
+
+[[package]]
+name = "derive_more-impl"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb7330aeadfbe296029522e6c40f315320aba36fc43a5b3632f3795348f3bd22"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.79",
+]
+
[[package]]
name = "dot"
version = "0.1.0"
@@ -607,6 +627,20 @@ dependencies = [
"ron",
]
+[[package]]
+name = "hercules_interpreter"
+version = "0.1.0"
+dependencies = [
+ "bitvec",
+ "clap",
+ "derive_more",
+ "hercules_ir",
+ "hercules_opt",
+ "itertools",
+ "ordered-float",
+ "rand",
+]
+
[[package]]
name = "hercules_ir"
version = "0.1.0"
@@ -630,6 +664,7 @@ dependencies = [
"ordered-float",
"postcard",
"serde",
+ "slotmap",
"take_mut",
]
@@ -656,6 +691,20 @@ dependencies = [
"uuid",
]
+[[package]]
+name = "hercules_tests"
+version = "0.1.0"
+dependencies = [
+ "bitvec",
+ "clap",
+ "hercules_interpreter",
+ "hercules_ir",
+ "hercules_opt",
+ "itertools",
+ "ordered-float",
+ "rand",
+]
+
[[package]]
name = "hermit-abi"
version = "0.4.0"
@@ -1290,6 +1339,15 @@ dependencies = [
"autocfg",
]
+[[package]]
+name = "slotmap"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dbff4acf519f630b3a3ddcfaea6c06b42174d9a44bc70c620e9ed1649d58b82a"
+dependencies = [
+ "version_check",
+]
+
[[package]]
name = "sparsevec"
version = "0.2.0"
@@ -1469,6 +1527,12 @@ dependencies = [
"time",
]
+[[package]]
+name = "version_check"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
+
[[package]]
name = "vob"
version = "3.0.3"
diff --git a/Cargo.toml b/Cargo.toml
index a34845f8..00ee71fd 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -9,8 +9,8 @@ members = [
"hercules_tools/hercules_driver",
- #"hercules_test/hercules_interpreter",
- #"hercules_test/hercules_tests",
+ "hercules_test/hercules_interpreter",
+ "hercules_test/hercules_tests",
"hercules_samples/dot",
"hercules_samples/matmul",
diff --git a/hercules_ir/src/loops.rs b/hercules_ir/src/loops.rs
index 5aa6bd19..3f6a4b1d 100644
--- a/hercules_ir/src/loops.rs
+++ b/hercules_ir/src/loops.rs
@@ -9,14 +9,14 @@ use self::bitvec::prelude::*;
use crate::*;
/*
- * Custom type for storing a loop tree. Each node corresponds to a single loop
- * or a fork join pair in the IR graph. Each node in the tree corresponds to
+ * Custom type for storing a loop tree. Each node corresponds to either a single
+ * loop or a fork join pair in the IR graph. Each node in the tree corresponds to
* some subset of the overall IR graph. The root node corresponds to the entire
* IR graph. The children of the root correspond to the top-level loops and fork
* join pairs, and so on. Each node in the loop tree has a representative
* "header" node. For normal loops, this is the region node branched to by a
* dominated if node. For fork join pairs, this is the fork node. A loop is a
- * top-level loop if its parent is the root node of the subgraph. Each node in
+ * top-level loop if its parent is the root node of the subgraph. Each control node in
* the tree is an entry in the loops HashMap - the key is the "header" node for
* the loop, and the value is a pair of the set of control nodes inside the loop
* and this loop's parent header.
@@ -24,11 +24,15 @@ use crate::*;
#[derive(Debug, Clone)]
pub struct LoopTree {
root: NodeID,
- loops: HashMap<NodeID, (BitVec<u8, Lsb0>, NodeID)>,
+ // Maps loop headers to their control nodes, and a possible header of the loop they are contained in.
+ // FIXME: (@xrouth) shouldn't the parent be an Option: i.e what if there is no loop parent.
+ loops: HashMap<NodeID, (BitVec<u8, Lsb0>, NodeID)>,
nesting: HashMap<NodeID, usize>,
}
impl LoopTree {
+ // TODO: Document what this does, seems to only work for control nodes.
+ // i.e data nodes *in* the loop do not return true.
pub fn contains(&self, x: NodeID) -> bool {
x == self.root || self.loops.contains_key(&x)
}
diff --git a/hercules_opt/Cargo.toml b/hercules_opt/Cargo.toml
index e1936a97..1ca4ae6a 100644
--- a/hercules_opt/Cargo.toml
+++ b/hercules_opt/Cargo.toml
@@ -9,6 +9,7 @@ bitvec = "*"
either = "*"
itertools = "*"
take_mut = "*"
+slotmap = "*"
postcard = { version = "*", features = ["alloc"] }
serde = { version = "*", features = ["derive"] }
hercules_cg = { path = "../hercules_cg" }
diff --git a/hercules_opt/src/forkify.rs b/hercules_opt/src/forkify.rs
index e32bef38..6f041591 100644
--- a/hercules_opt/src/forkify.rs
+++ b/hercules_opt/src/forkify.rs
@@ -2,6 +2,9 @@ extern crate hercules_ir;
use std::iter::zip;
+use crate::compute_induction_vars;
+use crate::compute_loop_variance;
+
use self::hercules_ir::def_use::*;
use self::hercules_ir::ir::*;
use self::hercules_ir::loops::*;
@@ -17,6 +20,22 @@ pub fn forkify(
def_use: &ImmutableDefUseMap,
loops: &LoopTree,
) {
+
+ // let mut scev_context = SCEVContext::new(function, loops);
+ // scev_context.gather_evolutions();
+
+ println!("num loops: {:?}", loops.loops().len());
+
+ println!("funciton len: {:?}", function.nodes.len());
+
+ let (header, (body, parent)) = loops.loops().nth(0).expect("No loops found in function.");
+
+ let loop_nodes = (body.clone(), header.clone());
+ let variance = compute_loop_variance(function, &loop_nodes);
+ compute_induction_vars(function, *parent, &loop_nodes, variance);
+ // println!("variance: {:?}", variance);
+
+ return;
// Ignore loops that are already fork-joins. TODO: re-calculate def_use per
// loop, since it's technically invalidated after each individual loop
// modification.
diff --git a/hercules_opt/src/ivar.rs b/hercules_opt/src/ivar.rs
new file mode 100644
index 00000000..d9a516b1
--- /dev/null
+++ b/hercules_opt/src/ivar.rs
@@ -0,0 +1,172 @@
+extern crate hercules_ir;
+extern crate slotmap;
+extern crate bitvec;
+
+use std::collections::{BTreeMap, HashMap, VecDeque};
+
+use self::bitvec::order::Lsb0;
+use self::bitvec::vec::BitVec;
+use self::hercules_ir::get_uses;
+use self::bitvec::prelude::*;
+
+use self::hercules_ir::LoopTree;
+
+use self::slotmap::{new_key_type, SlotMap};
+
+use self::hercules_ir::ir::*;
+
+use crate::*;
+
+type DenseNodeMap<T> = Vec<T>;
+type SparseNodeMap<T> = HashMap<NodeID, T>;
+
+/**
+ * This represents induction vairable analysis, to be used by forkify!
+ */
+
+/* ASIDE: (@xrouth) I want a word for something that can be 'queried', but doesn't reveal anything about the underlying data structure,
+ single loop only... */
+
+
+#[derive(Debug)]
+pub struct LoopVarianceInfo {
+ loop_header: NodeID,
+ map: DenseNodeMap<LoopVariance>
+}
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+enum LoopVariance {
+ Unknown,
+ Invariant,
+ Variant,
+}
+
+/** Given a loop (from LoopTree) determine for each data node if. Queries on control nodes are undefined. */
+pub fn compute_loop_variance(function: &Function, loop_nodes: &(BitVec<u8, Lsb0>, NodeID)) -> LoopVarianceInfo {
+ let (loop_inner_control_nodes, loop_header) = loop_nodes;
+
+ // Gather all Phi nodes that are controlled by this loop.
+ let mut loop_vars: Vec<NodeID> = vec![];
+
+ for (node_id, node) in function.nodes.iter().enumerate() {
+ if let Some((control, _)) = node.try_phi() {
+ if loop_inner_control_nodes[control.idx()] {
+ loop_vars.push(NodeID::new(node_id));
+ }
+ }
+ }
+
+ let len = function.nodes.len();
+
+ let mut all_loop_nodes = loop_inner_control_nodes.clone();
+
+ all_loop_nodes.set(loop_header.idx(), true);
+
+ let mut variance_map: DenseNodeMap<LoopVariance> = vec![LoopVariance::Unknown; len];
+
+ fn recurse(function: &Function, node: NodeID, all_loop_nodes: &BitVec<u8, Lsb0>, variance_map: & mut DenseNodeMap<LoopVariance>, visited: &mut DenseNodeMap<bool>) -> LoopVariance {
+ if visited[node.idx()] {
+ return variance_map[node.idx()];
+ }
+
+ visited[node.idx()] = true;
+
+ let node_variance = match variance_map[node.idx()] {
+ LoopVariance::Invariant => LoopVariance::Invariant,
+ LoopVariance::Variant => LoopVariance::Variant,
+ LoopVariance::Unknown => {
+
+ let mut node_variance = LoopVariance::Invariant;
+
+ // Two conditions cause something to be loop variant:
+ for node_use in get_uses(&function.nodes[node.idx()]).as_ref() {
+ // 1) The use is a PHI *controlled* by the loop
+ if let Some((control, data)) = function.nodes[node_use.idx()].try_phi() {
+ if *all_loop_nodes.get(control.idx()).unwrap() {
+ node_variance = LoopVariance::Variant;
+ break;
+ }
+ }
+
+ // 2) Any of the nodes uses are loop variant
+ if recurse(function, *node_use, all_loop_nodes, variance_map, visited) == LoopVariance::Variant {
+ node_variance = LoopVariance::Variant;
+ break;
+ }
+ }
+
+ variance_map[node.idx()] = node_variance;
+
+ node_variance
+ }
+ };
+
+ return node_variance;
+ }
+
+ let mut visited: DenseNodeMap<bool> = vec![false; len];
+
+ for node in (0..function.nodes.len()).map(NodeID::new) {
+ recurse(function, node, &all_loop_nodes, &mut variance_map, &mut visited);
+ };
+
+ return LoopVarianceInfo { loop_header: *loop_header, map: variance_map };
+}
+
+pub fn compute_induction_vars(function: &Function, loop_preheader: NodeID, loop_nodes: &(BitVec<u8, Lsb0>, NodeID), loop_variance: LoopVarianceInfo) {
+ let (loop_inner_control_nodes, loop_header) = loop_nodes;
+
+ let mut loop_vars: Vec<NodeID> = vec![];
+
+ for (node_id, node) in function.nodes.iter().enumerate() {
+ if let Some((control, _)) = node.try_phi() {
+ if loop_inner_control_nodes[control.idx()] {
+ loop_vars.push(NodeID::new(node_id));
+ }
+ }
+ }
+ // FIXME: (@xrouth) For now, only compute variables that have one assignment, (look into this:) possibly treat multiple assignment as separate induction variables.
+
+ let mut induction_variables: Vec<NodeID> = vec![];
+
+ /* 1) For each PHI controlled by the loop, check how it is modified */
+
+ // It's initializer needs to be loop invariant, it's update needs to be loop variant.
+ for phi_idx in loop_vars {
+ let phi_node = &function.nodes[phi_idx.idx()];
+ let (control, data) = phi_node.try_phi().unwrap();
+
+ //
+ let initializer_idx = data.iter().position(|&node_id| node_id == loop_preheader).unwrap();
+
+ // Check variance,
+ if loop_variance.map[initializer_idx] != LoopVariance::Invariant {
+ break;
+ }
+
+ // Check all data inputs to this phi, that aren't the initializer (i.e the value the comes from control outside of the loop)
+ // For now we expect only one initializer.
+ // data.iter().filter(
+ // |node_id| NodeID::new(initializer_idx) != **node_id
+ // ).map(
+ // // Later, we are interested in PHIs that contain cycles only containing itself.
+ // // For now, we are intetersted in PHIs that are linear / based on a simple expression, i.e only
+
+ // // Pattern match
+ // // Expressions we are looking for: %PHI = %PHI + %invariant expression.
+ // todo!()
+ // )
+ // ;
+
+ // if loop_variance.map[]
+
+ induction_variables.push(phi_idx);
+ };
+
+ // Check it's initializer ()
+
+
+
+ /* 2) Find */
+
+}
\ No newline at end of file
diff --git a/hercules_opt/src/lib.rs b/hercules_opt/src/lib.rs
index dbd66012..862356fe 100644
--- a/hercules_opt/src/lib.rs
+++ b/hercules_opt/src/lib.rs
@@ -12,6 +12,8 @@ pub mod pass;
pub mod phi_elim;
pub mod pred;
pub mod sroa;
+pub mod scev;
+pub mod ivar;
pub use crate::ccp::*;
pub use crate::dce::*;
@@ -25,3 +27,6 @@ pub use crate::pass::*;
pub use crate::phi_elim::*;
pub use crate::pred::*;
pub use crate::sroa::*;
+pub use crate::scev::*;
+pub use crate::ivar::*;
+
diff --git a/hercules_test/hercules_tests/tests/loop_tests.rs b/hercules_test/hercules_tests/tests/loop_tests.rs
new file mode 100644
index 00000000..d01f24ab
--- /dev/null
+++ b/hercules_test/hercules_tests/tests/loop_tests.rs
@@ -0,0 +1,40 @@
+use std::env;
+
+use hercules_interpreter::*;
+use hercules_opt::pass::Pass;
+
+extern crate rand;
+use rand::Rng;
+
+#[test]
+fn loop0() {
+ let module = parse_file("../test_inputs/fork_optimization/phi_loop0.hir");
+ let dyn_consts = [2];
+ let result_1 = interp_module!(module, dyn_consts, m1.clone(), m2.clone());
+
+ println!("result: {:?}", reuslt_1);
+
+ let mut pm = hercules_opt::pass::PassManager::new(module.clone());
+
+ let passes = vec![
+ Pass::Verify,
+ // Pass::CCP,
+ // Pass::DCE,
+ // Pass::GVN,
+ // Pass::DCE,
+ // Pass::Forkify,
+ // Pass::DCE,
+ // Pass::Predication,
+ // Pass::DCE,
+ ];
+
+ for pass in passes {
+ pm.add_pass(pass);
+ }
+ pm.run_passes();
+
+ // let module = pm.get_module();
+ // let result_2 = interp_module!(module, dyn_consts, m1, m2);
+ // assert_eq!(result_1, result_2)
+}
+
diff --git a/hercules_test/test_inputs/fork_optimization/fork_fission.hir b/hercules_test/test_inputs/fork_optimization/fork_fission.hir
new file mode 100644
index 00000000..e69de29b
diff --git a/hercules_test/test_inputs/fork_optimization/fork_fusion.hir b/hercules_test/test_inputs/fork_optimization/fork_fusion.hir
new file mode 100644
index 00000000..e69de29b
diff --git a/hercules_test/test_inputs/fork_optimization/fork_interchange.hir b/hercules_test/test_inputs/fork_optimization/fork_interchange.hir
new file mode 100644
index 00000000..e69de29b
diff --git a/hercules_test/test_inputs/fork_optimization/phi_loop0.hir b/hercules_test/test_inputs/fork_optimization/phi_loop0.hir
new file mode 100644
index 00000000..e3a73ec7
--- /dev/null
+++ b/hercules_test/test_inputs/fork_optimization/phi_loop0.hir
@@ -0,0 +1,12 @@
+fn loop<1>() -> u64
+ zero_idx = constant(u64, 0)
+ one_idx = constant(u64, 1)
+ bound = dynamic_constant(#0)
+ loop = region(start, if_true)
+ idx = phi(loop, zero_idx, idx_inc)
+ idx_inc = add(idx, one_idx)
+ in_bounds = lt(idx, bound)
+ if = if(loop, in_bounds)
+ if_false = projection(if, 0)
+ if_true = projection(if, 1)
+ r = return(if_false, idx)
\ No newline at end of file
diff --git a/hercules_test/test_inputs/fork_optimization/phi_loop1.hir b/hercules_test/test_inputs/fork_optimization/phi_loop1.hir
new file mode 100644
index 00000000..147cef62
--- /dev/null
+++ b/hercules_test/test_inputs/fork_optimization/phi_loop1.hir
@@ -0,0 +1,16 @@
+fn loop<1>() -> i32
+ zero_idx = constant(u64, 0)
+ one_idx = constant(u64, 1)
+ zero_var = constant(i32, 0)
+ one_var = constant(i32, 1)
+ bound = dynamic_constant(#0)
+ loop = region(start, if_true)
+ var = phi(loop, zero_var, var_inc)
+ var_inc = add(var, one_var)
+ idx = phi(loop, zero_idx, idx_inc)
+ idx_inc = add(idx, one_idx)
+ in_bounds = lt(idx, bound)
+ if = if(loop, in_bounds)
+ if_false = projection(if, 0)
+ if_true = projection(if, 1)
+ r = return(if_false, var_inc)
\ No newline at end of file
diff --git a/hercules_test/test_inputs/fork_optimization/phi_loop2.hir b/hercules_test/test_inputs/fork_optimization/phi_loop2.hir
new file mode 100644
index 00000000..78cd129c
--- /dev/null
+++ b/hercules_test/test_inputs/fork_optimization/phi_loop2.hir
@@ -0,0 +1,15 @@
+fn loop<1>() -> u64
+ zero_idx = constant(u64, 0)
+ one_idx = constant(u64, 1)
+ zero_inc = constant(u64, 0)
+ bound = dynamic_constant(#0)
+ loop = region(start, if_true)
+ idx = phi(loop, zero_idx, idx_inc)
+ idx_inc = add(idx, one_idx)
+ red = phi(loop, zero_inc, red_add)
+ red_add = add(red, idx)
+ in_bounds = lt(idx, bound)
+ if = if(loop, in_bounds)
+ if_false = projection(if, 0)
+ if_true = projection(if, 1)
+ r = return(if_false, red_add)
\ No newline at end of file
diff --git a/hercules_test/test_inputs/fork_optimization/phi_loop3.hir b/hercules_test/test_inputs/fork_optimization/phi_loop3.hir
new file mode 100644
index 00000000..4a9ba015
--- /dev/null
+++ b/hercules_test/test_inputs/fork_optimization/phi_loop3.hir
@@ -0,0 +1,16 @@
+fn sum<1>(a: array(i32, #0)) -> i32
+ zero_idx = constant(u64, 0)
+ one_idx = constant(u64, 1)
+ zero_inc = constant(i32, 0)
+ bound = dynamic_constant(#0)
+ loop = region(start, if_true)
+ idx = phi(loop, zero_idx, idx_inc)
+ idx_inc = add(idx, one_idx)
+ red = phi(loop, zero_inc, red_add)
+ read = read(a, position(idx))
+ red_add = add(red, read)
+ in_bounds = lt(idx_inc, bound)
+ if = if(loop, in_bounds)
+ if_false = projection(if, 0)
+ if_true = projection(if, 1)
+ r = return(if_false, red_add)
\ No newline at end of file
diff --git a/hercules_test/test_inputs/fork_optimization/tiling.hir b/hercules_test/test_inputs/fork_optimization/tiling.hir
new file mode 100644
index 00000000..e69de29b
diff --git a/hercules_test/test_inputs/fork_optimization/untiling.hir b/hercules_test/test_inputs/fork_optimization/untiling.hir
new file mode 100644
index 00000000..e69de29b
--
GitLab
From e357ca381e29788499c3cb9ab4d379c5ae576c50 Mon Sep 17 00:00:00 2001
From: Xavier Routh <xrouth2@illinois.edu>
Date: Wed, 11 Dec 2024 12:23:56 -0600
Subject: [PATCH 02/68] DC math + disabled calls, disabled multi-dimensional
fork
---
Cargo.lock | 48 ++++++++++++++++
Cargo.toml | 4 +-
.../hercules_interpreter/src/interpreter.rs | 57 ++++++++-----------
hercules_test/hercules_interpreter/src/lib.rs | 1 +
.../hercules_interpreter/src/value.rs | 2 +-
5 files changed, 75 insertions(+), 37 deletions(-)
diff --git a/Cargo.lock b/Cargo.lock
index 23c5f4c7..e4f7a431 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -369,6 +369,26 @@ dependencies = [
"powerfmt",
]
+[[package]]
+name = "derive_more"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4a9b99b9cbbe49445b21764dc0625032a89b145a2642e67603e1c936f5458d05"
+dependencies = [
+ "derive_more-impl",
+]
+
+[[package]]
+name = "derive_more-impl"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb7330aeadfbe296029522e6c40f315320aba36fc43a5b3632f3795348f3bd22"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.79",
+]
+
[[package]]
name = "dot"
version = "0.1.0"
@@ -607,6 +627,20 @@ dependencies = [
"ron",
]
+[[package]]
+name = "hercules_interpreter"
+version = "0.1.0"
+dependencies = [
+ "bitvec",
+ "clap",
+ "derive_more",
+ "hercules_ir",
+ "hercules_opt",
+ "itertools",
+ "ordered-float",
+ "rand",
+]
+
[[package]]
name = "hercules_ir"
version = "0.1.0"
@@ -656,6 +690,20 @@ dependencies = [
"uuid",
]
+[[package]]
+name = "hercules_tests"
+version = "0.1.0"
+dependencies = [
+ "bitvec",
+ "clap",
+ "hercules_interpreter",
+ "hercules_ir",
+ "hercules_opt",
+ "itertools",
+ "ordered-float",
+ "rand",
+]
+
[[package]]
name = "hermit-abi"
version = "0.4.0"
diff --git a/Cargo.toml b/Cargo.toml
index bffe0364..0965682b 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -9,8 +9,8 @@ members = [
"hercules_tools/hercules_driver",
- #"hercules_test/hercules_interpreter",
- #"hercules_test/hercules_tests",
+ "hercules_test/hercules_interpreter",
+ "hercules_test/hercules_tests",
"hercules_samples/dot",
"hercules_samples/matmul",
diff --git a/hercules_test/hercules_interpreter/src/interpreter.rs b/hercules_test/hercules_interpreter/src/interpreter.rs
index a166427f..5ee723e7 100644
--- a/hercules_test/hercules_interpreter/src/interpreter.rs
+++ b/hercules_test/hercules_interpreter/src/interpreter.rs
@@ -62,10 +62,17 @@ impl <'a> FunctionContext<'a> {
}
}
-pub fn dyn_const_value(dc: &DynamicConstant, dyn_const_params: &[usize]) -> usize {
+// TODO: (@xrouth) I feel like this funcitonality should be provided by the manager that holds and allocates dynamic constants & IDs.
+pub fn dyn_const_value(dc: &DynamicConstantID, dyn_const_values: &[DynamicConstant], dyn_const_params: &[usize]) -> usize {
+ let dc = &dyn_const_values[dc.idx()];
match dc {
DynamicConstant::Constant(v) => *v,
DynamicConstant::Parameter(v) => dyn_const_params[*v],
+ DynamicConstant::Add(a, b) => dyn_const_value(a, dyn_const_values, dyn_const_params) + dyn_const_value(b, dyn_const_values, dyn_const_params),
+ DynamicConstant::Sub(a, b) => dyn_const_value(a, dyn_const_values, dyn_const_params) - dyn_const_value(b, dyn_const_values, dyn_const_params),
+ DynamicConstant::Mul(a, b) => dyn_const_value(a, dyn_const_values, dyn_const_params) * dyn_const_value(b, dyn_const_values, dyn_const_params),
+ DynamicConstant::Div(a, b) => dyn_const_value(a, dyn_const_values, dyn_const_params) / dyn_const_value(b, dyn_const_values, dyn_const_params),
+ DynamicConstant::Rem(a, b) => dyn_const_value(a, dyn_const_values, dyn_const_params) % dyn_const_value(b, dyn_const_values, dyn_const_params),
}
}
// Each control token stores a current position, and also a mapping of fork nodes -> thread idx.
@@ -260,8 +267,6 @@ impl<'a> FunctionExecutionState<'a> {
let thread_values = self.get_thread_factors(token, *control);
let init = self.handle_data(&token, *init);
- // Q (@xrouth): It is UB to have the initializer depend on things within the fork-join section? do we check for that?
- // A: Should be done in verify (TODO).
self.reduce_values
.entry((thread_values.clone(), reduce))
@@ -276,15 +281,7 @@ impl<'a> FunctionExecutionState<'a> {
let thread_values = self.get_thread_factors(token, *control);
- // If empty set to default (figure out how to not repeat this check)
- // TODO: (Can we do it upon entry to the fork node?) (YES!)
-
let data = self.handle_data(&token, *reduct);
- /*
- println!(
- "reduction write: {:?}, {:?}, {:?}",
- thread_values, reduce, data
- ); */
self.reduce_values.insert((thread_values, reduce), data);
}
@@ -299,7 +296,7 @@ impl<'a> FunctionExecutionState<'a> {
.get(&node)
.expect("PANIC: Phi value not latched."))
.clone(),
- Node::ThreadID { control } => {
+ Node::ThreadID { control, dimension } => {
// `control` is the fork that drives this node.
let nesting_level = self
.get_fork_join_nest()
@@ -342,13 +339,10 @@ impl<'a> FunctionExecutionState<'a> {
)
}
Node::DynamicConstant { id } => {
- let dyn_con = &self.module.dynamic_constants[id.idx()];
- let v = match dyn_con {
- DynamicConstant::Constant(v) => v,
- DynamicConstant::Parameter(v) => &self.dynamic_constant_params[*v],
- };
+ let v = dyn_const_value(id, &self.module.dynamic_constants, &self.dynamic_constant_params);
+
// TODO: Figure out what type / semantics are of thread ID and dynamic const.
- InterpreterVal::DynamicConstant((*v).into())
+ InterpreterVal::DynamicConstant(v.into())
}
Node::Unary { input, op } => {
let val = self.handle_data(token, *input);
@@ -384,8 +378,9 @@ impl<'a> FunctionExecutionState<'a> {
function,
dynamic_constants,
args,
+ control,
} => {
-
+ todo!("call currently dissabled lol");
let args = args.into_iter()
.map(|arg_node| self.handle_data(token, *arg_node))
.collect();
@@ -393,12 +388,7 @@ impl<'a> FunctionExecutionState<'a> {
let dynamic_constant_params = dynamic_constants.into_iter()
.map(|id| {
- let dyn_con = &self.module.dynamic_constants[id.idx()];
- let v = match dyn_con {
- DynamicConstant::Constant(v) => *v,
- DynamicConstant::Parameter(v) => self.dynamic_constant_params[*v],
- };
- v
+ dyn_const_value(id, &self.module.dynamic_constants, &self.dynamic_constant_params)
}).collect_vec();
let mut state = FunctionExecutionState::new(
@@ -456,7 +446,7 @@ impl<'a> FunctionExecutionState<'a> {
.try_extents()
.expect("PANIC: wrong type for array")
.into_iter()
- .map(|extent| dyn_const_value(&self.module.dynamic_constants[extent.idx()], &self.dynamic_constant_params))
+ .map(|extent| dyn_const_value(extent, &self.module.dynamic_constants, &self.dynamic_constant_params))
.collect();
let idx = InterpreterVal::array_idx(&extents, &array_indices);
//println!("idx: {:?}", idx);
@@ -496,7 +486,7 @@ impl<'a> FunctionExecutionState<'a> {
.try_extents()
.expect("PANIC: wrong type for array")
.into_iter()
- .map(|extent| dyn_const_value(&self.module.dynamic_constants[extent.idx()], &self.dynamic_constant_params))
+ .map(|extent| dyn_const_value(extent, &self.module.dynamic_constants, &self.dynamic_constant_params))
.collect();
vals[InterpreterVal::array_idx(&extents, &array_indices)].clone()
} else {
@@ -589,14 +579,13 @@ impl<'a> FunctionExecutionState<'a> {
}
Node::Match { control: _, sum: _ } => todo!(),
- Node::Fork { control: _, factor } => {
+ Node::Fork { control: _, factors } => {
let fork = ctrl_token.curr;
- let dyn_con = &self.module.dynamic_constants[factor.idx()];
-
- let thread_factor = match dyn_con {
- DynamicConstant::Constant(v) => v,
- DynamicConstant::Parameter(v) => &self.dynamic_constant_params[*v],
- }.clone();
+ if factors.len() > 1 {
+ panic!("multi-dimensional forks unimplemented")
+ }
+ let factor = factors[0];
+ let thread_factor = dyn_const_value(&factor, &self.module.dynamic_constants, &self.dynamic_constant_params).clone();
// Update control token
let next = self.get_control_subgraph().succs(ctrl_token.curr).nth(0).unwrap();
diff --git a/hercules_test/hercules_interpreter/src/lib.rs b/hercules_test/hercules_interpreter/src/lib.rs
index 89fae51a..b67b2ca4 100644
--- a/hercules_test/hercules_interpreter/src/lib.rs
+++ b/hercules_test/hercules_interpreter/src/lib.rs
@@ -5,6 +5,7 @@ use std::fs::File;
use hercules_ir::Module;
use hercules_ir::TypeID;
+use hercules_ir::ID;
pub use crate::interpreter::*;
pub use crate::value::*;
diff --git a/hercules_test/hercules_interpreter/src/value.rs b/hercules_test/hercules_interpreter/src/value.rs
index d236145c..39158649 100644
--- a/hercules_test/hercules_interpreter/src/value.rs
+++ b/hercules_test/hercules_interpreter/src/value.rs
@@ -154,7 +154,7 @@ impl<'a> InterpreterVal {
.expect("PANIC: wrong type for array")
.into_iter()
.map(|extent| {
- dyn_const_value(&dynamic_constants[extent.idx()], &dynamic_constant_params)
+ dyn_const_value(extent, &dynamic_constants, &dynamic_constant_params)
})
.collect();
--
GitLab
From 615347e78eef165bec929f318b46d7678f9589e5 Mon Sep 17 00:00:00 2001
From: Xavier Routh <xrouth2@illinois.edu>
Date: Wed, 11 Dec 2024 12:34:24 -0600
Subject: [PATCH 03/68] matmul int failing
---
hercules_test/hercules_tests/tests/opt_tests.rs | 1 +
hercules_test/test_inputs/matmul_int.hir | 6 +++---
2 files changed, 4 insertions(+), 3 deletions(-)
diff --git a/hercules_test/hercules_tests/tests/opt_tests.rs b/hercules_test/hercules_tests/tests/opt_tests.rs
index c14d4db5..256ab2ee 100644
--- a/hercules_test/hercules_tests/tests/opt_tests.rs
+++ b/hercules_test/hercules_tests/tests/opt_tests.rs
@@ -2,6 +2,7 @@ use std::env;
use hercules_interpreter::*;
use hercules_opt::pass::Pass;
+use hercules_ir::ID;
extern crate rand;
use rand::Rng;
diff --git a/hercules_test/test_inputs/matmul_int.hir b/hercules_test/test_inputs/matmul_int.hir
index 1e496bab..34d8169b 100644
--- a/hercules_test/test_inputs/matmul_int.hir
+++ b/hercules_test/test_inputs/matmul_int.hir
@@ -1,11 +1,11 @@
fn matmul<3>(a: array(i32, #0, #1), b: array(i32, #1, #2)) -> array(i32, #0, #2)
c = constant(array(i32, #0, #2), [])
i_ctrl = fork(start, #0)
- i_idx = thread_id(i_ctrl)
+ i_idx = thread_id(i_ctrl, 0)
j_ctrl = fork(i_ctrl, #2)
- j_idx = thread_id(j_ctrl)
+ j_idx = thread_id(j_ctrl, 0)
k_ctrl = fork(j_ctrl, #1)
- k_idx = thread_id(k_ctrl)
+ k_idx = thread_id(k_ctrl, 0)
k_join_ctrl = join(k_ctrl)
j_join_ctrl = join(k_join_ctrl)
i_join_ctrl = join(j_join_ctrl)
--
GitLab
From 5a55b8ee70833e12abf12bfd069216b7a3cf5f70 Mon Sep 17 00:00:00 2001
From: Xavier Routh <xrouth2@illinois.edu>
Date: Wed, 11 Dec 2024 13:18:29 -0600
Subject: [PATCH 04/68] merge conflict
---
hercules_opt/src/lib.rs | 3 ---
1 file changed, 3 deletions(-)
diff --git a/hercules_opt/src/lib.rs b/hercules_opt/src/lib.rs
index 7ffbdd93..0c313280 100644
--- a/hercules_opt/src/lib.rs
+++ b/hercules_opt/src/lib.rs
@@ -30,10 +30,7 @@ pub use crate::pass::*;
pub use crate::phi_elim::*;
pub use crate::pred::*;
pub use crate::sroa::*;
-<<<<<<< HEAD
pub use crate::scev::*;
pub use crate::ivar::*;
-=======
pub use crate::utils::*;
->>>>>>> interpreter-fix
--
GitLab
From 42701de84db0081762016645bb869af47647b670 Mon Sep 17 00:00:00 2001
From: Xavier Routh <xrouth2@illinois.edu>
Date: Wed, 11 Dec 2024 13:27:12 -0600
Subject: [PATCH 05/68] simple tests
---
.../hercules_tests/tests/loop_tests.rs | 42 ++++++++++++++-----
.../fork_optimization/phi_loop0.hir | 2 +-
.../fork_optimization/phi_loop1.hir | 2 +-
3 files changed, 33 insertions(+), 13 deletions(-)
diff --git a/hercules_test/hercules_tests/tests/loop_tests.rs b/hercules_test/hercules_tests/tests/loop_tests.rs
index d01f24ab..030e9b16 100644
--- a/hercules_test/hercules_tests/tests/loop_tests.rs
+++ b/hercules_test/hercules_tests/tests/loop_tests.rs
@@ -2,6 +2,8 @@ use std::env;
use hercules_interpreter::*;
use hercules_opt::pass::Pass;
+use hercules_ir::ID;
+
extern crate rand;
use rand::Rng;
@@ -9,23 +11,41 @@ use rand::Rng;
#[test]
fn loop0() {
let module = parse_file("../test_inputs/fork_optimization/phi_loop0.hir");
- let dyn_consts = [2];
- let result_1 = interp_module!(module, dyn_consts, m1.clone(), m2.clone());
+ let dyn_consts = [10];
+ let params = 2; // TODO: (@xrouth) fix macro to take no params as an option.
+ let result_1 = interp_module!(module, dyn_consts, 2);
+
+ println!("result: {:?}", result_1);
+
+ let mut pm = hercules_opt::pass::PassManager::new(module.clone());
+
+ let passes = vec![
+ Pass::Verify,
+ ];
+
+ for pass in passes {
+ pm.add_pass(pass);
+ }
+ pm.run_passes();
+
+ // let module = pm.get_module();
+ // let result_2 = interp_module!(module, dyn_consts, m1, m2);
+ // assert_eq!(result_1, result_2)
+}
+
+#[test]
+fn loop1() {
+ let module = parse_file("../test_inputs/fork_optimization/phi_loop1.hir");
+ let dyn_consts = [10];
+ let params = 2; // TODO: (@xrouth) fix macro to take no params as an option.
+ let result_1 = interp_module!(module, dyn_consts, 2);
- println!("result: {:?}", reuslt_1);
+ println!("result: {:?}", result_1);
let mut pm = hercules_opt::pass::PassManager::new(module.clone());
let passes = vec![
Pass::Verify,
- // Pass::CCP,
- // Pass::DCE,
- // Pass::GVN,
- // Pass::DCE,
- // Pass::Forkify,
- // Pass::DCE,
- // Pass::Predication,
- // Pass::DCE,
];
for pass in passes {
diff --git a/hercules_test/test_inputs/fork_optimization/phi_loop0.hir b/hercules_test/test_inputs/fork_optimization/phi_loop0.hir
index e3a73ec7..c25b9a2c 100644
--- a/hercules_test/test_inputs/fork_optimization/phi_loop0.hir
+++ b/hercules_test/test_inputs/fork_optimization/phi_loop0.hir
@@ -1,4 +1,4 @@
-fn loop<1>() -> u64
+fn loop<1>(a: u32) -> u64
zero_idx = constant(u64, 0)
one_idx = constant(u64, 1)
bound = dynamic_constant(#0)
diff --git a/hercules_test/test_inputs/fork_optimization/phi_loop1.hir b/hercules_test/test_inputs/fork_optimization/phi_loop1.hir
index 147cef62..e69ecc3d 100644
--- a/hercules_test/test_inputs/fork_optimization/phi_loop1.hir
+++ b/hercules_test/test_inputs/fork_optimization/phi_loop1.hir
@@ -1,4 +1,4 @@
-fn loop<1>() -> i32
+fn loop<1>(a: u32) -> i32
zero_idx = constant(u64, 0)
one_idx = constant(u64, 1)
zero_var = constant(i32, 0)
--
GitLab
From 2833ce667e88e3a690c4d962271b37d878cd2cc3 Mon Sep 17 00:00:00 2001
From: Xavier Routh <xrouth2@illinois.edu>
Date: Thu, 12 Dec 2024 15:44:45 -0600
Subject: [PATCH 06/68] forkify on singular minimal example
---
hercules_opt/src/editor.rs | 7 +
hercules_opt/src/forkify.rs | 322 +++++++++++++++++-
hercules_opt/src/ivar.rs | 272 +++++++++++++--
hercules_opt/src/pass.rs | 35 +-
hercules_opt/src/sroa.rs | 2 +-
.../hercules_tests/tests/loop_tests.rs | 18 +-
6 files changed, 611 insertions(+), 45 deletions(-)
diff --git a/hercules_opt/src/editor.rs b/hercules_opt/src/editor.rs
index 2d342a88..46606d62 100644
--- a/hercules_opt/src/editor.rs
+++ b/hercules_opt/src/editor.rs
@@ -222,6 +222,13 @@ impl<'a: 'b, 'b> FunctionEditor<'a> {
self.mut_def_use[id.idx()].iter().map(|x| *x)
}
+ pub fn get_uses(&self, id: NodeID) -> impl ExactSizeIterator<Item = NodeID> + '_ {
+ get_uses(&self.function.nodes[id.idx()])
+ .as_ref().into_iter().map(|x| *x)
+ .collect_vec() // @(xrouth): wtf???
+ .into_iter()
+ }
+
pub fn get_type(&self, id: TypeID) -> Ref<'_, Type> {
Ref::map(self.types.borrow(), |types| &types[id.idx()])
}
diff --git a/hercules_opt/src/forkify.rs b/hercules_opt/src/forkify.rs
index 6f041591..c4740289 100644
--- a/hercules_opt/src/forkify.rs
+++ b/hercules_opt/src/forkify.rs
@@ -2,8 +2,15 @@ extern crate hercules_ir;
use std::iter::zip;
+use self::hercules_ir::Subgraph;
+
+use self::hercules_ir::control_subgraph;
+
+use crate::check_reductionable_phis;
use crate::compute_induction_vars;
+use crate::compute_loop_bounds;
use crate::compute_loop_variance;
+use crate::FunctionEditor;
use self::hercules_ir::def_use::*;
use self::hercules_ir::ir::*;
@@ -14,6 +21,300 @@ use self::hercules_ir::loops::*;
* into fork-joins.
*/
pub fn forkify(
+ editor: &mut FunctionEditor,
+ control_subgraph: &Subgraph,
+ loops: &LoopTree,
+) -> () {
+
+ // TODO: Do we want to run analysizes before, I think it's fine to put them in the pass itself.
+ // i.e no real split between analysis and transformation.
+
+ let function = editor.func();
+ println!("num loops: {:?}", loops.loops().len());
+
+ // TODO: (@xrouth) handle multiple loops.
+ // Probably want to forkify bottom up, but also need to look at potential 2d forkifies.
+ // Maybe upon forkification: BLARGH, Nd forkys are complicated.
+ let (header, (body, parent)) = loops.loops().nth(0).expect("No loops found in function.");
+
+ let loop_nodes = (body.clone(), header.clone());
+
+ // Compute loop variance
+ let loop_variance = compute_loop_variance(function, &loop_nodes);
+
+ // Compute induction vars
+ let basic_ivs = compute_induction_vars(function, *parent, &loop_nodes, &loop_variance);
+
+ // Compute loop bounds
+ let loop_bounds = compute_loop_bounds(function, &control_subgraph, *parent, &loop_nodes, &basic_ivs, &loop_variance);
+
+ println!("loop_bounds: {:?}", loop_bounds);
+
+ let (iv, bound, loop_condition) = match loop_bounds {
+ Some(v) => v,
+ None => return,
+ };
+
+ // Check reductionable phis, only PHIs depending on the loop are considered,
+ // this is how we avoid reductions that depend on control flow.
+ let candidate_phis: Vec<_> = editor
+ .get_users(*header)
+ .filter(|id|function.nodes[id.idx()].is_phi())
+ .collect();
+
+ let reductionable_phis = check_reductionable_phis(function, &editor, &control_subgraph, *parent, &loop_nodes,
+ &basic_ivs, &loop_variance, &candidate_phis);
+
+
+ // Check for a constant used as loop bound.
+ let bound_dc_id =
+ if let Some(bound_dc_id) = function.nodes[bound.idx()].try_dynamic_constant() {
+ bound_dc_id
+ } else if let Some(bound_c_id) = function.nodes[bound.idx()].try_constant() {
+ // Create new dynamic constant that reflects this constant.
+ let dc = match *editor.get_constant(bound_c_id) {
+ Constant::Integer8(x) => DynamicConstant::Constant(x as _),
+ Constant::Integer16(x) => DynamicConstant::Constant(x as _),
+ Constant::Integer32(x) => DynamicConstant::Constant(x as _),
+ Constant::Integer64(x) => DynamicConstant::Constant(x as _),
+ Constant::UnsignedInteger8(x) => DynamicConstant::Constant(x as _),
+ Constant::UnsignedInteger16(x) => DynamicConstant::Constant(x as _),
+ Constant::UnsignedInteger32(x) => DynamicConstant::Constant(x as _),
+ Constant::UnsignedInteger64(x) => DynamicConstant::Constant(x as _),
+ _ => return,
+ };
+
+ // TODO: ABSOLUTELY NO WAY THIS IS INTENDED USAGE
+ let mut b = DynamicConstantID::new(0);
+ editor.edit(
+ |mut edit| {
+ b = edit.add_dynamic_constant(dc);
+ Ok(edit)
+ }
+ );
+ // Return the ID of the dynamic constant that is generated from the constant
+ // or dynamic constant that is the existing loop bound
+ b
+ } else {
+ return;
+ };
+
+ // START EDITING
+
+ // Induction variables are *also* reducible PHIs. If the PHI / IV has a dependency outside of the loop,
+ // then we can't just replace it with the ThreadID.
+ // Uses of the IV become:
+ // 1) Inside the loop: Uses of the ThreadID
+ // 2) Outside the loop: Uses of the reduction node.
+ // Regardless, all reductionable PHIs get killed.
+
+ // We will always create both, and then just run DCE?!
+ // How do we define 'inside loop' for data nodes.
+
+ // Confirm that *all* PHIs are reductionable.
+ // Q: What other things break parallelism?
+
+ // What we do is:
+ // 1) Find a (the?) basic induction variable, create a ThreadID + Fork + Join over it.
+ // 2) Turn reductionable PHIs into reduces (including the redcutionable PHI)
+ // - a) If the PHI is the IV:
+ // Uses of the IV become:
+ // 1) Inside the loop: Uses of the ThreadID
+ // 2) Outside the loop: Uses of the reduction node.
+ // - b) if the PHI is not the IV:
+ // Just make it a reduce or something.
+
+ // Get the control portions of the loop that need to be grafted;
+
+ let function = editor.func();
+
+ // Get the control portions of the loop that need to be grafted.
+ let loop_pred = editor.get_uses(*header) // Is this the same as parent? NO!
+ .filter(|id| !body[id.idx()])
+ .next()
+ .unwrap();
+ let loop_true_read = editor.get_uses(*header)
+ .filter(|id| body[id.idx()])
+ .next()
+ .unwrap();
+ let loop_end = function.nodes[loop_true_read.idx()]
+ .try_projection(1)
+ .unwrap();
+ let loop_false_read =
+ editor.get_users(loop_end)
+ .filter_map(|id| {
+ if function.nodes[id.idx()].try_projection(0).is_some() {
+ Some(id)
+ } else {
+ None
+ }
+ })
+ .next()
+ .unwrap();
+
+ let loop_end_uses: Vec<_> = editor.get_uses(loop_end).collect();
+ let loop_end = function.nodes[loop_end.idx()].clone();
+
+ // Create fork and join nodes:
+ let mut join_id = NodeID::new(0);
+ let mut fork_id = NodeID::new(0);
+
+ editor.edit(
+ |mut edit| {
+ let fork = Node::Fork { control: loop_pred, factors: Box::new([bound_dc_id])};
+ fork_id = edit.add_node(fork);
+
+ // If there is no control between loop_end and header, attach join to header
+ // If there is control, attach join to the control.
+ let join = Node::Join {
+ control: if *header == loop_end_uses[0] {
+ fork_id
+ } else {
+ loop_end.try_if().unwrap().0
+ },
+ };
+ join_id = edit.add_node(join);
+
+ Ok(edit)
+ }
+ );
+
+ let function = editor.func();
+ let induction_variable = basic_ivs[0]; // TODO: Choose this better.
+
+ let update = *zip(
+ editor.get_uses(*header),
+ function.nodes[induction_variable.node.idx()]
+ .try_phi()
+ .unwrap()
+ .1
+ .iter(),
+ )
+ .filter(|(c, _)| *c == loop_true_read)
+ .next()
+ .unwrap()
+ .1;
+
+ // Create ThreadID
+ editor.edit(
+ |mut edit| {
+ let thread_id = Node::ThreadID {
+ control: fork_id,
+ dimension: 0,
+ };
+ let thread_id_id = edit.add_node(thread_id);
+
+
+
+ let iv_reduce = Node::Reduce {
+ control: join_id,
+ init: induction_variable.initializer,
+ reduct: update,
+ };
+
+ let iv_reduce_id = edit.add_node(iv_reduce);
+ // let users = edit.get_users(induction_variable.node);
+
+ println!("replacing all uses of: {:?} with {:?}", induction_variable.node, iv_reduce_id);
+ edit = edit.replace_all_uses(induction_variable.node, iv_reduce_id)?;
+ edit.delete_node(induction_variable.node)
+
+ // for user in users {
+ // // How to check if user is 'inside' or 'outside' loop?
+ // // FIXME: For now, just replace everything with the reduce. Oh Well!
+
+ // }
+ }
+ );
+
+ // - a) If the PHI is the IV:
+ // Uses of the IV become:
+ // 1) Inside the loop: Uses of the ThreadID
+ // 2) Outside the loop: Uses of the reduction node.
+
+ for reduction_phi in reductionable_phis {
+ // Special case this, we handle the IV differently.
+ if reduction_phi == induction_variable.node {
+ continue;
+ }
+
+ let function = editor.func();
+
+ let init = *zip(
+ editor.get_uses(*header),
+ function.nodes[reduction_phi.idx()]
+ .try_phi()
+ .unwrap()
+ .1
+ .iter(),
+ )
+ .filter(|(c, _)| *c == loop_pred)
+ .next()
+ .unwrap()
+ .1;
+
+ // Loop back edge input to phi is the reduction update expression.
+ let update = *zip(
+ editor.get_uses(*header),
+ function.nodes[reduction_phi.idx()]
+ .try_phi()
+ .unwrap()
+ .1
+ .iter(),
+ )
+ .filter(|(c, _)| *c == loop_true_read)
+ .next()
+ .unwrap()
+ .1;
+
+ editor.edit(
+ |mut edit| {
+ let reduce = Node::Reduce {
+ control: join_id,
+ init,
+ reduct: update,
+ };
+ let reduce_id = edit.add_node(reduce);
+
+ edit.replace_all_uses(reduction_phi, reduce_id)
+ }
+ );
+ }
+
+ // Replace all uses of the loop ehader with the fork
+ editor.edit(
+ |mut edit| {
+ edit.replace_all_uses(*header, fork_id)
+ }
+ );
+
+ editor.edit(
+ |mut edit| {
+ edit.replace_all_uses(loop_false_read, join_id)
+ }
+ );
+
+ // TODO: (@xrouth) Wtf is this?
+ editor.edit(
+ |mut edit| {
+ edit = edit.delete_node(loop_false_read)?;
+ edit = edit.delete_node(loop_false_read)?;
+ edit = edit.delete_node(loop_true_read)?;
+ edit = edit.delete_node(loop_condition)?; // Delet ethe if.
+ edit = edit.delete_node(*header)?;
+ Ok(edit)
+ }
+ );
+
+ return;
+}
+
+
+/*
+ * Top level function to convert natural loops with simple induction variables
+ * into fork-joins.
+ */
+pub fn forkify_old(
function: &mut Function,
constants: &Vec<Constant>,
dynamic_constants: &mut Vec<DynamicConstant>,
@@ -21,19 +322,32 @@ pub fn forkify(
loops: &LoopTree,
) {
+ todo!();
+
+ // TODO: (@xrouth): Should this be created by pass manager?
+ let control_subgraph = control_subgraph(function, def_use);
// let mut scev_context = SCEVContext::new(function, loops);
// scev_context.gather_evolutions();
println!("num loops: {:?}", loops.loops().len());
- println!("funciton len: {:?}", function.nodes.len());
+ println!("function len: {:?}", function.nodes.len());
+ // TODO: (@xrouth) handle multiple loops.
let (header, (body, parent)) = loops.loops().nth(0).expect("No loops found in function.");
let loop_nodes = (body.clone(), header.clone());
- let variance = compute_loop_variance(function, &loop_nodes);
- compute_induction_vars(function, *parent, &loop_nodes, variance);
- // println!("variance: {:?}", variance);
+
+ // Compute loop variance
+ let loop_variance = compute_loop_variance(function, &loop_nodes);
+
+ // Compute induction vars
+ let basic_ivs = compute_induction_vars(function, *parent, &loop_nodes, &loop_variance);
+
+ // Compute loop bounds
+ let loop_bounds = compute_loop_bounds(function, &control_subgraph, *parent, &loop_nodes, &basic_ivs, &loop_variance);
+
+ println!("loop_bounds: {:?}", loop_bounds);
return;
// Ignore loops that are already fork-joins. TODO: re-calculate def_use per
diff --git a/hercules_opt/src/ivar.rs b/hercules_opt/src/ivar.rs
index d9a516b1..3f0ae63c 100644
--- a/hercules_opt/src/ivar.rs
+++ b/hercules_opt/src/ivar.rs
@@ -4,6 +4,8 @@ extern crate bitvec;
use std::collections::{BTreeMap, HashMap, VecDeque};
+use self::hercules_ir::Subgraph;
+
use self::bitvec::order::Lsb0;
use self::bitvec::vec::BitVec;
use self::hercules_ir::get_uses;
@@ -41,6 +43,19 @@ enum LoopVariance {
Variant,
}
+
+/** Represents a basic induction variable.
+ *
+ * NOTE (@xrouth): May switch to using SCEV to represent induction vairables, for now we assume only basic induction variables
+ * with a constant update (not even linear). Eventually add dynamic constant updates, and linear updates
+ */
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct BasicInductionVariable {
+ pub node: NodeID,
+ pub initializer: NodeID,
+ pub update: NodeID, // TODO: Assume only *constants*, not dynamic constants for now.
+}
+
/** Given a loop (from LoopTree) determine for each data node if. Queries on control nodes are undefined. */
pub fn compute_loop_variance(function: &Function, loop_nodes: &(BitVec<u8, Lsb0>, NodeID)) -> LoopVarianceInfo {
let (loop_inner_control_nodes, loop_header) = loop_nodes;
@@ -113,7 +128,171 @@ pub fn compute_loop_variance(function: &Function, loop_nodes: &(BitVec<u8, Lsb0>
return LoopVarianceInfo { loop_header: *loop_header, map: variance_map };
}
-pub fn compute_induction_vars(function: &Function, loop_preheader: NodeID, loop_nodes: &(BitVec<u8, Lsb0>, NodeID), loop_variance: LoopVarianceInfo) {
+/** To convert a phi into a reduce we need to check that every cycle containing the PHI does not contain any other PHI.
+ * I think this restriction can be loosened (more specified)
+ * - Every cycle *in the loop* containing the PHI does not contain any other PHI. Or something, IDK.
+ * -
+ * We also need to make it not control dependent on anything other than the loop header. */
+pub fn check_reductionable_phis(function: &Function, editor: &FunctionEditor, control_subgraph: &Subgraph, loop_preheader: NodeID,
+ loop_nodes: &(BitVec<u8, Lsb0>, NodeID), induction_vars: &[BasicInductionVariable],
+ loop_variance: &LoopVarianceInfo, phis: &[NodeID])
+ -> impl IntoIterator<Item = NodeID>
+ {
+
+ // FIXME: (@xrouth)
+ // Check that the PHI actually has a cycle back to it.
+
+ let mut reductionable_phis: Vec<NodeID> = vec![];
+
+ for phi in phis {
+ // do WFS
+ let mut other_phi_on_path: DenseNodeMap<bool> = vec![false; function.nodes.len()];
+ let mut bag_of_control_nodes: Vec<NodeID> = vec![*phi];
+ let mut visited: DenseNodeMap<bool> = vec![false; function.nodes.len()];
+
+ while !bag_of_control_nodes.is_empty() {
+ let node = bag_of_control_nodes.pop().unwrap();
+
+ if visited[node.idx()] {
+ continue;
+ }
+ visited[node.idx()] = true;
+
+ if function.nodes[node.idx()].is_phi() && node != *phi{
+ other_phi_on_path[node.idx()] = true;
+ }
+
+ // Get node's users or users of node?. I concede that these actually are the same thing.
+ // IT is NOT OBVIOSU THOUGH! rename plz? get_users_of()?
+ for succ in editor.get_users(node) {
+ // If we change, mark as unvisited.
+ if other_phi_on_path[node.idx()] && other_phi_on_path[succ.idx()] == false {
+ other_phi_on_path[succ.idx()] = true;
+ visited[succ.idx()] = false;
+ bag_of_control_nodes.push(succ.clone());
+ }
+ }
+ }
+
+ if other_phi_on_path[phi.idx()] == false {
+ reductionable_phis.push(phi.clone());
+ }
+ }
+
+ println!("reductionable phis: {:?}", reductionable_phis);
+ return reductionable_phis;
+}
+
+/** Given loop information, returns the Node that makes the loop bound, and the NodeID representing the loop bound */
+pub fn compute_loop_bounds(function: &Function, control_subgraph: &Subgraph, loop_preheader: NodeID, loop_nodes: &(BitVec<u8, Lsb0>, NodeID),
+ induction_vars: &[BasicInductionVariable], loop_variance: &LoopVarianceInfo) -> Option<(BasicInductionVariable, NodeID, NodeID)> {
+
+ let (loop_inner_control_nodes, loop_header) = loop_nodes;
+
+ // We assume we *only* care about trip counts / loop bounds.
+
+ // Answers the question which PHI node does this loop depend on,
+ // Q: What happens if it is a PHI + expression, i.e i = 0; i + 2 < 6; i++
+ // A: Some transformation that changes this to i < 6 - 2? i.e don't worry about this here.
+
+ // Get loop condition:
+ // DFS Traversal on loop control subgraph until we find a node that is outside the loop, find the last IF on this path.
+ let mut last_if_on_path: DenseNodeMap<Option<NodeID>> = vec![None; function.nodes.len()];
+ // FIXME: (@xrouth) THIS IS MOST CERTAINLY BUGGED
+ // this might be bugged... i.e might need to udpate `last if` even if already defined.
+ // needs to be `saturating` kinda, more iterative. May need to visit nodes more than once?
+
+ // FIXME: (@xrouth) Right now we assume only one exit from the loop, later: check for multiple exits on the loop,
+ // either as an assertion here or some other part of forkify or analysis.
+ let mut bag_of_control_nodes = vec![loop_header.clone()];
+ let mut visited: DenseNodeMap<bool> = vec![false; function.nodes.len()];
+
+ let mut final_if: Option<NodeID> = None;
+
+ // do WFS
+ while !bag_of_control_nodes.is_empty() {
+ let node = bag_of_control_nodes.pop().unwrap();
+ if visited[node.idx()] {
+ continue;
+ }
+ visited[node.idx()] = true;
+
+ final_if =
+ if function.nodes[node.idx()].is_if() {
+ Some(node)
+ } else {
+ last_if_on_path[node.idx()]
+ };
+
+ if !loop_inner_control_nodes[node.idx()] {
+ break;
+ }
+
+ for succ in control_subgraph.succs(node) {
+ last_if_on_path[succ.idx()] = final_if;
+ bag_of_control_nodes.push(succ.clone());
+ }
+ }
+
+ // We have found the node that exits the loop.
+ let loop_condition = match final_if {
+ Some(v) => v,
+ None => return None,
+ };
+
+ println!("loop condition: {:?}", loop_condition);
+
+ // Check for an induction variable that interacts reasonably with the loop condition via pattern matching.
+ for induction_var in induction_vars {
+ // Check for
+ let (_, condition) = function.nodes[loop_condition.idx()].try_if().unwrap();
+
+ let bound = match &function.nodes[condition.idx()] {
+ Node::Phi { control, data } => todo!(),
+ Node::Reduce { control, init, reduct } => todo!(),
+ Node::Parameter { index } => todo!(),
+ Node::Constant { id } => todo!(),
+ Node::Unary { input, op } => todo!(),
+ Node::Binary { left, right, op } => {
+ match op {
+ BinaryOperator::LT => {
+ // Need to check for loops
+ println!("induction var: {:?}", induction_var);
+ println!("left, right {:?}, {:?}", left, right);
+ // left < right
+ if *left == induction_var.node &&
+ (function.nodes[right.idx()].is_constant() || function.nodes[right.idx()].is_dynamic_constant()) {
+ Some(right)
+ }
+ else {
+ None
+ }
+ }
+ BinaryOperator::LTE => todo!(), // like wtf.
+ BinaryOperator::GT => todo!(),
+ BinaryOperator::GTE => todo!(),
+ BinaryOperator::EQ => todo!(),
+ BinaryOperator::NE => todo!(),
+ _ => None,
+ }
+
+ }
+ Node::Ternary { first, second, third, op } => todo!(),
+ _ => None,
+ };
+
+ match bound {
+ Some(v) => return Some((*induction_var, *v, loop_condition)),
+ None => return None,
+ }
+ }
+
+ None
+}
+
+
+
+pub fn compute_induction_vars(function: &Function, loop_preheader: NodeID, loop_nodes: &(BitVec<u8, Lsb0>, NodeID), loop_variance: &LoopVarianceInfo) -> Vec<BasicInductionVariable> {
let (loop_inner_control_nodes, loop_header) = loop_nodes;
let mut loop_vars: Vec<NodeID> = vec![];
@@ -125,48 +304,83 @@ pub fn compute_induction_vars(function: &Function, loop_preheader: NodeID, loop
}
}
}
+
+ println!("loop_vars: {:?}", loop_vars);
// FIXME: (@xrouth) For now, only compute variables that have one assignment, (look into this:) possibly treat multiple assignment as separate induction variables.
- let mut induction_variables: Vec<NodeID> = vec![];
+ let mut induction_variables: Vec<BasicInductionVariable> = vec![];
/* 1) For each PHI controlled by the loop, check how it is modified */
// It's initializer needs to be loop invariant, it's update needs to be loop variant.
- for phi_idx in loop_vars {
- let phi_node = &function.nodes[phi_idx.idx()];
- let (control, data) = phi_node.try_phi().unwrap();
+ for phi_id in loop_vars {
+ let phi_node = &function.nodes[phi_id.idx()];
+ let (region, data) = phi_node.try_phi().unwrap();
+ let region_node = &function.nodes[region.idx()];
+ let region_inputs = region_node.try_region().unwrap();
+
+ // The initializer index is the first index of the inputs to the region node of that isn't in the loop. (what is loop_header, wtf...)
+ // FIXME (@xrouth): If there is control flow in the loop, we won't find
+ let Some(initializer_idx) = region_inputs.iter().position(|&node_id| !loop_inner_control_nodes[node_id.idx()]) else {
+ continue;
+ };
+
+ let initializer_id = data[initializer_idx];
- //
- let initializer_idx = data.iter().position(|&node_id| node_id == loop_preheader).unwrap();
+ // Check dynamic constancy:
+ let initializer = &function.nodes[initializer_id.idx()];
+ println!("initializer_id: {:?}", initializer_id);
- // Check variance,
- if loop_variance.map[initializer_idx] != LoopVariance::Invariant {
+ // In the case of a non 0 starting value:
+ // - a new dynamic constant or constant may need to be created that is the difference between the initiailizer and the loop bounds.
+ if !(initializer.is_dynamic_constant() || initializer.is_constant()) {
break;
}
+ // Check that intiailizer is 0:
+
+ // TODO: (@xrouth) These checks, for initializer and non 0 starting value maybe can be done later, i.e in a different function / transformation.
+ // Maybe return all induction variables as long as things are *loop invariant* and then filter by actualy constancy or dynamic constancy later.
+
// Check all data inputs to this phi, that aren't the initializer (i.e the value the comes from control outside of the loop)
// For now we expect only one initializer.
- // data.iter().filter(
- // |node_id| NodeID::new(initializer_idx) != **node_id
- // ).map(
- // // Later, we are interested in PHIs that contain cycles only containing itself.
- // // For now, we are intetersted in PHIs that are linear / based on a simple expression, i.e only
-
- // // Pattern match
- // // Expressions we are looking for: %PHI = %PHI + %invariant expression.
- // todo!()
- // )
- // ;
-
- // if loop_variance.map[]
+ let basic_ivs = data.iter().filter(
+ |data_id| NodeID::new(initializer_idx) != **data_id
+ ).filter_map(
+ |data_id| {
+ let node = &function.nodes[data_id.idx()];
+ for bop in [BinaryOperator::Add] { //, BinaryOperator::Mul, BinaryOperator::Sub] {
+ if let Some((a, b)) = node.try_binary(bop) {
+ if a == phi_id && function.nodes[b.idx()].is_constant() {
+ // TODO: (@xrouth), move this is_strictly_scalar check somewhere else for when you actually evalute the constant.
+ // let constant_id = function.nodes[b.idx()].try_constant().unwrap();
+ // let constant = &module.constants[constant_id.idx()];
+ // if !constant.is_strictly_scalar() {
+ // break;
+ // }
+ return Some(BasicInductionVariable{
+ node: phi_id,
+ initializer: initializer_id,
+ update: b,
+ });
+
+ } else if b == phi_id && function.nodes[a.idx()].is_constant() {
+ return Some(BasicInductionVariable{
+ node: phi_id,
+ initializer: initializer_id,
+ update: a,
+ });
+ }
+ }
+ }
+ None
+ }
+ );
- induction_variables.push(phi_idx);
+ let mut v: Vec<_> = basic_ivs.collect();
+ induction_variables.append(& mut v);
};
- // Check it's initializer ()
-
-
-
- /* 2) Find */
-
+ println!("basic induction variables: {:?}", induction_variables);
+ induction_variables
}
\ No newline at end of file
diff --git a/hercules_opt/src/pass.rs b/hercules_opt/src/pass.rs
index 2aa25a34..e7e0db69 100644
--- a/hercules_opt/src/pass.rs
+++ b/hercules_opt/src/pass.rs
@@ -494,18 +494,43 @@ impl PassManager {
Pass::Forkify => {
self.make_def_uses();
self.make_loops();
+ self.make_control_subgraphs();
let def_uses = self.def_uses.as_ref().unwrap();
let loops = self.loops.as_ref().unwrap();
for idx in 0..self.module.functions.len() {
- forkify(
+ let constants_ref =
+ RefCell::new(std::mem::take(&mut self.module.constants));
+ let dynamic_constants_ref =
+ RefCell::new(std::mem::take(&mut self.module.dynamic_constants));
+ let types_ref = RefCell::new(std::mem::take(&mut self.module.types));
+ let subgraph = &self.control_subgraphs.as_ref().unwrap()[idx];
+ let mut editor = FunctionEditor::new(
&mut self.module.functions[idx],
- &self.module.constants,
- &mut self.module.dynamic_constants,
+ &constants_ref,
+ &dynamic_constants_ref,
+ &types_ref,
&def_uses[idx],
+ );
+
+ forkify(
+ &mut editor,
+ subgraph,
&loops[idx],
- )
+ );
+
+ self.module.constants = constants_ref.take();
+ self.module.dynamic_constants = dynamic_constants_ref.take();
+ self.module.types = types_ref.take();
+
+ let edits = &editor.edits();
+ if let Some(plans) = self.plans.as_mut() {
+ repair_plan(&mut plans[idx], &self.module.functions[idx], edits);
+ }
+ let grave_mapping = self.module.functions[idx].delete_gravestones();
+ if let Some(plans) = self.plans.as_mut() {
+ plans[idx].fix_gravestones(&grave_mapping);
+ }
}
- self.legacy_repair_plan();
self.clear_analyses();
}
Pass::PhiElim => {
diff --git a/hercules_opt/src/sroa.rs b/hercules_opt/src/sroa.rs
index 67c904ff..b8c867fa 100644
--- a/hercules_opt/src/sroa.rs
+++ b/hercules_opt/src/sroa.rs
@@ -187,7 +187,7 @@ pub fn sroa(editor: &mut FunctionEditor, reverse_postorder: &Vec<NodeID>, types:
},
AllocatedTernary {
cond: NodeID,
- thn: NodeID,
+ thn: NodeID,
els: NodeID,
node: NodeID,
fields: IndexTree<NodeID>,
diff --git a/hercules_test/hercules_tests/tests/loop_tests.rs b/hercules_test/hercules_tests/tests/loop_tests.rs
index 030e9b16..48b436d3 100644
--- a/hercules_test/hercules_tests/tests/loop_tests.rs
+++ b/hercules_test/hercules_tests/tests/loop_tests.rs
@@ -21,6 +21,8 @@ fn loop0() {
let passes = vec![
Pass::Verify,
+ Pass::Forkify,
+ Pass::Verify,
];
for pass in passes {
@@ -28,9 +30,10 @@ fn loop0() {
}
pm.run_passes();
- // let module = pm.get_module();
- // let result_2 = interp_module!(module, dyn_consts, m1, m2);
- // assert_eq!(result_1, result_2)
+ let module = pm.get_module();
+ let result_2 = interp_module!(module, dyn_consts, 2);
+ println!("result: {:?}", result_2);
+ assert_eq!(result_1, result_2)
}
#[test]
@@ -46,6 +49,8 @@ fn loop1() {
let passes = vec![
Pass::Verify,
+ Pass::Forkify,
+ Pass::Verify,
];
for pass in passes {
@@ -53,8 +58,9 @@ fn loop1() {
}
pm.run_passes();
- // let module = pm.get_module();
- // let result_2 = interp_module!(module, dyn_consts, m1, m2);
- // assert_eq!(result_1, result_2)
+ let module = pm.get_module();
+ let result_2 = interp_module!(module, dyn_consts, 2);
+ assert_eq!(result_1, result_2);
+ println!("{:?}, {:?}", result_1, result_2);
}
--
GitLab
From f9bf21637702ca39b19bd320a15bb47df0b34db5 Mon Sep 17 00:00:00 2001
From: Xavier Routh <xrouth2@illinois.edu>
Date: Fri, 13 Dec 2024 13:01:18 -0600
Subject: [PATCH 07/68] forkify tests + bugfixes
---
hercules_opt/src/forkify.rs | 386 ++++--------------
hercules_opt/src/ivar.rs | 66 ++-
.../hercules_interpreter/src/interpreter.rs | 27 +-
.../hercules_tests/tests/loop_tests.rs | 80 +++-
.../hercules_tests/tests/opt_tests.rs | 8 +-
.../fork_fission.hir | 0
.../fork_fusion.hir | 0
.../fork_interchange.hir | 0
.../alternate_bounds.hir} | 0
.../phi_loop2.hir => forkify/broken_sum.hir} | 7 +-
.../test_inputs/forkify/loop_array_sum.hir | 16 +
.../loop_simple_iv.hir} | 0
.../phi_loop1.hir => forkify/loop_sum.hir} | 0
.../test_inputs/forkify/nested_loop1.hir | 23 ++
.../test_inputs/forkify/nested_loop2.hir | 25 ++
.../test_inputs/forkify/nested_loop3.hir | 25 ++
.../test_inputs/forkify/phi_loop4.hir | 16 +
.../{fork_optimization => forkify}/tiling.hir | 0
.../untiling.hir | 0
19 files changed, 314 insertions(+), 365 deletions(-)
rename hercules_test/test_inputs/{fork_optimization => fork_transforms}/fork_fission.hir (100%)
rename hercules_test/test_inputs/{fork_optimization => fork_transforms}/fork_fusion.hir (100%)
rename hercules_test/test_inputs/{fork_optimization => fork_transforms}/fork_interchange.hir (100%)
rename hercules_test/test_inputs/{fork_optimization/phi_loop3.hir => forkify/alternate_bounds.hir} (100%)
rename hercules_test/test_inputs/{fork_optimization/phi_loop2.hir => forkify/broken_sum.hir} (74%)
create mode 100644 hercules_test/test_inputs/forkify/loop_array_sum.hir
rename hercules_test/test_inputs/{fork_optimization/phi_loop0.hir => forkify/loop_simple_iv.hir} (100%)
rename hercules_test/test_inputs/{fork_optimization/phi_loop1.hir => forkify/loop_sum.hir} (100%)
create mode 100644 hercules_test/test_inputs/forkify/nested_loop1.hir
create mode 100644 hercules_test/test_inputs/forkify/nested_loop2.hir
create mode 100644 hercules_test/test_inputs/forkify/nested_loop3.hir
create mode 100644 hercules_test/test_inputs/forkify/phi_loop4.hir
rename hercules_test/test_inputs/{fork_optimization => forkify}/tiling.hir (100%)
rename hercules_test/test_inputs/{fork_optimization => forkify}/untiling.hir (100%)
diff --git a/hercules_opt/src/forkify.rs b/hercules_opt/src/forkify.rs
index c4740289..ab31c66a 100644
--- a/hercules_opt/src/forkify.rs
+++ b/hercules_opt/src/forkify.rs
@@ -1,7 +1,10 @@
extern crate hercules_ir;
+extern crate bitvec;
use std::iter::zip;
+use self::bitvec::vec::BitVec;
+
use self::hercules_ir::Subgraph;
use self::hercules_ir::control_subgraph;
@@ -16,37 +19,62 @@ use self::hercules_ir::def_use::*;
use self::hercules_ir::ir::*;
use self::hercules_ir::loops::*;
+pub fn forkify(
+ editor: &mut FunctionEditor,
+ control_subgraph: &Subgraph,
+ loops: &LoopTree,
+) -> () {
+ println!("loops: {:?} ", loops.bottom_up_loops());
+
+ let natural_loops = loops
+ .bottom_up_loops()
+ .into_iter()
+ .filter(|(k, _)| editor.func().nodes[k.idx()].is_region());
+
+ let natural_loops: Vec<_> = natural_loops.collect();
+
+ for l in natural_loops {
+ forkify_loop(editor, control_subgraph, l);
+ break; //TODO: REMOVE ME
+ }
+}
/*
* Top level function to convert natural loops with simple induction variables
* into fork-joins.
*/
-pub fn forkify(
+pub fn forkify_loop(
editor: &mut FunctionEditor,
control_subgraph: &Subgraph,
- loops: &LoopTree,
+ looop: (NodeID, &BitVec<u8>),
) -> () {
// TODO: Do we want to run analysizes before, I think it's fine to put them in the pass itself.
// i.e no real split between analysis and transformation.
let function = editor.func();
- println!("num loops: {:?}", loops.loops().len());
// TODO: (@xrouth) handle multiple loops.
// Probably want to forkify bottom up, but also need to look at potential 2d forkifies.
// Maybe upon forkification: BLARGH, Nd forkys are complicated.
- let (header, (body, parent)) = loops.loops().nth(0).expect("No loops found in function.");
+ let (header, body) = looop;
+
+ println!("header: {:?}", header);
let loop_nodes = (body.clone(), header.clone());
+ let loop_pred = editor.get_uses(header) // Is this the same as parent? NO!
+ .filter(|id| !body[id.idx()])
+ .next()
+ .unwrap();
+
// Compute loop variance
let loop_variance = compute_loop_variance(function, &loop_nodes);
// Compute induction vars
- let basic_ivs = compute_induction_vars(function, *parent, &loop_nodes, &loop_variance);
+ let basic_ivs = compute_induction_vars(function, &loop_nodes, &loop_variance);
// Compute loop bounds
- let loop_bounds = compute_loop_bounds(function, &control_subgraph, *parent, &loop_nodes, &basic_ivs, &loop_variance);
+ let loop_bounds = compute_loop_bounds(function, &control_subgraph, &loop_nodes, &basic_ivs, &loop_variance);
println!("loop_bounds: {:?}", loop_bounds);
@@ -58,13 +86,13 @@ pub fn forkify(
// Check reductionable phis, only PHIs depending on the loop are considered,
// this is how we avoid reductions that depend on control flow.
let candidate_phis: Vec<_> = editor
- .get_users(*header)
+ .get_users(header)
.filter(|id|function.nodes[id.idx()].is_phi())
.collect();
- let reductionable_phis = check_reductionable_phis(function, &editor, &control_subgraph, *parent, &loop_nodes,
+ let reductionable_phis = check_reductionable_phis(function, &editor, &control_subgraph, &loop_nodes,
&basic_ivs, &loop_variance, &candidate_phis);
-
+
// Check for a constant used as loop bound.
let bound_dc_id =
@@ -124,24 +152,18 @@ pub fn forkify(
// - b) if the PHI is not the IV:
// Just make it a reduce or something.
- // Get the control portions of the loop that need to be grafted;
let function = editor.func();
// Get the control portions of the loop that need to be grafted.
- let loop_pred = editor.get_uses(*header) // Is this the same as parent? NO!
- .filter(|id| !body[id.idx()])
- .next()
- .unwrap();
- let loop_true_read = editor.get_uses(*header)
+ let loop_true_projection = editor.get_uses(header)
.filter(|id| body[id.idx()])
.next()
.unwrap();
- let loop_end = function.nodes[loop_true_read.idx()]
+ let loop_end = function.nodes[loop_true_projection.idx()]
.try_projection(1)
.unwrap();
- let loop_false_read =
- editor.get_users(loop_end)
+ let loop_false_projection = editor.get_users(loop_end)
.filter_map(|id| {
if function.nodes[id.idx()].try_projection(0).is_some() {
Some(id)
@@ -167,7 +189,7 @@ pub fn forkify(
// If there is no control between loop_end and header, attach join to header
// If there is control, attach join to the control.
let join = Node::Join {
- control: if *header == loop_end_uses[0] {
+ control: if header == loop_end_uses[0] {
fork_id
} else {
loop_end.try_if().unwrap().0
@@ -180,20 +202,21 @@ pub fn forkify(
);
let function = editor.func();
- let induction_variable = basic_ivs[0]; // TODO: Choose this better.
-
+ let induction_variable = basic_ivs.iter().find(|v| iv == **v).unwrap();
+
+ // If there are uses of the IV that aren't PHIs controlled by the header,
let update = *zip(
- editor.get_uses(*header),
+ editor.get_uses(header),
function.nodes[induction_variable.node.idx()]
.try_phi()
.unwrap()
.1
.iter(),
- )
- .filter(|(c, _)| *c == loop_true_read)
- .next()
- .unwrap()
- .1;
+ )
+ .filter(|(c, _)| *c == loop_true_projection)
+ .next()
+ .unwrap()
+ .1;
// Create ThreadID
editor.edit(
@@ -204,8 +227,6 @@ pub fn forkify(
};
let thread_id_id = edit.add_node(thread_id);
-
-
let iv_reduce = Node::Reduce {
control: join_id,
init: induction_variable.initializer,
@@ -214,11 +235,11 @@ pub fn forkify(
let iv_reduce_id = edit.add_node(iv_reduce);
// let users = edit.get_users(induction_variable.node);
-
println!("replacing all uses of: {:?} with {:?}", induction_variable.node, iv_reduce_id);
- edit = edit.replace_all_uses(induction_variable.node, iv_reduce_id)?;
+ edit = edit.replace_all_uses(induction_variable.node, thread_id_id)?;
edit.delete_node(induction_variable.node)
+ // edit.replace_all_uses_where(old, new, pred)
// for user in users {
// // How to check if user is 'inside' or 'outside' loop?
// // FIXME: For now, just replace everything with the reduce. Oh Well!
@@ -241,31 +262,31 @@ pub fn forkify(
let function = editor.func();
let init = *zip(
- editor.get_uses(*header),
+ editor.get_uses(header),
function.nodes[reduction_phi.idx()]
.try_phi()
.unwrap()
.1
.iter(),
- )
- .filter(|(c, _)| *c == loop_pred)
- .next()
- .unwrap()
- .1;
+ )
+ .filter(|(c, _)| *c == loop_pred)
+ .next()
+ .unwrap()
+ .1;
// Loop back edge input to phi is the reduction update expression.
let update = *zip(
- editor.get_uses(*header),
+ editor.get_uses(header),
function.nodes[reduction_phi.idx()]
.try_phi()
.unwrap()
.1
.iter(),
- )
- .filter(|(c, _)| *c == loop_true_read)
- .next()
- .unwrap()
- .1;
+ )
+ .filter(|(c, _)| *c == loop_true_projection)
+ .next()
+ .unwrap()
+ .1;
editor.edit(
|mut edit| {
@@ -281,294 +302,31 @@ pub fn forkify(
);
}
- // Replace all uses of the loop ehader with the fork
+ // Replace all uses of the loop header with the fork
editor.edit(
|mut edit| {
- edit.replace_all_uses(*header, fork_id)
+ edit.replace_all_uses(header, fork_id)
}
);
editor.edit(
|mut edit| {
- edit.replace_all_uses(loop_false_read, join_id)
+ edit.replace_all_uses(loop_false_projection, join_id)
}
);
// TODO: (@xrouth) Wtf is this?
+ // DCE should get these, but delete them ourselves because we are nice :)
editor.edit(
|mut edit| {
- edit = edit.delete_node(loop_false_read)?;
- edit = edit.delete_node(loop_false_read)?;
- edit = edit.delete_node(loop_true_read)?;
+ edit = edit.delete_node(loop_false_projection)?;
+ // edit = edit.delete_node(loop_false_read)?;
+ edit = edit.delete_node(loop_true_projection)?;
edit = edit.delete_node(loop_condition)?; // Delet ethe if.
- edit = edit.delete_node(*header)?;
+ edit = edit.delete_node(header)?;
Ok(edit)
}
);
return;
}
-
-
-/*
- * Top level function to convert natural loops with simple induction variables
- * into fork-joins.
- */
-pub fn forkify_old(
- function: &mut Function,
- constants: &Vec<Constant>,
- dynamic_constants: &mut Vec<DynamicConstant>,
- def_use: &ImmutableDefUseMap,
- loops: &LoopTree,
-) {
-
- todo!();
-
- // TODO: (@xrouth): Should this be created by pass manager?
- let control_subgraph = control_subgraph(function, def_use);
- // let mut scev_context = SCEVContext::new(function, loops);
- // scev_context.gather_evolutions();
-
- println!("num loops: {:?}", loops.loops().len());
-
- println!("function len: {:?}", function.nodes.len());
-
- // TODO: (@xrouth) handle multiple loops.
- let (header, (body, parent)) = loops.loops().nth(0).expect("No loops found in function.");
-
- let loop_nodes = (body.clone(), header.clone());
-
- // Compute loop variance
- let loop_variance = compute_loop_variance(function, &loop_nodes);
-
- // Compute induction vars
- let basic_ivs = compute_induction_vars(function, *parent, &loop_nodes, &loop_variance);
-
- // Compute loop bounds
- let loop_bounds = compute_loop_bounds(function, &control_subgraph, *parent, &loop_nodes, &basic_ivs, &loop_variance);
-
- println!("loop_bounds: {:?}", loop_bounds);
-
- return;
- // Ignore loops that are already fork-joins. TODO: re-calculate def_use per
- // loop, since it's technically invalidated after each individual loop
- // modification.
- let natural_loops = loops
- .bottom_up_loops()
- .into_iter()
- .rev()
- .filter(|(k, _)| function.nodes[k.idx()].is_region());
-
- // Detect loops that have a simple loop induction variable. TODO: proper
- // affine analysis to recognize other cases of linear induction variables.
- let affine_loops: Vec<_> = natural_loops
- .into_iter()
- .filter_map(|(header, contents)| {
- // Get the single loop contained predecessor of the loop header.
- let header_uses = get_uses(&function.nodes[header.idx()]);
- let mut pred_loop = header_uses.as_ref().iter().filter(|id| contents[id.idx()]);
- let single_pred_loop = pred_loop.next()?;
- if pred_loop.next().is_some() || header_uses.as_ref().len() != 2 {
- return None;
- }
-
- // Check for a very particular loop indexing structure.
- let if_ctrl = function.nodes[single_pred_loop.idx()].try_projection(1)?;
- let (_, if_cond) = function.nodes[if_ctrl.idx()].try_if()?;
- let (idx, bound) = function.nodes[if_cond.idx()].try_binary(BinaryOperator::LT)?;
- let (phi, one) = function.nodes[idx.idx()].try_binary(BinaryOperator::Add)?;
- let (should_be_header, pred_datas) = function.nodes[phi.idx()].try_phi()?;
- let one_c_id = function.nodes[one.idx()].try_constant()?;
-
- if should_be_header != header || !constants[one_c_id.idx()].is_one() {
- return None;
- }
-
- // Check that phi's if predecessor is the add node, and check that the
- // phi's other predecessors are zeros.
- zip(header_uses.as_ref().iter(), pred_datas.iter())
- .position(|(c, d)| *c == *single_pred_loop && *d == idx)?;
- if zip(header_uses.as_ref().iter(), pred_datas.iter())
- .filter(|(c, d)| {
- (**c != *single_pred_loop)
- && !function.nodes[d.idx()].is_zero_constant(constants)
- })
- .count()
- != 0
- {
- return None;
- }
-
- // Check for constant used as loop bound. Do this last, since we may
- // create a new dynamic constant here.
- let bound_dc_id =
- if let Some(bound_dc_id) = function.nodes[bound.idx()].try_dynamic_constant() {
- bound_dc_id
- } else if let Some(bound_c_id) = function.nodes[bound.idx()].try_constant() {
- // Create new dynamic constant that reflects this constant.
- let dc = match constants[bound_c_id.idx()] {
- Constant::Integer8(x) => DynamicConstant::Constant(x as _),
- Constant::Integer16(x) => DynamicConstant::Constant(x as _),
- Constant::Integer32(x) => DynamicConstant::Constant(x as _),
- Constant::Integer64(x) => DynamicConstant::Constant(x as _),
- Constant::UnsignedInteger8(x) => DynamicConstant::Constant(x as _),
- Constant::UnsignedInteger16(x) => DynamicConstant::Constant(x as _),
- Constant::UnsignedInteger32(x) => DynamicConstant::Constant(x as _),
- Constant::UnsignedInteger64(x) => DynamicConstant::Constant(x as _),
- _ => return None,
- };
-
- // The new dynamic constant may already be interned.
- let maybe_already_in = dynamic_constants
- .iter()
- .enumerate()
- .find(|(_, x)| **x == dc)
- .map(|(idx, _)| idx);
- if let Some(bound_dc_idx) = maybe_already_in {
- DynamicConstantID::new(bound_dc_idx)
- } else {
- let id = DynamicConstantID::new(dynamic_constants.len());
- dynamic_constants.push(dc);
- id
- }
- } else {
- return None;
- };
-
- Some((header, phi, contents, bound_dc_id))
- })
- .collect();
-
- // Convert affine loops into fork-joins.
- for (header, idx_phi, contents, dc_id) in affine_loops {
- let header_uses = get_uses(&function.nodes[header.idx()]);
- let header_uses: Vec<_> = header_uses.as_ref().into_iter().map(|x| *x).collect();
-
- // Get the control portions of the loop that need to be grafted.
- let loop_pred = header_uses
- .iter()
- .filter(|id| !contents[id.idx()])
- .next()
- .unwrap();
- let loop_true_read = header_uses
- .iter()
- .filter(|id| contents[id.idx()])
- .next()
- .unwrap();
- let loop_end = function.nodes[loop_true_read.idx()]
- .try_projection(1)
- .unwrap();
- let loop_false_read = *def_use
- .get_users(loop_end)
- .iter()
- .filter_map(|id| {
- if function.nodes[id.idx()].try_projection(0).is_some() {
- Some(id)
- } else {
- None
- }
- })
- .next()
- .unwrap();
-
- // Create fork and join nodes.
- let fork = Node::Fork {
- control: *loop_pred,
- factors: Box::new([dc_id]),
- };
- let fork_id = NodeID::new(function.nodes.len());
- function.nodes.push(fork);
-
- let join = Node::Join {
- control: if header == get_uses(&function.nodes[loop_end.idx()]).as_ref()[0] {
- fork_id
- } else {
- function.nodes[loop_end.idx()].try_if().unwrap().0
- },
- };
- let join_id = NodeID::new(function.nodes.len());
- function.nodes.push(join);
-
- // Convert reducing phi nodes to reduce nodes.
- let reduction_phis: Vec<_> = def_use
- .get_users(header)
- .iter()
- .filter(|id| **id != idx_phi && function.nodes[id.idx()].is_phi())
- .collect();
- for reduction_phi in reduction_phis {
- // Loop predecessor input to phi is the reduction initializer.
- let init = *zip(
- header_uses.iter(),
- function.nodes[reduction_phi.idx()]
- .try_phi()
- .unwrap()
- .1
- .iter(),
- )
- .filter(|(c, _)| **c == *loop_pred)
- .next()
- .unwrap()
- .1;
-
- // Loop back edge input to phi is the reduction induction variable.
- let reduct = *zip(
- header_uses.iter(),
- function.nodes[reduction_phi.idx()]
- .try_phi()
- .unwrap()
- .1
- .iter(),
- )
- .filter(|(c, _)| **c == *loop_true_read)
- .next()
- .unwrap()
- .1;
-
- // Create reduction node.
- let reduce = Node::Reduce {
- control: join_id,
- init,
- reduct,
- };
- let reduce_id = NodeID::new(function.nodes.len());
- function.nodes.push(reduce);
-
- // Edit users of phis.
- for user in def_use.get_users(*reduction_phi) {
- get_uses_mut(&mut function.nodes[user.idx()]).map(*reduction_phi, reduce_id);
- }
-
- // Edit users of uses of phis.
- for user in def_use.get_users(reduct) {
- get_uses_mut(&mut function.nodes[user.idx()]).map(reduct, reduce_id);
- }
-
- // Delete reducing phi.
- function.nodes[reduction_phi.idx()] = Node::Start;
- }
-
- // Convert index phi node to thread ID node.
- let thread_id = Node::ThreadID {
- control: fork_id,
- dimension: 0,
- };
- let thread_id_id = NodeID::new(function.nodes.len());
- function.nodes.push(thread_id);
-
- for user in def_use.get_users(idx_phi) {
- get_uses_mut(&mut function.nodes[user.idx()]).map(idx_phi, thread_id_id);
- }
- for user in def_use.get_users(header) {
- get_uses_mut(&mut function.nodes[user.idx()]).map(header, fork_id);
- }
- for user in def_use.get_users(loop_false_read) {
- get_uses_mut(&mut function.nodes[user.idx()]).map(loop_false_read, join_id);
- }
-
- function.nodes[idx_phi.idx()] = Node::Start;
- function.nodes[header.idx()] = Node::Start;
- function.nodes[loop_end.idx()] = Node::Start;
- function.nodes[loop_true_read.idx()] = Node::Start;
- function.nodes[loop_false_read.idx()] = Node::Start;
- }
-}
diff --git a/hercules_opt/src/ivar.rs b/hercules_opt/src/ivar.rs
index 3f0ae63c..a04a29ee 100644
--- a/hercules_opt/src/ivar.rs
+++ b/hercules_opt/src/ivar.rs
@@ -133,7 +133,7 @@ pub fn compute_loop_variance(function: &Function, loop_nodes: &(BitVec<u8, Lsb0>
* - Every cycle *in the loop* containing the PHI does not contain any other PHI. Or something, IDK.
* -
* We also need to make it not control dependent on anything other than the loop header. */
-pub fn check_reductionable_phis(function: &Function, editor: &FunctionEditor, control_subgraph: &Subgraph, loop_preheader: NodeID,
+pub fn check_reductionable_phis(function: &Function, editor: &FunctionEditor, control_subgraph: &Subgraph,
loop_nodes: &(BitVec<u8, Lsb0>, NodeID), induction_vars: &[BasicInductionVariable],
loop_variance: &LoopVarianceInfo, phis: &[NodeID])
-> impl IntoIterator<Item = NodeID>
@@ -184,7 +184,7 @@ pub fn check_reductionable_phis(function: &Function, editor: &FunctionEditor, co
}
/** Given loop information, returns the Node that makes the loop bound, and the NodeID representing the loop bound */
-pub fn compute_loop_bounds(function: &Function, control_subgraph: &Subgraph, loop_preheader: NodeID, loop_nodes: &(BitVec<u8, Lsb0>, NodeID),
+pub fn compute_loop_bounds(function: &Function, control_subgraph: &Subgraph, loop_nodes: &(BitVec<u8, Lsb0>, NodeID),
induction_vars: &[BasicInductionVariable], loop_variance: &LoopVarianceInfo) -> Option<(BasicInductionVariable, NodeID, NodeID)> {
let (loop_inner_control_nodes, loop_header) = loop_nodes;
@@ -283,7 +283,7 @@ pub fn compute_loop_bounds(function: &Function, control_subgraph: &Subgraph, loo
match bound {
Some(v) => return Some((*induction_var, *v, loop_condition)),
- None => return None,
+ None => (),
}
}
@@ -292,7 +292,7 @@ pub fn compute_loop_bounds(function: &Function, control_subgraph: &Subgraph, loo
-pub fn compute_induction_vars(function: &Function, loop_preheader: NodeID, loop_nodes: &(BitVec<u8, Lsb0>, NodeID), loop_variance: &LoopVarianceInfo) -> Vec<BasicInductionVariable> {
+pub fn compute_induction_vars(function: &Function, loop_nodes: &(BitVec<u8, Lsb0>, NodeID), loop_variance: &LoopVarianceInfo) -> Vec<BasicInductionVariable> {
let (loop_inner_control_nodes, loop_header) = loop_nodes;
let mut loop_vars: Vec<NodeID> = vec![];
@@ -334,7 +334,7 @@ pub fn compute_induction_vars(function: &Function, loop_preheader: NodeID, loop_
// In the case of a non 0 starting value:
// - a new dynamic constant or constant may need to be created that is the difference between the initiailizer and the loop bounds.
if !(initializer.is_dynamic_constant() || initializer.is_constant()) {
- break;
+ continue;
}
// Check that intiailizer is 0:
@@ -346,39 +346,35 @@ pub fn compute_induction_vars(function: &Function, loop_preheader: NodeID, loop_
// For now we expect only one initializer.
let basic_ivs = data.iter().filter(
|data_id| NodeID::new(initializer_idx) != **data_id
- ).filter_map(
- |data_id| {
- let node = &function.nodes[data_id.idx()];
- for bop in [BinaryOperator::Add] { //, BinaryOperator::Mul, BinaryOperator::Sub] {
- if let Some((a, b)) = node.try_binary(bop) {
- if a == phi_id && function.nodes[b.idx()].is_constant() {
- // TODO: (@xrouth), move this is_strictly_scalar check somewhere else for when you actually evalute the constant.
- // let constant_id = function.nodes[b.idx()].try_constant().unwrap();
- // let constant = &module.constants[constant_id.idx()];
- // if !constant.is_strictly_scalar() {
- // break;
- // }
- return Some(BasicInductionVariable{
- node: phi_id,
- initializer: initializer_id,
- update: b,
- });
-
- } else if b == phi_id && function.nodes[a.idx()].is_constant() {
- return Some(BasicInductionVariable{
- node: phi_id,
- initializer: initializer_id,
- update: a,
- });
- }
+ );
+
+ for data_id in basic_ivs {
+ let node = &function.nodes[data_id.idx()];
+ for bop in [BinaryOperator::Add] { //, BinaryOperator::Mul, BinaryOperator::Sub] {
+ if let Some((a, b)) = node.try_binary(bop) {
+ if a == phi_id && function.nodes[b.idx()].is_constant() {
+ // TODO: (@xrouth), move this is_strictly_scalar check somewhere else for when you actually evalute the constant.
+ // let constant_id = function.nodes[b.idx()].try_constant().unwrap();
+ // let constant = &module.constants[constant_id.idx()];
+ // if !constant.is_strictly_scalar() {
+ // break;
+ // }
+ induction_variables.push(BasicInductionVariable{
+ node: phi_id,
+ initializer: initializer_id,
+ update: b,
+ });
+
+ } else if b == phi_id && function.nodes[a.idx()].is_constant() {
+ induction_variables.push(BasicInductionVariable{
+ node: phi_id,
+ initializer: initializer_id,
+ update: a,
+ });
}
}
- None
}
- );
-
- let mut v: Vec<_> = basic_ivs.collect();
- induction_variables.append(& mut v);
+ }
};
println!("basic induction variables: {:?}", induction_variables);
diff --git a/hercules_test/hercules_interpreter/src/interpreter.rs b/hercules_test/hercules_interpreter/src/interpreter.rs
index 5ee723e7..c98f5485 100644
--- a/hercules_test/hercules_interpreter/src/interpreter.rs
+++ b/hercules_test/hercules_interpreter/src/interpreter.rs
@@ -15,6 +15,8 @@ extern crate hercules_opt;
use self::hercules_ir::*;
+const VERBOSE: bool = true;
+
/* High level design details / discussion for this:
*
* This crate includes tools for interpreting a hercules IR module. Execution model / flow is based on
@@ -190,8 +192,12 @@ impl<'a> FunctionExecutionState<'a> {
.try_phi()
.expect("PANIC: handle_phi on non-phi node.");
let value_node = data[edge];
- // println!("Latching PHI value of node {:?}", value_node.idx());
+
let value = self.handle_data(token, value_node);
+ if VERBOSE {
+ println!("Latching PHI {:?} to {:?}", phi.idx(), value);
+ }
+
(phi, value)
}
@@ -521,12 +527,19 @@ impl<'a> FunctionExecutionState<'a> {
'outer: loop {
let mut ctrl_token = live_tokens.pop().expect("PANIC: Interpreter ran out of control tokens without returning.");
- /* println!(
- "\n\nNew Token at: Control State: {} threads: {:?}, {:?}",
- ctrl_token.curr.idx(),
- ctrl_token.thread_indicies.clone(),
- &self.get_function().nodes[ctrl_token.curr.idx()]
- ); */
+ // println!(
+ // "\n\nNew Token at: Control State: {} threads: {:?}, {:?}",
+ // ctrl_token.curr.idx(),
+ // ctrl_token.thread_indicies.clone(),
+ // &self.get_function().nodes[ctrl_token.curr.idx()]
+ // );
+ // TODO: (@xrouth): Enable this + PHI latch logging wi/ a simple debug flag.
+ // Tracking PHI vals and control state is very useful for debugging.
+
+
+ if VERBOSE {
+ println!("control token {} {}", ctrl_token.curr.idx(), &self.get_function().nodes[ctrl_token.curr.idx()].lower_case_name());
+ }
// TODO: Rust is annoying and can't recognize that this is a partial borrow.
// Can't partial borrow, so need a clone.
diff --git a/hercules_test/hercules_tests/tests/loop_tests.rs b/hercules_test/hercules_tests/tests/loop_tests.rs
index 48b436d3..dcbdd458 100644
--- a/hercules_test/hercules_tests/tests/loop_tests.rs
+++ b/hercules_test/hercules_tests/tests/loop_tests.rs
@@ -9,8 +9,8 @@ extern crate rand;
use rand::Rng;
#[test]
-fn loop0() {
- let module = parse_file("../test_inputs/fork_optimization/phi_loop0.hir");
+fn loop_simple_iv() {
+ let module = parse_file("../test_inputs/forkify/loop_simple_iv.hir");
let dyn_consts = [10];
let params = 2; // TODO: (@xrouth) fix macro to take no params as an option.
let result_1 = interp_module!(module, dyn_consts, 2);
@@ -37,9 +37,9 @@ fn loop0() {
}
#[test]
-fn loop1() {
- let module = parse_file("../test_inputs/fork_optimization/phi_loop1.hir");
- let dyn_consts = [10];
+fn loop_sum() {
+ let module = parse_file("../test_inputs/forkify/loop_sum.hir");
+ let dyn_consts = [20];
let params = 2; // TODO: (@xrouth) fix macro to take no params as an option.
let result_1 = interp_module!(module, dyn_consts, 2);
@@ -50,6 +50,7 @@ fn loop1() {
let passes = vec![
Pass::Verify,
Pass::Forkify,
+ Pass::DCE,
Pass::Verify,
];
@@ -64,3 +65,72 @@ fn loop1() {
println!("{:?}, {:?}", result_1, result_2);
}
+#[test]
+fn loop_array_sum() {
+ let module = parse_file("../test_inputs/forkify/loop_array_sum.hir");
+ let len = 5;
+ let dyn_consts = [len];
+ let params = vec![1, 2, 3, 4, 5]; // TODO: (@xrouth) fix macro to take no params as an option.
+ let result_1 = interp_module!(module, dyn_consts, params.clone());
+
+ println!("result: {:?}", result_1);
+
+ let mut pm = hercules_opt::pass::PassManager::new(module.clone());
+
+ let passes = vec![
+ Pass::Verify,
+ Pass::Forkify,
+ Pass::DCE,
+ Pass::Verify,
+ ];
+
+ for pass in passes {
+ pm.add_pass(pass);
+ }
+ pm.run_passes();
+
+ let module = pm.get_module();
+ let result_2 = interp_module!(module, dyn_consts, params);
+ assert_eq!(result_1, result_2);
+ println!("{:?}, {:?}", result_1, result_2);
+}
+
+/** Nested loop 2 is 2 nested loops with different dyn var parameter dimensions.
+ * It is a add of 1 for each iteration, so the result should be dim1 x dim2
+ * The loop PHIs are structured such that on every outer iteration, inner loop increment is set to the running sum,
+ * Notice how there is no outer_var_inc.
+ *
+ * The alternative, seen in nested_loop1, is to intiailize the inner loop to 0 every time, and track
+ * the outer sum more separaetly.
+ *
+ * Idk what im yapping about.
+*/
+#[test]
+fn nested_loop2() {
+ let module = parse_file("../test_inputs/forkify/nested_loop2.hir");
+ let len = 5;
+ let dyn_consts = [5, 6];
+ let params = vec![1, 2, 3, 4, 5]; // TODO: (@xrouth) fix macro to take no params as an option.
+ let result_1 = interp_module!(module, dyn_consts, 2);
+
+ println!("result: {:?}", result_1);
+
+ let mut pm = hercules_opt::pass::PassManager::new(module.clone());
+
+ let passes = vec![
+ Pass::Verify,
+ Pass::Forkify,
+ Pass::DCE,
+ Pass::Verify,
+ ];
+
+ for pass in passes {
+ pm.add_pass(pass);
+ }
+ pm.run_passes();
+
+ let module = pm.get_module();
+ let result_2 = interp_module!(module, dyn_consts, 2);
+ assert_eq!(result_1, result_2);
+ println!("{:?}, {:?}", result_1, result_2);
+}
\ No newline at end of file
diff --git a/hercules_test/hercules_tests/tests/opt_tests.rs b/hercules_test/hercules_tests/tests/opt_tests.rs
index 256ab2ee..8bc0c745 100644
--- a/hercules_test/hercules_tests/tests/opt_tests.rs
+++ b/hercules_test/hercules_tests/tests/opt_tests.rs
@@ -109,7 +109,7 @@ fn gvn_example() {
fn sum_int() {
let module = parse_file("../test_inputs/sum_int1.hir");
- let size = 100;
+ let size = 2;
let dyn_consts = [size];
let mut vec = vec![0; size];
let mut rng = rand::thread_rng();
@@ -118,8 +118,12 @@ fn sum_int() {
*x = rng.gen::<i32>() / 100;
}
+ println!("{:?}", vec);
+
let result_1 = interp_module!(module, dyn_consts, vec.clone());
+ println!("{:?}", result_1);
+
let mut pm = hercules_opt::pass::PassManager::new(module.clone());
let passes = vec![
@@ -141,6 +145,8 @@ fn sum_int() {
let module = pm.get_module();
let result_2 = interp_module!(module, dyn_consts, vec);
+
+
assert_eq!(result_1, result_2)
}
diff --git a/hercules_test/test_inputs/fork_optimization/fork_fission.hir b/hercules_test/test_inputs/fork_transforms/fork_fission.hir
similarity index 100%
rename from hercules_test/test_inputs/fork_optimization/fork_fission.hir
rename to hercules_test/test_inputs/fork_transforms/fork_fission.hir
diff --git a/hercules_test/test_inputs/fork_optimization/fork_fusion.hir b/hercules_test/test_inputs/fork_transforms/fork_fusion.hir
similarity index 100%
rename from hercules_test/test_inputs/fork_optimization/fork_fusion.hir
rename to hercules_test/test_inputs/fork_transforms/fork_fusion.hir
diff --git a/hercules_test/test_inputs/fork_optimization/fork_interchange.hir b/hercules_test/test_inputs/fork_transforms/fork_interchange.hir
similarity index 100%
rename from hercules_test/test_inputs/fork_optimization/fork_interchange.hir
rename to hercules_test/test_inputs/fork_transforms/fork_interchange.hir
diff --git a/hercules_test/test_inputs/fork_optimization/phi_loop3.hir b/hercules_test/test_inputs/forkify/alternate_bounds.hir
similarity index 100%
rename from hercules_test/test_inputs/fork_optimization/phi_loop3.hir
rename to hercules_test/test_inputs/forkify/alternate_bounds.hir
diff --git a/hercules_test/test_inputs/fork_optimization/phi_loop2.hir b/hercules_test/test_inputs/forkify/broken_sum.hir
similarity index 74%
rename from hercules_test/test_inputs/fork_optimization/phi_loop2.hir
rename to hercules_test/test_inputs/forkify/broken_sum.hir
index 78cd129c..d15ef561 100644
--- a/hercules_test/test_inputs/fork_optimization/phi_loop2.hir
+++ b/hercules_test/test_inputs/forkify/broken_sum.hir
@@ -1,13 +1,14 @@
-fn loop<1>() -> u64
+fn sum<1>(a: array(i32, #0)) -> i32
zero_idx = constant(u64, 0)
one_idx = constant(u64, 1)
- zero_inc = constant(u64, 0)
+ zero_inc = constant(i32, 0)
bound = dynamic_constant(#0)
loop = region(start, if_true)
idx = phi(loop, zero_idx, idx_inc)
idx_inc = add(idx, one_idx)
red = phi(loop, zero_inc, red_add)
- red_add = add(red, idx)
+ read = read(a, position(idx))
+ red_add = add(red, read)
in_bounds = lt(idx, bound)
if = if(loop, in_bounds)
if_false = projection(if, 0)
diff --git a/hercules_test/test_inputs/forkify/loop_array_sum.hir b/hercules_test/test_inputs/forkify/loop_array_sum.hir
new file mode 100644
index 00000000..f9972b59
--- /dev/null
+++ b/hercules_test/test_inputs/forkify/loop_array_sum.hir
@@ -0,0 +1,16 @@
+fn sum<1>(a: array(i32, #0)) -> i32
+ zero_idx = constant(u64, 0)
+ one_idx = constant(u64, 1)
+ zero_inc = constant(i32, 0)
+ bound = dynamic_constant(#0)
+ loop = region(start, if_true)
+ idx = phi(loop, zero_idx, idx_inc)
+ idx_inc = add(idx, one_idx)
+ red = phi(loop, zero_inc, red_add)
+ read = read(a, position(idx))
+ red_add = add(red, read)
+ in_bounds = lt(idx, bound)
+ if = if(loop, in_bounds)
+ if_false = projection(if, 0)
+ if_true = projection(if, 1)
+ r = return(if_false, red)
\ No newline at end of file
diff --git a/hercules_test/test_inputs/fork_optimization/phi_loop0.hir b/hercules_test/test_inputs/forkify/loop_simple_iv.hir
similarity index 100%
rename from hercules_test/test_inputs/fork_optimization/phi_loop0.hir
rename to hercules_test/test_inputs/forkify/loop_simple_iv.hir
diff --git a/hercules_test/test_inputs/fork_optimization/phi_loop1.hir b/hercules_test/test_inputs/forkify/loop_sum.hir
similarity index 100%
rename from hercules_test/test_inputs/fork_optimization/phi_loop1.hir
rename to hercules_test/test_inputs/forkify/loop_sum.hir
diff --git a/hercules_test/test_inputs/forkify/nested_loop1.hir b/hercules_test/test_inputs/forkify/nested_loop1.hir
new file mode 100644
index 00000000..3e5dd77e
--- /dev/null
+++ b/hercules_test/test_inputs/forkify/nested_loop1.hir
@@ -0,0 +1,23 @@
+fn loop<2>(a: u32) -> i32
+ zero_idx = constant(u64, 0)
+ one_idx = constant(u64, 1)
+ zero_var = constant(i32, 0)
+ one_var = constant(i32, 1)
+ inner_bound = dynamic_constant(#0)
+ outer_bound = dynamic_constant(#0)
+ outer_loop = region(start, outer_if_true, inner_if_false)
+ inner_loop = region(outer_if_true, inner_if_true)
+ inner_var = phi(inner_loop, zero_var, inner_var_inc)
+ inner_var_inc = add(inner_var, one_var)
+ outer_var_inc = add(outer_var, one_var)
+ inner_idx = phi(loop, zero_idx, idx_inc)
+ inner_idx_inc = add(idx, one_idx)
+ inner_in_bounds = lt(idx, bound)
+ inner_if = if(loop, in_bounds)
+ inner_if_false = projection(inner_if, 0)
+ inner_if_true = projection(inner_if, 1)
+ outer_if_false = projection(outer_if, 0)
+ outer_if_true = projection(outer_if, 1)
+ outer_var = phi(outer_lop, zero_var, outer_var_inc, outer_var)
+
+ r = return(if_false, var_inc)
\ No newline at end of file
diff --git a/hercules_test/test_inputs/forkify/nested_loop2.hir b/hercules_test/test_inputs/forkify/nested_loop2.hir
new file mode 100644
index 00000000..0f29ec74
--- /dev/null
+++ b/hercules_test/test_inputs/forkify/nested_loop2.hir
@@ -0,0 +1,25 @@
+fn loop<2>(a: u32) -> i32
+ zero_idx = constant(u64, 0)
+ one_idx = constant(u64, 1)
+ zero_var = constant(i32, 0)
+ one_var = constant(i32, 1)
+ inner_bound = dynamic_constant(#0)
+ outer_bound = dynamic_constant(#1)
+ outer_loop = region(start, inner_if_false)
+ inner_loop = region(outer_if_true, inner_if_true)
+ outer_var = phi(outer_loop, zero_var, inner_var)
+ inner_var = phi(inner_loop, outer_var, inner_var_inc)
+ inner_var_inc = add(inner_var, one_var)
+ inner_idx = phi(inner_loop, zero_idx, inner_idx_inc)
+ inner_idx_inc = add(inner_idx, one_idx)
+ inner_in_bounds = lt(inner_idx, inner_bound)
+ outer_idx = phi(outer_loop, zero_idx, outer_idx_inc, outer_idx)
+ outer_idx_inc = add(outer_idx, one_idx)
+ outer_in_bounds = lt(outer_idx, outer_bound)
+ inner_if = if(inner_loop, inner_in_bounds)
+ inner_if_false = projection(inner_if, 0)
+ inner_if_true = projection(inner_if, 1)
+ outer_if = if(outer_loop, outer_in_bounds)
+ outer_if_false = projection(outer_if, 0)
+ outer_if_true = projection(outer_if, 1)
+ r = return(outer_if_false, outer_var)
\ No newline at end of file
diff --git a/hercules_test/test_inputs/forkify/nested_loop3.hir b/hercules_test/test_inputs/forkify/nested_loop3.hir
new file mode 100644
index 00000000..ebbe4360
--- /dev/null
+++ b/hercules_test/test_inputs/forkify/nested_loop3.hir
@@ -0,0 +1,25 @@
+fn loop<2>(a: u32) -> i32
+ zero_idx = constant(u64, 0)
+ one_idx = constant(u64, 1)
+ zero_var = constant(i32, 0)
+ one_var = constant(i32, 1)
+ inner_bound = dynamic_constant(#0)
+ outer_bound = dynamic_constant(#1)
+ outer_loop = region(start, outer_if_true, inner_if_false)
+ inner_loop = region(outer_if_true, inner_if_true)
+ outer_var = phi(outer_loop, zero_var, outer_var, inner_var)
+ inner_var = phi(inner_loop, outer_var, inner_var_inc)
+ inner_var_inc = add(inner_var, one_var)
+ inner_idx = phi(inner_loop, zero_idx, inner_idx_inc)
+ inner_idx_inc = add(inner_idx, one_idx)
+ inner_in_bounds = lt(inner_idx, inner_bound)
+ outer_idx = phi(outer_loop, zero_idx, outer_idx_inc, outer_idx)
+ outer_idx_inc = add(outer_idx, one_idx)
+ outer_in_bounds = lt(outer_idx, outer_bound)
+ inner_if = if(inner_loop, inner_in_bounds)
+ inner_if_false = projection(inner_if, 0)
+ inner_if_true = projection(inner_if, 1)
+ outer_if = if(outer_loop, outer_in_bounds)
+ outer_if_false = projection(outer_if, 0)
+ outer_if_true = projection(outer_if, 1)
+ r = return(outer_if_false, outer_var)
\ No newline at end of file
diff --git a/hercules_test/test_inputs/forkify/phi_loop4.hir b/hercules_test/test_inputs/forkify/phi_loop4.hir
new file mode 100644
index 00000000..e69ecc3d
--- /dev/null
+++ b/hercules_test/test_inputs/forkify/phi_loop4.hir
@@ -0,0 +1,16 @@
+fn loop<1>(a: u32) -> i32
+ zero_idx = constant(u64, 0)
+ one_idx = constant(u64, 1)
+ zero_var = constant(i32, 0)
+ one_var = constant(i32, 1)
+ bound = dynamic_constant(#0)
+ loop = region(start, if_true)
+ var = phi(loop, zero_var, var_inc)
+ var_inc = add(var, one_var)
+ idx = phi(loop, zero_idx, idx_inc)
+ idx_inc = add(idx, one_idx)
+ in_bounds = lt(idx, bound)
+ if = if(loop, in_bounds)
+ if_false = projection(if, 0)
+ if_true = projection(if, 1)
+ r = return(if_false, var_inc)
\ No newline at end of file
diff --git a/hercules_test/test_inputs/fork_optimization/tiling.hir b/hercules_test/test_inputs/forkify/tiling.hir
similarity index 100%
rename from hercules_test/test_inputs/fork_optimization/tiling.hir
rename to hercules_test/test_inputs/forkify/tiling.hir
diff --git a/hercules_test/test_inputs/fork_optimization/untiling.hir b/hercules_test/test_inputs/forkify/untiling.hir
similarity index 100%
rename from hercules_test/test_inputs/fork_optimization/untiling.hir
rename to hercules_test/test_inputs/forkify/untiling.hir
--
GitLab
From a696452b17addb2d599168bdbc3ec4cb06741b96 Mon Sep 17 00:00:00 2001
From: Xavier Routh <xrouth2@illinois.edu>
Date: Fri, 13 Dec 2024 13:23:03 -0600
Subject: [PATCH 08/68] params-bug?
---
Cargo.lock | 1 +
hercules_opt/src/pass.rs | 2 ++
hercules_test/hercules_interpreter/Cargo.toml | 3 +-
.../hercules_interpreter/src/interpreter.rs | 2 ++
hercules_test/hercules_interpreter/src/lib.rs | 9 ++++++
.../hercules_tests/tests/loop_tests.rs | 32 ++++++++++++++++++-
6 files changed, 47 insertions(+), 2 deletions(-)
diff --git a/Cargo.lock b/Cargo.lock
index da5aa8eb..3394bac3 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -638,6 +638,7 @@ dependencies = [
"hercules_opt",
"itertools",
"ordered-float",
+ "postcard",
"rand",
]
diff --git a/hercules_opt/src/pass.rs b/hercules_opt/src/pass.rs
index e7e0db69..9f05b677 100644
--- a/hercules_opt/src/pass.rs
+++ b/hercules_opt/src/pass.rs
@@ -872,6 +872,8 @@ impl PassManager {
println!("{:?}", self.manifests);
}
Pass::Serialize(output_file) => {
+ println!("param types: {:?}", self.module.functions[0].param_types);
+
let module_contents: Vec<u8> = postcard::to_allocvec(&self.module).unwrap();
let mut file = File::create(&output_file)
.expect("PANIC: Unable to open output module file.");
diff --git a/hercules_test/hercules_interpreter/Cargo.toml b/hercules_test/hercules_interpreter/Cargo.toml
index d41caff8..6bad1674 100644
--- a/hercules_test/hercules_interpreter/Cargo.toml
+++ b/hercules_test/hercules_interpreter/Cargo.toml
@@ -11,4 +11,5 @@ hercules_ir = { path = "../../hercules_ir" }
hercules_opt = { path = "../../hercules_opt" }
itertools = "*"
ordered-float = "*"
-derive_more = {version = "*", features = ["from"]}
\ No newline at end of file
+derive_more = {version = "*", features = ["from"]}
+postcard = { version = "*", features = ["alloc"] }
\ No newline at end of file
diff --git a/hercules_test/hercules_interpreter/src/interpreter.rs b/hercules_test/hercules_interpreter/src/interpreter.rs
index c98f5485..9b529fd9 100644
--- a/hercules_test/hercules_interpreter/src/interpreter.rs
+++ b/hercules_test/hercules_interpreter/src/interpreter.rs
@@ -103,6 +103,8 @@ impl<'a> FunctionExecutionState<'a> {
function_contexts: &'a Vec<FunctionContext>,
dynamic_constant_params: Vec<usize>,
) -> Self {
+ println!("param types: {:?}", module.functions[function_id.idx()].param_types);
+
assert_eq!(args.len(), module.functions[function_id.idx()].param_types.len());
FunctionExecutionState {
diff --git a/hercules_test/hercules_interpreter/src/lib.rs b/hercules_test/hercules_interpreter/src/lib.rs
index b67b2ca4..ca4b5447 100644
--- a/hercules_test/hercules_interpreter/src/lib.rs
+++ b/hercules_test/hercules_interpreter/src/lib.rs
@@ -1,7 +1,9 @@
pub mod interpreter;
pub mod value;
+extern crate postcard;
use std::fs::File;
+use std::io::Read;
use hercules_ir::Module;
use hercules_ir::TypeID;
@@ -86,6 +88,13 @@ pub fn parse_file(path: &str) -> Module {
module
}
+pub fn parse_module_from_hbin(path: &str) -> hercules_ir::ir::Module {
+ let mut file = File::open(path).expect("PANIC: Unable to open input file.");
+ let mut buffer = vec![];
+ file.read_to_end(&mut buffer).unwrap();
+ postcard::from_bytes(&buffer).unwrap()
+}
+
#[macro_export]
macro_rules! interp_module {
($module:ident, $dynamic_constants:expr, $($args:expr), *) => {
diff --git a/hercules_test/hercules_tests/tests/loop_tests.rs b/hercules_test/hercules_tests/tests/loop_tests.rs
index dcbdd458..15058b58 100644
--- a/hercules_test/hercules_tests/tests/loop_tests.rs
+++ b/hercules_test/hercules_tests/tests/loop_tests.rs
@@ -1,4 +1,4 @@
-use std::env;
+use std::{env, fs::File, io::Read, path::Path};
use hercules_interpreter::*;
use hercules_opt::pass::Pass;
@@ -129,6 +129,36 @@ fn nested_loop2() {
}
pm.run_passes();
+ let module = pm.get_module();
+ let result_2 = interp_module!(module, dyn_consts, 2);
+ assert_eq!(result_1, result_2);
+ println!("{:?}, {:?}", result_1, result_2);
+}
+
+#[test]
+fn interpret_temp() {
+ let module = parse_module_from_hbin("../../a.hbin");
+ let len = 5;
+ let dyn_consts = [5, 6];
+ let params = vec![1, 2, 3, 4, 5]; // TODO: (@xrouth) fix macro to take no params as an option.
+ let result_1 = interp_module!(module, dyn_consts, 2);
+
+ println!("result: {:?}", result_1);
+
+ let mut pm = hercules_opt::pass::PassManager::new(module.clone());
+
+ let passes = vec![
+ Pass::Verify,
+ Pass::Forkify,
+ Pass::DCE,
+ Pass::Verify,
+ ];
+
+ for pass in passes {
+ pm.add_pass(pass);
+ }
+ pm.run_passes();
+
let module = pm.get_module();
let result_2 = interp_module!(module, dyn_consts, 2);
assert_eq!(result_1, result_2);
--
GitLab
From ab1560d3e29aca90b17db8eb50fd571fa5638ed6 Mon Sep 17 00:00:00 2001
From: Xavier Routh <xrouth2@illinois.edu>
Date: Fri, 13 Dec 2024 14:46:14 -0600
Subject: [PATCH 09/68] nested loop
---
hercules_opt/src/forkify.rs | 76 +++++++++++--------
hercules_opt/src/pass.rs | 2 -
.../hercules_tests/tests/loop_tests.rs | 20 ++++-
3 files changed, 64 insertions(+), 34 deletions(-)
diff --git a/hercules_opt/src/forkify.rs b/hercules_opt/src/forkify.rs
index ab31c66a..9482a1d4 100644
--- a/hercules_opt/src/forkify.rs
+++ b/hercules_opt/src/forkify.rs
@@ -156,45 +156,51 @@ pub fn forkify_loop(
let function = editor.func();
// Get the control portions of the loop that need to be grafted.
- let loop_true_projection = editor.get_uses(header)
- .filter(|id| body[id.idx()])
+ let loop_exit_projection = editor.get_users(loop_condition)
+ .filter(|id| !body[id.idx()])
.next()
.unwrap();
- let loop_end = function.nodes[loop_true_projection.idx()]
- .try_projection(1)
- .unwrap();
- let loop_false_projection = editor.get_users(loop_end)
- .filter_map(|id| {
- if function.nodes[id.idx()].try_projection(0).is_some() {
- Some(id)
- } else {
- None
- }
- })
+
+ let loop_continue_projection = editor.get_users(loop_condition)
+ .filter(|id| body[id.idx()])
.next()
.unwrap();
- let loop_end_uses: Vec<_> = editor.get_uses(loop_end).collect();
- let loop_end = function.nodes[loop_end.idx()].clone();
+ let header_uses: Vec<_> = editor.get_uses(header).collect();
+ println!("editor uses header {:?}: {:?}", header, header_uses );
+
+ // Last control in loop body before join.
+ // FIXME: We are assuming there is only one.
+ let loop_body_last = editor.get_uses(header)
+ .filter(|id| body[id.idx()])
+ .next()
+ .unwrap();
+
+ println!("loop_body_last: {:?} ", loop_body_last);
// Create fork and join nodes:
let mut join_id = NodeID::new(0);
let mut fork_id = NodeID::new(0);
+ // If there is control between continue projection and header, attach join to last thing before header:
+
+ // If there is control between header and loop conition: BLARGH
+
+ // FIXME (@xrouth), handle control in loop body.
editor.edit(
|mut edit| {
let fork = Node::Fork { control: loop_pred, factors: Box::new([bound_dc_id])};
fork_id = edit.add_node(fork);
- // If there is no control between loop_end and header, attach join to header
- // If there is control, attach join to the control.
+
let join = Node::Join {
- control: if header == loop_end_uses[0] {
+ control: if loop_continue_projection == loop_body_last {
fork_id
} else {
- loop_end.try_if().unwrap().0
+ loop_body_last
},
};
+
join_id = edit.add_node(join);
Ok(edit)
@@ -204,16 +210,18 @@ pub fn forkify_loop(
let function = editor.func();
let induction_variable = basic_ivs.iter().find(|v| iv == **v).unwrap();
- // If there are uses of the IV that aren't PHIs controlled by the header,
+ let header_uses: Vec<_> = editor.get_uses(header).collect();
+ println!("editor uses header {:?}: {:?}", header, header_uses );
+
let update = *zip(
- editor.get_uses(header),
- function.nodes[induction_variable.node.idx()]
- .try_phi()
- .unwrap()
- .1
- .iter(),
+ editor.get_uses(header),
+ function.nodes[induction_variable.node.idx()]
+ .try_phi()
+ .unwrap()
+ .1
+ .iter(),
)
- .filter(|(c, _)| *c == loop_true_projection)
+ .filter(|(c, _)| *c == loop_body_last)
.next()
.unwrap()
.1;
@@ -283,7 +291,7 @@ pub fn forkify_loop(
.1
.iter(),
)
- .filter(|(c, _)| *c == loop_true_projection)
+ .filter(|(c, _)| *c == loop_body_last)
.next()
.unwrap()
.1;
@@ -311,7 +319,13 @@ pub fn forkify_loop(
editor.edit(
|mut edit| {
- edit.replace_all_uses(loop_false_projection, join_id)
+ edit.replace_all_uses(loop_continue_projection, fork_id)
+ }
+ );
+
+ editor.edit(
+ |mut edit| {
+ edit.replace_all_uses(loop_exit_projection, join_id)
}
);
@@ -319,9 +333,9 @@ pub fn forkify_loop(
// DCE should get these, but delete them ourselves because we are nice :)
editor.edit(
|mut edit| {
- edit = edit.delete_node(loop_false_projection)?;
+ edit = edit.delete_node(loop_continue_projection)?;
// edit = edit.delete_node(loop_false_read)?;
- edit = edit.delete_node(loop_true_projection)?;
+ edit = edit.delete_node(loop_exit_projection)?;
edit = edit.delete_node(loop_condition)?; // Delet ethe if.
edit = edit.delete_node(header)?;
Ok(edit)
diff --git a/hercules_opt/src/pass.rs b/hercules_opt/src/pass.rs
index 9f05b677..e7e0db69 100644
--- a/hercules_opt/src/pass.rs
+++ b/hercules_opt/src/pass.rs
@@ -872,8 +872,6 @@ impl PassManager {
println!("{:?}", self.manifests);
}
Pass::Serialize(output_file) => {
- println!("param types: {:?}", self.module.functions[0].param_types);
-
let module_contents: Vec<u8> = postcard::to_allocvec(&self.module).unwrap();
let mut file = File::create(&output_file)
.expect("PANIC: Unable to open output module file.");
diff --git a/hercules_test/hercules_tests/tests/loop_tests.rs b/hercules_test/hercules_tests/tests/loop_tests.rs
index 15058b58..2a938c70 100644
--- a/hercules_test/hercules_tests/tests/loop_tests.rs
+++ b/hercules_test/hercules_tests/tests/loop_tests.rs
@@ -132,7 +132,25 @@ fn nested_loop2() {
let module = pm.get_module();
let result_2 = interp_module!(module, dyn_consts, 2);
assert_eq!(result_1, result_2);
- println!("{:?}, {:?}", result_1, result_2);
+
+ let mut pm = hercules_opt::pass::PassManager::new(module.clone());
+
+ let passes = vec![
+ Pass::Verify,
+ Pass::Forkify,
+ Pass::DCE,
+ Pass::Verify,
+ ];
+
+ for pass in passes {
+ pm.add_pass(pass);
+ }
+ pm.run_passes();
+
+ let module = pm.get_module();
+ let result_3 = interp_module!(module, dyn_consts, 2);
+
+ println!("{:?}, {:?}, {:?}", result_1, result_2, result_3);
}
#[test]
--
GitLab
From 72557ba0b6adb2cd4053c750df5990c6dc966ea7 Mon Sep 17 00:00:00 2001
From: Xavier Routh <xrouth2@illinois.edu>
Date: Fri, 13 Dec 2024 17:17:20 -0600
Subject: [PATCH 10/68] loop control tests
---
hercules_opt/src/forkify.rs | 3 ---
.../hercules_tests/tests/opt_tests.rs | 2 +-
.../forkify/control_after_condition.hir | 25 +++++++++++++++++++
.../forkify/control_before_condition.hir | 25 +++++++++++++++++++
4 files changed, 51 insertions(+), 4 deletions(-)
create mode 100644 hercules_test/test_inputs/forkify/control_after_condition.hir
create mode 100644 hercules_test/test_inputs/forkify/control_before_condition.hir
diff --git a/hercules_opt/src/forkify.rs b/hercules_opt/src/forkify.rs
index 9482a1d4..ad6ff6bc 100644
--- a/hercules_opt/src/forkify.rs
+++ b/hercules_opt/src/forkify.rs
@@ -169,8 +169,6 @@ pub fn forkify_loop(
let header_uses: Vec<_> = editor.get_uses(header).collect();
println!("editor uses header {:?}: {:?}", header, header_uses );
- // Last control in loop body before join.
- // FIXME: We are assuming there is only one.
let loop_body_last = editor.get_uses(header)
.filter(|id| body[id.idx()])
.next()
@@ -183,7 +181,6 @@ pub fn forkify_loop(
let mut fork_id = NodeID::new(0);
// If there is control between continue projection and header, attach join to last thing before header:
-
// If there is control between header and loop conition: BLARGH
// FIXME (@xrouth), handle control in loop body.
diff --git a/hercules_test/hercules_tests/tests/opt_tests.rs b/hercules_test/hercules_tests/tests/opt_tests.rs
index 8bc0c745..222f1e83 100644
--- a/hercules_test/hercules_tests/tests/opt_tests.rs
+++ b/hercules_test/hercules_tests/tests/opt_tests.rs
@@ -154,7 +154,7 @@ fn sum_int() {
fn sum_int2() {
let module = parse_file("../test_inputs/sum_int2.hir");
- let size = 100;
+ let size = 0;
let dyn_consts = [size];
let mut vec = vec![0; size];
let mut rng = rand::thread_rng();
diff --git a/hercules_test/test_inputs/forkify/control_after_condition.hir b/hercules_test/test_inputs/forkify/control_after_condition.hir
new file mode 100644
index 00000000..db40225b
--- /dev/null
+++ b/hercules_test/test_inputs/forkify/control_after_condition.hir
@@ -0,0 +1,25 @@
+fn alt_sum<1>(a: array(i32, #0)) -> i32
+ zero_idx = constant(u64, 0)
+ one_idx = constant(u64, 1)
+ two_idx = constant(u64, 2)
+ zero_inc = constant(i32, 0)
+ bound = dynamic_constant(#0)
+ loop = region(start, negate_bottom)
+ idx = phi(loop, zero_idx, idx_inc)
+ idx_inc = add(idx, one_idx)
+ red = phi(loop, zero_inc, red_add)
+ rem = rem(idx, two_idx)
+ odd = eq(rem, one_idx)
+ negate_if = if(loop_continue, odd)
+ negate_if_false = projection(negate_if, 0)
+ negate_if_true = projection(negate_if, 1)
+ negate_bottom = region(negate_if_false, negate_if_true)
+ read = read(a, position(idx))
+ read_neg = neg(read)
+ read_phi = phi(negate_bottom, read, read_neg)
+ red_add = add(red, read_phi)
+ in_bounds = lt(idx, bound)
+ if = if(loop, in_bounds)
+ loop_exit = projection(if, 0)
+ loop_continue = projection(if, 1)
+ r = return(loop_exit, red)
\ No newline at end of file
diff --git a/hercules_test/test_inputs/forkify/control_before_condition.hir b/hercules_test/test_inputs/forkify/control_before_condition.hir
new file mode 100644
index 00000000..f24b565a
--- /dev/null
+++ b/hercules_test/test_inputs/forkify/control_before_condition.hir
@@ -0,0 +1,25 @@
+fn alt_sum<1>(a: array(i32, #0)) -> i32
+ zero_idx = constant(u64, 0)
+ one_idx = constant(u64, 1)
+ two_idx = constant(u64, 2)
+ zero_inc = constant(i32, 0)
+ bound = dynamic_constant(#0)
+ loop = region(start, if_true)
+ idx = phi(loop, zero_idx, idx_inc)
+ idx_inc = add(idx, one_idx)
+ red = phi(loop, zero_inc, red_add)
+ rem = rem(idx, two_idx)
+ odd = eq(rem, one_idx)
+ negate_if = if(loop, odd)
+ negate_if_false = projection(negate_if, 0)
+ negate_if_true = projection(negate_if, 1)
+ negate_bottom = region(negate_if_false, negate_if_true)
+ read = read(a, position(idx))
+ read_neg = neg(read)
+ read_phi = phi(negate_bottom, read, read_neg)
+ red_add = add(red, read_phi)
+ in_bounds = lt(idx, bound)
+ if = if(negate_bottom, in_bounds)
+ if_false = projection(if, 0)
+ if_true = projection(if, 1)
+ r = return(if_false, red)
\ No newline at end of file
--
GitLab
From 44fe6e2ae7951bd178eeda720ab5b2c77ae6a8e9 Mon Sep 17 00:00:00 2001
From: Xavier Routh <xrouth2@illinois.edu>
Date: Fri, 13 Dec 2024 17:31:31 -0600
Subject: [PATCH 11/68] loop control tests
---
.../hercules_tests/tests/loop_tests.rs | 85 ++++++++++++++++++-
.../hercules_tests/tests/opt_tests.rs | 2 +-
2 files changed, 85 insertions(+), 2 deletions(-)
diff --git a/hercules_test/hercules_tests/tests/loop_tests.rs b/hercules_test/hercules_tests/tests/loop_tests.rs
index 2a938c70..13ae76e0 100644
--- a/hercules_test/hercules_tests/tests/loop_tests.rs
+++ b/hercules_test/hercules_tests/tests/loop_tests.rs
@@ -134,7 +134,7 @@ fn nested_loop2() {
assert_eq!(result_1, result_2);
let mut pm = hercules_opt::pass::PassManager::new(module.clone());
-
+
let passes = vec![
Pass::Verify,
Pass::Forkify,
@@ -181,4 +181,87 @@ fn interpret_temp() {
let result_2 = interp_module!(module, dyn_consts, 2);
assert_eq!(result_1, result_2);
println!("{:?}, {:?}", result_1, result_2);
+}
+
+
+/**
+ * Tests forkify on a loop where there is control in between the continue projection
+ * and the header. aka control *after* the `loop condition / guard`. This should forkify.
+ */
+#[test]
+fn control_after_condition() {
+ let module = parse_file("../test_inputs/forkify/control_after_condition.hir");
+
+ let size = 10;
+ let dyn_consts = [size];
+ let mut vec = vec![0; size];
+ let mut rng = rand::thread_rng();
+
+ for x in vec.iter_mut() {
+ *x = rng.gen::<i32>() / 100;
+ }
+
+ let result_1 = interp_module!(module, dyn_consts, vec.clone());
+
+ println!("result: {:?}", result_1);
+
+ let mut pm = hercules_opt::pass::PassManager::new(module.clone());
+
+ let passes = vec![
+ Pass::Verify,
+ Pass::Forkify,
+ Pass::DCE,
+ Pass::Verify,
+ ];
+
+ for pass in passes {
+ pm.add_pass(pass);
+ }
+ pm.run_passes();
+
+ let module = pm.get_module();
+ let result_2 = interp_module!(module, dyn_consts, vec);
+ assert_eq!(result_1, result_2);
+
+}
+
+/**
+ * Tests forkify on a loop where there is control before the loop condition, so in between the header
+ * and the loop condition. This should not forkify.
+ */
+#[test]
+fn control_before_condition() {
+ let module = parse_file("../test_inputs/forkify/control_before_condition.hir");
+
+ let size = 10;
+ let dyn_consts = [size];
+ let mut vec = vec![0; size];
+ let mut rng = rand::thread_rng();
+
+ for x in vec.iter_mut() {
+ *x = rng.gen::<i32>() / 100;
+ }
+
+ let result_1 = interp_module!(module, dyn_consts, vec.clone());
+
+ println!("result: {:?}", result_1);
+
+ let mut pm = hercules_opt::pass::PassManager::new(module.clone());
+
+ let passes = vec![
+ Pass::Verify,
+ Pass::Forkify,
+ Pass::DCE,
+ Pass::Verify,
+ ];
+
+ for pass in passes {
+ pm.add_pass(pass);
+ }
+ pm.run_passes();
+
+ let module = pm.get_module();
+ let result_2 = interp_module!(module, dyn_consts, vec);
+ assert_eq!(result_1, result_2);
+
}
\ No newline at end of file
diff --git a/hercules_test/hercules_tests/tests/opt_tests.rs b/hercules_test/hercules_tests/tests/opt_tests.rs
index 222f1e83..0cb902a8 100644
--- a/hercules_test/hercules_tests/tests/opt_tests.rs
+++ b/hercules_test/hercules_tests/tests/opt_tests.rs
@@ -154,7 +154,7 @@ fn sum_int() {
fn sum_int2() {
let module = parse_file("../test_inputs/sum_int2.hir");
- let size = 0;
+ let size = 10;
let dyn_consts = [size];
let mut vec = vec![0; size];
let mut rng = rand::thread_rng();
--
GitLab
From 63788ff52f0fba21fe788de8b26ab23d0588d6c0 Mon Sep 17 00:00:00 2001
From: Xavier Routh <xrouth2@illinois.edu>
Date: Fri, 13 Dec 2024 22:15:02 -0600
Subject: [PATCH 12/68] n-dim reductions?
---
Cargo.lock | 37 +++
hercules_opt/Cargo.toml | 1 +
hercules_opt/src/forkify.rs | 235 +++++++++++++-----
hercules_opt/src/ivar.rs | 74 +++++-
hercules_opt/src/pass.rs | 3 +
.../hercules_interpreter/src/interpreter.rs | 1 +
6 files changed, 276 insertions(+), 75 deletions(-)
diff --git a/Cargo.lock b/Cargo.lock
index 3394bac3..513272c6 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -662,6 +662,7 @@ dependencies = [
"hercules_cg",
"hercules_ir",
"itertools",
+ "nestify",
"ordered-float",
"postcard",
"serde",
@@ -964,6 +965,18 @@ version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
+[[package]]
+name = "nestify"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41d7249f7122d4e8a40f3b1b1850b763d2f864bf8e4b712427f024f8a167ea17"
+dependencies = [
+ "proc-macro-error",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.79",
+]
+
[[package]]
name = "nom"
version = "7.1.3"
@@ -1169,6 +1182,30 @@ dependencies = [
"zerocopy",
]
+[[package]]
+name = "proc-macro-error"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da25490ff9892aab3fcf7c36f08cfb902dd3e71ca0f9f9517bea02a73a5ce38c"
+dependencies = [
+ "proc-macro-error-attr",
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+ "version_check",
+]
+
+[[package]]
+name = "proc-macro-error-attr"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1be40180e52ecc98ad80b184934baf3d0d29f979574e439af5a55274b35f869"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "version_check",
+]
+
[[package]]
name = "proc-macro2"
version = "1.0.86"
diff --git a/hercules_opt/Cargo.toml b/hercules_opt/Cargo.toml
index 1ca4ae6a..d91b49f0 100644
--- a/hercules_opt/Cargo.toml
+++ b/hercules_opt/Cargo.toml
@@ -14,3 +14,4 @@ postcard = { version = "*", features = ["alloc"] }
serde = { version = "*", features = ["derive"] }
hercules_cg = { path = "../hercules_cg" }
hercules_ir = { path = "../hercules_ir" }
+nestify = "*"
diff --git a/hercules_opt/src/forkify.rs b/hercules_opt/src/forkify.rs
index ad6ff6bc..b2c2d2d0 100644
--- a/hercules_opt/src/forkify.rs
+++ b/hercules_opt/src/forkify.rs
@@ -1,6 +1,7 @@
extern crate hercules_ir;
extern crate bitvec;
+use std::collections::HashMap;
use std::iter::zip;
use self::bitvec::vec::BitVec;
@@ -14,6 +15,7 @@ use crate::compute_induction_vars;
use crate::compute_loop_bounds;
use crate::compute_loop_variance;
use crate::FunctionEditor;
+use crate::ReductionablePHI;
use self::hercules_ir::def_use::*;
use self::hercules_ir::ir::*;
@@ -22,6 +24,7 @@ use self::hercules_ir::loops::*;
pub fn forkify(
editor: &mut FunctionEditor,
control_subgraph: &Subgraph,
+ fork_join_map: &HashMap<NodeID, NodeID>,
loops: &LoopTree,
) -> () {
println!("loops: {:?} ", loops.bottom_up_loops());
@@ -34,10 +37,12 @@ pub fn forkify(
let natural_loops: Vec<_> = natural_loops.collect();
for l in natural_loops {
- forkify_loop(editor, control_subgraph, l);
+ forkify_loop(editor, control_subgraph, fork_join_map, l);
break; //TODO: REMOVE ME
}
}
+
+
/*
* Top level function to convert natural loops with simple induction variables
* into fork-joins.
@@ -45,6 +50,7 @@ pub fn forkify(
pub fn forkify_loop(
editor: &mut FunctionEditor,
control_subgraph: &Subgraph,
+ fork_join_map: &HashMap<NodeID, NodeID>,
looop: (NodeID, &BitVec<u8>),
) -> () {
@@ -84,16 +90,19 @@ pub fn forkify_loop(
};
// Check reductionable phis, only PHIs depending on the loop are considered,
- // this is how we avoid reductions that depend on control flow.
- let candidate_phis: Vec<_> = editor
- .get_users(header)
+ // CHECK ME: this is how we avoid reductions that depend on control flow?
+ let candidate_phis: Vec<_> = editor.get_users(header)
.filter(|id|function.nodes[id.idx()].is_phi())
+ .filter(|id| *id != iv.node)
.collect();
- let reductionable_phis = check_reductionable_phis(function, &editor, &control_subgraph, &loop_nodes,
- &basic_ivs, &loop_variance, &candidate_phis);
-
-
+ // Check if the reductionable phi is in a cycle with a reduce, if it is, we probably have to make a multi-dimensional fork.
+ // FIXME: You can actually just pattern match, you shouldn't try to handle expresions inbetween reductions.
+ let reductionable_phis: Vec<_> = check_reductionable_phis(function, &editor, &control_subgraph, &loop_nodes,
+ &basic_ivs, &loop_variance, &candidate_phis).into_iter().collect();
+
+ // TODO: Check that *all* phis are reductionable. If they aren't, we can't forkify without splitting the loop.
+
// Check for a constant used as loop bound.
let bound_dc_id =
if let Some(bound_dc_id) = function.nodes[bound.idx()].try_dynamic_constant() {
@@ -176,6 +185,21 @@ pub fn forkify_loop(
println!("loop_body_last: {:?} ", loop_body_last);
+ // Check if we need to make an NDimensional Fork + Join
+ // If we do, we do the following:
+ // - We need to make a new reduce for each NDimensional reductionable PHI.
+ // - The reduce is a combination of the reduce it is in a cycle with, and the reductionable PHI.
+ // - We need to update the fork bounds to add an outer dimension that is this loops bounds
+ // - We need to create a new threadID (this is easy actually, its the same as the non-fused case. )
+
+ // What happens if only some of the reductionable phis are n dimensions...
+
+ // I think we want basic loop splitting.
+
+ // For now, all PHIs besides the indcution variable must be ndimensionalable
+ let make_n_dims = reductionable_phis.iter()
+ .all(|phi| matches!(phi, ReductionablePHI::NDimensional { phi_node, reduction_node }));
+
// Create fork and join nodes:
let mut join_id = NodeID::new(0);
let mut fork_id = NodeID::new(0);
@@ -183,26 +207,60 @@ pub fn forkify_loop(
// If there is control between continue projection and header, attach join to last thing before header:
// If there is control between header and loop conition: BLARGH
- // FIXME (@xrouth), handle control in loop body.
- editor.edit(
- |mut edit| {
- let fork = Node::Fork { control: loop_pred, factors: Box::new([bound_dc_id])};
- fork_id = edit.add_node(fork);
-
-
- let join = Node::Join {
- control: if loop_continue_projection == loop_body_last {
- fork_id
- } else {
- loop_body_last
- },
- };
+ // FIXME (@xrouth): Check for this:
+ // If there is any complicated control either, then don't make it n-dimensional
+ // 1) between the continue projection and the fork
+ // 2) bewteen the header and the loop condition
+ // but not
+ // 3) in between the inner fork and join. (control here is okay), because we don't have to deal with it.
+
+ if make_n_dims {
+ // Find the inner fork / join,
+ let inner_fork = editor.get_users(loop_continue_projection).next().unwrap();
+ let inner_join = fork_join_map[&inner_fork];
+ let (_, fork_dimensions) = function.nodes[inner_fork.idx()].try_fork().unwrap();
+
+ let mut new_factors = vec![bound_dc_id];
+ new_factors.append(& mut fork_dimensions.to_vec()); // FIXME: Might need to be added the other way.
+ // '0' is innermost dimension.
+
+ join_id = inner_join;
+ fork_id = inner_fork;
+
+ // I don't actually think you have to convert the ThreadIDs
+ editor.edit(
+ |mut edit| {
+ let new_fork = Node::Fork {control: loop_pred, factors: new_factors.into()};
- join_id = edit.add_node(join);
+ fork_id = edit.add_node(new_fork);
+ edit = edit.replace_all_uses(inner_fork, fork_id)?;
+ edit = edit.delete_node(inner_fork)?;
- Ok(edit)
- }
- );
+ Ok(edit)
+ }
+ );
+
+ } else {
+ // FIXME (@xrouth), handle control in loop body.
+ editor.edit(
+ |mut edit| {
+ let fork = Node::Fork { control: loop_pred, factors: Box::new([bound_dc_id])};
+ fork_id = edit.add_node(fork);
+
+ let join = Node::Join {
+ control: if loop_continue_projection == loop_body_last {
+ fork_id
+ } else {
+ loop_body_last
+ },
+ };
+
+ join_id = edit.add_node(join);
+
+ Ok(edit)
+ }
+ );
+ }
let function = editor.func();
let induction_variable = basic_ivs.iter().find(|v| iv == **v).unwrap();
@@ -223,12 +281,16 @@ pub fn forkify_loop(
.unwrap()
.1;
+ let (_, factors) = function.nodes[fork_id.idx()].try_fork().unwrap();
+ let factors = factors.len() - 1;
+
// Create ThreadID
+ // FIXME: Fix this for n-dimensional things.
editor.edit(
|mut edit| {
let thread_id = Node::ThreadID {
control: fork_id,
- dimension: 0,
+ dimension: factors,
};
let thread_id_id = edit.add_node(thread_id);
@@ -253,58 +315,93 @@ pub fn forkify_loop(
}
);
- // - a) If the PHI is the IV:
- // Uses of the IV become:
- // 1) Inside the loop: Uses of the ThreadID
- // 2) Outside the loop: Uses of the reduction node.
+ if make_n_dims {
+ for reduction_phi in reductionable_phis {
+ let ReductionablePHI::NDimensional { phi_node, reduction_node } = reduction_phi else {
+ panic!();
+ };
- for reduction_phi in reductionable_phis {
- // Special case this, we handle the IV differently.
- if reduction_phi == induction_variable.node {
- continue;
- }
+ // Delete the phi, replace uses of it with the reduction
+ // FIXME: Wtf happens with the initializer? What is the condition here ig.
- let function = editor.func();
+ let function = editor.func();
+ let (control, init, reduct) = function.nodes[reduction_node.idx()].try_reduce().unwrap();
- let init = *zip(
- editor.get_uses(header),
- function.nodes[reduction_phi.idx()]
- .try_phi()
- .unwrap()
- .1
- .iter(),
+ let phi_init = *zip(
+ editor.get_uses(header),
+ function.nodes[phi_node.idx()]
+ .try_phi()
+ .unwrap()
+ .1
+ .iter(),
)
.filter(|(c, _)| *c == loop_pred)
.next()
.unwrap()
.1;
-
- // Loop back edge input to phi is the reduction update expression.
- let update = *zip(
- editor.get_uses(header),
- function.nodes[reduction_phi.idx()]
- .try_phi()
+
+ editor.edit(
+ |mut edit| {
+
+ // Set the reduction node to be the same, just move its initailizer to the PHI's intiailizer.
+ let reduce_node = Node::Reduce { control, init: phi_init, reduct };
+ let reduce_id = edit.add_node(reduce_node);
+ edit = edit.replace_all_uses(reduction_node, reduce_id)?;
+ edit = edit.replace_all_uses(phi_node, reduce_id)?;
+ edit.delete_node(phi_node)
+ }
+ );
+ }
+ } else {
+ // - a) If the PHI is the IV:
+ // Uses of the IV become:
+ // 1) Inside the loop: Uses of the ThreadID
+ // 2) Outside the loop: Uses of the reduction node.
+ for reduction_phi in reductionable_phis {
+ let reduction_phi = reduction_phi.get_phi();
+
+ let function = editor.func();
+
+ let init = *zip(
+ editor.get_uses(header),
+ function.nodes[reduction_phi.idx()]
+ .try_phi()
+ .unwrap()
+ .1
+ .iter(),
+ )
+ .filter(|(c, _)| *c == loop_pred)
+ .next()
.unwrap()
- .1
- .iter(),
- )
- .filter(|(c, _)| *c == loop_body_last)
- .next()
- .unwrap()
- .1;
-
- editor.edit(
- |mut edit| {
- let reduce = Node::Reduce {
- control: join_id,
- init,
- reduct: update,
- };
- let reduce_id = edit.add_node(reduce);
+ .1;
+
+ // Loop back edge input to phi is the reduction update expression.
+ let update = *zip(
+ editor.get_uses(header),
+ function.nodes[reduction_phi.idx()]
+ .try_phi()
+ .unwrap()
+ .1
+ .iter(),
+ )
+ .filter(|(c, _)| *c == loop_body_last)
+ .next()
+ .unwrap()
+ .1;
- edit.replace_all_uses(reduction_phi, reduce_id)
- }
- );
+ editor.edit(
+ |mut edit| {
+ let reduce = Node::Reduce {
+ control: join_id,
+ init,
+ reduct: update,
+ };
+ let reduce_id = edit.add_node(reduce);
+
+ edit.replace_all_uses(reduction_phi, reduce_id)
+ }
+ );
+ }
}
// Replace all uses of the loop header with the fork
diff --git a/hercules_opt/src/ivar.rs b/hercules_opt/src/ivar.rs
index a04a29ee..98d98f08 100644
--- a/hercules_opt/src/ivar.rs
+++ b/hercules_opt/src/ivar.rs
@@ -1,9 +1,12 @@
extern crate hercules_ir;
extern crate slotmap;
extern crate bitvec;
+extern crate nestify;
use std::collections::{BTreeMap, HashMap, VecDeque};
+use self::nestify::nest;
+
use self::hercules_ir::Subgraph;
use self::bitvec::order::Lsb0;
@@ -128,6 +131,28 @@ pub fn compute_loop_variance(function: &Function, loop_nodes: &(BitVec<u8, Lsb0>
return LoopVarianceInfo { loop_header: *loop_header, map: variance_map };
}
+
+nest! {
+ #[derive(Debug)]
+ pub enum ReductionablePHI {
+ Normal(NodeID),
+ NDimensional {
+ phi_node: NodeID,
+ reduction_node: NodeID
+ }
+ }
+}
+
+impl ReductionablePHI {
+ pub fn get_phi(&self) -> NodeID {
+ match self {
+ ReductionablePHI::Normal(node_id) => *node_id,
+ ReductionablePHI::NDimensional { phi_node, reduction_node } => *phi_node,
+ }
+ }
+}
+
+
/** To convert a phi into a reduce we need to check that every cycle containing the PHI does not contain any other PHI.
* I think this restriction can be loosened (more specified)
* - Every cycle *in the loop* containing the PHI does not contain any other PHI. Or something, IDK.
@@ -136,17 +161,18 @@ pub fn compute_loop_variance(function: &Function, loop_nodes: &(BitVec<u8, Lsb0>
pub fn check_reductionable_phis(function: &Function, editor: &FunctionEditor, control_subgraph: &Subgraph,
loop_nodes: &(BitVec<u8, Lsb0>, NodeID), induction_vars: &[BasicInductionVariable],
loop_variance: &LoopVarianceInfo, phis: &[NodeID])
- -> impl IntoIterator<Item = NodeID>
+ -> impl IntoIterator<Item = ReductionablePHI>
{
// FIXME: (@xrouth)
// Check that the PHI actually has a cycle back to it.
-
let mut reductionable_phis: Vec<NodeID> = vec![];
for phi in phis {
// do WFS
let mut other_phi_on_path: DenseNodeMap<bool> = vec![false; function.nodes.len()];
+ // let mut reduce_on_path: DenseNodeMap<Option<NodeID>> = vec![None; function.nodes.len()];
+
let mut bag_of_control_nodes: Vec<NodeID> = vec![*phi];
let mut visited: DenseNodeMap<bool> = vec![false; function.nodes.len()];
@@ -162,8 +188,12 @@ pub fn check_reductionable_phis(function: &Function, editor: &FunctionEditor, co
other_phi_on_path[node.idx()] = true;
}
+ // if function.nodes[node.idx()].is_reduce() {
+ // reduce_on_path[node.idx()] = Some(node);
+ // }
+
// Get node's users or users of node?. I concede that these actually are the same thing.
- // IT is NOT OBVIOSU THOUGH! rename plz? get_users_of()?
+ // IT is NOT OBVIOUS THOUGH! rename plz? get_users_of()?
for succ in editor.get_users(node) {
// If we change, mark as unvisited.
if other_phi_on_path[node.idx()] && other_phi_on_path[succ.idx()] == false {
@@ -175,12 +205,44 @@ pub fn check_reductionable_phis(function: &Function, editor: &FunctionEditor, co
}
if other_phi_on_path[phi.idx()] == false {
- reductionable_phis.push(phi.clone());
+ // if reduce_on_path[phi.idx()].is_some() {
+ // let reduce = reduce_on_path[phi.idx()].unwrap();
+ // reductionable_phis.push(ReductionablePHI::NDimensional { phi_node: phi.clone(), reduction_node: reduce })
+ // } else {
+ reductionable_phis.push(phi.clone());
+ // }
}
}
- println!("reductionable phis: {:?}", reductionable_phis);
- return reductionable_phis;
+ // Check if the PHIs are in cycles with redutions via pattern matching
+ let mut n_dimensional_candidates: Vec<ReductionablePHI> = vec![];
+
+ // Jesus what a mess. FIXME: (@xrouth).
+ for phi_id in &reductionable_phis {
+ let (control, data) = function.nodes[phi_id.idx()].try_phi().unwrap();
+ for data_id in data {
+ if let Some((control, init, reduct)) = function.nodes[data_id.idx()].try_reduce() {
+ if init == *phi_id {
+ n_dimensional_candidates.push(ReductionablePHI::NDimensional
+ { phi_node: phi_id.clone(), reduction_node: data_id.clone()});
+ break;
+ }
+ } else {
+ continue;
+ }
+ }
+ }
+
+ println!("n_dimensional_candiates: {:?}", n_dimensional_candidates);
+
+ let final_phis = if n_dimensional_candidates.len() > 0 {
+ n_dimensional_candidates
+ } else {
+ reductionable_phis.into_iter().map(|phi| ReductionablePHI::Normal(phi)).collect()
+ };
+
+ println!("reductionable phis: {:?}", final_phis);
+ final_phis
}
/** Given loop information, returns the Node that makes the loop bound, and the NodeID representing the loop bound */
diff --git a/hercules_opt/src/pass.rs b/hercules_opt/src/pass.rs
index e7e0db69..2e3d2616 100644
--- a/hercules_opt/src/pass.rs
+++ b/hercules_opt/src/pass.rs
@@ -495,8 +495,10 @@ impl PassManager {
self.make_def_uses();
self.make_loops();
self.make_control_subgraphs();
+ self.make_fork_join_maps();
let def_uses = self.def_uses.as_ref().unwrap();
let loops = self.loops.as_ref().unwrap();
+ let fork_join_maps = self.fork_join_maps.as_ref().unwrap();
for idx in 0..self.module.functions.len() {
let constants_ref =
RefCell::new(std::mem::take(&mut self.module.constants));
@@ -515,6 +517,7 @@ impl PassManager {
forkify(
&mut editor,
subgraph,
+ &fork_join_maps[idx],
&loops[idx],
);
diff --git a/hercules_test/hercules_interpreter/src/interpreter.rs b/hercules_test/hercules_interpreter/src/interpreter.rs
index 9b529fd9..a2e0319e 100644
--- a/hercules_test/hercules_interpreter/src/interpreter.rs
+++ b/hercules_test/hercules_interpreter/src/interpreter.rs
@@ -77,6 +77,7 @@ pub fn dyn_const_value(dc: &DynamicConstantID, dyn_const_values: &[DynamicConsta
DynamicConstant::Rem(a, b) => dyn_const_value(a, dyn_const_values, dyn_const_params) % dyn_const_value(b, dyn_const_values, dyn_const_params),
}
}
+
// Each control token stores a current position, and also a mapping of fork nodes -> thread idx.
#[derive(Debug, Clone, Eq, PartialEq)]
pub struct ControlToken {
--
GitLab
From 6d8dde5ceccdc4c0939589139fdaa8d6c4ccce16 Mon Sep 17 00:00:00 2001
From: Xavier Routh <xrouth2@illinois.edu>
Date: Sat, 14 Dec 2024 15:46:23 -0600
Subject: [PATCH 13/68] N-d forks in interpreter
---
.../hercules_interpreter/src/interpreter.rs | 46 +++++++++++++------
.../hercules_tests/tests/interpreter_tests.rs | 20 ++++++++
.../hercules_tests/tests/loop_tests.rs | 1 +
.../hercules_tests/tests/opt_tests.rs | 19 ++++----
hercules_test/test_inputs/2d_fork.hir | 8 ++++
5 files changed, 71 insertions(+), 23 deletions(-)
create mode 100644 hercules_test/hercules_tests/tests/interpreter_tests.rs
create mode 100644 hercules_test/test_inputs/2d_fork.hir
diff --git a/hercules_test/hercules_interpreter/src/interpreter.rs b/hercules_test/hercules_interpreter/src/interpreter.rs
index a2e0319e..3fbec850 100644
--- a/hercules_test/hercules_interpreter/src/interpreter.rs
+++ b/hercules_test/hercules_interpreter/src/interpreter.rs
@@ -257,9 +257,17 @@ impl<'a> FunctionExecutionState<'a> {
// Take the top N entries such that it matches the length of the TRF in the control token.
// Get the depth of the control token that is requesting this reduction node.
- let fork_levels = nested_forks.len();
+
+ // Sum over all thread dimensions in nested forks
+ let fork_levels: usize = nested_forks.iter().map(|ele|
+ self.get_function().nodes[ele.idx()].try_fork().unwrap().1.len()).sum();
+
+ let len = if nested_forks.is_empty() {
+ fork_levels - 1
+ } else {
+ fork_levels - self.get_function().nodes[nested_forks.last().unwrap().idx()].try_fork().unwrap().1.len()
+ };
- let len = fork_levels - 1;
let mut thread_values = token.thread_indicies.clone();
thread_values.truncate(len);
thread_values
@@ -312,7 +320,8 @@ impl<'a> FunctionExecutionState<'a> {
.get(control)
.expect("PANIC: No nesting information for thread index!")
.len();
- let v = token.thread_indicies[nesting_level - 1]; // Might have to -1?
+ // dimension might need to instead be dimensions - dimension
+ let v = token.thread_indicies[nesting_level + dimension - 1]; // Might have to -1?
InterpreterVal::DynamicConstant((v).into())
}
// If we read from a reduction that is the same depth as this thread, we need to write back to it before anyone else reads from it.
@@ -389,7 +398,7 @@ impl<'a> FunctionExecutionState<'a> {
args,
control,
} => {
- todo!("call currently dissabled lol");
+ // todo!("call currently dissabled lol");
let args = args.into_iter()
.map(|arg_node| self.handle_data(token, *arg_node))
.collect();
@@ -597,28 +606,37 @@ impl<'a> FunctionExecutionState<'a> {
Node::Match { control: _, sum: _ } => todo!(),
Node::Fork { control: _, factors } => {
let fork = ctrl_token.curr;
- if factors.len() > 1 {
- panic!("multi-dimensional forks unimplemented")
- }
- let factor = factors[0];
- let thread_factor = dyn_const_value(&factor, &self.module.dynamic_constants, &self.dynamic_constant_params).clone();
+ // if factors.len() > 1 {
+ // panic!("multi-dimensional forks unimplemented")
+ // }
+
+ let factors = factors.iter().map(|f| dyn_const_value(&f, &self.module.dynamic_constants, &self.dynamic_constant_params));
+
+ let n_tokens: usize = factors.clone().product();
// Update control token
let next = self.get_control_subgraph().succs(ctrl_token.curr).nth(0).unwrap();
let ctrl_token = ctrl_token.moved_to(next);
- let mut tokens_to_add = Vec::with_capacity(thread_factor);
+ let mut tokens_to_add = Vec::with_capacity(n_tokens);
- assert_ne!(thread_factor, 0);
+ assert_ne!(n_tokens, 0);
// Token is at its correct sontrol succesor already.
+
// Add the new thread index.
- for i in 0..(thread_factor) {
+ for i in 0..n_tokens {
+ let mut temp = i;
let mut new_token = ctrl_token.clone(); // Copy map, curr, prev, etc.
- new_token.thread_indicies.push(i); // Stack of thread indicies
+
+ for (j, dim) in factors.clone().enumerate().rev() {
+ new_token.thread_indicies.push(temp % dim); // Stack of thread indicies
+ temp /= dim;
+ }
tokens_to_add.push(new_token);
}
+
let thread_factors = self.get_thread_factors(&ctrl_token, ctrl_token.curr);
// Find join and initialize them, and set their reduction counters as well.
@@ -647,7 +665,7 @@ impl<'a> FunctionExecutionState<'a> {
}
- self.join_counters.insert((thread_factors, join), thread_factor);
+ self.join_counters.insert((thread_factors, join), n_tokens);
tokens_to_add
}
diff --git a/hercules_test/hercules_tests/tests/interpreter_tests.rs b/hercules_test/hercules_tests/tests/interpreter_tests.rs
new file mode 100644
index 00000000..13be5cc3
--- /dev/null
+++ b/hercules_test/hercules_tests/tests/interpreter_tests.rs
@@ -0,0 +1,20 @@
+use std::env;
+
+use hercules_interpreter::*;
+use hercules_opt::pass::Pass;
+use hercules_ir::ID;
+
+extern crate rand;
+use rand::Rng;
+
+#[test]
+fn twodeefork() {
+ let module = parse_file("../test_inputs/2d_fork.hir");
+ let d1 = 2;
+ let d2 = 3;
+ let dyn_consts = [d1, d2];
+ let result_1 = interp_module!(module, dyn_consts, 2);
+ let res = (d1 as i32 * d2 as i32);
+ let result_2: InterpreterWrapper = res.into();
+ println!("result: {:?}", result_1); // Should be d1 * d2.
+}
diff --git a/hercules_test/hercules_tests/tests/loop_tests.rs b/hercules_test/hercules_tests/tests/loop_tests.rs
index 13ae76e0..c780cbae 100644
--- a/hercules_test/hercules_tests/tests/loop_tests.rs
+++ b/hercules_test/hercules_tests/tests/loop_tests.rs
@@ -140,6 +140,7 @@ fn nested_loop2() {
Pass::Forkify,
Pass::DCE,
Pass::Verify,
+ Pass::Xdot(true),
];
for pass in passes {
diff --git a/hercules_test/hercules_tests/tests/opt_tests.rs b/hercules_test/hercules_tests/tests/opt_tests.rs
index 0cb902a8..1ceb9c33 100644
--- a/hercules_test/hercules_tests/tests/opt_tests.rs
+++ b/hercules_test/hercules_tests/tests/opt_tests.rs
@@ -18,15 +18,15 @@ fn matmul_int() {
let mut pm = hercules_opt::pass::PassManager::new(module.clone());
let passes = vec![
- Pass::Verify,
- Pass::CCP,
- Pass::DCE,
- Pass::GVN,
- Pass::DCE,
- Pass::Forkify,
- Pass::DCE,
- Pass::Predication,
- Pass::DCE,
+ // Pass::Verify,
+ // Pass::CCP,
+ // Pass::DCE,
+ // Pass::GVN,
+ // Pass::DCE,
+ // Pass::Forkify,
+ // Pass::DCE,
+ // Pass::Predication,
+ // Pass::DCE,
];
for pass in passes {
@@ -36,6 +36,7 @@ fn matmul_int() {
let module = pm.get_module();
let result_2 = interp_module!(module, dyn_consts, m1, m2);
+ // println!("result: {:?}", result_1);
assert_eq!(result_1, result_2)
}
diff --git a/hercules_test/test_inputs/2d_fork.hir b/hercules_test/test_inputs/2d_fork.hir
new file mode 100644
index 00000000..e784c1db
--- /dev/null
+++ b/hercules_test/test_inputs/2d_fork.hir
@@ -0,0 +1,8 @@
+fn twodeefork<2>(x: i32) -> i32
+ zero = constant(i32, 0)
+ one = constant(i32, 1)
+ f = fork(start, #1, #0)
+ j = join(f)
+ add = add(r, one)
+ r = reduce(j, zero, add)
+ z = return(j, r)
\ No newline at end of file
--
GitLab
From dd8744c8bebb93e9aea616bb137c66177793cd22 Mon Sep 17 00:00:00 2001
From: Xavier Routh <xrouth2@illinois.edu>
Date: Sat, 14 Dec 2024 16:49:21 -0600
Subject: [PATCH 14/68] tid samples
---
.../hercules_tests/tests/interpreter_tests.rs | 8 +
.../hercules_tests/tests/loop_tests.rs | 195 ++++++++++++++++++
hercules_test/test_inputs/5d_fork.hir | 8 +
.../expected_fails.hir/bad_3nest_return.hir | 35 ++++
.../expected_fails.hir/bad_loop_tid_sum.hir | 16 ++
.../test_inputs/forkify/loop_sum.hir | 2 +-
.../test_inputs/forkify/loop_tid_sum.hir | 16 ++
.../test_inputs/forkify/nested_loop1.hir | 23 ---
.../{nested_loop3.hir => nested_tid_sum.hir} | 12 +-
.../test_inputs/forkify/nested_tid_sum_2.hir | 26 +++
.../test_inputs/forkify/super_nested_loop.hir | 35 ++++
11 files changed, 346 insertions(+), 30 deletions(-)
create mode 100644 hercules_test/test_inputs/5d_fork.hir
create mode 100644 hercules_test/test_inputs/forkify/expected_fails.hir/bad_3nest_return.hir
create mode 100644 hercules_test/test_inputs/forkify/expected_fails.hir/bad_loop_tid_sum.hir
create mode 100644 hercules_test/test_inputs/forkify/loop_tid_sum.hir
delete mode 100644 hercules_test/test_inputs/forkify/nested_loop1.hir
rename hercules_test/test_inputs/forkify/{nested_loop3.hir => nested_tid_sum.hir} (77%)
create mode 100644 hercules_test/test_inputs/forkify/nested_tid_sum_2.hir
create mode 100644 hercules_test/test_inputs/forkify/super_nested_loop.hir
diff --git a/hercules_test/hercules_tests/tests/interpreter_tests.rs b/hercules_test/hercules_tests/tests/interpreter_tests.rs
index 13be5cc3..51c900e4 100644
--- a/hercules_test/hercules_tests/tests/interpreter_tests.rs
+++ b/hercules_test/hercules_tests/tests/interpreter_tests.rs
@@ -18,3 +18,11 @@ fn twodeefork() {
let result_2: InterpreterWrapper = res.into();
println!("result: {:?}", result_1); // Should be d1 * d2.
}
+
+#[test]
+fn fivedeefork() {
+ let module = parse_file("../test_inputs/5d_fork.hir");
+ let dyn_consts = [1, 2, 3, 4, 5];
+ let result_1 = interp_module!(module, dyn_consts, 2);
+ println!("result: {:?}", result_1); // Should be 1 * 2 * 3 * 4 * 5;
+}
diff --git a/hercules_test/hercules_tests/tests/loop_tests.rs b/hercules_test/hercules_tests/tests/loop_tests.rs
index c780cbae..3c425e50 100644
--- a/hercules_test/hercules_tests/tests/loop_tests.rs
+++ b/hercules_test/hercules_tests/tests/loop_tests.rs
@@ -65,6 +65,35 @@ fn loop_sum() {
println!("{:?}, {:?}", result_1, result_2);
}
+#[test]
+fn loop_tid_sum() {
+ let module = parse_file("../test_inputs/forkify/loop_tid_sum.hir");
+ let dyn_consts = [20];
+ let params = 2; // TODO: (@xrouth) fix macro to take no params as an option.
+ let result_1 = interp_module!(module, dyn_consts, 2);
+
+ println!("result: {:?}", result_1);
+
+ let mut pm = hercules_opt::pass::PassManager::new(module.clone());
+
+ let passes = vec![
+ Pass::Verify,
+ Pass::Forkify,
+ Pass::DCE,
+ Pass::Verify,
+ ];
+
+ for pass in passes {
+ pm.add_pass(pass);
+ }
+ pm.run_passes();
+
+ let module = pm.get_module();
+ let result_2 = interp_module!(module, dyn_consts, 2);
+ assert_eq!(result_1, result_2);
+ println!("{:?}, {:?}", result_1, result_2);
+}
+
#[test]
fn loop_array_sum() {
let module = parse_file("../test_inputs/forkify/loop_array_sum.hir");
@@ -154,6 +183,72 @@ fn nested_loop2() {
println!("{:?}, {:?}, {:?}", result_1, result_2, result_3);
}
+#[test]
+fn super_nested_loop() {
+ let module = parse_file("../test_inputs/forkify/super_nested_loop.hir");
+ let len = 5;
+ let dyn_consts = [5, 10, 15];
+ let params = vec![1, 2, 3, 4, 5]; // TODO: (@xrouth) fix macro to take no params as an option.
+ let result_1 = interp_module!(module, dyn_consts, 2);
+
+ println!("result: {:?}", result_1);
+
+ let mut pm = hercules_opt::pass::PassManager::new(module.clone());
+
+ let passes = vec![
+ Pass::Verify,
+ Pass::Forkify,
+ Pass::DCE,
+ Pass::Verify,
+ ];
+
+ for pass in passes {
+ pm.add_pass(pass);
+ }
+ pm.run_passes();
+
+ let module = pm.get_module();
+ let result_2 = interp_module!(module, dyn_consts, 2);
+ assert_eq!(result_1, result_2);
+
+ let mut pm = hercules_opt::pass::PassManager::new(module.clone());
+
+ let passes = vec![
+ Pass::Verify,
+ Pass::Forkify,
+ Pass::DCE,
+ Pass::Verify,
+ ];
+
+ for pass in passes {
+ pm.add_pass(pass);
+ }
+ pm.run_passes();
+
+ let module = pm.get_module();
+ let result_3 = interp_module!(module, dyn_consts, 2);
+
+ let mut pm = hercules_opt::pass::PassManager::new(module.clone());
+
+ let passes = vec![
+ Pass::Verify,
+ Pass::Forkify,
+ Pass::DCE,
+ Pass::Verify,
+ ];
+
+ for pass in passes {
+ pm.add_pass(pass);
+ }
+ pm.run_passes();
+
+ let module = pm.get_module();
+ let result_4 = interp_module!(module, dyn_consts, 2);
+
+ println!("{:?}, {:?}, {:?}, {:?}", result_1, result_2, result_3, result_4);
+}
+
+
#[test]
fn interpret_temp() {
let module = parse_module_from_hbin("../../a.hbin");
@@ -265,4 +360,104 @@ fn control_before_condition() {
let result_2 = interp_module!(module, dyn_consts, vec);
assert_eq!(result_1, result_2);
+}
+
+#[test]
+fn nested_tid_sum() {
+ let module = parse_file("../test_inputs/forkify/nested_tid_sum.hir");
+ let len = 5;
+ let dyn_consts = [5, 6];
+ let params = vec![1, 2, 3, 4, 5]; // TODO: (@xrouth) fix macro to take no params as an option.
+ let result_1 = interp_module!(module, dyn_consts, 2);
+
+ println!("result: {:?}", result_1);
+
+ let mut pm = hercules_opt::pass::PassManager::new(module.clone());
+
+ let passes = vec![
+ // Pass::Xdot(true),
+ Pass::Verify,
+ Pass::Forkify,
+ Pass::DCE,
+ Pass::Verify,
+ ];
+
+ for pass in passes {
+ pm.add_pass(pass);
+ }
+ pm.run_passes();
+
+ let module = pm.get_module();
+ let result_2 = interp_module!(module, dyn_consts, 2);
+ assert_eq!(result_1, result_2);
+
+ let mut pm = hercules_opt::pass::PassManager::new(module.clone());
+
+ let passes = vec![
+ Pass::Verify,
+ Pass::Forkify,
+ Pass::DCE,
+ Pass::Verify,
+ Pass::Xdot(true),
+ ];
+
+ for pass in passes {
+ pm.add_pass(pass);
+ }
+ pm.run_passes();
+
+ let module = pm.get_module();
+ let result_3 = interp_module!(module, dyn_consts, 2);
+
+ println!("{:?}, {:?}, {:?}", result_1, result_2, result_3);
+}
+
+#[test]
+fn nested_tid_sum_2() {
+ let module = parse_file("../test_inputs/forkify/nested_tid_sum_2.hir");
+ let len = 5;
+ let dyn_consts = [5, 6];
+ let params = vec![1, 2, 3, 4, 5]; // TODO: (@xrouth) fix macro to take no params as an option.
+ let result_1 = interp_module!(module, dyn_consts, 2);
+
+ println!("result: {:?}", result_1);
+
+ let mut pm = hercules_opt::pass::PassManager::new(module.clone());
+
+ let passes = vec![
+ Pass::Xdot(true),
+ Pass::Verify,
+ Pass::Forkify,
+ Pass::DCE,
+ Pass::Verify,
+ ];
+
+ for pass in passes {
+ pm.add_pass(pass);
+ }
+ pm.run_passes();
+
+ let module = pm.get_module();
+ let result_2 = interp_module!(module, dyn_consts, 2);
+ assert_eq!(result_1, result_2);
+
+ let mut pm = hercules_opt::pass::PassManager::new(module.clone());
+
+ let passes = vec![
+ Pass::Verify,
+ Pass::Forkify,
+ Pass::DCE,
+ Pass::Verify,
+ Pass::Xdot(true),
+ ];
+
+ for pass in passes {
+ pm.add_pass(pass);
+ }
+ pm.run_passes();
+
+ let module = pm.get_module();
+ let result_3 = interp_module!(module, dyn_consts, 2);
+
+ println!("{:?}, {:?}, {:?}", result_1, result_2, result_3);
}
\ No newline at end of file
diff --git a/hercules_test/test_inputs/5d_fork.hir b/hercules_test/test_inputs/5d_fork.hir
new file mode 100644
index 00000000..94299601
--- /dev/null
+++ b/hercules_test/test_inputs/5d_fork.hir
@@ -0,0 +1,8 @@
+fn fivedeefork<5>(x: i32) -> i32
+ zero = constant(i32, 0)
+ one = constant(i32, 1)
+ f = fork(start, #4, #3, #2, #1, #0)
+ j = join(f)
+ add = add(r, one)
+ r = reduce(j, zero, add)
+ z = return(j, r)
\ No newline at end of file
diff --git a/hercules_test/test_inputs/forkify/expected_fails.hir/bad_3nest_return.hir b/hercules_test/test_inputs/forkify/expected_fails.hir/bad_3nest_return.hir
new file mode 100644
index 00000000..f5ec4370
--- /dev/null
+++ b/hercules_test/test_inputs/forkify/expected_fails.hir/bad_3nest_return.hir
@@ -0,0 +1,35 @@
+fn loop<3>(a: u32) -> i32
+ zero_idx = constant(u64, 0)
+ one_idx = constant(u64, 1)
+ zero_var = constant(i32, 0)
+ one_var = constant(i32, 1)
+ inner_bound = dynamic_constant(#0)
+ outer_loop = region(outer_outer_if_true, inner_if_false)
+ inner_loop = region(outer_if_true, inner_if_true)
+ outer_var = phi(outer_loop, outer_outer_var, inner_var)
+ inner_var = phi(inner_loop, outer_var, inner_var_inc)
+ inner_var_inc = add(inner_var, one_var)
+ inner_idx = phi(inner_loop, zero_idx, inner_idx_inc)
+ inner_idx_inc = add(inner_idx, one_idx)
+ inner_in_bounds = lt(inner_idx, inner_bound)
+ outer_idx = phi(outer_loop, zero_idx, outer_idx_inc, outer_idx)
+ outer_idx_inc = add(outer_idx, one_idx)
+ outer_in_bounds = lt(outer_idx, outer_bound)
+ inner_if = if(inner_loop, inner_in_bounds)
+ inner_if_false = projection(inner_if, 0)
+ inner_if_true = projection(inner_if, 1)
+ outer_if = if(outer_loop, outer_in_bounds)
+ outer_if_false = projection(outer_if, 0)
+ outer_if_true = projection(outer_if, 1)
+ outer_bound = dynamic_constant(#1)
+ outer_outer_bound = dynamic_constant(#2)
+ outer_outer_loop = region(start, outer_if_false)
+ outer_outer_var = phi(outer_outer_loop, zero_var, outer_var)
+ outer_outer_if = if(outer_outer_loop, outer_outer_in_bounds)
+ outer_outer_if_false = projection(outer_outer_if, 0)
+ outer_outer_if_true = projection(outer_outer_if, 1)
+ outer_outer_idx = phi(outer_outer_loop, zero_idx, outer_outer_idx_inc, outer_outer_idx)
+ outer_outer_idx_inc = add(outer_outer_idx, one_idx)
+ outer_outer_in_bounds = lt(outer_outer_idx, outer_outer_bound)
+ r = return(outer_outer_if_false, inner_var)
+
diff --git a/hercules_test/test_inputs/forkify/expected_fails.hir/bad_loop_tid_sum.hir b/hercules_test/test_inputs/forkify/expected_fails.hir/bad_loop_tid_sum.hir
new file mode 100644
index 00000000..8dda179b
--- /dev/null
+++ b/hercules_test/test_inputs/forkify/expected_fails.hir/bad_loop_tid_sum.hir
@@ -0,0 +1,16 @@
+fn loop<1>(a: u64) -> u64
+ zero_idx = constant(u64, 0)
+ one_idx = constant(u64, 1)
+ zero_var = constant(u64, 0)
+ one_var = constant(u64, 1)
+ bound = dynamic_constant(#0)
+ loop = region(start, if_true)
+ var = phi(loop, zero_var, var_inc)
+ var_inc = add(var, idx)
+ idx = phi(loop, zero_idx, idx_inc)
+ idx_inc = add(idx, one_idx)
+ in_bounds = lt(idx, bound)
+ if = if(loop, in_bounds)
+ if_false = projection(if, 0)
+ if_true = projection(if, 1)
+ r = return(if_false, var_inc)
\ No newline at end of file
diff --git a/hercules_test/test_inputs/forkify/loop_sum.hir b/hercules_test/test_inputs/forkify/loop_sum.hir
index e69ecc3d..fd9c4deb 100644
--- a/hercules_test/test_inputs/forkify/loop_sum.hir
+++ b/hercules_test/test_inputs/forkify/loop_sum.hir
@@ -13,4 +13,4 @@ fn loop<1>(a: u32) -> i32
if = if(loop, in_bounds)
if_false = projection(if, 0)
if_true = projection(if, 1)
- r = return(if_false, var_inc)
\ No newline at end of file
+ r = return(if_false, var)
\ No newline at end of file
diff --git a/hercules_test/test_inputs/forkify/loop_tid_sum.hir b/hercules_test/test_inputs/forkify/loop_tid_sum.hir
new file mode 100644
index 00000000..2d3ca34d
--- /dev/null
+++ b/hercules_test/test_inputs/forkify/loop_tid_sum.hir
@@ -0,0 +1,16 @@
+fn loop<1>(a: u64) -> u64
+ zero_idx = constant(u64, 0)
+ one_idx = constant(u64, 1)
+ zero_var = constant(u64, 0)
+ one_var = constant(u64, 1)
+ bound = dynamic_constant(#0)
+ loop = region(start, if_true)
+ var = phi(loop, zero_var, var_inc)
+ var_inc = add(var, idx)
+ idx = phi(loop, zero_idx, idx_inc)
+ idx_inc = add(idx, one_idx)
+ in_bounds = lt(idx, bound)
+ if = if(loop, in_bounds)
+ if_false = projection(if, 0)
+ if_true = projection(if, 1)
+ r = return(if_false, var)
\ No newline at end of file
diff --git a/hercules_test/test_inputs/forkify/nested_loop1.hir b/hercules_test/test_inputs/forkify/nested_loop1.hir
deleted file mode 100644
index 3e5dd77e..00000000
--- a/hercules_test/test_inputs/forkify/nested_loop1.hir
+++ /dev/null
@@ -1,23 +0,0 @@
-fn loop<2>(a: u32) -> i32
- zero_idx = constant(u64, 0)
- one_idx = constant(u64, 1)
- zero_var = constant(i32, 0)
- one_var = constant(i32, 1)
- inner_bound = dynamic_constant(#0)
- outer_bound = dynamic_constant(#0)
- outer_loop = region(start, outer_if_true, inner_if_false)
- inner_loop = region(outer_if_true, inner_if_true)
- inner_var = phi(inner_loop, zero_var, inner_var_inc)
- inner_var_inc = add(inner_var, one_var)
- outer_var_inc = add(outer_var, one_var)
- inner_idx = phi(loop, zero_idx, idx_inc)
- inner_idx_inc = add(idx, one_idx)
- inner_in_bounds = lt(idx, bound)
- inner_if = if(loop, in_bounds)
- inner_if_false = projection(inner_if, 0)
- inner_if_true = projection(inner_if, 1)
- outer_if_false = projection(outer_if, 0)
- outer_if_true = projection(outer_if, 1)
- outer_var = phi(outer_lop, zero_var, outer_var_inc, outer_var)
-
- r = return(if_false, var_inc)
\ No newline at end of file
diff --git a/hercules_test/test_inputs/forkify/nested_loop3.hir b/hercules_test/test_inputs/forkify/nested_tid_sum.hir
similarity index 77%
rename from hercules_test/test_inputs/forkify/nested_loop3.hir
rename to hercules_test/test_inputs/forkify/nested_tid_sum.hir
index ebbe4360..5539202d 100644
--- a/hercules_test/test_inputs/forkify/nested_loop3.hir
+++ b/hercules_test/test_inputs/forkify/nested_tid_sum.hir
@@ -1,15 +1,15 @@
-fn loop<2>(a: u32) -> i32
+fn loop<2>(a: u32) -> u64
zero_idx = constant(u64, 0)
one_idx = constant(u64, 1)
- zero_var = constant(i32, 0)
- one_var = constant(i32, 1)
+ zero_var = constant(u64, 0)
+ one_var = constant(u64, 1)
inner_bound = dynamic_constant(#0)
outer_bound = dynamic_constant(#1)
- outer_loop = region(start, outer_if_true, inner_if_false)
+ outer_loop = region(start, inner_if_false)
inner_loop = region(outer_if_true, inner_if_true)
- outer_var = phi(outer_loop, zero_var, outer_var, inner_var)
+ outer_var = phi(outer_loop, zero_var, inner_var)
inner_var = phi(inner_loop, outer_var, inner_var_inc)
- inner_var_inc = add(inner_var, one_var)
+ inner_var_inc = add(inner_var, inner_idx)
inner_idx = phi(inner_loop, zero_idx, inner_idx_inc)
inner_idx_inc = add(inner_idx, one_idx)
inner_in_bounds = lt(inner_idx, inner_bound)
diff --git a/hercules_test/test_inputs/forkify/nested_tid_sum_2.hir b/hercules_test/test_inputs/forkify/nested_tid_sum_2.hir
new file mode 100644
index 00000000..9221fd47
--- /dev/null
+++ b/hercules_test/test_inputs/forkify/nested_tid_sum_2.hir
@@ -0,0 +1,26 @@
+fn loop<2>(a: u32) -> u64
+ zero_idx = constant(u64, 0)
+ one_idx = constant(u64, 1)
+ zero_var = constant(u64, 0)
+ one_var = constant(u64, 1)
+ inner_bound = dynamic_constant(#0)
+ outer_bound = dynamic_constant(#1)
+ outer_loop = region(start, inner_if_false)
+ inner_loop = region(outer_if_true, inner_if_true)
+ outer_var = phi(outer_loop, zero_var, inner_var)
+ inner_var = phi(inner_loop, outer_var, inner_var_inc)
+ iv_mul = mul(inner_idx, outer_idx)
+ inner_var_inc = add(inner_var, iv_mul)
+ inner_idx = phi(inner_loop, zero_idx, inner_idx_inc)
+ inner_idx_inc = add(inner_idx, one_idx)
+ inner_in_bounds = lt(inner_idx, inner_bound)
+ outer_idx = phi(outer_loop, zero_idx, outer_idx_inc, outer_idx)
+ outer_idx_inc = add(outer_idx, one_idx)
+ outer_in_bounds = lt(outer_idx, outer_bound)
+ inner_if = if(inner_loop, inner_in_bounds)
+ inner_if_false = projection(inner_if, 0)
+ inner_if_true = projection(inner_if, 1)
+ outer_if = if(outer_loop, outer_in_bounds)
+ outer_if_false = projection(outer_if, 0)
+ outer_if_true = projection(outer_if, 1)
+ r = return(outer_if_false, outer_var)
\ No newline at end of file
diff --git a/hercules_test/test_inputs/forkify/super_nested_loop.hir b/hercules_test/test_inputs/forkify/super_nested_loop.hir
new file mode 100644
index 00000000..6853efbf
--- /dev/null
+++ b/hercules_test/test_inputs/forkify/super_nested_loop.hir
@@ -0,0 +1,35 @@
+fn loop<3>(a: u32) -> i32
+ zero_idx = constant(u64, 0)
+ one_idx = constant(u64, 1)
+ zero_var = constant(i32, 0)
+ one_var = constant(i32, 1)
+ inner_bound = dynamic_constant(#0)
+ outer_loop = region(outer_outer_if_true, inner_if_false)
+ inner_loop = region(outer_if_true, inner_if_true)
+ outer_var = phi(outer_loop, outer_outer_var, inner_var)
+ inner_var = phi(inner_loop, outer_var, inner_var_inc)
+ inner_var_inc = add(inner_var, one_var)
+ inner_idx = phi(inner_loop, zero_idx, inner_idx_inc)
+ inner_idx_inc = add(inner_idx, one_idx)
+ inner_in_bounds = lt(inner_idx, inner_bound)
+ outer_idx = phi(outer_loop, zero_idx, outer_idx_inc, outer_idx)
+ outer_idx_inc = add(outer_idx, one_idx)
+ outer_in_bounds = lt(outer_idx, outer_bound)
+ inner_if = if(inner_loop, inner_in_bounds)
+ inner_if_false = projection(inner_if, 0)
+ inner_if_true = projection(inner_if, 1)
+ outer_if = if(outer_loop, outer_in_bounds)
+ outer_if_false = projection(outer_if, 0)
+ outer_if_true = projection(outer_if, 1)
+ outer_bound = dynamic_constant(#1)
+ outer_outer_bound = dynamic_constant(#2)
+ outer_outer_loop = region(start, outer_if_false)
+ outer_outer_var = phi(outer_outer_loop, zero_var, outer_var)
+ outer_outer_if = if(outer_outer_loop, outer_outer_in_bounds)
+ outer_outer_if_false = projection(outer_outer_if, 0)
+ outer_outer_if_true = projection(outer_outer_if, 1)
+ outer_outer_idx = phi(outer_outer_loop, zero_idx, outer_outer_idx_inc, outer_outer_idx)
+ outer_outer_idx_inc = add(outer_outer_idx, one_idx)
+ outer_outer_in_bounds = lt(outer_outer_idx, outer_outer_bound)
+ r = return(outer_outer_if_false, outer_outer_var)
+
--
GitLab
From e59c2b3a04996e1a019d0024e0292b706928db0a Mon Sep 17 00:00:00 2001
From: Xavier Routh <xrouth2@illinois.edu>
Date: Tue, 24 Dec 2024 16:16:15 -0500
Subject: [PATCH 15/68] cleanup
---
hercules_opt/src/forkify.rs | 370 ++++++++++++++----
hercules_opt/src/ivar.rs | 281 ++++++-------
.../hercules_interpreter/src/value.rs | 6 +-
3 files changed, 418 insertions(+), 239 deletions(-)
diff --git a/hercules_opt/src/forkify.rs b/hercules_opt/src/forkify.rs
index b2c2d2d0..26f2daed 100644
--- a/hercules_opt/src/forkify.rs
+++ b/hercules_opt/src/forkify.rs
@@ -1,26 +1,36 @@
extern crate hercules_ir;
extern crate bitvec;
+extern crate nestify;
use std::collections::HashMap;
use std::iter::zip;
+use self::nestify::nest;
+
+use self::bitvec::order::Lsb0;
use self::bitvec::vec::BitVec;
use self::hercules_ir::Subgraph;
use self::hercules_ir::control_subgraph;
-use crate::check_reductionable_phis;
+use crate::bound_induction_variables;
use crate::compute_induction_vars;
-use crate::compute_loop_bounds;
use crate::compute_loop_variance;
+use crate::get_loop_exit_conditions;
+use crate::BasicInductionVariable;
use crate::FunctionEditor;
-use crate::ReductionablePHI;
+use crate::Loop;
+use crate::LoopVarianceInfo;
use self::hercules_ir::def_use::*;
use self::hercules_ir::ir::*;
use self::hercules_ir::loops::*;
+// Hmm some third variety of this that switches between the two automatically could be fun.
+type DenseNodeMap<T> = Vec<T>;
+type SparseNodeMap<T> = HashMap<NodeID, T>;
+
pub fn forkify(
editor: &mut FunctionEditor,
control_subgraph: &Subgraph,
@@ -37,11 +47,97 @@ pub fn forkify(
let natural_loops: Vec<_> = natural_loops.collect();
for l in natural_loops {
- forkify_loop(editor, control_subgraph, fork_join_map, l);
+ forkify_loop(editor, control_subgraph, fork_join_map, &Loop { header: l.0, control: l.1.clone()});
break; //TODO: REMOVE ME
}
}
+/** Provides a utility to answer the question whether a data node is entirely contained within a loop or not.
+If the node has no uses outside of the loop,
+loop transformations are free to get rid of it.
+looop
+Returns a map from Nodes -> bool,
+- True means the node does not use any values that are in the loop.
+- False means the node is outside the loop.
+*/
+
+// Buggy scenario:
+// What if a node has two uses, one is the IV of a loop,
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum DataUseLoopLocation {
+ Unknown,
+ Inside,
+ Outside,
+}
+
+// FIXME: This is a mess.
+pub fn loop_data_location(function: &Function, node: NodeID, all_loop_nodes: &BitVec<u8, Lsb0>,
+ visited: &mut DenseNodeMap<bool>
+) -> DataUseLoopLocation {
+
+ if visited[node.idx()] {
+ return DataUseLoopLocation::Unknown;
+ }
+
+ visited[node.idx()] = true;
+
+ // Control node on frontier.
+ if function.nodes[node.idx()].is_control() {
+ return match all_loop_nodes[node.idx()] {
+ true => DataUseLoopLocation::Inside,
+ false => DataUseLoopLocation::Outside
+ }
+ }
+
+
+ let mut data_location = DataUseLoopLocation::Inside;
+
+ for node_use in get_uses(&function.nodes[node.idx()]).as_ref() {
+ // If any use is outside, then this node is outside, else its on inside.
+ if loop_data_location(function, *node_use, &all_loop_nodes, visited) == DataUseLoopLocation::Outside {
+ data_location = DataUseLoopLocation::Outside;
+ }
+ }
+
+ data_location
+}
+
+/** Given a node used as a loop bound, return a dynamic constant ID. */
+fn get_dc_bound(editor: &mut FunctionEditor, bound: LoopBound) -> Result<DynamicConstantID, String> {
+ // Check for a constant used as loop bound.
+ let function = editor.func();
+
+ if let Some(bound_dc_id) = function.nodes[bound.idx()].try_dynamic_constant() {
+ Ok(bound_dc_id)
+ } else if let Some(bound_c_id) = function.nodes[bound.idx()].try_constant() {
+ // Create new dynamic constant that reflects this constant.
+ let dc = match *editor.get_constant(bound_c_id) {
+ Constant::Integer8(x) => DynamicConstant::Constant(x as _),
+ Constant::Integer16(x) => DynamicConstant::Constant(x as _),
+ Constant::Integer32(x) => DynamicConstant::Constant(x as _),
+ Constant::Integer64(x) => DynamicConstant::Constant(x as _),
+ Constant::UnsignedInteger8(x) => DynamicConstant::Constant(x as _),
+ Constant::UnsignedInteger16(x) => DynamicConstant::Constant(x as _),
+ Constant::UnsignedInteger32(x) => DynamicConstant::Constant(x as _),
+ Constant::UnsignedInteger64(x) => DynamicConstant::Constant(x as _),
+ _ => return Err("Invalid constant as loop bound".to_string()),
+ };
+
+ // TODO: ABSOLUTELY NO WAY THIS IS INTENDED USAGE
+ let mut b = DynamicConstantID::new(0);
+ editor.edit(
+ |mut edit| {
+ b = edit.add_dynamic_constant(dc);
+ Ok(edit)
+ }
+ );
+ // Return the ID of the dynamic constant that is generated from the constant
+ // or dynamic constant that is the existing loop bound
+ Ok(b)
+ } else {
+ Err("Bound is not constant or dynamic constant".to_string())
+ }
+}
/*
* Top level function to convert natural loops with simple induction variables
@@ -51,7 +147,7 @@ pub fn forkify_loop(
editor: &mut FunctionEditor,
control_subgraph: &Subgraph,
fork_join_map: &HashMap<NodeID, NodeID>,
- looop: (NodeID, &BitVec<u8>),
+ l: &Loop,
) -> () {
// TODO: Do we want to run analysizes before, I think it's fine to put them in the pass itself.
@@ -59,82 +155,41 @@ pub fn forkify_loop(
let function = editor.func();
- // TODO: (@xrouth) handle multiple loops.
- // Probably want to forkify bottom up, but also need to look at potential 2d forkifies.
- // Maybe upon forkification: BLARGH, Nd forkys are complicated.
- let (header, body) = looop;
-
- println!("header: {:?}", header);
- let loop_nodes = (body.clone(), header.clone());
-
- let loop_pred = editor.get_uses(header) // Is this the same as parent? NO!
- .filter(|id| !body[id.idx()])
+ let loop_pred = editor.get_uses(l.header)
+ .filter(|id| !l.control[id.idx()])
.next()
.unwrap();
+
+ let Some(loop_condition) = get_loop_exit_conditions(function, l, control_subgraph) else {return};
+
// Compute loop variance
- let loop_variance = compute_loop_variance(function, &loop_nodes);
+ let loop_variance = compute_loop_variance(function, &l);
// Compute induction vars
- let basic_ivs = compute_induction_vars(function, &loop_nodes, &loop_variance);
+ let basic_ivs = compute_induction_vars(function, &l, &loop_variance);
// Compute loop bounds
- let loop_bounds = compute_loop_bounds(function, &control_subgraph, &loop_nodes, &basic_ivs, &loop_variance);
+ let Some(basic_iv) = bound_induction_variables(function, &control_subgraph, &l,
+ &basic_ivs, &loop_condition, &loop_variance) else {return};
- println!("loop_bounds: {:?}", loop_bounds);
-
- let (iv, bound, loop_condition) = match loop_bounds {
- Some(v) => v,
- None => return,
- };
-
// Check reductionable phis, only PHIs depending on the loop are considered,
// CHECK ME: this is how we avoid reductions that depend on control flow?
- let candidate_phis: Vec<_> = editor.get_users(header)
+ let candidate_phis: Vec<_> = editor.get_users(l.header)
.filter(|id|function.nodes[id.idx()].is_phi())
- .filter(|id| *id != iv.node)
+ .filter(|id| *id != basic_iv.node)
.collect();
// Check if the reductionable phi is in a cycle with a reduce, if it is, we probably have to make a multi-dimensional fork.
// FIXME: You can actually just pattern match, you shouldn't try to handle expresions inbetween reductions.
- let reductionable_phis: Vec<_> = check_reductionable_phis(function, &editor, &control_subgraph, &loop_nodes,
+ let reductionable_phis: Vec<_> = check_reductionable_phis(&editor, &control_subgraph, &l,
&basic_ivs, &loop_variance, &candidate_phis).into_iter().collect();
// TODO: Check that *all* phis are reductionable. If they aren't, we can't forkify without splitting the loop.
// Check for a constant used as loop bound.
- let bound_dc_id =
- if let Some(bound_dc_id) = function.nodes[bound.idx()].try_dynamic_constant() {
- bound_dc_id
- } else if let Some(bound_c_id) = function.nodes[bound.idx()].try_constant() {
- // Create new dynamic constant that reflects this constant.
- let dc = match *editor.get_constant(bound_c_id) {
- Constant::Integer8(x) => DynamicConstant::Constant(x as _),
- Constant::Integer16(x) => DynamicConstant::Constant(x as _),
- Constant::Integer32(x) => DynamicConstant::Constant(x as _),
- Constant::Integer64(x) => DynamicConstant::Constant(x as _),
- Constant::UnsignedInteger8(x) => DynamicConstant::Constant(x as _),
- Constant::UnsignedInteger16(x) => DynamicConstant::Constant(x as _),
- Constant::UnsignedInteger32(x) => DynamicConstant::Constant(x as _),
- Constant::UnsignedInteger64(x) => DynamicConstant::Constant(x as _),
- _ => return,
- };
-
- // TODO: ABSOLUTELY NO WAY THIS IS INTENDED USAGE
- let mut b = DynamicConstantID::new(0);
- editor.edit(
- |mut edit| {
- b = edit.add_dynamic_constant(dc);
- Ok(edit)
- }
- );
- // Return the ID of the dynamic constant that is generated from the constant
- // or dynamic constant that is the existing loop bound
- b
- } else {
- return;
- };
+ let bound_dc_id = get_dc_bound(editor, basic_iv.bound);
// START EDITING
@@ -196,9 +251,19 @@ pub fn forkify_loop(
// I think we want basic loop splitting.
- // For now, all PHIs besides the indcution variable must be ndimensionalable
+ // For now, all PHIs besides the induction variable must be ndimensionalable
let make_n_dims = reductionable_phis.iter()
.all(|phi| matches!(phi, ReductionablePHI::NDimensional { phi_node, reduction_node }));
+
+ // If there is an inner fork, but PHIs that aren't Reductionable
+ // (well maybe they can be reductionable and not involve the )
+ // this isn't the correct condition.
+
+ // All PHIs need to be NDimensionable (simple expression w/r to the reduction node)
+ // OR not involve the reduction node at all.
+ let inner_fork = editor.get_users(loop_continue_projection).next();
+
+ //
// Create fork and join nodes:
let mut join_id = NodeID::new(0);
@@ -213,18 +278,26 @@ pub fn forkify_loop(
// 2) bewteen the header and the loop condition
// but not
// 3) in between the inner fork and join. (control here is okay), because we don't have to deal with it.
-
if make_n_dims {
- // Find the inner fork / join,
- let inner_fork = editor.get_users(loop_continue_projection).next().unwrap();
- let inner_join = fork_join_map[&inner_fork];
+ // If there is no inner fork / join, fall back to normal.
+ println!("loop_continue_project: {:?}", loop_continue_projection);
+ let inner_fork = editor.get_users(loop_continue_projection).next();
+
+ match inner_fork {
+ Some(_) => todo!(),
+ None => todo!(),
+ }
+ let inner_join = fork_join_map.get(&inner_fork);
let (_, fork_dimensions) = function.nodes[inner_fork.idx()].try_fork().unwrap();
let mut new_factors = vec![bound_dc_id];
- new_factors.append(& mut fork_dimensions.to_vec()); // FIXME: Might need to be added the other way.
+ new_factors.append(&mut fork_dimensions.to_vec()); // FIXME: Might need to be added the other way.
// '0' is innermost dimension.
- join_id = inner_join;
+ join_id = match inner_join {
+ Some(_) => todo!(),
+ None => todo!(),
+ };
fork_id = inner_fork;
// I don't actually think you have to convert the ThreadIDs
@@ -240,6 +313,8 @@ pub fn forkify_loop(
}
);
+ //
+
} else {
// FIXME (@xrouth), handle control in loop body.
editor.edit(
@@ -280,11 +355,21 @@ pub fn forkify_loop(
.next()
.unwrap()
.1;
-
+
+ let function = editor.func();
let (_, factors) = function.nodes[fork_id.idx()].try_fork().unwrap();
let factors = factors.len() - 1;
+
+ let mut iv_use_location: DenseNodeMap<DataUseLoopLocation> = vec![DataUseLoopLocation::Unknown; function.nodes.len()];
+
+ for node_use in editor.get_users(induction_variable.node) {
+ let mut visited = vec![false; function.nodes.len()];
+ iv_use_location[node_use.idx()] = loop_data_location(function, induction_variable.node, &all_loop_nodes, &mut visited)
+ }
+
// Create ThreadID
+
// FIXME: Fix this for n-dimensional things.
editor.edit(
|mut edit| {
@@ -301,17 +386,37 @@ pub fn forkify_loop(
};
let iv_reduce_id = edit.add_node(iv_reduce);
+
+ // If a user occurs after the loop is finished, we replace it with the DC that is the IV bound,
+ // If a user occurs inside the loop, we replace it with the IV.
+
+ // A user is 'after' the loop is finished if we walk the users of it, (or itself), and
+ // any control node on the frontier of control nodes (don't go through users of control nodes) is
+ // not in the loop body or is not the loop header.
+
+
// let users = edit.get_users(induction_variable.node);
println!("replacing all uses of: {:?} with {:?}", induction_variable.node, iv_reduce_id);
- edit = edit.replace_all_uses(induction_variable.node, thread_id_id)?;
- edit.delete_node(induction_variable.node)
- // edit.replace_all_uses_where(old, new, pred)
- // for user in users {
- // // How to check if user is 'inside' or 'outside' loop?
- // // FIXME: For now, just replace everything with the reduce. Oh Well!
-
- // }
+ // Replace uses that are inside with the thread id
+ edit = edit.replace_all_uses_where(induction_variable.node, thread_id_id, |node| {
+ match iv_use_location[node.idx()] {
+ DataUseLoopLocation::Unknown => todo!(),
+ DataUseLoopLocation::Inside => true,
+ DataUseLoopLocation::Outside => false,
+ }
+ })?;
+
+ // Replace uses that are outside with the DC
+ edit = edit.replace_all_uses_where(induction_variable.node, thread_id_id, |node| {
+ match iv_use_location[node.idx()] {
+ DataUseLoopLocation::Unknown => todo!(),
+ DataUseLoopLocation::Inside => false,
+ DataUseLoopLocation::Outside => true,
+ }
+ })?;
+
+ edit.delete_node(induction_variable.node)
}
);
@@ -438,3 +543,118 @@ pub fn forkify_loop(
return;
}
+
+
+nest! {
+ #[derive(Debug)]
+ pub enum ReductionablePHI {
+ Normal(NodeID),
+ NDimensional {
+ phi_node: NodeID,
+ reduction_node: NodeID
+ }
+ }
+}
+
+impl ReductionablePHI {
+ pub fn get_phi(&self) -> NodeID {
+ match self {
+ ReductionablePHI::Normal(node_id) => *node_id,
+ ReductionablePHI::NDimensional { phi_node, reduction_node } => *phi_node,
+ }
+ }
+}
+
+
+/**
+ Checks some conditions on loop variables that will need to be converted into reductions to be forkified.
+ To convert a phi into a reduce we need to check that every cycle containing the PHI does not contain any other PHI.
+ I think this restriction can be loosened (more specified)
+ - Every cycle *in the loop* containing the PHI does not contain any other PHI. Or something, IDK.
+ -
+ We also need to make it not control dependent on anything other than the loop header. */
+pub fn check_reductionable_phis(editor: &FunctionEditor, control_subgraph: &Subgraph,
+ l: &Loop, induction_vars: &[BasicInductionVariable],
+ loop_variance: &LoopVarianceInfo, phis: &[NodeID])
+ -> impl IntoIterator<Item = ReductionablePHI>
+{
+ let function = editor.func();
+
+ // FIXME: (@xrouth)
+ // Check that the PHI actually has a cycle back to it.
+ let mut reductionable_phis: Vec<NodeID> = vec![];
+
+ for phi in phis {
+ // do WFS
+ let mut other_phi_on_path: DenseNodeMap<bool> = vec![false; function.nodes.len()];
+ // let mut reduce_on_path: DenseNodeMap<Option<NodeID>> = vec![None; function.nodes.len()];
+
+ let mut bag_of_control_nodes: Vec<NodeID> = vec![*phi];
+ let mut visited: DenseNodeMap<bool> = vec![false; function.nodes.len()];
+
+ while !bag_of_control_nodes.is_empty() {
+ let node = bag_of_control_nodes.pop().unwrap();
+
+ if visited[node.idx()] {
+ continue;
+ }
+ visited[node.idx()] = true;
+
+ if function.nodes[node.idx()].is_phi() && node != *phi{
+ other_phi_on_path[node.idx()] = true;
+ }
+
+ // if function.nodes[node.idx()].is_reduce() {
+ // reduce_on_path[node.idx()] = Some(node);
+ // }
+
+ for succ in editor.get_users(node) {
+ // If we change, mark as unvisited.
+ if other_phi_on_path[node.idx()] && other_phi_on_path[succ.idx()] == false {
+ other_phi_on_path[succ.idx()] = true;
+ visited[succ.idx()] = false;
+ bag_of_control_nodes.push(succ.clone());
+ }
+ }
+ }
+
+ if other_phi_on_path[phi.idx()] == false {
+ // if reduce_on_path[phi.idx()].is_some() {
+ // let reduce = reduce_on_path[phi.idx()].unwrap();
+ // reductionable_phis.push(ReductionablePHI::NDimensional { phi_node: phi.clone(), reduction_node: reduce })
+ // } else {
+ reductionable_phis.push(phi.clone());
+ // }
+ }
+ }
+
+ // Check if the PHIs are in cycles with redutions via pattern matching
+ let mut n_dimensional_candidates: Vec<ReductionablePHI> = vec![];
+
+ // Jesus what a mess. FIXME: (@xrouth).
+ for phi_id in &reductionable_phis {
+ let (control, data) = function.nodes[phi_id.idx()].try_phi().unwrap();
+ for data_id in data {
+ if let Some((control, init, reduct)) = function.nodes[data_id.idx()].try_reduce() {
+ if init == *phi_id {
+ n_dimensional_candidates.push(ReductionablePHI::NDimensional
+ { phi_node: phi_id.clone(), reduction_node: data_id.clone()});
+ break;
+ }
+ } else {
+ continue;
+ }
+ }
+ }
+
+ println!("n_dimensional_candiates: {:?}", n_dimensional_candidates);
+
+ let final_phis = if n_dimensional_candidates.len() > 0 {
+ n_dimensional_candidates
+ } else {
+ reductionable_phis.into_iter().map(|phi| ReductionablePHI::Normal(phi)).collect()
+ };
+
+ println!("reductionable phis: {:?}", final_phis);
+ final_phis
+}
\ No newline at end of file
diff --git a/hercules_opt/src/ivar.rs b/hercules_opt/src/ivar.rs
index 98d98f08..948eab9a 100644
--- a/hercules_opt/src/ivar.rs
+++ b/hercules_opt/src/ivar.rs
@@ -46,29 +46,52 @@ enum LoopVariance {
Variant,
}
+type NodeVec = BitVec<u8, Lsb0>;
-/** Represents a basic induction variable.
- *
- * NOTE (@xrouth): May switch to using SCEV to represent induction vairables, for now we assume only basic induction variables
- * with a constant update (not even linear). Eventually add dynamic constant updates, and linear updates
+#[derive(Clone, Debug)]
+pub struct Loop {
+ pub header: NodeID,
+ pub control: NodeVec, //
+}
+
+impl Loop {
+ pub fn get_all_nodes(&self) -> NodeVec {
+ let mut all_loop_nodes = self.control.clone();
+ all_loop_nodes.set(self.header.idx(), true);
+ all_loop_nodes
+ }
+}
+
+nest!{
+/** Represents a basic induction variable.
+ NOTE (@xrouth): May switch to using SCEV to represent induction vairables, for now we assume only basic induction variables
+ with a constant update (not even linear). Eventually add dynamic constant updates, and linear updates
*/
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct BasicInductionVariable {
pub node: NodeID,
pub initializer: NodeID,
pub update: NodeID, // TODO: Assume only *constants*, not dynamic constants for now.
+ pub bound: Option<
+ #[derive(Clone, Copy, Debug, PartialEq)]
+ enum LoopBound {
+ DynamicConstant(DynamicConstantID),
+ Constant(ConstantID),
+ Variable(NodeID),
+ Unbounded,
+ },
+ >,
}
+} // nest
/** Given a loop (from LoopTree) determine for each data node if. Queries on control nodes are undefined. */
-pub fn compute_loop_variance(function: &Function, loop_nodes: &(BitVec<u8, Lsb0>, NodeID)) -> LoopVarianceInfo {
- let (loop_inner_control_nodes, loop_header) = loop_nodes;
-
+pub fn compute_loop_variance(function: &Function, l: &Loop) -> LoopVarianceInfo {
// Gather all Phi nodes that are controlled by this loop.
let mut loop_vars: Vec<NodeID> = vec![];
for (node_id, node) in function.nodes.iter().enumerate() {
if let Some((control, _)) = node.try_phi() {
- if loop_inner_control_nodes[control.idx()] {
+ if l.control[control.idx()] {
loop_vars.push(NodeID::new(node_id));
}
}
@@ -76,13 +99,16 @@ pub fn compute_loop_variance(function: &Function, loop_nodes: &(BitVec<u8, Lsb0>
let len = function.nodes.len();
- let mut all_loop_nodes = loop_inner_control_nodes.clone();
+ let mut all_loop_nodes = l.control.clone();
- all_loop_nodes.set(loop_header.idx(), true);
+ all_loop_nodes.set(l.header.idx(), true);
let mut variance_map: DenseNodeMap<LoopVariance> = vec![LoopVariance::Unknown; len];
- fn recurse(function: &Function, node: NodeID, all_loop_nodes: &BitVec<u8, Lsb0>, variance_map: & mut DenseNodeMap<LoopVariance>, visited: &mut DenseNodeMap<bool>) -> LoopVariance {
+ fn recurse(function: &Function, node: NodeID, all_loop_nodes: &BitVec<u8, Lsb0>,
+ variance_map: &mut DenseNodeMap<LoopVariance>, visited: &mut DenseNodeMap<bool>)
+ -> LoopVariance {
+
if visited[node.idx()] {
return variance_map[node.idx()];
}
@@ -128,136 +154,21 @@ pub fn compute_loop_variance(function: &Function, loop_nodes: &(BitVec<u8, Lsb0>
recurse(function, node, &all_loop_nodes, &mut variance_map, &mut visited);
};
- return LoopVarianceInfo { loop_header: *loop_header, map: variance_map };
+ return LoopVarianceInfo { loop_header: l.header, map: variance_map };
}
-
nest! {
- #[derive(Debug)]
- pub enum ReductionablePHI {
- Normal(NodeID),
- NDimensional {
- phi_node: NodeID,
- reduction_node: NodeID
- }
- }
-}
-
-impl ReductionablePHI {
- pub fn get_phi(&self) -> NodeID {
- match self {
- ReductionablePHI::Normal(node_id) => *node_id,
- ReductionablePHI::NDimensional { phi_node, reduction_node } => *phi_node,
- }
- }
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum LoopExit {
+ Conditional {
+ if_node: NodeID,
+ condition_node: NodeID,
+ },
+ Unconditional(NodeID) // Probably a region.
}
-
-
-/** To convert a phi into a reduce we need to check that every cycle containing the PHI does not contain any other PHI.
- * I think this restriction can be loosened (more specified)
- * - Every cycle *in the loop* containing the PHI does not contain any other PHI. Or something, IDK.
- * -
- * We also need to make it not control dependent on anything other than the loop header. */
-pub fn check_reductionable_phis(function: &Function, editor: &FunctionEditor, control_subgraph: &Subgraph,
- loop_nodes: &(BitVec<u8, Lsb0>, NodeID), induction_vars: &[BasicInductionVariable],
- loop_variance: &LoopVarianceInfo, phis: &[NodeID])
- -> impl IntoIterator<Item = ReductionablePHI>
- {
-
- // FIXME: (@xrouth)
- // Check that the PHI actually has a cycle back to it.
- let mut reductionable_phis: Vec<NodeID> = vec![];
-
- for phi in phis {
- // do WFS
- let mut other_phi_on_path: DenseNodeMap<bool> = vec![false; function.nodes.len()];
- // let mut reduce_on_path: DenseNodeMap<Option<NodeID>> = vec![None; function.nodes.len()];
-
- let mut bag_of_control_nodes: Vec<NodeID> = vec![*phi];
- let mut visited: DenseNodeMap<bool> = vec![false; function.nodes.len()];
-
- while !bag_of_control_nodes.is_empty() {
- let node = bag_of_control_nodes.pop().unwrap();
-
- if visited[node.idx()] {
- continue;
- }
- visited[node.idx()] = true;
-
- if function.nodes[node.idx()].is_phi() && node != *phi{
- other_phi_on_path[node.idx()] = true;
- }
-
- // if function.nodes[node.idx()].is_reduce() {
- // reduce_on_path[node.idx()] = Some(node);
- // }
-
- // Get node's users or users of node?. I concede that these actually are the same thing.
- // IT is NOT OBVIOUS THOUGH! rename plz? get_users_of()?
- for succ in editor.get_users(node) {
- // If we change, mark as unvisited.
- if other_phi_on_path[node.idx()] && other_phi_on_path[succ.idx()] == false {
- other_phi_on_path[succ.idx()] = true;
- visited[succ.idx()] = false;
- bag_of_control_nodes.push(succ.clone());
- }
- }
- }
-
- if other_phi_on_path[phi.idx()] == false {
- // if reduce_on_path[phi.idx()].is_some() {
- // let reduce = reduce_on_path[phi.idx()].unwrap();
- // reductionable_phis.push(ReductionablePHI::NDimensional { phi_node: phi.clone(), reduction_node: reduce })
- // } else {
- reductionable_phis.push(phi.clone());
- // }
- }
- }
-
- // Check if the PHIs are in cycles with redutions via pattern matching
- let mut n_dimensional_candidates: Vec<ReductionablePHI> = vec![];
-
- // Jesus what a mess. FIXME: (@xrouth).
- for phi_id in &reductionable_phis {
- let (control, data) = function.nodes[phi_id.idx()].try_phi().unwrap();
- for data_id in data {
- if let Some((control, init, reduct)) = function.nodes[data_id.idx()].try_reduce() {
- if init == *phi_id {
- n_dimensional_candidates.push(ReductionablePHI::NDimensional
- { phi_node: phi_id.clone(), reduction_node: data_id.clone()});
- break;
- }
- } else {
- continue;
- }
- }
- }
-
- println!("n_dimensional_candiates: {:?}", n_dimensional_candidates);
-
- let final_phis = if n_dimensional_candidates.len() > 0 {
- n_dimensional_candidates
- } else {
- reductionable_phis.into_iter().map(|phi| ReductionablePHI::Normal(phi)).collect()
- };
-
- println!("reductionable phis: {:?}", final_phis);
- final_phis
}
-/** Given loop information, returns the Node that makes the loop bound, and the NodeID representing the loop bound */
-pub fn compute_loop_bounds(function: &Function, control_subgraph: &Subgraph, loop_nodes: &(BitVec<u8, Lsb0>, NodeID),
- induction_vars: &[BasicInductionVariable], loop_variance: &LoopVarianceInfo) -> Option<(BasicInductionVariable, NodeID, NodeID)> {
-
- let (loop_inner_control_nodes, loop_header) = loop_nodes;
-
- // We assume we *only* care about trip counts / loop bounds.
-
- // Answers the question which PHI node does this loop depend on,
- // Q: What happens if it is a PHI + expression, i.e i = 0; i + 2 < 6; i++
- // A: Some transformation that changes this to i < 6 - 2? i.e don't worry about this here.
-
- // Get loop condition:
+pub fn get_loop_exit_conditions(function: &Function, l: &Loop, control_subgraph: &Subgraph) -> Option<LoopExit> { // impl IntoIterator<Item = LoopExit>
// DFS Traversal on loop control subgraph until we find a node that is outside the loop, find the last IF on this path.
let mut last_if_on_path: DenseNodeMap<Option<NodeID>> = vec![None; function.nodes.len()];
// FIXME: (@xrouth) THIS IS MOST CERTAINLY BUGGED
@@ -266,7 +177,7 @@ pub fn compute_loop_bounds(function: &Function, control_subgraph: &Subgraph, loo
// FIXME: (@xrouth) Right now we assume only one exit from the loop, later: check for multiple exits on the loop,
// either as an assertion here or some other part of forkify or analysis.
- let mut bag_of_control_nodes = vec![loop_header.clone()];
+ let mut bag_of_control_nodes = vec![l.header];
let mut visited: DenseNodeMap<bool> = vec![false; function.nodes.len()];
let mut final_if: Option<NodeID> = None;
@@ -286,7 +197,7 @@ pub fn compute_loop_bounds(function: &Function, control_subgraph: &Subgraph, loo
last_if_on_path[node.idx()]
};
- if !loop_inner_control_nodes[node.idx()] {
+ if !l.control[node.idx()] {
break;
}
@@ -296,31 +207,64 @@ pub fn compute_loop_bounds(function: &Function, control_subgraph: &Subgraph, loo
}
}
- // We have found the node that exits the loop.
- let loop_condition = match final_if {
- Some(v) => v,
- None => return None,
- };
+ final_if.map(|v| {LoopExit::Conditional {
+ if_node: v,
+ condition_node: if let Node::If{ control: _, cond } = function.nodes[v.idx()] {cond} else {unreachable!()}
+ // CODE STYLE: Its this ^ or function.nodes[v.idx()].try_if().unwrap().1;
+ // I prefer to epxlicitly specify what field of the IF I want (instead of using .1), so slightly more verbose is okay?
+ }})
+}
+
+/** Add bounds to induction variables that don't have a currently known bound.
+ - Induction variables that aren't immediately used in a loop condition will not be bounded. For now, we don't return these at all.
+ - *The single* induction variable used in a loop condition will be given an appropriate bound.
+
+ Returns the single induction variable that is used in the loop exit condition, or None if something is wrong.
+ (CODE STYLE: Context w/ None, look into Anyhow::RESULT? )
+
+ */
+pub fn bound_induction_variables(function: &Function, control_subgraph: &Subgraph, l: &Loop,
+ induction_vars: &[BasicInductionVariable], loop_condition: &LoopExit, loop_variance: &LoopVarianceInfo)
+ -> Option<BasicInductionVariable> {
- println!("loop condition: {:?}", loop_condition);
+ // Answers the question which PHI node does this loop depend on,
+ // Q: What happens if it is a PHI + expression, i.e i = 0; i + 2 < 6; i++
+
+
+ // Q: What happens when the loop exit condition isn't based on simple bound, i.e: i < 6 - 2?
+ // A: IDK!
+
+ // Q: What happens when the loop condition is based on multiple induction variables, i.e: (i + j < 20)
+ // A: IDK!
+
+ assert!(matches!(loop_condition, LoopExit::Conditional { .. }));
+ // CODE STYLE: Make this more rust-y.
+ let (exit_if_node, loop_condition) = match loop_condition {
+ LoopExit::Conditional { if_node, condition_node } => (if_node, condition_node),
+ LoopExit::Unconditional(node_id) => todo!()
+ };
+
// Check for an induction variable that interacts reasonably with the loop condition via pattern matching.
for induction_var in induction_vars {
- // Check for
let (_, condition) = function.nodes[loop_condition.idx()].try_if().unwrap();
let bound = match &function.nodes[condition.idx()] {
+ // All of these node types are valid boolean conditionals, we only handle some currently.
+
+ // CODE STYLE: I'm not sure the best way to handle this in the code, I want to return `None` for correctness,
+ // but also I want to attach the context that it is `None` only because it is unimplemented (laziness), not
+ // user error.
Node::Phi { control, data } => todo!(),
Node::Reduce { control, init, reduct } => todo!(),
Node::Parameter { index } => todo!(),
Node::Constant { id } => todo!(),
Node::Unary { input, op } => todo!(),
+ Node::Ternary { first, second, third, op } => todo!(),
Node::Binary { left, right, op } => {
match op {
BinaryOperator::LT => {
- // Need to check for loops
- println!("induction var: {:?}", induction_var);
- println!("left, right {:?}, {:?}", left, right);
+ // Check for a loop guard condition.
// left < right
if *left == induction_var.node &&
(function.nodes[right.idx()].is_constant() || function.nodes[right.idx()].is_dynamic_constant()) {
@@ -339,40 +283,51 @@ pub fn compute_loop_bounds(function: &Function, control_subgraph: &Subgraph, loo
}
}
- Node::Ternary { first, second, third, op } => todo!(),
_ => None,
};
- match bound {
- Some(v) => return Some((*induction_var, *v, loop_condition)),
- None => (),
- }
+ // Simplify our representation of the bound here.
+ // NodeID -> LoopBound
+ let bound = bound.map(|bound|
+ {
+ match function.nodes[bound.idx()] {
+ Node::Constant { id } => LoopBound::Constant(id),
+ Node::DynamicConstant { id } => LoopBound::DynamicConstant(id),
+ _ => todo!(),
+ }
+ }
+ );
+
+ return Some(BasicInductionVariable {
+ node: induction_var.node,
+ initializer: induction_var.initializer,
+ update: induction_var.update,
+ bound: bound,
+ });
}
None
}
-
-
-pub fn compute_induction_vars(function: &Function, loop_nodes: &(BitVec<u8, Lsb0>, NodeID), loop_variance: &LoopVarianceInfo) -> Vec<BasicInductionVariable> {
- let (loop_inner_control_nodes, loop_header) = loop_nodes;
-
+pub fn compute_induction_vars(function: &Function, l: &Loop, loop_variance: &LoopVarianceInfo)
+ -> Vec<BasicInductionVariable> {
+
+ // 1) Gather PHIs contained in the loop.
+ // FIXME: (@xrouth) Should this just be PHIs controlled by the header?
let mut loop_vars: Vec<NodeID> = vec![];
for (node_id, node) in function.nodes.iter().enumerate() {
if let Some((control, _)) = node.try_phi() {
- if loop_inner_control_nodes[control.idx()] {
+ if l.control[control.idx()] {
loop_vars.push(NodeID::new(node_id));
}
}
}
- println!("loop_vars: {:?}", loop_vars);
// FIXME: (@xrouth) For now, only compute variables that have one assignment, (look into this:) possibly treat multiple assignment as separate induction variables.
-
let mut induction_variables: Vec<BasicInductionVariable> = vec![];
- /* 1) For each PHI controlled by the loop, check how it is modified */
+ /* For each PHI controlled by the loop, check how it is modified */
// It's initializer needs to be loop invariant, it's update needs to be loop variant.
for phi_id in loop_vars {
@@ -383,7 +338,7 @@ pub fn compute_induction_vars(function: &Function, loop_nodes: &(BitVec<u8, Lsb0
// The initializer index is the first index of the inputs to the region node of that isn't in the loop. (what is loop_header, wtf...)
// FIXME (@xrouth): If there is control flow in the loop, we won't find
- let Some(initializer_idx) = region_inputs.iter().position(|&node_id| !loop_inner_control_nodes[node_id.idx()]) else {
+ let Some(initializer_idx) = region_inputs.iter().position(|&node_id| !l.control[node_id.idx()]) else {
continue;
};
@@ -425,6 +380,7 @@ pub fn compute_induction_vars(function: &Function, loop_nodes: &(BitVec<u8, Lsb0
node: phi_id,
initializer: initializer_id,
update: b,
+ bound: None,
});
} else if b == phi_id && function.nodes[a.idx()].is_constant() {
@@ -432,6 +388,7 @@ pub fn compute_induction_vars(function: &Function, loop_nodes: &(BitVec<u8, Lsb0
node: phi_id,
initializer: initializer_id,
update: a,
+ bound: None,
});
}
}
diff --git a/hercules_test/hercules_interpreter/src/value.rs b/hercules_test/hercules_interpreter/src/value.rs
index 39158649..34a7495d 100644
--- a/hercules_test/hercules_interpreter/src/value.rs
+++ b/hercules_test/hercules_interpreter/src/value.rs
@@ -218,7 +218,8 @@ impl<'a> InterpreterVal {
InterpreterVal::UnsignedInteger64(v.try_into().unwrap())
}
InterpreterVal::DynamicConstant(_) => {
- panic!("PANIC: Some math on dynamic constants is unimplemented")
+ InterpreterVal::UnsignedInteger64(v.try_into().unwrap())
+ //panic!("PANIC: Some math on dynamic constants is unimplemented")
}
// InterpreterVal::ThreadID(_) => InterpreterVal::Boolean(v),
_ => panic!("PANIC: Some math on dynamic constants is unimplemented"),
@@ -246,7 +247,8 @@ impl<'a> InterpreterVal {
InterpreterVal::UnsignedInteger64(v.try_into().unwrap())
}
InterpreterVal::DynamicConstant(_) => {
- panic!("PANIC: Some math on dynamic constants is unimplemented")
+ InterpreterVal::UnsignedInteger64(v.try_into().unwrap())
+ //panic!("PANIC: Some math on dynamic constants is unimplemented")
}
_ => panic!("PANIC: Some math on dynamic constants is unimplemented"),
},
--
GitLab
From 353723a8b71e42b8326fd5c86cf6ab98b7261e07 Mon Sep 17 00:00:00 2001
From: Xavier Routh <xrouth2@illinois.edu>
Date: Wed, 25 Dec 2024 19:03:53 -0500
Subject: [PATCH 16/68] more forkify cleanup
---
hercules_ir/src/verify.rs | 8 +-
hercules_opt/src/ccp.rs | 6 +-
hercules_opt/src/forkify.rs | 319 +++++++++---------
hercules_opt/src/ivar.rs | 6 +-
.../hercules_tests/tests/loop_tests.rs | 39 ++-
.../test_inputs/forkify/inner_fork.hir | 22 ++
.../forkify/inner_fork_complex.hir | 32 ++
7 files changed, 264 insertions(+), 168 deletions(-)
create mode 100644 hercules_test/test_inputs/forkify/inner_fork.hir
create mode 100644 hercules_test/test_inputs/forkify/inner_fork_complex.hir
diff --git a/hercules_ir/src/verify.rs b/hercules_ir/src/verify.rs
index 83ee5a50..a24a386f 100644
--- a/hercules_ir/src/verify.rs
+++ b/hercules_ir/src/verify.rs
@@ -303,7 +303,7 @@ fn verify_structure(
}
}
}
- // Collect nodes must depend on a join node.
+ // Reduce nodes must depend on a join node.
Node::Reduce {
control,
init: _,
@@ -311,7 +311,7 @@ fn verify_structure(
} => {
if let Node::Join { control: _ } = function.nodes[control.idx()] {
} else {
- Err("Collect node's control input must be a join node.")?;
+ Err("Reduce node's control input must be a join node.")?;
}
}
// Return nodes must have no users.
@@ -501,8 +501,8 @@ fn verify_dominance_relationships(
// Every use of a thread ID must be postdominated by
// the thread ID's fork's corresponding join node. We
// don't need to check for the case where the thread ID
- // flows through the collect node out of the fork-join,
- // because after the collect, the thread ID is no longer
+ // flows through the reduce node out of the fork-join,
+ // because after the reduce, the thread ID is no longer
// considered an immediate control output use.
if postdom.contains(this_id)
&& !postdom.does_dom(*fork_join_map.get(&control).unwrap(), this_id)
diff --git a/hercules_opt/src/ccp.rs b/hercules_opt/src/ccp.rs
index b8eb57ca..cabb2fac 100644
--- a/hercules_opt/src/ccp.rs
+++ b/hercules_opt/src/ccp.rs
@@ -384,11 +384,11 @@ fn ccp_flow_function(
// If node has only one output, if doesn't directly handle crossover of
// reachability and constant propagation. Read handles that.
Node::If { control, cond } => {
- assert!(!inputs[control.idx()].is_reachable() || inputs[cond.idx()].is_reachable());
+ // assert!(!inputs[control.idx()].is_reachable() || inputs[cond.idx()].is_reachable());
inputs[control.idx()].clone()
}
Node::Match { control, sum } => {
- assert!(!inputs[control.idx()].is_reachable() || inputs[sum.idx()].is_reachable());
+ // assert!(!inputs[control.idx()].is_reachable() || inputs[sum.idx()].is_reachable());
inputs[control.idx()].clone()
}
Node::Fork {
@@ -437,7 +437,7 @@ fn ccp_flow_function(
} => {
let reachability = inputs[control.idx()].reachability.clone();
if reachability == ReachabilityLattice::Reachable {
- assert!(inputs[init.idx()].is_reachable());
+ // assert!(inputs[init.idx()].is_reachable());
let mut constant = inputs[init.idx()].constant.clone();
if inputs[reduct.idx()].is_reachable() {
constant = ConstantLattice::meet(&constant, &inputs[reduct.idx()].constant);
diff --git a/hercules_opt/src/forkify.rs b/hercules_opt/src/forkify.rs
index 26f2daed..ea0f7f58 100644
--- a/hercules_opt/src/forkify.rs
+++ b/hercules_opt/src/forkify.rs
@@ -21,6 +21,8 @@ use crate::get_loop_exit_conditions;
use crate::BasicInductionVariable;
use crate::FunctionEditor;
use crate::Loop;
+use crate::LoopBound;
+use crate::LoopExit;
use crate::LoopVarianceInfo;
use self::hercules_ir::def_use::*;
@@ -105,40 +107,56 @@ pub fn loop_data_location(function: &Function, node: NodeID, all_loop_nodes: &Bi
/** Given a node used as a loop bound, return a dynamic constant ID. */
fn get_dc_bound(editor: &mut FunctionEditor, bound: LoopBound) -> Result<DynamicConstantID, String> {
// Check for a constant used as loop bound.
- let function = editor.func();
+ match bound {
+ LoopBound::DynamicConstant(dynamic_constant_id) => {
+ Ok(dynamic_constant_id)
+ }
+ LoopBound::Constant(constant_id) => {
+ let dc = match *editor.get_constant(constant_id) {
+ Constant::Integer8(x) => DynamicConstant::Constant(x as _),
+ Constant::Integer16(x) => DynamicConstant::Constant(x as _),
+ Constant::Integer32(x) => DynamicConstant::Constant(x as _),
+ Constant::Integer64(x) => DynamicConstant::Constant(x as _),
+ Constant::UnsignedInteger8(x) => DynamicConstant::Constant(x as _),
+ Constant::UnsignedInteger16(x) => DynamicConstant::Constant(x as _),
+ Constant::UnsignedInteger32(x) => DynamicConstant::Constant(x as _),
+ Constant::UnsignedInteger64(x) => DynamicConstant::Constant(x as _),
+ _ => return Err("Invalid constant as loop bound".to_string()),
+ };
- if let Some(bound_dc_id) = function.nodes[bound.idx()].try_dynamic_constant() {
- Ok(bound_dc_id)
- } else if let Some(bound_c_id) = function.nodes[bound.idx()].try_constant() {
- // Create new dynamic constant that reflects this constant.
- let dc = match *editor.get_constant(bound_c_id) {
- Constant::Integer8(x) => DynamicConstant::Constant(x as _),
- Constant::Integer16(x) => DynamicConstant::Constant(x as _),
- Constant::Integer32(x) => DynamicConstant::Constant(x as _),
- Constant::Integer64(x) => DynamicConstant::Constant(x as _),
- Constant::UnsignedInteger8(x) => DynamicConstant::Constant(x as _),
- Constant::UnsignedInteger16(x) => DynamicConstant::Constant(x as _),
- Constant::UnsignedInteger32(x) => DynamicConstant::Constant(x as _),
- Constant::UnsignedInteger64(x) => DynamicConstant::Constant(x as _),
- _ => return Err("Invalid constant as loop bound".to_string()),
- };
-
- // TODO: ABSOLUTELY NO WAY THIS IS INTENDED USAGE
- let mut b = DynamicConstantID::new(0);
- editor.edit(
- |mut edit| {
- b = edit.add_dynamic_constant(dc);
- Ok(edit)
- }
- );
- // Return the ID of the dynamic constant that is generated from the constant
- // or dynamic constant that is the existing loop bound
- Ok(b)
- } else {
- Err("Bound is not constant or dynamic constant".to_string())
+ let mut b = DynamicConstantID::new(0);
+ editor.edit(
+ |mut edit| {
+ b = edit.add_dynamic_constant(dc);
+ Ok(edit)
+ }
+ );
+ // Return the ID of the dynamic constant that is generated from the constant
+ // or dynamic constant that is the existing loop bound
+ Ok(b)
+ }
+ LoopBound::Variable(node_id) => todo!(),
+ LoopBound::Unbounded => Err("Bound is not constant or dynamic constant".to_string()),
}
}
+fn all_same_variant<I, T>(mut iter: I) -> bool
+where
+ I: Iterator<Item = T>
+{
+ // Empty iterator case - return true
+ let first = match iter.next() {
+ None => return true,
+ Some(val) => val,
+ };
+
+ // Get discriminant of first item
+ let first_discriminant = std::mem::discriminant(&first);
+
+ // Check all remaining items have same discriminant
+ iter.all(|x| std::mem::discriminant(&x) == first_discriminant)
+}
+
/*
* Top level function to convert natural loops with simple induction variables
* into fork-joins.
@@ -152,18 +170,17 @@ pub fn forkify_loop(
// TODO: Do we want to run analysizes before, I think it's fine to put them in the pass itself.
// i.e no real split between analysis and transformation.
-
let function = editor.func();
-
let loop_pred = editor.get_uses(l.header)
.filter(|id| !l.control[id.idx()])
.next()
.unwrap();
-
let Some(loop_condition) = get_loop_exit_conditions(function, l, control_subgraph) else {return};
+ let LoopExit::Conditional { if_node: loop_if, condition_node } = loop_condition.clone() else {return};
+
// Compute loop variance
let loop_variance = compute_loop_variance(function, &l);
@@ -183,13 +200,16 @@ pub fn forkify_loop(
// Check if the reductionable phi is in a cycle with a reduce, if it is, we probably have to make a multi-dimensional fork.
// FIXME: You can actually just pattern match, you shouldn't try to handle expresions inbetween reductions.
- let reductionable_phis: Vec<_> = check_reductionable_phis(&editor, &control_subgraph, &l,
- &basic_ivs, &loop_variance, &candidate_phis).into_iter().collect();
+ let reductionable_phis: Vec<_> = analyze_phis(&editor, &candidate_phis).into_iter().collect();
// TODO: Check that *all* phis are reductionable. If they aren't, we can't forkify without splitting the loop.
+ // N-Dimensiinoable PHIs get combined with the reduction,
+ // Non N-Dimensionable PHIS just get convverted to normals reduces.
+
// Check for a constant used as loop bound.
- let bound_dc_id = get_dc_bound(editor, basic_iv.bound);
+ let Some(bound) = basic_iv.bound else {return};
+ let Ok(bound_dc_id) = get_dc_bound(editor, bound) else {return};
// START EDITING
@@ -219,86 +239,107 @@ pub fn forkify_loop(
let function = editor.func();
- // Get the control portions of the loop that need to be grafted.
- let loop_exit_projection = editor.get_users(loop_condition)
- .filter(|id| !body[id.idx()])
+ // Get the control portions of the loop.
+ let loop_exit_projection = editor.get_users(loop_if)
+ .filter(|id| !l.control[id.idx()])
.next()
.unwrap();
- let loop_continue_projection = editor.get_users(loop_condition)
- .filter(|id| body[id.idx()])
+ let loop_continue_projection = editor.get_users(loop_if)
+ .filter(|id| l.control[id.idx()])
.next()
.unwrap();
- let header_uses: Vec<_> = editor.get_uses(header).collect();
- println!("editor uses header {:?}: {:?}", header, header_uses );
+ let header_uses: Vec<_> = editor.get_uses(l.header).collect();
+
+ // TOOD: Handle multiple loop body lasts.
+ // If there are multiple candidates for loop body last, return.
+ if editor.get_uses(l.header)
+ .filter(|id| l.control[id.idx()])
+ .count() > 1 {
+ return;
+ }
- let loop_body_last = editor.get_uses(header)
- .filter(|id| body[id.idx()])
+ let loop_body_last = editor.get_uses(l.header)
+ .filter(|id| l.control[id.idx()])
.next()
.unwrap();
+
+ if reductionable_phis.iter()
+ .any(|phi| matches!(phi, LoopPHI::LoopDependant(_))) {
+ return
+ }
+
+ // Check if all loop PHIs are the same type.
+ if !all_same_variant(reductionable_phis.iter()) {
+ return
+ }
- println!("loop_body_last: {:?} ", loop_body_last);
- // Check if we need to make an NDimensional Fork + Join
- // If we do, we do the following:
- // - We need to make a new reduce for each NDimensional reductionable PHI.
- // - The reduce is a combination of the reduce it is in a cycle with, and the reductionable PHI.
- // - We need to update the fork bounds to add an outer dimension that is this loops bounds
- // - We need to create a new threadID (this is easy actually, its the same as the non-fused case. )
+ // Analyze the control that is inside the loop:
+ // FOR NOW: Assume basic structure where loop header is region, unconditionally goes to if, and then branches to continue or exit projections.
- // What happens if only some of the reductionable phis are n dimensions...
+ // 1) If there is any control between header and loop condition, exit.
+ let header_control_users: Vec<_> = editor.get_users(l.header)
+ .filter(|id| function.nodes[id.idx()].is_control())
+ .collect();
- // I think we want basic loop splitting.
-
- // For now, all PHIs besides the induction variable must be ndimensionalable
- let make_n_dims = reductionable_phis.iter()
- .all(|phi| matches!(phi, ReductionablePHI::NDimensional { phi_node, reduction_node }));
-
- // If there is an inner fork, but PHIs that aren't Reductionable
- // (well maybe they can be reductionable and not involve the )
- // this isn't the correct condition.
-
- // All PHIs need to be NDimensionable (simple expression w/r to the reduction node)
- // OR not involve the reduction node at all.
- let inner_fork = editor.get_users(loop_continue_projection).next();
+ if header_control_users.first() != Some(&loop_if) {
+ return
+ }
- //
+ // Graft everything between loop_continue_projection (deleted) and header (deleted).
+ // Attach join to right before header (after loop_body_last, unless loop body last *is* the header).
+ // Attach fork to right after loop_continue_projection.
// Create fork and join nodes:
let mut join_id = NodeID::new(0);
let mut fork_id = NodeID::new(0);
+ let mut thread_id_id = NodeID::new(0);
+
+ let make_n_dims = reductionable_phis.iter()
+ .all(|phi| matches!(phi, LoopPHI::NDimensional { phi_node, reduction_node }));
+
+ // Either every phi is NDimensionalable, or none of them are. Handle these cases separately.
- // If there is control between continue projection and header, attach join to last thing before header:
- // If there is control between header and loop conition: BLARGH
+ let function = editor.func();
+ // Add to an existing inner fork + join pair:
+ // - We need to make a new reduce for each NDimensional reductionable PHI.
+ // - The reduce is a combination of the reduce it is in a cycle with, and the reductionable PHI.
+ // - We need to update the fork bounds to add an outer dimension that is this loops bounds
+ // - We need to create a new threadID (this is easy actually, its the same as the non-fused case. )
// FIXME (@xrouth): Check for this:
- // If there is any complicated control either, then don't make it n-dimensional
+ // If there is any complicated control either, then don't forkify.
// 1) between the continue projection and the fork
// 2) bewteen the header and the loop condition
// but not
// 3) in between the inner fork and join. (control here is okay), because we don't have to deal with it.
if make_n_dims {
// If there is no inner fork / join, fall back to normal.
- println!("loop_continue_project: {:?}", loop_continue_projection);
- let inner_fork = editor.get_users(loop_continue_projection).next();
+ let Some(LoopPHI::NDimensional { phi_node, reduction_node }) = reductionable_phis.first() else {return};
+
+ let (inner_join, init, reduct) = function.nodes[reduction_node.idx()].try_reduce().unwrap();
+
+ let inner_fork = function.nodes[inner_join.idx()].try_join().unwrap();
+
+ if loop_body_last != inner_join {
+ return;
+ }
- match inner_fork {
- Some(_) => todo!(),
- None => todo!(),
+ let Some(loop_body_first) = editor.get_users(loop_continue_projection).next() else {return};
+
+ if loop_body_first != inner_fork {
+ return;
}
- let inner_join = fork_join_map.get(&inner_fork);
+
let (_, fork_dimensions) = function.nodes[inner_fork.idx()].try_fork().unwrap();
let mut new_factors = vec![bound_dc_id];
new_factors.append(&mut fork_dimensions.to_vec()); // FIXME: Might need to be added the other way.
// '0' is innermost dimension.
-
- join_id = match inner_join {
- Some(_) => todo!(),
- None => todo!(),
- };
fork_id = inner_fork;
+ join_id = inner_join;
// I don't actually think you have to convert the ThreadIDs
editor.edit(
@@ -312,9 +353,6 @@ pub fn forkify_loop(
Ok(edit)
}
);
-
- //
-
} else {
// FIXME (@xrouth), handle control in loop body.
editor.edit(
@@ -338,14 +376,10 @@ pub fn forkify_loop(
}
let function = editor.func();
- let induction_variable = basic_ivs.iter().find(|v| iv == **v).unwrap();
- let header_uses: Vec<_> = editor.get_uses(header).collect();
- println!("editor uses header {:?}: {:?}", header, header_uses );
-
let update = *zip(
- editor.get_uses(header),
- function.nodes[induction_variable.node.idx()]
+ editor.get_uses(l.header),
+ function.nodes[basic_iv.node.idx()]
.try_phi()
.unwrap()
.1
@@ -358,14 +392,14 @@ pub fn forkify_loop(
let function = editor.func();
let (_, factors) = function.nodes[fork_id.idx()].try_fork().unwrap();
- let factors = factors.len() - 1;
+ let dimension = factors.len() - 1;
let mut iv_use_location: DenseNodeMap<DataUseLoopLocation> = vec![DataUseLoopLocation::Unknown; function.nodes.len()];
- for node_use in editor.get_users(induction_variable.node) {
+ for node_use in editor.get_users(basic_iv.node) {
let mut visited = vec![false; function.nodes.len()];
- iv_use_location[node_use.idx()] = loop_data_location(function, induction_variable.node, &all_loop_nodes, &mut visited)
+ iv_use_location[node_use.idx()] = loop_data_location(function, basic_iv.node, &l.get_all_nodes(), &mut visited)
}
// Create ThreadID
@@ -375,13 +409,13 @@ pub fn forkify_loop(
|mut edit| {
let thread_id = Node::ThreadID {
control: fork_id,
- dimension: factors,
+ dimension: dimension,
};
let thread_id_id = edit.add_node(thread_id);
let iv_reduce = Node::Reduce {
control: join_id,
- init: induction_variable.initializer,
+ init: basic_iv.initializer,
reduct: update,
};
@@ -396,10 +430,10 @@ pub fn forkify_loop(
// let users = edit.get_users(induction_variable.node);
- println!("replacing all uses of: {:?} with {:?}", induction_variable.node, iv_reduce_id);
+ println!("replacing all uses of: {:?} with {:?}", basic_iv.node, iv_reduce_id);
// Replace uses that are inside with the thread id
- edit = edit.replace_all_uses_where(induction_variable.node, thread_id_id, |node| {
+ edit = edit.replace_all_uses_where(basic_iv.node, thread_id_id, |node| {
match iv_use_location[node.idx()] {
DataUseLoopLocation::Unknown => todo!(),
DataUseLoopLocation::Inside => true,
@@ -408,7 +442,7 @@ pub fn forkify_loop(
})?;
// Replace uses that are outside with the DC
- edit = edit.replace_all_uses_where(induction_variable.node, thread_id_id, |node| {
+ edit = edit.replace_all_uses_where(basic_iv.node, thread_id_id, |node| {
match iv_use_location[node.idx()] {
DataUseLoopLocation::Unknown => todo!(),
DataUseLoopLocation::Inside => false,
@@ -416,13 +450,13 @@ pub fn forkify_loop(
}
})?;
- edit.delete_node(induction_variable.node)
+ edit.delete_node(basic_iv.node)
}
);
if make_n_dims {
for reduction_phi in reductionable_phis {
- let ReductionablePHI::NDimensional { phi_node, reduction_node } = reduction_phi else {
+ let LoopPHI::NDimensional { phi_node, reduction_node } = reduction_phi else {
panic!();
};
@@ -433,7 +467,7 @@ pub fn forkify_loop(
let (control, init, reduct) = function.nodes[reduction_node.idx()].try_reduce().unwrap();
let phi_init = *zip(
- editor.get_uses(header),
+ editor.get_uses(l.header),
function.nodes[phi_node.idx()]
.try_phi()
.unwrap()
@@ -468,7 +502,7 @@ pub fn forkify_loop(
let function = editor.func();
let init = *zip(
- editor.get_uses(header),
+ editor.get_uses(l.header),
function.nodes[reduction_phi.idx()]
.try_phi()
.unwrap()
@@ -482,7 +516,7 @@ pub fn forkify_loop(
// Loop back edge input to phi is the reduction update expression.
let update = *zip(
- editor.get_uses(header),
+ editor.get_uses(l.header),
function.nodes[reduction_phi.idx()]
.try_phi()
.unwrap()
@@ -512,7 +546,7 @@ pub fn forkify_loop(
// Replace all uses of the loop header with the fork
editor.edit(
|mut edit| {
- edit.replace_all_uses(header, fork_id)
+ edit.replace_all_uses(l.header, fork_id)
}
);
@@ -535,8 +569,8 @@ pub fn forkify_loop(
edit = edit.delete_node(loop_continue_projection)?;
// edit = edit.delete_node(loop_false_read)?;
edit = edit.delete_node(loop_exit_projection)?;
- edit = edit.delete_node(loop_condition)?; // Delet ethe if.
- edit = edit.delete_node(header)?;
+ edit = edit.delete_node(loop_if)?; // Delet ethe if.
+ edit = edit.delete_node(l.header)?;
Ok(edit)
}
);
@@ -547,20 +581,22 @@ pub fn forkify_loop(
nest! {
#[derive(Debug)]
- pub enum ReductionablePHI {
- Normal(NodeID),
+ pub enum LoopPHI {
+ Reductionable(NodeID),
NDimensional {
phi_node: NodeID,
reduction_node: NodeID
- }
+ },
+ LoopDependant(NodeID),
}
}
-impl ReductionablePHI {
+impl LoopPHI {
pub fn get_phi(&self) -> NodeID {
match self {
- ReductionablePHI::Normal(node_id) => *node_id,
- ReductionablePHI::NDimensional { phi_node, reduction_node } => *phi_node,
+ LoopPHI::Reductionable(node_id) => *node_id,
+ LoopPHI::NDimensional { phi_node, reduction_node } => *phi_node,
+ LoopPHI::LoopDependant(node_id) => *node_id,
}
}
}
@@ -573,18 +609,14 @@ impl ReductionablePHI {
- Every cycle *in the loop* containing the PHI does not contain any other PHI. Or something, IDK.
-
We also need to make it not control dependent on anything other than the loop header. */
-pub fn check_reductionable_phis(editor: &FunctionEditor, control_subgraph: &Subgraph,
- l: &Loop, induction_vars: &[BasicInductionVariable],
- loop_variance: &LoopVarianceInfo, phis: &[NodeID])
- -> impl IntoIterator<Item = ReductionablePHI>
+pub fn analyze_phis<'a>(editor: &'a FunctionEditor, phis: &'a [NodeID])
+ -> impl Iterator<Item = LoopPHI> + 'a
{
let function = editor.func();
// FIXME: (@xrouth)
// Check that the PHI actually has a cycle back to it.
- let mut reductionable_phis: Vec<NodeID> = vec![];
-
- for phi in phis {
+ phis.into_iter().map(move |phi| {
// do WFS
let mut other_phi_on_path: DenseNodeMap<bool> = vec![false; function.nodes.len()];
// let mut reduce_on_path: DenseNodeMap<Option<NodeID>> = vec![None; function.nodes.len()];
@@ -619,42 +651,21 @@ pub fn check_reductionable_phis(editor: &FunctionEditor, control_subgraph: &Subg
}
if other_phi_on_path[phi.idx()] == false {
- // if reduce_on_path[phi.idx()].is_some() {
- // let reduce = reduce_on_path[phi.idx()].unwrap();
- // reductionable_phis.push(ReductionablePHI::NDimensional { phi_node: phi.clone(), reduction_node: reduce })
- // } else {
- reductionable_phis.push(phi.clone());
- // }
- }
- }
-
- // Check if the PHIs are in cycles with redutions via pattern matching
- let mut n_dimensional_candidates: Vec<ReductionablePHI> = vec![];
-
- // Jesus what a mess. FIXME: (@xrouth).
- for phi_id in &reductionable_phis {
- let (control, data) = function.nodes[phi_id.idx()].try_phi().unwrap();
- for data_id in data {
- if let Some((control, init, reduct)) = function.nodes[data_id.idx()].try_reduce() {
- if init == *phi_id {
- n_dimensional_candidates.push(ReductionablePHI::NDimensional
- { phi_node: phi_id.clone(), reduction_node: data_id.clone()});
- break;
+
+ // Check if the PHIs are in cycles with redutions via pattern matching
+ let (_, data) = function.nodes[phi.idx()].try_phi().unwrap();
+ for data_id in data {
+ if let Some((control, init, _)) = function.nodes[data_id.idx()].try_reduce() {
+ if init == *phi {
+ return LoopPHI::NDimensional {phi_node: phi.clone(), reduction_node: data_id.clone()};
+ }
+ } else {
+ continue;
}
- } else {
- continue;
}
+ return LoopPHI::Reductionable(*phi)
+ } else {
+ LoopPHI::LoopDependant(*phi)
}
- }
-
- println!("n_dimensional_candiates: {:?}", n_dimensional_candidates);
-
- let final_phis = if n_dimensional_candidates.len() > 0 {
- n_dimensional_candidates
- } else {
- reductionable_phis.into_iter().map(|phi| ReductionablePHI::Normal(phi)).collect()
- };
-
- println!("reductionable phis: {:?}", final_phis);
- final_phis
+ })
}
\ No newline at end of file
diff --git a/hercules_opt/src/ivar.rs b/hercules_opt/src/ivar.rs
index 948eab9a..e520a6bb 100644
--- a/hercules_opt/src/ivar.rs
+++ b/hercules_opt/src/ivar.rs
@@ -74,7 +74,7 @@ pub struct BasicInductionVariable {
pub update: NodeID, // TODO: Assume only *constants*, not dynamic constants for now.
pub bound: Option<
#[derive(Clone, Copy, Debug, PartialEq)]
- enum LoopBound {
+ pub enum LoopBound {
DynamicConstant(DynamicConstantID),
Constant(ConstantID),
Variable(NodeID),
@@ -247,9 +247,7 @@ pub fn bound_induction_variables(function: &Function, control_subgraph: &Subgrap
// Check for an induction variable that interacts reasonably with the loop condition via pattern matching.
for induction_var in induction_vars {
- let (_, condition) = function.nodes[loop_condition.idx()].try_if().unwrap();
-
- let bound = match &function.nodes[condition.idx()] {
+ let bound = match &function.nodes[loop_condition.idx()] {
// All of these node types are valid boolean conditionals, we only handle some currently.
// CODE STYLE: I'm not sure the best way to handle this in the code, I want to return `None` for correctness,
diff --git a/hercules_test/hercules_tests/tests/loop_tests.rs b/hercules_test/hercules_tests/tests/loop_tests.rs
index 3c425e50..82368fbd 100644
--- a/hercules_test/hercules_tests/tests/loop_tests.rs
+++ b/hercules_test/hercules_tests/tests/loop_tests.rs
@@ -249,7 +249,6 @@ fn super_nested_loop() {
}
-#[test]
fn interpret_temp() {
let module = parse_module_from_hbin("../../a.hbin");
let len = 5;
@@ -324,13 +323,16 @@ fn control_after_condition() {
/**
* Tests forkify on a loop where there is control before the loop condition, so in between the header
* and the loop condition. This should not forkify.
+ *
+ * This example is bugged, it reads out of bounds even before forkify.
*/
+#[ignore]
#[test]
fn control_before_condition() {
let module = parse_file("../test_inputs/forkify/control_before_condition.hir");
- let size = 10;
- let dyn_consts = [size];
+ let size = 11;
+ let dyn_consts = [size - 1];
let mut vec = vec![0; size];
let mut rng = rand::thread_rng();
@@ -460,4 +462,35 @@ fn nested_tid_sum_2() {
let result_3 = interp_module!(module, dyn_consts, 2);
println!("{:?}, {:?}, {:?}", result_1, result_2, result_3);
+}
+
+
+/** Tests weird control in outer loop for possible 2d fork-join pair. */
+#[test]
+fn inner_fork_complex() {
+ let module = parse_file("../test_inputs/forkify/inner_fork_complex.hir");
+ let dyn_consts = [5, 6];
+ let params = vec![1, 2, 3, 4, 5]; // TODO: (@xrouth) fix macro to take no params as an option.
+ let result_1 = interp_module!(module, dyn_consts, 10);
+
+ println!("result: {:?}", result_1);
+
+ let mut pm = hercules_opt::pass::PassManager::new(module.clone());
+
+ let passes = vec![
+ Pass::Verify,
+ Pass::Forkify,
+ Pass::DCE,
+ Pass::Verify,
+ ];
+
+ for pass in passes {
+ pm.add_pass(pass);
+ }
+ pm.run_passes();
+
+ let module = pm.get_module();
+ let result_2 = interp_module!(module, dyn_consts, 10);
+ assert_eq!(result_1, result_2);
+ println!("{:?}, {:?}", result_1, result_2);
}
\ No newline at end of file
diff --git a/hercules_test/test_inputs/forkify/inner_fork.hir b/hercules_test/test_inputs/forkify/inner_fork.hir
new file mode 100644
index 00000000..e2c96a68
--- /dev/null
+++ b/hercules_test/test_inputs/forkify/inner_fork.hir
@@ -0,0 +1,22 @@
+fn loop<2>(a: u32) -> i32
+ zero_idx = constant(u64, 0)
+ one_idx = constant(u64, 1)
+ zero_var = constant(i32, 0)
+ one_var = constant(i32, 1)
+ inner_bound = dynamic_constant(#0)
+ outer_bound = dynamic_constant(#1)
+ outer_loop = region(start, inner_join)
+ outer_if_true = projection(outer_if, 1)
+ inner_fork = fork(outer_if_true, #0)
+ inner_join = join(inner_fork)
+ outer_var = phi(outer_loop, zero_var, inner_var)
+ inner_var = reduce(inner_fork, outer_var, inner_var_inc)
+ inner_var_inc = add(inner_var, inner_idx)
+ inner_idx = thread_id(inner_fork, 0)
+ outer_idx = phi(outer_loop, zero_idx, outer_idx_inc)
+ outer_idx_inc = add(outer_idx, one_idx)
+ outer_in_bounds = lt(outer_idx, outer_bound)
+ outer_if = if(outer_loop, outer_in_bounds)
+ outer_if_false = projection(outer_if, 0)
+ r = return(outer_if_false, outer_var)
+
\ No newline at end of file
diff --git a/hercules_test/test_inputs/forkify/inner_fork_complex.hir b/hercules_test/test_inputs/forkify/inner_fork_complex.hir
new file mode 100644
index 00000000..91eb00fa
--- /dev/null
+++ b/hercules_test/test_inputs/forkify/inner_fork_complex.hir
@@ -0,0 +1,32 @@
+fn loop<2>(a: u32) -> u64
+ zero_idx = constant(u64, 0)
+ one_idx = constant(u64, 1)
+ zero_var = constant(u64, 0)
+ one_var = constant(u64, 1)
+ ten = constant(u64, 10)
+ two = constant(u64, 2)
+ inner_bound = dynamic_constant(#0)
+ outer_bound = dynamic_constant(#1)
+ outer_loop = region(start, inner_condition_true_projection, inner_condition_false_projection )
+ outer_if_true = projection(outer_if, 1)
+ other_phi_weird = phi(outer_loop, zero_var, inner_var, other_phi_weird)
+ inner_fork = fork(outer_if_true, #0)
+ inner_join = join(inner_fork)
+ inner_condition_eq = eq(outer_idx, two)
+ inner_condition_if = if(inner_join, inner_condition_eq)
+ inner_condition_true_projection = projection(inner_condition_if, 1)
+ inner_condition_false_projection = projection(inner_condition_if, 0)
+ outer_var = phi(outer_loop, zero_var, inner_var, inner_var)
+ inner_var = reduce(inner_join, outer_var, inner_var_inc)
+ inner_var_inc = add(inner_var, inner_var_inc_3)
+ inner_var_inc_2 = mul(ten, outer_idx)
+ inner_var_inc_3 = add(inner_var_inc_2, inner_idx)
+ inner_idx = thread_id(inner_fork, 0)
+ outer_idx = phi(outer_loop, zero_idx, outer_idx_inc, outer_idx_inc)
+ outer_idx_inc = add(outer_idx, one_idx)
+ outer_in_bounds = lt(outer_idx, outer_bound)
+ outer_if = if(outer_loop, outer_in_bounds)
+ outer_if_false = projection(outer_if, 0)
+ ret_val = add(outer_var, other_phi_weird)
+ r = return(outer_if_false, ret_val)
+
\ No newline at end of file
--
GitLab
From 4b85587a7a682ca0793c681f05332e74ae894078 Mon Sep 17 00:00:00 2001
From: Xavier Routh <xrouth2@illinois.edu>
Date: Wed, 25 Dec 2024 19:11:43 -0500
Subject: [PATCH 17/68] loop bound bugfix
---
hercules_opt/src/ivar.rs | 4 ++++
1 file changed, 4 insertions(+)
diff --git a/hercules_opt/src/ivar.rs b/hercules_opt/src/ivar.rs
index e520a6bb..52fa756c 100644
--- a/hercules_opt/src/ivar.rs
+++ b/hercules_opt/src/ivar.rs
@@ -284,6 +284,10 @@ pub fn bound_induction_variables(function: &Function, control_subgraph: &Subgrap
_ => None,
};
+ if bound.is_none() {
+ continue;
+ }
+
// Simplify our representation of the bound here.
// NodeID -> LoopBound
let bound = bound.map(|bound|
--
GitLab
From 0ff095514308d27b34fcf482f113f833c2991a94 Mon Sep 17 00:00:00 2001
From: Xavier Routh <xrouth2@illinois.edu>
Date: Wed, 25 Dec 2024 19:18:48 -0500
Subject: [PATCH 18/68] n-dim bugfix
---
hercules_opt/src/forkify.rs | 6 +++---
1 file changed, 3 insertions(+), 3 deletions(-)
diff --git a/hercules_opt/src/forkify.rs b/hercules_opt/src/forkify.rs
index ea0f7f58..6bf201be 100644
--- a/hercules_opt/src/forkify.rs
+++ b/hercules_opt/src/forkify.rs
@@ -297,8 +297,8 @@ pub fn forkify_loop(
let mut fork_id = NodeID::new(0);
let mut thread_id_id = NodeID::new(0);
- let make_n_dims = reductionable_phis.iter()
- .all(|phi| matches!(phi, LoopPHI::NDimensional { phi_node, reduction_node }));
+ let make_n_dims = if reductionable_phis.is_empty() {false} else {reductionable_phis.iter()
+ .all(|phi| matches!(phi, LoopPHI::NDimensional { phi_node, reduction_node }))};
// Either every phi is NDimensionalable, or none of them are. Handle these cases separately.
@@ -322,7 +322,7 @@ pub fn forkify_loop(
let (inner_join, init, reduct) = function.nodes[reduction_node.idx()].try_reduce().unwrap();
let inner_fork = function.nodes[inner_join.idx()].try_join().unwrap();
-
+
if loop_body_last != inner_join {
return;
}
--
GitLab
From e876bd9f716566ad3bfaaa61a099067ada644e7c Mon Sep 17 00:00:00 2001
From: Xavier Routh <xrouth2@illinois.edu>
Date: Fri, 27 Dec 2024 17:35:47 -0500
Subject: [PATCH 19/68] fork fission intiial"
"
---
hercules_opt/src/editor.rs | 4 +
hercules_opt/src/fork_transforms.rs | 359 ++++++++++++++++++
hercules_opt/src/forkify.rs | 34 +-
hercules_opt/src/lib.rs | 4 +-
hercules_opt/src/pass.rs | 50 +++
.../tests/fork_transform_tests.rs | 134 +++++++
.../tests/{loop_tests.rs => forkify_tests.rs} | 0
.../fork_transforms/fork_fission.hir | 0
.../fork_fission/inner_control.hir | 15 +
.../fork_fission/inner_loop.hir | 23 ++
.../intermediate_buffer_simple.hir | 10 +
.../fork_transforms/fork_fission/simple1.hir | 13 +
.../fork_transforms/fork_fission/simple2.hir | 19 +
.../fork_transforms/fork_fission/tricky.hir | 13 +
14 files changed, 651 insertions(+), 27 deletions(-)
create mode 100644 hercules_opt/src/fork_transforms.rs
create mode 100644 hercules_test/hercules_tests/tests/fork_transform_tests.rs
rename hercules_test/hercules_tests/tests/{loop_tests.rs => forkify_tests.rs} (100%)
delete mode 100644 hercules_test/test_inputs/fork_transforms/fork_fission.hir
create mode 100644 hercules_test/test_inputs/fork_transforms/fork_fission/inner_control.hir
create mode 100644 hercules_test/test_inputs/fork_transforms/fork_fission/inner_loop.hir
create mode 100644 hercules_test/test_inputs/fork_transforms/fork_fission/intermediate_buffer_simple.hir
create mode 100644 hercules_test/test_inputs/fork_transforms/fork_fission/simple1.hir
create mode 100644 hercules_test/test_inputs/fork_transforms/fork_fission/simple2.hir
create mode 100644 hercules_test/test_inputs/fork_transforms/fork_fission/tricky.hir
diff --git a/hercules_opt/src/editor.rs b/hercules_opt/src/editor.rs
index 46606d62..25d2d26b 100644
--- a/hercules_opt/src/editor.rs
+++ b/hercules_opt/src/editor.rs
@@ -283,6 +283,10 @@ impl<'a, 'b> FunctionEdit<'a, 'b> {
self.editor.dynamic_constants.borrow().len() + self.added_dynamic_constants.len()
}
+ pub fn copy_node(&mut self, node: NodeID) -> NodeID {
+ self.add_node(self.editor.func().nodes[node.idx()].clone())
+ }
+
pub fn add_node(&mut self, node: Node) -> NodeID {
let id = NodeID::new(self.editor.function.nodes.len() + self.added_nodeids.len());
// Added nodes need to have an entry in the def-use map.
diff --git a/hercules_opt/src/fork_transforms.rs b/hercules_opt/src/fork_transforms.rs
new file mode 100644
index 00000000..9ce26590
--- /dev/null
+++ b/hercules_opt/src/fork_transforms.rs
@@ -0,0 +1,359 @@
+use std::collections::{HashMap, HashSet};
+use std::ops::Sub;
+extern crate hercules_ir;
+
+use self::hercules_ir::{Index, TypeID};
+
+use self::hercules_ir::Subgraph;
+
+use self::hercules_ir::DynamicConstantID;
+
+use self::hercules_ir::Node;
+
+use self::hercules_ir::{get_uses, Function};
+
+use self::hercules_ir::{NodeID, ID};
+
+use crate::{DenseNodeMap, FunctionEditor, Loop, SparseNodeMap};
+
+type ForkID = usize;
+
+/** Places each reduce node into its own fork */
+pub fn default_reduce_partition(editor: &FunctionEditor, fork: NodeID, join: NodeID) -> SparseNodeMap<ForkID> {
+ let mut map = SparseNodeMap::new();
+
+ editor.get_users(join)
+ .filter(|id| editor.func().nodes[id.idx()].is_reduce())
+ .enumerate()
+ .for_each(|(fork, reduce)| { map.insert(reduce, fork); });
+
+ map
+}
+
+pub fn find_reduce_dependencies<'a>(function: &'a Function, reduce: NodeID, fork: NodeID
+) -> impl IntoIterator<Item = NodeID> + 'a
+{
+ let len = function.nodes.len();
+
+ let mut visited: DenseNodeMap<bool> = vec![false; len];
+ let mut depdendent: DenseNodeMap<bool> = vec![false; len];
+
+ // Does `fork` need to be a parameter here? It never changes. If this was a closure could it just capture it?
+ fn recurse(function: &Function, node: NodeID, fork: NodeID,
+ dependent_map: &mut DenseNodeMap<bool>, visited: &mut DenseNodeMap<bool>
+ ) -> () { // return through dependent_map {
+
+ if visited[node.idx()] {
+ return;
+ }
+
+ visited[node.idx()] = true;
+
+ if node == fork {
+ dependent_map[node.idx()] = true;
+ return;
+ }
+
+ let binding = get_uses(&function.nodes[node.idx()]);
+ let uses = binding.as_ref();
+
+ for used in uses {
+ recurse(function, *used, fork, dependent_map, visited);
+ }
+
+ dependent_map[node.idx()] = uses.iter().map(|id| dependent_map[id.idx()]).any(|a| a);
+ return;
+ }
+
+ // Note: HACKY, the condition wwe want is 'all nodes on any path from the fork to the reduce (in the forward graph), or the reduce to the fork (in the directed graph)
+ // cycles break this, but we assume for now that the only cycles are ones that involve the reduce node
+ // NOTE: (control may break this (i.e loop inside fork) is a cycle that isn't the reduce)
+ // the current solution is just to mark the reduce as dependent at the start of traversing the graph.
+ depdendent[reduce.idx()] = true;
+
+ recurse(function, reduce, fork, &mut depdendent, &mut visited);
+
+ // Return node IDs that are dependent
+ let a: Vec<_> = depdendent.iter().enumerate()
+ .filter_map(|(idx, dependent)| if *dependent {Some(NodeID::new(idx))} else {None})
+ .collect();
+
+ a
+}
+
+pub fn copy_subgraph(editor: &mut FunctionEditor, subgraph: HashSet<NodeID>)
+-> (HashSet<NodeID>, HashMap<NodeID, NodeID>, Vec<(NodeID, NodeID)>) // set of all nodes, set of new nodes, outside node. s.t old node-> outside node exists as an edge.
+{
+ let mut map: HashMap<NodeID, NodeID> = HashMap::new();
+ let mut new_nodes: HashSet<NodeID> = HashSet::new();
+
+ // Copy nodes
+ for old_id in subgraph.iter() {
+ editor.edit(|mut edit|
+ {
+ let new_id = edit.copy_node(*old_id);
+ map.insert(*old_id, new_id);
+ new_nodes.insert(new_id);
+ Ok(edit)
+ }
+ );
+ }
+
+ // Update edges to new nodes
+ for old_id in subgraph.iter() {
+ // Replace all uses of old_id w/ new_id, where the use is in new_node
+ editor.edit(|edit|
+ {
+ edit.replace_all_uses_where(*old_id, map[old_id], |node_id| new_nodes.contains(node_id))
+ }
+ );
+ }
+
+ // Get all users that aren't in new_nodes.
+ let mut outside_users = Vec::new();
+
+ for node in new_nodes.iter() {
+ for user in editor.get_users(*node) {
+ if !new_nodes.contains(&user) {
+ outside_users.push((*node, user));
+ }
+ }
+ }
+
+ (new_nodes, map, outside_users)
+}
+
+pub fn fork_fission<'a> (
+ editor: &'a mut FunctionEditor,
+ control_subgraph: &Subgraph,
+ types: &Vec<TypeID>,
+ fork_join_map: &HashMap<NodeID, NodeID>,
+)-> () {
+ let forks: Vec<_> = editor.func().nodes.iter().enumerate().filter_map(|(idx, node)| {
+ if node.is_fork() {
+ Some(NodeID::new(idx))
+ } else {None}
+ }).collect();
+
+ let mut control_pred = NodeID::new(0);
+
+ // This does the reduction fission:
+ if true {
+ for fork in forks.clone() {
+ // FIXME: If there is control in between fork and join, give up.
+ let join = fork_join_map[&fork];
+ let join_pred = editor.func().nodes[join.idx()].try_join().unwrap();
+ if join_pred != fork {
+ todo!("Can't do fork fission on nodes with internal control")
+ // Inner control LOOPs are hard
+ // inner control in general *should* work right now without modifications.
+ }
+ let reduce_partition = default_reduce_partition(editor, fork, join);
+
+ let (new_fork, new_join) = fork_reduce_fission_helper(editor, fork_join_map, reduce_partition, control_pred, fork);
+ // control_pred = new_join;
+ }}
+
+ // This does the bufferization:
+ // let edge = (NodeID::new(4), NodeID::new(9));
+ // let mut edges = HashSet::new();
+ // edges.insert(edge);
+
+ // let fork = forks.first().unwrap();
+ // fork_bufferize_fission_helper(editor, fork_join_map, edges, NodeID::new(0), types, *fork);
+}
+
+/** Split a 1D fork into two forks, placing select intermediate data into buffers. */
+pub fn fork_bufferize_fission_helper<'a> (
+ editor: &'a mut FunctionEditor,
+ fork_join_map: &HashMap<NodeID, NodeID>,
+ bufferized_edges: HashSet<(NodeID, NodeID)>, // Describes what intermediate data should be bufferized.
+ original_control_pred: NodeID, // What the new fork connects to.
+ types: &Vec<TypeID>,
+ fork: NodeID,
+) -> () {
+ // TODO: Check validititry of bufferized_edges (ask xavier for condition).
+
+ // Copy fork + control intermediates + join to new fork + join,
+ // How does control get partitioned?
+ // (depending on how it affects the data nodes on each side of the bufferized_edges)
+ // may end up in each loop, fix me later.
+ // place new fork + join after join of first.
+
+ // Only handle fork+joins with no inner control for now.
+
+ // Create fork + join + Thread control
+ let join = fork_join_map[&fork];
+ let mut new_fork_id = NodeID::new(0);
+ let mut new_join_id = NodeID::new(0);
+
+ editor.edit(|mut edit| {
+ new_join_id = edit.add_node(Node::Join { control: fork });
+ let factors = edit.get_node(fork).try_fork().unwrap().1.clone();
+ new_fork_id = edit.add_node(Node::Fork { control: new_join_id, factors: factors.into() });
+ edit.replace_all_uses_where(fork, new_fork_id, |usee| *usee == join)
+ });
+
+
+ for (src, dst) in bufferized_edges {
+ // FIXME: Disgusting cloning and allocationing and iteartors.
+ let factors: Vec<_> = editor.func().nodes[fork.idx()].try_fork().unwrap().1.iter().cloned().collect();
+
+ editor.edit(|mut edit|
+ {
+ // Create write to buffer
+
+ let thread_stuff_it = factors.into_iter().enumerate();
+
+ // FIxme: try to use unzip here? Idk why it wasn't working.
+ let (tids) = thread_stuff_it.clone().map(|(dim, factor)|
+ (
+ edit.add_node(Node::ThreadID { control: fork, dimension: dim })
+ )
+ );
+
+ let array_dims = thread_stuff_it.clone().map(|(dim, factor)|
+ (
+ factor
+ )
+ );
+
+ // Assume 1-d fork only for now.
+ // let tid = edit.add_node(Node::ThreadID { control: fork, dimension: 0 });
+ let position_idx = Index::Position(tids.collect::<Vec<_>>().into_boxed_slice());
+ let write = edit.add_node(Node::Write { collect: NodeID::new(0), data: src, indices: vec![position_idx].into() });
+ let ele_type = types[src.idx()];
+ let empty_buffer = edit.add_type(hercules_ir::Type::Array(ele_type, array_dims.collect::<Vec<_>>().into_boxed_slice()));
+ let empty_buffer = edit.add_zero_constant(empty_buffer);
+ let empty_buffer = edit.add_node(Node::Constant { id: empty_buffer });
+ let reduce = Node::Reduce { control: new_join_id, init: empty_buffer, reduct: write };
+ let reduce = edit.add_node(reduce);
+ // Fix write node
+ edit = edit.replace_all_uses_where(NodeID::new(0), reduce, |usee| *usee == write)?;
+
+
+ // Create read from buffer
+ let (tids) = thread_stuff_it.clone().map(|(dim, factor)|
+ (
+ edit.add_node(Node::ThreadID { control: new_fork_id, dimension: dim })
+ )
+ );
+
+ let position_idx = Index::Position(tids.collect::<Vec<_>>().into_boxed_slice());
+
+ let read = edit.add_node(Node::Read { collect: reduce, indices: vec![position_idx].into() });
+
+ edit = edit.replace_all_uses_where(src, read, |usee| *usee == dst)?;
+
+ Ok(edit)
+ }
+ );
+ }
+
+}
+
+/** Split a 1D fork into a separate fork for each reduction. */
+pub fn fork_reduce_fission_helper<'a> (
+ editor: &'a mut FunctionEditor,
+ fork_join_map: &HashMap<NodeID, NodeID>,
+ reduce_partition: SparseNodeMap<ForkID>, // Describes how the reduces of the fork should be split,
+ original_control_pred: NodeID, // What the new fork connects to.
+
+ fork: NodeID,
+) -> (NodeID, NodeID) { // returns Fork, Join pair {
+
+ let join = fork_join_map[&fork];
+ // If there is control in between then j give up.
+
+ let mut new_control_pred: NodeID = original_control_pred;
+
+ // Get nodes to copy
+ // let factors: Box<[DynamicConstantID]> = edit..nodes[fork.idx()].try_fork().unwrap().1.into();
+
+ // None of this matters, just assume we have DCE for control flow.
+ // Make new fork put it after the existing loop (deal with dependencies later.)
+ // Make new join, put it after fork (FIXME: THIS IS WRONG)
+ // Make copies of all control + data nodes, including the reduce and join, with equivalent uses / users, mark them as NEW
+ // - Need an editor utility to copy a subsection of the graph.
+ // 1) Edges going into the subsection stay the same, i.e something new still *uses* something old.
+ // 2) Edges leaving the subsection need to be handled by the user, (can't force outgoing new edges into nodes)
+ // return a list of outgoing (but unattatached) edges + the old destination to the programmer.
+
+ // Important edges are: Reduces,
+
+ // NOTE:
+ // Say two reduce are in a fork, s.t reduce A depends on reduce B
+ // If user wants A and B in separate forks:
+ // - we can simply refuse
+ // - or we can duplicate B
+
+ // OR we can allow reduces to end up in multiple forks, (no restrictions on the reduce->fork mapping function).
+ // And complain when user doesn't put them in the same fork correctly.
+ // for now, DONT HANDLE IT. LOL.
+
+ // NOTE:
+ //
+
+ // Replace all
+ // Replace all uses of (fork, reduce, ) w/ predicate that they are the newly copied nodes.
+ // repalce uses
+
+ let mut new_fork = NodeID::new(0);
+ let mut new_join = NodeID::new(0);
+
+ // Gets everything between fork & join that this reduce needs. (ALL CONTROL)
+ for reduce in reduce_partition {
+ let reduce = reduce.0;
+
+ let function = editor.func();
+ let subgraph = find_reduce_dependencies(function, reduce, fork);
+
+ let mut subgraph: HashSet<NodeID> = subgraph.into_iter().collect();
+
+ subgraph.insert(join);
+ subgraph.insert(fork);
+ subgraph.insert(reduce);
+
+ println!("subgraph for {:?}: \n{:?}", reduce, subgraph);
+
+ let (new_nodes, mapping, _) = copy_subgraph(editor, subgraph);
+
+ println!("new_nodes: {:?} ", new_nodes);
+ println!("mapping: {:?} ",mapping);
+
+ new_fork = mapping[&fork];
+ new_join = mapping[&join];
+
+ editor.edit(|mut edit| {
+ // Atttach new_fork after control_pred
+ let (old_control_pred, factors) = edit.get_node(new_fork).try_fork().unwrap().clone();
+ edit = edit.replace_all_uses_where(old_control_pred, new_control_pred, |usee| *usee == new_fork)?;
+
+ // Replace uses of reduce
+ edit = edit.replace_all_uses(reduce, mapping[&reduce])?;
+ Ok(edit)
+ });
+
+ new_control_pred = new_join;
+ }
+
+
+ editor.edit(|mut edit| {
+ // Replace original join w/ new final join
+ edit = edit.replace_all_uses_where(join, new_join, |_| true)?;
+
+ // Delete original join (all reduce users have been moved)
+ edit = edit.delete_node(join)?;
+
+ // Replace all users of original fork, and then delete it, leftover users will be DCE'd.
+ edit = edit.replace_all_uses(fork, new_fork)?;
+ edit.delete_node(fork)
+ });
+
+
+
+
+
+
+ (new_fork, new_join)
+}
\ No newline at end of file
diff --git a/hercules_opt/src/forkify.rs b/hercules_opt/src/forkify.rs
index 6bf201be..fa899232 100644
--- a/hercules_opt/src/forkify.rs
+++ b/hercules_opt/src/forkify.rs
@@ -30,8 +30,8 @@ use self::hercules_ir::ir::*;
use self::hercules_ir::loops::*;
// Hmm some third variety of this that switches between the two automatically could be fun.
-type DenseNodeMap<T> = Vec<T>;
-type SparseNodeMap<T> = HashMap<NodeID, T>;
+pub type DenseNodeMap<T> = Vec<T>;
+pub type SparseNodeMap<T> = HashMap<NodeID, T>;
pub fn forkify(
editor: &mut FunctionEditor,
@@ -301,21 +301,15 @@ pub fn forkify_loop(
.all(|phi| matches!(phi, LoopPHI::NDimensional { phi_node, reduction_node }))};
// Either every phi is NDimensionalable, or none of them are. Handle these cases separately.
-
let function = editor.func();
- // Add to an existing inner fork + join pair:
- // - We need to make a new reduce for each NDimensional reductionable PHI.
- // - The reduce is a combination of the reduce it is in a cycle with, and the reductionable PHI.
- // - We need to update the fork bounds to add an outer dimension that is this loops bounds
- // - We need to create a new threadID (this is easy actually, its the same as the non-fused case. )
-
- // FIXME (@xrouth): Check for this:
- // If there is any complicated control either, then don't forkify.
- // 1) between the continue projection and the fork
- // 2) bewteen the header and the loop condition
- // but not
- // 3) in between the inner fork and join. (control here is okay), because we don't have to deal with it.
+
if make_n_dims {
+ // To add to an existing inner fork + join pair:
+ // - We need to make a new reduce for each NDimensional reductionable PHI.
+ // - The reduce is a combination of the reduce it is in a cycle with, and the reductionable PHI.
+ // - We need to update the fork bounds to add an outer dimension that is this loops bounds
+ // - We need to create a new threadID (this is easy actually, its the same as the non-fused case. )
+
// If there is no inner fork / join, fall back to normal.
let Some(LoopPHI::NDimensional { phi_node, reduction_node }) = reductionable_phis.first() else {return};
@@ -419,8 +413,6 @@ pub fn forkify_loop(
reduct: update,
};
- let iv_reduce_id = edit.add_node(iv_reduce);
-
// If a user occurs after the loop is finished, we replace it with the DC that is the IV bound,
// If a user occurs inside the loop, we replace it with the IV.
@@ -428,10 +420,6 @@ pub fn forkify_loop(
// any control node on the frontier of control nodes (don't go through users of control nodes) is
// not in the loop body or is not the loop header.
-
- // let users = edit.get_users(induction_variable.node);
- println!("replacing all uses of: {:?} with {:?}", basic_iv.node, iv_reduce_id);
-
// Replace uses that are inside with the thread id
edit = edit.replace_all_uses_where(basic_iv.node, thread_id_id, |node| {
match iv_use_location[node.idx()] {
@@ -492,10 +480,6 @@ pub fn forkify_loop(
);
}
} else {
- // - a) If the PHI is the IV:
- // Uses of the IV become:
- // 1) Inside the loop: Uses of the ThreadID
- // 2) Outside the loop: Uses of the reduction node.
for reduction_phi in reductionable_phis {
let reduction_phi = reduction_phi.get_phi();
diff --git a/hercules_opt/src/lib.rs b/hercules_opt/src/lib.rs
index 0c313280..aa7fe1d0 100644
--- a/hercules_opt/src/lib.rs
+++ b/hercules_opt/src/lib.rs
@@ -13,7 +13,7 @@ pub mod pass;
pub mod phi_elim;
pub mod pred;
pub mod sroa;
-pub mod scev;
+pub mod fork_transforms;
pub mod ivar;
pub mod utils;
@@ -30,7 +30,7 @@ pub use crate::pass::*;
pub use crate::phi_elim::*;
pub use crate::pred::*;
pub use crate::sroa::*;
-pub use crate::scev::*;
+pub use crate::fork_transforms::*;
pub use crate::ivar::*;
pub use crate::utils::*;
diff --git a/hercules_opt/src/pass.rs b/hercules_opt/src/pass.rs
index 2e3d2616..aef40c1e 100644
--- a/hercules_opt/src/pass.rs
+++ b/hercules_opt/src/pass.rs
@@ -44,6 +44,7 @@ pub enum Pass {
Serialize(String),
InterproceduralSROA,
DeleteUncalled,
+ ForkFission,
}
/*
@@ -881,6 +882,55 @@ impl PassManager {
file.write_all(&module_contents)
.expect("PANIC: Unable to write output module file contents.");
}
+ Pass::ForkFission => {
+ self.make_def_uses();
+ self.make_loops();
+ self.make_control_subgraphs();
+ self.make_fork_join_maps();
+ self.make_typing();
+ self.make_doms();
+ let def_uses = self.def_uses.as_ref().unwrap();
+ let loops = self.loops.as_ref().unwrap();
+ let fork_join_maps = self.fork_join_maps.as_ref().unwrap();
+ let types = self.typing.as_ref().unwrap();
+ for idx in 0..self.module.functions.len() {
+ let constants_ref =
+ RefCell::new(std::mem::take(&mut self.module.constants));
+ let dynamic_constants_ref =
+ RefCell::new(std::mem::take(&mut self.module.dynamic_constants));
+ let types_ref = RefCell::new(std::mem::take(&mut self.module.types));
+ let control_subgraph = &self.control_subgraphs.as_ref().unwrap()[idx];
+ let mut editor = FunctionEditor::new(
+ &mut self.module.functions[idx],
+ &constants_ref,
+ &dynamic_constants_ref,
+ &types_ref,
+ &def_uses[idx],
+ );
+
+ fork_fission(
+ &mut editor,
+ control_subgraph,
+ &types[idx], // FIXME: I think types should be gotten from the editor, not this...
+ // because pass can add more typees. Blah. WTF!
+ &fork_join_maps[idx],
+ );
+
+ self.module.constants = constants_ref.take();
+ self.module.dynamic_constants = dynamic_constants_ref.take();
+ self.module.types = types_ref.take();
+
+ let edits = &editor.edits();
+ if let Some(plans) = self.plans.as_mut() {
+ repair_plan(&mut plans[idx], &self.module.functions[idx], edits);
+ }
+ let grave_mapping = self.module.functions[idx].delete_gravestones();
+ if let Some(plans) = self.plans.as_mut() {
+ plans[idx].fix_gravestones(&grave_mapping);
+ }
+ }
+ self.clear_analyses();
+ }
}
println!("Ran pass: {:?}", pass);
}
diff --git a/hercules_test/hercules_tests/tests/fork_transform_tests.rs b/hercules_test/hercules_tests/tests/fork_transform_tests.rs
new file mode 100644
index 00000000..bf75609c
--- /dev/null
+++ b/hercules_test/hercules_tests/tests/fork_transform_tests.rs
@@ -0,0 +1,134 @@
+use std::{env, fs::File, io::Read, path::Path};
+
+use hercules_interpreter::*;
+use hercules_opt::pass::Pass;
+use hercules_ir::ID;
+
+
+extern crate rand;
+use rand::Rng;
+
+#[test]
+fn fission_simple1() {
+ let module = parse_file("../test_inputs/fork_transforms/fork_fission/simple1.hir");
+ let dyn_consts = [10];
+ let params = 2; // TODO: (@xrouth) fix macro to take no params as an option.
+ let result_1 = interp_module!(module, dyn_consts, 2);
+
+ println!("result: {:?}", result_1);
+
+ let mut pm = hercules_opt::pass::PassManager::new(module.clone());
+
+ let passes = vec![
+ Pass::Verify,
+ Pass::ForkFission,
+ Pass::DCE,
+ // Pass::Xdot(true),
+ Pass::Verify,
+ ];
+
+ for pass in passes {
+ pm.add_pass(pass);
+ }
+ pm.run_passes();
+
+ let module = pm.get_module();
+ let result_2 = interp_module!(module, dyn_consts, 2);
+ println!("result: {:?}", result_2);
+ assert_eq!(result_1, result_2)
+}
+
+
+#[test]
+fn fission_simple2() {
+ let module = parse_file("../test_inputs/fork_transforms/fork_fission/simple2.hir");
+ let dyn_consts = [10];
+ let params = 2; // TODO: (@xrouth) fix macro to take no params as an option.
+ let result_1 = interp_module!(module, dyn_consts, 2);
+
+ println!("result: {:?}", result_1);
+
+ let mut pm = hercules_opt::pass::PassManager::new(module.clone());
+
+ let passes = vec![
+ Pass::Verify,
+ Pass::ForkFission,
+ Pass::DCE,
+ // Pass::Xdot(true),
+ Pass::Verify,
+ ];
+
+ for pass in passes {
+ pm.add_pass(pass);
+ }
+ pm.run_passes();
+
+ let module = pm.get_module();
+ let result_2 = interp_module!(module, dyn_consts, 2);
+ println!("result: {:?}", result_2);
+ assert_eq!(result_1, result_2)
+}
+
+#[test]
+fn fission_tricky() {
+ // This either crashes or gives wrong result depending on the order which reduces are observed in.
+ let module = parse_file("../test_inputs/fork_transforms/fork_fission/tricky.hir");
+ let dyn_consts = [10];
+ let params = 2; // TODO: (@xrouth) fix macro to take no params as an option.
+ let result_1 = interp_module!(module, dyn_consts, 2);
+
+ println!("result: {:?}", result_1);
+
+ let mut pm = hercules_opt::pass::PassManager::new(module.clone());
+
+ let passes = vec![
+ Pass::Verify,
+ Pass::Xdot(false),
+ Pass::ForkFission,
+ Pass::DCE,
+ Pass::Xdot(false),
+ Pass::Verify,
+ ];
+
+ for pass in passes {
+ pm.add_pass(pass);
+ }
+ pm.run_passes();
+
+ let module = pm.get_module();
+ let result_2 = interp_module!(module, dyn_consts, 2);
+ println!("result: {:?}", result_2);
+ assert_eq!(result_1, result_2)
+}
+
+#[test]
+fn inner_loop() {
+ // This either crashes or gives wrong result depending on the order which reduces are observed in.
+ let module = parse_file("../test_inputs/fork_transforms/fork_fission/inner_loop.hir");
+ let dyn_consts = [10];
+ let params = 2; // TODO: (@xrouth) fix macro to take no params as an option.
+ let result_1 = interp_module!(module, dyn_consts, 2);
+
+ println!("result: {:?}", result_1);
+
+ let mut pm = hercules_opt::pass::PassManager::new(module.clone());
+
+ let passes = vec![
+ Pass::Verify,
+ Pass::Xdot(false),
+ Pass::ForkFission,
+ Pass::DCE,
+ Pass::Xdot(false),
+ Pass::Verify,
+ ];
+
+ for pass in passes {
+ pm.add_pass(pass);
+ }
+ pm.run_passes();
+
+ let module = pm.get_module();
+ let result_2 = interp_module!(module, dyn_consts, 2);
+ println!("result: {:?}", result_2);
+ assert_eq!(result_1, result_2)
+}
\ No newline at end of file
diff --git a/hercules_test/hercules_tests/tests/loop_tests.rs b/hercules_test/hercules_tests/tests/forkify_tests.rs
similarity index 100%
rename from hercules_test/hercules_tests/tests/loop_tests.rs
rename to hercules_test/hercules_tests/tests/forkify_tests.rs
diff --git a/hercules_test/test_inputs/fork_transforms/fork_fission.hir b/hercules_test/test_inputs/fork_transforms/fork_fission.hir
deleted file mode 100644
index e69de29b..00000000
diff --git a/hercules_test/test_inputs/fork_transforms/fork_fission/inner_control.hir b/hercules_test/test_inputs/fork_transforms/fork_fission/inner_control.hir
new file mode 100644
index 00000000..052bbdb8
--- /dev/null
+++ b/hercules_test/test_inputs/fork_transforms/fork_fission/inner_control.hir
@@ -0,0 +1,15 @@
+fn fun<2>(x: u64) -> u64
+ zero = constant(u64, 0)
+ one = constant(u64, 1)
+ two = constant(u64, 2)
+ f = fork(start, #0)
+ f2 = fork(f, #1)
+ j2 = join(f2)
+ j = join(j2)
+ tid = thread_id(f, 0)
+ add1 = add(reduce1, one)
+ reduce1 = reduce(j, zero, add1)
+ add2 = add(reduce2, two)
+ reduce2 = reduce(j, zero, add2)
+ out1 = add(reduce1, reduce2)
+ z = return(j, out1)
\ No newline at end of file
diff --git a/hercules_test/test_inputs/fork_transforms/fork_fission/inner_loop.hir b/hercules_test/test_inputs/fork_transforms/fork_fission/inner_loop.hir
new file mode 100644
index 00000000..0cc13b2f
--- /dev/null
+++ b/hercules_test/test_inputs/fork_transforms/fork_fission/inner_loop.hir
@@ -0,0 +1,23 @@
+fn fun<2>(x: u64) -> u64
+ zero = constant(u64, 0)
+ one = constant(u64, 1)
+ two = constant(u64, 2)
+ f = fork(start, #0)
+ zero_idx = constant(u64, 0)
+ one_idx = constant(u64, 1)
+ bound = dynamic_constant(#1)
+ loop = region(f, if_true)
+ idx = phi(loop, zero_idx, idx_inc)
+ idx_inc = add(idx, one_idx)
+ in_bounds = lt(idx, bound)
+ if = if(loop, in_bounds)
+ if_false = projection(if, 0)
+ if_true = projection(if, 1)
+ j = join(if_false)
+ tid = thread_id(f, 0)
+ add1 = add(reduce1, idx)
+ reduce1 = reduce(j, zero, add1)
+ add2 = add(reduce2, idx_inc)
+ reduce2 = reduce(j, zero, add2)
+ out1 = add(reduce1, reduce2)
+ z = return(j, out1)
\ No newline at end of file
diff --git a/hercules_test/test_inputs/fork_transforms/fork_fission/intermediate_buffer_simple.hir b/hercules_test/test_inputs/fork_transforms/fork_fission/intermediate_buffer_simple.hir
new file mode 100644
index 00000000..75e0f157
--- /dev/null
+++ b/hercules_test/test_inputs/fork_transforms/fork_fission/intermediate_buffer_simple.hir
@@ -0,0 +1,10 @@
+fn fun<1>(x: u64) -> u64
+ zero = constant(u64, 0)
+ one = constant(u64, 1)
+ two = constant(u64, 2)
+ f = fork(start, #0)
+ j = join(f)
+ tid = thread_id(f, 0)
+ add1 = add(reduce1, two)
+ reduce1 = reduce(j, zero, add1)
+ z = return(j, reduce1)
diff --git a/hercules_test/test_inputs/fork_transforms/fork_fission/simple1.hir b/hercules_test/test_inputs/fork_transforms/fork_fission/simple1.hir
new file mode 100644
index 00000000..aaed60d9
--- /dev/null
+++ b/hercules_test/test_inputs/fork_transforms/fork_fission/simple1.hir
@@ -0,0 +1,13 @@
+fn fun<1>(x: u64) -> u64
+ zero = constant(u64, 0)
+ one = constant(u64, 1)
+ two = constant(u64, 2)
+ f = fork(start, #0)
+ j = join(f)
+ tid = thread_id(f, 0)
+ add1 = add(reduce1, one)
+ reduce1 = reduce(j, zero, add1)
+ add2 = add(reduce2, two)
+ reduce2 = reduce(j, zero, add2)
+ out1 = add(reduce1, reduce2)
+ z = return(j, out1)
diff --git a/hercules_test/test_inputs/fork_transforms/fork_fission/simple2.hir b/hercules_test/test_inputs/fork_transforms/fork_fission/simple2.hir
new file mode 100644
index 00000000..14c09aec
--- /dev/null
+++ b/hercules_test/test_inputs/fork_transforms/fork_fission/simple2.hir
@@ -0,0 +1,19 @@
+fn fun<1>(x: u64) -> u64
+ zero = constant(u64, 0)
+ one = constant(u64, 1)
+ two = constant(u64, 2)
+ f = fork(start, #0)
+ j = join(f)
+ tid = thread_id(f, 0)
+ add1 = add(reduce1, one)
+ reduce1 = reduce(j, zero, add1)
+ add2 = add(reduce2, two)
+ reduce2 = reduce(j, zero, add2)
+ add3 = add(reduce3, tid)
+ reduce3 = reduce(j, zero, add3)
+ add4 = sub(reduce4, tid)
+ reduce4 = reduce(j, zero, add4)
+ out1 = add(reduce1, reduce2)
+ out2 = add(reduce3, reduce4)
+ out3 = add(out1, out2)
+ z = return(j, out3)
diff --git a/hercules_test/test_inputs/fork_transforms/fork_fission/tricky.hir b/hercules_test/test_inputs/fork_transforms/fork_fission/tricky.hir
new file mode 100644
index 00000000..6fb895c4
--- /dev/null
+++ b/hercules_test/test_inputs/fork_transforms/fork_fission/tricky.hir
@@ -0,0 +1,13 @@
+fn fun<1>(x: u64) -> u64
+ zero = constant(u64, 0)
+ one = constant(u64, 1)
+ two = constant(u64, 2)
+ f = fork(start, #0)
+ j = join(f)
+ tid = thread_id(f, 0)
+ add1 = add(reduce1, one)
+ reduce1 = reduce(j, zero, add1)
+ add2 = add(reduce2, reduce1)
+ reduce2 = reduce(j, zero, add2)
+ out1 = add(reduce1, reduce2)
+ z = return(j, out1)
--
GitLab
From 41554698b90a1012ff885903a008875929e5c9d1 Mon Sep 17 00:00:00 2001
From: Xavier Routh <xrouth2@illinois.edu>
Date: Fri, 27 Dec 2024 18:51:21 -0500
Subject: [PATCH 20/68] awdawd
---
hercules_opt/src/pass.rs | 11 +----------
1 file changed, 1 insertion(+), 10 deletions(-)
diff --git a/hercules_opt/src/pass.rs b/hercules_opt/src/pass.rs
index 047eecd2..c330abfc 100644
--- a/hercules_opt/src/pass.rs
+++ b/hercules_opt/src/pass.rs
@@ -47,8 +47,6 @@ pub enum Pass {
Codegen(String, String),
// Parameterized over where to serialize module to.
Serialize(String),
- InterproceduralSROA,
- DeleteUncalled,
ForkFission,
}
@@ -999,14 +997,7 @@ impl PassManager {
self.module.dynamic_constants = dynamic_constants_ref.take();
self.module.types = types_ref.take();
- let edits = &editor.edits();
- if let Some(plans) = self.plans.as_mut() {
- repair_plan(&mut plans[idx], &self.module.functions[idx], edits);
- }
- let grave_mapping = self.module.functions[idx].delete_gravestones();
- if let Some(plans) = self.plans.as_mut() {
- plans[idx].fix_gravestones(&grave_mapping);
- }
+ self.module.functions[idx].delete_gravestones();
}
self.clear_analyses();
}
--
GitLab
From 4719e00856cca1baaedf0581a400a536679c7f31 Mon Sep 17 00:00:00 2001
From: Xavier Routh <xrouth2@illinois.edu>
Date: Fri, 27 Dec 2024 22:09:14 -0500
Subject: [PATCH 21/68] forkify fixes
---
Cargo.lock | 262 +++++++++---------
hercules_opt/src/editor.rs | 2 +-
hercules_opt/src/fork_transforms.rs | 22 +-
hercules_opt/src/forkify.rs | 39 ++-
hercules_opt/src/pass.rs | 6 +
.../hercules_interpreter/src/interpreter.rs | 2 +-
hercules_test/hercules_interpreter/src/lib.rs | 2 -
hercules_test/test_inputs/matmul_int.hir | 19 +-
8 files changed, 186 insertions(+), 168 deletions(-)
diff --git a/Cargo.lock b/Cargo.lock
index 758038ab..985d103d 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -13,9 +13,9 @@ dependencies = [
[[package]]
name = "anstream"
-version = "0.6.15"
+version = "0.6.18"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "64e15c1ab1f89faffbf04a634d5e1962e9074f2741eef6d97f3c4e322426d526"
+checksum = "8acc5369981196006228e28809f761875c0327210a891e941f4c683b3a99529b"
dependencies = [
"anstyle",
"anstyle-parse",
@@ -28,43 +28,43 @@ dependencies = [
[[package]]
name = "anstyle"
-version = "1.0.8"
+version = "1.0.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1bec1de6f59aedf83baf9ff929c98f2ad654b97c9510f4e70cf6f661d49fd5b1"
+checksum = "55cc3b69f167a1ef2e161439aa98aed94e6028e5f9a59be9a6ffb47aef1651f9"
[[package]]
name = "anstyle-parse"
-version = "0.2.5"
+version = "0.2.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eb47de1e80c2b463c735db5b217a0ddc39d612e7ac9e2e96a5aed1f57616c1cb"
+checksum = "3b2d16507662817a6a20a9ea92df6652ee4f94f914589377d69f3b21bc5798a9"
dependencies = [
"utf8parse",
]
[[package]]
name = "anstyle-query"
-version = "1.1.1"
+version = "1.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6d36fc52c7f6c869915e99412912f22093507da8d9e942ceaf66fe4b7c14422a"
+checksum = "79947af37f4177cfead1110013d678905c37501914fba0efea834c3fe9a8d60c"
dependencies = [
- "windows-sys 0.52.0",
+ "windows-sys",
]
[[package]]
name = "anstyle-wincon"
-version = "3.0.4"
+version = "3.0.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5bf74e1b6e971609db8ca7a9ce79fd5768ab6ae46441c572e46cf596f59e57f8"
+checksum = "2109dbce0e72be3ec00bed26e6a7479ca384ad226efdd66db8fa2e3a38c83125"
dependencies = [
"anstyle",
- "windows-sys 0.52.0",
+ "windows-sys",
]
[[package]]
name = "anyhow"
-version = "1.0.89"
+version = "1.0.95"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "86fdf8605db99b54d3cd748a44c6d04df638eb5dafb219b135d0149bd0db01f6"
+checksum = "34ac096ce696dc2fcabef30516bb13c0a68a11d30131d3df6f04711467681b04"
[[package]]
name = "async-channel"
@@ -119,9 +119,9 @@ dependencies = [
[[package]]
name = "async-io"
-version = "2.3.4"
+version = "2.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "444b0228950ee6501b3568d3c93bf1176a1fdbc3b758dcd9475046d30f4dc7e8"
+checksum = "43a2b323ccce0a1d90b449fd71f2a06ca7faa7c54c2751f06c9bd851fc061059"
dependencies = [
"async-lock",
"cfg-if",
@@ -133,7 +133,7 @@ dependencies = [
"rustix",
"slab",
"tracing",
- "windows-sys 0.59.0",
+ "windows-sys",
]
[[package]]
@@ -295,9 +295,9 @@ checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
[[package]]
name = "cfgrammar"
-version = "0.13.7"
+version = "0.13.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6026d8cd82ada8bbcfe337805dd1eb6afdc9e80fa4d57e977b3a36315e0c5525"
+checksum = "6d621f687a04efa1f269f1cd13d8cfea9660852bdb3d1cd2c3c9fb6fdd34daf2"
dependencies = [
"indexmap",
"lazy_static",
@@ -309,9 +309,9 @@ dependencies = [
[[package]]
name = "clap"
-version = "4.5.19"
+version = "4.5.23"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7be5744db7978a28d9df86a214130d106a89ce49644cbc4e3f0c22c3fba30615"
+checksum = "3135e7ec2ef7b10c6ed8950f0f792ed96ee093fa088608f1c76e569722700c84"
dependencies = [
"clap_builder",
"clap_derive",
@@ -319,9 +319,9 @@ dependencies = [
[[package]]
name = "clap_builder"
-version = "4.5.19"
+version = "4.5.23"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a5fbc17d3ef8278f55b282b2a2e75ae6f6c7d4bb70ed3d0382375104bfafdb4b"
+checksum = "30582fc632330df2bd26877bde0c1f4470d57c582bbc070376afcd04d8cb4838"
dependencies = [
"anstream",
"anstyle",
@@ -338,14 +338,14 @@ dependencies = [
"heck",
"proc-macro2",
"quote",
- "syn 2.0.79",
+ "syn 2.0.92",
]
[[package]]
name = "clap_lex"
-version = "0.7.2"
+version = "0.7.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1462739cb27611015575c0c11df5df7601141071f07518d56fcc1be504cbec97"
+checksum = "f46ad14479a25103f283c0f10005961cf086d8dc42205bb44c46ac563475dca6"
[[package]]
name = "cobs"
@@ -355,9 +355,9 @@ checksum = "67ba02a97a2bd10f4b59b25c7973101c79642302776489e030cd13cdab09ed15"
[[package]]
name = "colorchoice"
-version = "1.0.2"
+version = "1.0.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d3fd119d74b830634cea2a0f58bbd0d54540518a14397557951e79340abc28c0"
+checksum = "5b63caa9aa9397e2d9480a9b13673856c78d8ac123288526c37d7839f2a86990"
[[package]]
name = "concurrent-queue"
@@ -370,15 +370,15 @@ dependencies = [
[[package]]
name = "critical-section"
-version = "1.1.3"
+version = "1.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f64009896348fc5af4222e9cf7d7d82a95a256c634ebcf61c53e4ea461422242"
+checksum = "790eea4361631c5e7d22598ecd5723ff611904e3344ce8720784c93e3d83d40b"
[[package]]
name = "crossbeam-utils"
-version = "0.8.20"
+version = "0.8.21"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "22ec99545bb0ed0ea7bb9b8e1e9122ea386ff8a48c0922e43f36d45ab09e0e80"
+checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
[[package]]
name = "deranged"
@@ -406,7 +406,7 @@ checksum = "cb7330aeadfbe296029522e6c40f315320aba36fc43a5b3632f3795348f3bd22"
dependencies = [
"proc-macro2",
"quote",
- "syn 2.0.79",
+ "syn 2.0.92",
]
[[package]]
@@ -446,12 +446,12 @@ checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5"
[[package]]
name = "errno"
-version = "0.3.9"
+version = "0.3.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "534c5cf6194dfab3db3242765c03bbe257cf92f22b38f6bc0c58d59108a820ba"
+checksum = "33d852cb9b869c2a9b3df2f71a3074817f01e1844f839a144f5fcef059a4eb5d"
dependencies = [
"libc",
- "windows-sys 0.52.0",
+ "windows-sys",
]
[[package]]
@@ -473,9 +473,9 @@ dependencies = [
[[package]]
name = "event-listener-strategy"
-version = "0.5.2"
+version = "0.5.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0f214dc438f977e6d4e3500aaa277f5ad94ca83fbbd9b1a15713ce2344ccc5a1"
+checksum = "3c3e4e0dd3673c1139bf041f3008816d9cf2946bbfac2945c09e523b8d7b05b2"
dependencies = [
"event-listener 5.3.1",
"pin-project-lite",
@@ -494,9 +494,9 @@ dependencies = [
[[package]]
name = "fastrand"
-version = "2.1.1"
+version = "2.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e8c02a5121d4ea3eb16a80748c74f5549a5665e4c21333c6098f283870fbdea6"
+checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be"
[[package]]
name = "filetime"
@@ -507,7 +507,7 @@ dependencies = [
"cfg-if",
"libc",
"libredox",
- "windows-sys 0.59.0",
+ "windows-sys",
]
[[package]]
@@ -545,9 +545,9 @@ checksum = "9e5c1b78ca4aae1ac06c48a526a655760685149f0d465d21f37abfe57ce075c6"
[[package]]
name = "futures-lite"
-version = "2.3.0"
+version = "2.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "52527eb5074e35e9339c6b4e8d12600c7128b68fb25dcb9fa9dec18f7c25f3a5"
+checksum = "cef40d21ae2c515b51041df9ed313ed21e572df340ea58a922a0aefe7e8891a1"
dependencies = [
"fastrand",
"futures-core",
@@ -599,9 +599,9 @@ dependencies = [
[[package]]
name = "hashbrown"
-version = "0.15.0"
+version = "0.15.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e087f84d4f86bf4b218b927129862374b72199ae7d8657835f1e89000eea4fb"
+checksum = "bf151400ff0baff5465007dd2f3e717f3fe502074ca563069ce3a6629d07b289"
[[package]]
name = "heapless"
@@ -710,9 +710,9 @@ checksum = "fbf6a919d6cf397374f7dfeeea91d974c7c0a7221d0d0f4f20d859d329e53fcc"
[[package]]
name = "indexmap"
-version = "2.6.0"
+version = "2.7.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "707907fe3c25f5424cce2cb7e1cbcafee6bdbe735ca90ef77c29e84591e5b9da"
+checksum = "62f822373a4fe84d4bb149bf54e584a7f4abec90e072ed49cda0edea5b95471f"
dependencies = [
"equivalent",
"hashbrown",
@@ -735,16 +735,17 @@ dependencies = [
[[package]]
name = "itoa"
-version = "1.0.11"
+version = "1.0.14"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b"
+checksum = "d75a2a4b1b190afb6f5425f10f6a8f959d2ea0b9c2b1d79553551850539e4674"
[[package]]
name = "js-sys"
-version = "0.3.70"
+version = "0.3.76"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1868808506b929d7b0cfa8f75951347aa71bb21144b7791bae35d9bccfcfe37a"
+checksum = "6717b6b5b077764fb5966237269cb3c64edddde4b14ce42647430a78ced9e7b7"
dependencies = [
+ "once_cell",
"wasm-bindgen",
]
@@ -838,9 +839,9 @@ checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
[[package]]
name = "libc"
-version = "0.2.159"
+version = "0.2.169"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "561d97a539a36e26a9a5fad1ea11a3039a67714694aaa379433e580854bc3dc5"
+checksum = "b5aba8db14291edd000dfcc4d620c7ebfb122c613afb886ca8803fa4e128a20a"
[[package]]
name = "libredox"
@@ -880,9 +881,9 @@ dependencies = [
[[package]]
name = "lrlex"
-version = "0.13.7"
+version = "0.13.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "05863fdac293d1bc74f0cd91512933a5ab67e0cb607dc78ac4984be089456b49"
+checksum = "6fe1e8741f737ba4b6d781f716051df6375ff0488d57ee23822a2cdba1c3dc7a"
dependencies = [
"cfgrammar",
"getopts",
@@ -898,9 +899,9 @@ dependencies = [
[[package]]
name = "lrpar"
-version = "0.13.7"
+version = "0.13.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3b1ecae55cf667db308d3555e22b20bcc28eaeca0c95a09b37171673be157c71"
+checksum = "19c61bcff4c1dd2deb9567ea868237828a8cd179c3f64106f6726656e372421d"
dependencies = [
"bincode",
"cactus",
@@ -920,9 +921,9 @@ dependencies = [
[[package]]
name = "lrtable"
-version = "0.13.7"
+version = "0.13.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d42d2752cb50a171efadda0cb6fa97432e8bf05accfff3eed320b87e80a2f69e"
+checksum = "49e35162de3a5d91b380f8ebb31fc6c5e9a4618276465df4725ff1f88613312b"
dependencies = [
"cfgrammar",
"fnv",
@@ -964,7 +965,7 @@ dependencies = [
"proc-macro-error",
"proc-macro2",
"quote",
- "syn 2.0.79",
+ "syn 2.0.92",
]
[[package]]
@@ -1039,9 +1040,9 @@ checksum = "1261fe7e33c73b354eab43b1273a57c8f967d0391e80353e51f764ac02cf6775"
[[package]]
name = "ordered-float"
-version = "4.3.0"
+version = "4.6.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "44d501f1a72f71d3c063a6bbc8f7271fa73aa09fe5d6283b6571e2ed176a2537"
+checksum = "7bb71e1b3fa6ca1c61f383464aaf2bb0e2f8e772a1f01d486832464de363b951"
dependencies = [
"num-traits",
"rand",
@@ -1094,7 +1095,7 @@ dependencies = [
"phf_shared",
"proc-macro2",
"quote",
- "syn 2.0.79",
+ "syn 2.0.92",
]
[[package]]
@@ -1108,9 +1109,9 @@ dependencies = [
[[package]]
name = "pin-project-lite"
-version = "0.2.14"
+version = "0.2.15"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bda66fc9667c18cb2758a2ac84d1167245054bcf85d5d1aaa6923f45801bdd02"
+checksum = "915a1e146535de9163f3987b8944ed8cf49a18bb0056bcebcdcece385cece4ff"
[[package]]
name = "pin-utils"
@@ -1131,9 +1132,9 @@ dependencies = [
[[package]]
name = "polling"
-version = "3.7.3"
+version = "3.7.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cc2790cd301dec6cd3b7a025e4815cf825724a51c98dccfe6a3e55f05ffb6511"
+checksum = "a604568c3202727d1507653cb121dbd627a58684eb09a820fd746bee38b4442f"
dependencies = [
"cfg-if",
"concurrent-queue",
@@ -1141,14 +1142,14 @@ dependencies = [
"pin-project-lite",
"rustix",
"tracing",
- "windows-sys 0.59.0",
+ "windows-sys",
]
[[package]]
name = "postcard"
-version = "1.0.10"
+version = "1.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f7f0a8d620d71c457dd1d47df76bb18960378da56af4527aaa10f515eee732e"
+checksum = "170a2601f67cc9dba8edd8c4870b15f71a6a2dc196daec8c83f72b59dff628a8"
dependencies = [
"cobs",
"embedded-io 0.4.0",
@@ -1198,18 +1199,18 @@ dependencies = [
[[package]]
name = "proc-macro2"
-version = "1.0.86"
+version = "1.0.92"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e719e8df665df0d1c8fbfd238015744736151d4445ec0836b8e628aae103b77"
+checksum = "37d3544b3f2748c54e147655edb5025752e2303145b5aefb3c3ea2c78b973bb0"
dependencies = [
"unicode-ident",
]
[[package]]
name = "quote"
-version = "1.0.37"
+version = "1.0.38"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af"
+checksum = "0e4dccaaaf89514f546c693ddc140f729f958c247918a13380cccc6078391acc"
dependencies = [
"proc-macro2",
]
@@ -1254,18 +1255,18 @@ dependencies = [
[[package]]
name = "redox_syscall"
-version = "0.5.7"
+version = "0.5.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b6dfecf2c74bce2466cabf93f6664d6998a69eb21e39f4207930065b27b771f"
+checksum = "03a862b389f93e68874fbf580b9de08dd02facb9a788ebadaf4a3fd33cf58834"
dependencies = [
"bitflags",
]
[[package]]
name = "regex"
-version = "1.11.0"
+version = "1.11.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38200e5ee88914975b69f657f0801b6f6dccafd44fd9326302a4aaeecfacb1d8"
+checksum = "b544ef1b4eac5dc2db33ea63606ae9ffcfac26c1416a2806ae0bf5f56b201191"
dependencies = [
"aho-corasick",
"memchr",
@@ -1275,9 +1276,9 @@ dependencies = [
[[package]]
name = "regex-automata"
-version = "0.4.8"
+version = "0.4.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "368758f23274712b504848e9d5a6f010445cc8b87a7cdb4d7cbee666c1288da3"
+checksum = "809e8dc61f6de73b46c85f4c96486310fe304c434cfa43669d7b40f711150908"
dependencies = [
"aho-corasick",
"memchr",
@@ -1313,22 +1314,22 @@ dependencies = [
[[package]]
name = "rustix"
-version = "0.38.37"
+version = "0.38.42"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8acb788b847c24f28525660c4d7758620a7210875711f79e7f663cc152726811"
+checksum = "f93dc38ecbab2eb790ff964bb77fa94faf256fd3e73285fd7ba0903b76bedb85"
dependencies = [
"bitflags",
"errno",
"libc",
"linux-raw-sys",
- "windows-sys 0.52.0",
+ "windows-sys",
]
[[package]]
name = "rustversion"
-version = "1.0.17"
+version = "1.0.19"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "955d28af4278de8121b7ebeb796b6a45735dc01436d898801014aced2773a3d6"
+checksum = "f7c45b9784283f1b2e7fb61b42047c2fd678ef0960d4f6f1eba131594cc369d4"
[[package]]
name = "scopeguard"
@@ -1338,28 +1339,28 @@ checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
[[package]]
name = "semver"
-version = "1.0.23"
+version = "1.0.24"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "61697e0a1c7e512e84a621326239844a24d8207b4669b41bc18b32ea5cbf988b"
+checksum = "3cb6eb87a131f756572d7fb904f6e7b68633f09cca868c5df1c4b8d1a694bbba"
[[package]]
name = "serde"
-version = "1.0.210"
+version = "1.0.217"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c8e3592472072e6e22e0a54d5904d9febf8508f65fb8552499a1abc7d1078c3a"
+checksum = "02fc4265df13d6fa1d00ecff087228cc0a2b5f3c0e87e258d8b94a156e984c70"
dependencies = [
"serde_derive",
]
[[package]]
name = "serde_derive"
-version = "1.0.210"
+version = "1.0.217"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "243902eda00fad750862fc144cea25caca5e20d615af0a81bee94ca738f1df1f"
+checksum = "5a9bf7cf98d04a2b28aead066b7496853d4779c9cc183c440dbac457641e19a0"
dependencies = [
"proc-macro2",
"quote",
- "syn 2.0.79",
+ "syn 2.0.92",
]
[[package]]
@@ -1388,9 +1389,9 @@ dependencies = [
[[package]]
name = "sparsevec"
-version = "0.2.0"
+version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "35df5d2e580b29f3f7ec5b4ed49b0ab3acf7f3624122b3e823cafb9630f293b8"
+checksum = "91ef4657ebc254f6e84a863cb495c2feb60e5b48eba5141bf2bbbe202adb65b4"
dependencies = [
"num-traits",
"packedvec",
@@ -1438,9 +1439,9 @@ dependencies = [
[[package]]
name = "syn"
-version = "2.0.79"
+version = "2.0.92"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "89132cd0bf050864e1d38dc3bbc07a0eb8e7530af26344d3d2bbbef83499f590"
+checksum = "70ae51629bf965c5c098cc9e87908a3df5301051a9e087d6f9bef5c9771ed126"
dependencies = [
"proc-macro2",
"quote",
@@ -1461,9 +1462,9 @@ checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
[[package]]
name = "time"
-version = "0.3.36"
+version = "0.3.37"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5dfd88e563464686c916c7e46e623e520ddc6d79fa6641390f2e3fa86e83e885"
+checksum = "35e7868883861bd0e56d9ac6efcaaca0d6d5d82a2a7ec8209ff492c07cf37b21"
dependencies = [
"deranged",
"itoa",
@@ -1484,9 +1485,9 @@ checksum = "ef927ca75afb808a4d64dd374f00a2adf8d0fcff8e7b184af886c3c87ec4a3f3"
[[package]]
name = "time-macros"
-version = "0.2.18"
+version = "0.2.19"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3f252a68540fde3a3877aeea552b832b40ab9a69e318efd078774a01ddee1ccf"
+checksum = "2834e6017e3e5e4b9834939793b282bc03b37a3336245fa820e35e233e2a85de"
dependencies = [
"num-conv",
"time-core",
@@ -1494,9 +1495,9 @@ dependencies = [
[[package]]
name = "tracing"
-version = "0.1.40"
+version = "0.1.41"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c3523ab5a71916ccf420eebdf5521fcef02141234bbc0b8a49f2fdc4544364ef"
+checksum = "784e0ac535deb450455cbfa28a6f0df145ea1bb7ae51b821cf5e7927fdcfbdd0"
dependencies = [
"pin-project-lite",
"tracing-core",
@@ -1504,15 +1505,15 @@ dependencies = [
[[package]]
name = "tracing-core"
-version = "0.1.32"
+version = "0.1.33"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c06d3da6113f116aaee68e4d601191614c9053067f9ab7f6edbcb161237daa54"
+checksum = "e672c95779cf947c5311f83787af4fa8fffd12fb27e4993211a84bdfd9610f9c"
[[package]]
name = "unicode-ident"
-version = "1.0.13"
+version = "1.0.14"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e91b56cd4cadaeb79bbf1a5645f6b4f8dc5bde8834ad5894a8db35fda9efa1fe"
+checksum = "adb9e6ca4f869e1180728b7950e35922a7fc6397f7b641499e8f3ef06e50dc83"
[[package]]
name = "unicode-width"
@@ -1528,9 +1529,9 @@ checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
[[package]]
name = "value-bag"
-version = "1.9.0"
+version = "1.10.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5a84c137d37ab0142f0f2ddfe332651fdbf252e7b7dbb4e67b6c1f1b2e925101"
+checksum = "3ef4c4aa54d5d05a279399bfa921ec387b7aba77caf7a682ae8d86785b8fdad2"
[[package]]
name = "vergen"
@@ -1568,9 +1569,9 @@ checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
[[package]]
name = "wasm-bindgen"
-version = "0.2.93"
+version = "0.2.99"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a82edfc16a6c469f5f44dc7b571814045d60404b55a0ee849f9bcfa2e63dd9b5"
+checksum = "a474f6281d1d70c17ae7aa6a613c87fce69a127e2624002df63dcb39d6cf6396"
dependencies = [
"cfg-if",
"once_cell",
@@ -1579,36 +1580,36 @@ dependencies = [
[[package]]
name = "wasm-bindgen-backend"
-version = "0.2.93"
+version = "0.2.99"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9de396da306523044d3302746f1208fa71d7532227f15e347e2d93e4145dd77b"
+checksum = "5f89bb38646b4f81674e8f5c3fb81b562be1fd936d84320f3264486418519c79"
dependencies = [
"bumpalo",
"log",
- "once_cell",
"proc-macro2",
"quote",
- "syn 2.0.79",
+ "syn 2.0.92",
"wasm-bindgen-shared",
]
[[package]]
name = "wasm-bindgen-futures"
-version = "0.4.43"
+version = "0.4.49"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "61e9300f63a621e96ed275155c108eb6f843b6a26d053f122ab69724559dc8ed"
+checksum = "38176d9b44ea84e9184eff0bc34cc167ed044f816accfe5922e54d84cf48eca2"
dependencies = [
"cfg-if",
"js-sys",
+ "once_cell",
"wasm-bindgen",
"web-sys",
]
[[package]]
name = "wasm-bindgen-macro"
-version = "0.2.93"
+version = "0.2.99"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "585c4c91a46b072c92e908d99cb1dcdf95c5218eeb6f3bf1efa991ee7a68cccf"
+checksum = "2cc6181fd9a7492eef6fef1f33961e3695e4579b9872a6f7c83aee556666d4fe"
dependencies = [
"quote",
"wasm-bindgen-macro-support",
@@ -1616,42 +1617,33 @@ dependencies = [
[[package]]
name = "wasm-bindgen-macro-support"
-version = "0.2.93"
+version = "0.2.99"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "afc340c74d9005395cf9dd098506f7f44e38f2b4a21c6aaacf9a105ea5e1e836"
+checksum = "30d7a95b763d3c45903ed6c81f156801839e5ee968bb07e534c44df0fcd330c2"
dependencies = [
"proc-macro2",
"quote",
- "syn 2.0.79",
+ "syn 2.0.92",
"wasm-bindgen-backend",
"wasm-bindgen-shared",
]
[[package]]
name = "wasm-bindgen-shared"
-version = "0.2.93"
+version = "0.2.99"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c62a0a307cb4a311d3a07867860911ca130c3494e8c2719593806c08bc5d0484"
+checksum = "943aab3fdaaa029a6e0271b35ea10b72b943135afe9bffca82384098ad0e06a6"
[[package]]
name = "web-sys"
-version = "0.3.70"
+version = "0.3.76"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "26fdeaafd9bd129f65e7c031593c24d62186301e0c72c8978fa1678be7d532c0"
+checksum = "04dd7223427d52553d3702c004d3b2fe07c148165faa56313cb00211e31c12bc"
dependencies = [
"js-sys",
"wasm-bindgen",
]
-[[package]]
-name = "windows-sys"
-version = "0.52.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
-dependencies = [
- "windows-targets",
-]
-
[[package]]
name = "windows-sys"
version = "0.59.0"
@@ -1772,5 +1764,5 @@ checksum = "fa4f8080344d4671fb4e831a13ad1e68092748387dfc4f55e356242fae12ce3e"
dependencies = [
"proc-macro2",
"quote",
- "syn 2.0.79",
+ "syn 2.0.92",
]
diff --git a/hercules_opt/src/editor.rs b/hercules_opt/src/editor.rs
index c9865f8f..48e04582 100644
--- a/hercules_opt/src/editor.rs
+++ b/hercules_opt/src/editor.rs
@@ -229,7 +229,7 @@ impl<'a: 'b, 'b> FunctionEditor<'a> {
pub fn get_uses(&self, id: NodeID) -> impl ExactSizeIterator<Item = NodeID> + '_ {
get_uses(&self.function.nodes[id.idx()])
.as_ref().into_iter().map(|x| *x)
- .collect_vec() // @(xrouth): wtf???
+ .collect::<Vec<_>>() // @(xrouth): wtf???
.into_iter()
}
diff --git a/hercules_opt/src/fork_transforms.rs b/hercules_opt/src/fork_transforms.rs
index 9ce26590..d47416d1 100644
--- a/hercules_opt/src/fork_transforms.rs
+++ b/hercules_opt/src/fork_transforms.rs
@@ -2,6 +2,8 @@ use std::collections::{HashMap, HashSet};
use std::ops::Sub;
extern crate hercules_ir;
+use self::hercules_ir::LoopTree;
+
use self::hercules_ir::{Index, TypeID};
use self::hercules_ir::Subgraph;
@@ -127,6 +129,7 @@ pub fn fork_fission<'a> (
editor: &'a mut FunctionEditor,
control_subgraph: &Subgraph,
types: &Vec<TypeID>,
+ loop_tree: &LoopTree,
fork_join_map: &HashMap<NodeID, NodeID>,
)-> () {
let forks: Vec<_> = editor.func().nodes.iter().enumerate().filter_map(|(idx, node)| {
@@ -138,7 +141,7 @@ pub fn fork_fission<'a> (
let mut control_pred = NodeID::new(0);
// This does the reduction fission:
- if true {
+ if false {
for fork in forks.clone() {
// FIXME: If there is control in between fork and join, give up.
let join = fork_join_map[&fork];
@@ -155,12 +158,13 @@ pub fn fork_fission<'a> (
}}
// This does the bufferization:
+ let edge = (NodeID::new(15), NodeID::new(16));
// let edge = (NodeID::new(4), NodeID::new(9));
- // let mut edges = HashSet::new();
- // edges.insert(edge);
-
- // let fork = forks.first().unwrap();
- // fork_bufferize_fission_helper(editor, fork_join_map, edges, NodeID::new(0), types, *fork);
+ let mut edges = HashSet::new();
+ edges.insert(edge);
+ let fork = loop_tree.bottom_up_loops().first().unwrap().0;
+ //let fork = forks.first().unwrap();
+ fork_bufferize_fission_helper(editor, fork_join_map, edges, NodeID::new(0), types, fork);
}
/** Split a 1D fork into two forks, placing select intermediate data into buffers. */
@@ -171,8 +175,10 @@ pub fn fork_bufferize_fission_helper<'a> (
original_control_pred: NodeID, // What the new fork connects to.
types: &Vec<TypeID>,
fork: NodeID,
-) -> () {
+) -> (NodeID, NodeID) { // Returns the two forks that it generates.
// TODO: Check validititry of bufferized_edges (ask xavier for condition).
+
+ // TODO: Check that bufferized edges src doesn't depend on anything that comes after the fork.
// Copy fork + control intermediates + join to new fork + join,
// How does control get partitioned?
@@ -250,6 +256,8 @@ pub fn fork_bufferize_fission_helper<'a> (
);
}
+ (fork, new_fork_id)
+
}
/** Split a 1D fork into a separate fork for each reduction. */
diff --git a/hercules_opt/src/forkify.rs b/hercules_opt/src/forkify.rs
index fa899232..adbd927e 100644
--- a/hercules_opt/src/forkify.rs
+++ b/hercules_opt/src/forkify.rs
@@ -73,30 +73,47 @@ pub enum DataUseLoopLocation {
}
// FIXME: This is a mess.
-pub fn loop_data_location(function: &Function, node: NodeID, all_loop_nodes: &BitVec<u8, Lsb0>,
+// A user is 'after' the loop is finished if we walk the users of it, (or itself), and
+// any control node on the frontier of control nodes (don't go through users of control nodes) is
+// not in the loop body or is not the loop header.
+
+pub fn loop_data_location(editor: &FunctionEditor, node: NodeID, all_loop_nodes: &BitVec<u8, Lsb0>,
visited: &mut DenseNodeMap<bool>
) -> DataUseLoopLocation {
+ let function = editor.func();
+
if visited[node.idx()] {
return DataUseLoopLocation::Unknown;
}
visited[node.idx()] = true;
+ let node_data = &function.nodes[node.idx()];
+
// Control node on frontier.
- if function.nodes[node.idx()].is_control() {
+ if node_data.is_control() {
return match all_loop_nodes[node.idx()] {
true => DataUseLoopLocation::Inside,
false => DataUseLoopLocation::Outside
}
}
+ // Don't go through PHIs that are contorlled by something in the loop either.
+ if node_data.is_phi() {
+ let control = node_data.try_phi().unwrap().0;
+ return match all_loop_nodes[control.idx()] {
+ true => DataUseLoopLocation::Inside,
+ false => DataUseLoopLocation::Outside // FIXME: Is this the correct condition?
+ }
+ }
+
let mut data_location = DataUseLoopLocation::Inside;
- for node_use in get_uses(&function.nodes[node.idx()]).as_ref() {
- // If any use is outside, then this node is outside, else its on inside.
- if loop_data_location(function, *node_use, &all_loop_nodes, visited) == DataUseLoopLocation::Outside {
+ for node_user in editor.get_users(node) {
+ // If any user is outside, then this node is outside, else its on inside.
+ if loop_data_location(editor, node_user, &all_loop_nodes, visited) == DataUseLoopLocation::Outside {
data_location = DataUseLoopLocation::Outside;
}
}
@@ -393,9 +410,12 @@ pub fn forkify_loop(
for node_use in editor.get_users(basic_iv.node) {
let mut visited = vec![false; function.nodes.len()];
- iv_use_location[node_use.idx()] = loop_data_location(function, basic_iv.node, &l.get_all_nodes(), &mut visited)
+ iv_use_location[node_use.idx()] = loop_data_location(&editor, node_use, &l.get_all_nodes(), &mut visited)
}
+ println!("loop datalocation: {:?}", iv_use_location );
+
+
// Create ThreadID
// FIXME: Fix this for n-dimensional things.
@@ -416,10 +436,6 @@ pub fn forkify_loop(
// If a user occurs after the loop is finished, we replace it with the DC that is the IV bound,
// If a user occurs inside the loop, we replace it with the IV.
- // A user is 'after' the loop is finished if we walk the users of it, (or itself), and
- // any control node on the frontier of control nodes (don't go through users of control nodes) is
- // not in the loop body or is not the loop header.
-
// Replace uses that are inside with the thread id
edit = edit.replace_all_uses_where(basic_iv.node, thread_id_id, |node| {
match iv_use_location[node.idx()] {
@@ -430,7 +446,8 @@ pub fn forkify_loop(
})?;
// Replace uses that are outside with the DC
- edit = edit.replace_all_uses_where(basic_iv.node, thread_id_id, |node| {
+ let bound_dc_node = edit.add_node(Node::DynamicConstant { id: bound_dc_id });
+ edit = edit.replace_all_uses_where(basic_iv.node, bound_dc_node, |node| {
match iv_use_location[node.idx()] {
DataUseLoopLocation::Unknown => todo!(),
DataUseLoopLocation::Inside => false,
diff --git a/hercules_opt/src/pass.rs b/hercules_opt/src/pass.rs
index c330abfc..2d330cf6 100644
--- a/hercules_opt/src/pass.rs
+++ b/hercules_opt/src/pass.rs
@@ -473,6 +473,11 @@ impl PassManager {
&fork_join_maps[idx],
&loops[idx],
);
+
+ self.module.constants = constants_ref.take();
+ self.module.dynamic_constants = dynamic_constants_ref.take();
+ self.module.types = types_ref.take();
+
let num_nodes = self.module.functions[idx].nodes.len();
self.module.functions[idx]
.schedules
@@ -990,6 +995,7 @@ impl PassManager {
control_subgraph,
&types[idx], // FIXME: I think types should be gotten from the editor, not this...
// because pass can add more typees. Blah. WTF!
+ &loops[idx],
&fork_join_maps[idx],
);
diff --git a/hercules_test/hercules_interpreter/src/interpreter.rs b/hercules_test/hercules_interpreter/src/interpreter.rs
index 3fbec850..bda02590 100644
--- a/hercules_test/hercules_interpreter/src/interpreter.rs
+++ b/hercules_test/hercules_interpreter/src/interpreter.rs
@@ -360,7 +360,7 @@ impl<'a> FunctionExecutionState<'a> {
let v = dyn_const_value(id, &self.module.dynamic_constants, &self.dynamic_constant_params);
// TODO: Figure out what type / semantics are of thread ID and dynamic const.
- InterpreterVal::DynamicConstant(v.into())
+ InterpreterVal::UnsignedInteger64(v.try_into().expect("too big dyn const!"))
}
Node::Unary { input, op } => {
let val = self.handle_data(token, *input);
diff --git a/hercules_test/hercules_interpreter/src/lib.rs b/hercules_test/hercules_interpreter/src/lib.rs
index ca4b5447..4801c0a2 100644
--- a/hercules_test/hercules_interpreter/src/lib.rs
+++ b/hercules_test/hercules_interpreter/src/lib.rs
@@ -115,13 +115,11 @@ macro_rules! interp_module {
pm.make_fork_join_maps();
pm.make_fork_join_nests();
pm.make_control_subgraphs();
- pm.make_plans();
let reverse_postorders = pm.reverse_postorders.as_ref().unwrap().clone();
let doms = pm.doms.as_ref().unwrap().clone();
let fork_join_maps = pm.fork_join_maps.as_ref().unwrap().clone();
let fork_join_nests = pm.fork_join_nests.as_ref().unwrap().clone();
- let plans = pm.plans.as_ref().unwrap().clone();
let control_subgraphs = pm.control_subgraphs.as_ref().unwrap().clone();
let def_uses = pm.def_uses.as_ref().unwrap().clone();
diff --git a/hercules_test/test_inputs/matmul_int.hir b/hercules_test/test_inputs/matmul_int.hir
index 34d8169b..ab0f384a 100644
--- a/hercules_test/test_inputs/matmul_int.hir
+++ b/hercules_test/test_inputs/matmul_int.hir
@@ -1,21 +1,18 @@
fn matmul<3>(a: array(i32, #0, #1), b: array(i32, #1, #2)) -> array(i32, #0, #2)
c = constant(array(i32, #0, #2), [])
- i_ctrl = fork(start, #0)
- i_idx = thread_id(i_ctrl, 0)
- j_ctrl = fork(i_ctrl, #2)
- j_idx = thread_id(j_ctrl, 0)
- k_ctrl = fork(j_ctrl, #1)
+ i_j_ctrl = fork(start, #0, #2)
+ i_idx = thread_id(i_j_ctrl, 0)
+ j_idx = thread_id(i_j_ctrl, 1)
+ k_ctrl = fork(i_j_ctrl, #1)
k_idx = thread_id(k_ctrl, 0)
k_join_ctrl = join(k_ctrl)
- j_join_ctrl = join(k_join_ctrl)
- i_join_ctrl = join(j_join_ctrl)
- r = return(i_join_ctrl, update_i_c)
+ i_j_join_ctrl = join(k_join_ctrl)
+ r = return(i_j_join_ctrl, update_i_j_c)
zero = constant(i32, 0)
a_val = read(a, position(i_idx, k_idx))
b_val = read(b, position(k_idx, j_idx))
mul = mul(a_val, b_val)
add = add(mul, dot)
dot = reduce(k_join_ctrl, zero, add)
- updated_c = write(update_j_c, dot, position(i_idx, j_idx))
- update_j_c = reduce(j_join_ctrl, update_i_c, updated_c)
- update_i_c = reduce(i_join_ctrl, c, update_j_c)
+ update_c = write(update_i_j_c, dot, position(i_idx, j_idx))
+ update_i_j_c = reduce(i_j_join_ctrl, c, update_c)
\ No newline at end of file
--
GitLab
From e72df4b95ef12e89140221e9e1b407391faba57e Mon Sep 17 00:00:00 2001
From: Xavier Routh <xrouth2@illinois.edu>
Date: Mon, 6 Jan 2025 14:40:45 -0500
Subject: [PATCH 22/68] fork canonicalization
---
hercules_ir/src/loops.rs | 2 +-
hercules_opt/src/forkify.rs | 145 +++++++-----------
hercules_opt/src/ivar.rs | 127 +++++++++++++--
hercules_opt/src/lib.rs | 3 +-
hercules_opt/src/pass.rs | 42 +++++
.../hercules_interpreter/src/interpreter.rs | 11 +-
hercules_test/test_inputs/forkify/tiling.hir | 0
.../test_inputs/forkify/untiling.hir | 0
juno_frontend/src/lib.rs | 6 +-
juno_samples/matmul/build.rs | 1 +
10 files changed, 232 insertions(+), 105 deletions(-)
delete mode 100644 hercules_test/test_inputs/forkify/tiling.hir
delete mode 100644 hercules_test/test_inputs/forkify/untiling.hir
diff --git a/hercules_ir/src/loops.rs b/hercules_ir/src/loops.rs
index b4fed67b..2f5ae580 100644
--- a/hercules_ir/src/loops.rs
+++ b/hercules_ir/src/loops.rs
@@ -27,7 +27,7 @@ pub struct LoopTree {
// Maps loop headers to their control nodes, and a possible header of the loop they are contained in.
// FIXME: (@xrouth) shouldn't the parent be an Option: i.e what if there is no loop parent.
loops: HashMap<NodeID, (BitVec<u8, Lsb0>, NodeID)>,
- nesting: HashMap<NodeID, usize>,
+ nesting: HashMap<NodeID, usize>,
}
impl LoopTree {
diff --git a/hercules_opt/src/forkify.rs b/hercules_opt/src/forkify.rs
index adbd927e..55acb725 100644
--- a/hercules_opt/src/forkify.rs
+++ b/hercules_opt/src/forkify.rs
@@ -18,7 +18,9 @@ use crate::bound_induction_variables;
use crate::compute_induction_vars;
use crate::compute_loop_variance;
use crate::get_loop_exit_conditions;
+use crate::loop_data_location;
use crate::BasicInductionVariable;
+use crate::DataUseLoopLocation;
use crate::FunctionEditor;
use crate::Loop;
use crate::LoopBound;
@@ -41,86 +43,49 @@ pub fn forkify(
) -> () {
println!("loops: {:?} ", loops.bottom_up_loops());
- let natural_loops = loops
- .bottom_up_loops()
- .into_iter()
- .filter(|(k, _)| editor.func().nodes[k.idx()].is_region());
-
- let natural_loops: Vec<_> = natural_loops.collect();
-
- for l in natural_loops {
- forkify_loop(editor, control_subgraph, fork_join_map, &Loop { header: l.0, control: l.1.clone()});
- break; //TODO: REMOVE ME
- }
-}
-
-/** Provides a utility to answer the question whether a data node is entirely contained within a loop or not.
-If the node has no uses outside of the loop,
-loop transformations are free to get rid of it.
-looop
-Returns a map from Nodes -> bool,
-- True means the node does not use any values that are in the loop.
-- False means the node is outside the loop.
-*/
-
-// Buggy scenario:
-// What if a node has two uses, one is the IV of a loop,
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub enum DataUseLoopLocation {
- Unknown,
- Inside,
- Outside,
-}
-
-// FIXME: This is a mess.
-// A user is 'after' the loop is finished if we walk the users of it, (or itself), and
-// any control node on the frontier of control nodes (don't go through users of control nodes) is
-// not in the loop body or is not the loop header.
-
-pub fn loop_data_location(editor: &FunctionEditor, node: NodeID, all_loop_nodes: &BitVec<u8, Lsb0>,
- visited: &mut DenseNodeMap<bool>
-) -> DataUseLoopLocation {
-
- let function = editor.func();
-
- if visited[node.idx()] {
- return DataUseLoopLocation::Unknown;
- }
+ // Loop until all nesting are unchanged.
+ // 'outer: loop {
+ // let mut changed = false;
+ // let natural_loops = loops
+ // .bottom_up_loops()
+ // .into_iter()
+ // .filter(|(k, _)| editor.func().nodes[k.idx()].is_region());
- visited[node.idx()] = true;
+ // let natural_loops: Vec<_> = natural_loops.collect();
- let node_data = &function.nodes[node.idx()];
+ // 'inner: for l in natural_loops {
+ // changed = forkify_loop(editor, control_subgraph, fork_join_map, &Loop { header: l.0, control: l.1.clone()});
- // Control node on frontier.
- if node_data.is_control() {
- return match all_loop_nodes[node.idx()] {
- true => DataUseLoopLocation::Inside,
- false => DataUseLoopLocation::Outside
- }
- }
-
- // Don't go through PHIs that are contorlled by something in the loop either.
- if node_data.is_phi() {
- let control = node_data.try_phi().unwrap().0;
- return match all_loop_nodes[control.idx()] {
- true => DataUseLoopLocation::Inside,
- false => DataUseLoopLocation::Outside // FIXME: Is this the correct condition?
- }
- }
+ // // Recompute nesting every time because I am lazy, two other options:
+ // // 1) have child loops manually add new control nodes to parent loops
+ // // 2) use l.control more smartly (this is basically a disgusting hack).
+ // if changed {
+ // continue 'outer;
+ // }
+ // }
+ // if !changed {
+ // break 'outer;
+ // }
+ // }
- let mut data_location = DataUseLoopLocation::Inside;
+ let natural_loops = loops
+ .bottom_up_loops()
+ .into_iter()
+ .filter(|(k, _)| editor.func().nodes[k.idx()].is_region());
- for node_user in editor.get_users(node) {
- // If any user is outside, then this node is outside, else its on inside.
- if loop_data_location(editor, node_user, &all_loop_nodes, visited) == DataUseLoopLocation::Outside {
- data_location = DataUseLoopLocation::Outside;
- }
+ let natural_loops: Vec<_> = natural_loops.collect();
+
+ for l in natural_loops {
+ // FIXME: Needs to iterate over all loops on bottom level of tree.
+ // This is complicated actually, because we can forkify a parent and have a natural loop in the fork body.
+ forkify_loop(editor, control_subgraph, fork_join_map, &Loop { header: l.0, control: l.1.clone()});
+ return;
}
-
- data_location
+
}
+
/** Given a node used as a loop bound, return a dynamic constant ID. */
fn get_dc_bound(editor: &mut FunctionEditor, bound: LoopBound) -> Result<DynamicConstantID, String> {
// Check for a constant used as loop bound.
@@ -183,7 +148,7 @@ pub fn forkify_loop(
control_subgraph: &Subgraph,
fork_join_map: &HashMap<NodeID, NodeID>,
l: &Loop,
-) -> () {
+) -> bool {
// TODO: Do we want to run analysizes before, I think it's fine to put them in the pass itself.
// i.e no real split between analysis and transformation.
@@ -194,19 +159,19 @@ pub fn forkify_loop(
.next()
.unwrap();
- let Some(loop_condition) = get_loop_exit_conditions(function, l, control_subgraph) else {return};
+ let Some(loop_condition) = get_loop_exit_conditions(function, l, control_subgraph) else {return false};
- let LoopExit::Conditional { if_node: loop_if, condition_node } = loop_condition.clone() else {return};
+ let LoopExit::Conditional { if_node: loop_if, condition_node } = loop_condition.clone() else {return false};
// Compute loop variance
- let loop_variance = compute_loop_variance(function, &l);
+ let loop_variance = compute_loop_variance(editor, &l);
// Compute induction vars
let basic_ivs = compute_induction_vars(function, &l, &loop_variance);
// Compute loop bounds
let Some(basic_iv) = bound_induction_variables(function, &control_subgraph, &l,
- &basic_ivs, &loop_condition, &loop_variance) else {return};
+ &basic_ivs, &loop_condition, &loop_variance) else {return false};
// Check reductionable phis, only PHIs depending on the loop are considered,
// CHECK ME: this is how we avoid reductions that depend on control flow?
@@ -225,8 +190,8 @@ pub fn forkify_loop(
// Non N-Dimensionable PHIS just get convverted to normals reduces.
// Check for a constant used as loop bound.
- let Some(bound) = basic_iv.bound else {return};
- let Ok(bound_dc_id) = get_dc_bound(editor, bound) else {return};
+ let Some(bound) = basic_iv.bound else {return false};
+ let Ok(bound_dc_id) = get_dc_bound(editor, bound) else {return false};
// START EDITING
@@ -270,11 +235,11 @@ pub fn forkify_loop(
let header_uses: Vec<_> = editor.get_uses(l.header).collect();
// TOOD: Handle multiple loop body lasts.
- // If there are multiple candidates for loop body last, return.
+ // If there are multiple candidates for loop body last, return false.
if editor.get_uses(l.header)
.filter(|id| l.control[id.idx()])
.count() > 1 {
- return;
+ return false;
}
let loop_body_last = editor.get_uses(l.header)
@@ -284,15 +249,14 @@ pub fn forkify_loop(
if reductionable_phis.iter()
.any(|phi| matches!(phi, LoopPHI::LoopDependant(_))) {
- return
+ return false
}
// Check if all loop PHIs are the same type.
if !all_same_variant(reductionable_phis.iter()) {
- return
+ return false
}
-
// Analyze the control that is inside the loop:
// FOR NOW: Assume basic structure where loop header is region, unconditionally goes to if, and then branches to continue or exit projections.
@@ -302,7 +266,7 @@ pub fn forkify_loop(
.collect();
if header_control_users.first() != Some(&loop_if) {
- return
+ return false
}
// Graft everything between loop_continue_projection (deleted) and header (deleted).
@@ -328,20 +292,20 @@ pub fn forkify_loop(
// - We need to create a new threadID (this is easy actually, its the same as the non-fused case. )
// If there is no inner fork / join, fall back to normal.
- let Some(LoopPHI::NDimensional { phi_node, reduction_node }) = reductionable_phis.first() else {return};
+ let Some(LoopPHI::NDimensional { phi_node, reduction_node }) = reductionable_phis.first() else {return false};
let (inner_join, init, reduct) = function.nodes[reduction_node.idx()].try_reduce().unwrap();
let inner_fork = function.nodes[inner_join.idx()].try_join().unwrap();
if loop_body_last != inner_join {
- return;
+ return false;
}
- let Some(loop_body_first) = editor.get_users(loop_continue_projection).next() else {return};
+ let Some(loop_body_first) = editor.get_users(loop_continue_projection).next() else {return false};
if loop_body_first != inner_fork {
- return;
+ return false;
}
let (_, fork_dimensions) = function.nodes[inner_fork.idx()].try_fork().unwrap();
@@ -538,7 +502,8 @@ pub fn forkify_loop(
};
let reduce_id = edit.add_node(reduce);
- edit.replace_all_uses(reduction_phi, reduce_id)
+ edit = edit.replace_all_uses(reduction_phi, reduce_id)?;
+ edit.delete_node(reduction_phi)
}
);
}
@@ -576,7 +541,7 @@ pub fn forkify_loop(
}
);
- return;
+ return true;
}
diff --git a/hercules_opt/src/ivar.rs b/hercules_opt/src/ivar.rs
index 52fa756c..a734da38 100644
--- a/hercules_opt/src/ivar.rs
+++ b/hercules_opt/src/ivar.rs
@@ -35,12 +35,12 @@ type SparseNodeMap<T> = HashMap<NodeID, T>;
#[derive(Debug)]
pub struct LoopVarianceInfo {
- loop_header: NodeID,
- map: DenseNodeMap<LoopVariance>
+ pub loop_header: NodeID,
+ pub map: DenseNodeMap<LoopVariance>
}
#[derive(Clone, Copy, Debug, PartialEq)]
-enum LoopVariance {
+pub enum LoopVariance {
Unknown,
Invariant,
Variant,
@@ -84,20 +84,122 @@ pub struct BasicInductionVariable {
}
} // nest
+/** Provides a utility to answer the question whether a data node is entirely contained within a loop or not.
+If the node has no uses outside of the loop,
+loop transformations are free to get rid of it.
+looop
+Returns a map from Nodes -> bool,
+- True means the node does not use any values that are in the loop.
+- False means the node is outside the loop.
+*/
+
+// Buggy scenario:
+// What if a node has two uses, one is the IV of a loop,
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum DataUseLoopLocation {
+ Unknown,
+ Inside,
+ Outside,
+}
+
+// FIXME: This is a mess.
+// A user is 'after' the loop is finished if we walk the users of it, (or itself), and
+// any control node on the frontier of control nodes (don't go through users of control nodes) is
+// not in the loop body or is not the loop header.
+
+pub fn loop_data_location(editor: &FunctionEditor, node: NodeID, all_loop_nodes: &BitVec<u8, Lsb0>,
+ visited: &mut DenseNodeMap<bool>
+) -> DataUseLoopLocation {
+
+ let function = editor.func();
+
+ if visited[node.idx()] {
+ return DataUseLoopLocation::Unknown;
+ }
+
+ visited[node.idx()] = true;
+
+ let node_data = &function.nodes[node.idx()];
+
+ // Control node on frontier.
+ if node_data.is_control() {
+ return match all_loop_nodes[node.idx()] {
+ true => DataUseLoopLocation::Inside,
+ false => DataUseLoopLocation::Outside
+ }
+ }
+
+ // Don't go through PHIs that are contorlled by something in the loop either.
+ if node_data.is_phi() {
+ let control = node_data.try_phi().unwrap().0;
+ return match all_loop_nodes[control.idx()] {
+ true => DataUseLoopLocation::Inside,
+ false => DataUseLoopLocation::Outside // FIXME: Is this the correct condition?
+ }
+ }
+
+
+ let mut data_location = DataUseLoopLocation::Inside;
+
+ for node_user in editor.get_users(node) {
+ // If any user is outside, then this node is outside, else its on inside.
+ if loop_data_location(editor, node_user, &all_loop_nodes, visited) == DataUseLoopLocation::Outside {
+ data_location = DataUseLoopLocation::Outside;
+ }
+ }
+
+ data_location
+}
+
+
+pub fn get_loop_data_location<'a>(
+ editor: &'a FunctionEditor, l: &'a Loop
+) -> DenseNodeMap<DataUseLoopLocation> {
+
+ let function = editor.func();
+ let mut result = vec![DataUseLoopLocation::Unknown; function.nodes.len()];
+
+ for node in (0..function.nodes.len()).map(NodeID::new) {
+ let mut visited = vec![false; function.nodes.len()];
+ result[node.idx()] = loop_data_location(&editor, node, &l.get_all_nodes(), &mut visited)
+ }
+
+ result
+}
+
+pub fn get_loop_phis<'a>(function: &'a Function, l: &'a Loop) -> impl Iterator<Item = NodeID> + 'a {
+ function.nodes.iter().enumerate().filter_map(
+ move |(node_id, node)| {
+ if let Some((control, _)) = node.try_phi() {
+ if l.control[control.idx()] {
+ Some(NodeID::new(node_id))
+ } else {
+ None
+ }
+ } else {
+ None
+ }
+ }
+ )
+}
+
+// FIXME: Need a trait that Editor and Function both implement, that gives us UseDefInfo
+
/** Given a loop (from LoopTree) determine for each data node if. Queries on control nodes are undefined. */
-pub fn compute_loop_variance(function: &Function, l: &Loop) -> LoopVarianceInfo {
+pub fn compute_loop_variance(editor: &FunctionEditor, l: &Loop) -> LoopVarianceInfo {
// Gather all Phi nodes that are controlled by this loop.
let mut loop_vars: Vec<NodeID> = vec![];
- for (node_id, node) in function.nodes.iter().enumerate() {
+ for node_id in editor.get_users(l.header) {
+ let node = &editor.func().nodes[node_id.idx()];
if let Some((control, _)) = node.try_phi() {
if l.control[control.idx()] {
- loop_vars.push(NodeID::new(node_id));
+ loop_vars.push(node_id);
}
}
}
- let len = function.nodes.len();
+ let len = editor.func().nodes.len();
let mut all_loop_nodes = l.control.clone();
@@ -150,8 +252,8 @@ pub fn compute_loop_variance(function: &Function, l: &Loop) -> LoopVarianceInfo
let mut visited: DenseNodeMap<bool> = vec![false; len];
- for node in (0..function.nodes.len()).map(NodeID::new) {
- recurse(function, node, &all_loop_nodes, &mut variance_map, &mut visited);
+ for node in (0..len).map(NodeID::new) {
+ recurse(editor.func(), node, &all_loop_nodes, &mut variance_map, &mut visited);
};
return LoopVarianceInfo { loop_header: l.header, map: variance_map };
@@ -222,6 +324,8 @@ pub fn get_loop_exit_conditions(function: &Function, l: &Loop, control_subgraph:
Returns the single induction variable that is used in the loop exit condition, or None if something is wrong.
(CODE STYLE: Context w/ None, look into Anyhow::RESULT? )
+ This gives the beginning and final value of the IV, THIS ISN"T NECESSARILY THE ITERATION COUNT.
+
*/
pub fn bound_induction_variables(function: &Function, control_subgraph: &Subgraph, l: &Loop,
induction_vars: &[BasicInductionVariable], loop_condition: &LoopExit, loop_variance: &LoopVarianceInfo)
@@ -245,7 +349,8 @@ pub fn bound_induction_variables(function: &Function, control_subgraph: &Subgrap
LoopExit::Unconditional(node_id) => todo!()
};
- // Check for an induction variable that interacts reasonably with the loop condition via pattern matching.
+ // Check for an induction variable that interacts reasonably with the loop condition via pattern matching.
+ // FIXME: Is there a better way to check for loop bounds?
for induction_var in induction_vars {
let bound = match &function.nodes[loop_condition.idx()] {
// All of these node types are valid boolean conditionals, we only handle some currently.
@@ -271,6 +376,8 @@ pub fn bound_induction_variables(function: &Function, control_subgraph: &Subgrap
else {
None
}
+
+ // left is some expression
}
BinaryOperator::LTE => todo!(), // like wtf.
BinaryOperator::GT => todo!(),
diff --git a/hercules_opt/src/lib.rs b/hercules_opt/src/lib.rs
index 9b18fb33..444fb275 100644
--- a/hercules_opt/src/lib.rs
+++ b/hercules_opt/src/lib.rs
@@ -20,6 +20,7 @@ pub mod fork_transforms;
pub mod ivar;
pub mod unforkify;
pub mod utils;
+pub mod loop_fixification;
pub use crate::ccp::*;
pub use crate::dce::*;
@@ -39,6 +40,6 @@ pub use crate::schedule::*;
pub use crate::sroa::*;
pub use crate::fork_transforms::*;
pub use crate::ivar::*;
-
+pub use crate::loop_fixification::*;
pub use crate::unforkify::*;
pub use crate::utils::*;
diff --git a/hercules_opt/src/pass.rs b/hercules_opt/src/pass.rs
index 2d330cf6..58e36a71 100644
--- a/hercules_opt/src/pass.rs
+++ b/hercules_opt/src/pass.rs
@@ -48,6 +48,7 @@ pub enum Pass {
// Parameterized over where to serialize module to.
Serialize(String),
ForkFission,
+ LoopCanonicalization,
}
/*
@@ -1006,6 +1007,47 @@ impl PassManager {
self.module.functions[idx].delete_gravestones();
}
self.clear_analyses();
+ },
+ Pass::LoopCanonicalization => {
+ self.make_def_uses();
+ self.make_loops();
+ self.make_control_subgraphs();
+ self.make_fork_join_maps();
+ self.make_typing();
+ self.make_doms();
+ let def_uses = self.def_uses.as_ref().unwrap();
+ let loops = self.loops.as_ref().unwrap();
+ let fork_join_maps = self.fork_join_maps.as_ref().unwrap();
+ let types = self.typing.as_ref().unwrap();
+ for idx in 0..self.module.functions.len() {
+ let constants_ref =
+ RefCell::new(std::mem::take(&mut self.module.constants));
+ let dynamic_constants_ref =
+ RefCell::new(std::mem::take(&mut self.module.dynamic_constants));
+ let types_ref = RefCell::new(std::mem::take(&mut self.module.types));
+ let control_subgraph = &self.control_subgraphs.as_ref().unwrap()[idx];
+ let mut editor = FunctionEditor::new(
+ &mut self.module.functions[idx],
+ &constants_ref,
+ &dynamic_constants_ref,
+ &types_ref,
+ &def_uses[idx],
+ );
+
+ loop_fixification(
+ &mut editor,
+ control_subgraph,
+ &fork_join_maps[idx],
+ &loops[idx],
+ );
+
+ self.module.constants = constants_ref.take();
+ self.module.dynamic_constants = dynamic_constants_ref.take();
+ self.module.types = types_ref.take();
+
+ self.module.functions[idx].delete_gravestones();
+ }
+ self.clear_analyses();
}
}
println!("Ran pass: {:?}", pass);
diff --git a/hercules_test/hercules_interpreter/src/interpreter.rs b/hercules_test/hercules_interpreter/src/interpreter.rs
index bda02590..1a38c4d6 100644
--- a/hercules_test/hercules_interpreter/src/interpreter.rs
+++ b/hercules_test/hercules_interpreter/src/interpreter.rs
@@ -15,7 +15,7 @@ extern crate hercules_opt;
use self::hercules_ir::*;
-const VERBOSE: bool = true;
+const VERBOSE: bool = false;
/* High level design details / discussion for this:
*
@@ -448,7 +448,14 @@ impl<'a> FunctionExecutionState<'a> {
// TODO (@xrouth): Recurse on writes correctly
let val = match index {
- Index::Field(_) => todo!(),
+ Index::Field(idx) => {
+ if let InterpreterVal::Product(type_id, mut vals) = collection {
+ vals[*idx] = data;
+ InterpreterVal::Product(type_id, vals)
+ } else {
+ panic!("PANIC: Field index on not a product type")
+ }
+ },
Index::Variant(_) => todo!(),
Index::Position(array_indices) => {
// Arrays also have inner indices...
diff --git a/hercules_test/test_inputs/forkify/tiling.hir b/hercules_test/test_inputs/forkify/tiling.hir
deleted file mode 100644
index e69de29b..00000000
diff --git a/hercules_test/test_inputs/forkify/untiling.hir b/hercules_test/test_inputs/forkify/untiling.hir
deleted file mode 100644
index e69de29b..00000000
diff --git a/juno_frontend/src/lib.rs b/juno_frontend/src/lib.rs
index b18b2979..89fbc98e 100644
--- a/juno_frontend/src/lib.rs
+++ b/juno_frontend/src/lib.rs
@@ -184,7 +184,11 @@ pub fn compile_ir(
if x_dot {
pm.add_pass(hercules_opt::pass::Pass::Xdot(true));
}
- //add_pass!(pm, verify, Forkify);
+ pm.add_pass(hercules_opt::pass::Pass::Serialize(module_name.clone() + ".module"));
+ add_pass!(pm, verify, Forkify);
+ if x_dot {
+ pm.add_pass(hercules_opt::pass::Pass::Xdot(true));
+ }
//add_pass!(pm, verify, ForkGuardElim);
add_verified_pass!(pm, verify, DCE);
add_pass!(pm, verify, Outline);
diff --git a/juno_samples/matmul/build.rs b/juno_samples/matmul/build.rs
index 81f645e0..213f3ea2 100644
--- a/juno_samples/matmul/build.rs
+++ b/juno_samples/matmul/build.rs
@@ -3,6 +3,7 @@ use juno_build::JunoCompiler;
fn main() {
JunoCompiler::new()
+ .x_dot(false)
.file_in_src("matmul.jn")
.unwrap()
.build()
--
GitLab
From 1a3f9e236cb1a723f3373a964f702bfd3848dedd Mon Sep 17 00:00:00 2001
From: Xavier Routh <xrouth2@illinois.edu>
Date: Mon, 6 Jan 2025 14:41:23 -0500
Subject: [PATCH 23/68] tests and canonicalization apss
---
hercules_opt/src/loop_fixification.rs | 437 ++++++++++++++++++
.../hercules_tests/tests/loop_tests.rs | 193 ++++++++
.../fork_transforms/matmul_int.hir | 18 +
.../fork_transforms/tiled_matmul_int.hir | 18 +
.../loop_analysis/alternate_bounds.hir | 14 +
.../alternate_bounds_use_after_loop.hir | 18 +
...alternate_bounds_use_after_loop_no_tid.hir | 17 +
...lternate_bounds_use_after_loop_no_tid2.hir | 19 +
.../test_inputs/loop_analysis/broken_sum.hir | 16 +
.../loop_analysis/loop_array_sum.hir | 16 +
.../loop_analysis/loop_body_count.hir | 16 +
.../test_inputs/loop_analysis/loop_sum.hir | 16 +
.../loop_analysis/loop_trip_count_tuple.hir | 19 +
13 files changed, 817 insertions(+)
create mode 100644 hercules_opt/src/loop_fixification.rs
create mode 100644 hercules_test/hercules_tests/tests/loop_tests.rs
create mode 100644 hercules_test/test_inputs/fork_transforms/matmul_int.hir
create mode 100644 hercules_test/test_inputs/fork_transforms/tiled_matmul_int.hir
create mode 100644 hercules_test/test_inputs/loop_analysis/alternate_bounds.hir
create mode 100644 hercules_test/test_inputs/loop_analysis/alternate_bounds_use_after_loop.hir
create mode 100644 hercules_test/test_inputs/loop_analysis/alternate_bounds_use_after_loop_no_tid.hir
create mode 100644 hercules_test/test_inputs/loop_analysis/alternate_bounds_use_after_loop_no_tid2.hir
create mode 100644 hercules_test/test_inputs/loop_analysis/broken_sum.hir
create mode 100644 hercules_test/test_inputs/loop_analysis/loop_array_sum.hir
create mode 100644 hercules_test/test_inputs/loop_analysis/loop_body_count.hir
create mode 100644 hercules_test/test_inputs/loop_analysis/loop_sum.hir
create mode 100644 hercules_test/test_inputs/loop_analysis/loop_trip_count_tuple.hir
diff --git a/hercules_opt/src/loop_fixification.rs b/hercules_opt/src/loop_fixification.rs
new file mode 100644
index 00000000..183b7bc4
--- /dev/null
+++ b/hercules_opt/src/loop_fixification.rs
@@ -0,0 +1,437 @@
+extern crate hercules_ir;
+extern crate itertools;
+extern crate nestify;
+
+use std::collections::HashMap;
+use std::collections::HashSet;
+use std::iter::FromIterator;
+
+use self::nestify::nest;
+
+use self::hercules_ir::get_uses;
+
+use self::itertools::Itertools;
+
+use self::hercules_ir::BinaryOperator;
+
+use self::hercules_ir::Function;
+use self::hercules_ir::Node;
+
+use self::hercules_ir::ID;
+
+use self::hercules_ir::NodeID;
+
+use self::hercules_ir::Subgraph;
+
+use crate::compute_induction_vars;
+use crate::compute_loop_variance;
+use crate::get_loop_data_location;
+use crate::get_loop_exit_conditions;
+use crate::get_loop_phis;
+use crate::BasicInductionVariable;
+use crate::DataUseLoopLocation;
+use crate::DenseNodeMap;
+use crate::FunctionEditor;
+use crate::Loop;
+use crate::LoopExit;
+use crate::LoopVariance;
+
+use self::hercules_ir::LoopTree;
+
+pub fn loop_fixification(
+ editor: &mut FunctionEditor,
+ control_subgraph: &Subgraph,
+ fork_join_map: &HashMap<NodeID, NodeID>,
+ loops: &LoopTree,
+
+) -> () {
+ println!("loops: {:?} ", loops.bottom_up_loops());
+
+ let natural_loops = loops
+ .bottom_up_loops()
+ .into_iter()
+ .filter(|(k, _)| editor.func().nodes[k.idx()].is_region());
+
+ let natural_loops: Vec<_> = natural_loops.collect();
+
+ let mut loop_exits = HashMap::new();
+
+ for l in &natural_loops {
+ let Some(loop_exit) = get_loop_exit_conditions(editor.func(), &Loop { header: l.0, control: l.1.clone()}, control_subgraph) else {continue};
+ loop_exits.insert(l.0, loop_exit);
+ }
+
+
+ for l in natural_loops {
+ let natural_loop = &Loop { header: l.0, control: l.1.clone()};
+ convert_to_while_loop(editor, natural_loop, loop_exits.get(&l.0).copied());
+ fixify_loop(editor, loop_exits.get(&l.0).copied(), fork_join_map, natural_loop);
+ return;
+ }
+
+}
+
+//
+pub enum ConversionResult {
+ Failure,
+ Success,
+}
+
+/** Attempts to converts a simple natural loop to a while loop
+ by moving all control between the loop header and the loop condition to after the loop true condition,
+ but before the header.
+ FIXME: Check whether the loop is guaranteed to be entered.
+ * */
+pub fn convert_to_while_loop(
+ editor: &mut FunctionEditor,
+ natural_loop: &Loop,
+ loop_exit: Option<LoopExit>,
+
+) -> ConversionResult {
+
+ // FIXME: Check that Loop is simple.
+
+ // FIXME: Check whether the loop is guaranteed to be entered.
+ // i.e add a guard if needed.
+
+ let Some(LoopExit::Conditional { if_node, condition_node: _ }) = loop_exit.clone() else {return ConversionResult::Failure};
+
+ // Get the control in between the header and before the condition,
+
+ // If the header -> if, then there is no control before the condition, so it's a while loop.
+ if editor.get_uses(if_node).contains(&natural_loop.header) {
+ return ConversionResult::Success
+ }
+
+ let loop_before_if_first = editor.get_users(natural_loop.header)
+ .filter(|id| natural_loop.control[id.idx()])
+ .next()
+ .unwrap();
+
+ let loop_before_if_last = editor.get_uses(if_node).next().unwrap();
+
+ assert_ne!(loop_before_if_first, loop_before_if_last);
+
+ let loop_exit_projection = editor.get_users(if_node)
+ .filter(|id| !natural_loop.control[id.idx()])
+ .next()
+ .unwrap();
+
+ let loop_continue_projection = editor.get_users(if_node)
+ .filter(|id| natural_loop.control[id.idx()])
+ .next()
+ .unwrap();
+
+ // Control goes after the loop_continue_projection, and before whatever is after loop_continue_projection.
+ let loop_body_last = editor.get_uses(natural_loop.header)
+ .filter(|id| natural_loop.control[id.idx()])
+ .next()
+ .unwrap();
+
+ editor.edit(|mut edit| {
+ // have fun understanding this!
+ edit = edit.replace_all_uses(loop_continue_projection, loop_before_if_last)?;
+ edit = edit.replace_all_uses_where(natural_loop.header, loop_continue_projection, |usee| *usee == loop_before_if_first)?;
+ edit = edit.replace_all_uses_where(loop_before_if_last, natural_loop.header, |usee| *usee == if_node)?;
+
+ Ok(edit)
+ });
+
+
+ ConversionResult::Success
+}
+
+// FIXME: Return whether the loop is already in fixified form or was able to be place in fixifeid form, vs
+// if it didn't get fixified. Blah.
+pub fn fixify_loop(
+ editor: &mut FunctionEditor,
+ loop_exit: Option<LoopExit>,
+ fork_join_map: &HashMap<NodeID, NodeID>,
+ l: &Loop,
+) -> bool {
+
+ let function = editor.func();
+
+ let Some(loop_condition) = loop_exit else {return false};
+
+ let LoopExit::Conditional { if_node: loop_if, condition_node } = loop_condition.clone() else {return false};
+
+ // Compute loop variance
+ let loop_variance = compute_loop_variance(&editor, &l);
+
+ // Compute induction vars
+ let basic_ivs = compute_induction_vars(function, &l, &loop_variance);
+
+ // Analyze Loop Bound (pattern match w/ )
+ let alternate_iv = basic_ivs.iter().filter_map(|iv|
+ {
+ match &function.nodes[condition_node.idx()] {
+ Node::Start => todo!(),
+ Node::Phi { control, data } => todo!(),
+ Node::Reduce { control, init, reduct } => todo!(),
+ Node::Parameter { index } => todo!(),
+ Node::Constant { id } => todo!(),
+ Node::Unary { input, op } => todo!(),
+ Node::Ternary { first, second, third, op } => todo!(),
+ Node::Binary { left, right, op } => {
+ match op {
+ BinaryOperator::LT => {
+ // Check for a loop guard condition.
+ // ADDME: Check if the condition is *normal* already, and then check if the rest of the loop is normal.
+
+ // left + 1 < right
+ let Node::Binary { left: inner_left, right: inner_right, op: inner_op } = function.nodes[left.idx()] else {return None};
+ if inner_op == BinaryOperator::Add &&
+ ((inner_left == iv.update && inner_right == iv.node) ||
+ (inner_right == iv.update && inner_left == iv.node)) &&
+ loop_variance.map[right.idx()] == LoopVariance::Invariant
+ {
+ return Some((left, iv));
+ } else {
+ return None;
+ }
+
+ }
+ BinaryOperator::LTE => todo!(),
+ BinaryOperator::GT => todo!(),
+ BinaryOperator::GTE => todo!(),
+ BinaryOperator::EQ => todo!(),
+ BinaryOperator::NE => todo!(),
+ _ => None,
+ }
+
+ }
+ _ => None,
+ }
+ }
+ ).next();
+
+
+
+ let Some((iv_expression, base_iv)) = alternate_iv else {return false};
+ let iv_expression = iv_expression.clone();
+ let base_iv = base_iv.clone();
+
+
+ // If there are users of iv_expression (not just the loop bound condition), then abort
+ if editor.get_users(iv_expression).count() > 2 {return false};
+
+ // Replace external_uses uses of data with phi.
+ // Panic on internal uses.
+ struct PhiTransformInfo {
+ phi: NodeID,
+ data: NodeID,
+ external_uses: Vec<NodeID>,
+ internal_uses: Vec<NodeID>
+ }
+
+ // The initiailzer position for all loop phis.
+ let loop_phi_init_idx = editor.get_uses(l.header)
+ .position(|node| !l.control[node.idx()] // Position of the predecessor (used by header but not in loop body.)
+ ).unwrap();
+
+ let data_use_locations = get_loop_data_location(editor, l);
+
+ // Check all PHIs in the loop:
+ let transform_infos: Option<Vec<_>> = get_loop_phis(function, l)
+ .filter(|phi| *phi != base_iv.node)
+ .map(|phi: NodeID| {
+
+ // There should only be one candidate data,
+ // but possibly multiple external uses. z
+
+ let initializer_node_id = editor.func().nodes[phi.idx()].try_phi().unwrap().1[loop_phi_init_idx];
+ // Check if any use is in a cycle w/ the phi.
+ let mut iter =
+ editor.get_uses(phi)
+ .filter(|phi_use|
+ *phi_use != initializer_node_id) // Not the initializer.
+ .filter_map(|phi_use| {
+
+ // If the data node is not in a cycle w/ the phi,
+ if !walk_all_uses(phi_use, editor).contains(&phi) {return None};
+
+ // Find users of phi_use that are outside the loop, these we will change to use the phi.
+ let (internal_uses, external_uses) = editor
+ .get_users(phi_use)
+ .filter_map(|data_user| {
+ Some(data_user)
+ }).partition(|data_user| {
+ match data_use_locations[data_user.idx()] {
+ DataUseLoopLocation::Unknown => todo!(),
+ DataUseLoopLocation::Inside => true,
+ DataUseLoopLocation::Outside => false,
+ }
+ });
+
+ Some((phi_use, internal_uses, external_uses))
+ });
+
+
+
+
+ let Some((data, internal_uses, external_uses)) = iter.next() else {
+ return None;
+ };
+
+ if iter.next().is_some() {
+ return None;
+ }
+
+ // Check usres of the PHI, make sure they aren't outside the loop
+ // Condition: (unless its the one we found in step (1))
+ // Refinment: Unless they would be outside because of the use we are going to get rid of,
+ // need a more complicated use location analysis for this.
+ if editor.get_users(phi)
+ .any(|node|
+ {
+ if node == data {
+ return false;
+ }
+
+ let stop_on: HashSet<NodeID> = editor.node_ids().filter(|n| {
+ if *n == data {
+ return true
+ };
+
+ let node_data = &editor.func().nodes[n.idx()];
+
+ // Stop on Control.
+ if node_data.is_control() {
+ return true;
+ }
+ // Stop on PHIs.
+ if node_data.is_phi() {
+ // Need to maybe not stop on PHIs, but only stop on some of their uses.
+ let control = node_data.try_phi().unwrap().0;
+ return l.control[control.idx()];
+ }
+
+ false
+ }).collect();
+
+ let outside_loop = editor.node_ids().filter(|n| editor.func().nodes[n.idx()].is_control() && !l.control[n.idx()]);
+
+ // If any uses are control nodes *outside* the loop,
+ let node_uses = walk_all_users_stop_on(node, editor, stop_on);
+
+ // TODO: Do intersection lazily?
+ let set1: HashSet<_> = HashSet::from_iter(outside_loop);
+ let set2: HashSet<_> = HashSet::from_iter(node_uses);
+
+ // If there is no intersection, then it is inside the loop
+ if set1.intersection(&set2).next().is_none() {
+ false // No intersection, so all users of this phi are good
+ } else {
+ true // Intersection, so some user of this phi leaves the loop, and we can't fix it by transforming.
+ }
+ }
+ ) {
+ return None;
+ };
+
+ Some(PhiTransformInfo {
+ phi,
+ data,
+ external_uses,
+ internal_uses,
+ })
+ }).collect();
+
+ let Some(transform_infos) = transform_infos else {
+ return false;
+ };
+
+ if transform_infos.len() != 1 {
+ return false;
+ }
+
+ let transform_info = &transform_infos[0];
+
+ // Change loop bounds
+ editor.edit(|edit|
+ edit.replace_all_uses_where(iv_expression, base_iv.node, |usee| *usee == condition_node)
+ );
+
+ editor.edit(|mut edit|
+ {
+ edit.replace_all_uses_where(transform_info.data, transform_info.phi, |usee| transform_info.external_uses.contains(usee))
+ }
+ );
+ //
+
+ true
+}
+
+
+
+nest! {
+// Is this something editor should give... Or is it just for analyses.
+//
+#[derive(Clone, Debug)]
+pub struct NodeIterator<'a> {
+ pub direction:
+ #[derive(Clone, Debug, PartialEq)]
+ enum Direction {
+ Uses,
+ Users,
+ },
+ visited: DenseNodeMap<bool>,
+ stack: Vec<NodeID>,
+ func: &'a FunctionEditor<'a>, // Maybe this is an enum, def use can be gotten from the function or from the editor.
+ // `stop condition`, then return all nodes that caused stoppage i.e the frontier of the search.
+ stop_on: HashSet<NodeID>, // Don't add neighbors of these.
+}
+}
+
+pub fn walk_all_uses<'a>(node: NodeID, editor: &'a FunctionEditor<'a>) -> NodeIterator<'a> {
+ let len = editor.func().nodes.len();
+ NodeIterator { direction: Direction::Uses, visited: vec![false; len], stack: vec![node], func: editor,
+ stop_on: HashSet::new()}
+}
+
+pub fn walk_all_users<'a>(node: NodeID, editor: &'a FunctionEditor<'a>) -> NodeIterator<'a> {
+ let len = editor.func().nodes.len();
+ NodeIterator { direction: Direction::Users, visited: vec![false; len], stack: vec![node], func: editor,
+ stop_on: HashSet::new()}
+}
+
+pub fn walk_all_uses_stop_on<'a>(node: NodeID, editor: &'a FunctionEditor<'a>, stop_on: HashSet<NodeID>) -> NodeIterator<'a> {
+ let len = editor.func().nodes.len();
+ NodeIterator { direction: Direction::Uses, visited: vec![false; len], stack: vec![node], func: editor,
+ stop_on,}
+}
+
+pub fn walk_all_users_stop_on<'a>(node: NodeID, editor: &'a FunctionEditor<'a>, stop_on: HashSet<NodeID>) -> NodeIterator<'a> {
+ let len = editor.func().nodes.len();
+ NodeIterator { direction: Direction::Users, visited: vec![false; len], stack: vec![node], func: editor,
+ stop_on,}
+}
+
+impl<'a> Iterator for NodeIterator<'a> {
+ type Item = NodeID;
+
+ fn next(&mut self) -> Option<Self::Item> {
+ while let Some(current) = self.stack.pop() {
+
+ if !self.visited[current.idx()]{
+ self.visited[current.idx()] = true;
+
+ if !self.stop_on.contains(¤t) {
+ if self.direction == Direction::Uses {
+ for neighbor in self.func.get_uses(current) {
+ self.stack.push(neighbor)
+ }
+ } else {
+ for neighbor in self.func.get_users(current) {
+ self.stack.push(neighbor)
+ }
+ }
+ }
+
+ return Some(current);
+ }
+ }
+ None
+ }
+}
\ No newline at end of file
diff --git a/hercules_test/hercules_tests/tests/loop_tests.rs b/hercules_test/hercules_tests/tests/loop_tests.rs
new file mode 100644
index 00000000..449bb5df
--- /dev/null
+++ b/hercules_test/hercules_tests/tests/loop_tests.rs
@@ -0,0 +1,193 @@
+use std::{env, fs::File, io::Read, path::Path};
+
+use hercules_interpreter::*;
+use hercules_opt::pass::Pass;
+use hercules_ir::ID;
+
+
+extern crate rand;
+use rand::Rng;
+
+#[test]
+fn loop_trip_count() {
+ let module = parse_file("../test_inputs/loop_analysis/loop_trip_count.hir");
+ let dyn_consts = [10];
+ let params = 2; // TODO: (@xrouth) fix macro to take no params as an option.
+ let result_1 = interp_module!(module, dyn_consts, 2);
+
+ println!("result: {:?}", result_1);
+
+}
+
+#[test]
+fn loop_alternate_sum() {
+ let len = 1;
+ let dyn_consts = [len];
+ let params = vec![1, 2, 3, 4, 5];
+
+ let module = parse_file("../test_inputs/loop_analysis/alternate_bounds_use_after_loop.hir");
+ let result_1 = interp_module!(module, dyn_consts, params);
+
+ println!("result: {:?}", result_1);
+
+}
+
+#[test]
+fn loop_canonical_sum() {
+ let len = 1;
+ let dyn_consts = [len];
+ let params = vec![1, 2, 3, 4, 5];
+
+ let module = parse_file("../test_inputs/loop_analysis/loop_array_sum.hir");
+ let result_1 = interp_module!(module, dyn_consts, params);
+
+ println!("result: {:?}", result_1);
+
+}
+
+#[test]
+fn matmul_pipeline() {
+ let len = 1;
+ let dyn_consts = [2, 2, 2];
+ let m1 = vec![1, 2, 3, 4];
+ let m2 = vec![5, 6, 7, 8];
+
+ // FIXME: This path should not leave the crate
+ let module = parse_module_from_hbin("../../juno_samples/matmul/matmul.hbin");
+ let result_1 = interp_module!(module, dyn_consts, m1.clone(), m2.clone());
+
+ println!("result: {:?}", result_1);
+
+ let mut pm = hercules_opt::pass::PassManager::new(module.clone());
+
+ let passes = vec![
+ Pass::Verify,
+ Pass::CCP,
+ Pass::DCE,
+ Pass::GVN,
+ Pass::Verify,
+ ];
+
+ for pass in passes {
+ pm.add_pass(pass);
+ }
+ pm.run_passes();
+
+
+ let module = pm.get_module();
+ let result_2 = interp_module!(module, dyn_consts, m1.clone(), m2.clone());
+ assert_eq!(result_1, result_2);
+
+ // -------------------
+ let mut pm = hercules_opt::pass::PassManager::new(module.clone());
+
+ let passes = vec![
+ Pass::LoopCanonicalization,
+ Pass::Verify,
+ ];
+
+ for pass in passes {
+ pm.add_pass(pass);
+ }
+ pm.run_passes();
+
+
+ let module = pm.get_module();
+ let result_2 = interp_module!(module, dyn_consts, m1.clone(), m2.clone());
+ assert_eq!(result_1, result_2);
+
+ // -------------------
+ let mut pm = hercules_opt::pass::PassManager::new(module.clone());
+
+ let passes = vec![
+ Pass::Forkify,
+ Pass::DCE,
+ Pass::Verify,
+ ];
+
+ for pass in passes {
+ pm.add_pass(pass);
+ }
+ pm.run_passes();
+
+ let module = pm.get_module();
+ let result_2 = interp_module!(module, dyn_consts, m1.clone(), m2.clone());
+ assert_eq!(result_1, result_2);
+
+ // -------
+ let mut pm = hercules_opt::pass::PassManager::new(module.clone());
+
+ let passes = vec![
+ Pass::ForkGuardElim,
+ Pass::DCE,
+ Pass::Verify,
+ ];
+
+ for pass in passes {
+ pm.add_pass(pass);
+ }
+ pm.run_passes();
+
+ let module = pm.get_module();
+ let result_2 = interp_module!(module, dyn_consts, m1.clone(), m2.clone());
+ assert_eq!(result_1, result_2);
+
+ println!("before failture: {:?}", result_2);
+
+ // ========================
+ // -----
+ let mut pm = hercules_opt::pass::PassManager::new(module.clone());
+
+ let passes = vec![
+ Pass::Xdot(true),
+ Pass::LoopCanonicalization,
+ Pass::Verify,
+ Pass::Xdot(true),
+ ];
+
+ for pass in passes {
+ pm.add_pass(pass);
+ }
+ pm.run_passes();
+
+
+ let module = pm.get_module();
+ let result_2 = interp_module!(module, dyn_consts, m1.clone(), m2.clone());
+ assert_eq!(result_1, result_2);
+
+ // -------------------
+ let mut pm = hercules_opt::pass::PassManager::new(module.clone());
+
+ let passes = vec![
+ Pass::Forkify,
+ Pass::DCE,
+ Pass::Verify,
+ ];
+
+ for pass in passes {
+ pm.add_pass(pass);
+ }
+ pm.run_passes();
+
+ let module = pm.get_module();
+ let result_2 = interp_module!(module, dyn_consts, m1.clone(), m2.clone());
+ assert_eq!(result_1, result_2);
+
+ // -------
+ let mut pm = hercules_opt::pass::PassManager::new(module.clone());
+
+ let passes = vec![
+ Pass::ForkGuardElim,
+ Pass::DCE,
+ Pass::Verify,
+ ];
+
+ for pass in passes {
+ pm.add_pass(pass);
+ }
+ pm.run_passes();
+
+ let module = pm.get_module();
+ let result_2 = interp_module!(module, dyn_consts, m1.clone(), m2.clone());
+ assert_eq!(result_1, result_2);
+}
\ No newline at end of file
diff --git a/hercules_test/test_inputs/fork_transforms/matmul_int.hir b/hercules_test/test_inputs/fork_transforms/matmul_int.hir
new file mode 100644
index 00000000..ab0f384a
--- /dev/null
+++ b/hercules_test/test_inputs/fork_transforms/matmul_int.hir
@@ -0,0 +1,18 @@
+fn matmul<3>(a: array(i32, #0, #1), b: array(i32, #1, #2)) -> array(i32, #0, #2)
+ c = constant(array(i32, #0, #2), [])
+ i_j_ctrl = fork(start, #0, #2)
+ i_idx = thread_id(i_j_ctrl, 0)
+ j_idx = thread_id(i_j_ctrl, 1)
+ k_ctrl = fork(i_j_ctrl, #1)
+ k_idx = thread_id(k_ctrl, 0)
+ k_join_ctrl = join(k_ctrl)
+ i_j_join_ctrl = join(k_join_ctrl)
+ r = return(i_j_join_ctrl, update_i_j_c)
+ zero = constant(i32, 0)
+ a_val = read(a, position(i_idx, k_idx))
+ b_val = read(b, position(k_idx, j_idx))
+ mul = mul(a_val, b_val)
+ add = add(mul, dot)
+ dot = reduce(k_join_ctrl, zero, add)
+ update_c = write(update_i_j_c, dot, position(i_idx, j_idx))
+ update_i_j_c = reduce(i_j_join_ctrl, c, update_c)
\ No newline at end of file
diff --git a/hercules_test/test_inputs/fork_transforms/tiled_matmul_int.hir b/hercules_test/test_inputs/fork_transforms/tiled_matmul_int.hir
new file mode 100644
index 00000000..ab0f384a
--- /dev/null
+++ b/hercules_test/test_inputs/fork_transforms/tiled_matmul_int.hir
@@ -0,0 +1,18 @@
+fn matmul<3>(a: array(i32, #0, #1), b: array(i32, #1, #2)) -> array(i32, #0, #2)
+ c = constant(array(i32, #0, #2), [])
+ i_j_ctrl = fork(start, #0, #2)
+ i_idx = thread_id(i_j_ctrl, 0)
+ j_idx = thread_id(i_j_ctrl, 1)
+ k_ctrl = fork(i_j_ctrl, #1)
+ k_idx = thread_id(k_ctrl, 0)
+ k_join_ctrl = join(k_ctrl)
+ i_j_join_ctrl = join(k_join_ctrl)
+ r = return(i_j_join_ctrl, update_i_j_c)
+ zero = constant(i32, 0)
+ a_val = read(a, position(i_idx, k_idx))
+ b_val = read(b, position(k_idx, j_idx))
+ mul = mul(a_val, b_val)
+ add = add(mul, dot)
+ dot = reduce(k_join_ctrl, zero, add)
+ update_c = write(update_i_j_c, dot, position(i_idx, j_idx))
+ update_i_j_c = reduce(i_j_join_ctrl, c, update_c)
\ No newline at end of file
diff --git a/hercules_test/test_inputs/loop_analysis/alternate_bounds.hir b/hercules_test/test_inputs/loop_analysis/alternate_bounds.hir
new file mode 100644
index 00000000..4df92a18
--- /dev/null
+++ b/hercules_test/test_inputs/loop_analysis/alternate_bounds.hir
@@ -0,0 +1,14 @@
+fn sum<1>(a: u32) -> u64
+ zero_idx = constant(u64, 0)
+ one_idx = constant(u64, 1)
+ bound = dynamic_constant(#0)
+ loop = region(start, if_true)
+ idx = phi(loop, zero_idx, idx_inc)
+ idx_inc = add(idx, one_idx)
+ red = phi(loop, zero_idx, red_add)
+ red_add = add(red, one_idx)
+ in_bounds = lt(idx_inc, bound)
+ if = if(loop, in_bounds)
+ if_false = projection(if, 0)
+ if_true = projection(if, 1)
+ r = return(if_false, red)
\ No newline at end of file
diff --git a/hercules_test/test_inputs/loop_analysis/alternate_bounds_use_after_loop.hir b/hercules_test/test_inputs/loop_analysis/alternate_bounds_use_after_loop.hir
new file mode 100644
index 00000000..6b54c531
--- /dev/null
+++ b/hercules_test/test_inputs/loop_analysis/alternate_bounds_use_after_loop.hir
@@ -0,0 +1,18 @@
+fn sum<1>(a: array(u64, #0)) -> u64
+ zero_idx = constant(u64, 0)
+ one_idx = constant(u64, 1)
+ zero_inc = constant(u64, 0)
+ ten = constant(u64, 10)
+ bound = dynamic_constant(#0)
+ loop = region(start, if_true)
+ idx = phi(loop, zero_idx, idx_inc)
+ idx_inc = add(idx, one_idx)
+ red = phi(loop, zero_inc, red_add)
+ read = read(a, position(idx))
+ red_add = add(red, read)
+ in_bounds = lt(idx_inc, bound)
+ if = if(loop, in_bounds)
+ if_false = projection(if, 0)
+ if_true = projection(if, 1)
+ plus_ten = add(red_add, ten)
+ r = return(if_false, plus_ten)
\ No newline at end of file
diff --git a/hercules_test/test_inputs/loop_analysis/alternate_bounds_use_after_loop_no_tid.hir b/hercules_test/test_inputs/loop_analysis/alternate_bounds_use_after_loop_no_tid.hir
new file mode 100644
index 00000000..4b937509
--- /dev/null
+++ b/hercules_test/test_inputs/loop_analysis/alternate_bounds_use_after_loop_no_tid.hir
@@ -0,0 +1,17 @@
+fn sum<1>(a: u64) -> u64
+ zero_idx = constant(u64, 0)
+ one_idx = constant(u64, 1)
+ two = constant(u64, 2)
+ ten = constant(u64, 10)
+ bound = dynamic_constant(#0)
+ loop = region(start, if_true)
+ idx = phi(loop, zero_idx, idx_inc)
+ idx_inc = add(idx, one_idx)
+ red = phi(loop, zero_idx, red_add)
+ red_add = add(red, two)
+ in_bounds = lt(idx_inc, bound)
+ if = if(loop, in_bounds)
+ if_false = projection(if, 0)
+ if_true = projection(if, 1)
+ plus_ten = add(red_add, ten)
+ r = return(if_false, plus_ten)
\ No newline at end of file
diff --git a/hercules_test/test_inputs/loop_analysis/alternate_bounds_use_after_loop_no_tid2.hir b/hercules_test/test_inputs/loop_analysis/alternate_bounds_use_after_loop_no_tid2.hir
new file mode 100644
index 00000000..fd06eb7d
--- /dev/null
+++ b/hercules_test/test_inputs/loop_analysis/alternate_bounds_use_after_loop_no_tid2.hir
@@ -0,0 +1,19 @@
+fn sum<1>(a: u64) -> u64
+ zero_idx = constant(u64, 0)
+ one_idx = constant(u64, 1)
+ two = constant(u64, 2)
+ ten = constant(u64, 10)
+ bound = dynamic_constant(#0)
+ loop = region(start, if_true)
+ idx = phi(loop, zero_idx, idx_inc)
+ idx_inc = add(idx, one_idx)
+ red = phi(loop, zero_idx, red_add)
+ red_add = add(red, two)
+ blah = phi(loop, zero_idx, red_add)
+ in_bounds = lt(idx_inc, bound)
+ if = if(loop, in_bounds)
+ if_false = projection(if, 0)
+ if_true = projection(if, 1)
+ plus_ten = add(red_add, ten)
+ plus_blah = add(blah, red_add)
+ r = return(if_false, plus_blah)
\ No newline at end of file
diff --git a/hercules_test/test_inputs/loop_analysis/broken_sum.hir b/hercules_test/test_inputs/loop_analysis/broken_sum.hir
new file mode 100644
index 00000000..d15ef561
--- /dev/null
+++ b/hercules_test/test_inputs/loop_analysis/broken_sum.hir
@@ -0,0 +1,16 @@
+fn sum<1>(a: array(i32, #0)) -> i32
+ zero_idx = constant(u64, 0)
+ one_idx = constant(u64, 1)
+ zero_inc = constant(i32, 0)
+ bound = dynamic_constant(#0)
+ loop = region(start, if_true)
+ idx = phi(loop, zero_idx, idx_inc)
+ idx_inc = add(idx, one_idx)
+ red = phi(loop, zero_inc, red_add)
+ read = read(a, position(idx))
+ red_add = add(red, read)
+ in_bounds = lt(idx, bound)
+ if = if(loop, in_bounds)
+ if_false = projection(if, 0)
+ if_true = projection(if, 1)
+ r = return(if_false, red_add)
\ No newline at end of file
diff --git a/hercules_test/test_inputs/loop_analysis/loop_array_sum.hir b/hercules_test/test_inputs/loop_analysis/loop_array_sum.hir
new file mode 100644
index 00000000..f9972b59
--- /dev/null
+++ b/hercules_test/test_inputs/loop_analysis/loop_array_sum.hir
@@ -0,0 +1,16 @@
+fn sum<1>(a: array(i32, #0)) -> i32
+ zero_idx = constant(u64, 0)
+ one_idx = constant(u64, 1)
+ zero_inc = constant(i32, 0)
+ bound = dynamic_constant(#0)
+ loop = region(start, if_true)
+ idx = phi(loop, zero_idx, idx_inc)
+ idx_inc = add(idx, one_idx)
+ red = phi(loop, zero_inc, red_add)
+ read = read(a, position(idx))
+ red_add = add(red, read)
+ in_bounds = lt(idx, bound)
+ if = if(loop, in_bounds)
+ if_false = projection(if, 0)
+ if_true = projection(if, 1)
+ r = return(if_false, red)
\ No newline at end of file
diff --git a/hercules_test/test_inputs/loop_analysis/loop_body_count.hir b/hercules_test/test_inputs/loop_analysis/loop_body_count.hir
new file mode 100644
index 00000000..c6f3cbf6
--- /dev/null
+++ b/hercules_test/test_inputs/loop_analysis/loop_body_count.hir
@@ -0,0 +1,16 @@
+fn loop<1>(a: u64) -> u64
+ zero_idx = constant(u64, 0)
+ one_idx = constant(u64, 1)
+ zero_var = constant(u64, 0)
+ one_var = constant(u64, 1)
+ bound = dynamic_constant(#0)
+ loop = region(start, if_true)
+ var = phi(loop, zero_var, var_inc)
+ var_inc = add(var, one_var)
+ idx = phi(loop, zero_idx, idx_inc)
+ idx_inc = add(idx, one_idx)
+ in_bounds = lt(idx, bound)
+ if = if(loop, in_bounds)
+ if_false = projection(if, 0)
+ if_true = projection(if, 1)
+ r = return(if_false, var)
\ No newline at end of file
diff --git a/hercules_test/test_inputs/loop_analysis/loop_sum.hir b/hercules_test/test_inputs/loop_analysis/loop_sum.hir
new file mode 100644
index 00000000..fd9c4deb
--- /dev/null
+++ b/hercules_test/test_inputs/loop_analysis/loop_sum.hir
@@ -0,0 +1,16 @@
+fn loop<1>(a: u32) -> i32
+ zero_idx = constant(u64, 0)
+ one_idx = constant(u64, 1)
+ zero_var = constant(i32, 0)
+ one_var = constant(i32, 1)
+ bound = dynamic_constant(#0)
+ loop = region(start, if_true)
+ var = phi(loop, zero_var, var_inc)
+ var_inc = add(var, one_var)
+ idx = phi(loop, zero_idx, idx_inc)
+ idx_inc = add(idx, one_idx)
+ in_bounds = lt(idx, bound)
+ if = if(loop, in_bounds)
+ if_false = projection(if, 0)
+ if_true = projection(if, 1)
+ r = return(if_false, var)
\ No newline at end of file
diff --git a/hercules_test/test_inputs/loop_analysis/loop_trip_count_tuple.hir b/hercules_test/test_inputs/loop_analysis/loop_trip_count_tuple.hir
new file mode 100644
index 00000000..b756f090
--- /dev/null
+++ b/hercules_test/test_inputs/loop_analysis/loop_trip_count_tuple.hir
@@ -0,0 +1,19 @@
+fn loop<1>(b: prod(u64, u64)) -> prod(u64, u64)
+ zero_idx = constant(u64, 0)
+ one_idx = constant(u64, 1)
+ zero_var = constant(u64, 0)
+ one_var = constant(u64, 1)
+ c = constant(prod(u64, u64), (0, 0))
+ bound = dynamic_constant(#0)
+ loop = region(start, if_true)
+ var = phi(loop, zero_var, var_inc)
+ var_inc = add(var, one_var)
+ idx = phi(loop, zero_idx, idx_inc)
+ idx_inc = add(idx, one_idx)
+ in_bounds = lt(idx, bound)
+ if = if(loop, in_bounds)
+ if_false = projection(if, 0)
+ if_true = projection(if, 1)
+ tuple1 = write(c, var, field(0))
+ tuple2 = write(tuple1, idx, field(1))
+ r = return(if_false, tuple2)
\ No newline at end of file
--
GitLab
From e82d2ab80a8cff3297e62a2b22aacbc53a8004aa Mon Sep 17 00:00:00 2001
From: Xavier Routh <xrouth2@illinois.edu>
Date: Tue, 7 Jan 2025 17:28:13 -0500
Subject: [PATCH 24/68] fork coalesce as separate pass, interpreter bug fix
---
Cargo.lock | 7 +
hercules_opt/Cargo.toml | 1 +
hercules_opt/src/fork_transforms.rs | 163 ++++++++++++-
hercules_opt/src/forkify.rs | 222 +++++-------------
hercules_opt/src/ivar.rs | 9 +
hercules_opt/src/loop_fixification.rs | 19 +-
hercules_opt/src/pass.rs | 46 ++++
hercules_samples/matmul/src/main.rs | 12 +-
.../hercules_interpreter/src/interpreter.rs | 34 ++-
.../tests/fork_transform_tests.rs | 4 +-
.../hercules_tests/tests/loop_tests.rs | 51 +++-
juno_frontend/src/lib.rs | 27 +--
juno_samples/matmul/src/main.rs | 13 +-
13 files changed, 385 insertions(+), 223 deletions(-)
diff --git a/Cargo.lock b/Cargo.lock
index 985d103d..5a692418 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -206,6 +206,12 @@ version = "0.21.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9d297deb1925b89f2ccc13d7635fa0714f12c87adce1c75356b39ca9b7178567"
+[[package]]
+name = "bimap"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "230c5f1ca6a325a32553f8640d31ac9b49f2411e901e427570154868b46da4f7"
+
[[package]]
name = "bincode"
version = "1.3.3"
@@ -675,6 +681,7 @@ dependencies = [
name = "hercules_opt"
version = "0.1.0"
dependencies = [
+ "bimap",
"bitvec",
"either",
"hercules_cg",
diff --git a/hercules_opt/Cargo.toml b/hercules_opt/Cargo.toml
index d91b49f0..be2cbef7 100644
--- a/hercules_opt/Cargo.toml
+++ b/hercules_opt/Cargo.toml
@@ -15,3 +15,4 @@ serde = { version = "*", features = ["derive"] }
hercules_cg = { path = "../hercules_cg" }
hercules_ir = { path = "../hercules_ir" }
nestify = "*"
+bimap = "*"
\ No newline at end of file
diff --git a/hercules_opt/src/fork_transforms.rs b/hercules_opt/src/fork_transforms.rs
index d47416d1..895c94f5 100644
--- a/hercules_opt/src/fork_transforms.rs
+++ b/hercules_opt/src/fork_transforms.rs
@@ -1,6 +1,9 @@
use std::collections::{HashMap, HashSet};
use std::ops::Sub;
extern crate hercules_ir;
+extern crate bimap;
+
+use self::bimap::BiMap;
use self::hercules_ir::LoopTree;
@@ -141,7 +144,7 @@ pub fn fork_fission<'a> (
let mut control_pred = NodeID::new(0);
// This does the reduction fission:
- if false {
+ if true {
for fork in forks.clone() {
// FIXME: If there is control in between fork and join, give up.
let join = fork_join_map[&fork];
@@ -155,16 +158,16 @@ pub fn fork_fission<'a> (
let (new_fork, new_join) = fork_reduce_fission_helper(editor, fork_join_map, reduce_partition, control_pred, fork);
// control_pred = new_join;
- }}
-
- // This does the bufferization:
- let edge = (NodeID::new(15), NodeID::new(16));
- // let edge = (NodeID::new(4), NodeID::new(9));
- let mut edges = HashSet::new();
- edges.insert(edge);
- let fork = loop_tree.bottom_up_loops().first().unwrap().0;
- //let fork = forks.first().unwrap();
- fork_bufferize_fission_helper(editor, fork_join_map, edges, NodeID::new(0), types, fork);
+ }} else {
+ // This does the bufferization:
+ let edge = (NodeID::new(15), NodeID::new(16));
+ // let edge = (NodeID::new(4), NodeID::new(9));
+ let mut edges = HashSet::new();
+ edges.insert(edge);
+ let fork = loop_tree.bottom_up_loops().first().unwrap().0;
+ //let fork = forks.first().unwrap();
+ fork_bufferize_fission_helper(editor, fork_join_map, edges, NodeID::new(0), types, fork);
+ }
}
/** Split a 1D fork into two forks, placing select intermediate data into buffers. */
@@ -358,10 +361,144 @@ pub fn fork_reduce_fission_helper<'a> (
edit.delete_node(fork)
});
+ (new_fork, new_join)
+}
+
+pub fn fork_coalesce(
+ editor: &mut FunctionEditor,
+ loops: &LoopTree,
+ fork_join_map: &HashMap<NodeID, NodeID>,
+ reduce_cycles: &HashMap<NodeID, HashSet<NodeID>>,
+) -> () {
+
+ let fork_joins = loops
+ .bottom_up_loops()
+ .into_iter()
+ .filter(|(k, _)| editor.func().nodes[k.idx()].is_fork());
+
+ let fork_joins: Vec<_> = fork_joins.collect();
+
+ let inner = fork_joins[0].0;
+ let outer = fork_joins[1].0;
+
+ fork_coalesce_helper(editor, outer, inner, fork_join_map, reduce_cycles);
+
+}
+
+/** Opposite of fork split, takes two one-dimensional fork-joins
+ with no control between them,
+ FIXME:
+*/
+pub fn fork_coalesce_helper(
+ editor: &mut FunctionEditor,
+ outer_fork: NodeID,
+ inner_fork: NodeID,
+ fork_join_map: &HashMap<NodeID, NodeID>,
+ reduce_cycles: &HashMap<NodeID, HashSet<NodeID>>,
+) -> bool {
+
+ // Check that all reduces in the outer fork are in *simple* cycles with a unique reduce of the inner fork.
+
+ let outer_join = fork_join_map[&outer_fork];
+ let inner_join = fork_join_map[&inner_fork];
+ let mut pairs: BiMap<NodeID, NodeID> = BiMap::new(); // Outer <-> Inner
+ // FIXME: Iterate all control uses of joins to really collect all reduces
+ // (reduces can be attached to inner control)
+ for outer_reduce in editor.get_users(outer_join).filter(|node| editor.func().nodes[node.idx()].is_reduce()) {
-
+ // check that inner reduce is of the inner join
+ let (outer_control, outer_init, outer_reduct) = editor.func().nodes[outer_reduce.idx()].try_reduce().unwrap();
+
+ let inner_reduce = outer_reduct;
+ let inner_reduce_node = &editor.func().nodes[outer_reduct.idx()];
+
+ let Node::Reduce { control: inner_control, init: inner_init, reduct: inner_reduct } = inner_reduce_node else {return false};
+
+ // FIXME: check this condition better (i.e reduce might not be attached to join)
+ if *inner_control != inner_join {return false};
+ if *inner_init != outer_reduce {return false};
+
+ if pairs.contains_left(&outer_reduce) || pairs.contains_right(&inner_reduce) {
+ return false;
+ } else {
+ pairs.insert(outer_reduce, inner_reduce);
+ }
+ }
+
+ // Check Control between joins and forks
+ // FIXME: use control subgraph.
+ let Some(user) = editor.get_users(outer_fork).filter(|node| editor.func().nodes[node.idx()].is_control()).next() else { return false};
+ if user != inner_fork {
+ return false;
+ }
+
+ let Some(user) = editor.get_users(inner_join).filter(|node| editor.func().nodes[node.idx()].is_control()).next() else { return false};
+ if user != outer_join {
+ return false;
+ }
+
+ // Increment inner TIDs
+ // Add outers dimension to front of inner fork.
+ // Fuse reductions
+ // - Initializer becomes outer initializer
+ // -
+ // Replace uses of outer fork w/ inner fork.
+ // Replace uses of outer join w/ inner join.
+ // Delete outer fork-join
+
+ let inner_tids: Vec<NodeID> = editor.get_users(inner_fork).filter(|node| editor.func().nodes[node.idx()].is_thread_id()).collect();
+
+ let (outer_pred, outer_dims) = editor.func().nodes[outer_fork.idx()].try_fork().unwrap();
+ let (_, inner_dims) = editor.func().nodes[inner_fork.idx()].try_fork().unwrap();
+ let num_outer_dims = outer_dims.len();
+ let mut new_factors = outer_dims.to_vec();
+
+ // FIXME: Might need to be added the other way.
+ new_factors.append(&mut inner_dims.to_vec());
+
+ for tid in inner_tids {
+ let (fork, dim) = editor.func().nodes[tid.idx()].try_thread_id().unwrap();
+ let new_tid = Node::ThreadID { control: fork, dimension: dim + num_outer_dims};
+
+ editor.edit(|mut edit| {
+ let new_tid = edit.add_node(new_tid);
+ let edit = edit.replace_all_uses(tid, new_tid)?;
+ Ok(edit)
+ });
+ }
+
+ // Fuse Reductions
+ for (outer_reduce, inner_reduce) in pairs {
+ let (outer_control, outer_init, outer_reduct) = editor.func().nodes[outer_reduce.idx()].try_reduce().unwrap();
+ let (inner_control, inner_init, inner_reduct) = editor.func().nodes[inner_reduce.idx()].try_reduce().unwrap();
+ editor.edit(|mut edit| {
+ // Set inner init to outer init.
+ edit = edit.replace_all_uses_where(inner_init, outer_init, |usee| *usee == inner_reduce)?;
+ edit = edit.replace_all_uses(outer_reduce, inner_reduce)?;
+ edit = edit.delete_node(outer_reduce)?;
+
+ Ok(edit)
+ });
+ }
+
+ editor.edit(
+ |mut edit| {
+ let new_fork = Node::Fork {control: outer_pred, factors: new_factors.into()};
+ let new_fork = edit.add_node(new_fork);
+
+ edit = edit.replace_all_uses(inner_fork, new_fork)?;
+ edit = edit.replace_all_uses(outer_fork, new_fork)?;
+ edit = edit.replace_all_uses(outer_join, inner_join)?;
+ edit = edit.delete_node(outer_join)?;
+ edit = edit.delete_node(inner_fork)?;
+ edit = edit.delete_node(outer_fork)?;
+
+ Ok(edit)
+ }
+ );
+
+ true
- (new_fork, new_join)
}
\ No newline at end of file
diff --git a/hercules_opt/src/forkify.rs b/hercules_opt/src/forkify.rs
index 55acb725..c5aba648 100644
--- a/hercules_opt/src/forkify.rs
+++ b/hercules_opt/src/forkify.rs
@@ -252,13 +252,10 @@ pub fn forkify_loop(
return false
}
- // Check if all loop PHIs are the same type.
- if !all_same_variant(reductionable_phis.iter()) {
- return false
- }
// Analyze the control that is inside the loop:
- // FOR NOW: Assume basic structure where loop header is region, unconditionally goes to if, and then branches to continue or exit projections.
+
+ // Assume while loops, not do while loops.
// 1) If there is any control between header and loop condition, exit.
let header_control_users: Vec<_> = editor.get_users(l.header)
@@ -278,77 +275,28 @@ pub fn forkify_loop(
let mut fork_id = NodeID::new(0);
let mut thread_id_id = NodeID::new(0);
- let make_n_dims = if reductionable_phis.is_empty() {false} else {reductionable_phis.iter()
- .all(|phi| matches!(phi, LoopPHI::NDimensional { phi_node, reduction_node }))};
-
- // Either every phi is NDimensionalable, or none of them are. Handle these cases separately.
let function = editor.func();
-
- if make_n_dims {
- // To add to an existing inner fork + join pair:
- // - We need to make a new reduce for each NDimensional reductionable PHI.
- // - The reduce is a combination of the reduce it is in a cycle with, and the reductionable PHI.
- // - We need to update the fork bounds to add an outer dimension that is this loops bounds
- // - We need to create a new threadID (this is easy actually, its the same as the non-fused case. )
- // If there is no inner fork / join, fall back to normal.
- let Some(LoopPHI::NDimensional { phi_node, reduction_node }) = reductionable_phis.first() else {return false};
-
- let (inner_join, init, reduct) = function.nodes[reduction_node.idx()].try_reduce().unwrap();
-
- let inner_fork = function.nodes[inner_join.idx()].try_join().unwrap();
-
- if loop_body_last != inner_join {
- return false;
- }
+ // FIXME (@xrouth), handle control in loop body.
+ editor.edit(
+ |mut edit| {
+ let fork = Node::Fork { control: loop_pred, factors: Box::new([bound_dc_id])};
+ fork_id = edit.add_node(fork);
+
+ let join = Node::Join {
+ control: if loop_continue_projection == loop_body_last {
+ fork_id
+ } else {
+ loop_body_last
+ },
+ };
- let Some(loop_body_first) = editor.get_users(loop_continue_projection).next() else {return false};
+ join_id = edit.add_node(join);
- if loop_body_first != inner_fork {
- return false;
+ Ok(edit)
}
-
- let (_, fork_dimensions) = function.nodes[inner_fork.idx()].try_fork().unwrap();
-
- let mut new_factors = vec![bound_dc_id];
- new_factors.append(&mut fork_dimensions.to_vec()); // FIXME: Might need to be added the other way.
- // '0' is innermost dimension.
- fork_id = inner_fork;
- join_id = inner_join;
-
- // I don't actually think you have to convert the ThreadIDs
- editor.edit(
- |mut edit| {
- let new_fork = Node::Fork {control: loop_pred, factors: new_factors.into()};
-
- fork_id = edit.add_node(new_fork);
- edit = edit.replace_all_uses(inner_fork, fork_id)?;
- edit = edit.delete_node(inner_fork)?;
-
- Ok(edit)
- }
- );
- } else {
- // FIXME (@xrouth), handle control in loop body.
- editor.edit(
- |mut edit| {
- let fork = Node::Fork { control: loop_pred, factors: Box::new([bound_dc_id])};
- fork_id = edit.add_node(fork);
-
- let join = Node::Join {
- control: if loop_continue_projection == loop_body_last {
- fork_id
- } else {
- loop_body_last
- },
- };
-
- join_id = edit.add_node(join);
-
- Ok(edit)
- }
- );
- }
+ );
+
let function = editor.func();
@@ -423,91 +371,53 @@ pub fn forkify_loop(
}
);
- if make_n_dims {
- for reduction_phi in reductionable_phis {
- let LoopPHI::NDimensional { phi_node, reduction_node } = reduction_phi else {
- panic!();
- };
-
- // Delete the phi, replace uses of it with the reduction
- // FIXME: Wtf happens with the initializer? What is the condition here ig.
+ for reduction_phi in reductionable_phis {
+ let reduction_phi = reduction_phi.get_phi();
- let function = editor.func();
- let (control, init, reduct) = function.nodes[reduction_node.idx()].try_reduce().unwrap();
+ let function = editor.func();
- let phi_init = *zip(
- editor.get_uses(l.header),
- function.nodes[phi_node.idx()]
- .try_phi()
- .unwrap()
- .1
- .iter(),
+ let init = *zip(
+ editor.get_uses(l.header),
+ function.nodes[reduction_phi.idx()]
+ .try_phi()
+ .unwrap()
+ .1
+ .iter(),
)
.filter(|(c, _)| *c == loop_pred)
.next()
.unwrap()
.1;
-
- editor.edit(
- |mut edit| {
-
- // Set the reduction node to be the same, just move its initailizer to the PHI's intiailizer.
- let reduce_node = Node::Reduce { control, init: phi_init, reduct };
- let reduce_id = edit.add_node(reduce_node);
- edit = edit.replace_all_uses(reduction_node, reduce_id)?;
- edit = edit.replace_all_uses(phi_node, reduce_id)?;
- edit.delete_node(phi_node)
- }
- );
- }
- } else {
- for reduction_phi in reductionable_phis {
- let reduction_phi = reduction_phi.get_phi();
-
- let function = editor.func();
-
- let init = *zip(
- editor.get_uses(l.header),
- function.nodes[reduction_phi.idx()]
- .try_phi()
- .unwrap()
- .1
- .iter(),
- )
- .filter(|(c, _)| *c == loop_pred)
- .next()
- .unwrap()
- .1;
-
- // Loop back edge input to phi is the reduction update expression.
- let update = *zip(
- editor.get_uses(l.header),
- function.nodes[reduction_phi.idx()]
- .try_phi()
- .unwrap()
- .1
- .iter(),
- )
- .filter(|(c, _)| *c == loop_body_last)
- .next()
+
+ // Loop back edge input to phi is the reduction update expression.
+ let update = *zip(
+ editor.get_uses(l.header),
+ function.nodes[reduction_phi.idx()]
+ .try_phi()
.unwrap()
- .1;
+ .1
+ .iter(),
+ )
+ .filter(|(c, _)| *c == loop_body_last)
+ .next()
+ .unwrap()
+ .1;
- editor.edit(
- |mut edit| {
- let reduce = Node::Reduce {
- control: join_id,
- init,
- reduct: update,
- };
- let reduce_id = edit.add_node(reduce);
-
- edit = edit.replace_all_uses(reduction_phi, reduce_id)?;
- edit.delete_node(reduction_phi)
- }
- );
- }
+ editor.edit(
+ |mut edit| {
+ let reduce = Node::Reduce {
+ control: join_id,
+ init,
+ reduct: update,
+ };
+ let reduce_id = edit.add_node(reduce);
+
+ edit = edit.replace_all_uses(reduction_phi, reduce_id)?;
+ edit.delete_node(reduction_phi)
+ }
+ );
}
+
// Replace all uses of the loop header with the fork
editor.edit(
@@ -549,10 +459,6 @@ nest! {
#[derive(Debug)]
pub enum LoopPHI {
Reductionable(NodeID),
- NDimensional {
- phi_node: NodeID,
- reduction_node: NodeID
- },
LoopDependant(NodeID),
}
}
@@ -561,7 +467,6 @@ impl LoopPHI {
pub fn get_phi(&self) -> NodeID {
match self {
LoopPHI::Reductionable(node_id) => *node_id,
- LoopPHI::NDimensional { phi_node, reduction_node } => *phi_node,
LoopPHI::LoopDependant(node_id) => *node_id,
}
}
@@ -585,7 +490,6 @@ pub fn analyze_phis<'a>(editor: &'a FunctionEditor, phis: &'a [NodeID])
phis.into_iter().map(move |phi| {
// do WFS
let mut other_phi_on_path: DenseNodeMap<bool> = vec![false; function.nodes.len()];
- // let mut reduce_on_path: DenseNodeMap<Option<NodeID>> = vec![None; function.nodes.len()];
let mut bag_of_control_nodes: Vec<NodeID> = vec![*phi];
let mut visited: DenseNodeMap<bool> = vec![false; function.nodes.len()];
@@ -617,19 +521,7 @@ pub fn analyze_phis<'a>(editor: &'a FunctionEditor, phis: &'a [NodeID])
}
if other_phi_on_path[phi.idx()] == false {
-
- // Check if the PHIs are in cycles with redutions via pattern matching
- let (_, data) = function.nodes[phi.idx()].try_phi().unwrap();
- for data_id in data {
- if let Some((control, init, _)) = function.nodes[data_id.idx()].try_reduce() {
- if init == *phi {
- return LoopPHI::NDimensional {phi_node: phi.clone(), reduction_node: data_id.clone()};
- }
- } else {
- continue;
- }
- }
- return LoopPHI::Reductionable(*phi)
+ LoopPHI::Reductionable(*phi)
} else {
LoopPHI::LoopDependant(*phi)
}
diff --git a/hercules_opt/src/ivar.rs b/hercules_opt/src/ivar.rs
index a734da38..21290dea 100644
--- a/hercules_opt/src/ivar.rs
+++ b/hercules_opt/src/ivar.rs
@@ -138,6 +138,15 @@ pub fn loop_data_location(editor: &FunctionEditor, node: NodeID, all_loop_nodes:
}
}
+ // Don't go through reduces that are controlled by something in the loop
+ if node_data.is_reduce() {
+ let control = node_data.try_reduce().unwrap().0;
+ return match all_loop_nodes[control.idx()] {
+ true => DataUseLoopLocation::Inside,
+ false => DataUseLoopLocation::Outside // FIXME: Is this the correct condition?
+ }
+ }
+
let mut data_location = DataUseLoopLocation::Inside;
diff --git a/hercules_opt/src/loop_fixification.rs b/hercules_opt/src/loop_fixification.rs
index 183b7bc4..bab302b4 100644
--- a/hercules_opt/src/loop_fixification.rs
+++ b/hercules_opt/src/loop_fixification.rs
@@ -302,11 +302,18 @@ pub fn fixify_loop(
}
// Stop on PHIs.
if node_data.is_phi() {
- // Need to maybe not stop on PHIs, but only stop on some of their uses.
+ // Need to maybe not stop on PHIs, but only stop on some of their incoming edges,
+ // depending
let control = node_data.try_phi().unwrap().0;
return l.control[control.idx()];
}
+ // Stop on Reduces.
+ if node_data.is_reduce() {
+ let control = node_data.try_reduce().unwrap().0;
+ return l.control[control.idx()];
+ }
+
false
}).collect();
@@ -338,6 +345,11 @@ pub fn fixify_loop(
})
}).collect();
+ // Change loop bounds
+ editor.edit(|edit|
+ edit.replace_all_uses_where(iv_expression, base_iv.node, |usee| *usee == condition_node)
+ );
+
let Some(transform_infos) = transform_infos else {
return false;
};
@@ -348,11 +360,6 @@ pub fn fixify_loop(
let transform_info = &transform_infos[0];
- // Change loop bounds
- editor.edit(|edit|
- edit.replace_all_uses_where(iv_expression, base_iv.node, |usee| *usee == condition_node)
- );
-
editor.edit(|mut edit|
{
edit.replace_all_uses_where(transform_info.data, transform_info.phi, |usee| transform_info.external_uses.contains(usee))
diff --git a/hercules_opt/src/pass.rs b/hercules_opt/src/pass.rs
index 58e36a71..d3945300 100644
--- a/hercules_opt/src/pass.rs
+++ b/hercules_opt/src/pass.rs
@@ -48,6 +48,7 @@ pub enum Pass {
// Parameterized over where to serialize module to.
Serialize(String),
ForkFission,
+ ForkCoalesce,
LoopCanonicalization,
}
@@ -1008,6 +1009,51 @@ impl PassManager {
}
self.clear_analyses();
},
+ Pass::ForkCoalesce => {
+ self.make_def_uses();
+ self.make_loops();
+ self.make_control_subgraphs();
+ self.make_fork_join_maps();
+ self.make_typing();
+ self.make_reduce_cycles();
+ self.make_doms();
+ let def_uses = self.def_uses.as_ref().unwrap();
+ let loops = self.loops.as_ref().unwrap();
+ let fork_join_maps = self.fork_join_maps.as_ref().unwrap();
+ let types = self.typing.as_ref().unwrap();
+ let reduce_cycles = self.reduce_cycles.as_ref().unwrap();
+
+ for idx in 0..self.module.functions.len() {
+ let constants_ref =
+ RefCell::new(std::mem::take(&mut self.module.constants));
+ let dynamic_constants_ref =
+ RefCell::new(std::mem::take(&mut self.module.dynamic_constants));
+ let types_ref = RefCell::new(std::mem::take(&mut self.module.types));
+
+ let control_subgraph = &self.control_subgraphs.as_ref().unwrap()[idx];
+ let mut editor = FunctionEditor::new(
+ &mut self.module.functions[idx],
+ &constants_ref,
+ &dynamic_constants_ref,
+ &types_ref,
+ &def_uses[idx],
+ );
+
+ fork_coalesce(
+ &mut editor,
+ &loops[idx],
+ &fork_join_maps[idx],
+ &reduce_cycles[idx],
+ );
+
+ self.module.constants = constants_ref.take();
+ self.module.dynamic_constants = dynamic_constants_ref.take();
+ self.module.types = types_ref.take();
+
+ self.module.functions[idx].delete_gravestones();
+ }
+ self.clear_analyses();
+ },
Pass::LoopCanonicalization => {
self.make_def_uses();
self.make_loops();
diff --git a/hercules_samples/matmul/src/main.rs b/hercules_samples/matmul/src/main.rs
index 93d007c7..94f06029 100644
--- a/hercules_samples/matmul/src/main.rs
+++ b/hercules_samples/matmul/src/main.rs
@@ -12,11 +12,13 @@ juno_build::juno!("matmul");
fn main() {
async_std::task::block_on(async {
- const I: usize = 256;
- const J: usize = 64;
- const K: usize = 128;
- let a: Box<[i32]> = (0..I * J).map(|_| random::<i32>() % 100).collect();
- let b: Box<[i32]> = (0..J * K).map(|_| random::<i32>() % 100).collect();
+ const I: usize = 2;
+ const J: usize = 2;
+ const K: usize = 2;
+ let a: Box<[i32]> = Box::new([1, 2, 3, 4]);
+ // (0..I * J).map(|_| random::<i32>() % 100).collect();
+ let b: Box<[i32]> = Box::new([5, 6, 7, 8]);
+ // (0..J * K).map(|_| random::<i32>() % 100).collect();
let mut a_bytes: Box<[u8]> = Box::new([0; I * J * 4]);
let mut b_bytes: Box<[u8]> = Box::new([0; J * K * 4]);
unsafe {
diff --git a/hercules_test/hercules_interpreter/src/interpreter.rs b/hercules_test/hercules_interpreter/src/interpreter.rs
index 1a38c4d6..acbb05e8 100644
--- a/hercules_test/hercules_interpreter/src/interpreter.rs
+++ b/hercules_test/hercules_interpreter/src/interpreter.rs
@@ -220,8 +220,8 @@ impl<'a> FunctionExecutionState<'a> {
})
.collect();
- for reduction in reduces {
- self.handle_reduction(&token, reduction);
+ for reduction in &reduces {
+ self.handle_reduction(&token, *reduction);
}
let thread_values = self.get_thread_factors(&token, join);
@@ -233,7 +233,7 @@ impl<'a> FunctionExecutionState<'a> {
if *self
.join_counters
- .get(&(thread_values, join))
+ .get(&(thread_values.clone(), join))
.expect("PANIC: join counter not initialized")
== 0
{
@@ -265,7 +265,7 @@ impl<'a> FunctionExecutionState<'a> {
let len = if nested_forks.is_empty() {
fork_levels - 1
} else {
- fork_levels - self.get_function().nodes[nested_forks.last().unwrap().idx()].try_fork().unwrap().1.len()
+ fork_levels - (self.get_function().nodes[nested_forks.first().unwrap().idx()].try_fork().unwrap().1.len())
};
let mut thread_values = token.thread_indicies.clone();
@@ -273,7 +273,7 @@ impl<'a> FunctionExecutionState<'a> {
thread_values
}
- pub fn intialize_reduction(&mut self, token_at_fork: &ControlToken, reduce: NodeID) {
+ pub fn initialize_reduction(&mut self, token_at_fork: &ControlToken, reduce: NodeID) {
let token = token_at_fork;
@@ -284,10 +284,12 @@ impl<'a> FunctionExecutionState<'a> {
let thread_values = self.get_thread_factors(token, *control);
let init = self.handle_data(&token, *init);
+
+ if VERBOSE {
+ println!("reduction {:?} initailized to: {:?} on thread {:?}", reduce, init, thread_values);
+ }
- self.reduce_values
- .entry((thread_values.clone(), reduce))
- .or_insert(init);
+ self.reduce_values.insert((thread_values.clone(), reduce), init);
}
// Drive the reduction, this will be invoked for each control token.
@@ -322,6 +324,9 @@ impl<'a> FunctionExecutionState<'a> {
.len();
// dimension might need to instead be dimensions - dimension
let v = token.thread_indicies[nesting_level + dimension - 1]; // Might have to -1?
+ if VERBOSE {
+ println!("node: {:?} gives tid: {:?} for thread: {:?}, dim: {:?}", node, v, token.thread_indicies, dimension);
+ }
InterpreterVal::DynamicConstant((v).into())
}
// If we read from a reduction that is the same depth as this thread, we need to write back to it before anyone else reads from it.
@@ -422,7 +427,12 @@ impl<'a> FunctionExecutionState<'a> {
Node::Read { collect, indices } => {
let collection = self.handle_data(token, *collect);
- self.handle_read(token, collection, indices)
+ let result = self.handle_read(token, collection.clone(), indices);
+
+ if VERBOSE {
+ println!("{:?} read value : {:?} from {:?}, {:?} at index {:?}", node, result, collect, collection, indices);
+ }
+ result
}
Node::Write {
collect,
@@ -504,6 +514,10 @@ impl<'a> FunctionExecutionState<'a> {
.map(|idx| self.handle_data(token, *idx).as_usize())
.collect();
+ if VERBOSE{
+ println!("read at rt indicies: {:?}", array_indices);
+ }
+
// TODO: Implemenet . try_array() and other try_conversions on the InterpreterVal type
if let InterpreterVal::Array(type_id, vals) = collection {
// TODO: Make this its own funciton to reuse w/ array_size
@@ -668,7 +682,7 @@ impl<'a> FunctionExecutionState<'a> {
for reduction in reduces {
// TODO: Is this the correct reduction?
- self.intialize_reduction(&ctrl_token, reduction);
+ self.initialize_reduction(&ctrl_token, reduction);
}
diff --git a/hercules_test/hercules_tests/tests/fork_transform_tests.rs b/hercules_test/hercules_tests/tests/fork_transform_tests.rs
index bf75609c..6789be26 100644
--- a/hercules_test/hercules_tests/tests/fork_transform_tests.rs
+++ b/hercules_test/hercules_tests/tests/fork_transform_tests.rs
@@ -83,10 +83,10 @@ fn fission_tricky() {
let passes = vec![
Pass::Verify,
- Pass::Xdot(false),
+ Pass::Xdot(true),
Pass::ForkFission,
Pass::DCE,
- Pass::Xdot(false),
+ Pass::Xdot(true),
Pass::Verify,
];
diff --git a/hercules_test/hercules_tests/tests/loop_tests.rs b/hercules_test/hercules_tests/tests/loop_tests.rs
index 449bb5df..6d67d67e 100644
--- a/hercules_test/hercules_tests/tests/loop_tests.rs
+++ b/hercules_test/hercules_tests/tests/loop_tests.rs
@@ -16,7 +16,6 @@ fn loop_trip_count() {
let result_1 = interp_module!(module, dyn_consts, 2);
println!("result: {:?}", result_1);
-
}
#[test]
@@ -139,10 +138,8 @@ fn matmul_pipeline() {
let mut pm = hercules_opt::pass::PassManager::new(module.clone());
let passes = vec![
- Pass::Xdot(true),
Pass::LoopCanonicalization,
Pass::Verify,
- Pass::Xdot(true),
];
for pass in passes {
@@ -171,6 +168,8 @@ fn matmul_pipeline() {
let module = pm.get_module();
let result_2 = interp_module!(module, dyn_consts, m1.clone(), m2.clone());
+ println!("2d: {:?}", result_2);
+
assert_eq!(result_1, result_2);
// -------
@@ -180,6 +179,10 @@ fn matmul_pipeline() {
Pass::ForkGuardElim,
Pass::DCE,
Pass::Verify,
+ Pass::LoopCanonicalization,
+ Pass::Forkify,
+ Pass::DCE,
+ Pass::Xdot(true),
];
for pass in passes {
@@ -189,5 +192,47 @@ fn matmul_pipeline() {
let module = pm.get_module();
let result_2 = interp_module!(module, dyn_consts, m1.clone(), m2.clone());
+
assert_eq!(result_1, result_2);
+
+ // -------
+ let mut pm = hercules_opt::pass::PassManager::new(module.clone());
+
+ let passes = vec![
+ Pass::ForkCoalesce,
+ Pass::DCE,
+ Pass::Xdot(true),
+ ];
+
+ for pass in passes {
+ pm.add_pass(pass);
+ }
+ pm.run_passes();
+
+ let module = pm.get_module();
+ let result_2 = interp_module!(module, dyn_consts, m1.clone(), m2.clone());
+ assert_eq!(result_1, result_2);
+
+ // -------
+ let mut pm = hercules_opt::pass::PassManager::new(module.clone());
+
+ let passes = vec![
+ Pass::ForkCoalesce,
+ Pass::DCE,
+ Pass::ForkGuardElim,
+ Pass::DCE,
+ Pass::Xdot(true),
+ ];
+
+ for pass in passes {
+ pm.add_pass(pass);
+ }
+ pm.run_passes();
+
+ let module = pm.get_module();
+ let result_2 = interp_module!(module, dyn_consts, m1.clone(), m2.clone());
+ assert_eq!(result_1, result_2);
+
+ println!("final: {:?}", result_2);
+
}
\ No newline at end of file
diff --git a/juno_frontend/src/lib.rs b/juno_frontend/src/lib.rs
index 89fbc98e..50792f52 100644
--- a/juno_frontend/src/lib.rs
+++ b/juno_frontend/src/lib.rs
@@ -153,19 +153,10 @@ pub fn compile_ir(
add_verified_pass!(pm, verify, GVN);
add_verified_pass!(pm, verify, PhiElim);
add_pass!(pm, verify, DCE);
- if x_dot {
- pm.add_pass(hercules_opt::pass::Pass::Xdot(true));
- }
add_pass!(pm, verify, Inline);
- if x_dot {
- pm.add_pass(hercules_opt::pass::Pass::Xdot(true));
- }
// Inlining may make some functions uncalled, so run this pass.
// In general, this should always be run after inlining.
add_pass!(pm, verify, DeleteUncalled);
- if x_dot {
- pm.add_pass(hercules_opt::pass::Pass::Xdot(true));
- }
// Run SROA pretty early (though after inlining which can make SROA more effective) so that
// CCP, GVN, etc. can work on the result of SROA
add_pass!(pm, verify, InterproceduralSROA);
@@ -174,21 +165,29 @@ pub fn compile_ir(
// simplified
add_verified_pass!(pm, verify, PhiElim);
add_pass!(pm, verify, DCE);
- if x_dot {
- pm.add_pass(hercules_opt::pass::Pass::Xdot(true));
- }
+
add_pass!(pm, verify, CCP);
add_pass!(pm, verify, DCE);
add_pass!(pm, verify, GVN);
add_pass!(pm, verify, DCE);
+
+ pm.add_pass(hercules_opt::pass::Pass::Serialize(module_name.clone() + ".module"));
if x_dot {
pm.add_pass(hercules_opt::pass::Pass::Xdot(true));
}
- pm.add_pass(hercules_opt::pass::Pass::Serialize(module_name.clone() + ".module"));
- add_pass!(pm, verify, Forkify);
+ add_verified_pass!(pm, verify, CCP);
+ add_verified_pass!(pm, verify, DCE);
+ add_verified_pass!(pm, verify, GVN);
+ add_verified_pass!(pm, verify, LoopCanonicalization);
+ add_verified_pass!(pm, verify, Forkify);
+ add_verified_pass!(pm, verify, DCE);
+ add_verified_pass!(pm, verify, ForkGuardElim);
+ add_verified_pass!(pm, verify, LoopCanonicalization);
+ add_verified_pass!(pm, verify, Forkify);
if x_dot {
pm.add_pass(hercules_opt::pass::Pass::Xdot(true));
}
+
//add_pass!(pm, verify, ForkGuardElim);
add_verified_pass!(pm, verify, DCE);
add_pass!(pm, verify, Outline);
diff --git a/juno_samples/matmul/src/main.rs b/juno_samples/matmul/src/main.rs
index 865beaf5..8d4194bd 100644
--- a/juno_samples/matmul/src/main.rs
+++ b/juno_samples/matmul/src/main.rs
@@ -12,11 +12,13 @@ juno_build::juno!("matmul");
fn main() {
async_std::task::block_on(async {
- const I: usize = 256;
- const J: usize = 64;
- const K: usize = 128;
- let a: Box<[i32]> = (0..I * J).map(|_| random::<i32>() % 100).collect();
- let b: Box<[i32]> = (0..J * K).map(|_| random::<i32>() % 100).collect();
+ const I: usize = 2;
+ const J: usize = 2;
+ const K: usize = 2;
+ let a: Box<[i32]> = Box::new([1, 2, 3, 4]);
+ // (0..I * J).map(|_| random::<i32>() % 100).collect();
+ let b: Box<[i32]> = Box::new([5, 6, 7, 8]);
+ // (0..J * K).map(|_| random::<i32>() % 100).collect();
let mut a_bytes: Box<[u8]> = Box::new([0; I * J * 4]);
let mut b_bytes: Box<[u8]> = Box::new([0; J * K * 4]);
unsafe {
@@ -48,6 +50,7 @@ fn main() {
}
}
}
+ println!("c: {:?}", c);
assert_eq!(c, correct_c);
});
}
--
GitLab
From 7bde2e3a7d0b1e2741156c85fb7a782b20d0cc8b Mon Sep 17 00:00:00 2001
From: Xavier Routh <xrouth2@illinois.edu>
Date: Thu, 9 Jan 2025 14:32:46 -0500
Subject: [PATCH 25/68] basic guard detection for do-while transform
---
hercules_opt/src/lib.rs | 4 +-
...xification.rs => loop_canonicalization.rs} | 117 +++++++++++++++---
hercules_opt/src/pass.rs | 6 +-
.../tests/fork_transform_tests.rs | 13 +-
.../hercules_tests/tests/forkify_tests.rs | 8 +-
.../hercules_tests/tests/loop_tests.rs | 61 ++++++++-
.../fork_transforms/fork_fission/simple2.hir | 2 +-
.../loop_analysis/do_loop_far_guard.hir | 14 +++
.../loop_analysis/do_loop_immediate_guard.hir | 21 ++++
.../loop_analysis/do_loop_no_guard.hir | 15 +++
10 files changed, 226 insertions(+), 35 deletions(-)
rename hercules_opt/src/{loop_fixification.rs => loop_canonicalization.rs} (79%)
create mode 100644 hercules_test/test_inputs/loop_analysis/do_loop_far_guard.hir
create mode 100644 hercules_test/test_inputs/loop_analysis/do_loop_immediate_guard.hir
create mode 100644 hercules_test/test_inputs/loop_analysis/do_loop_no_guard.hir
diff --git a/hercules_opt/src/lib.rs b/hercules_opt/src/lib.rs
index 930a9b1a..1b0eb166 100644
--- a/hercules_opt/src/lib.rs
+++ b/hercules_opt/src/lib.rs
@@ -21,7 +21,7 @@ pub mod fork_transforms;
pub mod ivar;
pub mod unforkify;
pub mod utils;
-pub mod loop_fixification;
+pub mod loop_canonicalization;
pub use crate::ccp::*;
pub use crate::dce::*;
@@ -42,6 +42,6 @@ pub use crate::schedule::*;
pub use crate::sroa::*;
pub use crate::fork_transforms::*;
pub use crate::ivar::*;
-pub use crate::loop_fixification::*;
+pub use crate::loop_canonicalization::*;
pub use crate::unforkify::*;
pub use crate::utils::*;
diff --git a/hercules_opt/src/loop_fixification.rs b/hercules_opt/src/loop_canonicalization.rs
similarity index 79%
rename from hercules_opt/src/loop_fixification.rs
rename to hercules_opt/src/loop_canonicalization.rs
index bab302b4..0d5b1066 100644
--- a/hercules_opt/src/loop_fixification.rs
+++ b/hercules_opt/src/loop_canonicalization.rs
@@ -38,7 +38,7 @@ use crate::LoopVariance;
use self::hercules_ir::LoopTree;
-pub fn loop_fixification(
+pub fn loop_canonicalization(
editor: &mut FunctionEditor,
control_subgraph: &Subgraph,
fork_join_map: &HashMap<NodeID, NodeID>,
@@ -61,20 +61,94 @@ pub fn loop_fixification(
loop_exits.insert(l.0, loop_exit);
}
-
for l in natural_loops {
let natural_loop = &Loop { header: l.0, control: l.1.clone()};
- convert_to_while_loop(editor, natural_loop, loop_exits.get(&l.0).copied());
- fixify_loop(editor, loop_exits.get(&l.0).copied(), fork_join_map, natural_loop);
+ convert_to_while_loop(editor, natural_loop, loop_exits.get(&l.0).copied(), false);
+ canonicalize_loop(editor, loop_exits.get(&l.0).copied(), fork_join_map, natural_loop);
return;
}
}
-//
-pub enum ConversionResult {
- Failure,
- Success,
+// Returns false if a guard can't be added, true if a guard is succesffuly added.
+pub fn add_guard() -> bool {
+ false
+}
+
+// True if a guard exists already, false otehrwise
+pub fn guard_exists(
+ editor: &mut FunctionEditor,
+ natural_loop: &Loop,
+ if_node: NodeID,
+) -> bool {
+ // Given loop condition (iv_phi ? bound_expr)
+
+ // Q: What if iv_phi isn't a PHI, but instead a more complex expression.
+ // A: Idk!
+
+ // Q: What if idx_phi.init changes from when the loop is entered vs where the guard is?
+ // A: Guards have to be immediate, later we can look through control dominators blah blah.
+
+ // Search for a condition (idx_phi.init ? bound_expr) immediately before the loop is entered
+ // (header predecessor)
+ let Node::If { control: pred, cond: loop_condition } =
+ editor.func().nodes[if_node.idx()] else {return false};
+
+ // Rely on GVN that the initializers will be the same exact node.
+ let mut header_preds = editor.get_uses(natural_loop.header)
+ .filter(|pred| !natural_loop.control[pred.idx()]);
+
+ let Some(loop_pred) = header_preds.next() else {return false};
+ if header_preds.next().is_some() {return false}; // If there is more than one header predecessor.
+
+ let Node::Projection { control: guard_if_node, ref selection } =
+ editor.func().nodes[loop_pred.idx()] else {return false};
+
+ let Node::If { control: guard_if_pred, cond: guard_cond } =
+ editor.func().nodes[guard_if_node.idx()] else {return false};
+
+ let Node::Binary { left: guard_cond_left, right: guard_cond_right, op: guard_cond_op } =
+ editor.func().nodes[guard_cond.idx()] else {return false};
+
+ // Check that the side of the exit condition is the same, or the initializer is the same.
+
+ // Replace phis in the loop latch w/ their initializers.
+ let Node::Binary {left: latch_left, right: latch_right, op: latch_op } =
+ editor.func().nodes[loop_condition.idx()] else {return false};
+
+ let latch_left = if let Node::Phi { control: left_control, data } = &editor.func().nodes[latch_left.idx()] {
+ if *left_control == natural_loop.header {
+ let Node::Region { preds } = &editor.func().nodes[natural_loop.header.idx()] else {panic!()};
+ let init_idx = preds.iter().position(|node| *node == loop_pred ).unwrap();
+
+ data[init_idx]
+ } else {
+ latch_left
+ }
+ } else {
+ latch_left
+ };
+
+ let latch_right = if let Node::Phi { control: right_control, data } = &editor.func().nodes[latch_right.idx()] {
+ if *right_control == natural_loop.header {
+ let Node::Region { preds } = &editor.func().nodes[natural_loop.header.idx()] else {panic!()};
+ let init_idx = preds.iter().position(|node| *node == loop_pred ).unwrap();
+
+ data[init_idx]
+ } else {
+ latch_right
+ }
+ } else {
+ latch_right
+ };
+
+ // FIXME: More comprehensive condition equivalance.
+ // Check condition equivalence:
+ if latch_op == guard_cond_op && guard_cond_left == latch_left && guard_cond_right == latch_right {
+ return true;
+ } else {
+ return false;
+ }
}
/** Attempts to converts a simple natural loop to a while loop
@@ -86,21 +160,27 @@ pub fn convert_to_while_loop(
editor: &mut FunctionEditor,
natural_loop: &Loop,
loop_exit: Option<LoopExit>,
-
-) -> ConversionResult {
+ add_guard_flag: bool,
+) -> bool {
// FIXME: Check that Loop is simple.
+
+ let Some(LoopExit::Conditional { if_node, condition_node: _ }) = loop_exit.clone() else {return false};
+
// FIXME: Check whether the loop is guaranteed to be entered.
// i.e add a guard if needed.
-
- let Some(LoopExit::Conditional { if_node, condition_node: _ }) = loop_exit.clone() else {return ConversionResult::Failure};
+ if guard_exists(editor, natural_loop, if_node) == false {
+ if add_guard() == false { // If we failed to add a guard, don't convert to while loop.
+ return false;
+ }
+ }
// Get the control in between the header and before the condition,
// If the header -> if, then there is no control before the condition, so it's a while loop.
if editor.get_uses(if_node).contains(&natural_loop.header) {
- return ConversionResult::Success
+ return true
}
let loop_before_if_first = editor.get_users(natural_loop.header)
@@ -110,7 +190,7 @@ pub fn convert_to_while_loop(
let loop_before_if_last = editor.get_uses(if_node).next().unwrap();
- assert_ne!(loop_before_if_first, loop_before_if_last);
+ // assert_ne!(loop_before_if_first, loop_before_if_last);
let loop_exit_projection = editor.get_users(if_node)
.filter(|id| !natural_loop.control[id.idx()])
@@ -129,7 +209,7 @@ pub fn convert_to_while_loop(
.unwrap();
editor.edit(|mut edit| {
- // have fun understanding this!
+ // Have fun understanding this!
edit = edit.replace_all_uses(loop_continue_projection, loop_before_if_last)?;
edit = edit.replace_all_uses_where(natural_loop.header, loop_continue_projection, |usee| *usee == loop_before_if_first)?;
edit = edit.replace_all_uses_where(loop_before_if_last, natural_loop.header, |usee| *usee == if_node)?;
@@ -137,13 +217,10 @@ pub fn convert_to_while_loop(
Ok(edit)
});
-
- ConversionResult::Success
+ true
}
-// FIXME: Return whether the loop is already in fixified form or was able to be place in fixifeid form, vs
-// if it didn't get fixified. Blah.
-pub fn fixify_loop(
+pub fn canonicalize_loop(
editor: &mut FunctionEditor,
loop_exit: Option<LoopExit>,
fork_join_map: &HashMap<NodeID, NodeID>,
diff --git a/hercules_opt/src/pass.rs b/hercules_opt/src/pass.rs
index b954b975..1cb7d340 100644
--- a/hercules_opt/src/pass.rs
+++ b/hercules_opt/src/pass.rs
@@ -425,6 +425,7 @@ impl PassManager {
let subgraph = &self.control_subgraphs.as_ref().unwrap()[idx];
let mut editor = FunctionEditor::new(
&mut self.module.functions[idx],
+ FunctionID::new(idx),
&constants_ref,
&dynamic_constants_ref,
&types_ref,
@@ -1010,6 +1011,7 @@ impl PassManager {
let control_subgraph = &self.control_subgraphs.as_ref().unwrap()[idx];
let mut editor = FunctionEditor::new(
&mut self.module.functions[idx],
+ FunctionID::new(idx),
&constants_ref,
&dynamic_constants_ref,
&types_ref,
@@ -1057,6 +1059,7 @@ impl PassManager {
let control_subgraph = &self.control_subgraphs.as_ref().unwrap()[idx];
let mut editor = FunctionEditor::new(
&mut self.module.functions[idx],
+ FunctionID::new(idx),
&constants_ref,
&dynamic_constants_ref,
&types_ref,
@@ -1098,13 +1101,14 @@ impl PassManager {
let control_subgraph = &self.control_subgraphs.as_ref().unwrap()[idx];
let mut editor = FunctionEditor::new(
&mut self.module.functions[idx],
+ FunctionID::new(idx),
&constants_ref,
&dynamic_constants_ref,
&types_ref,
&def_uses[idx],
);
- loop_fixification(
+ loop_canonicalization(
&mut editor,
control_subgraph,
&fork_join_maps[idx],
diff --git a/hercules_test/hercules_tests/tests/fork_transform_tests.rs b/hercules_test/hercules_tests/tests/fork_transform_tests.rs
index 6789be26..934f0518 100644
--- a/hercules_test/hercules_tests/tests/fork_transform_tests.rs
+++ b/hercules_test/hercules_tests/tests/fork_transform_tests.rs
@@ -69,6 +69,7 @@ fn fission_simple2() {
assert_eq!(result_1, result_2)
}
+#[ignore] // Wait
#[test]
fn fission_tricky() {
// This either crashes or gives wrong result depending on the order which reduces are observed in.
@@ -83,10 +84,10 @@ fn fission_tricky() {
let passes = vec![
Pass::Verify,
- Pass::Xdot(true),
+ // Pass::Xdot(true),
Pass::ForkFission,
Pass::DCE,
- Pass::Xdot(true),
+ // Pass::Xdot(true),
Pass::Verify,
];
@@ -101,11 +102,11 @@ fn fission_tricky() {
assert_eq!(result_1, result_2)
}
+#[ignore]
#[test]
fn inner_loop() {
- // This either crashes or gives wrong result depending on the order which reduces are observed in.
let module = parse_file("../test_inputs/fork_transforms/fork_fission/inner_loop.hir");
- let dyn_consts = [10];
+ let dyn_consts = [10, 20];
let params = 2; // TODO: (@xrouth) fix macro to take no params as an option.
let result_1 = interp_module!(module, dyn_consts, 2);
@@ -115,10 +116,10 @@ fn inner_loop() {
let passes = vec![
Pass::Verify,
- Pass::Xdot(false),
+ // Pass::Xdot(true),
Pass::ForkFission,
Pass::DCE,
- Pass::Xdot(false),
+ // Pass::Xdot(false),
Pass::Verify,
];
diff --git a/hercules_test/hercules_tests/tests/forkify_tests.rs b/hercules_test/hercules_tests/tests/forkify_tests.rs
index 82368fbd..40859089 100644
--- a/hercules_test/hercules_tests/tests/forkify_tests.rs
+++ b/hercules_test/hercules_tests/tests/forkify_tests.rs
@@ -169,7 +169,7 @@ fn nested_loop2() {
Pass::Forkify,
Pass::DCE,
Pass::Verify,
- Pass::Xdot(true),
+ // Pass::Xdot(true),
];
for pass in passes {
@@ -400,7 +400,7 @@ fn nested_tid_sum() {
Pass::Forkify,
Pass::DCE,
Pass::Verify,
- Pass::Xdot(true),
+ // Pass::Xdot(true),
];
for pass in passes {
@@ -427,7 +427,7 @@ fn nested_tid_sum_2() {
let mut pm = hercules_opt::pass::PassManager::new(module.clone());
let passes = vec![
- Pass::Xdot(true),
+ // Pass::Xdot(true),
Pass::Verify,
Pass::Forkify,
Pass::DCE,
@@ -450,7 +450,7 @@ fn nested_tid_sum_2() {
Pass::Forkify,
Pass::DCE,
Pass::Verify,
- Pass::Xdot(true),
+ // Pass::Xdot(true),
];
for pass in passes {
diff --git a/hercules_test/hercules_tests/tests/loop_tests.rs b/hercules_test/hercules_tests/tests/loop_tests.rs
index 6d67d67e..00252f06 100644
--- a/hercules_test/hercules_tests/tests/loop_tests.rs
+++ b/hercules_test/hercules_tests/tests/loop_tests.rs
@@ -8,6 +8,9 @@ use hercules_ir::ID;
extern crate rand;
use rand::Rng;
+// Tests canonicalization
+
+#[ignore]
#[test]
fn loop_trip_count() {
let module = parse_file("../test_inputs/loop_analysis/loop_trip_count.hir");
@@ -18,6 +21,61 @@ fn loop_trip_count() {
println!("result: {:?}", result_1);
}
+// Tests a do while loop that only iterates once,
+// canonicalization *should not* transform this to a while loop, as there is no
+// guard that replicates the loop condition.
+#[test]
+fn do_loop_not_continued() {
+ let len = 1;
+ let dyn_consts = [len];
+ let params = vec![1, 2, 3, 4, 5];
+
+ let module = parse_file("../test_inputs/loop_analysis/alternate_bounds_use_after_loop.hir");
+ let result_1 = interp_module!(module, dyn_consts, params);
+
+ println!("result: {:?}", result_1);
+}
+
+// Tests a do while loop that is guarded, so should be canonicalized
+// It also has
+#[test]
+fn do_loop_complex_immediate_guarded() {
+ let len = 1;
+ let dyn_consts = [len];
+
+ let module = parse_file("../test_inputs/loop_analysis/do_loop_immediate_guard.hir");
+ let result_1 = interp_module!(module, dyn_consts, 3);
+
+
+ println!("result: {:?}", result_1);
+
+ let mut pm = hercules_opt::pass::PassManager::new(module.clone());
+
+ let passes = vec![
+ Pass::Verify,
+ Pass::CCP,
+ Pass::DCE,
+ Pass::GVN,
+ Pass::Xdot(true),
+ Pass::LoopCanonicalization,
+ Pass::DCE,
+ Pass::Xdot(true),
+ Pass::LoopCanonicalization,
+ Pass::Xdot(true),
+ Pass::Verify,
+ ];
+
+ for pass in passes {
+ pm.add_pass(pass);
+ }
+ pm.run_passes();
+
+ let module = pm.get_module();
+ let result_2 = interp_module!(module, dyn_consts, 3);
+ assert_eq!(result_1, result_2);
+}
+
+#[ignore]
#[test]
fn loop_alternate_sum() {
let len = 1;
@@ -28,9 +86,9 @@ fn loop_alternate_sum() {
let result_1 = interp_module!(module, dyn_consts, params);
println!("result: {:?}", result_1);
-
}
+#[ignore]
#[test]
fn loop_canonical_sum() {
let len = 1;
@@ -44,6 +102,7 @@ fn loop_canonical_sum() {
}
+#[ignore]
#[test]
fn matmul_pipeline() {
let len = 1;
diff --git a/hercules_test/test_inputs/fork_transforms/fork_fission/simple2.hir b/hercules_test/test_inputs/fork_transforms/fork_fission/simple2.hir
index 14c09aec..6be6d2c7 100644
--- a/hercules_test/test_inputs/fork_transforms/fork_fission/simple2.hir
+++ b/hercules_test/test_inputs/fork_transforms/fork_fission/simple2.hir
@@ -11,7 +11,7 @@ fn fun<1>(x: u64) -> u64
reduce2 = reduce(j, zero, add2)
add3 = add(reduce3, tid)
reduce3 = reduce(j, zero, add3)
- add4 = sub(reduce4, tid)
+ add4 = mul(reduce4, tid)
reduce4 = reduce(j, zero, add4)
out1 = add(reduce1, reduce2)
out2 = add(reduce3, reduce4)
diff --git a/hercules_test/test_inputs/loop_analysis/do_loop_far_guard.hir b/hercules_test/test_inputs/loop_analysis/do_loop_far_guard.hir
new file mode 100644
index 00000000..4df92a18
--- /dev/null
+++ b/hercules_test/test_inputs/loop_analysis/do_loop_far_guard.hir
@@ -0,0 +1,14 @@
+fn sum<1>(a: u32) -> u64
+ zero_idx = constant(u64, 0)
+ one_idx = constant(u64, 1)
+ bound = dynamic_constant(#0)
+ loop = region(start, if_true)
+ idx = phi(loop, zero_idx, idx_inc)
+ idx_inc = add(idx, one_idx)
+ red = phi(loop, zero_idx, red_add)
+ red_add = add(red, one_idx)
+ in_bounds = lt(idx_inc, bound)
+ if = if(loop, in_bounds)
+ if_false = projection(if, 0)
+ if_true = projection(if, 1)
+ r = return(if_false, red)
\ No newline at end of file
diff --git a/hercules_test/test_inputs/loop_analysis/do_loop_immediate_guard.hir b/hercules_test/test_inputs/loop_analysis/do_loop_immediate_guard.hir
new file mode 100644
index 00000000..a4732cde
--- /dev/null
+++ b/hercules_test/test_inputs/loop_analysis/do_loop_immediate_guard.hir
@@ -0,0 +1,21 @@
+fn sum<1>(a: u64) -> u64
+ zero_idx = constant(u64, 0)
+ one_idx = constant(u64, 1)
+ bound = dynamic_constant(#0)
+ guard_lt = lt(zero_idx, bound)
+ guard = if(start, guard_lt)
+ guard_true = projection(guard, 1)
+ guard_false = projection(guard, 0)
+ loop = region(guard_true, if_true)
+ inner_side_effect = region(loop)
+ idx = phi(loop, zero_idx, idx_inc)
+ idx_inc = add(idx, one_idx)
+ red = phi(loop, zero_idx, red_add)
+ red_add = add(red, one_idx)
+ join_phi = phi(final, zero_idx, red_add)
+ in_bounds = lt(idx_inc, bound)
+ if = if(inner_side_effect, in_bounds)
+ if_false = projection(if, 0)
+ if_true = projection(if, 1)
+ final = region(guard_false, if_false)
+ r = return(final, join_phi)
\ No newline at end of file
diff --git a/hercules_test/test_inputs/loop_analysis/do_loop_no_guard.hir b/hercules_test/test_inputs/loop_analysis/do_loop_no_guard.hir
new file mode 100644
index 00000000..9e22e14b
--- /dev/null
+++ b/hercules_test/test_inputs/loop_analysis/do_loop_no_guard.hir
@@ -0,0 +1,15 @@
+fn sum<1>(a: u64) -> u64
+ zero_idx = constant(u64, 0)
+ one_idx = constant(u64, 1)
+ bound = dynamic_constant(#0)
+ loop = region(start, if_true)
+ inner_side_effect = region(loop)
+ idx = phi(loop, zero_idx, idx_inc)
+ idx_inc = add(idx, one_idx)
+ red = phi(loop, zero_idx, red_add)
+ red_add = add(red, one_idx)
+ in_bounds = lt(idx_inc, bound)
+ if = if(inner_side_effect, in_bounds)
+ if_false = projection(if, 0)
+ if_true = projection(if, 1)
+ r = return(if_false, red_add)
\ No newline at end of file
--
GitLab
From f5938f6916d159b01f31313cdd947292598821bc Mon Sep 17 00:00:00 2001
From: Xavier Routh <xrouth2@illinois.edu>
Date: Mon, 13 Jan 2025 18:38:30 -0500
Subject: [PATCH 26/68] canonicalization + forkify fixes
---
Cargo.lock | 55 ----
Cargo.toml | 12 +-
hercules_ir/src/loops.rs | 2 -
hercules_opt/src/editor.rs | 81 ++++-
hercules_opt/src/forkify.rs | 142 +++++----
hercules_opt/src/ivar.rs | 7 +-
hercules_opt/src/loop_canonicalization.rs | 282 ++++++++++--------
hercules_opt/src/pass.rs | 163 +++++-----
.../hercules_tests/tests/loop_tests.rs | 268 +++++++++++++++--
.../alternate_bounds_internal_control.hir | 22 ++
.../alternate_bounds_nested_do_loop.hir | 28 ++
.../alternate_bounds_nested_do_loop2.hir | 25 ++
.../alternate_bounds_nested_do_loop_array.hir | 28 ++
...lternate_bounds_nested_do_loop_guarded.hir | 40 +++
.../alternate_bounds_use_after_loop.hir | 8 +-
15 files changed, 796 insertions(+), 367 deletions(-)
create mode 100644 hercules_test/test_inputs/loop_analysis/alternate_bounds_internal_control.hir
create mode 100644 hercules_test/test_inputs/loop_analysis/alternate_bounds_nested_do_loop.hir
create mode 100644 hercules_test/test_inputs/loop_analysis/alternate_bounds_nested_do_loop2.hir
create mode 100644 hercules_test/test_inputs/loop_analysis/alternate_bounds_nested_do_loop_array.hir
create mode 100644 hercules_test/test_inputs/loop_analysis/alternate_bounds_nested_do_loop_guarded.hir
diff --git a/Cargo.lock b/Cargo.lock
index 5b42a5b6..cc0667d2 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -756,15 +756,6 @@ dependencies = [
"wasm-bindgen",
]
-[[package]]
-name = "juno_antideps"
-version = "0.1.0"
-dependencies = [
- "async-std",
- "juno_build",
- "with_builtin_macros",
-]
-
[[package]]
name = "juno_build"
version = "0.1.0"
@@ -774,15 +765,6 @@ dependencies = [
"with_builtin_macros",
]
-[[package]]
-name = "juno_casts_and_intrinsics"
-version = "0.1.0"
-dependencies = [
- "async-std",
- "juno_build",
- "with_builtin_macros",
-]
-
[[package]]
name = "juno_frontend"
version = "0.1.0"
@@ -800,34 +782,6 @@ dependencies = [
"phf",
]
-[[package]]
-name = "juno_implicit_clone"
-version = "0.1.0"
-dependencies = [
- "async-std",
- "juno_build",
- "with_builtin_macros",
-]
-
-[[package]]
-name = "juno_matmul"
-version = "0.1.0"
-dependencies = [
- "async-std",
- "juno_build",
- "rand",
- "with_builtin_macros",
-]
-
-[[package]]
-name = "juno_nested_ccp"
-version = "0.1.0"
-dependencies = [
- "async-std",
- "juno_build",
- "with_builtin_macros",
-]
-
[[package]]
name = "juno_scheduler"
version = "0.0.1"
@@ -838,15 +792,6 @@ dependencies = [
"lrpar",
]
-[[package]]
-name = "juno_simple3"
-version = "0.1.0"
-dependencies = [
- "async-std",
- "juno_build",
- "with_builtin_macros",
-]
-
[[package]]
name = "kv-log-macro"
version = "1.0.7"
diff --git a/Cargo.toml b/Cargo.toml
index da44b66f..2b330bf4 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -20,10 +20,10 @@ members = [
"hercules_samples/call",
"hercules_samples/ccp",
- "juno_samples/simple3",
- "juno_samples/matmul",
- "juno_samples/casts_and_intrinsics",
- "juno_samples/nested_ccp",
- "juno_samples/antideps",
- "juno_samples/implicit_clone",
+ # "juno_samples/simple3",
+ # "juno_samples/matmul",
+ # "juno_samples/casts_and_intrinsics",
+ # "juno_samples/nested_ccp",
+ # "juno_samples/antideps",
+ # "juno_samples/implicit_clone",
]
diff --git a/hercules_ir/src/loops.rs b/hercules_ir/src/loops.rs
index a338fbd6..eacfe325 100644
--- a/hercules_ir/src/loops.rs
+++ b/hercules_ir/src/loops.rs
@@ -30,8 +30,6 @@ pub struct LoopTree {
}
impl LoopTree {
- // TODO: Document what this does, seems to only work for control nodes.
- // i.e data nodes *in* the loop do not return true.
pub fn contains(&self, x: NodeID) -> bool {
x == self.root || self.loops.contains_key(&x)
}
diff --git a/hercules_opt/src/editor.rs b/hercules_opt/src/editor.rs
index 69c0fde4..5fe7076f 100644
--- a/hercules_opt/src/editor.rs
+++ b/hercules_opt/src/editor.rs
@@ -2,12 +2,14 @@ extern crate bitvec;
extern crate either;
extern crate hercules_ir;
extern crate itertools;
-
+extern crate nestify;
use std::cell::{Ref, RefCell};
-use std::collections::{BTreeMap, HashSet};
+use std::collections::{BTreeMap, HashMap, HashSet};
use std::mem::take;
use std::ops::Deref;
+use self::nestify::nest;
+
use self::bitvec::prelude::*;
use self::either::Either;
@@ -596,6 +598,81 @@ impl<'a, 'b> FunctionEdit<'a, 'b> {
}
}
+pub type DenseNodeMap<T> = Vec<T>;
+pub type SparseNodeMap<T> = HashMap<NodeID, T>;
+
+nest! {
+// Is this something editor should give... Or is it just for analyses.
+//
+#[derive(Clone, Debug)]
+pub struct NodeIterator<'a> {
+ pub direction:
+ #[derive(Clone, Debug, PartialEq)]
+ enum Direction {
+ Uses,
+ Users,
+ },
+ visited: DenseNodeMap<bool>,
+ stack: Vec<NodeID>,
+ func: &'a FunctionEditor<'a>, // Maybe this is an enum, def use can be gotten from the function or from the editor.
+ // `stop condition`, then return all nodes that caused stoppage i.e the frontier of the search.
+ stop_on: HashSet<NodeID>, // Don't add neighbors of these.
+}
+}
+
+pub fn walk_all_uses<'a>(node: NodeID, editor: &'a FunctionEditor<'a>) -> NodeIterator<'a> {
+ let len = editor.func().nodes.len();
+ NodeIterator { direction: Direction::Uses, visited: vec![false; len], stack: vec![node], func: editor,
+ stop_on: HashSet::new()}
+}
+
+pub fn walk_all_users<'a>(node: NodeID, editor: &'a FunctionEditor<'a>) -> NodeIterator<'a> {
+ let len = editor.func().nodes.len();
+ NodeIterator { direction: Direction::Users, visited: vec![false; len], stack: vec![node], func: editor,
+ stop_on: HashSet::new()}
+}
+
+pub fn walk_all_uses_stop_on<'a>(node: NodeID, editor: &'a FunctionEditor<'a>, stop_on: HashSet<NodeID>) -> NodeIterator<'a> {
+ let len = editor.func().nodes.len();
+ NodeIterator { direction: Direction::Uses, visited: vec![false; len], stack: vec![node], func: editor,
+ stop_on,}
+}
+
+pub fn walk_all_users_stop_on<'a>(node: NodeID, editor: &'a FunctionEditor<'a>, stop_on: HashSet<NodeID>) -> NodeIterator<'a> {
+ let len = editor.func().nodes.len();
+ NodeIterator { direction: Direction::Users, visited: vec![false; len], stack: vec![node], func: editor,
+ stop_on,}
+}
+
+impl<'a> Iterator for NodeIterator<'a> {
+ type Item = NodeID;
+
+ fn next(&mut self) -> Option<Self::Item> {
+ while let Some(current) = self.stack.pop() {
+
+ if !self.visited[current.idx()]{
+ self.visited[current.idx()] = true;
+
+ if !self.stop_on.contains(¤t) {
+ if self.direction == Direction::Uses {
+ for neighbor in self.func.get_uses(current) {
+ self.stack.push(neighbor)
+ }
+ } else {
+ for neighbor in self.func.get_users(current) {
+ self.stack.push(neighbor)
+ }
+ }
+ }
+
+ return Some(current);
+ }
+ }
+ None
+ }
+}
+
+
#[cfg(test)]
mod editor_tests {
#[allow(unused_imports)]
diff --git a/hercules_opt/src/forkify.rs b/hercules_opt/src/forkify.rs
index c5aba648..adbff36f 100644
--- a/hercules_opt/src/forkify.rs
+++ b/hercules_opt/src/forkify.rs
@@ -3,7 +3,9 @@ extern crate bitvec;
extern crate nestify;
use std::collections::HashMap;
+use std::collections::HashSet;
use std::iter::zip;
+use std::iter::FromIterator;
use self::nestify::nest;
@@ -19,8 +21,13 @@ use crate::compute_induction_vars;
use crate::compute_loop_variance;
use crate::get_loop_exit_conditions;
use crate::loop_data_location;
+use crate::walk_all_users;
+use crate::walk_all_users_stop_on;
+use crate::walk_all_uses;
+use crate::walk_all_uses_stop_on;
use crate::BasicInductionVariable;
use crate::DataUseLoopLocation;
+use crate::DenseNodeMap;
use crate::FunctionEditor;
use crate::Loop;
use crate::LoopBound;
@@ -31,44 +38,14 @@ use self::hercules_ir::def_use::*;
use self::hercules_ir::ir::*;
use self::hercules_ir::loops::*;
-// Hmm some third variety of this that switches between the two automatically could be fun.
-pub type DenseNodeMap<T> = Vec<T>;
-pub type SparseNodeMap<T> = HashMap<NodeID, T>;
-
pub fn forkify(
editor: &mut FunctionEditor,
control_subgraph: &Subgraph,
fork_join_map: &HashMap<NodeID, NodeID>,
loops: &LoopTree,
-) -> () {
+) -> bool {
println!("loops: {:?} ", loops.bottom_up_loops());
- // Loop until all nesting are unchanged.
- // 'outer: loop {
- // let mut changed = false;
- // let natural_loops = loops
- // .bottom_up_loops()
- // .into_iter()
- // .filter(|(k, _)| editor.func().nodes[k.idx()].is_region());
-
- // let natural_loops: Vec<_> = natural_loops.collect();
-
- // 'inner: for l in natural_loops {
- // changed = forkify_loop(editor, control_subgraph, fork_join_map, &Loop { header: l.0, control: l.1.clone()});
-
- // // Recompute nesting every time because I am lazy, two other options:
- // // 1) have child loops manually add new control nodes to parent loops
- // // 2) use l.control more smartly (this is basically a disgusting hack).
- // if changed {
- // continue 'outer;
- // }
- // }
-
- // if !changed {
- // break 'outer;
- // }
- // }
-
let natural_loops = loops
.bottom_up_loops()
.into_iter()
@@ -79,9 +56,12 @@ pub fn forkify(
for l in natural_loops {
// FIXME: Needs to iterate over all loops on bottom level of tree.
// This is complicated actually, because we can forkify a parent and have a natural loop in the fork body.
- forkify_loop(editor, control_subgraph, fork_join_map, &Loop { header: l.0, control: l.1.clone()});
- return;
+ if forkify_loop(editor, control_subgraph, fork_join_map, &Loop { header: l.0, control: l.1.clone()}) {
+ return true;
+ }
}
+
+ return false;
}
@@ -180,15 +160,11 @@ pub fn forkify_loop(
.filter(|id| *id != basic_iv.node)
.collect();
- // Check if the reductionable phi is in a cycle with a reduce, if it is, we probably have to make a multi-dimensional fork.
// FIXME: You can actually just pattern match, you shouldn't try to handle expresions inbetween reductions.
let reductionable_phis: Vec<_> = analyze_phis(&editor, &candidate_phis).into_iter().collect();
// TODO: Check that *all* phis are reductionable. If they aren't, we can't forkify without splitting the loop.
- // N-Dimensiinoable PHIs get combined with the reduction,
- // Non N-Dimensionable PHIS just get convverted to normals reduces.
-
// Check for a constant used as loop bound.
let Some(bound) = basic_iv.bound else {return false};
let Ok(bound_dc_id) = get_dc_bound(editor, bound) else {return false};
@@ -485,45 +461,79 @@ pub fn analyze_phis<'a>(editor: &'a FunctionEditor, phis: &'a [NodeID])
{
let function = editor.func();
- // FIXME: (@xrouth)
- // Check that the PHI actually has a cycle back to it.
+ // // FIXME: (@xrouth)
+ // // Check that the PHI actually has a cycle back to it.
phis.into_iter().map(move |phi| {
- // do WFS
- let mut other_phi_on_path: DenseNodeMap<bool> = vec![false; function.nodes.len()];
+ // // do WFS
+ // let mut other_phi_on_path: DenseNodeMap<bool> = vec![false; function.nodes.len()];
- let mut bag_of_control_nodes: Vec<NodeID> = vec![*phi];
- let mut visited: DenseNodeMap<bool> = vec![false; function.nodes.len()];
+ // let mut bag_of_control_nodes: Vec<NodeID> = vec![*phi];
+ // let mut visited: DenseNodeMap<bool> = vec![false; function.nodes.len()];
- while !bag_of_control_nodes.is_empty() {
- let node = bag_of_control_nodes.pop().unwrap();
+ // while !bag_of_control_nodes.is_empty() {
+ // let node = bag_of_control_nodes.pop().unwrap();
- if visited[node.idx()] {
- continue;
- }
- visited[node.idx()] = true;
+ // if visited[node.idx()] {
+ // continue;
+ // }
+ // visited[node.idx()] = true;
- if function.nodes[node.idx()].is_phi() && node != *phi{
- other_phi_on_path[node.idx()] = true;
- }
+ // if function.nodes[node.idx()].is_phi() && node != *phi{
+ // other_phi_on_path[node.idx()] = true;
+ // }
- // if function.nodes[node.idx()].is_reduce() {
- // reduce_on_path[node.idx()] = Some(node);
- // }
+ // for succ in editor.get_users(node) {
+ // // If we change, mark as unvisited.
+ // if other_phi_on_path[node.idx()] && other_phi_on_path[succ.idx()] == false {
+ // other_phi_on_path[succ.idx()] = true;
+ // visited[succ.idx()] = false;
+ // bag_of_control_nodes.push(succ.clone());
+ // }
+ // }
+ // }
- for succ in editor.get_users(node) {
- // If we change, mark as unvisited.
- if other_phi_on_path[node.idx()] && other_phi_on_path[succ.idx()] == false {
- other_phi_on_path[succ.idx()] = true;
- visited[succ.idx()] = false;
- bag_of_control_nodes.push(succ.clone());
- }
+ // if other_phi_on_path[phi.idx()] == false {
+ // LoopPHI::Reductionable(*phi)
+ // } else {
+ // LoopPHI::LoopDependant(*phi)
+ // }
+
+ let stop_on: HashSet<NodeID> = editor.node_ids().filter(|n| {
+ if n == phi {
+ return false
+ };
+
+ let node_data = &editor.func().nodes[n.idx()];
+
+ // Stop on Control.
+ if node_data.is_control() {
+ return true;
}
- }
+ // Stop on PHIs.
+ if node_data.is_phi() {
+ return true;
+ // Need to maybe not stop on PHIs, but only stop on some of their incoming edges,
+ // depending
+ // let control = node_data.try_phi().unwrap().0;
+ // return l.control[control.idx()];
+ }
+ false
- if other_phi_on_path[phi.idx()] == false {
- LoopPHI::Reductionable(*phi)
- } else {
+ }).collect();
+
+ // TODO: We may need to stop on exiting the loop for looking for data cycles.
+ let uses = walk_all_uses_stop_on(*phi, editor, stop_on.clone());
+ let users = walk_all_users_stop_on(*phi, editor, stop_on);
+
+ let set1: HashSet<_> = HashSet::from_iter(uses);
+ let set2: HashSet<_> = HashSet::from_iter(users);
+
+ // If there are any cycles containing a phi
+ if set1.intersection(&set2).any(|node| editor.func().nodes[node.idx()].is_phi() && node != phi) {
LoopPHI::LoopDependant(*phi)
+ } else {
+ LoopPHI::Reductionable(*phi)
}
})
+
}
\ No newline at end of file
diff --git a/hercules_opt/src/ivar.rs b/hercules_opt/src/ivar.rs
index 21290dea..78f37346 100644
--- a/hercules_opt/src/ivar.rs
+++ b/hercules_opt/src/ivar.rs
@@ -22,9 +22,6 @@ use self::hercules_ir::ir::*;
use crate::*;
-type DenseNodeMap<T> = Vec<T>;
-type SparseNodeMap<T> = HashMap<NodeID, T>;
-
/**
* This represents induction vairable analysis, to be used by forkify!
*/
@@ -176,7 +173,8 @@ pub fn get_loop_data_location<'a>(
result
}
-pub fn get_loop_phis<'a>(function: &'a Function, l: &'a Loop) -> impl Iterator<Item = NodeID> + 'a {
+/** returns PHIs that are *in* a loop */
+pub fn get_all_loop_phis<'a>(function: &'a Function, l: &'a Loop) -> impl Iterator<Item = NodeID> + 'a {
function.nodes.iter().enumerate().filter_map(
move |(node_id, node)| {
if let Some((control, _)) = node.try_phi() {
@@ -192,6 +190,7 @@ pub fn get_loop_phis<'a>(function: &'a Function, l: &'a Loop) -> impl Iterator<I
)
}
+
// FIXME: Need a trait that Editor and Function both implement, that gives us UseDefInfo
/** Given a loop (from LoopTree) determine for each data node if. Queries on control nodes are undefined. */
diff --git a/hercules_opt/src/loop_canonicalization.rs b/hercules_opt/src/loop_canonicalization.rs
index 0d5b1066..1a02a108 100644
--- a/hercules_opt/src/loop_canonicalization.rs
+++ b/hercules_opt/src/loop_canonicalization.rs
@@ -27,10 +27,11 @@ use crate::compute_induction_vars;
use crate::compute_loop_variance;
use crate::get_loop_data_location;
use crate::get_loop_exit_conditions;
-use crate::get_loop_phis;
+use crate::get_all_loop_phis;
+use crate::walk_all_users_stop_on;
+use crate::walk_all_uses;
use crate::BasicInductionVariable;
use crate::DataUseLoopLocation;
-use crate::DenseNodeMap;
use crate::FunctionEditor;
use crate::Loop;
use crate::LoopExit;
@@ -38,13 +39,14 @@ use crate::LoopVariance;
use self::hercules_ir::LoopTree;
+/** On return `true` means the function has been modified, and loop_canonicalization can be ran again
+ (with newly analysis info), to canonicalze more loops. */
pub fn loop_canonicalization(
editor: &mut FunctionEditor,
control_subgraph: &Subgraph,
fork_join_map: &HashMap<NodeID, NodeID>,
loops: &LoopTree,
-
-) -> () {
+) -> bool {
println!("loops: {:?} ", loops.bottom_up_loops());
let natural_loops = loops
@@ -56,18 +58,28 @@ pub fn loop_canonicalization(
let mut loop_exits = HashMap::new();
+ // FIXME: Add return type enum of: {transformed, already in transformed form (not modified), unable to transform}.
for l in &natural_loops {
let Some(loop_exit) = get_loop_exit_conditions(editor.func(), &Loop { header: l.0, control: l.1.clone()}, control_subgraph) else {continue};
loop_exits.insert(l.0, loop_exit);
}
-
+
for l in natural_loops {
let natural_loop = &Loop { header: l.0, control: l.1.clone()};
- convert_to_while_loop(editor, natural_loop, loop_exits.get(&l.0).copied(), false);
- canonicalize_loop(editor, loop_exits.get(&l.0).copied(), fork_join_map, natural_loop);
- return;
+
+ // Can't canonicalize loops where there is a use of the IV after the region that increments the IV
+ // but before the guard, which happens in do-while loops.
+ if canonicalize_loop(editor, loop_exits.get(&l.0).copied(), fork_join_map, natural_loop) {
+ return true;
+ }
+ // Can't convert while loops w/ weird guards?
+ if convert_to_while_loop(editor, natural_loop, loop_exits.get(&l.0).copied(), false) {
+ return true;
+ }
}
+ return false;
+
}
// Returns false if a guard can't be added, true if a guard is succesffuly added.
@@ -111,11 +123,72 @@ pub fn guard_exists(
editor.func().nodes[guard_cond.idx()] else {return false};
// Check that the side of the exit condition is the same, or the initializer is the same.
-
- // Replace phis in the loop latch w/ their initializers.
let Node::Binary {left: latch_left, right: latch_right, op: latch_op } =
editor.func().nodes[loop_condition.idx()] else {return false};
+ // Check for Specific Pattern for do-while loops.
+ // This is the worst code I have ever seen in my life.
+ let blah = {
+ if let Node::Binary { left: latch_add_left, right: latch_add_right, op: add_op } = &editor.func().nodes[latch_left.idx()] {
+
+ // FIXME: Better utilities for comparing equiv of expressions. Blah.
+ let left_is_one = if let Node::Constant { id } = &editor.func().nodes[latch_add_left.idx()] {
+ editor.get_constant(*id).is_one()
+ } else {
+ false
+ };
+
+ let right_is_one = if let Node::Constant { id } = &editor.func().nodes[latch_add_right.idx()] {
+ editor.get_constant(*id).is_one()
+ } else {
+ false
+ };
+
+ if !(right_is_one || left_is_one) {
+ false
+ } else if !(*add_op == BinaryOperator::Add) {
+ false
+ } else {
+ let n = if (right_is_one) {
+ &editor.func().nodes[latch_add_left.idx()]
+ } else {
+ &editor.func().nodes[latch_add_right.idx()]
+ };
+
+ if let Node::Phi {control: phi_control, data} = n {
+ if *phi_control == natural_loop.header {
+ let Node::Region { preds } = &editor.func().nodes[natural_loop.header.idx()] else {panic!()};
+ let init_idx = preds.iter().position(|node| *node == loop_pred ).unwrap();
+ let init_value = data[init_idx];
+
+ // Now, we have all the pieces, compare to the guard condition.
+ if latch_op == guard_cond_op && guard_cond_left == init_value && guard_cond_right == latch_right {
+ return true;
+ } else {
+ return false;
+ }
+ true
+ } else {
+ false
+ }
+ } else {
+ false
+ }
+ }
+
+ } else {
+ false
+ }
+ };
+
+ if blah {
+ return true;
+ }
+
+
+ // Replace phis in the loop latch w/ their initializers.
+
+ // General Case:
let latch_left = if let Node::Phi { control: left_control, data } = &editor.func().nodes[latch_left.idx()] {
if *left_control == natural_loop.header {
let Node::Region { preds } = &editor.func().nodes[natural_loop.header.idx()] else {panic!()};
@@ -144,7 +217,7 @@ pub fn guard_exists(
// FIXME: More comprehensive condition equivalance.
// Check condition equivalence:
- if latch_op == guard_cond_op && guard_cond_left == latch_left && guard_cond_right == latch_right {
+ if latch_op == guard_cond_op && guard_cond_left == latch_left && guard_cond_right == latch_right {
return true;
} else {
return false;
@@ -180,7 +253,7 @@ pub fn convert_to_while_loop(
// If the header -> if, then there is no control before the condition, so it's a while loop.
if editor.get_uses(if_node).contains(&natural_loop.header) {
- return true
+ return false
}
let loop_before_if_first = editor.get_users(natural_loop.header)
@@ -220,6 +293,11 @@ pub fn convert_to_while_loop(
true
}
+// struct TransformResult {
+// modified: bool,
+// suceeded: bool,
+// }
+
pub fn canonicalize_loop(
editor: &mut FunctionEditor,
loop_exit: Option<LoopExit>,
@@ -227,12 +305,24 @@ pub fn canonicalize_loop(
l: &Loop,
) -> bool {
- let function = editor.func();
-
let Some(loop_condition) = loop_exit else {return false};
let LoopExit::Conditional { if_node: loop_if, condition_node } = loop_condition.clone() else {return false};
+ // FIXME: Need to be more careful abo ut changing the conditions if we are a do-while loop,
+
+ // Changing loop conditions in canonicalization *actually* changes the number of times the loop runs.
+ // If there is no internal control, this doesn't matter.
+ // If there is internal control, then changing loop iterations might mater.
+
+ // If the IF doesn't directly use the header, then there might be side-effects inside the loop,
+ // so we don't canonicalize
+ if !editor.get_uses(loop_if).contains(&l.header) {
+ return false
+ }
+
+ let function = editor.func();
+
// Compute loop variance
let loop_variance = compute_loop_variance(&editor, &l);
@@ -283,19 +373,16 @@ pub fn canonicalize_loop(
}
).next();
-
-
let Some((iv_expression, base_iv)) = alternate_iv else {return false};
let iv_expression = iv_expression.clone();
let base_iv = base_iv.clone();
-
// If there are users of iv_expression (not just the loop bound condition), then abort
if editor.get_users(iv_expression).count() > 2 {return false};
// Replace external_uses uses of data with phi.
// Panic on internal uses.
- struct PhiTransformInfo {
+ struct PhiDataCycle {
phi: NodeID,
data: NodeID,
external_uses: Vec<NodeID>,
@@ -309,8 +396,10 @@ pub fn canonicalize_loop(
let data_use_locations = get_loop_data_location(editor, l);
- // Check all PHIs in the loop:
- let transform_infos: Option<Vec<_>> = get_loop_phis(function, l)
+ let mut changed = false;
+
+ // Check all PHIs controlled by the loop
+ let loop_phis: Option<Vec<PhiDataCycle>> = editor.get_users(l.header).filter(|n| editor.func().nodes[n.idx()].is_phi())
.filter(|phi| *phi != base_iv.node)
.map(|phi: NodeID| {
@@ -318,8 +407,9 @@ pub fn canonicalize_loop(
// but possibly multiple external uses. z
let initializer_node_id = editor.func().nodes[phi.idx()].try_phi().unwrap().1[loop_phi_init_idx];
+
// Check if any use is in a cycle w/ the phi.
- let mut iter =
+ let mut data_cycles =
editor.get_uses(phi)
.filter(|phi_use|
*phi_use != initializer_node_id) // Not the initializer.
@@ -345,29 +435,46 @@ pub fn canonicalize_loop(
});
-
-
- let Some((data, internal_uses, external_uses)) = iter.next() else {
- return None;
+ let Some((data, internal_uses, external_uses)) = data_cycles.next() else {
+ return None;
};
- if iter.next().is_some() {
+ // There should only be one cycle
+ if data_cycles.next().is_some() {
return None;
}
+ Some(PhiDataCycle {
+ phi,
+ data,
+ external_uses,
+ internal_uses,
+ })
+ }).collect();
+
+ // If any PHIs are invalid, (not in cycles, )
+ let Some(loop_phis) = loop_phis else {
+ return false;
+ };
+
+ // Make sure all phi data cycles are fully contained.
+ let used_outside_loop = loop_phis.iter()
+ .any(|transform_info: &PhiDataCycle|
+ {
+ let PhiDataCycle { phi, data, external_uses, internal_uses } = transform_info;
+
// Check usres of the PHI, make sure they aren't outside the loop
- // Condition: (unless its the one we found in step (1))
- // Refinment: Unless they would be outside because of the use we are going to get rid of,
+ // Unless they would be outside because of the use we are going to get rid of,
// need a more complicated use location analysis for this.
- if editor.get_users(phi)
+ if editor.get_users(*phi)
.any(|node|
{
- if node == data {
+ if node == *data {
return false;
}
let stop_on: HashSet<NodeID> = editor.node_ids().filter(|n| {
- if *n == data {
+ if *n == *data {
return true
};
@@ -411,111 +518,30 @@ pub fn canonicalize_loop(
}
}
) {
- return None;
- };
+ return true;
+ } else {
+ return false;
+ }
+ });
- Some(PhiTransformInfo {
- phi,
- data,
- external_uses,
- internal_uses,
- })
- }).collect();
+ if used_outside_loop {
+ return changed;
+ }
// Change loop bounds
editor.edit(|edit|
edit.replace_all_uses_where(iv_expression, base_iv.node, |usee| *usee == condition_node)
);
- let Some(transform_infos) = transform_infos else {
- return false;
- };
-
- if transform_infos.len() != 1 {
- return false;
- }
-
- let transform_info = &transform_infos[0];
-
- editor.edit(|mut edit|
- {
- edit.replace_all_uses_where(transform_info.data, transform_info.phi, |usee| transform_info.external_uses.contains(usee))
- }
- );
- //
-
- true
-}
-
-
-
-nest! {
-// Is this something editor should give... Or is it just for analyses.
-//
-#[derive(Clone, Debug)]
-pub struct NodeIterator<'a> {
- pub direction:
- #[derive(Clone, Debug, PartialEq)]
- enum Direction {
- Uses,
- Users,
- },
- visited: DenseNodeMap<bool>,
- stack: Vec<NodeID>,
- func: &'a FunctionEditor<'a>, // Maybe this is an enum, def use can be gotten from the function or from the editor.
- // `stop condition`, then return all nodes that caused stoppage i.e the frontier of the search.
- stop_on: HashSet<NodeID>, // Don't add neighbors of these.
-}
-}
-
-pub fn walk_all_uses<'a>(node: NodeID, editor: &'a FunctionEditor<'a>) -> NodeIterator<'a> {
- let len = editor.func().nodes.len();
- NodeIterator { direction: Direction::Uses, visited: vec![false; len], stack: vec![node], func: editor,
- stop_on: HashSet::new()}
-}
-
-pub fn walk_all_users<'a>(node: NodeID, editor: &'a FunctionEditor<'a>) -> NodeIterator<'a> {
- let len = editor.func().nodes.len();
- NodeIterator { direction: Direction::Users, visited: vec![false; len], stack: vec![node], func: editor,
- stop_on: HashSet::new()}
-}
-
-pub fn walk_all_uses_stop_on<'a>(node: NodeID, editor: &'a FunctionEditor<'a>, stop_on: HashSet<NodeID>) -> NodeIterator<'a> {
- let len = editor.func().nodes.len();
- NodeIterator { direction: Direction::Uses, visited: vec![false; len], stack: vec![node], func: editor,
- stop_on,}
-}
-
-pub fn walk_all_users_stop_on<'a>(node: NodeID, editor: &'a FunctionEditor<'a>, stop_on: HashSet<NodeID>) -> NodeIterator<'a> {
- let len = editor.func().nodes.len();
- NodeIterator { direction: Direction::Users, visited: vec![false; len], stack: vec![node], func: editor,
- stop_on,}
-}
-
-impl<'a> Iterator for NodeIterator<'a> {
- type Item = NodeID;
+ changed = true;
- fn next(&mut self) -> Option<Self::Item> {
- while let Some(current) = self.stack.pop() {
-
- if !self.visited[current.idx()]{
- self.visited[current.idx()] = true;
-
- if !self.stop_on.contains(¤t) {
- if self.direction == Direction::Uses {
- for neighbor in self.func.get_uses(current) {
- self.stack.push(neighbor)
- }
- } else {
- for neighbor in self.func.get_users(current) {
- self.stack.push(neighbor)
- }
- }
- }
-
- return Some(current);
+ for transform_info in loop_phis {
+ editor.edit(|mut edit|
+ {
+ edit.replace_all_uses_where(transform_info.data, transform_info.phi, |usee| transform_info.external_uses.contains(usee))
}
- }
- None
+ );
}
+
+ changed
}
\ No newline at end of file
diff --git a/hercules_opt/src/pass.rs b/hercules_opt/src/pass.rs
index 1cb7d340..cadf5f95 100644
--- a/hercules_opt/src/pass.rs
+++ b/hercules_opt/src/pass.rs
@@ -409,47 +409,52 @@ impl PassManager {
self.clear_analyses();
}
Pass::Forkify => {
- self.make_def_uses();
- self.make_loops();
- self.make_control_subgraphs();
- self.make_fork_join_maps();
- let def_uses = self.def_uses.as_ref().unwrap();
- let loops = self.loops.as_ref().unwrap();
- let fork_join_maps = self.fork_join_maps.as_ref().unwrap();
- for idx in 0..self.module.functions.len() {
- let constants_ref =
- RefCell::new(std::mem::take(&mut self.module.constants));
- let dynamic_constants_ref =
- RefCell::new(std::mem::take(&mut self.module.dynamic_constants));
- let types_ref = RefCell::new(std::mem::take(&mut self.module.types));
- let subgraph = &self.control_subgraphs.as_ref().unwrap()[idx];
- let mut editor = FunctionEditor::new(
- &mut self.module.functions[idx],
- FunctionID::new(idx),
- &constants_ref,
- &dynamic_constants_ref,
- &types_ref,
- &def_uses[idx],
- );
-
- forkify(
- &mut editor,
- subgraph,
- &fork_join_maps[idx],
- &loops[idx],
- );
-
- self.module.constants = constants_ref.take();
- self.module.dynamic_constants = dynamic_constants_ref.take();
- self.module.types = types_ref.take();
-
- let num_nodes = self.module.functions[idx].nodes.len();
- self.module.functions[idx]
- .schedules
- .resize(num_nodes, vec![]);
- self.module.functions[idx].delete_gravestones();
+ let mut changed = true;
+ while changed {
+ changed = false;
+
+ self.make_def_uses();
+ self.make_loops();
+ self.make_control_subgraphs();
+ self.make_fork_join_maps();
+ let def_uses = self.def_uses.as_ref().unwrap();
+ let loops = self.loops.as_ref().unwrap();
+ let fork_join_maps = self.fork_join_maps.as_ref().unwrap();
+ for idx in 0..self.module.functions.len() {
+ let constants_ref =
+ RefCell::new(std::mem::take(&mut self.module.constants));
+ let dynamic_constants_ref =
+ RefCell::new(std::mem::take(&mut self.module.dynamic_constants));
+ let types_ref = RefCell::new(std::mem::take(&mut self.module.types));
+ let subgraph = &self.control_subgraphs.as_ref().unwrap()[idx];
+ let mut editor = FunctionEditor::new(
+ &mut self.module.functions[idx],
+ FunctionID::new(idx),
+ &constants_ref,
+ &dynamic_constants_ref,
+ &types_ref,
+ &def_uses[idx],
+ );
+
+ changed |= forkify(
+ &mut editor,
+ subgraph,
+ &fork_join_maps[idx],
+ &loops[idx],
+ );
+
+ self.module.constants = constants_ref.take();
+ self.module.dynamic_constants = dynamic_constants_ref.take();
+ self.module.types = types_ref.take();
+
+ let num_nodes = self.module.functions[idx].nodes.len();
+ self.module.functions[idx]
+ .schedules
+ .resize(num_nodes, vec![]);
+ self.module.functions[idx].delete_gravestones();
+ }
+ self.clear_analyses();
}
- self.clear_analyses();
}
Pass::PhiElim => {
self.make_def_uses();
@@ -1082,46 +1087,52 @@ impl PassManager {
self.clear_analyses();
},
Pass::LoopCanonicalization => {
- self.make_def_uses();
- self.make_loops();
- self.make_control_subgraphs();
- self.make_fork_join_maps();
- self.make_typing();
- self.make_doms();
- let def_uses = self.def_uses.as_ref().unwrap();
- let loops = self.loops.as_ref().unwrap();
- let fork_join_maps = self.fork_join_maps.as_ref().unwrap();
- let types = self.typing.as_ref().unwrap();
- for idx in 0..self.module.functions.len() {
- let constants_ref =
- RefCell::new(std::mem::take(&mut self.module.constants));
- let dynamic_constants_ref =
- RefCell::new(std::mem::take(&mut self.module.dynamic_constants));
- let types_ref = RefCell::new(std::mem::take(&mut self.module.types));
- let control_subgraph = &self.control_subgraphs.as_ref().unwrap()[idx];
- let mut editor = FunctionEditor::new(
- &mut self.module.functions[idx],
- FunctionID::new(idx),
- &constants_ref,
- &dynamic_constants_ref,
- &types_ref,
- &def_uses[idx],
- );
+ let mut changed = true;
- loop_canonicalization(
- &mut editor,
- control_subgraph,
- &fork_join_maps[idx],
- &loops[idx],
- );
+ while changed {
+ changed = false;
- self.module.constants = constants_ref.take();
- self.module.dynamic_constants = dynamic_constants_ref.take();
- self.module.types = types_ref.take();
+ self.make_def_uses();
+ self.make_loops();
+ self.make_control_subgraphs();
+ self.make_fork_join_maps();
+ self.make_typing();
+ self.make_doms();
+ let def_uses = self.def_uses.as_ref().unwrap();
+ let loops = self.loops.as_ref().unwrap();
+ let fork_join_maps = self.fork_join_maps.as_ref().unwrap();
+ let types = self.typing.as_ref().unwrap();
+ for idx in 0..self.module.functions.len() {
+ let constants_ref =
+ RefCell::new(std::mem::take(&mut self.module.constants));
+ let dynamic_constants_ref =
+ RefCell::new(std::mem::take(&mut self.module.dynamic_constants));
+ let types_ref = RefCell::new(std::mem::take(&mut self.module.types));
+ let control_subgraph = &self.control_subgraphs.as_ref().unwrap()[idx];
+ let mut editor = FunctionEditor::new(
+ &mut self.module.functions[idx],
+ FunctionID::new(idx),
+ &constants_ref,
+ &dynamic_constants_ref,
+ &types_ref,
+ &def_uses[idx],
+ );
- self.module.functions[idx].delete_gravestones();
+ changed |= loop_canonicalization(
+ &mut editor,
+ control_subgraph,
+ &fork_join_maps[idx],
+ &loops[idx],
+ );
+
+ self.module.constants = constants_ref.take();
+ self.module.dynamic_constants = dynamic_constants_ref.take();
+ self.module.types = types_ref.take();
+
+ self.module.functions[idx].delete_gravestones();
+ }
+ self.clear_analyses();
}
- self.clear_analyses();
}
}
println!("Ran pass: {:?}", pass);
diff --git a/hercules_test/hercules_tests/tests/loop_tests.rs b/hercules_test/hercules_tests/tests/loop_tests.rs
index 00252f06..790644eb 100644
--- a/hercules_test/hercules_tests/tests/loop_tests.rs
+++ b/hercules_test/hercules_tests/tests/loop_tests.rs
@@ -21,31 +21,129 @@ fn loop_trip_count() {
println!("result: {:?}", result_1);
}
-// Tests a do while loop that only iterates once,
-// canonicalization *should not* transform this to a while loop, as there is no
-// guard that replicates the loop condition.
+
+// Test canonicalization
#[test]
-fn do_loop_not_continued() {
+fn alternate_bounds_use_after_loop_no_tid() {
let len = 1;
let dyn_consts = [len];
- let params = vec![1, 2, 3, 4, 5];
+ let module = parse_file("../test_inputs/loop_analysis/alternate_bounds_use_after_loop_no_tid.hir");
+ let result_1 = interp_module!(module, dyn_consts, 3);
+
+ println!("result: {:?}", result_1);
+
+ let mut pm = hercules_opt::pass::PassManager::new(module.clone());
+
+ let passes = vec![
+ Pass::Verify,
+ Pass::Xdot(true),
+ Pass::CCP,
+ Pass::DCE,
+ Pass::GVN,
+ Pass::Xdot(true),
+ Pass::LoopCanonicalization,
+ Pass::DCE,
+ Pass::Xdot(true),
+ Pass::LoopCanonicalization,
+ Pass::Xdot(true),
+ Pass::Verify,
+ ];
+
+ for pass in passes {
+ pm.add_pass(pass);
+ }
+ pm.run_passes();
+
+ let module = pm.get_module();
+ let result_2 = interp_module!(module, dyn_consts, 3);
+ println!("{:?}", result_1);
+ println!("{:?}", result_2);
+
+ assert_eq!(result_1, result_2);
+}
+
+// Test canonicalization
+#[test]
+fn alternate_bounds_use_after_loop() {
+ let len = 4;
+ let dyn_consts = [len];
+
+ let a = vec![3, 4, 5, 6];
let module = parse_file("../test_inputs/loop_analysis/alternate_bounds_use_after_loop.hir");
- let result_1 = interp_module!(module, dyn_consts, params);
+ let result_1 = interp_module!(module, dyn_consts, a.clone());
println!("result: {:?}", result_1);
+
+ let mut pm = hercules_opt::pass::PassManager::new(module.clone());
+
+ let passes = vec![
+ Pass::Verify,
+ Pass::CCP,
+ Pass::DCE,
+ Pass::GVN,
+ Pass::Xdot(true),
+ Pass::LoopCanonicalization,
+ Pass::DCE,
+ Pass::Xdot(true),
+ Pass::Verify,
+ ];
+
+ for pass in passes {
+ pm.add_pass(pass);
+ }
+ pm.run_passes();
+
+ let module = pm.get_module();
+ let result_2 = interp_module!(module, dyn_consts, a.clone());
+ //println!("{:?}", result_1);
+ println!("{:?}", result_2);
+
+ //assert_eq!(result_1, result_2);
}
-// Tests a do while loop that is guarded, so should be canonicalized
-// It also has
#[test]
-fn do_loop_complex_immediate_guarded() {
+fn alternate_bounds_internal_control() {
let len = 1;
let dyn_consts = [len];
- let module = parse_file("../test_inputs/loop_analysis/do_loop_immediate_guard.hir");
+ let module = parse_file("../test_inputs/loop_analysis/alternate_bounds_internal_control.hir");
let result_1 = interp_module!(module, dyn_consts, 3);
+ println!("result: {:?}", result_1);
+
+ let mut pm = hercules_opt::pass::PassManager::new(module.clone());
+
+ let passes = vec![
+ Pass::Verify,
+ Pass::Xdot(true),
+ Pass::LoopCanonicalization,
+ Pass::Xdot(true),
+ Pass::DCE,
+ Pass::Verify,
+ ];
+
+ for pass in passes {
+ pm.add_pass(pass);
+ }
+
+ pm.run_passes();
+
+ let module = pm.get_module();
+ let result_2 = interp_module!(module, dyn_consts, 3);
+ println!("{:?}", result_1);
+ println!("{:?}", result_2);
+
+ assert_eq!(result_1, result_2);
+}
+
+#[test]
+fn alternate_bounds_nested_do_loop() {
+ let len = 1;
+ let dyn_consts = [10, 5];
+
+ let module = parse_file("../test_inputs/loop_analysis/alternate_bounds_nested_do_loop.hir");
+ let result_1 = interp_module!(module, dyn_consts, 3);
println!("result: {:?}", result_1);
@@ -53,39 +151,155 @@ fn do_loop_complex_immediate_guarded() {
let passes = vec![
Pass::Verify,
- Pass::CCP,
+ Pass::Xdot(true),
+ Pass::LoopCanonicalization,
+ Pass::Xdot(true),
+ Pass::LoopCanonicalization,
+ Pass::Xdot(true),
Pass::DCE,
- Pass::GVN,
+ Pass::Verify,
+ ];
+
+ for pass in passes {
+ pm.add_pass(pass);
+ }
+
+ pm.run_passes();
+
+ let module = pm.get_module();
+ let result_2 = interp_module!(module, dyn_consts, 3);
+ println!("{:?}", result_1);
+ println!("{:?}", result_2);
+
+ assert_eq!(result_1, result_2);
+}
+
+#[test]
+fn alternate_bounds_nested_do_loop_array() {
+ let len = 1;
+ let dyn_consts = [10, 5];
+
+ let a = vec![4u64, 4, 4, 4, 4, 100];
+ let module = parse_file("../test_inputs/loop_analysis/alternate_bounds_nested_do_loop_array.hir");
+ let result_1 = interp_module!(module, dyn_consts, a.clone());
+
+ println!("result: {:?}", result_1);
+
+ let mut pm = hercules_opt::pass::PassManager::new(module.clone());
+
+ let passes = vec![
+ Pass::Verify,
Pass::Xdot(true),
Pass::LoopCanonicalization,
+ Pass::Xdot(true),
Pass::DCE,
+ Pass::Verify,
+ ];
+
+ for pass in passes {
+ pm.add_pass(pass);
+ }
+
+ pm.run_passes();
+
+ let module = pm.get_module();
+ let result_2 = interp_module!(module, dyn_consts, a);
+ println!("{:?}", result_1);
+ println!("{:?}", result_2);
+
+ assert_eq!(result_1, result_2);
+}
+
+#[test]
+fn alternate_bounds_nested_do_loop_guarded() {
+ let len = 1;
+ let dyn_consts = [10, 5];
+
+ let module = parse_file("../test_inputs/loop_analysis/alternate_bounds_nested_do_loop_guarded.hir");
+ let result_1 = interp_module!(module, dyn_consts, 3);
+
+ println!("result: {:?}", result_1);
+
+ let mut pm = hercules_opt::pass::PassManager::new(module.clone());
+
+ let passes = vec![
+ Pass::Verify,
+ Pass::Xdot(true),
+ Pass::LoopCanonicalization,
Pass::Xdot(true),
Pass::LoopCanonicalization,
Pass::Xdot(true),
+ Pass::DCE,
Pass::Verify,
];
for pass in passes {
pm.add_pass(pass);
}
+
pm.run_passes();
let module = pm.get_module();
let result_2 = interp_module!(module, dyn_consts, 3);
+ println!("{:?}", result_1);
+ println!("{:?}", result_2);
+
assert_eq!(result_1, result_2);
}
+// Tests a do while loop that only iterates once,
+// canonicalization *should not* transform this to a while loop, as there is no
+// guard that replicates the loop condition.
#[ignore]
#[test]
-fn loop_alternate_sum() {
+fn do_loop_not_continued() {
+ // let len = 1;
+ // let dyn_consts = [len];
+ // let params = vec![1, 2, 3, 4, 5];
+
+ // let module = parse_file("../test_inputs/loop_analysis/alternate_bounds_use_after_loop.hir");
+ // let result_1 = interp_module!(module, dyn_consts, params);
+
+ // println!("result: {:?}", result_1);
+}
+
+// Tests a do while loop that is guarded, so should be canonicalized
+// It also has
+#[test]
+fn do_loop_complex_immediate_guarded() {
let len = 1;
let dyn_consts = [len];
- let params = vec![1, 2, 3, 4, 5];
- let module = parse_file("../test_inputs/loop_analysis/alternate_bounds_use_after_loop.hir");
- let result_1 = interp_module!(module, dyn_consts, params);
+ let module = parse_file("../test_inputs/loop_analysis/do_loop_immediate_guard.hir");
+ let result_1 = interp_module!(module, dyn_consts, 3);
+
println!("result: {:?}", result_1);
+
+ let mut pm = hercules_opt::pass::PassManager::new(module.clone());
+
+ let passes = vec![
+ Pass::Verify,
+ Pass::CCP,
+ Pass::DCE,
+ Pass::GVN,
+ Pass::Xdot(true),
+ Pass::LoopCanonicalization,
+ Pass::DCE,
+ Pass::Xdot(true),
+ Pass::LoopCanonicalization,
+ Pass::Xdot(true),
+ Pass::Verify,
+ ];
+
+ for pass in passes {
+ pm.add_pass(pass);
+ }
+ pm.run_passes();
+
+ let module = pm.get_module();
+ let result_2 = interp_module!(module, dyn_consts, 3);
+ assert_eq!(result_1, result_2);
}
#[ignore]
@@ -99,10 +313,8 @@ fn loop_canonical_sum() {
let result_1 = interp_module!(module, dyn_consts, params);
println!("result: {:?}", result_1);
-
}
-#[ignore]
#[test]
fn matmul_pipeline() {
let len = 1;
@@ -136,11 +348,13 @@ fn matmul_pipeline() {
let result_2 = interp_module!(module, dyn_consts, m1.clone(), m2.clone());
assert_eq!(result_1, result_2);
- // -------------------
+ // 1st (innermost) Loop Canonicalization
let mut pm = hercules_opt::pass::PassManager::new(module.clone());
let passes = vec![
+ Pass::Xdot(true),
Pass::LoopCanonicalization,
+ Pass::Xdot(true),
Pass::Verify,
];
@@ -148,18 +362,24 @@ fn matmul_pipeline() {
pm.add_pass(pass);
}
pm.run_passes();
-
let module = pm.get_module();
let result_2 = interp_module!(module, dyn_consts, m1.clone(), m2.clone());
assert_eq!(result_1, result_2);
-
// -------------------
let mut pm = hercules_opt::pass::PassManager::new(module.clone());
let passes = vec![
Pass::Forkify,
Pass::DCE,
+ Pass::Xdot(true),
+ Pass::Verify,
+ Pass::ForkGuardElim,
+ Pass::Forkify,
+ Pass::ForkGuardElim,
+ Pass::Forkify,
+ Pass::DCE,
+ Pass::Xdot(true),
Pass::Verify,
];
@@ -241,7 +461,7 @@ fn matmul_pipeline() {
Pass::LoopCanonicalization,
Pass::Forkify,
Pass::DCE,
- Pass::Xdot(true),
+ // Pass::Xdot(true),
];
for pass in passes {
@@ -260,7 +480,7 @@ fn matmul_pipeline() {
let passes = vec![
Pass::ForkCoalesce,
Pass::DCE,
- Pass::Xdot(true),
+ // Pass::Xdot(true),
];
for pass in passes {
@@ -280,7 +500,7 @@ fn matmul_pipeline() {
Pass::DCE,
Pass::ForkGuardElim,
Pass::DCE,
- Pass::Xdot(true),
+ // Pass::Xdot(true),
];
for pass in passes {
diff --git a/hercules_test/test_inputs/loop_analysis/alternate_bounds_internal_control.hir b/hercules_test/test_inputs/loop_analysis/alternate_bounds_internal_control.hir
new file mode 100644
index 00000000..3746b00a
--- /dev/null
+++ b/hercules_test/test_inputs/loop_analysis/alternate_bounds_internal_control.hir
@@ -0,0 +1,22 @@
+fn sum<1>(a: u64) -> u64
+ zero_idx = constant(u64, 0)
+ one_idx = constant(u64, 1)
+ two = constant(u64, 2)
+ ten = constant(u64, 10)
+ bound = dynamic_constant(#0)
+ loop = region(start, if_true)
+ inner_ctrl = region(loop)
+ inner_phi = phi(inner_ctrl, idx)
+ idx = phi(loop, zero_idx, idx_inc)
+ idx_inc = add(idx, one_idx)
+ red = phi(loop, zero_idx, red_add)
+ red_add = add(red, two)
+ red2 = phi(loop, zero_idx, red_add2)
+ red_add2 = add(red, inner_phi)
+ in_bounds = lt(idx_inc, bound)
+ if = if(inner_ctrl, in_bounds)
+ if_false = projection(if, 0)
+ if_true = projection(if, 1)
+ plus_ten = add(red_add, ten)
+ red_add_2_plus_blah = add(red2, plus_ten)
+ r = return(if_false, red_add_2_plus_blah)
\ No newline at end of file
diff --git a/hercules_test/test_inputs/loop_analysis/alternate_bounds_nested_do_loop.hir b/hercules_test/test_inputs/loop_analysis/alternate_bounds_nested_do_loop.hir
new file mode 100644
index 00000000..52f70172
--- /dev/null
+++ b/hercules_test/test_inputs/loop_analysis/alternate_bounds_nested_do_loop.hir
@@ -0,0 +1,28 @@
+fn loop<2>(a: u64) -> u64
+ zero_idx = constant(u64, 0)
+ one_idx = constant(u64, 1)
+ zero_var = constant(u64, 0)
+ one_var = constant(u64, 1)
+ ten = constant(u64, 10)
+ inner_bound = dynamic_constant(#0)
+ outer_bound = dynamic_constant(#1)
+ outer_loop = region(start, outer_if_true)
+ inner_loop = region(outer_loop, inner_if_true)
+ outer_var = phi(outer_loop, zero_var, inner_var_inc)
+ inner_var = phi(inner_loop, outer_var, inner_var_inc)
+ inner_var_inc = add(inner_var, blah2)
+ inner_idx = phi(inner_loop, zero_idx, inner_idx_inc)
+ blah = mul(outer_idx, ten)
+ blah2 = add(blah, inner_idx)
+ inner_idx_inc = add(inner_idx, one_idx)
+ inner_in_bounds = lt(inner_idx_inc, inner_bound)
+ outer_idx = phi(outer_loop, zero_idx, outer_idx_inc, outer_idx)
+ outer_idx_inc = add(outer_idx, one_idx)
+ outer_in_bounds = lt(outer_idx_inc, outer_bound)
+ inner_if = if(inner_loop, inner_in_bounds)
+ inner_if_false = projection(inner_if, 0)
+ inner_if_true = projection(inner_if, 1)
+ outer_if = if(inner_if_false, outer_in_bounds)
+ outer_if_false = projection(outer_if, 0)
+ outer_if_true = projection(outer_if, 1)
+ r = return(outer_if_false, inner_var_inc)
\ No newline at end of file
diff --git a/hercules_test/test_inputs/loop_analysis/alternate_bounds_nested_do_loop2.hir b/hercules_test/test_inputs/loop_analysis/alternate_bounds_nested_do_loop2.hir
new file mode 100644
index 00000000..f295b391
--- /dev/null
+++ b/hercules_test/test_inputs/loop_analysis/alternate_bounds_nested_do_loop2.hir
@@ -0,0 +1,25 @@
+fn loop<2>(a: u32) -> i32
+ zero_idx = constant(u64, 0)
+ one_idx = constant(u64, 1)
+ zero_var = constant(i32, 0)
+ one_var = constant(i32, 1)
+ inner_bound = dynamic_constant(#0)
+ outer_bound = dynamic_constant(#1)
+ outer_loop = region(start, outer_if_true)
+ inner_loop = region(outer_loop, inner_if_true)
+ outer_var = phi(outer_loop, zero_var, inner_var_inc)
+ inner_var = phi(inner_loop, outer_var, inner_var_inc)
+ inner_var_inc = add(inner_var, one_var)
+ inner_idx = phi(inner_loop, zero_idx, inner_idx_inc)
+ inner_idx_inc = add(inner_idx, one_idx)
+ inner_in_bounds = lt(inner_idx_inc, inner_bound)
+ outer_idx = phi(outer_loop, zero_idx, outer_idx_inc, outer_idx)
+ outer_idx_inc = add(outer_idx, one_idx)
+ outer_in_bounds = lt(outer_idx_inc, outer_bound)
+ inner_if = if(inner_loop, inner_in_bounds)
+ inner_if_false = projection(inner_if, 0)
+ inner_if_true = projection(inner_if, 1)
+ outer_if = if(inner_if_false, outer_in_bounds)
+ outer_if_false = projection(outer_if, 0)
+ outer_if_true = projection(outer_if, 1)
+ r = return(outer_if_false, inner_var_inc)
\ No newline at end of file
diff --git a/hercules_test/test_inputs/loop_analysis/alternate_bounds_nested_do_loop_array.hir b/hercules_test/test_inputs/loop_analysis/alternate_bounds_nested_do_loop_array.hir
new file mode 100644
index 00000000..e5401779
--- /dev/null
+++ b/hercules_test/test_inputs/loop_analysis/alternate_bounds_nested_do_loop_array.hir
@@ -0,0 +1,28 @@
+fn loop<2>(a: array(u64, #1)) -> u64
+ zero_idx = constant(u64, 0)
+ one_idx = constant(u64, 1)
+ zero_var = constant(u64, 0)
+ one_var = constant(u64, 1)
+ ten = constant(u64, 10)
+ inner_bound = dynamic_constant(#0)
+ outer_bound = dynamic_constant(#1)
+ outer_loop = region(start, outer_if_true)
+ inner_loop = region(outer_loop, inner_if_true)
+ outer_var = phi(outer_loop, zero_var, inner_var_inc)
+ inner_var = phi(inner_loop, outer_var, inner_var_inc)
+ inner_var_inc = add(inner_var, blah2)
+ inner_idx = phi(inner_loop, zero_idx, inner_idx_inc)
+ blah = read(a, position(outer_idx))
+ blah2 = add(blah, inner_idx)
+ inner_idx_inc = add(inner_idx, one_idx)
+ inner_in_bounds = lt(inner_idx_inc, inner_bound)
+ outer_idx = phi(outer_loop, zero_idx, outer_idx_inc, outer_idx)
+ outer_idx_inc = add(outer_idx, one_idx)
+ outer_in_bounds = lt(outer_idx_inc, outer_bound)
+ inner_if = if(inner_loop, inner_in_bounds)
+ inner_if_false = projection(inner_if, 0)
+ inner_if_true = projection(inner_if, 1)
+ outer_if = if(inner_if_false, outer_in_bounds)
+ outer_if_false = projection(outer_if, 0)
+ outer_if_true = projection(outer_if, 1)
+ r = return(outer_if_false, inner_var_inc)
\ No newline at end of file
diff --git a/hercules_test/test_inputs/loop_analysis/alternate_bounds_nested_do_loop_guarded.hir b/hercules_test/test_inputs/loop_analysis/alternate_bounds_nested_do_loop_guarded.hir
new file mode 100644
index 00000000..b979ad42
--- /dev/null
+++ b/hercules_test/test_inputs/loop_analysis/alternate_bounds_nested_do_loop_guarded.hir
@@ -0,0 +1,40 @@
+fn loop<2>(a: u64) -> u64
+ zero_idx = constant(u64, 0)
+ one_idx = constant(u64, 1)
+ zero_var = constant(u64, 0)
+ one_var = constant(u64, 1)
+ ten = constant(u64, 10)
+ outer_guard_if = if(start, outer_guard_lt)
+ outer_guard_if_false = projection(outer_guard_if, 0)
+ outer_guard_if_true = projection(outer_guard_if, 1)
+ outer_guard_lt = lt(zero_idx, outer_bound)
+ outer_join = region(outer_guard_if_false, outer_if_false)
+ outer_join_var = phi(outer_join, zero_idx, join_var)
+ inner_bound = dynamic_constant(#0)
+ outer_bound = dynamic_constant(#1)
+ outer_loop = region(outer_guard_if_true, outer_if_true)
+ inner_loop = region(guard_if_true, inner_if_true)
+ guard_lt = lt(zero_idx, inner_bound)
+ guard_if = if(outer_loop, guard_lt)
+ guard_if_true = projection(guard_if, 1)
+ guard_if_false = projection(guard_if, 0)
+ guard_join = region(guard_if_false, inner_if_false)
+ inner_idx = phi(inner_loop, zero_idx, inner_idx_inc)
+ inner_idx_inc = add(inner_idx, one_idx)
+ inner_in_bounds = lt(inner_idx_inc, inner_bound)
+ outer_idx = phi(outer_loop, zero_idx, outer_idx_inc, outer_idx)
+ outer_idx_inc = add(outer_idx, one_idx)
+ outer_in_bounds = lt(outer_idx_inc, outer_bound)
+ inner_if = if(inner_loop, inner_in_bounds)
+ inner_if_false = projection(inner_if, 0)
+ inner_if_true = projection(inner_if, 1)
+ outer_if = if(guard_join, outer_in_bounds)
+ outer_if_false = projection(outer_if, 0)
+ outer_if_true = projection(outer_if, 1)
+ outer_var = phi(outer_loop, zero_var, join_var)
+ inner_var = phi(inner_loop, outer_var, inner_var_inc)
+ blah = mul(outer_idx, ten)
+ blah2 = add(blah, inner_idx)
+ inner_var_inc = add(inner_var, blah2)
+ join_var = phi(guard_join, outer_var, inner_var_inc)
+ r = return(outer_join, outer_join_var)
\ No newline at end of file
diff --git a/hercules_test/test_inputs/loop_analysis/alternate_bounds_use_after_loop.hir b/hercules_test/test_inputs/loop_analysis/alternate_bounds_use_after_loop.hir
index 6b54c531..7851b97c 100644
--- a/hercules_test/test_inputs/loop_analysis/alternate_bounds_use_after_loop.hir
+++ b/hercules_test/test_inputs/loop_analysis/alternate_bounds_use_after_loop.hir
@@ -1,10 +1,10 @@
-fn sum<1>(a: array(u64, #0)) -> u64
+fn sum<1>(a: array(i32, #0)) -> i32
zero_idx = constant(u64, 0)
one_idx = constant(u64, 1)
- zero_inc = constant(u64, 0)
- ten = constant(u64, 10)
+ zero_inc = constant(i32, 0)
+ ten = constant(i32, 10)
bound = dynamic_constant(#0)
- loop = region(start, if_true)
+ loop = region(start, if_true)
idx = phi(loop, zero_idx, idx_inc)
idx_inc = add(idx, one_idx)
red = phi(loop, zero_inc, red_add)
--
GitLab
From a9981cd69b757c034305ea96b28b8cf2930ebc0d Mon Sep 17 00:00:00 2001
From: Xavier Routh <xrouth2@illinois.edu>
Date: Mon, 13 Jan 2025 20:32:13 -0500
Subject: [PATCH 27/68] slight cleanup
---
hercules_opt/src/fork_transforms.rs | 46 ++++++++++++-----------
hercules_opt/src/forkify.rs | 41 ++++----------------
hercules_opt/src/ivar.rs | 28 +++++---------
hercules_opt/src/loop_canonicalization.rs | 8 ++--
4 files changed, 43 insertions(+), 80 deletions(-)
diff --git a/hercules_opt/src/fork_transforms.rs b/hercules_opt/src/fork_transforms.rs
index 895c94f5..6c98a1fa 100644
--- a/hercules_opt/src/fork_transforms.rs
+++ b/hercules_opt/src/fork_transforms.rs
@@ -35,11 +35,14 @@ pub fn default_reduce_partition(editor: &FunctionEditor, fork: NodeID, join: Nod
map
}
+// TODO: Refine these conditions.
+/** */
pub fn find_reduce_dependencies<'a>(function: &'a Function, reduce: NodeID, fork: NodeID
) -> impl IntoIterator<Item = NodeID> + 'a
{
let len = function.nodes.len();
+
let mut visited: DenseNodeMap<bool> = vec![false; len];
let mut depdendent: DenseNodeMap<bool> = vec![false; len];
@@ -73,7 +76,7 @@ pub fn find_reduce_dependencies<'a>(function: &'a Function, reduce: NodeID, fork
// Note: HACKY, the condition wwe want is 'all nodes on any path from the fork to the reduce (in the forward graph), or the reduce to the fork (in the directed graph)
// cycles break this, but we assume for now that the only cycles are ones that involve the reduce node
// NOTE: (control may break this (i.e loop inside fork) is a cycle that isn't the reduce)
- // the current solution is just to mark the reduce as dependent at the start of traversing the graph.
+ // the current solution is just to mark the reduce as dependent at the start of traversing the graph.
depdendent[reduce.idx()] = true;
recurse(function, reduce, fork, &mut depdendent, &mut visited);
@@ -145,20 +148,21 @@ pub fn fork_fission<'a> (
// This does the reduction fission:
if true {
- for fork in forks.clone() {
- // FIXME: If there is control in between fork and join, give up.
- let join = fork_join_map[&fork];
- let join_pred = editor.func().nodes[join.idx()].try_join().unwrap();
- if join_pred != fork {
- todo!("Can't do fork fission on nodes with internal control")
- // Inner control LOOPs are hard
- // inner control in general *should* work right now without modifications.
- }
- let reduce_partition = default_reduce_partition(editor, fork, join);
+ for fork in forks.clone() {
+ // FIXME: If there is control in between fork and join, give up.
+ let join = fork_join_map[&fork];
+ let join_pred = editor.func().nodes[join.idx()].try_join().unwrap();
+ if join_pred != fork {
+ todo!("Can't do fork fission on nodes with internal control")
+ // Inner control LOOPs are hard
+ // inner control in general *should* work right now without modifications.
+ }
+ let reduce_partition = default_reduce_partition(editor, fork, join);
- let (new_fork, new_join) = fork_reduce_fission_helper(editor, fork_join_map, reduce_partition, control_pred, fork);
- // control_pred = new_join;
- }} else {
+ let (new_fork, new_join) = fork_reduce_fission_helper(editor, fork_join_map, reduce_partition, control_pred, fork);
+ // control_pred = new_join;
+ }
+ } else {
// This does the bufferization:
let edge = (NodeID::new(15), NodeID::new(16));
// let edge = (NodeID::new(4), NodeID::new(9));
@@ -179,7 +183,6 @@ pub fn fork_bufferize_fission_helper<'a> (
types: &Vec<TypeID>,
fork: NodeID,
) -> (NodeID, NodeID) { // Returns the two forks that it generates.
- // TODO: Check validititry of bufferized_edges (ask xavier for condition).
// TODO: Check that bufferized edges src doesn't depend on anything that comes after the fork.
@@ -203,11 +206,9 @@ pub fn fork_bufferize_fission_helper<'a> (
edit.replace_all_uses_where(fork, new_fork_id, |usee| *usee == join)
});
-
for (src, dst) in bufferized_edges {
- // FIXME: Disgusting cloning and allocationing and iteartors.
+ // FIXME: Disgusting cloning and allocationing and iterators.
let factors: Vec<_> = editor.func().nodes[fork.idx()].try_fork().unwrap().1.iter().cloned().collect();
-
editor.edit(|mut edit|
{
// Create write to buffer
@@ -385,9 +386,8 @@ pub fn fork_coalesce(
}
-/** Opposite of fork split, takes two one-dimensional fork-joins
- with no control between them,
- FIXME:
+/** Opposite of fork split, takes two fork-joins
+ with no control between them, and merges them into a single fork-join.
*/
pub fn fork_coalesce_helper(
editor: &mut FunctionEditor,
@@ -429,7 +429,9 @@ pub fn fork_coalesce_helper(
// Check Control between joins and forks
// FIXME: use control subgraph.
- let Some(user) = editor.get_users(outer_fork).filter(|node| editor.func().nodes[node.idx()].is_control()).next() else { return false};
+ let Some(user) = editor.get_users(outer_fork)
+ .filter(|node| editor.func().nodes[node.idx()].is_control()).next() else { return false};
+
if user != inner_fork {
return false;
}
diff --git a/hercules_opt/src/forkify.rs b/hercules_opt/src/forkify.rs
index adbff36f..0824f258 100644
--- a/hercules_opt/src/forkify.rs
+++ b/hercules_opt/src/forkify.rs
@@ -54,8 +54,7 @@ pub fn forkify(
let natural_loops: Vec<_> = natural_loops.collect();
for l in natural_loops {
- // FIXME: Needs to iterate over all loops on bottom level of tree.
- // This is complicated actually, because we can forkify a parent and have a natural loop in the fork body.
+ // FIXME: Run on all-bottom level loops, as they can be independently optimized without recomputing analyses.
if forkify_loop(editor, control_subgraph, fork_join_map, &Loop { header: l.0, control: l.1.clone()}) {
return true;
}
@@ -119,9 +118,9 @@ where
iter.all(|x| std::mem::discriminant(&x) == first_discriminant)
}
-/*
- * Top level function to convert natural loops with simple induction variables
- * into fork-joins.
+/**
+ Top level function to convert natural loops with simple induction variables
+ into fork-joins.
*/
pub fn forkify_loop(
editor: &mut FunctionEditor,
@@ -130,8 +129,6 @@ pub fn forkify_loop(
l: &Loop,
) -> bool {
- // TODO: Do we want to run analysizes before, I think it's fine to put them in the pass itself.
- // i.e no real split between analysis and transformation.
let function = editor.func();
let loop_pred = editor.get_uses(l.header)
@@ -154,36 +151,19 @@ pub fn forkify_loop(
&basic_ivs, &loop_condition, &loop_variance) else {return false};
// Check reductionable phis, only PHIs depending on the loop are considered,
- // CHECK ME: this is how we avoid reductions that depend on control flow?
let candidate_phis: Vec<_> = editor.get_users(l.header)
.filter(|id|function.nodes[id.idx()].is_phi())
.filter(|id| *id != basic_iv.node)
.collect();
- // FIXME: You can actually just pattern match, you shouldn't try to handle expresions inbetween reductions.
let reductionable_phis: Vec<_> = analyze_phis(&editor, &candidate_phis).into_iter().collect();
-
- // TODO: Check that *all* phis are reductionable. If they aren't, we can't forkify without splitting the loop.
-
+
// Check for a constant used as loop bound.
let Some(bound) = basic_iv.bound else {return false};
let Ok(bound_dc_id) = get_dc_bound(editor, bound) else {return false};
// START EDITING
- // Induction variables are *also* reducible PHIs. If the PHI / IV has a dependency outside of the loop,
- // then we can't just replace it with the ThreadID.
- // Uses of the IV become:
- // 1) Inside the loop: Uses of the ThreadID
- // 2) Outside the loop: Uses of the reduction node.
- // Regardless, all reductionable PHIs get killed.
-
- // We will always create both, and then just run DCE?!
- // How do we define 'inside loop' for data nodes.
-
- // Confirm that *all* PHIs are reductionable.
- // Q: What other things break parallelism?
-
// What we do is:
// 1) Find a (the?) basic induction variable, create a ThreadID + Fork + Join over it.
// 2) Turn reductionable PHIs into reduces (including the redcutionable PHI)
@@ -192,8 +172,7 @@ pub fn forkify_loop(
// 1) Inside the loop: Uses of the ThreadID
// 2) Outside the loop: Uses of the reduction node.
// - b) if the PHI is not the IV:
- // Just make it a reduce or something.
-
+ // Make it a reduce
let function = editor.func();
@@ -208,8 +187,6 @@ pub fn forkify_loop(
.next()
.unwrap();
- let header_uses: Vec<_> = editor.get_uses(l.header).collect();
-
// TOOD: Handle multiple loop body lasts.
// If there are multiple candidates for loop body last, return false.
if editor.get_uses(l.header)
@@ -249,9 +226,6 @@ pub fn forkify_loop(
// Create fork and join nodes:
let mut join_id = NodeID::new(0);
let mut fork_id = NodeID::new(0);
- let mut thread_id_id = NodeID::new(0);
-
- let function = editor.func();
// FIXME (@xrouth), handle control in loop body.
editor.edit(
@@ -419,9 +393,8 @@ pub fn forkify_loop(
editor.edit(
|mut edit| {
edit = edit.delete_node(loop_continue_projection)?;
- // edit = edit.delete_node(loop_false_read)?;
edit = edit.delete_node(loop_exit_projection)?;
- edit = edit.delete_node(loop_if)?; // Delet ethe if.
+ edit = edit.delete_node(loop_if)?;
edit = edit.delete_node(l.header)?;
Ok(edit)
}
diff --git a/hercules_opt/src/ivar.rs b/hercules_opt/src/ivar.rs
index 78f37346..608e0d31 100644
--- a/hercules_opt/src/ivar.rs
+++ b/hercules_opt/src/ivar.rs
@@ -126,7 +126,7 @@ pub fn loop_data_location(editor: &FunctionEditor, node: NodeID, all_loop_nodes:
}
}
- // Don't go through PHIs that are contorlled by something in the loop either.
+ // Don't go through PHIs that are controlled by something in the loop either.
if node_data.is_phi() {
let control = node_data.try_phi().unwrap().0;
return match all_loop_nodes[control.idx()] {
@@ -193,7 +193,7 @@ pub fn get_all_loop_phis<'a>(function: &'a Function, l: &'a Loop) -> impl Iterat
// FIXME: Need a trait that Editor and Function both implement, that gives us UseDefInfo
-/** Given a loop (from LoopTree) determine for each data node if. Queries on control nodes are undefined. */
+/** Given a loop determine for each data node if the value might change upon each iteration of the loop */
pub fn compute_loop_variance(editor: &FunctionEditor, l: &Loop) -> LoopVarianceInfo {
// Gather all Phi nodes that are controlled by this loop.
let mut loop_vars: Vec<NodeID> = vec![];
@@ -320,20 +320,16 @@ pub fn get_loop_exit_conditions(function: &Function, l: &Loop, control_subgraph:
final_if.map(|v| {LoopExit::Conditional {
if_node: v,
condition_node: if let Node::If{ control: _, cond } = function.nodes[v.idx()] {cond} else {unreachable!()}
- // CODE STYLE: Its this ^ or function.nodes[v.idx()].try_if().unwrap().1;
- // I prefer to epxlicitly specify what field of the IF I want (instead of using .1), so slightly more verbose is okay?
}})
}
/** Add bounds to induction variables that don't have a currently known bound.
- Induction variables that aren't immediately used in a loop condition will not be bounded. For now, we don't return these at all.
- - *The single* induction variable used in a loop condition will be given an appropriate bound.
+ - The s*ingle* induction variable used in a loop condition will be given an appropriate bound.
Returns the single induction variable that is used in the loop exit condition, or None if something is wrong.
- (CODE STYLE: Context w/ None, look into Anyhow::RESULT? )
This gives the beginning and final value of the IV, THIS ISN"T NECESSARILY THE ITERATION COUNT.
-
*/
pub fn bound_induction_variables(function: &Function, control_subgraph: &Subgraph, l: &Loop,
induction_vars: &[BasicInductionVariable], loop_condition: &LoopExit, loop_variance: &LoopVarianceInfo)
@@ -342,7 +338,6 @@ pub fn bound_induction_variables(function: &Function, control_subgraph: &Subgrap
// Answers the question which PHI node does this loop depend on,
// Q: What happens if it is a PHI + expression, i.e i = 0; i + 2 < 6; i++
-
// Q: What happens when the loop exit condition isn't based on simple bound, i.e: i < 6 - 2?
// A: IDK!
@@ -351,7 +346,6 @@ pub fn bound_induction_variables(function: &Function, control_subgraph: &Subgrap
assert!(matches!(loop_condition, LoopExit::Conditional { .. }));
- // CODE STYLE: Make this more rust-y.
let (exit_if_node, loop_condition) = match loop_condition {
LoopExit::Conditional { if_node, condition_node } => (if_node, condition_node),
LoopExit::Unconditional(node_id) => todo!()
@@ -363,9 +357,7 @@ pub fn bound_induction_variables(function: &Function, control_subgraph: &Subgrap
let bound = match &function.nodes[loop_condition.idx()] {
// All of these node types are valid boolean conditionals, we only handle some currently.
- // CODE STYLE: I'm not sure the best way to handle this in the code, I want to return `None` for correctness,
- // but also I want to attach the context that it is `None` only because it is unimplemented (laziness), not
- // user error.
+ // `None` only because it is unimplemented (laziness), not user error.
Node::Phi { control, data } => todo!(),
Node::Reduce { control, init, reduct } => todo!(),
Node::Parameter { index } => todo!(),
@@ -384,8 +376,6 @@ pub fn bound_induction_variables(function: &Function, control_subgraph: &Subgrap
else {
None
}
-
- // left is some expression
}
BinaryOperator::LTE => todo!(), // like wtf.
BinaryOperator::GT => todo!(),
@@ -394,7 +384,6 @@ pub fn bound_induction_variables(function: &Function, control_subgraph: &Subgrap
BinaryOperator::NE => todo!(),
_ => None,
}
-
}
_ => None,
};
@@ -441,7 +430,8 @@ pub fn compute_induction_vars(function: &Function, l: &Loop, loop_variance: &Loo
}
}
- // FIXME: (@xrouth) For now, only compute variables that have one assignment, (look into this:) possibly treat multiple assignment as separate induction variables.
+ // FIXME: (@xrouth) For now, only compute variables that have one assignment,
+ // (look into this:) possibly treat multiple assignment as separate induction variables.
let mut induction_variables: Vec<BasicInductionVariable> = vec![];
/* For each PHI controlled by the loop, check how it is modified */
@@ -454,7 +444,7 @@ pub fn compute_induction_vars(function: &Function, l: &Loop, loop_variance: &Loo
let region_inputs = region_node.try_region().unwrap();
// The initializer index is the first index of the inputs to the region node of that isn't in the loop. (what is loop_header, wtf...)
- // FIXME (@xrouth): If there is control flow in the loop, we won't find
+ // FIXME (@xrouth): If there is control flow in the loop, we won't find ... WHAT
let Some(initializer_idx) = region_inputs.iter().position(|&node_id| !l.control[node_id.idx()]) else {
continue;
};
@@ -463,7 +453,7 @@ pub fn compute_induction_vars(function: &Function, l: &Loop, loop_variance: &Loo
// Check dynamic constancy:
let initializer = &function.nodes[initializer_id.idx()];
- println!("initializer_id: {:?}", initializer_id);
+ // println!("initializer_id: {:?}", initializer_id);
// In the case of a non 0 starting value:
// - a new dynamic constant or constant may need to be created that is the difference between the initiailizer and the loop bounds.
@@ -513,6 +503,6 @@ pub fn compute_induction_vars(function: &Function, l: &Loop, loop_variance: &Loo
}
};
- println!("basic induction variables: {:?}", induction_variables);
+ // println!("basic induction variables: {:?}", induction_variables);
induction_variables
}
\ No newline at end of file
diff --git a/hercules_opt/src/loop_canonicalization.rs b/hercules_opt/src/loop_canonicalization.rs
index 1a02a108..250b5e3b 100644
--- a/hercules_opt/src/loop_canonicalization.rs
+++ b/hercules_opt/src/loop_canonicalization.rs
@@ -83,6 +83,7 @@ pub fn loop_canonicalization(
}
// Returns false if a guard can't be added, true if a guard is succesffuly added.
+// FIXME: Implement this.
pub fn add_guard() -> bool {
false
}
@@ -126,8 +127,8 @@ pub fn guard_exists(
let Node::Binary {left: latch_left, right: latch_right, op: latch_op } =
editor.func().nodes[loop_condition.idx()] else {return false};
- // Check for Specific Pattern for do-while loops.
- // This is the worst code I have ever seen in my life.
+ // Check for Specific Pattern for do-while loops that have weird ivar + 1 < dc bound.
+ // This is the worst code I have ever written in my life.
let blah = {
if let Node::Binary { left: latch_add_left, right: latch_add_right, op: add_op } = &editor.func().nodes[latch_left.idx()] {
@@ -167,7 +168,6 @@ pub fn guard_exists(
} else {
return false;
}
- true
} else {
false
}
@@ -227,7 +227,6 @@ pub fn guard_exists(
/** Attempts to converts a simple natural loop to a while loop
by moving all control between the loop header and the loop condition to after the loop true condition,
but before the header.
- FIXME: Check whether the loop is guaranteed to be entered.
* */
pub fn convert_to_while_loop(
editor: &mut FunctionEditor,
@@ -238,7 +237,6 @@ pub fn convert_to_while_loop(
// FIXME: Check that Loop is simple.
-
let Some(LoopExit::Conditional { if_node, condition_node: _ }) = loop_exit.clone() else {return false};
// FIXME: Check whether the loop is guaranteed to be entered.
--
GitLab
From 2fde0f187bff825841111041d79ab52a7eb9abe0 Mon Sep 17 00:00:00 2001
From: Xavier Routh <xrouth2@illinois.edu>
Date: Mon, 13 Jan 2025 20:36:48 -0500
Subject: [PATCH 28/68] cargo lockfile
---
Cargo.lock | 205 ++++++++++++++++++++---------------------------------
1 file changed, 75 insertions(+), 130 deletions(-)
diff --git a/Cargo.lock b/Cargo.lock
index f94c3a85..de2160f5 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -52,11 +52,12 @@ dependencies = [
[[package]]
name = "anstyle-wincon"
-version = "3.0.6"
+version = "3.0.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2109dbce0e72be3ec00bed26e6a7479ca384ad226efdd66db8fa2e3a38c83125"
+checksum = "ca3534e77181a9cc07539ad51f2141fe32f6c3ffd4df76db8ad92346b003ae4e"
dependencies = [
"anstyle",
+ "once_cell",
"windows-sys",
]
@@ -142,7 +143,7 @@ version = "3.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ff6e472cdea888a4bd64f342f09b3f50e1886d32afe8df3d663c01140b811b18"
dependencies = [
- "event-listener 5.3.1",
+ "event-listener 5.4.0",
"event-listener-strategy",
"pin-project-lite",
]
@@ -223,9 +224,9 @@ dependencies = [
[[package]]
name = "bitflags"
-version = "2.6.0"
+version = "2.7.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de"
+checksum = "1be3f42a67d6d345ecd59f675f3f012d6974981560836e938c22b424b85ce1be"
dependencies = [
"serde",
]
@@ -315,9 +316,9 @@ dependencies = [
[[package]]
name = "clap"
-version = "4.5.23"
+version = "4.5.26"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3135e7ec2ef7b10c6ed8950f0f792ed96ee093fa088608f1c76e569722700c84"
+checksum = "a8eb5e908ef3a6efbe1ed62520fb7287959888c88485abe072543190ecc66783"
dependencies = [
"clap_builder",
"clap_derive",
@@ -325,9 +326,9 @@ dependencies = [
[[package]]
name = "clap_builder"
-version = "4.5.23"
+version = "4.5.26"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "30582fc632330df2bd26877bde0c1f4470d57c582bbc070376afcd04d8cb4838"
+checksum = "96b01801b5fc6a0a232407abc821660c9c6d25a1cafc0d4f85f29fb8d9afc121"
dependencies = [
"anstream",
"anstyle",
@@ -337,14 +338,14 @@ dependencies = [
[[package]]
name = "clap_derive"
-version = "4.5.18"
+version = "4.5.24"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ac6a0c7b1a9e9a5186361f67dfa1b88213572f427fb9ab038efb2bd8c582dab"
+checksum = "54b755194d6389280185988721fffba69495eed5ee9feeee9a599b53db80318c"
dependencies = [
"heck",
"proc-macro2",
"quote",
- "syn 2.0.92",
+ "syn 2.0.96",
]
[[package]]
@@ -412,7 +413,7 @@ checksum = "cb7330aeadfbe296029522e6c40f315320aba36fc43a5b3632f3795348f3bd22"
dependencies = [
"proc-macro2",
"quote",
- "syn 2.0.92",
+ "syn 2.0.96",
]
[[package]]
@@ -469,9 +470,9 @@ checksum = "0206175f82b8d6bf6652ff7d71a1e27fd2e4efde587fd368662814d6ec1d9ce0"
[[package]]
name = "event-listener"
-version = "5.3.1"
+version = "5.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6032be9bd27023a771701cc49f9f053c751055f71efb2e0ae5c15809093675ba"
+checksum = "3492acde4c3fc54c845eaab3eed8bd00c7a7d881f78bfc801e43a93dec1331ae"
dependencies = [
"concurrent-queue",
"parking",
@@ -484,7 +485,7 @@ version = "0.5.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3c3e4e0dd3673c1139bf041f3008816d9cf2946bbfac2945c09e523b8d7b05b2"
dependencies = [
- "event-listener 5.3.1",
+ "event-listener 5.4.0",
"pin-project-lite",
]
@@ -552,9 +553,9 @@ checksum = "9e5c1b78ca4aae1ac06c48a526a655760685149f0d465d21f37abfe57ce075c6"
[[package]]
name = "futures-lite"
-version = "2.5.0"
+version = "2.6.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cef40d21ae2c515b51041df9ed313ed21e572df340ea58a922a0aefe7e8891a1"
+checksum = "f5edaec856126859abb19ed65f39e90fea3a9574b9707f13539acf4abf7eb532"
dependencies = [
"fastrand",
"futures-core",
@@ -698,7 +699,10 @@ dependencies = [
]
[[package]]
-<<<<<<< HEAD
+name = "hercules_rt"
+version = "0.1.0"
+
+[[package]]
name = "hercules_tests"
version = "0.1.0"
dependencies = [
@@ -711,10 +715,6 @@ dependencies = [
"ordered-float",
"rand",
]
-=======
-name = "hercules_rt"
-version = "0.1.0"
->>>>>>> main
[[package]]
name = "hermit-abi"
@@ -740,9 +740,9 @@ checksum = "7943c866cc5cd64cbc25b2e01621d07fa8eb2a1a23160ee81ce38704e97b8ecf"
[[package]]
name = "itertools"
-version = "0.13.0"
+version = "0.14.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186"
+checksum = "2b192c782037fadd9cfa75548310488aabdbf3d2da73885b31bd0abd03351285"
dependencies = [
"either",
]
@@ -755,28 +755,15 @@ checksum = "d75a2a4b1b190afb6f5425f10f6a8f959d2ea0b9c2b1d79553551850539e4674"
[[package]]
name = "js-sys"
-version = "0.3.76"
+version = "0.3.77"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6717b6b5b077764fb5966237269cb3c64edddde4b14ce42647430a78ced9e7b7"
+checksum = "1cfaf33c695fc6e08064efbc1f72ec937429614f25eef83af942d0e227c3a28f"
dependencies = [
"once_cell",
"wasm-bindgen",
]
[[package]]
-<<<<<<< HEAD
-=======
-name = "juno_antideps"
-version = "0.1.0"
-dependencies = [
- "async-std",
- "hercules_rt",
- "juno_build",
- "with_builtin_macros",
-]
-
-[[package]]
->>>>>>> main
name = "juno_build"
version = "0.1.0"
dependencies = [
@@ -803,40 +790,6 @@ dependencies = [
]
[[package]]
-<<<<<<< HEAD
-=======
-name = "juno_implicit_clone"
-version = "0.1.0"
-dependencies = [
- "async-std",
- "hercules_rt",
- "juno_build",
- "with_builtin_macros",
-]
-
-[[package]]
-name = "juno_matmul"
-version = "0.1.0"
-dependencies = [
- "async-std",
- "hercules_rt",
- "juno_build",
- "rand",
- "with_builtin_macros",
-]
-
-[[package]]
-name = "juno_nested_ccp"
-version = "0.1.0"
-dependencies = [
- "async-std",
- "hercules_rt",
- "juno_build",
- "with_builtin_macros",
-]
-
-[[package]]
->>>>>>> main
name = "juno_scheduler"
version = "0.0.1"
dependencies = [
@@ -847,19 +800,6 @@ dependencies = [
]
[[package]]
-<<<<<<< HEAD
-=======
-name = "juno_simple3"
-version = "0.1.0"
-dependencies = [
- "async-std",
- "hercules_rt",
- "juno_build",
- "with_builtin_macros",
-]
-
-[[package]]
->>>>>>> main
name = "kv-log-macro"
version = "1.0.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -893,9 +833,9 @@ dependencies = [
[[package]]
name = "linux-raw-sys"
-version = "0.4.14"
+version = "0.4.15"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "78b3ae25bc7c8c38cec158d1f2757ee79e9b3740fbc7ccf0e59e4b08d793fa89"
+checksum = "d26c52dbd32dccf2d10cac7725f8eae5296885fb5703b261f7d0a0739ec807ab"
[[package]]
name = "lock_api"
@@ -1003,7 +943,7 @@ dependencies = [
"proc-macro-error",
"proc-macro2",
"quote",
- "syn 2.0.92",
+ "syn 2.0.96",
]
[[package]]
@@ -1105,9 +1045,9 @@ checksum = "f38d5652c16fde515bb1ecef450ab0f6a219d619a7274976324d5e377f7dceba"
[[package]]
name = "phf"
-version = "0.11.2"
+version = "0.11.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ade2d8b8f33c7333b51bcf0428d37e217e9f32192ae4772156f65063b8ce03dc"
+checksum = "1fd6780a80ae0c52cc120a26a1a42c1ae51b247a253e4e06113d23d2c2edd078"
dependencies = [
"phf_macros",
"phf_shared",
@@ -1115,9 +1055,9 @@ dependencies = [
[[package]]
name = "phf_generator"
-version = "0.11.2"
+version = "0.11.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "48e4cc64c2ad9ebe670cb8fd69dd50ae301650392e81c05f9bfcb2d5bdbc24b0"
+checksum = "3c80231409c20246a13fddb31776fb942c38553c51e871f8cbd687a4cfb5843d"
dependencies = [
"phf_shared",
"rand",
@@ -1125,31 +1065,31 @@ dependencies = [
[[package]]
name = "phf_macros"
-version = "0.11.2"
+version = "0.11.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3444646e286606587e49f3bcf1679b8cef1dc2c5ecc29ddacaffc305180d464b"
+checksum = "f84ac04429c13a7ff43785d75ad27569f2951ce0ffd30a3321230db2fc727216"
dependencies = [
"phf_generator",
"phf_shared",
"proc-macro2",
"quote",
- "syn 2.0.92",
+ "syn 2.0.96",
]
[[package]]
name = "phf_shared"
-version = "0.11.2"
+version = "0.11.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90fcb95eef784c2ac79119d1dd819e162b5da872ce6f3c3abe1e8ca1c082f72b"
+checksum = "67eabc2ef2a60eb7faa00097bd1ffdb5bd28e62bf39990626a582201b7a754e5"
dependencies = [
"siphasher",
]
[[package]]
name = "pin-project-lite"
-version = "0.2.15"
+version = "0.2.16"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "915a1e146535de9163f3987b8944ed8cf49a18bb0056bcebcdcece385cece4ff"
+checksum = "3b3cff922bd51709b605d9ead9aa71031d81447142d828eb4a6eba76fe619f9b"
[[package]]
name = "pin-utils"
@@ -1237,9 +1177,9 @@ dependencies = [
[[package]]
name = "proc-macro2"
-version = "1.0.92"
+version = "1.0.93"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "37d3544b3f2748c54e147655edb5025752e2303145b5aefb3c3ea2c78b973bb0"
+checksum = "60946a68e5f9d28b0dc1c21bb8a97ee7d018a8b322fa57838ba31cc878e22d99"
dependencies = [
"unicode-ident",
]
@@ -1352,9 +1292,9 @@ dependencies = [
[[package]]
name = "rustix"
-version = "0.38.42"
+version = "0.38.43"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f93dc38ecbab2eb790ff964bb77fa94faf256fd3e73285fd7ba0903b76bedb85"
+checksum = "a78891ee6bf2340288408954ac787aa063d8e8817e9f53abb37c695c6d834ef6"
dependencies = [
"bitflags",
"errno",
@@ -1398,14 +1338,14 @@ checksum = "5a9bf7cf98d04a2b28aead066b7496853d4779c9cc183c440dbac457641e19a0"
dependencies = [
"proc-macro2",
"quote",
- "syn 2.0.92",
+ "syn 2.0.96",
]
[[package]]
name = "siphasher"
-version = "0.3.11"
+version = "1.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38b58827f4464d87d377d175e90bf58eb00fd8716ff0a62f80356b5e61555d0d"
+checksum = "56199f7ddabf13fe5074ce809e7d3f42b42ae711800501b5b16ea82ad029c39d"
[[package]]
name = "slab"
@@ -1477,9 +1417,9 @@ dependencies = [
[[package]]
name = "syn"
-version = "2.0.92"
+version = "2.0.96"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "70ae51629bf965c5c098cc9e87908a3df5301051a9e087d6f9bef5c9771ed126"
+checksum = "d5d0adab1ae378d7f53bdebc67a39f1f151407ef230f0ce2883572f5d8985c80"
dependencies = [
"proc-macro2",
"quote",
@@ -1500,15 +1440,16 @@ checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
[[package]]
name = "tempfile"
-version = "3.13.0"
+version = "3.15.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f0f2c9fc62d0beef6951ccffd757e241266a2c833136efbe35af6cd2567dca5b"
+checksum = "9a8a559c81686f576e8cd0290cd2a24a2a9ad80c98b3478856500fcbd7acd704"
dependencies = [
"cfg-if",
"fastrand",
+ "getrandom",
"once_cell",
"rustix",
- "windows-sys 0.59.0",
+ "windows-sys",
]
[[package]]
@@ -1620,34 +1561,35 @@ checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
[[package]]
name = "wasm-bindgen"
-version = "0.2.99"
+version = "0.2.100"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a474f6281d1d70c17ae7aa6a613c87fce69a127e2624002df63dcb39d6cf6396"
+checksum = "1edc8929d7499fc4e8f0be2262a241556cfc54a0bea223790e71446f2aab1ef5"
dependencies = [
"cfg-if",
"once_cell",
+ "rustversion",
"wasm-bindgen-macro",
]
[[package]]
name = "wasm-bindgen-backend"
-version = "0.2.99"
+version = "0.2.100"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f89bb38646b4f81674e8f5c3fb81b562be1fd936d84320f3264486418519c79"
+checksum = "2f0a0651a5c2bc21487bde11ee802ccaf4c51935d0d3d42a6101f98161700bc6"
dependencies = [
"bumpalo",
"log",
"proc-macro2",
"quote",
- "syn 2.0.92",
+ "syn 2.0.96",
"wasm-bindgen-shared",
]
[[package]]
name = "wasm-bindgen-futures"
-version = "0.4.49"
+version = "0.4.50"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38176d9b44ea84e9184eff0bc34cc167ed044f816accfe5922e54d84cf48eca2"
+checksum = "555d470ec0bc3bb57890405e5d4322cc9ea83cebb085523ced7be4144dac1e61"
dependencies = [
"cfg-if",
"js-sys",
@@ -1658,9 +1600,9 @@ dependencies = [
[[package]]
name = "wasm-bindgen-macro"
-version = "0.2.99"
+version = "0.2.100"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2cc6181fd9a7492eef6fef1f33961e3695e4579b9872a6f7c83aee556666d4fe"
+checksum = "7fe63fc6d09ed3792bd0897b314f53de8e16568c2b3f7982f468c0bf9bd0b407"
dependencies = [
"quote",
"wasm-bindgen-macro-support",
@@ -1668,28 +1610,31 @@ dependencies = [
[[package]]
name = "wasm-bindgen-macro-support"
-version = "0.2.99"
+version = "0.2.100"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "30d7a95b763d3c45903ed6c81f156801839e5ee968bb07e534c44df0fcd330c2"
+checksum = "8ae87ea40c9f689fc23f209965b6fb8a99ad69aeeb0231408be24920604395de"
dependencies = [
"proc-macro2",
"quote",
- "syn 2.0.92",
+ "syn 2.0.96",
"wasm-bindgen-backend",
"wasm-bindgen-shared",
]
[[package]]
name = "wasm-bindgen-shared"
-version = "0.2.99"
+version = "0.2.100"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "943aab3fdaaa029a6e0271b35ea10b72b943135afe9bffca82384098ad0e06a6"
+checksum = "1a05d73b933a847d6cccdda8f838a22ff101ad9bf93e33684f39c1f5f0eece3d"
+dependencies = [
+ "unicode-ident",
+]
[[package]]
name = "web-sys"
-version = "0.3.76"
+version = "0.3.77"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "04dd7223427d52553d3702c004d3b2fe07c148165faa56313cb00211e31c12bc"
+checksum = "33b6dd2ef9186f1f2072e409e99cd22a975331a6b3591b12c764e0e55c60d5d2"
dependencies = [
"js-sys",
"wasm-bindgen",
@@ -1815,5 +1760,5 @@ checksum = "fa4f8080344d4671fb4e831a13ad1e68092748387dfc4f55e356242fae12ce3e"
dependencies = [
"proc-macro2",
"quote",
- "syn 2.0.92",
+ "syn 2.0.96",
]
--
GitLab
From b49f3fd3c1600b7f37bda74c6ea66f08be929ada Mon Sep 17 00:00:00 2001
From: Xavier Routh <xrouth2@illinois.edu>
Date: Mon, 13 Jan 2025 20:39:33 -0500
Subject: [PATCH 29/68] fix tests
---
Cargo.lock | 60 +++++++++++++++++++
Cargo.toml | 12 ++--
.../hercules_tests/tests/loop_tests.rs | 52 ++++++++--------
3 files changed, 92 insertions(+), 32 deletions(-)
diff --git a/Cargo.lock b/Cargo.lock
index de2160f5..5e87d8ee 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -763,6 +763,16 @@ dependencies = [
"wasm-bindgen",
]
+[[package]]
+name = "juno_antideps"
+version = "0.1.0"
+dependencies = [
+ "async-std",
+ "hercules_rt",
+ "juno_build",
+ "with_builtin_macros",
+]
+
[[package]]
name = "juno_build"
version = "0.1.0"
@@ -772,6 +782,15 @@ dependencies = [
"with_builtin_macros",
]
+[[package]]
+name = "juno_casts_and_intrinsics"
+version = "0.1.0"
+dependencies = [
+ "async-std",
+ "juno_build",
+ "with_builtin_macros",
+]
+
[[package]]
name = "juno_frontend"
version = "0.1.0"
@@ -789,6 +808,37 @@ dependencies = [
"phf",
]
+[[package]]
+name = "juno_implicit_clone"
+version = "0.1.0"
+dependencies = [
+ "async-std",
+ "hercules_rt",
+ "juno_build",
+ "with_builtin_macros",
+]
+
+[[package]]
+name = "juno_matmul"
+version = "0.1.0"
+dependencies = [
+ "async-std",
+ "hercules_rt",
+ "juno_build",
+ "rand",
+ "with_builtin_macros",
+]
+
+[[package]]
+name = "juno_nested_ccp"
+version = "0.1.0"
+dependencies = [
+ "async-std",
+ "hercules_rt",
+ "juno_build",
+ "with_builtin_macros",
+]
+
[[package]]
name = "juno_scheduler"
version = "0.0.1"
@@ -799,6 +849,16 @@ dependencies = [
"lrpar",
]
+[[package]]
+name = "juno_simple3"
+version = "0.1.0"
+dependencies = [
+ "async-std",
+ "hercules_rt",
+ "juno_build",
+ "with_builtin_macros",
+]
+
[[package]]
name = "kv-log-macro"
version = "1.0.7"
diff --git a/Cargo.toml b/Cargo.toml
index f921501b..215b5916 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -21,10 +21,10 @@ members = [
"hercules_samples/call",
"hercules_samples/ccp",
- # "juno_samples/simple3",
- # "juno_samples/matmul",
- # "juno_samples/casts_and_intrinsics",
- # "juno_samples/nested_ccp",
- # "juno_samples/antideps",
- # "juno_samples/implicit_clone",
+ "juno_samples/simple3",
+ "juno_samples/matmul",
+ "juno_samples/casts_and_intrinsics",
+ "juno_samples/nested_ccp",
+ "juno_samples/antideps",
+ "juno_samples/implicit_clone",
]
diff --git a/hercules_test/hercules_tests/tests/loop_tests.rs b/hercules_test/hercules_tests/tests/loop_tests.rs
index 790644eb..1d1a050d 100644
--- a/hercules_test/hercules_tests/tests/loop_tests.rs
+++ b/hercules_test/hercules_tests/tests/loop_tests.rs
@@ -37,16 +37,16 @@ fn alternate_bounds_use_after_loop_no_tid() {
let passes = vec![
Pass::Verify,
- Pass::Xdot(true),
+ //Pass::Xdot(true),
Pass::CCP,
Pass::DCE,
Pass::GVN,
- Pass::Xdot(true),
+ //Pass::Xdot(true),
Pass::LoopCanonicalization,
Pass::DCE,
- Pass::Xdot(true),
+ //Pass::Xdot(true),
Pass::LoopCanonicalization,
- Pass::Xdot(true),
+ //Pass::Xdot(true),
Pass::Verify,
];
@@ -82,10 +82,10 @@ fn alternate_bounds_use_after_loop() {
Pass::CCP,
Pass::DCE,
Pass::GVN,
- Pass::Xdot(true),
+ //Pass::Xdot(true),
Pass::LoopCanonicalization,
Pass::DCE,
- Pass::Xdot(true),
+ //Pass::Xdot(true),
Pass::Verify,
];
@@ -116,9 +116,9 @@ fn alternate_bounds_internal_control() {
let passes = vec![
Pass::Verify,
- Pass::Xdot(true),
+ //Pass::Xdot(true),
Pass::LoopCanonicalization,
- Pass::Xdot(true),
+ //Pass::Xdot(true),
Pass::DCE,
Pass::Verify,
];
@@ -151,11 +151,11 @@ fn alternate_bounds_nested_do_loop() {
let passes = vec![
Pass::Verify,
- Pass::Xdot(true),
+ //Pass::Xdot(true),
Pass::LoopCanonicalization,
- Pass::Xdot(true),
+ //Pass::Xdot(true),
Pass::LoopCanonicalization,
- Pass::Xdot(true),
+ //Pass::Xdot(true),
Pass::DCE,
Pass::Verify,
];
@@ -189,9 +189,9 @@ fn alternate_bounds_nested_do_loop_array() {
let passes = vec![
Pass::Verify,
- Pass::Xdot(true),
+ //Pass::Xdot(true),
Pass::LoopCanonicalization,
- Pass::Xdot(true),
+ //Pass::Xdot(true),
Pass::DCE,
Pass::Verify,
];
@@ -224,11 +224,11 @@ fn alternate_bounds_nested_do_loop_guarded() {
let passes = vec![
Pass::Verify,
- Pass::Xdot(true),
+ //Pass::Xdot(true),
Pass::LoopCanonicalization,
- Pass::Xdot(true),
+ //Pass::Xdot(true),
Pass::LoopCanonicalization,
- Pass::Xdot(true),
+ //Pass::Xdot(true),
Pass::DCE,
Pass::Verify,
];
@@ -283,12 +283,12 @@ fn do_loop_complex_immediate_guarded() {
Pass::CCP,
Pass::DCE,
Pass::GVN,
- Pass::Xdot(true),
+ //Pass::Xdot(true),
Pass::LoopCanonicalization,
Pass::DCE,
- Pass::Xdot(true),
+ //Pass::Xdot(true),
Pass::LoopCanonicalization,
- Pass::Xdot(true),
+ //Pass::Xdot(true),
Pass::Verify,
];
@@ -352,9 +352,9 @@ fn matmul_pipeline() {
let mut pm = hercules_opt::pass::PassManager::new(module.clone());
let passes = vec![
- Pass::Xdot(true),
+ //Pass::Xdot(true),
Pass::LoopCanonicalization,
- Pass::Xdot(true),
+ //Pass::Xdot(true),
Pass::Verify,
];
@@ -372,14 +372,14 @@ fn matmul_pipeline() {
let passes = vec![
Pass::Forkify,
Pass::DCE,
- Pass::Xdot(true),
+ //Pass::Xdot(true),
Pass::Verify,
Pass::ForkGuardElim,
Pass::Forkify,
Pass::ForkGuardElim,
Pass::Forkify,
Pass::DCE,
- Pass::Xdot(true),
+ //Pass::Xdot(true),
Pass::Verify,
];
@@ -461,7 +461,7 @@ fn matmul_pipeline() {
Pass::LoopCanonicalization,
Pass::Forkify,
Pass::DCE,
- // Pass::Xdot(true),
+ // //Pass::Xdot(true),
];
for pass in passes {
@@ -480,7 +480,7 @@ fn matmul_pipeline() {
let passes = vec![
Pass::ForkCoalesce,
Pass::DCE,
- // Pass::Xdot(true),
+ // //Pass::Xdot(true),
];
for pass in passes {
@@ -500,7 +500,7 @@ fn matmul_pipeline() {
Pass::DCE,
Pass::ForkGuardElim,
Pass::DCE,
- // Pass::Xdot(true),
+ // //Pass::Xdot(true),
];
for pass in passes {
--
GitLab
From 57c3ebac8ea70fb17d0e1c95d68120321339ee59 Mon Sep 17 00:00:00 2001
From: Xavier Routh <xrouth2@illinois.edu>
Date: Mon, 13 Jan 2025 20:40:51 -0500
Subject: [PATCH 30/68] remove prints
---
hercules_opt/src/fork_transforms.rs | 6 +++---
hercules_opt/src/forkify.rs | 7 ++-----
hercules_opt/src/loop_canonicalization.rs | 2 +-
3 files changed, 6 insertions(+), 9 deletions(-)
diff --git a/hercules_opt/src/fork_transforms.rs b/hercules_opt/src/fork_transforms.rs
index 6c98a1fa..bbefcf83 100644
--- a/hercules_opt/src/fork_transforms.rs
+++ b/hercules_opt/src/fork_transforms.rs
@@ -326,12 +326,12 @@ pub fn fork_reduce_fission_helper<'a> (
subgraph.insert(fork);
subgraph.insert(reduce);
- println!("subgraph for {:?}: \n{:?}", reduce, subgraph);
+ // println!("subgraph for {:?}: \n{:?}", reduce, subgraph);
let (new_nodes, mapping, _) = copy_subgraph(editor, subgraph);
- println!("new_nodes: {:?} ", new_nodes);
- println!("mapping: {:?} ",mapping);
+ // println!("new_nodes: {:?} ", new_nodes);
+ // println!("mapping: {:?} ",mapping);
new_fork = mapping[&fork];
new_join = mapping[&join];
diff --git a/hercules_opt/src/forkify.rs b/hercules_opt/src/forkify.rs
index f42ff0f4..5a23db11 100644
--- a/hercules_opt/src/forkify.rs
+++ b/hercules_opt/src/forkify.rs
@@ -44,7 +44,7 @@ pub fn forkify(
fork_join_map: &HashMap<NodeID, NodeID>,
loops: &LoopTree,
) -> bool {
- println!("loops: {:?} ", loops.bottom_up_loops());
+ // println!("loops: {:?} ", loops.bottom_up_loops());
let natural_loops = loops
.bottom_up_loops()
@@ -275,12 +275,9 @@ pub fn forkify_loop(
iv_use_location[node_use.idx()] = loop_data_location(&editor, node_use, &l.get_all_nodes(), &mut visited)
}
- println!("loop datalocation: {:?}", iv_use_location );
-
+ // println!("loop datalocation: {:?}", iv_use_location );
// Create ThreadID
-
- // FIXME: Fix this for n-dimensional things.
editor.edit(
|mut edit| {
let thread_id = Node::ThreadID {
diff --git a/hercules_opt/src/loop_canonicalization.rs b/hercules_opt/src/loop_canonicalization.rs
index 250b5e3b..298cad29 100644
--- a/hercules_opt/src/loop_canonicalization.rs
+++ b/hercules_opt/src/loop_canonicalization.rs
@@ -47,7 +47,7 @@ pub fn loop_canonicalization(
fork_join_map: &HashMap<NodeID, NodeID>,
loops: &LoopTree,
) -> bool {
- println!("loops: {:?} ", loops.bottom_up_loops());
+ // println!("loops: {:?} ", loops.bottom_up_loops());
let natural_loops = loops
.bottom_up_loops()
--
GitLab
From 39bf9fb5ffb884bf0e6aa790372d87923d4c6d13 Mon Sep 17 00:00:00 2001
From: Xavier Routh <xrouth2@illinois.edu>
Date: Mon, 13 Jan 2025 20:44:28 -0500
Subject: [PATCH 31/68] add canonicalization to frontend passes
---
juno_frontend/src/lib.rs | 38 +++++++++++++++++++++-----------------
1 file changed, 21 insertions(+), 17 deletions(-)
diff --git a/juno_frontend/src/lib.rs b/juno_frontend/src/lib.rs
index a50e71f5..64b21d9c 100644
--- a/juno_frontend/src/lib.rs
+++ b/juno_frontend/src/lib.rs
@@ -151,10 +151,19 @@ pub fn compile_ir(
add_verified_pass!(pm, verify, GVN);
add_verified_pass!(pm, verify, PhiElim);
add_pass!(pm, verify, DCE);
+ if x_dot {
+ pm.add_pass(hercules_opt::pass::Pass::Xdot(true));
+ }
add_pass!(pm, verify, Inline);
+ if x_dot {
+ pm.add_pass(hercules_opt::pass::Pass::Xdot(true));
+ }
// Inlining may make some functions uncalled, so run this pass.
// In general, this should always be run after inlining.
add_pass!(pm, verify, DeleteUncalled);
+ if x_dot {
+ pm.add_pass(hercules_opt::pass::Pass::Xdot(true));
+ }
// Run SROA pretty early (though after inlining which can make SROA more effective) so that
// CCP, GVN, etc. can work on the result of SROA
add_pass!(pm, verify, InterproceduralSROA);
@@ -163,30 +172,25 @@ pub fn compile_ir(
// simplified
add_verified_pass!(pm, verify, PhiElim);
add_pass!(pm, verify, DCE);
-
+ if x_dot {
+ pm.add_pass(hercules_opt::pass::Pass::Xdot(true));
+ }
add_pass!(pm, verify, CCP);
add_pass!(pm, verify, DCE);
add_pass!(pm, verify, GVN);
add_pass!(pm, verify, DCE);
-
- pm.add_pass(hercules_opt::pass::Pass::Serialize(module_name.clone() + ".module"));
- if x_dot {
- pm.add_pass(hercules_opt::pass::Pass::Xdot(true));
- }
- add_verified_pass!(pm, verify, CCP);
- add_verified_pass!(pm, verify, DCE);
- add_verified_pass!(pm, verify, GVN);
- add_verified_pass!(pm, verify, LoopCanonicalization);
- add_verified_pass!(pm, verify, Forkify);
- add_verified_pass!(pm, verify, DCE);
- add_verified_pass!(pm, verify, ForkGuardElim);
- add_verified_pass!(pm, verify, LoopCanonicalization);
- add_verified_pass!(pm, verify, Forkify);
if x_dot {
pm.add_pass(hercules_opt::pass::Pass::Xdot(true));
}
-
- //add_pass!(pm, verify, ForkGuardElim);
+ add_pass!(pm, verify, LoopCanonicalization);
+ // These two need to be ran in a loop, matmul has three layers,
+ // so list them three times for now.
+ add_pass!(pm, verify, Forkify);
+ add_pass!(pm, verify, ForkGuardElim);
+ add_pass!(pm, verify, Forkify);
+ add_pass!(pm, verify, ForkGuardElim);
+ add_pass!(pm, verify, Forkify);
+ add_pass!(pm, verify, ForkGuardElim);
add_verified_pass!(pm, verify, DCE);
add_pass!(pm, verify, ForkSplit);
add_pass!(pm, verify, Unforkify);
--
GitLab
From de3120f68854ed06267ccd500a5a79ee8dd78ce5 Mon Sep 17 00:00:00 2001
From: Xavier Routh <xrouth2@illinois.edu>
Date: Tue, 14 Jan 2025 20:53:14 -0500
Subject: [PATCH 32/68] canonicalization fix for internal PHIs
---
Cargo.lock | 60 -----------
hercules_opt/src/loop_canonicalization.rs | 118 ++++++++++++++++++----
hercules_opt/src/pass.rs | 3 +-
juno_frontend/src/lib.rs | 1 +
juno_samples/nested_ccp/build.rs | 1 +
5 files changed, 101 insertions(+), 82 deletions(-)
diff --git a/Cargo.lock b/Cargo.lock
index 5e87d8ee..de2160f5 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -763,16 +763,6 @@ dependencies = [
"wasm-bindgen",
]
-[[package]]
-name = "juno_antideps"
-version = "0.1.0"
-dependencies = [
- "async-std",
- "hercules_rt",
- "juno_build",
- "with_builtin_macros",
-]
-
[[package]]
name = "juno_build"
version = "0.1.0"
@@ -782,15 +772,6 @@ dependencies = [
"with_builtin_macros",
]
-[[package]]
-name = "juno_casts_and_intrinsics"
-version = "0.1.0"
-dependencies = [
- "async-std",
- "juno_build",
- "with_builtin_macros",
-]
-
[[package]]
name = "juno_frontend"
version = "0.1.0"
@@ -808,37 +789,6 @@ dependencies = [
"phf",
]
-[[package]]
-name = "juno_implicit_clone"
-version = "0.1.0"
-dependencies = [
- "async-std",
- "hercules_rt",
- "juno_build",
- "with_builtin_macros",
-]
-
-[[package]]
-name = "juno_matmul"
-version = "0.1.0"
-dependencies = [
- "async-std",
- "hercules_rt",
- "juno_build",
- "rand",
- "with_builtin_macros",
-]
-
-[[package]]
-name = "juno_nested_ccp"
-version = "0.1.0"
-dependencies = [
- "async-std",
- "hercules_rt",
- "juno_build",
- "with_builtin_macros",
-]
-
[[package]]
name = "juno_scheduler"
version = "0.0.1"
@@ -849,16 +799,6 @@ dependencies = [
"lrpar",
]
-[[package]]
-name = "juno_simple3"
-version = "0.1.0"
-dependencies = [
- "async-std",
- "hercules_rt",
- "juno_build",
- "with_builtin_macros",
-]
-
[[package]]
name = "kv-log-macro"
version = "1.0.7"
diff --git a/hercules_opt/src/loop_canonicalization.rs b/hercules_opt/src/loop_canonicalization.rs
index 298cad29..9f1e6fdb 100644
--- a/hercules_opt/src/loop_canonicalization.rs
+++ b/hercules_opt/src/loop_canonicalization.rs
@@ -84,16 +84,22 @@ pub fn loop_canonicalization(
// Returns false if a guard can't be added, true if a guard is succesffuly added.
// FIXME: Implement this.
-pub fn add_guard() -> bool {
- false
+pub fn add_guard() -> Option<LoopGuard> {
+ None
}
-// True if a guard exists already, false otehrwise
-pub fn guard_exists(
+pub struct LoopGuard {
+ guard_if: NodeID,
+ loop_entered: NodeID,
+ loop_avoided: NodeID,
+}
+
+// Returns the
+pub fn get_guard(
editor: &mut FunctionEditor,
natural_loop: &Loop,
if_node: NodeID,
-) -> bool {
+) -> Option<LoopGuard> {
// Given loop condition (iv_phi ? bound_expr)
// Q: What if iv_phi isn't a PHI, but instead a more complex expression.
@@ -105,27 +111,32 @@ pub fn guard_exists(
// Search for a condition (idx_phi.init ? bound_expr) immediately before the loop is entered
// (header predecessor)
let Node::If { control: pred, cond: loop_condition } =
- editor.func().nodes[if_node.idx()] else {return false};
+ editor.func().nodes[if_node.idx()] else {return None};
// Rely on GVN that the initializers will be the same exact node.
let mut header_preds = editor.get_uses(natural_loop.header)
.filter(|pred| !natural_loop.control[pred.idx()]);
- let Some(loop_pred) = header_preds.next() else {return false};
- if header_preds.next().is_some() {return false}; // If there is more than one header predecessor.
+ let Some(loop_pred) = header_preds.next() else {return None};
+ if header_preds.next().is_some() {return None}; // If there is more than one header predecessor.
let Node::Projection { control: guard_if_node, ref selection } =
- editor.func().nodes[loop_pred.idx()] else {return false};
+ editor.func().nodes[loop_pred.idx()] else {return None};
let Node::If { control: guard_if_pred, cond: guard_cond } =
- editor.func().nodes[guard_if_node.idx()] else {return false};
+ editor.func().nodes[guard_if_node.idx()] else {return None};
+
+ let loop_entered_proj = loop_pred;
+
+ // The if user that isn't the entered proj:
+ let Some(loop_avoided_proj) = editor.get_users(guard_if_node).filter(|n| *n != loop_entered_proj).next() else {return None};
let Node::Binary { left: guard_cond_left, right: guard_cond_right, op: guard_cond_op } =
- editor.func().nodes[guard_cond.idx()] else {return false};
+ editor.func().nodes[guard_cond.idx()] else {return None};
// Check that the side of the exit condition is the same, or the initializer is the same.
let Node::Binary {left: latch_left, right: latch_right, op: latch_op } =
- editor.func().nodes[loop_condition.idx()] else {return false};
+ editor.func().nodes[loop_condition.idx()] else {return None};
// Check for Specific Pattern for do-while loops that have weird ivar + 1 < dc bound.
// This is the worst code I have ever written in my life.
@@ -164,9 +175,9 @@ pub fn guard_exists(
// Now, we have all the pieces, compare to the guard condition.
if latch_op == guard_cond_op && guard_cond_left == init_value && guard_cond_right == latch_right {
- return true;
+ return Some(LoopGuard { guard_if: guard_if_node, loop_entered: loop_entered_proj, loop_avoided: loop_avoided_proj });
} else {
- return false;
+ return None;
}
} else {
false
@@ -182,7 +193,7 @@ pub fn guard_exists(
};
if blah {
- return true;
+ return Some(LoopGuard { guard_if: guard_if_node, loop_entered: loop_entered_proj, loop_avoided: loop_avoided_proj });
}
@@ -218,9 +229,9 @@ pub fn guard_exists(
// FIXME: More comprehensive condition equivalance.
// Check condition equivalence:
if latch_op == guard_cond_op && guard_cond_left == latch_left && guard_cond_right == latch_right {
- return true;
+ return Some(LoopGuard { guard_if: guard_if_node, loop_entered: loop_entered_proj, loop_avoided: loop_avoided_proj });
} else {
- return false;
+ return None;
}
}
@@ -236,17 +247,69 @@ pub fn convert_to_while_loop(
) -> bool {
// FIXME: Check that Loop is simple.
-
let Some(LoopExit::Conditional { if_node, condition_node: _ }) = loop_exit.clone() else {return false};
// FIXME: Check whether the loop is guaranteed to be entered.
// i.e add a guard if needed.
- if guard_exists(editor, natural_loop, if_node) == false {
- if add_guard() == false { // If we failed to add a guard, don't convert to while loop.
- return false;
+ let guard = match get_guard(editor, natural_loop, if_node) {
+ Some(v) => v,
+ None => {
+ // FIXME: Implement add guard.
+ match add_guard() {
+ Some(v) => v,
+ None => return false
+ }
}
+ };
+
+ // Find the joining region for the guard and the loop exit.
+ // FIXME: For now, just assume its always the node following the guard loop_avoided projection. This is probably always the case.
+ let LoopGuard { guard_if, loop_entered, loop_avoided } = guard;
+ let Some(joining_region) = editor.get_users(loop_avoided).next() else {return false;};
+
+ // For PHIs in the loop (but not of the loop header), that this joining region controls, need
+ // to add a version to the loop header, initialized to the same thing as the loop non-taken, and
+ // updated when the loop is taken to be the internal version.
+ let loop_exit_proj = editor.get_users(if_node).filter(|node| !natural_loop.control[node.idx()]).next().unwrap();
+
+ // Indicies for joining phis
+ let joining_loop_avoided_idx = editor.func().nodes[joining_region.idx()].try_region().unwrap().iter().position(|pred| *pred == loop_avoided).unwrap();
+ let joining_loop_exit_idx = editor.func().nodes[joining_region.idx()].try_region().unwrap().iter().position(|pred| *pred == loop_exit_proj).unwrap();
+
+ let header_initial_idx = editor.func().nodes[natural_loop.header.idx()].try_region().unwrap().iter().position(|pred| !natural_loop.control[pred.idx()]).unwrap();
+ let header_continue_idx = editor.func().nodes[natural_loop.header.idx()].try_region().unwrap().iter().position(|pred| natural_loop.control[pred.idx()]).unwrap();
+
+ let joining_phis = editor.get_users(joining_region).filter(|node| editor.func().nodes[node.idx()].is_phi());
+
+ // If the PHI in the joining region attempts to pull from a phi on the loop_exit_idx edge, which is internal to the loop
+ // (in loop but not in loop header, add a phi to loop header)
+ struct PhiToAdd {
+ joining_phi: NodeID, //
+ internal_phi: NodeID,
+ initializer: NodeID,
}
+ let phis_to_add: Vec<_> = joining_phis.filter_map(|phi| {
+ let Node::Phi { control, ref data } = &editor.func().nodes[phi.idx()] else {unreachable!()};
+
+ // control is joining_region.
+
+ let loop_exit_node = data[joining_loop_exit_idx];
+
+ let Node::Phi {control: loop_phi_control, data: ref _loop_phi_data} = editor.func().nodes[loop_exit_node.idx()] else {return None};
+
+ if loop_phi_control == natural_loop.header {return None};
+
+ if !natural_loop.control[loop_phi_control.idx()] {
+ todo!("WHAT")
+ }
+
+ // Initializer is whatever the phi in the joining region takes if the loop is never run.
+ let initializer = data[joining_loop_avoided_idx];
+
+ Some(PhiToAdd {joining_phi: phi, internal_phi: loop_exit_node, initializer: initializer })
+ }).collect();
+
// Get the control in between the header and before the condition,
// If the header -> if, then there is no control before the condition, so it's a while loop.
@@ -279,6 +342,19 @@ pub fn convert_to_while_loop(
.next()
.unwrap();
+
+ for phi_to_add in phis_to_add {
+ editor.edit(|mut edit| {
+ let PhiToAdd { joining_phi, internal_phi, initializer } = phi_to_add;
+ let mut data = Box::new([NodeID::new(0); 2]);
+ data[header_initial_idx] = initializer;
+ data[header_continue_idx] = internal_phi;
+ let node = Node::Phi { control: natural_loop.header, data };
+ let new_phi = edit.add_node(node);
+ edit.replace_all_uses_where(internal_phi, new_phi, |usee| *usee == joining_phi)
+ });
+ }
+
editor.edit(|mut edit| {
// Have fun understanding this!
edit = edit.replace_all_uses(loop_continue_projection, loop_before_if_last)?;
diff --git a/hercules_opt/src/pass.rs b/hercules_opt/src/pass.rs
index bce3c056..411db442 100644
--- a/hercules_opt/src/pass.rs
+++ b/hercules_opt/src/pass.rs
@@ -1165,8 +1165,9 @@ impl PassManager {
self.module.types = types_ref.take();
self.module.functions[idx].delete_gravestones();
- }
+ }
self.clear_analyses();
+ break;
}
}
}
diff --git a/juno_frontend/src/lib.rs b/juno_frontend/src/lib.rs
index 64b21d9c..877a2e3b 100644
--- a/juno_frontend/src/lib.rs
+++ b/juno_frontend/src/lib.rs
@@ -179,6 +179,7 @@ pub fn compile_ir(
add_pass!(pm, verify, DCE);
add_pass!(pm, verify, GVN);
add_pass!(pm, verify, DCE);
+ pm.add_pass(hercules_opt::pass::Pass::Serialize(module_name.clone() + ".module"));
if x_dot {
pm.add_pass(hercules_opt::pass::Pass::Xdot(true));
}
diff --git a/juno_samples/nested_ccp/build.rs b/juno_samples/nested_ccp/build.rs
index c5c7ca6a..dc320096 100644
--- a/juno_samples/nested_ccp/build.rs
+++ b/juno_samples/nested_ccp/build.rs
@@ -2,6 +2,7 @@ use juno_build::JunoCompiler;
fn main() {
JunoCompiler::new()
+ .x_dot(false)
.file_in_src("nested_ccp.jn")
.unwrap()
.build()
--
GitLab
From 99ac6c10678fdc2bdde81ac6ceb270f2a7a37ab4 Mon Sep 17 00:00:00 2001
From: Xavier Routh <xrouth2@illinois.edu>
Date: Wed, 15 Jan 2025 13:42:46 -0500
Subject: [PATCH 33/68] test build
---
hercules_opt/src/loop_canonicalization.rs | 454 ++++++++++++++++++----
hercules_opt/src/pass.rs | 1 -
2 files changed, 389 insertions(+), 66 deletions(-)
diff --git a/hercules_opt/src/loop_canonicalization.rs b/hercules_opt/src/loop_canonicalization.rs
index 9f1e6fdb..85538c46 100644
--- a/hercules_opt/src/loop_canonicalization.rs
+++ b/hercules_opt/src/loop_canonicalization.rs
@@ -36,6 +36,7 @@ use crate::FunctionEditor;
use crate::Loop;
use crate::LoopExit;
use crate::LoopVariance;
+use crate::LoopVarianceInfo;
use self::hercules_ir::LoopTree;
@@ -67,25 +68,398 @@ pub fn loop_canonicalization(
for l in natural_loops {
let natural_loop = &Loop { header: l.0, control: l.1.clone()};
- // Can't canonicalize loops where there is a use of the IV after the region that increments the IV
- // but before the guard, which happens in do-while loops.
if canonicalize_loop(editor, loop_exits.get(&l.0).copied(), fork_join_map, natural_loop) {
return true;
}
- // Can't convert while loops w/ weird guards?
- if convert_to_while_loop(editor, natural_loop, loop_exits.get(&l.0).copied(), false) {
- return true;
- }
+ // // Can't canonicalize loops where there is a use of the IV after the region that increments the IV
+ // // but before the guard, which happens in do-while loops.
+ // if canonicalize_loop_old(editor, loop_exits.get(&l.0).copied(), fork_join_map, natural_loop) {
+ // return true;
+ // }
+ // // Can't convert while loops w/ weird guards?
+ // if convert_to_while_loop(editor, natural_loop, loop_exits.get(&l.0).copied(), false) {
+ // return true;
+ // }
}
return false;
}
-// Returns false if a guard can't be added, true if a guard is succesffuly added.
-// FIXME: Implement this.
-pub fn add_guard() -> Option<LoopGuard> {
- None
+
+
+pub fn has_alternate_bounds(
+ function: &Function,
+ l: &Loop,
+ condition_node: NodeID,
+ basic_ivs: &[BasicInductionVariable],
+ loop_variance: LoopVarianceInfo,
+) -> Option<(NodeID, BasicInductionVariable)> // iv_expression, base_iv
+{
+ // Analyze Loop Bound (pattern match w/ )
+ let alternate_iv = basic_ivs.iter().filter_map(|iv|
+ {
+ match &function.nodes[condition_node.idx()] {
+ Node::Start => todo!(),
+ Node::Phi { control, data } => todo!(),
+ Node::Reduce { control, init, reduct } => todo!(),
+ Node::Parameter { index } => todo!(),
+ Node::Constant { id } => todo!(),
+ Node::Unary { input, op } => todo!(),
+ Node::Ternary { first, second, third, op } => todo!(),
+ Node::Binary { left, right, op } => {
+ match op {
+ BinaryOperator::LT => {
+ // Check for a loop guard condition.
+ // ADDME: Check if the condition is *normal* already, and then check if the rest of the loop is normal.
+
+ // left + 1 < right
+ let Node::Binary { left: inner_left, right: inner_right, op: inner_op } = function.nodes[left.idx()] else {return None};
+ if inner_op == BinaryOperator::Add &&
+ ((inner_left == iv.update && inner_right == iv.node) ||
+ (inner_right == iv.update && inner_left == iv.node)) &&
+ loop_variance.map[right.idx()] == LoopVariance::Invariant
+ {
+ return Some((left.clone(), iv.clone()));
+ } else {
+ return None;
+ }
+
+ }
+ BinaryOperator::LTE => todo!(),
+ BinaryOperator::GT => todo!(),
+ BinaryOperator::GTE => todo!(),
+ BinaryOperator::EQ => todo!(),
+ BinaryOperator::NE => todo!(),
+ _ => None,
+ }
+
+ }
+ _ => None,
+ }
+ }
+ ).next();
+ alternate_iv
+}
+
+pub fn canonicalize_loop(
+ editor: &mut FunctionEditor,
+ loop_exit: Option<LoopExit>,
+ fork_join_map: &HashMap<NodeID, NodeID>,
+ l: &Loop,
+) -> bool {
+
+ // If the loop has no control before the condition:
+ // - Canonicalize by changing the bounds, and replacing outside-loop uses
+ // with the last phi value.
+ // If the loop has control before the condition:
+ // - Change bounds, replace outside-loop uses with last phi value
+ // - Move control to after the condition (convert to while loop)
+ let Some(loop_condition) = loop_exit else {return false};
+ let LoopExit::Conditional { if_node: loop_if, condition_node } = loop_condition.clone() else {return false};
+
+
+ let is_do_while = !editor.get_uses(loop_if).contains(&l.header);
+
+ let guard = get_guard(editor, l, loop_if);
+
+ if guard.is_none() && is_do_while {
+ return false;
+ }
+
+ // Compute loop variance
+ let loop_variance = compute_loop_variance(&editor, &l);
+
+ // Compute induction vars
+ let basic_ivs = compute_induction_vars(editor.func(), &l, &loop_variance);
+
+ let Some((iv_expression, base_iv)) = has_alternate_bounds(editor.func(), l, condition_node, &basic_ivs.as_slice(), loop_variance) else {return false};
+
+ let iv_expression = iv_expression.clone();
+ let base_iv = base_iv.clone();
+
+ // If there are users of iv_expression (not just the loop bound condition), then abort
+ if editor.get_users(iv_expression).count() > 2 {return false};
+
+ // Replace external_uses uses of data with phi.
+ // Panic on internal uses.
+ struct PhiDataCycle {
+ phi: NodeID,
+ data: NodeID,
+ external_uses: Vec<NodeID>,
+ internal_uses: Vec<NodeID>
+ }
+
+ // The initiailzer position for all loop phis.
+ let loop_phi_init_idx = editor.get_uses(l.header)
+ .position(|node| !l.control[node.idx()] // Position of the predecessor (used by header but not in loop body.)
+ ).unwrap();
+
+ let data_use_locations = get_loop_data_location(editor, l);
+
+ let mut changed = false;
+
+ // Check all PHIs controlled by the loop
+ let loop_phis: Option<Vec<PhiDataCycle>> = editor.get_users(l.header).filter(|n| editor.func().nodes[n.idx()].is_phi())
+ .filter(|phi| *phi != base_iv.node)
+ .map(|phi: NodeID| {
+
+ // There should only be one candidate data,
+ // but possibly multiple external uses. z
+
+ let initializer_node_id = editor.func().nodes[phi.idx()].try_phi().unwrap().1[loop_phi_init_idx];
+
+ // Check if any use is in a cycle w/ the phi.
+ let mut data_cycles =
+ editor.get_uses(phi)
+ .filter(|phi_use|
+ *phi_use != initializer_node_id) // Not the initializer.
+ .filter_map(|phi_use| {
+
+ // If the data node is not in a cycle w/ the phi,
+ if !walk_all_uses(phi_use, editor).contains(&phi) {return None};
+
+ // Find users of phi_use that are outside the loop, these we will change to use the phi.
+ let (internal_uses, external_uses) = editor
+ .get_users(phi_use)
+ .filter_map(|data_user| {
+ Some(data_user)
+ }).partition(|data_user| {
+ match data_use_locations[data_user.idx()] {
+ DataUseLoopLocation::Unknown => todo!(),
+ DataUseLoopLocation::Inside => true,
+ DataUseLoopLocation::Outside => false,
+ }
+ });
+
+ Some((phi_use, internal_uses, external_uses))
+ });
+
+
+ let Some((data, internal_uses, external_uses)) = data_cycles.next() else {
+ return None;
+ };
+
+ // There should only be one cycle
+ if data_cycles.next().is_some() {
+ return None;
+ }
+
+ Some(PhiDataCycle {
+ phi,
+ data,
+ external_uses,
+ internal_uses,
+ })
+ }).collect();
+
+ // If any PHIs are invalid, (not in cycles, )
+ let Some(loop_phis) = loop_phis else {
+ return false;
+ };
+
+ // Make sure all phi data cycles are fully contained.
+ let used_outside_loop = loop_phis.iter()
+ .any(|transform_info: &PhiDataCycle|
+ {
+ let PhiDataCycle { phi, data, external_uses, internal_uses } = transform_info;
+
+ // Check usres of the PHI, make sure they aren't outside the loop
+ // Unless they would be outside because of the use we are going to get rid of,
+ // need a more complicated use location analysis for this.
+ if editor.get_users(*phi)
+ .any(|node|
+ {
+ if node == *data {
+ return false;
+ }
+
+ let stop_on: HashSet<NodeID> = editor.node_ids().filter(|n| {
+ if *n == *data {
+ return true
+ };
+
+ let node_data = &editor.func().nodes[n.idx()];
+
+ // Stop on Control.
+ if node_data.is_control() {
+ return true;
+ }
+ // Stop on PHIs.
+ if node_data.is_phi() {
+ // Need to maybe not stop on PHIs, but only stop on some of their incoming edges,
+ // depending
+ let control = node_data.try_phi().unwrap().0;
+ return l.control[control.idx()];
+ }
+
+ // Stop on Reduces.
+ if node_data.is_reduce() {
+ let control = node_data.try_reduce().unwrap().0;
+ return l.control[control.idx()];
+ }
+
+ false
+ }).collect();
+
+ let outside_loop = editor.node_ids().filter(|n| editor.func().nodes[n.idx()].is_control() && !l.control[n.idx()]);
+
+ // If any uses are control nodes *outside* the loop,
+ let node_uses = walk_all_users_stop_on(node, editor, stop_on);
+
+ // TODO: Do intersection lazily?
+ let set1: HashSet<_> = HashSet::from_iter(outside_loop);
+ let set2: HashSet<_> = HashSet::from_iter(node_uses);
+
+ // If there is no intersection, then it is inside the loop
+ if set1.intersection(&set2).next().is_none() {
+ false // No intersection, so all users of this phi are good
+ } else {
+ true // Intersection, so some user of this phi leaves the loop, and we can't fix it by transforming.
+ }
+ }
+ ) {
+ return true;
+ } else {
+ return false;
+ }
+ });
+
+ if used_outside_loop {
+ return false;
+ }
+
+ // See if we can convert to do-while, if we can't transform anything.
+ if is_do_while {
+ let if_node = loop_if;
+ let natural_loop = l.clone();
+
+ let guard = match guard {
+ Some(v) => v,
+ None => return false,
+ };
+
+ let LoopGuard { guard_if, loop_entered, loop_avoided } = guard;
+ let Some(joining_region) = editor.get_users(loop_avoided).next() else {return false;};
+
+ // For PHIs in the loop (but not of the loop header), that this joining region controls, need
+ // to add a version to the loop header, initialized to the same thing as the loop non-taken, and
+ // updated when the loop is taken to be the internal version.
+ let loop_exit_proj = editor.get_users(if_node).filter(|node| !natural_loop.control[node.idx()]).next().unwrap();
+
+ // Indicies for joining phis
+ let joining_loop_avoided_idx = editor.func().nodes[joining_region.idx()].try_region().unwrap().iter().position(|pred| *pred == loop_avoided).unwrap();
+ let joining_loop_exit_idx = editor.func().nodes[joining_region.idx()].try_region().unwrap().iter().position(|pred| *pred == loop_exit_proj).unwrap();
+
+ let header_initial_idx = editor.func().nodes[natural_loop.header.idx()].try_region().unwrap().iter().position(|pred| !natural_loop.control[pred.idx()]).unwrap();
+ let header_continue_idx = editor.func().nodes[natural_loop.header.idx()].try_region().unwrap().iter().position(|pred| natural_loop.control[pred.idx()]).unwrap();
+
+ let joining_phis = editor.get_users(joining_region).filter(|node| editor.func().nodes[node.idx()].is_phi());
+
+ // If the PHI in the joining region attempts to pull from a phi on the loop_exit_idx edge, which is internal to the loop
+ // (in loop but not in loop header, add a phi to loop header)
+ struct PhiToAdd {
+ joining_phi: NodeID, //
+ internal_phi: NodeID,
+ initializer: NodeID,
+ }
+
+ let phis_to_add: Vec<_> = joining_phis.filter_map(|phi| {
+ let Node::Phi { control, ref data } = &editor.func().nodes[phi.idx()] else {unreachable!()};
+
+ // control is joining_region.
+
+ let loop_exit_node = data[joining_loop_exit_idx];
+
+ let Node::Phi {control: loop_phi_control, data: ref _loop_phi_data} = editor.func().nodes[loop_exit_node.idx()] else {return None};
+
+ if loop_phi_control == natural_loop.header {return None};
+
+ if !natural_loop.control[loop_phi_control.idx()] {
+ todo!("WHAT")
+ }
+
+ // Initializer is whatever the phi in the joining region takes if the loop is never run.
+ let initializer = data[joining_loop_avoided_idx];
+
+ Some(PhiToAdd {joining_phi: phi, internal_phi: loop_exit_node, initializer: initializer })
+ }).collect();
+
+ // Get the control in between the header and before the condition,
+
+ // If the header -> if, then there is no control before the condition, so it's a while loop.
+ if editor.get_uses(if_node).contains(&natural_loop.header) {
+ return false
+ }
+
+ let loop_before_if_first = editor.get_users(natural_loop.header)
+ .filter(|id| natural_loop.control[id.idx()])
+ .next()
+ .unwrap();
+
+ let loop_before_if_last = editor.get_uses(if_node).next().unwrap();
+
+ // assert_ne!(loop_before_if_first, loop_before_if_last);
+
+ let loop_exit_projection = editor.get_users(if_node)
+ .filter(|id| !natural_loop.control[id.idx()])
+ .next()
+ .unwrap();
+
+ let loop_continue_projection = editor.get_users(if_node)
+ .filter(|id| natural_loop.control[id.idx()])
+ .next()
+ .unwrap();
+
+ // Control goes after the loop_continue_projection, and before whatever is after loop_continue_projection.
+ let loop_body_last = editor.get_uses(natural_loop.header)
+ .filter(|id| natural_loop.control[id.idx()])
+ .next()
+ .unwrap();
+
+
+ for phi_to_add in phis_to_add {
+ editor.edit(|mut edit| {
+ let PhiToAdd { joining_phi, internal_phi, initializer } = phi_to_add;
+ let mut data = Box::new([NodeID::new(0); 2]);
+ data[header_initial_idx] = initializer;
+ data[header_continue_idx] = internal_phi;
+ let node = Node::Phi { control: natural_loop.header, data };
+ let new_phi = edit.add_node(node);
+ edit.replace_all_uses_where(internal_phi, new_phi, |usee| *usee == joining_phi)
+ });
+ println!("adding phi");
+ }
+
+ editor.edit(|mut edit| {
+ // Have fun understanding this!
+ edit = edit.replace_all_uses(loop_continue_projection, loop_before_if_last)?;
+ edit = edit.replace_all_uses_where(natural_loop.header, loop_continue_projection, |usee| *usee == loop_before_if_first)?;
+ edit = edit.replace_all_uses_where(loop_before_if_last, natural_loop.header, |usee| *usee == if_node)?;
+
+ Ok(edit)
+ });
+ }
+
+ // ========= Do transformation ===========:
+
+ // Change loop bounds
+ editor.edit(|edit|
+ edit.replace_all_uses_where(iv_expression, base_iv.node, |usee| *usee == condition_node)
+ );
+
+
+ for transform_info in loop_phis {
+ editor.edit(|mut edit|
+ {
+ edit.replace_all_uses_where(transform_info.data, transform_info.phi, |usee| transform_info.external_uses.contains(usee))
+ }
+ );
+ }
+
+ true
+
+
}
pub struct LoopGuard {
@@ -253,13 +627,7 @@ pub fn convert_to_while_loop(
// i.e add a guard if needed.
let guard = match get_guard(editor, natural_loop, if_node) {
Some(v) => v,
- None => {
- // FIXME: Implement add guard.
- match add_guard() {
- Some(v) => v,
- None => return false
- }
- }
+ None => return false,
};
// Find the joining region for the guard and the loop exit.
@@ -271,7 +639,7 @@ pub fn convert_to_while_loop(
// to add a version to the loop header, initialized to the same thing as the loop non-taken, and
// updated when the loop is taken to be the internal version.
let loop_exit_proj = editor.get_users(if_node).filter(|node| !natural_loop.control[node.idx()]).next().unwrap();
-
+
// Indicies for joining phis
let joining_loop_avoided_idx = editor.func().nodes[joining_region.idx()].try_region().unwrap().iter().position(|pred| *pred == loop_avoided).unwrap();
let joining_loop_exit_idx = editor.func().nodes[joining_region.idx()].try_region().unwrap().iter().position(|pred| *pred == loop_exit_proj).unwrap();
@@ -353,6 +721,7 @@ pub fn convert_to_while_loop(
let new_phi = edit.add_node(node);
edit.replace_all_uses_where(internal_phi, new_phi, |usee| *usee == joining_phi)
});
+ println!("adding phi");
}
editor.edit(|mut edit| {
@@ -363,7 +732,6 @@ pub fn convert_to_while_loop(
Ok(edit)
});
-
true
}
@@ -372,7 +740,7 @@ pub fn convert_to_while_loop(
// suceeded: bool,
// }
-pub fn canonicalize_loop(
+pub fn canonicalize_loop_old(
editor: &mut FunctionEditor,
loop_exit: Option<LoopExit>,
fork_join_map: &HashMap<NodeID, NodeID>,
@@ -403,51 +771,7 @@ pub fn canonicalize_loop(
// Compute induction vars
let basic_ivs = compute_induction_vars(function, &l, &loop_variance);
- // Analyze Loop Bound (pattern match w/ )
- let alternate_iv = basic_ivs.iter().filter_map(|iv|
- {
- match &function.nodes[condition_node.idx()] {
- Node::Start => todo!(),
- Node::Phi { control, data } => todo!(),
- Node::Reduce { control, init, reduct } => todo!(),
- Node::Parameter { index } => todo!(),
- Node::Constant { id } => todo!(),
- Node::Unary { input, op } => todo!(),
- Node::Ternary { first, second, third, op } => todo!(),
- Node::Binary { left, right, op } => {
- match op {
- BinaryOperator::LT => {
- // Check for a loop guard condition.
- // ADDME: Check if the condition is *normal* already, and then check if the rest of the loop is normal.
-
- // left + 1 < right
- let Node::Binary { left: inner_left, right: inner_right, op: inner_op } = function.nodes[left.idx()] else {return None};
- if inner_op == BinaryOperator::Add &&
- ((inner_left == iv.update && inner_right == iv.node) ||
- (inner_right == iv.update && inner_left == iv.node)) &&
- loop_variance.map[right.idx()] == LoopVariance::Invariant
- {
- return Some((left, iv));
- } else {
- return None;
- }
-
- }
- BinaryOperator::LTE => todo!(),
- BinaryOperator::GT => todo!(),
- BinaryOperator::GTE => todo!(),
- BinaryOperator::EQ => todo!(),
- BinaryOperator::NE => todo!(),
- _ => None,
- }
-
- }
- _ => None,
- }
- }
- ).next();
-
- let Some((iv_expression, base_iv)) = alternate_iv else {return false};
+ let Some((iv_expression, base_iv)) = has_alternate_bounds(editor.func(), l, condition_node, &basic_ivs, loop_variance) else {return false};
let iv_expression = iv_expression.clone();
let base_iv = base_iv.clone();
diff --git a/hercules_opt/src/pass.rs b/hercules_opt/src/pass.rs
index 411db442..08fd2bdc 100644
--- a/hercules_opt/src/pass.rs
+++ b/hercules_opt/src/pass.rs
@@ -1167,7 +1167,6 @@ impl PassManager {
self.module.functions[idx].delete_gravestones();
}
self.clear_analyses();
- break;
}
}
}
--
GitLab
From 784f26de9839d9baf94d7344118b7a82649c31f6 Mon Sep 17 00:00:00 2001
From: Xavier Routh <xrouth2@illinois.edu>
Date: Mon, 20 Jan 2025 16:51:26 -0600
Subject: [PATCH 34/68] canonicalization fixes
---
hercules_ir/src/verify.rs | 1 +
hercules_opt/src/fork_transforms.rs | 10 +-
hercules_opt/src/forkify.rs | 113 +--
hercules_opt/src/gcm.rs | 56 +-
hercules_opt/src/ivar.rs | 133 +--
hercules_opt/src/loop_canonicalization.rs | 921 ++++++++----------
hercules_opt/src/pass.rs | 5 +-
.../hercules_interpreter/src/interpreter.rs | 18 +-
.../hercules_interpreter/src/value.rs | 10 +
hercules_test/hercules_tests/output.pdf | Bin 0 -> 28792 bytes
.../hercules_tests/tests/loop_tests.rs | 111 ++-
.../alternate_bounds_use_after_loop.hir | 5 +-
.../loop_analysis/loop_trip_count.hir | 19 +
13 files changed, 649 insertions(+), 753 deletions(-)
create mode 100644 hercules_test/hercules_tests/output.pdf
create mode 100644 hercules_test/test_inputs/loop_analysis/loop_trip_count.hir
diff --git a/hercules_ir/src/verify.rs b/hercules_ir/src/verify.rs
index 0d7e345f..81818794 100644
--- a/hercules_ir/src/verify.rs
+++ b/hercules_ir/src/verify.rs
@@ -123,6 +123,7 @@ fn verify_structure(
match function.nodes[user.idx()] {
Node::Parameter { index: _ }
| Node::Constant { id: _ }
+ | Node::Undef { ty: _ }
| Node::DynamicConstant { id: _ } => {}
_ => {
if function.nodes[user.idx()].is_control() {
diff --git a/hercules_opt/src/fork_transforms.rs b/hercules_opt/src/fork_transforms.rs
index bbefcf83..19322c01 100644
--- a/hercules_opt/src/fork_transforms.rs
+++ b/hercules_opt/src/fork_transforms.rs
@@ -379,11 +379,11 @@ pub fn fork_coalesce(
let fork_joins: Vec<_> = fork_joins.collect();
- let inner = fork_joins[0].0;
- let outer = fork_joins[1].0;
-
- fork_coalesce_helper(editor, outer, inner, fork_join_map, reduce_cycles);
-
+ if fork_joins.len() > 1 {
+ let inner = fork_joins[0].0;
+ let outer = fork_joins[1].0;
+ fork_coalesce_helper(editor, outer, inner, fork_join_map, reduce_cycles);
+ }
}
/** Opposite of fork split, takes two fork-joins
diff --git a/hercules_opt/src/forkify.rs b/hercules_opt/src/forkify.rs
index 5a23db11..e963dcbc 100644
--- a/hercules_opt/src/forkify.rs
+++ b/hercules_opt/src/forkify.rs
@@ -17,16 +17,15 @@ use self::hercules_ir::Subgraph;
use self::hercules_ir::control_subgraph;
use crate::bound_induction_variables;
-use crate::compute_induction_vars;
+use crate::calculate_loop_nodes;
+use crate::compute_basic_induction_vars;
use crate::compute_loop_variance;
use crate::get_loop_exit_conditions;
-use crate::loop_data_location;
use crate::walk_all_users;
use crate::walk_all_users_stop_on;
use crate::walk_all_uses;
use crate::walk_all_uses_stop_on;
use crate::BasicInductionVariable;
-use crate::DataUseLoopLocation;
use crate::DenseNodeMap;
use crate::FunctionEditor;
use crate::Loop;
@@ -44,8 +43,6 @@ pub fn forkify(
fork_join_map: &HashMap<NodeID, NodeID>,
loops: &LoopTree,
) -> bool {
- // println!("loops: {:?} ", loops.bottom_up_loops());
-
let natural_loops = loops
.bottom_up_loops()
.into_iter()
@@ -144,7 +141,7 @@ pub fn forkify_loop(
let loop_variance = compute_loop_variance(editor, &l);
// Compute induction vars
- let basic_ivs = compute_induction_vars(function, &l, &loop_variance);
+ let basic_ivs = compute_basic_induction_vars(function, &l, &loop_variance);
// Compute loop bounds
let Some(basic_iv) = bound_induction_variables(function, &control_subgraph, &l,
@@ -156,7 +153,7 @@ pub fn forkify_loop(
.filter(|id| *id != basic_iv.node)
.collect();
- let reductionable_phis: Vec<_> = analyze_phis(&editor, &candidate_phis).into_iter().collect();
+ let reductionable_phis: Vec<_> = analyze_phis(&editor, &l, &candidate_phis).into_iter().collect();
// Check for a constant used as loop bound.
let Some(bound) = basic_iv.bound else {return false};
@@ -268,14 +265,7 @@ pub fn forkify_loop(
let dimension = factors.len() - 1;
- let mut iv_use_location: DenseNodeMap<DataUseLoopLocation> = vec![DataUseLoopLocation::Unknown; function.nodes.len()];
-
- for node_use in editor.get_users(basic_iv.node) {
- let mut visited = vec![false; function.nodes.len()];
- iv_use_location[node_use.idx()] = loop_data_location(&editor, node_use, &l.get_all_nodes(), &mut visited)
- }
-
- // println!("loop datalocation: {:?}", iv_use_location );
+ let loop_nodes = calculate_loop_nodes(editor, l);
// Create ThreadID
editor.edit(
@@ -297,21 +287,13 @@ pub fn forkify_loop(
// Replace uses that are inside with the thread id
edit = edit.replace_all_uses_where(basic_iv.node, thread_id_id, |node| {
- match iv_use_location[node.idx()] {
- DataUseLoopLocation::Unknown => todo!(),
- DataUseLoopLocation::Inside => true,
- DataUseLoopLocation::Outside => false,
- }
+ loop_nodes.contains(node)
})?;
// Replace uses that are outside with the DC
let bound_dc_node = edit.add_node(Node::DynamicConstant { id: bound_dc_id });
edit = edit.replace_all_uses_where(basic_iv.node, bound_dc_node, |node| {
- match iv_use_location[node.idx()] {
- DataUseLoopLocation::Unknown => todo!(),
- DataUseLoopLocation::Inside => false,
- DataUseLoopLocation::Outside => true,
- }
+ !loop_nodes.contains(node)
})?;
edit.delete_node(basic_iv.node)
@@ -385,7 +367,6 @@ pub fn forkify_loop(
}
);
- // TODO: (@xrouth) Wtf is this?
// DCE should get these, but delete them ourselves because we are nice :)
editor.edit(
|mut edit| {
@@ -426,7 +407,7 @@ impl LoopPHI {
- Every cycle *in the loop* containing the PHI does not contain any other PHI. Or something, IDK.
-
We also need to make it not control dependent on anything other than the loop header. */
-pub fn analyze_phis<'a>(editor: &'a FunctionEditor, phis: &'a [NodeID])
+pub fn analyze_phis<'a>(editor: &'a FunctionEditor, natural_loop: &'a Loop, phis: &'a [NodeID])
-> impl Iterator<Item = LoopPHI> + 'a
{
let function = editor.func();
@@ -434,71 +415,43 @@ pub fn analyze_phis<'a>(editor: &'a FunctionEditor, phis: &'a [NodeID])
// // FIXME: (@xrouth)
// // Check that the PHI actually has a cycle back to it.
phis.into_iter().map(move |phi| {
- // // do WFS
- // let mut other_phi_on_path: DenseNodeMap<bool> = vec![false; function.nodes.len()];
-
- // let mut bag_of_control_nodes: Vec<NodeID> = vec![*phi];
- // let mut visited: DenseNodeMap<bool> = vec![false; function.nodes.len()];
-
- // while !bag_of_control_nodes.is_empty() {
- // let node = bag_of_control_nodes.pop().unwrap();
-
- // if visited[node.idx()] {
- // continue;
- // }
- // visited[node.idx()] = true;
-
- // if function.nodes[node.idx()].is_phi() && node != *phi{
- // other_phi_on_path[node.idx()] = true;
- // }
-
- // for succ in editor.get_users(node) {
- // // If we change, mark as unvisited.
- // if other_phi_on_path[node.idx()] && other_phi_on_path[succ.idx()] == false {
- // other_phi_on_path[succ.idx()] = true;
- // visited[succ.idx()] = false;
- // bag_of_control_nodes.push(succ.clone());
- // }
- // }
- // }
-
- // if other_phi_on_path[phi.idx()] == false {
- // LoopPHI::Reductionable(*phi)
- // } else {
- // LoopPHI::LoopDependant(*phi)
- // }
-
- let stop_on: HashSet<NodeID> = editor.node_ids().filter(|n| {
- if n == phi {
- return false
- };
-
- let node_data = &editor.func().nodes[n.idx()];
+ let stop_on: HashSet<NodeID> = editor.node_ids().filter(|node| {
+ let data = &editor.func().nodes[node.idx()];
- // Stop on Control.
- if node_data.is_control() {
- return true;
+ // External Phi
+ if let Node::Phi { control, data } = data {
+ if !natural_loop.control[control.idx()] {
+ return true;
+ }
+ }
+ // External Reduce
+ if let Node::Reduce { control, init, reduct} = data {
+ if !natural_loop.control[control.idx()] {
+ return true;
+ }
}
- // Stop on PHIs.
- if node_data.is_phi() {
- return true;
- // Need to maybe not stop on PHIs, but only stop on some of their incoming edges,
- // depending
- // let control = node_data.try_phi().unwrap().0;
- // return l.control[control.idx()];
+
+ // External Control
+ if data.is_control() && !natural_loop.control[node.idx()] {
+ return true
}
- false
+
+ return false;
}).collect();
// TODO: We may need to stop on exiting the loop for looking for data cycles.
let uses = walk_all_uses_stop_on(*phi, editor, stop_on.clone());
- let users = walk_all_users_stop_on(*phi, editor, stop_on);
+ let users = walk_all_users_stop_on(*phi, editor, stop_on.clone()).filter(|node|
+ {
+ // Get rid of nodes in stop_on
+ !stop_on.contains(node)
+ });
let set1: HashSet<_> = HashSet::from_iter(uses);
let set2: HashSet<_> = HashSet::from_iter(users);
- // If there are any cycles containing a phi
+ // If there are any cycles containing a phi other than itself.
if set1.intersection(&set2).any(|node| editor.func().nodes[node.idx()].is_phi() && node != phi) {
LoopPHI::LoopDependant(*phi)
} else {
diff --git a/hercules_opt/src/gcm.rs b/hercules_opt/src/gcm.rs
index a7df9bd9..99406f07 100644
--- a/hercules_opt/src/gcm.rs
+++ b/hercules_opt/src/gcm.rs
@@ -329,34 +329,34 @@ fn basic_blocks(
.chain(schedule_late, schedule_early);
if let Some(mut location) = chain.next() {
- while let Some(control_node) = chain.next() {
- // If the next node further up the dominator tree is in a shallower
- // loop nest or if we can get out of a reduce loop when we don't
- // need to be in one, place this data node in a higher-up location.
- let old_nest = loops
- .header_of(location)
- .map(|header| loops.nesting(header).unwrap());
- let new_nest = loops
- .header_of(control_node)
- .map(|header| loops.nesting(header).unwrap());
- let shallower_nest = if let (Some(old_nest), Some(new_nest)) = (old_nest, new_nest)
- {
- old_nest > new_nest
- } else {
- // If the new location isn't a loop, it's nesting level should
- // be considered "shallower" if the current location is in a
- // loop.
- old_nest.is_some()
- };
- // This will move all nodes that don't need to be in reduce loops
- // outside of reduce loops. Nodes that do need to be in a reduce
- // loop use the reduce node forming the loop, so the dominator chain
- // will consist of one block, and this loop won't ever iterate.
- let currently_at_join = function.nodes[location.idx()].is_join();
- if shallower_nest || currently_at_join {
- location = control_node;
- }
- }
+ // while let Some(control_node) = chain.next() {
+ // // If the next node further up the dominator tree is in a shallower
+ // // loop nest or if we can get out of a reduce loop when we don't
+ // // need to be in one, place this data node in a higher-up location.
+ // let old_nest = loops
+ // .header_of(location)
+ // .map(|header| loops.nesting(header).unwrap());
+ // let new_nest = loops
+ // .header_of(control_node)
+ // .map(|header| loops.nesting(header).unwrap());
+ // let shallower_nest = if let (Some(old_nest), Some(new_nest)) = (old_nest, new_nest)
+ // {
+ // old_nest > new_nest
+ // } else {
+ // // If the new location isn't a loop, it's nesting level should
+ // // be considered "shallower" if the current location is in a
+ // // loop.
+ // old_nest.is_some()
+ // };
+ // // This will move all nodes that don't need to be in reduce loops
+ // // outside of reduce loops. Nodes that do need to be in a reduce
+ // // loop use the reduce node forming the loop, so the dominator chain
+ // // will consist of one block, and this loop won't ever iterate.
+ // let currently_at_join = function.nodes[location.idx()].is_join();
+ // if shallower_nest || currently_at_join {
+ // location = control_node;
+ // }
+ // }
bbs[id.idx()] = Some(location);
num_skip_iters = 0;
diff --git a/hercules_opt/src/ivar.rs b/hercules_opt/src/ivar.rs
index 608e0d31..60805efd 100644
--- a/hercules_opt/src/ivar.rs
+++ b/hercules_opt/src/ivar.rs
@@ -3,7 +3,7 @@ extern crate slotmap;
extern crate bitvec;
extern crate nestify;
-use std::collections::{BTreeMap, HashMap, VecDeque};
+use std::collections::{BTreeMap, HashMap, HashSet, VecDeque};
use self::nestify::nest;
@@ -81,96 +81,54 @@ pub struct BasicInductionVariable {
}
} // nest
-/** Provides a utility to answer the question whether a data node is entirely contained within a loop or not.
-If the node has no uses outside of the loop,
-loop transformations are free to get rid of it.
-looop
-Returns a map from Nodes -> bool,
-- True means the node does not use any values that are in the loop.
-- False means the node is outside the loop.
-*/
-
-// Buggy scenario:
-// What if a node has two uses, one is the IV of a loop,
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub enum DataUseLoopLocation {
- Unknown,
- Inside,
- Outside,
-}
-
-// FIXME: This is a mess.
-// A user is 'after' the loop is finished if we walk the users of it, (or itself), and
-// any control node on the frontier of control nodes (don't go through users of control nodes) is
-// not in the loop body or is not the loop header.
-
-pub fn loop_data_location(editor: &FunctionEditor, node: NodeID, all_loop_nodes: &BitVec<u8, Lsb0>,
- visited: &mut DenseNodeMap<bool>
-) -> DataUseLoopLocation {
-
- let function = editor.func();
-
- if visited[node.idx()] {
- return DataUseLoopLocation::Unknown;
- }
- visited[node.idx()] = true;
+// TODO: Optimize.
+pub fn calculate_loop_nodes(
+ editor: &FunctionEditor,
+ natural_loop: &Loop,
+) -> HashSet<NodeID> {
- let node_data = &function.nodes[node.idx()];
-
- // Control node on frontier.
- if node_data.is_control() {
- return match all_loop_nodes[node.idx()] {
- true => DataUseLoopLocation::Inside,
- false => DataUseLoopLocation::Outside
- }
- }
-
- // Don't go through PHIs that are controlled by something in the loop either.
- if node_data.is_phi() {
- let control = node_data.try_phi().unwrap().0;
- return match all_loop_nodes[control.idx()] {
- true => DataUseLoopLocation::Inside,
- false => DataUseLoopLocation::Outside // FIXME: Is this the correct condition?
- }
- }
-
- // Don't go through reduces that are controlled by something in the loop
- if node_data.is_reduce() {
- let control = node_data.try_reduce().unwrap().0;
- return match all_loop_nodes[control.idx()] {
- true => DataUseLoopLocation::Inside,
- false => DataUseLoopLocation::Outside // FIXME: Is this the correct condition?
- }
- }
+ // Stop on PHIs / reduces outside of loop.
+ let stop_on: HashSet<NodeID> = editor.node_ids().filter(
+ |node|{
+ let data = &editor.func().nodes[node.idx()];
+ // External Phi
+ if let Node::Phi { control, data } = data {
+ if !natural_loop.control[control.idx()] {
+ return true;
+ }
+ }
+ // External Reduce
+ if let Node::Reduce { control, init, reduct} = data {
+ if !natural_loop.control[control.idx()] {
+ return true;
+ }
+ }
- let mut data_location = DataUseLoopLocation::Inside;
+ // External Control
+ if data.is_control() && !natural_loop.control[node.idx()] {
+ return true
+ }
- for node_user in editor.get_users(node) {
- // If any user is outside, then this node is outside, else its on inside.
- if loop_data_location(editor, node_user, &all_loop_nodes, visited) == DataUseLoopLocation::Outside {
- data_location = DataUseLoopLocation::Outside;
+ return false;
}
- }
-
- data_location
-}
-
-
-pub fn get_loop_data_location<'a>(
- editor: &'a FunctionEditor, l: &'a Loop
-) -> DenseNodeMap<DataUseLoopLocation> {
-
- let function = editor.func();
- let mut result = vec![DataUseLoopLocation::Unknown; function.nodes.len()];
-
- for node in (0..function.nodes.len()).map(NodeID::new) {
- let mut visited = vec![false; function.nodes.len()];
- result[node.idx()] = loop_data_location(&editor, node, &l.get_all_nodes(), &mut visited)
- }
-
- result
+ ).collect();
+
+ let all_users: HashSet<_> = editor.get_users(natural_loop.header).filter(|node| editor.func().nodes[node.idx()].is_phi())
+ .flat_map(|phi| walk_all_users_stop_on(phi, editor, stop_on.clone()))
+ .collect();
+
+ let all_uses: HashSet<_> = editor.get_users(natural_loop.header).filter(|node| editor.func().nodes[node.idx()].is_phi())
+ .flat_map(|phi| walk_all_uses_stop_on(phi, editor, stop_on.clone()))
+ .filter(|node|
+ {
+ // Get rid of nodes in stop_on
+ !stop_on.contains(node)
+ })
+ .collect();
+
+ all_users.intersection(&all_uses).cloned().collect()
}
/** returns PHIs that are *in* a loop */
@@ -190,7 +148,6 @@ pub fn get_all_loop_phis<'a>(function: &'a Function, l: &'a Loop) -> impl Iterat
)
}
-
// FIXME: Need a trait that Editor and Function both implement, that gives us UseDefInfo
/** Given a loop determine for each data node if the value might change upon each iteration of the loop */
@@ -325,7 +282,7 @@ pub fn get_loop_exit_conditions(function: &Function, l: &Loop, control_subgraph:
/** Add bounds to induction variables that don't have a currently known bound.
- Induction variables that aren't immediately used in a loop condition will not be bounded. For now, we don't return these at all.
- - The s*ingle* induction variable used in a loop condition will be given an appropriate bound.
+ - The single induction variable used in a loop condition will be given an appropriate bound.
Returns the single induction variable that is used in the loop exit condition, or None if something is wrong.
@@ -415,7 +372,7 @@ pub fn bound_induction_variables(function: &Function, control_subgraph: &Subgrap
None
}
-pub fn compute_induction_vars(function: &Function, l: &Loop, loop_variance: &LoopVarianceInfo)
+pub fn compute_basic_induction_vars(function: &Function, l: &Loop, loop_variance: &LoopVarianceInfo)
-> Vec<BasicInductionVariable> {
// 1) Gather PHIs contained in the loop.
diff --git a/hercules_opt/src/loop_canonicalization.rs b/hercules_opt/src/loop_canonicalization.rs
index 85538c46..ebe6669b 100644
--- a/hercules_opt/src/loop_canonicalization.rs
+++ b/hercules_opt/src/loop_canonicalization.rs
@@ -6,6 +6,9 @@ use std::collections::HashMap;
use std::collections::HashSet;
use std::iter::FromIterator;
+use hercules_ir::Constant;
+use hercules_ir::TypeID;
+
use self::nestify::nest;
use self::hercules_ir::get_uses;
@@ -23,15 +26,11 @@ use self::hercules_ir::NodeID;
use self::hercules_ir::Subgraph;
-use crate::compute_induction_vars;
+use crate::calculate_loop_nodes;
+use crate::compute_basic_induction_vars;
use crate::compute_loop_variance;
-use crate::get_loop_data_location;
use crate::get_loop_exit_conditions;
-use crate::get_all_loop_phis;
-use crate::walk_all_users_stop_on;
-use crate::walk_all_uses;
use crate::BasicInductionVariable;
-use crate::DataUseLoopLocation;
use crate::FunctionEditor;
use crate::Loop;
use crate::LoopExit;
@@ -47,8 +46,8 @@ pub fn loop_canonicalization(
control_subgraph: &Subgraph,
fork_join_map: &HashMap<NodeID, NodeID>,
loops: &LoopTree,
+ typing: &Vec<TypeID>,
) -> bool {
- // println!("loops: {:?} ", loops.bottom_up_loops());
let natural_loops = loops
.bottom_up_loops()
@@ -67,395 +66,246 @@ pub fn loop_canonicalization(
for l in natural_loops {
let natural_loop = &Loop { header: l.0, control: l.1.clone()};
-
- if canonicalize_loop(editor, loop_exits.get(&l.0).copied(), fork_join_map, natural_loop) {
+ if canonicalize_loop(editor, loop_exits.get(&l.0).copied(), fork_join_map, natural_loop, typing) {
return true;
}
- // // Can't canonicalize loops where there is a use of the IV after the region that increments the IV
- // // but before the guard, which happens in do-while loops.
- // if canonicalize_loop_old(editor, loop_exits.get(&l.0).copied(), fork_join_map, natural_loop) {
- // return true;
- // }
- // // Can't convert while loops w/ weird guards?
- // if convert_to_while_loop(editor, natural_loop, loop_exits.get(&l.0).copied(), false) {
- // return true;
- // }
}
- return false;
+ // if merge_phis(editor) {
+ // return true;
+ // }
+ return false;
}
-pub fn has_alternate_bounds(
- function: &Function,
- l: &Loop,
- condition_node: NodeID,
- basic_ivs: &[BasicInductionVariable],
- loop_variance: LoopVarianceInfo,
-) -> Option<(NodeID, BasicInductionVariable)> // iv_expression, base_iv
-{
- // Analyze Loop Bound (pattern match w/ )
- let alternate_iv = basic_ivs.iter().filter_map(|iv|
- {
- match &function.nodes[condition_node.idx()] {
- Node::Start => todo!(),
- Node::Phi { control, data } => todo!(),
- Node::Reduce { control, init, reduct } => todo!(),
- Node::Parameter { index } => todo!(),
- Node::Constant { id } => todo!(),
- Node::Unary { input, op } => todo!(),
- Node::Ternary { first, second, third, op } => todo!(),
- Node::Binary { left, right, op } => {
- match op {
- BinaryOperator::LT => {
- // Check for a loop guard condition.
- // ADDME: Check if the condition is *normal* already, and then check if the rest of the loop is normal.
-
- // left + 1 < right
- let Node::Binary { left: inner_left, right: inner_right, op: inner_op } = function.nodes[left.idx()] else {return None};
- if inner_op == BinaryOperator::Add &&
- ((inner_left == iv.update && inner_right == iv.node) ||
- (inner_right == iv.update && inner_left == iv.node)) &&
- loop_variance.map[right.idx()] == LoopVariance::Invariant
- {
- return Some((left.clone(), iv.clone()));
- } else {
- return None;
- }
+/**
+ * Replaces undef's in PHIs to use already existing PHIs.
+ */
+pub fn merge_phis(editor: &mut FunctionEditor) -> bool {
- }
- BinaryOperator::LTE => todo!(),
- BinaryOperator::GT => todo!(),
- BinaryOperator::GTE => todo!(),
- BinaryOperator::EQ => todo!(),
- BinaryOperator::NE => todo!(),
- _ => None,
- }
-
- }
- _ => None,
- }
- }
- ).next();
- alternate_iv
-}
-
-pub fn canonicalize_loop(
- editor: &mut FunctionEditor,
- loop_exit: Option<LoopExit>,
- fork_join_map: &HashMap<NodeID, NodeID>,
- l: &Loop,
-) -> bool {
-
- // If the loop has no control before the condition:
- // - Canonicalize by changing the bounds, and replacing outside-loop uses
- // with the last phi value.
- // If the loop has control before the condition:
- // - Change bounds, replace outside-loop uses with last phi value
- // - Move control to after the condition (convert to while loop)
- let Some(loop_condition) = loop_exit else {return false};
- let LoopExit::Conditional { if_node: loop_if, condition_node } = loop_condition.clone() else {return false};
-
-
- let is_do_while = !editor.get_uses(loop_if).contains(&l.header);
+ let mut changed = false;
+ let mut worklist: Vec<NodeID> = editor.node_ids().filter(|node| editor.func().nodes[node.idx()].is_phi()).collect();
- let guard = get_guard(editor, l, loop_if);
- if guard.is_none() && is_do_while {
- return false;
- }
+ while let Some(phi) = worklist.pop() {
+ let Node::Phi { control: phi_region, data: phi_data } = &editor.func().nodes[phi.idx()] else {unreachable!()};
- // Compute loop variance
- let loop_variance = compute_loop_variance(&editor, &l);
+ // undef_idx
+ // FIXME: Enumerate + Partition
+ let undefs: Vec<_> = phi_data.iter().positions(|usee| editor.func().nodes[usee.idx()].is_undef()).collect();
+ let non_undefs: Vec<_> = phi_data.iter().positions(|usee| !editor.func().nodes[usee.idx()].is_undef()).collect();
- // Compute induction vars
- let basic_ivs = compute_induction_vars(editor.func(), &l, &loop_variance);
+ if undefs.is_empty() {
+ continue;
+ }
- let Some((iv_expression, base_iv)) = has_alternate_bounds(editor.func(), l, condition_node, &basic_ivs.as_slice(), loop_variance) else {return false};
+ if non_undefs.is_empty() {
+ continue;
+ }
+
+ // Find a phi it can be merged with (look through data edges until we find a PHI of the same region)
+ let candidate = editor.get_users(*phi_region).filter(|node| editor.func().nodes[node.idx()].is_phi());
- let iv_expression = iv_expression.clone();
- let base_iv = base_iv.clone();
+ let mut merge_candidates = candidate.filter(|node| {
+ if phi == *node {
+ return false;
+ }
- // If there are users of iv_expression (not just the loop bound condition), then abort
- if editor.get_users(iv_expression).count() > 2 {return false};
+ if let Node::Phi { control: candidate_region, data: candidate_data } = &editor.func().nodes[node.idx()] {
- // Replace external_uses uses of data with phi.
- // Panic on internal uses.
- struct PhiDataCycle {
- phi: NodeID,
- data: NodeID,
- external_uses: Vec<NodeID>,
- internal_uses: Vec<NodeID>
- }
+ // Regions have to match
+ if candidate_region != phi_region {
+ return false;
+ }
- // The initiailzer position for all loop phis.
- let loop_phi_init_idx = editor.get_uses(l.header)
- .position(|node| !l.control[node.idx()] // Position of the predecessor (used by header but not in loop body.)
- ).unwrap();
+ // FIXME: Sort by candidate that can replace the most undefs.
+ // All undefs need to have data.
+ if undefs.iter().any(|idx| editor.func().nodes[candidate_data[*idx].idx()].is_undef()) {
+ return false;
+ }
- let data_use_locations = get_loop_data_location(editor, l);
+ // All non_undefs need to be the same.
+ if non_undefs.iter().any(|idx| candidate_data[*idx] != phi_data[*idx]) {
+ return false;
+ }
+ true
+ } else {
+ false
+ }
+ });
- let mut changed = false;
- // Check all PHIs controlled by the loop
- let loop_phis: Option<Vec<PhiDataCycle>> = editor.get_users(l.header).filter(|n| editor.func().nodes[n.idx()].is_phi())
- .filter(|phi| *phi != base_iv.node)
- .map(|phi: NodeID| {
+ let Some(data) = merge_candidates.next() else {continue};
+ drop(merge_candidates);
- // There should only be one candidate data,
- // but possibly multiple external uses. z
-
- let initializer_node_id = editor.func().nodes[phi.idx()].try_phi().unwrap().1[loop_phi_init_idx];
-
- // Check if any use is in a cycle w/ the phi.
- let mut data_cycles =
- editor.get_uses(phi)
- .filter(|phi_use|
- *phi_use != initializer_node_id) // Not the initializer.
- .filter_map(|phi_use| {
-
- // If the data node is not in a cycle w/ the phi,
- if !walk_all_uses(phi_use, editor).contains(&phi) {return None};
-
- // Find users of phi_use that are outside the loop, these we will change to use the phi.
- let (internal_uses, external_uses) = editor
- .get_users(phi_use)
- .filter_map(|data_user| {
- Some(data_user)
- }).partition(|data_user| {
- match data_use_locations[data_user.idx()] {
- DataUseLoopLocation::Unknown => todo!(),
- DataUseLoopLocation::Inside => true,
- DataUseLoopLocation::Outside => false,
- }
- });
-
- Some((phi_use, internal_uses, external_uses))
- });
-
+ editor.edit(|mut edit|{
+ let edit = edit.replace_all_uses(phi, data)?;
+ edit.delete_node(phi)
+ });
+ changed = true;
- let Some((data, internal_uses, external_uses)) = data_cycles.next() else {
- return None;
- };
-
- // There should only be one cycle
- if data_cycles.next().is_some() {
- return None;
- }
-
- Some(PhiDataCycle {
- phi,
- data,
- external_uses,
- internal_uses,
- })
- }).collect();
-
- // If any PHIs are invalid, (not in cycles, )
- let Some(loop_phis) = loop_phis else {
- return false;
- };
-
- // Make sure all phi data cycles are fully contained.
- let used_outside_loop = loop_phis.iter()
- .any(|transform_info: &PhiDataCycle|
- {
- let PhiDataCycle { phi, data, external_uses, internal_uses } = transform_info;
-
- // Check usres of the PHI, make sure they aren't outside the loop
- // Unless they would be outside because of the use we are going to get rid of,
- // need a more complicated use location analysis for this.
- if editor.get_users(*phi)
- .any(|node|
- {
- if node == *data {
- return false;
- }
-
- let stop_on: HashSet<NodeID> = editor.node_ids().filter(|n| {
- if *n == *data {
- return true
- };
-
- let node_data = &editor.func().nodes[n.idx()];
+ }
+ changed
+}
- // Stop on Control.
- if node_data.is_control() {
- return true;
- }
- // Stop on PHIs.
- if node_data.is_phi() {
- // Need to maybe not stop on PHIs, but only stop on some of their incoming edges,
- // depending
- let control = node_data.try_phi().unwrap().0;
- return l.control[control.idx()];
- }
+/**
+
+ */
+pub fn canonicalize_loop(
+ editor: &mut FunctionEditor,
+ loop_exit: Option<LoopExit>,
+ fork_join_map: &HashMap<NodeID, NodeID>,
+ natural_loop: &Loop,
+ typing: &Vec<TypeID>
+) -> bool {
- // Stop on Reduces.
- if node_data.is_reduce() {
- let control = node_data.try_reduce().unwrap().0;
- return l.control[control.idx()];
- }
+ let Some(loop_condition) = loop_exit else {return false};
+ let LoopExit::Conditional { if_node: loop_if, condition_node } = loop_condition.clone() else {return false};
- false
- }).collect();
+ // let Some((iv_expression, base_iv)) = has_alternate_bounds(editor.func(),
+ // natural_loop, condition_node, &basic_ivs, loop_variance)
+ // else {return false};
+
+ // Find nodes that are `in the loop`
+ // - used by a phi (or the loop region)
+ // - uses a phi (the loop region)
+ // All other nodes are 'out of the loop'
+ // All edges from the loop to out of the loop need to have a phi added,
+ // controlled by the loop header. The loop entry edge is undef, the loop continued data node is
+ // the edge it is being inserted in.
+ //
+ // Inner control needs to be moved, with PHIs being inserted as appropriate for now undef'd variables.
+
+ let loop_nodes = calculate_loop_nodes(editor, natural_loop);
+
+ let header_initial_idx = editor.get_uses(natural_loop.header)
+ .position(|node| !natural_loop.control[node.idx()] // Position of the predecessor (used by header but not in loop body.)
+ ).unwrap();
- let outside_loop = editor.node_ids().filter(|n| editor.func().nodes[n.idx()].is_control() && !l.control[n.idx()]);
+ let header_continue_idx = editor.get_uses(natural_loop.header)
+ .position(|node| natural_loop.control[node.idx()]
+ ).unwrap();
- // If any uses are control nodes *outside* the loop,
- let node_uses = walk_all_users_stop_on(node, editor, stop_on);
- // TODO: Do intersection lazily?
- let set1: HashSet<_> = HashSet::from_iter(outside_loop);
- let set2: HashSet<_> = HashSet::from_iter(node_uses);
+ // Check loop variables that are used by smthn outside the loop.
+ let binding = loop_nodes.clone();
+ let phis_to_add: Vec<NodeID> = binding.iter()
+ .filter(
+ |loop_node| !editor.func().nodes[loop_node.idx()].is_control()
+ )
+ .filter(
+ |loop_node|
+ {
+ editor.get_users(**loop_node).any(|user|!loop_nodes.contains(&user))
+ }
+ ).cloned().collect();
+
+ // If all loop variables are contained w/ PHIs already, no point in canonicalizing.
+ if phis_to_add.iter().all(
+ |node| {
+ let Node::Phi { ref control, ref data } = editor.func().nodes[node.idx()] else {return false};
+ if *control == natural_loop.header {
+ true
+ } else {
+ false
+ }
+ }
+ ) {
+ return false;
- // If there is no intersection, then it is inside the loop
- if set1.intersection(&set2).next().is_none() {
- false // No intersection, so all users of this phi are good
- } else {
- true // Intersection, so some user of this phi leaves the loop, and we can't fix it by transforming.
- }
- }
- ) {
- return true;
- } else {
- return false;
- }
- });
+ }
- if used_outside_loop {
+ if phis_to_add.is_empty() {
return false;
}
- // See if we can convert to do-while, if we can't transform anything.
- if is_do_while {
- let if_node = loop_if;
- let natural_loop = l.clone();
-
- let guard = match guard {
- Some(v) => v,
- None => return false,
- };
-
- let LoopGuard { guard_if, loop_entered, loop_avoided } = guard;
- let Some(joining_region) = editor.get_users(loop_avoided).next() else {return false;};
+ let loop_before_if_first = editor.get_users(natural_loop.header)
+ .filter(|id| natural_loop.control[id.idx()])
+ .next()
+ .unwrap();
- // For PHIs in the loop (but not of the loop header), that this joining region controls, need
- // to add a version to the loop header, initialized to the same thing as the loop non-taken, and
- // updated when the loop is taken to be the internal version.
- let loop_exit_proj = editor.get_users(if_node).filter(|node| !natural_loop.control[node.idx()]).next().unwrap();
+ let loop_before_if_last = editor.get_uses(loop_if).next().unwrap();
- // Indicies for joining phis
- let joining_loop_avoided_idx = editor.func().nodes[joining_region.idx()].try_region().unwrap().iter().position(|pred| *pred == loop_avoided).unwrap();
- let joining_loop_exit_idx = editor.func().nodes[joining_region.idx()].try_region().unwrap().iter().position(|pred| *pred == loop_exit_proj).unwrap();
-
- let header_initial_idx = editor.func().nodes[natural_loop.header.idx()].try_region().unwrap().iter().position(|pred| !natural_loop.control[pred.idx()]).unwrap();
- let header_continue_idx = editor.func().nodes[natural_loop.header.idx()].try_region().unwrap().iter().position(|pred| natural_loop.control[pred.idx()]).unwrap();
-
- let joining_phis = editor.get_users(joining_region).filter(|node| editor.func().nodes[node.idx()].is_phi());
-
- // If the PHI in the joining region attempts to pull from a phi on the loop_exit_idx edge, which is internal to the loop
- // (in loop but not in loop header, add a phi to loop header)
- struct PhiToAdd {
- joining_phi: NodeID, //
- internal_phi: NodeID,
- initializer: NodeID,
- }
-
- let phis_to_add: Vec<_> = joining_phis.filter_map(|phi| {
- let Node::Phi { control, ref data } = &editor.func().nodes[phi.idx()] else {unreachable!()};
-
- // control is joining_region.
-
- let loop_exit_node = data[joining_loop_exit_idx];
-
- let Node::Phi {control: loop_phi_control, data: ref _loop_phi_data} = editor.func().nodes[loop_exit_node.idx()] else {return None};
-
- if loop_phi_control == natural_loop.header {return None};
+ let loop_exit_projection = editor.get_users(loop_if)
+ .filter(|id| !natural_loop.control[id.idx()])
+ .next()
+ .unwrap();
- if !natural_loop.control[loop_phi_control.idx()] {
- todo!("WHAT")
- }
+ let loop_continue_projection = editor.get_users(loop_if)
+ .filter(|id| natural_loop.control[id.idx()])
+ .next()
+ .unwrap();
- // Initializer is whatever the phi in the joining region takes if the loop is never run.
- let initializer = data[joining_loop_avoided_idx];
+ // Control goes after the loop_continue_projection, and before whatever is after loop_continue_projection.
+ let loop_body_last = editor.get_uses(natural_loop.header)
+ .filter(|id| natural_loop.control[id.idx()])
+ .next()
+ .unwrap();
- Some(PhiToAdd {joining_phi: phi, internal_phi: loop_exit_node, initializer: initializer })
- }).collect();
+ // for phi_to_add in phis_to_add {
+ // editor.edit(|mut edit| {
+ // let PhiToAdd { joining_phi, internal_phi, initializer } = phi_to_add;
+ // let mut data = Box::new([NodeID::new(0); 2]);
+ // data[header_initial_idx] = initializer;
+ // data[header_continue_idx] = internal_phi;
+ // let node = Node::Phi { control: natural_loop.header, data };
+ // let new_phi = edit.add_node(node);
+ // edit.replace_all_uses_where(internal_phi, new_phi, |usee| *usee == joining_phi)
+ // });
+ // println!("adding phi");
+ // }
+
+ let num_loop_predecessors = editor.get_uses(natural_loop.header).count();
- // Get the control in between the header and before the condition,
-
- // If the header -> if, then there is no control before the condition, so it's a while loop.
- if editor.get_uses(if_node).contains(&natural_loop.header) {
- return false
- }
+ // ========= Do transformation ===========:
- let loop_before_if_first = editor.get_users(natural_loop.header)
- .filter(|id| natural_loop.control[id.idx()])
- .next()
- .unwrap();
+ // Add PHIs
+ for data_in_loop in phis_to_add {
+ editor.edit(|mut edit| {
+ let ty = typing[data_in_loop.idx()];
+ let undef = Node::Undef { ty };
+ let undef = edit.add_node(undef);
+ let mut data = vec![undef; num_loop_predecessors];
+ data[header_continue_idx] = data_in_loop;
+ let new_phi = Node::Phi { control: natural_loop.header, data: data.into()};
+ let new_phi = edit.add_node(new_phi);
+ edit.replace_all_uses_where(data_in_loop, new_phi, |usee| !loop_nodes.contains(usee) && *usee != new_phi)
+ });
+ }
- let loop_before_if_last = editor.get_uses(if_node).next().unwrap();
-
- // assert_ne!(loop_before_if_first, loop_before_if_last);
+ // Add PHI for loop condition
+ editor.edit(|mut edit| {
+ let bool_ty = typing[condition_node.idx()];
+ let true_const = Constant::Boolean(true);
+ let true_const = edit.add_constant(true_const);
+ let true_const = Node::Constant { id: true_const };
+ let true_const = edit.add_node(true_const);
- let loop_exit_projection = editor.get_users(if_node)
- .filter(|id| !natural_loop.control[id.idx()])
- .next()
- .unwrap();
-
- let loop_continue_projection = editor.get_users(if_node)
- .filter(|id| natural_loop.control[id.idx()])
- .next()
- .unwrap();
-
- // Control goes after the loop_continue_projection, and before whatever is after loop_continue_projection.
- let loop_body_last = editor.get_uses(natural_loop.header)
- .filter(|id| natural_loop.control[id.idx()])
- .next()
- .unwrap();
-
-
- for phi_to_add in phis_to_add {
- editor.edit(|mut edit| {
- let PhiToAdd { joining_phi, internal_phi, initializer } = phi_to_add;
- let mut data = Box::new([NodeID::new(0); 2]);
- data[header_initial_idx] = initializer;
- data[header_continue_idx] = internal_phi;
- let node = Node::Phi { control: natural_loop.header, data };
- let new_phi = edit.add_node(node);
- edit.replace_all_uses_where(internal_phi, new_phi, |usee| *usee == joining_phi)
- });
- println!("adding phi");
- }
+ let mut data = vec![true_const; num_loop_predecessors];
+ data[header_continue_idx] = condition_node;
+ let new_phi = Node::Phi { control: natural_loop.header, data: data.into()};
+ let new_phi = edit.add_node(new_phi);
+ edit.replace_all_uses_where(condition_node, new_phi, |usee| *usee == loop_if)
+ });
+ // Convert to while loop if not a while loop already.
+ if !editor.get_users(natural_loop.header).contains(&loop_if) {
editor.edit(|mut edit| {
// Have fun understanding this!
edit = edit.replace_all_uses(loop_continue_projection, loop_before_if_last)?;
edit = edit.replace_all_uses_where(natural_loop.header, loop_continue_projection, |usee| *usee == loop_before_if_first)?;
- edit = edit.replace_all_uses_where(loop_before_if_last, natural_loop.header, |usee| *usee == if_node)?;
+ edit = edit.replace_all_uses_where(loop_before_if_last, natural_loop.header, |usee| *usee == loop_if)?;
Ok(edit)
});
}
- // ========= Do transformation ===========:
-
// Change loop bounds
- editor.edit(|edit|
- edit.replace_all_uses_where(iv_expression, base_iv.node, |usee| *usee == condition_node)
- );
-
-
- for transform_info in loop_phis {
- editor.edit(|mut edit|
- {
- edit.replace_all_uses_where(transform_info.data, transform_info.phi, |usee| transform_info.external_uses.contains(usee))
- }
- );
- }
+ // editor.edit(|edit|
+ // edit.replace_all_uses_where(iv_expression, base_iv.node, |usee| *usee == condition_node)
+ // );
true
@@ -735,10 +585,60 @@ pub fn convert_to_while_loop(
true
}
-// struct TransformResult {
-// modified: bool,
-// suceeded: bool,
-// }
+pub fn has_alternate_bounds(
+ function: &Function,
+ l: &Loop,
+ condition_node: NodeID,
+ basic_ivs: &[BasicInductionVariable],
+ loop_variance: LoopVarianceInfo,
+) -> Option<(NodeID, BasicInductionVariable)> // iv_expression, base_iv
+{
+ // Analyze Loop Bound (pattern match w/ )
+ let alternate_iv = basic_ivs.iter().filter_map(|iv|
+ {
+ match &function.nodes[condition_node.idx()] {
+ Node::Start => todo!(),
+ Node::Phi { control, data } => todo!(),
+ Node::Reduce { control, init, reduct } => todo!(),
+ Node::Parameter { index } => todo!(),
+ Node::Constant { id } => todo!(),
+ Node::Unary { input, op } => todo!(),
+ Node::Ternary { first, second, third, op } => todo!(),
+ Node::Binary { left, right, op } => {
+ match op {
+ BinaryOperator::LT => {
+ // Check for a loop guard condition.
+ // ADDME: Check if the condition is *normal* already, and then check if the rest of the loop is normal.
+
+ // left + 1 < right
+ let Node::Binary { left: inner_left, right: inner_right, op: inner_op } = function.nodes[left.idx()] else {return None};
+ if inner_op == BinaryOperator::Add &&
+ ((inner_left == iv.update && inner_right == iv.node) ||
+ (inner_right == iv.update && inner_left == iv.node)) &&
+ loop_variance.map[right.idx()] == LoopVariance::Invariant
+ {
+ return Some((left.clone(), iv.clone()));
+ } else {
+ return None;
+ }
+
+ }
+ BinaryOperator::LTE => todo!(),
+ BinaryOperator::GT => todo!(),
+ BinaryOperator::GTE => todo!(),
+ BinaryOperator::EQ => todo!(),
+ BinaryOperator::NE => todo!(),
+ _ => None,
+ }
+
+ }
+ _ => None,
+ }
+ }
+ ).next();
+ alternate_iv
+}
+
pub fn canonicalize_loop_old(
editor: &mut FunctionEditor,
@@ -769,177 +669,178 @@ pub fn canonicalize_loop_old(
let loop_variance = compute_loop_variance(&editor, &l);
// Compute induction vars
- let basic_ivs = compute_induction_vars(function, &l, &loop_variance);
-
- let Some((iv_expression, base_iv)) = has_alternate_bounds(editor.func(), l, condition_node, &basic_ivs, loop_variance) else {return false};
- let iv_expression = iv_expression.clone();
- let base_iv = base_iv.clone();
-
- // If there are users of iv_expression (not just the loop bound condition), then abort
- if editor.get_users(iv_expression).count() > 2 {return false};
-
- // Replace external_uses uses of data with phi.
- // Panic on internal uses.
- struct PhiDataCycle {
- phi: NodeID,
- data: NodeID,
- external_uses: Vec<NodeID>,
- internal_uses: Vec<NodeID>
- }
-
- // The initiailzer position for all loop phis.
- let loop_phi_init_idx = editor.get_uses(l.header)
- .position(|node| !l.control[node.idx()] // Position of the predecessor (used by header but not in loop body.)
- ).unwrap();
-
- let data_use_locations = get_loop_data_location(editor, l);
-
- let mut changed = false;
-
- // Check all PHIs controlled by the loop
- let loop_phis: Option<Vec<PhiDataCycle>> = editor.get_users(l.header).filter(|n| editor.func().nodes[n.idx()].is_phi())
- .filter(|phi| *phi != base_iv.node)
- .map(|phi: NodeID| {
-
- // There should only be one candidate data,
- // but possibly multiple external uses. z
-
- let initializer_node_id = editor.func().nodes[phi.idx()].try_phi().unwrap().1[loop_phi_init_idx];
-
- // Check if any use is in a cycle w/ the phi.
- let mut data_cycles =
- editor.get_uses(phi)
- .filter(|phi_use|
- *phi_use != initializer_node_id) // Not the initializer.
- .filter_map(|phi_use| {
-
- // If the data node is not in a cycle w/ the phi,
- if !walk_all_uses(phi_use, editor).contains(&phi) {return None};
-
- // Find users of phi_use that are outside the loop, these we will change to use the phi.
- let (internal_uses, external_uses) = editor
- .get_users(phi_use)
- .filter_map(|data_user| {
- Some(data_user)
- }).partition(|data_user| {
- match data_use_locations[data_user.idx()] {
- DataUseLoopLocation::Unknown => todo!(),
- DataUseLoopLocation::Inside => true,
- DataUseLoopLocation::Outside => false,
- }
- });
+ let basic_ivs = compute_basic_induction_vars(function, &l, &loop_variance);
- Some((phi_use, internal_uses, external_uses))
- });
-
-
- let Some((data, internal_uses, external_uses)) = data_cycles.next() else {
- return None;
- };
-
- // There should only be one cycle
- if data_cycles.next().is_some() {
- return None;
- }
-
- Some(PhiDataCycle {
- phi,
- data,
- external_uses,
- internal_uses,
- })
- }).collect();
-
- // If any PHIs are invalid, (not in cycles, )
- let Some(loop_phis) = loop_phis else {
- return false;
- };
-
- // Make sure all phi data cycles are fully contained.
- let used_outside_loop = loop_phis.iter()
- .any(|transform_info: &PhiDataCycle|
- {
- let PhiDataCycle { phi, data, external_uses, internal_uses } = transform_info;
-
- // Check usres of the PHI, make sure they aren't outside the loop
- // Unless they would be outside because of the use we are going to get rid of,
- // need a more complicated use location analysis for this.
- if editor.get_users(*phi)
- .any(|node|
- {
- if node == *data {
- return false;
- }
-
- let stop_on: HashSet<NodeID> = editor.node_ids().filter(|n| {
- if *n == *data {
- return true
- };
-
- let node_data = &editor.func().nodes[n.idx()];
-
- // Stop on Control.
- if node_data.is_control() {
- return true;
- }
- // Stop on PHIs.
- if node_data.is_phi() {
- // Need to maybe not stop on PHIs, but only stop on some of their incoming edges,
- // depending
- let control = node_data.try_phi().unwrap().0;
- return l.control[control.idx()];
- }
-
- // Stop on Reduces.
- if node_data.is_reduce() {
- let control = node_data.try_reduce().unwrap().0;
- return l.control[control.idx()];
- }
+ // let Some((iv_expression, base_iv)) = None; //has_alternate_bounds(editor.func(), l, condition_node, &basic_ivs, loop_variance) else {return false};
+ // let iv_expression = iv_expression.clone();
+ // let base_iv = base_iv.clone();
- false
- }).collect();
+ // // If there are users of iv_expression (not just the loop bound condition), then abort
+ // if editor.get_users(iv_expression).count() > 2 {return false};
- let outside_loop = editor.node_ids().filter(|n| editor.func().nodes[n.idx()].is_control() && !l.control[n.idx()]);
+ // // Replace external_uses uses of data with phi.
+ // // Panic on internal uses.
+ // struct PhiDataCycle {
+ // phi: NodeID,
+ // data: NodeID,
+ // external_uses: Vec<NodeID>,
+ // internal_uses: Vec<NodeID>
+ // }
- // If any uses are control nodes *outside* the loop,
- let node_uses = walk_all_users_stop_on(node, editor, stop_on);
+ // // The initiailzer position for all loop phis.
+ // let loop_phi_init_idx = editor.get_uses(l.header)
+ // .position(|node| !l.control[node.idx()] // Position of the predecessor (used by header but not in loop body.)
+ // ).unwrap();
- // TODO: Do intersection lazily?
- let set1: HashSet<_> = HashSet::from_iter(outside_loop);
- let set2: HashSet<_> = HashSet::from_iter(node_uses);
+ // let data_use_locations = get_loop_data_location(editor, l);
- // If there is no intersection, then it is inside the loop
- if set1.intersection(&set2).next().is_none() {
- false // No intersection, so all users of this phi are good
- } else {
- true // Intersection, so some user of this phi leaves the loop, and we can't fix it by transforming.
- }
- }
- ) {
- return true;
- } else {
- return false;
- }
- });
-
- if used_outside_loop {
- return changed;
- }
+ // let mut changed = false;
- // Change loop bounds
- editor.edit(|edit|
- edit.replace_all_uses_where(iv_expression, base_iv.node, |usee| *usee == condition_node)
- );
-
- changed = true;
-
- for transform_info in loop_phis {
- editor.edit(|mut edit|
- {
- edit.replace_all_uses_where(transform_info.data, transform_info.phi, |usee| transform_info.external_uses.contains(usee))
- }
- );
- }
+ // // Check all PHIs controlled by the loop
+ // let loop_phis: Option<Vec<PhiDataCycle>> = editor.get_users(l.header).filter(|n| editor.func().nodes[n.idx()].is_phi())
+ // .filter(|phi| *phi != base_iv.node)
+ // .map(|phi: NodeID| {
+
+ // // There should only be one candidate data,
+ // // but possibly multiple external uses. z
+
+ // let initializer_node_id = editor.func().nodes[phi.idx()].try_phi().unwrap().1[loop_phi_init_idx];
+
+ // // Check if any use is in a cycle w/ the phi.
+ // let mut data_cycles =
+ // editor.get_uses(phi)
+ // .filter(|phi_use|
+ // *phi_use != initializer_node_id) // Not the initializer.
+ // .filter_map(|phi_use| {
+
+ // // If the data node is not in a cycle w/ the phi,
+ // if !walk_all_uses(phi_use, editor).contains(&phi) {return None};
+
+ // // Find users of phi_use that are outside the loop, these we will change to use the phi.
+ // let (internal_uses, external_uses) = editor
+ // .get_users(phi_use)
+ // .filter_map(|data_user| {
+ // Some(data_user)
+ // }).partition(|data_user| {
+ // match data_use_locations[data_user.idx()] {
+ // DataUseLoopLocation::Unknown => todo!(),
+ // DataUseLoopLocation::Inside => true,
+ // DataUseLoopLocation::Outside => false,
+ // }
+ // });
+
+ // Some((phi_use, internal_uses, external_uses))
+ // });
+
+
+ // let Some((data, internal_uses, external_uses)) = data_cycles.next() else {
+ // return None;
+ // };
+
+ // // There should only be one cycle
+ // if data_cycles.next().is_some() {
+ // return None;
+ // }
+
+ // Some(PhiDataCycle {
+ // phi,
+ // data,
+ // external_uses,
+ // internal_uses,
+ // })
+ // }).collect();
+
+ // // If any PHIs are invalid, (not in cycles, )
+ // let Some(loop_phis) = loop_phis else {
+ // return false;
+ // };
+
+ // // Make sure all phi data cycles are fully contained.
+ // let used_outside_loop = loop_phis.iter()
+ // .any(|transform_info: &PhiDataCycle|
+ // {
+ // let PhiDataCycle { phi, data, external_uses, internal_uses } = transform_info;
+
+ // // Check usres of the PHI, make sure they aren't outside the loop
+ // // Unless they would be outside because of the use we are going to get rid of,
+ // // need a more complicated use location analysis for this.
+ // if editor.get_users(*phi)
+ // .any(|node|
+ // {
+ // if node == *data {
+ // return false;
+ // }
+
+ // let stop_on: HashSet<NodeID> = editor.node_ids().filter(|n| {
+ // if *n == *data {
+ // return true
+ // };
+
+ // let node_data = &editor.func().nodes[n.idx()];
+
+ // // Stop on Control.
+ // if node_data.is_control() {
+ // return true;
+ // }
+ // // Stop on PHIs.
+ // if node_data.is_phi() {
+ // // Need to maybe not stop on PHIs, but only stop on some of their incoming edges,
+ // // depending
+ // let control = node_data.try_phi().unwrap().0;
+ // return l.control[control.idx()];
+ // }
+
+ // // Stop on Reduces.
+ // if node_data.is_reduce() {
+ // let control = node_data.try_reduce().unwrap().0;
+ // return l.control[control.idx()];
+ // }
+
+ // false
+ // }).collect();
+
+ // let outside_loop = editor.node_ids().filter(|n| editor.func().nodes[n.idx()].is_control() && !l.control[n.idx()]);
+
+ // // If any uses are control nodes *outside* the loop,
+ // let node_uses = walk_all_users_stop_on(node, editor, stop_on);
+
+ // // TODO: Do intersection lazily?
+ // let set1: HashSet<_> = HashSet::from_iter(outside_loop);
+ // let set2: HashSet<_> = HashSet::from_iter(node_uses);
+
+ // // If there is no intersection, then it is inside the loop
+ // if set1.intersection(&set2).next().is_none() {
+ // false // No intersection, so all users of this phi are good
+ // } else {
+ // true // Intersection, so some user of this phi leaves the loop, and we can't fix it by transforming.
+ // }
+ // }
+ // ) {
+ // return true;
+ // } else {
+ // return false;
+ // }
+ // });
+
+ // if used_outside_loop {
+ // return changed;
+ // }
+
+ // // Change loop bounds
+ // editor.edit(|edit|
+ // edit.replace_all_uses_where(iv_expression, base_iv.node, |usee| *usee == condition_node)
+ // );
+
+ // changed = true;
+
+ // for transform_info in loop_phis {
+ // editor.edit(|mut edit|
+ // {
+ // edit.replace_all_uses_where(transform_info.data, transform_info.phi, |usee| transform_info.external_uses.contains(usee))
+ // }
+ // );
+ // }
- changed
+ // changed
+ false
}
\ No newline at end of file
diff --git a/hercules_opt/src/pass.rs b/hercules_opt/src/pass.rs
index 08fd2bdc..8b648149 100644
--- a/hercules_opt/src/pass.rs
+++ b/hercules_opt/src/pass.rs
@@ -1136,7 +1136,7 @@ impl PassManager {
let def_uses = self.def_uses.as_ref().unwrap();
let loops = self.loops.as_ref().unwrap();
let fork_join_maps = self.fork_join_maps.as_ref().unwrap();
- let types = self.typing.as_ref().unwrap();
+ let typing = self.typing.as_ref().unwrap();
for idx in 0..self.module.functions.len() {
let constants_ref =
RefCell::new(std::mem::take(&mut self.module.constants));
@@ -1157,7 +1157,8 @@ impl PassManager {
&mut editor,
control_subgraph,
&fork_join_maps[idx],
- &loops[idx],
+ &loops[idx],
+ &typing[idx],
);
self.module.constants = constants_ref.take();
diff --git a/hercules_test/hercules_interpreter/src/interpreter.rs b/hercules_test/hercules_interpreter/src/interpreter.rs
index 9f47dd3f..c07351bd 100644
--- a/hercules_test/hercules_interpreter/src/interpreter.rs
+++ b/hercules_test/hercules_interpreter/src/interpreter.rs
@@ -438,6 +438,11 @@ impl<'a> FunctionExecutionState<'a> {
let data = self.handle_data(token, *data);
self.handle_write(token, collection, data, indices)
}
+ Node::Undef {
+ ty
+ } => {
+ InterpreterVal::Undef(*ty)
+ }
_ => todo!(),
}
}
@@ -480,8 +485,13 @@ impl<'a> FunctionExecutionState<'a> {
.collect();
let idx = InterpreterVal::array_idx(&extents, &array_indices);
//println!("idx: {:?}", idx);
- vals[idx] = data;
- InterpreterVal::Array(type_id, vals)
+ if idx > vals.len() {
+ InterpreterVal::Undef(type_id)
+ } else {
+ vals[idx] = data;
+ InterpreterVal::Array(type_id, vals)
+ }
+
} else {
panic!("PANIC: Position index on not an array")
}
@@ -522,7 +532,8 @@ impl<'a> FunctionExecutionState<'a> {
.into_iter()
.map(|extent| dyn_const_value(extent, &self.module.dynamic_constants, &self.dynamic_constant_params))
.collect();
- vals[InterpreterVal::array_idx(&extents, &array_indices)].clone()
+ // FIXME: This type may be wrong.
+ vals.get(InterpreterVal::array_idx(&extents, &array_indices)).unwrap_or(&InterpreterVal::Undef(type_id)).clone()
} else {
panic!("PANIC: Position index on not an array")
}
@@ -594,6 +605,7 @@ impl<'a> FunctionExecutionState<'a> {
// Convert condition to usize
let cond: usize = match cond {
InterpreterVal::Boolean(v) => v.into(),
+ InterpreterVal::Undef(v) => panic!("PANIC: Undef reached IF"),
_ => panic!("PANIC: Invalid condition for IF, please typecheck."),
};
diff --git a/hercules_test/hercules_interpreter/src/value.rs b/hercules_test/hercules_interpreter/src/value.rs
index ba7c3e48..9c95d845 100644
--- a/hercules_test/hercules_interpreter/src/value.rs
+++ b/hercules_test/hercules_interpreter/src/value.rs
@@ -29,6 +29,7 @@ pub enum InterpreterVal {
Float32(ordered_float::OrderedFloat<f32>),
Float64(ordered_float::OrderedFloat<f64>),
+ Undef(TypeID),
Product(TypeID, Box<[InterpreterVal]>),
Summation(TypeID, u32, Box<[InterpreterVal]>),
Array(TypeID, Box<[InterpreterVal]>), // TypeID of the array Type (not the element type)
@@ -193,6 +194,14 @@ impl<'a> InterpreterVal {
left: InterpreterVal,
right: InterpreterVal,
) -> InterpreterVal {
+ // If either are undef, propogate undef
+ if let InterpreterVal::Undef(v) = left {
+ return InterpreterVal::Undef(v)
+ }
+ if let InterpreterVal::Undef(v) = right {
+ return InterpreterVal::Undef(v)
+ }
+
// Do some type conversion first.
let left = match left {
InterpreterVal::DynamicConstant(v) => match right {
@@ -792,6 +801,7 @@ impl<'a> InterpreterVal {
(UnaryOperator::Neg, Self::Float32(val)) => Self::Float32(-val),
(UnaryOperator::Neg, Self::Float64(val)) => Self::Float64(-val),
(UnaryOperator::Cast(_), _) => todo!("Write cast impl"),
+ (_, Self::Undef(v)) => InterpreterVal::Undef(v),
_ => panic!("Unsupported combination of unary operation and constant value. Did typechecking succeed?")
}
}
diff --git a/hercules_test/hercules_tests/output.pdf b/hercules_test/hercules_tests/output.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..a8d0de71b4d78ac417d36e856c0ca81dcba32dce
GIT binary patch
literal 28792
zcmYJZV{j-<*ESm4wr%g&wr$(CZQIF?ZQHhOn>)$L{hX@z`!O|D^P^{V_qwoFH>td^
zC@mu$D->z-b<HOf3jqUxouMTZH#Y&jw27^mvpE6l?<Ykl0s;bhQ44El6UX1TwSlvV
zu!)hKu?Z9}FO-wBqltkHlzaBHk5(LwjO()3S7fR?hu8tN+13LQAqfnGfkE(ff;+}+
z(DLDZ^s-GItl&Sd7fmZMVO3L=oT^0&?3fd8Tm{Uu=<u!jTC1?u{_j_*I=>T~n#V3_
zBVVtdu76*oUHg7NcYo~sp40|6cmExd(!BY2M%{D5@6*Oiy2L(eK^|wOzF*^ie_XqT
z<zm*5ru9o+@(E@d_UjvrueK+*rq{kmVLiGCf7;_N99(l8^Zm%J&}bGV?taHDe?@%#
z*wOcX$1KCy^>zpEU(4-&f79M+d|A;y7tQ><UC(xTWsT$iTqM>wQE*tqSQ5q@V}+qu
z_c-*(9^#a?>iOt?pSktI^y*jXece1<+U4!~MI5&Fetb(|^?cRdmb(xCe1A_qTpxbY
zKeqZkex=oUOYQn)^n7jJ_P#IYX@4Kqs!|uBZ%y;b46@F$J-%lyyuG}uQd?h!a<4Cq
zSZOb4$*!gsp$@VJt9tuMm1w82=xqR#YLkE3+1!ZSes`-SUz*omPVXvqIO48-4oBVE
zIRCWIEN||}etlij!&SRrRxihog2JYmq#w5FUG??_I;J%5{pedoLD5{&?{^Gwr~Khc
zXC&LK*wyWU-SvBJ)wYjTMgQ6fOhc(P!rV<AZ}DybwL_hBfpm4f%0GRlg-L+6`C0>N
zKKRsX3ALa~Q%yNN$4V_}u@iaz*`a=5r8lzqX&JI=xRv<Qv%K$))$^-KQaYSIf~WIn
zS%DtSu6e{rZPUB`dEpVEbJ<gr>$&1Q@U!{(usxIGc?f0md%yOQ-2Fz4`@Z`!H2b0N
zwMw%tmBI-dvVo$E+xlzoo)<dbGjvZ&!bKl~y=<9k#gJ$U?MOSRRacaI)$1|yGM}c}
zl9CrlYtr*1cIExo;GCzaVZ>c;ndDP?WFsVHusPZOyr?V?TyXI&l2_`v&L^(O%hY*=
zHxYA`dmRuf`t8K8&<DEHN6IMM_LUZIyR{95vwhJ8Gss4(8YAq|yop2hkX4v^!-r|3
zS@GmDU6Hm2oA3`-^7Us0{Lnn7rlu3U=j(0vfVg{k^|eqtTpQ}rXG!Yr=G}7ur&e=M
z&S!shWJ}|r;?;-yp#A<0_zS*u$*A4Ws~61f_slnrE!zcrzU%Fa+1tzQ`_|81>_xwy
zFgAGzdeb}C7JF6OBWMlV0$p$u2^Z@h?2HT1?=#cLaXd^T^5km4U^>xHK=94;`~*Yo
zLTW|KARkkUi()3MMTXNY&$403Y0Z$boYvZ=IdJv)3C@rY{+#?jy*>d&otW328KQP?
z{@UNCx09{A%d?~#LMB2d6Z5mA>j@bH7f$7<zB@`YtA<Y_y`jc-(O%s?bfQ(!S2SNv
z8qxGwAEyVy-|b6Kc<y#Oy<oRK&+SY5m%uJ9mOfmsMKFEx(b=dB06z<PQe9u#rbgr=
zn=${I5yia7SbcBAJ~M0}CG;+QSD<#|aSmL@efVs+?5Ur=vghh<&9JVqGB$lz47DCq
z3vd-KTXZgbn)6)TYt0)?E~mHRZcdY<*Xj2leo9`MtzVfjK)0^Uylwc5*ud5?{JH7L
zG>qf>HGwM{*Gddl8^2`eCV5HciVITs7o&N`M4K;e2d$;>Js&k+0C&__T^nVTt^=w@
zS+L<1!{jk(FHpKl<u<(5x`q@K&5zilgRZNmS8PXEPC2e$T^r3Nr&F6Ju4BKje*S^|
zJi$Ucsat=vVyD&{4Bo@fVf?i|YV-5gRp8@4ybC2=y`AK2Af^5So?0)?w6Mh2mu>4T
zUD=Ad#<oEH2wv*&(Yx^Z0{r;D1W{0(Z(BFOd1T;y2k^5^iq6AW{Y0K*ANKl0j=hcR
z_Q<@721Ay72!yp{O`@%*HE4$uXyqgM%)XL`FHf<7m04?*J6*u9rw5VtxGq3t9r~;w
zQ<QwctKwb@35#ol9e~OW;)Gp(((pvjdS&m>Alq603t<71x5{p8bUnLKWAEH~uz$^z
z5Q-k!UGas!t5iEq7KJqnZJ8XHB4)H>Iw7<-Vu@+iqwN6QOnyZifTHDfW)gG1V|5i2
zPU!`&IwXI*Fe(o^Y?>Fc+N9wLzxn$UofpbLwSY{cNYP#~qx_f6=hIy&XG|&dO*@B@
zYS&-HRb3y+eixko`JVG_H&<GZT)OW)z-Kk|!_X(XEx%OOaS{^S^`QQ_yhXqC@9vuG
z-{N|M{d@g)EVgW1$zms)$g=(6J`V4Xgmzw`ZV_|*RbWIx9v1Ry0oZvMg#dHfsBh$g
zepd1a<;8KwVD-qXzuSDA0&a0mAsck9MPt>e{Ue^3MzQ%e*?HHuAFs%xn%w-;5lTq|
zqR1CY%3)W!LclQHA0x*}oc>6UVQzUTOtCY%)K(5fdJPq5T^6=-WBCNBPaf^VWKAo2
z&)eH>BE5pp`;`{ILl)QRz_i`XvtRIQ*!>3w9CgMOJ6!@~xklWA`<>-)y`Hc(?@tv}
zF>vJZ3DL9Ju;xE)&!HLg&?O~nI?EXJ7BpZiGzcGsK3rrY39mShTN8Vt$UFB9o<pi@
z#>p!p)K>AYDl&5`Wzg8x{X5zp6czS7h^PCkKDj%?Co*u<PWF^S*#?vCTfKSswH_+s
z^kL65NwT60cqX#kE7c>#PRRNP?0V?t7=_&p2?y*0vI~)%<tA(!Yq|bwxqo+rsI8)Z
z$1j~a)ltXXaJj62D`c8&ogJ|Hpy>{q_QK&k7$J&c!@{=FO2eb({Mq*!FBZPv+zoUN
zR~2-O)?zYOo_i$=F^J5%HQ?^za5YJ`=>F3@fWCs(RrLb2McA{lyaUt1U0Dqo6@0ZJ
zM89fs$=XwQWzfv*65Ye<g63j%LDC(xna1A1=;~#tcct}lx|x3dHj<tX>J){WXFVC2
zQ_ec_Zfb#kzi*aQok)v5bWuK49bMf|Vl85Ys){$Dab1|kI_6b7zUb0``btMZn+&qv
z6<Y|UX6cBhyLh6}xz;tle+{^v(I0aJl)*$soImRx+1rn|wHeNcs`kot|Iw^7@ken0
zzB+xR)(J4HzI1hLDN%90z*Pyxoe}wOXFXYlK8nGZwH$~ghbDNl`ZPtgpevf)?iE8C
zry%oE6Q#RMUg2w<N5tS%j?GZKeLYX(63!-s5lpMJqK5*YMIP<W%$myQSwY<eYm!cb
zt9EF>M@jn77u_&~5^Vr@3p5J(x?e7NZ_{!|+Van5#RwTM*=^s<Gf>QU32Z)7aVIBW
z?K!eC_@)|r2V#_sFlHG*V|B~Ut?u^EjhCzFOY3qrcZ$W%TIb1N@Yv1xIt4$}ITf=+
zC57Th1_b2&P%O2JgQ%8$hvj<?PIUEp318wUb*ME@6H}PGo(jxA<t}h!cT;cbG~RHk
zF(Pv`-FfnJo~@qY{Z1~n_7N;uRknhE?ajvhEkjzC$hIopeA*A|a2UoO>Vq=z4Xk#o
z$C=fy=GuRr3?QwECq{ha3@l8l!;Jer!mIZiqPwG1R|syqM`CH4%6CAk$rii*OW^$G
z`QHS#$!(6B&gvpS3$`dw9SBd$S?_!}n$?>gIgMG=krHR`ks2|eW2|v2Uw%W{T$pvb
z(9*9A%yMj&LW~tYv`o877wFySFh6dQYA&U#?@+&1#4Wj1%n{oz;hf$04;huS0y|~A
zKc_n-haWsvVltvh<yIk5!<6Jux^&FsohWzON#*s3qH1*4ZbcCF<4etJ#XG8m<!f4<
zV^=w~#uuEPKKZgMTDvn}XRHRDI`%rFhfL2Xl56h5Z<6?{0i?wBLeiB{?W=FgmU%9{
z5iyjFhe>MaPPzB6Pg(026GuqwS*?zp8Co&BQx^s<tgDP0+uEmls6LT9gD0eLTt2X?
zj9~UNvo$B%6<K#auio^d97>%+2Ilp(2v<z1-OE$|Hk2Ta)`GgRdR|zh|4mqFcnW{I
z(pQRsb#yh;X=(&@)mj>p-qBUzL_2QcwJ0bH_^$jvUdY;v$x6XTY<=lLc|D8Vsq*6J
zxnWeOfK)0l7+(1u{6&x9iI@j5a6ZyO{Ug#Hvj=L@1)@d0dE!Lm(e;0j`cG9b_jS}g
z+GHo2G~HC}w|#yAby`l>V&|CrK|f+KPlZQ@ozH#0`yp{)XT9ni7Kf#`S2S`t)m-Ma
zWaS+|j=8o0Ce4{u$%7^Frsieb;5<{wV|m;nRz316uJgoWS=7X1`FNMfD|c)7NGA4b
z4nyXIiH!C$&Q`uX*P6wGyGzox2WNjJVT?+szm$nc9^Lf`6!SNSo%l>q`LsNxzkNo2
zNcV%7Bk|Ber>OzVLvI<TMj^XoGRJHyH;p%v${oe~zlhIutapyi$V}P{WCHBcZIA|a
z2oG6BMn$`3=(otpEcZzU;;1fo%UK(T0L{0Nl!bz-WMv&JG1G+FHXd{|QCk2<CO1Ur
z|D)lUZjp3LbXB|>j+$F!mG~M9yynu`#s4wPCy6#Vx%G-;#*N;w-bU;pSpkfMyCyZ4
zWymGx6-Jsv6^)YY$o+Bsqw+e26Q#-}uzFR^_1W>n?Gu)oYFXHfQZr*mPmyfl1=j^m
zci5&I`_*&8yhZ83F{llASFH8oME9kS?>;kwuPG!omqKkqLRcm!j@KWc0C>h5KNE6E
zq2Sk(30dP&zYN7z<Yvc4<Yp{PkFF?Na?2tXE`_YH)hCZ%JMhP2JL*0o=Paxu?k)2I
z_#Vq75WQK3L^0f)m3Vn_?_R>^`a8rEQxFx{xC;hz%46<D9Hd12|3`5pR!E*ZdIKaV
z1d<DiN?X%Hw3>nL^#5jWaBky2kTZ%mk#gQMac*3|*;D$lmoX4<)462n9dVtVNb-g@
zBtjM5Bjr$<S$M0+f{6Vs{wqBz$5yDCdUm@jKMSE}TFT@Ktz|L`t>%wdV)WLXKS|u#
z-x+Ras6ip~ukxzeDz%7GAj`lxOF1T%<XsLb^19M2vaMo;II~vh)!LZ3y2PntooCuA
z*d-1sHvhNpcWx|M{G3r!yeAdDH0UGf^wvdd@+^ORl&Z_Hh>_PM7wJ`A&uVO$-r+KD
zO6?j{`sJIO(K~y}Roh0!vebMOpW|+z$YF1f*)*DWroQSlfF6v#J9;R4O6`Dn2=Z3F
zYdmAPO9@mkP3-Vg>h`i2S{yrwNd5nsco_#*lfTeuwsQ(MW4UEK&~+^SM&_Z@?BOnx
zWp@2v!k@<{RAVqnAJ2Bx#8TuOL`nX2C=RU24A#_m!Rg33p1b0iixqfWlo6yHY|HAD
zfCv^G2yvUAu&q5uWjb?*-zHfCvmh&AgZ(u)Pk6Sv2WJMeWN9G2mU1wHr%+4xtkvM|
z8BA4fe^uT#1~v_}KQ;!7;lC_*@sc)ySn8(@Tl;dn&e1wmYkr^os7gH5O(pR2O{KpI
zt$$?}JKKEX1})1$7a&>cf0VhJR;7l~Rq#T3CQ+L6v);WgS;xm3oq-6LIK~ga%<8yP
zRek?Tvj}^-eiD;;6Z&_%%uiq)b*~Dmxs*XuqlXj!hsH9}`~RDJSk4^6r~-z20>jA@
z=x(eS9VopwW4xY`rpAM3%#?jy`5gY{wDaD=X+z7=ev_#L)VFxq2=8rSN@YUzavSDM
z=UHkOn`GnB|69#49qwqM%<G~_Ia&|B&A4-R_+et)m7S&P5uOVJQ!NiA;sz^STki*>
zj_2_>;6QOt`06e12P>K95L0;SynmdcovWKP6@OfEOs)+c@xp{C9#C6~pSH+<%1(%T
zO5gLPgR~aaB_QPT?7GPo_0n<RajmX^L@;alMpeP$j7hLp#e4>A4<JVyUgjpS4!c(|
z_^3IsdDI=c6oVAQ^xK(ipLPsHvJ7o{etp8nL*PkQ3L1vv;C9L`1T1rv%AZ#OPla<t
zllKY0Dv}^$tr(e@SO(^4?&wDW5B0LeDifV`;(-Y(R9j<+*5)YP|7j|n{s?v*ICZQ%
ztnLRv1;Oxx#cyVn{u+@u^qMP+(ta%3Q}5lyTjK!E?z3xwdzPw~veh@B!BvxUFBEcu
z37SftNa8OQH7{l7DlPQtt(USD^N{Ya9x<Ev7BL$v-Nn*#9_yXMyEKD_5%KCbzE?cl
z*XJ>gML>4B{3Dbetr$q&B$;hS>1b{m5c7I$_nTw4P;Vte+c^ImAO%(U?lQt1ub2c1
zDv2dvp^oVO_9p@50Iwq1L8}d#?x<@ooKzV!ZDx7g!eir0clzvSJ#MJe$$IVCLVLVn
zM_e}snMMcx7JF*TEz4}IK~1h_dajHi_~Zao)|ShNnVxIJO-=Jg&0pN}4XPeCDf3j7
zIp7v69dgD<#$2-e&$z<5wJsBL_<oe&AM-9)Rq5q8pYnRfxQBhLq_mb@F0{wByj>&e
zZTuQ+wVV89_8)n*-Uob}_zAxzjj}?ShL+u~k^Sa4Q3Rswro4N6zmJ?cZG*QLg;icT
z!nl1nbf%uVr+@~LG)b=*VaYdH3DZj7{1CLY6y=U3>>9}u`R<?x)$*p4EM-lr3i0+g
zRJD=?HpwK(P42GJ|2VT}+@QN>IwRLfu4Lio+Xn~7qD)D2eo-y_tVD#vFCknvI?^{I
z9I0gQK-n2;F|pP2&Y4>D-yKT^g3zH|l-@Zj6t4utMTVv|)RKV7Smhn+nH>}N^CvN|
zRtuhHyJ%_?Rvgbgo#&e*c1cL>l7+iS*8lQatoKOYu=E*H_EO>r>b+$5QR!RgD|u3%
z=0!ArtW|Aoey_j~e<<;R%6*JXn5-A<8s(Gj6p!m@Smi8!b*U|XqbJ2D_*G?E9DWUp
zL)jWIjQx3xu-5%DL8!S@Zu3_NN1zjgBEo4`knmbx4R}<&5qhP7a4$M-wa-}qsITBO
zbYin8w=D4Z-T8Gtt!<x3hc5SS4Cc|Oj4?Z+1EgIKEHxau5o3+M5V;gxBdy?@&xC$m
zjwr`a1vvGfUS2`vuSu;a!Y=(Se|8RK!Ugb;@~L}$)C2)>ZXb*I-oV(#;OK>w4qf-4
zn?q_@d#o9md^@Tw^)dD>w}DyaJeqF^<@c4i%7%Mxsz=aec&b*mN6#j8$raMNr~hjO
z3`5VcEi&|%TqHNs*9PSK-(o&uft0LD8>Z_E<zWv<WZHxnsGAc|K$6YYIU}H$KOmII
zdzlYM$}Lz0>mTqqBP8>Rg9@B4%FE=HxYc{a6)oX2u>+~6{w1KO&G~njjq~Q}3F`up
zsY(oxA;6#st7j^%c>B7ncU9Y^>Fv)yfW3g;i@JHxn%Ut9O`i(JzZhx`z+!_0$G>=T
z2EdZl%3i?}@}nDjTJr_nVHHeLJT?Zb?f1(_rFW@8tvG#NN*V5x$I8{kRGo`>=_xNm
z1fTZT1u3i}zts_RPVzFa5BV7XGNHO_Tz7vCZ8pyViq+$^6prgU^<8BI3!oVGeb3v&
z#sa<>$2lTPO$J_V8F$?MD}Pr7cbrc#God;4EVBZHHMg7!QR_?d)>?w@AxxB~`aQQx
z^vvUugmUg**$uBYpRmDPfJOlOyn8PC`^?%l1N#x3(-o>RhRR#5XA2jRj)`hoFRvlB
z=9jrh73>vDZ9Ubr?((e-0-58L-+gsSY!2H@b9Y(KE8o=Rx~_dpq2BA!R7!ZwE~@PF
zo_TON>X}e&0Uu&%`3)iAQ#0o9hC^#T;qw9mx1(0JQ1G?c!V5iX)jguxJ9Og}%gQOL
zHw^TrITb$*{HV3xwr95s@b4Gh5XUkx^SuM_xhv@_bp`Q5dReId<rvJ`ptx+U&`JL^
zjxp9e79x&oA@W@lMCQ`XI1qXrD52>lDAB)$`ch_?K9Gc5OgK(@=fXGnVg5cFcN@R1
zukQw%MxZh~^QYJQie7evz6(D~9jBU0D0&_Ce4%~bIo?i$5jwe$mWQ4Sr-6KT2trj4
zG~;gy9Sd5lWAP;f8!9{$^u1th)wnPL1^zW<23mfB0!sH(qhQ=W9ZNQ@uyMpkP{z72
zSo*Dhr?AR!dDno$aprNZhKzXJrs1x)G=jR@y!LR<l*P5$uJQDX$=7ZKED;&RcSd62
z8|X1=XPTh-Mc3YG_tdUzj$ZG_nP4tN7M8&&?-}CC{2}odcUw4`l+9p@O$7H;B-jDJ
zM+Z%yny9C}zvL>4kT7qoM1bQoncwaPzb&Iy=6k|2ia}S}ne;Gl;OMd{DGi*)?I!K%
z0|3?E$3t86a6d-feJB#lG866^^uN&s-v=Yo=sRtktu^E@CzN#7wvD5|o|sZvLclym
zBs*ia5s}dgVF@)uPGm%c1nKlvsAE!^bK3eC2|@L=I8UH1i0#V-idO~Dd>Yj6*%?p<
zcOb@e@^FUAkTp$cffI>AOvJ)9ChKgTI=_gxb>EakuQ)_?weP1uL#qU45a=@Pp{6ph
zv$#vZ16v3?32b?UaD}2?PMQwXroeC@hN+Zkj+*ZayvGET`x*^Sysk2FI4jLyo`_07
zkfEIHwEjxS^Knd?I64A9NLK-vGx{rqx=?ZHqV_T+ftgAL8fMcE95S?rpU<*wOkcIq
z#?mgXj(R-vLUOWxea0NI-hahL#Cx_aUCHlvMknkWRl>7_ag3pqcmr;H1F3A$bcgWm
zKC%oYkU%*!lE4FZEB8MT6QCCf@a@!p1jHnR;Hwco^xXiaz+jbXHfb@0XY^FJU*TCC
zGp(?z)e?FW7)C`4V{Ma<;GBQuYjaSa#TgI^$e_v~5YpSXi0s5A+D<^7Y%XcL#w{^D
zF>9oMHj{DQ8B=r(8{|Ppp;Wr}r{o~`7l`u--uQb3y%$16?hm<zFq&osGy$x;TKQ|^
zioM1IF!yW28jq)TgUn}QaWRjruc(4^>0x_A*mF}3M`94k_uF(Dscl;fc1sGQDT3>J
zw=W7717TJHe*@cK6E4&`GipPWt+tzVe(`(L4d;L*`ZHItQ=%bPv=Q|<Oipdo-YEpS
zMly?m&IDwgM|VpTdx%@zN-x$-Gs?b1C+MOJ9!ZSVY6(KHql(#=3Ib9!60M#?Dq9Z!
zIVvyBCJ5)4WwF)`FtCLthlv{tSaNJ_z~eRPl}v*;Jt&5<o(0D@kmqbFv$$8=Vc}|P
zJB0~--j<59zxbn(o}oyjU8MjVKns%y5WfhcKhl5pz#XD%3$kcMS8e$zPCNMNfhlD-
zz=A&pr5Y-D05eS`Bs|Fg@dy>MT#6ePofqUAq5-a0yDK<WhSpzZDxy3O&Q6Bz^`~0(
z(od|0*Cf2NGB?JF;0THUoKn|c-*Ftk4PZ|6jO?lh+Gvlir6FQ*VWILs(TWYesn7@2
zB*P0B3^~3sgXvL7z=#-Jg?+3V2!0onfDWZzWXUwakyC<ux@`qOc>(nZ_zV#zx_~Kx
zgNT9)kI3mnV|*t#quwaqw81XIfB1nR6Z1ConbZf28aNqNIhv5;wZZ1aT1gK3=%%H{
zQIb}0sti?RK%7?g0Ljv!0Hm=S-$vyc>^Sb}g-y^TuOy96(<&Io)WLC+Y*zIk_~y12
z@F{YHIPM6A_Z$;iueM%XEpEECk%8`je<Y*72zSae^X$`GLzwCydpspn03##*vEQ@G
z-j=+O7c5()f>-RKTRwEjQJ@S4N1dxQY97Z}v#6A!jvX`Nk07Z=PimSXhw`$v=JHE|
zCYWCde8KWi!peR+Pew_b@qO}KFt7rm;EL<xJq{q+C{$0NmyH6fqqBD%v^^P!L3EEu
zr>op-pG8rZs~a)rc#xUdN$wC{fJ(5XJt72HGpQn>Ah3R=<Xb%M5Zv1jBu69A@><>k
z`WmCiQ{_&diVw839i4<7Hm(t&9OeZpD~jh(!od5e$9r;g0LC`qJXF$fx8OddaE?Z}
zaKXUr4jua26lnfT!pHn<OFg0aC7-#BKR}q-mC~`+RVJ=heWU1SW+Wt_t9%pT*QRhG
z$X=oc;VSd_X9ydI|9VuQqgfvZUE6)ZN;trQwz>KN-?}x(9c=bC8KOe}_@M}cf7w~-
zx|C;8(#V#1EL@&w1$e#fz}I(iaa1SVUx(1NGKpo;!D?<M+i+PR06XwM9M?@^Zyxrh
z$UR_rj`0EZJY)U)L5egz1cA}3wU(<l`8|(S`#qin#Me$o9pI2f{c-v?-+%gMfM0pV
zO<)dDObL8%ZW4mgP3AZGDTzYp2&e6N%g6@d_P<X)r=P!Cu5~$+|HgbAupXpQ%N~-L
z5<|HFR+hQ12s|<zV1Rmq4DLep;Yl>5moJ})-MM;!tRNE13hmg+aP}fL9#v3`gXqSv
z(-UaA>e5vMg`#a`-*#q-9jBa#vZ9yU+LHpkgjw_zA4R|T^dkbo5kGE(+I!($QC_$p
z>$LJw!XPOSiD|m<sVi+;M<wmrRHnfVatM9X1TfLT8{h!qRTR;P$P4%zD1U3OwbsQ0
zrmG7R2hDcuZQbT;5!K;c;^bFjfON7c=3&`8Q}_^n#LD~jIpsYIe!7k}wf=>D6#)X3
zahvB<y+wT20v9Whej6&hDvPRv-V5-zNNu+Inf4f(WT<CY^z>^;VW|vIz7DEiMc}%F
zxIygRvZ+*yJ>($%zOukU%d8RScGuce+k)vz2X%A|3Op9iXiSkI%ZpGsVNFwQ_9;%~
zx;AH3xFMpTkHw1@&+`{yu5Iq&XO@B^K+o_84)rnjDYzHFL$Dl6r1rM0wcq+DvRku7
zbC>E|H>!2-UkDb>!|P#B{c+TK9jmkd7uHS9JET~yO5A)YcormYUSd5JQk7M}Ob9Z@
zASB+cKkQGF@z$2TD1ql6fAI*%lyQ10^4LQrv=XIthqK6F0JGNcKmH(-Q(_TJec+v{
z+LneZ7L3!Iu5u#1i=rO)Gb2=~5_4V;u>+FmB9&HzI`pjQ584P48MpQ!R9HA+fareq
z-?+93uJYr-nc9(R0BodXYqlX`k{@px8#rC4w(CbT+xSRDYoxeyPZyh};3oM=qFxI2
zAnf^Oe)62o1AnMVaT;S~fL3B9A~3Cm(x+$2g8lc{Hp(($EA`vU>Ojt@U{u`kGH2ie
zH%27N3(?7oJ55JZuZsJ7+`%`X0$?5{5G3oX6-aayr{hq?Ee!63;i%7g(DF_;%<U(W
z)`j|m9twotjbUE7A=J$Z6woA@yMV4khEwP|UFqvhe$%<p%^<gg8;q|pd{6vh#1bms
zXTLjmxwsGu<4fqo_vQ<ZpR5nmz)%BgiiJuQfNhLJ!7T+PFH{Ig8@JKMRsPv&!Ca3!
z(L(`BQk)!!i-Ac%4}`(8IQ4!aI?2{%ls2U~^bbaDs~8d(sV_$e`uE?bxZEzm8wz(F
zQ_H*r26g&Yo9Bf9Zi}fro>&O{AxWYjm*mSunr^?BbfU3nfC#_>X(M{Ks4h#oZJ=I{
z;?z~goYgroL&J4OmzXhXH2C_XnTad)>WF_ZA-wB#1#tY}<_z~Ja1Wvd&c_>hI*mcu
zD-uQ9W=+y8VO^lTv4W>q6iNxV9cMd1naFs~jeAG=^^KQSSnNA9kd%+U{Lb#GW(^yg
zhYZZ#bwKSc;hVf2ZgZvcN`v#1#9MlhT(|Q62M_T-Q$w-(@sZsB^w9tq@=~x&Gi?|1
z`;_SWp89B-HSSsfBY}sORvnQkTUg;I(o(MLc!3ywNV1n{Xe^1h6HGS)=ti8Qv|U#;
zLu-R0zELBf{McdVr$LvJZfwdTVpU>h<1bsSUY(<4v5!UMf=LLJ-Ld3`o~4)q03VUh
z672<o&2fUiQUdQDRUr@ZPfG(LdL)qtOUjp@Sy=X<Ee<nl-MA+~r~~kkX+c0Pm~D|*
zmG-URKcpym|JmDS;VQ{zv#dqUw7K4t#f!BtNG|yImvRQWD<e-b+=8xQihaTG%u%%N
zZ6}TcBk@h9*&|?K=KZC_XAMep@|RkWvev}au2&lQC``Jpo9p)N_J7hjyA*r0)9Mk)
zU~HLmtDNpPNs;tI#0Bf9v|7Qx3Xi<WQrl$nk|=Om$>$qq=RYz2)<kC0pKsQ3*w5@&
z0=9h;hXnev=NASRFa|FX!Z?O+?_MNV<6ED-LyWiMT0W>#fAnUEg}NZrCXsD^`NjRk
zFJmnOV~&r3?oEPD5Qp#cW9bz)f<3a(gM{>RE>LhwHHLeXI(QCE49L)1=8B-@a&#C)
zGpTv+#b^ZP1ptAz*ytJ>%VFLRQ=8S1+gy`%5E}_=MAT(EvS>gQ$JS!AIhAFm+8+WN
zJRw5HT5F|LdFFG1$s#EGEjzjet}R(lq^SZ92Nl7tWY*8g_;VJK;KR8jpn%6>^oda!
zm3oqBW6^@-O{DcbDrACkBv2CuYu0r5%QUW5Rh>q^FOrC^0v@V4c3xfaPtOSCTd$he
zol`7I6(I3WEmk|&J8e!Q<*KS7U`5yK3e;iIKQy+t2WfV$(sj|pyA9-k3wCLah7>sX
z;HD_o)gBTdHR+6Ut?n%Bl<x5RoOA@9sd_y6Zo1a)dYMIkG$JwgE14Z{PAp8s7}w6T
zk{X*fKfuh}d)1og-$0lppr&aydgP;WftIu86SM(GO6w);I2Cm@K)^SP0R-w5DdtJK
zz9)<6Jl#5_)`I*qeMbbwlE=SqSr<q-mMH3WN9>!Vr6{7DTF!HxDK<|9H`o#-*KtpT
z+OOh|U~&h#is@#4Gzut{u;fff3t$Dfz>T6YMNvy0AK@W+xrW=|n#H;i2_Vup@W|y(
zhwvq+J0MQONCY8TFjyE*g0n;<o0GOM>$Fq=^m!9CUhaG3uD^ROcIAh3y9XISd`Ie3
z9bNg43dMD{yCFuk$-F2?&k+=G0_oAhQh_`2$eJmf1_w9s;0dt+E@_B@GKY6<^0|~8
zQ6RvbQVUHsuSgd>e^b(DS8POd?l{$79Dzw30X(2f`BbgWsSbw@df1$-MeBtKl*Yul
z#zuBV=y*spMDGqUgRG>BO|i+!CHgLhWlin&gUI{5FrNEfI`{!sgmv$gkhw@7rv7ZM
z!64Pd(|fgZw}$6<ptI}Jov9)Cl>lT<<ld#X_X?}qbvBRjU^Z9S9RS7QjG^j+6A@=(
z?&-LWe4u)y@qO;9&S3v?m75U^yq9xBSy5A&_ZB}Do@4eVzM$<_qQZ!UXEAT0!Vu4~
z^bc<;)1P@(MS=mb&1TUNdsE-E;Uu4?=&n_`(Fd4XE&RGH_MAT*e>p#AWKr}>qXrp(
zK^mY^pGRVq0S7=TRFR}k!%QZ8eI3DCFxAr3c`22BU~D`?COHIjRuKA)rt$_{rU~f?
zt%GO`p~J>4nmd<m%V#s-wA>Pryjt-0DGN_h?ZS2d!qBCt(DDa&@Dz%JET2|mB<y69
zV|_A%xzoo5(>ySc!8&SADx1Pbm4l4JnIfN?8fr&Po1f3_`k(P%B8q=MW>T>_13NvZ
z&Sx(u<Qn`VvgDD{32u!Tw8ymVYcC)W7vibj#t(BB3TZiIfDdQP$9x%UQxYw4H%45D
zEs6v&LZjxnq&)rEv#r#c|104Nu>$s^{MeC&2#6sjpDiSoYKhF8fca5}3zOSrC7Czm
ztv<yme--}}uh1MwrQ?#YW0R%-*^FSQW>#0!Rw`u3jXH4lDPClg-y9nQwDDXU*4;Bx
zzrJs*tZ8f%csu~tO>LQ?@p7mDtN1PaR`-7kKMJjW8+*u<>&5FZ69XdXVmFZFQJU0f
zID9t9bj5oS{+A6}t<=?N0+&H@>^Zk_tfTx_`6hJUUW`jG>rGtkmd4OeD)a<%;9y-G
zSJ3GoNMD{<P;6F``UYu9;7aRx?)e8q;(|6&3(RJ|TrfL|SOk%zvn!6x3Q&{P8&=VS
zDh0pHW|;*qn&qExA|7`&V>0LvqF!kOsMEl|3m7R(&u}OBzAJ~(4k`a8vGoh>ZoyqB
zn_>@TF)E8*N|yy#$0?0`?)giJq<P=a=~bjhME3_r(8%B;`bxxoEaO>1Eq3&s?Xm~9
z@4;q31<<;WFK&^>;rC@sNvo5rsB~>NFIZdeoJPEtl?bRPEXN<f!&X%nGP2Y2d+yMJ
z*~9cH<xPO9o4366!9jcQfehgICmd*j<#UkqZ5G~Q+m@7#$G^<QwhJ8Ldz-daDy>ah
z@}wOjh4+(AfXPs*q>NVt?B*M)7~7|_zh;yNa1u!feh#PF2v+=MQO%Iui=dQBD9-oT
z`<l-ds5?5BOHT|uAY-vBBBLJu9xNw?6@u_YXaI^}U=Hu4JdbhB3~nR7@4<Bei#RU9
z46O;tWOJhjR<gTJ>pI18S<K~;rg1#3Bq-8<(8h`s|1IDL5KrIdo5C4#Os|bC<Wk{R
zIDqrKlVrp14w^qEz@ZO4BPh^f)w|ljRR+yw-BP1>FfeoZW37Fl?@%8tSy|PmUqy_|
zk+hgjv2`Nmxu8LVtj5(*A=ER593sI{Ebtj+hw!gs$8Ph6RpeZw=)0-Znb2zD*qL=#
zaFvb*e|sCjk$EY3Epc{lx1CHSzSEx*t{C91+~{COUI@<uD@?*$q=M`i7OXrHN?e~{
zj2!~MRmEAcx!gnDwpbFCNF|x&TAiUCYKjm>0Z!1lr1P7%PyovC`@**$Vowp2!)L&k
z{bjLhNk7)6F$fWsJm$slY%JMc14zafDf$TobX>i@H{MHL!;I_zd2$ft&D4TEMj<5*
z-UiKoj~ttSG#ISNuw3U%gsq_c!}h;50Lfw9igF-G`V7FD1(Xhvi)cJ^P&i}LfFRKB
zCmns~Dr1W8f$DGMx*QO{hwD=bqREMuPtUK@58_Q`NAPD1@6D(f@!P!0_t-C<@4<qn
zl%aJbIKE&V-U}JtPedQK13vc6B~d2eMlV$NINJo`wNy406Rz|5=#&Oon1{@_<fF79
zSQ1<IblkilT{&n{@Y_h@Cq$N(AwUUIAdDhYy)z$CPzA3dE5nl!Bfu3(B=0|wawTXb
zRKoi{3IhS<$_<N^$wNyRO-QO9Zuv##zr<g$iZVl@ny&(}s=JFS-1C*Owa*GPt3iHY
zJSTmeE4e&m=AcvsgqMl@hq`?{c~6laXnyG4euCd-^Rke@Z8ew2n;>}-xY_d2!cM_%
zj}Ae7WbeptD-Lx6!t4)CcY{3MPalxqERIXtD55|Xj+4a&0YnFQjVe~b<1A*oiQAR%
z8$p39?)-c3Qc?<G{F13rK^dl2Fx-g0x;yZ2mn`(3$sy1FgP6v@UX;?U5&%-3LYjy-
z(O&9x6x@8sqmwcZo%sMG@Fz)_=_mC~aW<=098_x@M%;a#*xdMqOVg6R70&KK_`5Vd
zXWX7OChd=e0_Wf6`>TwUCHu)#1JwD#Hfi~_9|X1hmQ?C`(=MAA?}6FOBVUWg|Jat3
z#i50lqjIR*jsfM+E#cMq)9*F`-vOV)Q-ppb6`VQ=>h9xbsnrq%?AKvfvr&B?1@?5G
z*%j1}ty`ya>Bc0Cw)EmvN~O2Mx=l|YFF8bkn@PKAXv(f53DQ3Dp9DI}>sQndG#?$Z
zTAJ|AbUOc9Ic`wE$3k8iN>6o&pF&a$5#Bo~<?jrX%=*uaqlh570(CH7B}qvtqLw?o
znUnDmWK1M#r%=R^FfT#W$W)#(8vcd3ClHrrmjkdtfWttANK%C8w}vn$+Z!`o-3Hx%
zWrVqvos*Yu;#1HVID(QN6_XEV#RsI4p@VCHhdpaqUj*f_ivJW3qP&FCb<XjYoD2um
zOU4B%>{2`geU}3Sv!a_gM|(|kO+dudFRl-?+Q;HQfLGuVBxIn@X2C?&zARmLS{rs6
zY3n6|IL_rxiViNJ5blP7Wd^7y`b(;ZmI(=QcSY?CAH)RLHF?kM92ct;$L)dC&G!cJ
z530SiD2(SelSe195v<+si>Pn4EVwfOG82O+Muq<pnBPQOAMQ{AFdch~U7W!Qy+1^-
z6pp?9_xy$+U0>&Kg7=avLk8uSjO^FuBC^@P`K{fmcWnoJHk;g<EyyoEZI=8w&Yl1?
z*lJP0F@t%2BQe6MD>Pd8VwtoAM+lf}`}VBjB(Uw!*@t3;Zm#-5{Vtx<<g4ItxdE=^
z;h0+XMgafX&<vX*{NV^+pJ4FI7KCjWv#2W;)zHh4yEB|4DMna2Z8N&8XAf|-FvG$e
z4=6$IHdR2k1_{eC_;aj-DJbxYZC1|~gwtqyKSF;W<cJM=kI1)ODU_Q^8oIU-4CXA&
z`u9V3k;l<>ZuzL~jH2Z!!N&M;GsHCoAfkIgXjG%MTY#FtIMU+txdjY$U`y9PBpAPV
zd^3CHG6$Vs_qEC6=Fe%B3|`60d<V2^P!$LU=mi-KCz-y}M|@V>v+>6yg|2n@S<!2_
zih{0~g`{so@S55Qy06<t-nZZt8k5D-H^>wG!LAMlfI{DZV*)OY6vIszWe-vsgi&1c
zpE0nl2}CY7DSXslU|1QQX1muXEq0saPp-r4(K4m?-+S)>_y8uQ=mk(CiSG5c@l+qB
zTfFj7{IoDnVV0~@$4qSYxBQ$ff}c132d$`ak+^c&znuqa6r;w6@VUCFpn@~t45Zic
zmh{x>yHjonIy{WRU@VSEWC!la#o_Lo*Xdl_OO2qdT@{kBsX&3gi0@*_AT(cl26bSr
zMV3<l48Vqoy*(m{_c=EfK8~zX2-5`Px{$iGK`PQr7>+PBXEXTM>)ge!Mo|xYNKW<O
z>fuD;f5$ChDh8q&oiO}Y>6<2oh^8KN3p+p5ohF!XFp|#zP%Ksopl_j2oYKNR1sj7l
zji=zp#lM}LlYl^n;*lt+#E^P1k~P6%pDm#JHWn5o;S>3y9yW35;{$dl=EhazN_Obh
zh7>7B>qVRCQf~{?J6s8l+Drxo;ITOp^yMlXE=(%nwKA?fKJA6laljvkabsNfGiUq0
z`qp@@eGE_X036>?Pb8WHmSvN_u+d|80hhTciUy_Og(kafUOlbkun+u9vs?X0=YXFQ
zy+CE$kt`u&EueWx3YpAhtoEQsjJuklJDE(-TyQ#-#aQOOK**USmdnK!135uv$p;FV
zrJJsNie@>?6G5by#&Q!4-=4C6ijAfs^#j{|%REBD1x7vzb{!<+1Qk#uQV#~1Px~tU
zuRKv$ES6&^wrn=9&ONhP$G(msYHsO}dt>A{hZxVJ9p<-h@g)@cU<Wg>{(&kYj@pw8
zH^$Ewx;1F8Cf1xufGKdtkE4!dh;XLJ6rFlzF^js_q4h^7SoZH5(pX5@|FC$AV+tlC
z(JyvLAzH>su~Uy>=Pi=N^O_e6bX_&d0GTR{Fe^{72KCphJJr4=fqA4e0;3eH5s6{;
zijtyH3!sF@!a_HQ!$XZYdQ=TL-})24GSlgoHlW$BlJq_UwU8(jG0Aid-oqR*Wh}N_
z=h97B6mbI>(smF8E%5s;a03}6s-2K911od3u@r5Rai3z`9_4Hs6Z!y(wlVyf^Y<kN
z$Ts3<D`s@y0S0x^VEr9JOLhk9xW9sCCNSh;xC=zLD&gV~Mk(7lN5PHd&@9r4){7R{
zbQIuW%|GB|T_bakl3zZEAHJX?PKK!4=9RepHCq9%DpC>bp(=WbnYh8$)*6%6MMGD)
zE7+=?QA*dzLS<9Tvi-Eql9hv61yx%RVMabZa({p;CB7m?C-5=PIv@mwp+<yrg^1&z
zxKB0|K!#;)ayN|t93wiu#UbAm4nL@G7;LtOeL@w&Pw>N#o|%}7;*{j~3UUtx9NC5t
z2!8MtTS6@h=C)7_Iq6Zrb{5@M<6A&8tJ>Z0n6#OlTS7a0=>yT3ceVnVcd+Z7EZ$Vc
zcig{a6$0QdLiMD^O8&Edp%iSV+^*BU$tUN@0(ic`%uXy*tZNvtn;Lnf1<f+K1MNmN
zk{x6mgtz~^^&!qec80qUc#P~1Pp#S?AG0!L-WRAflQpXW!4tU;IcTRv>XXD@Wc?(y
zYd(z`*NwRQ0nLau7`XnaC(lbMBD(rLF>f*{+imig%*tUO_uICUAq)wOd<AUSn|cMi
zcqmd;T;c1{x^3iVqS~x+FHBV4@h|sj=g&q)n8x1`4m_i@4^OxYVJ2E{H=Zg(J8BM{
z!Vpvbo7~&&C4=n)Bl$QxL%a#-Ad&YL?SgegF^ebNS03{o-}P5DJ`x7k02m#vvPocr
z!?KFtg^HJ@VU(=|;<kT~z=2SLxc%0+SaT+4WvC%&uY#l96EzW07w&gb+aOB)Xqk4Z
z`MUhtMPCijPfu|+iCnleuA!~1Bwc_FXS7v-W0-qX(g>&a*{KHc1v4;UL-brM3WY#6
z7yoBDw`h_&QnG}T@p~M?SG*|N-b*z#Qv8{r%g+vW!L!gIz~_0-(Z;BVB>T<3+m@sH
zCo-X*XHZ&j{qb7fX2@LsOp7p@SWbGi)pnC-^&*#b0=SpL2VD9`w#5k3%GYh6m<|e~
z*f)NrupuWN1@#_bTtdp3;Yy;8dk<KGP~Sm|n|?Z{IHIUdq<%t#7u;w`#mGC7`xHSR
zCXQo?1wUG+^YkL{ms;=I#}VpyHG*D>eQn9Kh+rX;?uj_4(b#v+M(+ef$*g3FG!&XJ
z1o)-1gBBy`TTU#-!h6*?F{sgthJXjVL10}iQ0-laM<!ZM6f!8iAT!Td(I>{;8@niw
zJ@81^%|QJ4;TdGzRE{{tmNBs?aCd2TU$`ea4}&_u=@9i@L<=OZH+jCqf18YijJWBL
zRi+oiH;S7$LAFUpuMYSBmQ7mQ?OU9W$#XRGP0bF%&Q1p>b2K*o*Zi9QRWRTqN^_2V
zRGqho{qUr?K6Fmo{H5K@JVUZsMV_HOf>XkKku_p|pb{v1!z-<4!Y+#!V!mPK5%)Sd
z!@qTM>`8e?cqJ|P<6d*#Jf7B2j!P>KmdiXpR(da+Vw&xZWx7e+*nd=W0C^%rLq8Rh
zp>^#C#2sBU!zHV$EMeqj4nx(b0Lq6H<%4j?o|0&VaA^C+oI3WsQP>E1c^)8f6hDB)
z9weDX{ygwb@~+_5BJ*g{E8hfnET&sd*`nCv2N|D~-;=jq`wjvAQaZ4d>`5SzB9!Dm
zIZj^&3lJrnsbUvnQn5Jn@CMc(r!e0GIDC?BFS2EkFqlHaX(Ac#?Cw%Cm7Ug4M11EN
z3ixX+l*i+z+Zo2>!lPQKnXugaxoo9IT$0G3iQDxf%Wpw$%p2JC$uT{2%nf5N#p$D1
zrv|yLmd^ylqhB_oiG1)NW3Qc-JpzTzTgHPsA6uRAJ>bz91wud6SeTdQCX>Xj8<+Rb
zDzOPeH0%iSWHZ~HZ$BBy{vtMen1nBMmH#W?X9%vp)$CaV!D|*B#>+fq4j+WLF0qyj
z!pt<@iaf{AhuJR>H0+~Ev9>4KLF~70rd<qTV!&Y4vI*$7Z)_?lysnUPAMF)>oyEhW
zW(NDPr!K-I9p3GH`p!Zzl}~Z(W4dID6l1vV#OH!-Vy{=I>;y(@d)IoK9iP6G!$FI2
zvvoB=6QhEb7I(+(GebnS#P>m~z1*I~He36Q4Ay3+nQjs@t#sey-*-=D^#}a{k_P^+
z8Rb@n<qjgor;U8<z=84>`1NIx_~+SsxC3lc_}TYnZ@;xV7aMH`^RPd%%@Y>mH0f>#
ziL?p^cAo&Jlw$!)NWdfY#~Jq$Zn^&};G5eq978mKHCHS~C%FYWh3t2E5w|(al0T!E
zC@BqdJ1E7*3m#ZFn`%eD4fY8!;sUS6+0zfd(*e3+MD0G;bsDz~vrn%u%;vjA9FYEY
z3G#GWyl#CxS1H`oN*2h0WtTS}i8#dFm7q!Ai??9)EKN}c?i!5X9zi*P$6)|~ylMPn
z<!2&5YZO4KcpID2dUC314|BWD{Y=aI<qxfrPDlb#^=&O!UdgI~v-Fa>=m8Hds#$zE
zSzIeO`D6?1ul{3Yjui@R8s#OQvarMpUUT5z+2bcUjkw#36M1kMxmqcEs*)vkL0n_*
z5cK>jw}c_aeZMWvD(Tn9XxHvQvlvxk@V^1FjD*sDQ7b6vG@Zr0k;6I~e*4M?XhX7$
z)g;+1eE{txG1+NhrHMa1L&mm<B9h2^wL&$1ADUI9$q%CVY!q5vCuXl19wd0f>NEvc
z3d>{Jh}!=Yas{8iaGx=*j>={XSLcBc2l+;tIs|MUKAX=3RrJWmdJx1CH@CqcWvcc5
zpz>7Il)jHe3}>#31LdRV+y|C>x!?@-uv)^!++w!fz0zN(PZIq!v}Q#}I|Eb;zxvCv
z(sduH7%djq@35S~n!@3Dx?CX^z-F~xpehE<9q2+{JW8O9(zE`+P%utlzwv?S-GIxE
zj7N#+tp6|0_s-JsS*LTg!99=lf{f_%4Q$MD7M7sS$5{3?f=${I9$X~E)CewOAsjX!
zzG?33Cg;>R5Dbze+ci=k+=*aVaS+_{3Bgn4rp}eYGlamC{Do+26y7aMnKB=+?#JKJ
z)Gc_Ul}lQG2J=RwZG_}a*FBP}6t0FwKJg%+!-5P}@B?F{tD_}4gMh-7>C}OrH-nU8
ziCDk8YM3Un5y1h#gYxJ=?2xq1832+4da}b5RSr6PVzmC02=`XlX<{@Rasfmxg*ygO
zA0r}kI1@2rJaDq$zxo6>IEmA$4gHnOGqsqz4Vns=0^L=-FM7{nuAzu7M7-9u?LCdF
zu<9$i7RqA{1Wag_*I0u}Xs}zU3UZ-U1*hMpGAKXf6y`+)gw8WeW($pQl8DhTqs_^_
zFz6-SVxiF<THoU|5iNo<jvt!2mY5rqs0Ic}e&S9gd4+cF3}4duxa&c6i_HtR`L0;N
zFOg!gFP6lTLm5Q8EDQY_-$hLxIQH$%X_BlvSxYgXconpm=!2YogMsn+Iae{-b^s0v
z&Oe>HQ@0REB4gYhKUz_um)Z{#gh~AA%n1)v3Db&<vGB;POGp`_39~<+;cVuBAJjcv
zGYXC<l)Xhj6td%iF)#HF&f`3&NHtwT1TjkU-;wQpv`>DbyZp?9<_&>ig+@u*Hn-wr
z<x@j57$N&yzF==&@h5o~E2fW^*_p42U%(F{4Zi%|sPvstHg-LSw(=bvO4&Oj!(WI4
zgZ)II=BqP<x2=ZyKNhbH%HAl&JTCtzruKorA~FW!BREBNoZPfQiIh;tB$5>nE;16`
z9RLg>-jBGz>c<oJTCU*+K7V_Bm3#T+KH3G!Ln5WN6Hx#cqCUcHVGgf-ZuIUQ<UTYY
z`utaT>b@P&0@NdSO=tWlOd|f>9fOyHp5e0@1s<`Vgj^Vw!g~3WDs^~mbmv5^)v?>~
z<ghP={3_uBi+$w^WJQ2eN*G+#(e+0>D(YmBTlpleT-CA&*@yDn|A0$n3z*Q)kv!vY
zX*_>nm0JD_t3qcG>1U2=bcKnxp76W2$Vw3!LF8?^1G443fw+k1UgeZ50EehB?E><T
z@vW|%mTjx??-{ITGZ9?kW(%|mI^ofqpEw3YPGEt_%pn-+;j$^fO6ce_%(T!o><EIk
zGoUOXtNM;U(f$wONMv`_*k*w=-coZR>;8CEbPV;FtMG1tnU$kFkf8O+FCeAq3!u&a
zwg|dv1tMD=vNVW}fjGoR^Ag%R9;`;3cSr>XMN_Dx>S6OlBR{Eg_Rj>PYbtysFU5u!
z5h6LSGZkVtbDHh^CM(z5doIhy<$99AV!;p%rD41YRxqj<yy2?&X&H^OX<szSar7qm
zHR2BT2L}Z11gBu|eHEAlK%ht%Cp1B7vDfO2J@2?v=%;0DxrXdcrHM93`F5&82FVB0
z#8{Kos7x#+2kZf%D`!;ya8rg=^4&Q?qMhzd>AV$YX%FwtEEIx3jidU2fCNnuOxK(>
z!4~*8Fbg&b6`Uqi?8w%j7T|>R0pJXgzVQWa!m;i`Y(j^?aU%kFjWhrQxL&eregjDK
zSTHkN`6<DavZ0RLgNA<|czwtyDh*dz>9${>Nt#-Q{yc%FO0<RJ4-am%zjuaN-G^aP
zDft_`HVOH(6%qV+EEBJeJEb%{k^&hJzT87bFCZr#nPCHb2Z%LdMiCk31lgM;yD|$>
z-v8IwS%9^%Z4J9cihJ<@!Cev{5NM&eOL3>TyA-Fzog&4hxVsf8Ee^%qio0u(Vt;7Q
zx!<|>e*g1)napJGwSDb1lV>Jx*3Q$)j{tAqY(Z^5?bjIwI(uoKRsM*H(p>qpkM1@S
zfby}pCA!nynvx0Vt6}T*G>W_xJ(Aam)gCu&O!picKTqQ{X<KSa`m;K2^%G4%fn;XQ
zM-@(dsdvwn>^J647WCQFoyCG(%g$)0RV{bJr7d5KbszCDo`RYO{~@?KiTF)d~C
zSN*~Y%i<RLWp)H^d?YiAJbx@bogQGBlpHNbQC)F~ECY!rBd0s}Ct8UcQDQdw(@$B)
z01<}4Qo1z(3|!sfoif(I9y5QzKv#8$etV{HF6P)EbFB6J;mm^5oPEU>J>uQF9}qm#
z;HQ)|@Lj-up`^x6`_`?u`u#=Ox}Jl1sx}lB8wqv|lOs-YZ6>t*Kk?-ZpNkfh`M(ib
zZthZz8ByR`pNUN@J5zu2Q*tp|(RSGrUhwVA{qglQ-AmuDeOc-kEjTW9qM&@YlP9X-
zD&owxL}uvT9+nuLo<Aq>Jw7Y<_2q=1;`!>(ykhmMHG4Kg!~XswUBTxPZAv@TXYm5k
zpJG4%P-!hKGWO2RD|S;nEMis>3Mmwu<p`mV2zf4ViPIvS<4*dr!c2?e`9Z$%=s+xz
z?_1bEclDC6oixO<4(G@w&NE;S&<Qql0NIkj>(v5A^7TR;?&G8siD!v%-+`jUltMYx
zPY-%Oe+wt7DmynrE>D^KmX%K5GfGxc1#otmKLipBT76a@MD?dqQ^waVLKv1^{020P
z`-v(u@Ek8*AkUZUO@MP}&6^USeArR4?sDQqt1nlVjl>8uTzJ#x2NE{DtF@ljW>4Q0
zOYhXbeNHLPHdvnNxK9jt=klQ>nqzJ&^jE`XXO*psBD~vo4gET8(L;WSPzK};4)Ky1
zw_+Ub38!S?mK+I<O=$y4<&;C6TwIUfw2j~9PdZkG(Y|cG)SU|dT7C36q^de<iI5ZM
zk||@$<a$Ik?P?M30tn5tg^OOHGmPXtK)p(YX(H8>eaAtb<jhPt4ronf!L!cZiQe(L
zZ9%b5R*2v|m`TI?`M0+3Pdx&T&PzWa=>_Fj!)`GZJ@oD1DqcJT#pDg6%4>dZgEOVc
zg<PUV`;`@+tPCt7dv8%)$;K1Iy+@DuU~7OT<&MuS4Ye>O$rB=0BYaC3FfLYP81rd%
ztA&S;%7Z@K%PnZT^0R@v@$q#qM@QPdC=bG63fVxE&zL#8WA~`CN#3f!;tT8u05QIk
zO(y;LcUps5(CABe-CtWIfrH)qjkT?kC0V)sN;#`nuI@G$6_cFf@!#T2%43=*9JfSl
znaQ7%;$?%+{00y_&@w(|^)gOy+giPrBLvMnUxh?SFG@S-^~KqUL^dcb$<+YN0HE0G
zYh0Yl_+eW|d#G6Dp~~yHXDna=6s=%7j=gW7LjTj4obX+^CcC$a_%2iS>=|s``4Yoq
z%pCiLito7kZ>$t8IbS74q4&9>yCmMdea~AXtc$%z7Xi^=iyP5IyhKp&jQvFwf)dyZ
z`wc{^;Vh`5>27x8;c4|x(IHe5TjRf6qrgIsPE{T~sXTtde5rtVAiNxpIUeJj|8lzW
zn8YsT<}9J?40EvpeDUH@@F+9jfJK1pB0@kAkln}tb`%hJO#5?W7q_!@{zq<8Rt{DU
zAmneyEwD_m_g{^H|J4|fUB%tr1jw#vU}gfO1%iGzu4v$B0;>!3cUg8h6JrYlVLLaV
zHcZ3;<c4yyfqA&Op&%eH7l@6Q7s><S0_y%QD+22UtgsXC(TmI<moXBKb}sh+=-HnZ
ze@p)!nlh{(js~_)_Kz(ax&JMe0y;aonEV|Rf#ni4akVfqQIZgT6#g}EB@-t*7e^x#
zC*Y$JmHshK9$5T8JlXL6t6Tq@C!0q#|8aQ(0)jwL4z7RmZL{Iw>GfQ-{&2C*Qr$)U
zYcbz~yX)A36dz>^E*=~L_IKo7nFw4QMUGb?-?p(u5z$kgh`_<&>7j(-Xd#Neiil}L
zfX@~uhvVdXXU4nA5SDG!8G$50Ps9IKmG)^m|JDz|qoaFUb=PUnqq^2F<V$m8!YGue
zjIc)poD?Z~w|!|ggvcoOvLPHMn?}(Hy=hkf;n*{jtd_#7_raT&p4M!XjBfH5FOHX2
zvnxuRw2$4`TRCknN_PS=hiwXwrMhHtAFNxJXXt`Yynq?>!#>+FVyuy^K5jk~8JQmT
zivv3dzgF(ZUmoB32j{ah5p;}sz34fS`gFCT+2z0Sb<IGFi_#i`BZ*T%5I*A?uSQqZ
zq}w8%Yc<g>jTn>5lWx-*T4<I!3^5Zm7h-)r;U`9Aq5Z_cM*q}u_WBG9OU5D~)<2;4
z#1KV_M)~}CpG~AI4x`@19P=u?BE>XO&UaBKO%|mLQ-_V~Y}P93xQY7Bf%^J-)4_Bn
zJShtB`q(6;++cDFKNG!3bg$%)44b@OBB1-AY+WIaKeo)7iA=f%O#MYGc8Z;r@%67s
zp@iuc#{5X$>ix+M3@ky|1Cy1NK&!V9F7y)J+beR7y7ejwLA$RCGrznBR}K#F+ouRK
zy!W~;P^;c7!E+`M^`hqHuAx<7?SA@zZ84#2bX(6*64wHt<>sw>)%ftKg0e_Y8_$IP
zHTFTJmbFi%n|SUgl7b<KnW-f-h(s>2yk6HvEn4q&g*j9!iqz%WM%+tWI7pEC1I~aX
zAfdQt52Z;TYg_0gh+Tl4ayXN)7j2VvGmoI4JfuRh@K_yz$&VR#Ixk3BTM4g8|G=l{
zCeSYc&R6IYP$NxopB?i#Qa|qZTa)+IZ_ZUZQ7BJDO-(MoCS#7oR;P0@f@qudA4=cU
zqa>!;2-5=YosY)chq)%Ev8;3&FO6@wnObTamtWnNb|~MMi1jitC08xq-q$)D$h;+#
z^Sucak@%5Ua&xheo-!9?D)S8ZMzFGs#t(hMC~aWXFELb{loda0&`_+Ss?c^zGI|b@
zi}C=LGf&~);-RO{IaFmAW32ncQ|L~Gq+CHsftr#x8dw`pLDalFlI6s%qEcCQoBsXc
zxcEf7{!WvjFjs_s%YtHPoF)x+(?RL)LZN}eTcolwF~v|js%+QOcrw$CMgSfQk8|QK
zfZ|Dfb!I%XRIahmz1eb)c0=Uj7VaODO{zZmghtm?;nNpetiHQv=Y25R5Irt9>fb(e
zu`^#!w#XK*gLcH4G7Hy?ez(+J(G`p2O?QG(t@(*JDa4=H(sUd1;|@zSex>15I}HH2
z*|)h>@AS52*6s2|a<>4%Tinne<(JPbUm<9T6q@fNe5Vn&q)F%(eUJOBIXBUm>4Pyy
z3UZ6+pi%+J!8D?mjqN%zo*bL(Jffr5LS!Gz-(Ry53{OxSLNH(1yY7ZR??^uvG5SH$
zY4g;I@}*?eVxk*$ykp7N7uYx#eC<<_vFw1Eq*^_#HE$5>7@^QNyfqn=LV@F}GNqI`
zNIeAXYh6bFuqcJmIp<)!yiSLXp`KdDU}QVFDWlHLU80{gNlNPB{A{u;5M}&s96nGe
zMm7&+Vh_hZl(A?QW#UzfzBGHvg1h|!l~{#@pTVB~I>m8C0a<FQ?`>8`4~gqOzhd3b
zt^#_1k6T-4pZ@EcBg%C<t;;^FtdV9O6E*ewa?7puRYcl8#vAzeSbGWk*W9gdx4-0)
zP*Jv*K0Bf1R{5la5r^=8QyLwiy;Jv`RueZ?%<##J+-vnGZz<<zSwieZA>2TL;Q%!@
z=@G|w1xM>UNZTTvL=A8!-cL{DXccxv0IqEoc(}JH+nCi<S9d6lVXSTJ9*idfN3+j$
z^FmdPmCe7@=S%n*p7r$6fY`ccC8ADfE)?0hxEr|jg^8SGo#pH+Zr8#*RQ3`EuF1$<
z59sKp8plSmFt5hP#t$X^izen1>5@U;9_-#J6nI;>el@1nh|;p(y(g<+|8ae__0T4`
zlDOrguQqmj%p8fYEiK@iDSpShB{+L=`RttC(|VJ|SGM8|X~;Jr=DsZ?2KJ}m16*I{
zOlr?4J!#7HDvIt;f|fKQmy(c(b4a26ls2h}ST%OPWW(Il#E!puYU)r1xYWp3ud^Q6
zS!j-NJMxMQ(dahEbGl_>gkyU-ETmOn=4eWu+_s{FSC=aeH2#2*#*AY|8cHSQ5%AnK
zuG0I9r(Esimh_WM9=19A8&f>qPF8<9)Rf(!@6J}mA5x^aKGM*VEVb{ZY-MzO-O6Yd
zFS{+Un!Zw)_<nk2;e$GFkrJpan1a8F<_4`;M%&hEN)nKtCIP1bMRodzaL~lFggm&)
zl%zho6ltrn5Z!7-7$u2&sf`+K@^(lm-js;rPTH_lEb$L`e!Wy>=QMnih!x-$bRGVs
zFhP{(v`)LebOV0p#47$Y%IelTVe!5I1Al|m)#v1dKC|Jd{bY;!SzbtEaAy_|Jsx{q
zg0>p?s6U>2W+!zN<Iv-VL_bZv(v8))blElXIQbJ-^6b=;&Dfn1bvd)i@t`ikp5QgX
z5W7&bj$RHvS)xrcf*z0lodjnqI}`F`i7k|~mb2AT<*l5F#ZMNp@GV4~@Xz8klSLr~
zN(3_VyZZ%8NuJi-16V#C6{kjAWd}}7(`fu^wifoN<M{xAsfwl6j4wN{ibs$=m>+U2
z&hEXnG5Cu&1d(ZDQ+a!zEYQA`gYc7qpEih6JumPuu(lBu=qB$9d1+*&y9pXal5dTl
zwa(X5VfUBzn_i2Omd2^RX+%P%-RMuKKvq|`nPX}Ex+=o1zv=(=Hi7(ZUwLjKf@t-V
z(sTX@&<_RF^VC)ATw#K>GG0$%F_nP+l50FKhpN{xdI|_BQR4;;TE?NF@7_bzLKEOD
z=NX+0gVV^sxi%pu3-O_%K#^(d3A&kmNU%i2q~QYjS40q+@QAoSj^;bfVQVQI(|*hp
zxro)w_3@G8SuS_^tEYS)1bqp~zGtSB`MmSJ{dQJ!?O6-Vq{w#)dxKcvk1CLEyEfi%
z++=oz-ZW`GJaVGF4T0}D2w8gpyAB`5VgO8}t!+W=!q`2O>UPWcG59+d9thB)ul&uK
zm1J4P#h4WutvZf8XOx*f-ALXywBARjCcmPHm)Nog6@*eHW?byp0>mf>628+|*Im(4
z_(|IA&Xy-<bq{dyxX^XVj-P_8<>Yg3beC}hi{Sl8`Y}z2(cg`OZi)H!y!rBNZfqUe
z3V*#W+j31^Q(bd28X5LBX0EQ9;SIU4kfk9pGA#eqQs0MjQA#MK0W79c>>|wbdu~U=
zWY-!~dU!CT_QtfNW>6x^87wD~Q8Jir5bsT2b7Wqoz}>+x$$3OTUmbe7wz{@o^*M}4
zlg2QDh`AfIM7<8$8J$6Nh`vgQIZZOD>R(N`c8$?>m{S3B2Ur?k(!&Rh`O2A9i*7Tm
z9Mn4yy{OJ#x>vfsGb4EE<2p7y!MVCf<l}OAxPZ3vO9;z`{7WU@<&-jyiO=1TH-FgL
zbwe(5ccm6*w|Q>GAvYX)H*xqUCh>qiF1Uz!XUj59g<Mk0Nqo_yA58t{{cjk|4?!=j
zTf&n2huKf#UL@M)xYVW$Z@PQ&$$YK<AZ`Ral*@5F9c+mZ>?@JGwcEr4bw9@@)Gb?L
z(ncr|*9kLKMs|R56FNY-n*E9R3q-0IT?b8-9myai($=MLm{6O@pkW3zl#njkChKAY
zGSs2St~7#F1FCKSaZh?cdqf-)Zrvu^;g6RR(-!j6pc^)(@uYHsP>yh8M2TG74Mj4k
zDC-{c4NQ|3qcE2+uzHbwJQTwB167F9dcf9cPUrOmb7A)P?B~&gM$s<aO-fQ=IRZGt
zcX^r~8Y0rwtg{)r+dKO^sOIpJkU;`)CptuN$8OJ#V!PL2^E0?sJ4D_^2uXJ$nQf=q
zwy!Qq(bg%#HOh5IOQ11sk?{wHyCHch!vd>9?GK|b5{>h&4c^sG)yxXa*<$V1CQ(jN
zC9jyPSRC0L%cvAI)o0XZ)S+rn^~Q`Uwb|l*?KEwjd7JqI&oob+y1C3+g*r?d0uoZE
zG5KAth%pxCL0m}GQmyft|JrGdpVx7-GfDcz;r?2*9kFT#dz9Tg0v7Jr$DA(VIL^yy
zBU_G556>Lo7{+Lx-Q*b4CNQoUAA!+=apSiedViL2Uv+DI5@UBe5s|~a=vHr)8QXaE
z`FfHK{QN!5z@;3FrR6^GP9A?=$EsEC>o*fru`vYx_Q@@u1|=hkRU0-n(Mr42rlgV`
zi2Nbb)8UBI?Xg>=B3J{S_QXF!C_B!1mE_gKh8%mO^Mvq7vnzSSKQ3T`zjIQl*>tpw
zbUnG6WZsQdkC-4W=>FJM7LL|KTy)7NwL4@?$B1ky-o9}%yz#~7e0$G*IP$A^&xGqe
z&Vfi?vp#ms<;CvLuAOoH^W8drC~^2}dY5q_DY{lPzScKIL?wpUOBy|AL*CLK#WU$|
zI*SW`25EpWV^>}qVZ3YZY_e2pinuH1^-UY0l`j~+2UlhDvea##R%5nn7fSb4_lr4w
zy&>}r6qN7Z2{=8PiEz49SnIjczjF7np1U&>j}%_=c{h|lZ_8;E(uPMa)`DKn^{i3J
zKb31{52JkDbpgfpD8zR~+GDIT30H~g<M+G-C95JOOXjLXKI!zla-}*IW`|%SEyG%U
zl_a8LAF(0=>$&Cv%eBQXq}qk4`WDyx4;hxnI~#cPY`)&NGd$e4ymp&Ql#IP?KaR5C
z<@PsM(#S=KmHRf>7GGqALliy>r8<<Whh{h)6`LECi~QtqJJWR_D6l@EiP|<e9;o@c
zI>>u1ND_B+&uw>@KS+ablz0C@;bhk9qE*t_W8PyPNgIjT-^Tx-{t3z(<L#{T%AXOE
zm${yv;un(JD+*}2h;hpOA04$Dzx-H%aA6}z#aO>VLgH;hWa@my()k{%Pt?+5uCn%K
zTzdTb*i>HNxYk(qXyDcZvruB}{ae393Nm!H=p}BG$ztNvAnt>!9d_kK@5=4%a}z7m
zgVD<uce51X7vUWjKeuBtE21&^JOyfsH(x1@t?cjjy^R_~Ym6;PuvthQ*||xQ*cKn4
ze)X$WNDsd-IwU)WUX}VBms2^_g?W;USU1p$cD|ct97Un!L4bdHu78`J3}e^qd;=M*
zc?tSB$I32K3%3(EQHYEKjwu^hwV&;Fj~M!ROA1<af7zYd|5VPFQ(ITqv{bLJGY;M3
z)#avphhC1ekj`pR75Ia3DKZf+vf%VkOM3np7OADxC0Xo?;q}1`&DjJ@3biO-C#>&v
z_%<!rKf~$A&uKtvQ{N}AW-9klN=g92Nh~g<F%9&h*M)Eb*@a4ebK<_5gT-Ip#1~U?
zI3m{Vgc%41JvDgUpUP)7hb+QEeTq{Nd|R9kj=iVH9w$G1S@f1!Zqw}gk|?MEa6QO;
z^!4F;`tVkbQ}gw+#BlxV`K9aV_uu+b!I%>h07-eug_gItt4wiiO)_4Z#dvyj6`DkW
z+M!*`UoQ5}xaz0U?T+7wSQ~~cxH63!J0@Md=A|}#X0=nEKoE7OdS6pEw*QdShZK3w
z>5Q+J?=rBR`GZN?&m6S*{i7X`|7g*h2=KbF)7t_SG*eP5>h>1`J2ywP!^6I1@tx9M
zrPybEuAMrs5*k&a3oz}mpGdGhO$CULCTbPwQVR4@&B-0wc2EK~v0X(DYtm(eg7DM2
z03+$UU3f{W3Pj0Y3L?*Ga(a!y!7MZiIMCP&D#lvE^MbV<vI~9yo&}C~yZ|P1Aw1dl
zuzkLMNkVh3HtP?cU%5jB-yVwIa1mJEz{xk59IP5>9Ur>r1#<ei?o(In%=YdI#c&zL
zyuuUf{V2MMII3;(Qw5qZCrbC;l(topUfIx4)Fw&dWVXw#rqT+`#9tQYi2;%<=kK{=
zo@;MfjmUV@nf#-Nnt?h3ECfePos#GgAQ^%yLL(|7jG8OW=om)ZMIyPaaDzs@BWVEf
zRPl;ujnH5$i_c8RNVroT%!@A!q1l#+)OwBftnx)nd16fEMM7*=!SGjZ)1TRBN8@Yp
zwXAmfT|6qPHrOQ8(=YqX#>aMv4@zblqwlLPKG{p$d<@&@S9jhDWi+Q|G6X9|huQ$;
z72s=19j3+y8K|m|8!T++L)^w$z>&EN)`|${aS`x{C?+T?2ppPb(|jp!rUGJW`6WL2
zenb2D(_c^9vD)7`P3KhWrYaF)JyU1Z5tO+6j^iM6uo<;rd}YFK{&?qy=jrK2+>Bzm
zf3Hvj>}zD5q`1eWU-d{w1WU;1#dqga#sx_yaWFsUY@Y3?vsHn0CT)nb<u;!~n=CDn
zm3O*VcYF++xjE6fRv+Wos6+8Ow*gT4GIrFp?kFyPA#mKC`hmEid*^)KcBRRPxnEej
zI=0Khuk`hMRFdj@9nB}F#eq^P1YU-|#3JQ>aP=+;dOPN)&;`1sIyd#L24YC;s6G)x
zG_Gyj7P6RQGEioM$=#xqD>f?OFe@%s(>bbELrW+#ws@PsB2`W-JOr8K+nV|qN-^rB
zTuYv}Egt{dL3Tas16sY7O$h+AgHOpIcbqX;N+Ie)NX`%W_86rZ!bTB{d3D<I%QBQ%
zyt3A$0Avb;I|s^m!mVFQTfda&^GIbpo3?16QVM7VE46O1>G2#*Q?$s+zJsWI%4ts)
zR!;fSaq266)Z5TPEXgkSKd+hT`0x2R#ef%2p>|v9=H!v2mn`T4SM6tZt=G3`NP%5H
z`xtML?(beIUtccybUm1|wGVvaZ*rWU!sPKzgz+^Iw!vk_jR;hcl%u%Pz85NHANhg(
z;eoFG$p<n=tDe_5#YS{Gk#41s6Up`#*AntDaW17id*RGVPw)1W2|~{7gT9yEi^iG#
zyJy|B?}qUsU=9L;474_PeWsfV+)dXj^%*F3^$a+rUpXPNF@lJdH9OgFg*3j{_C&et
zxgIX_CzR2X`QF7>=r^s1-H$5>o@CZXYkl>a?T&=qVGu6PE4{ATm^}?+#e;V-sqj5+
z+cR-_-<k7q>+Ah5uZ`DycQGdY<ZY&gRcJ=1*0o}x0~0yPbnl*|gw%mM0LbWtlA$yu
zHU%ksk;jDG91!#-aiuh8<ne&0bOXMgS7jJPyqa$na0?NtSb`%Bv0kwjeKa25ZQ%-i
z_O>nNVt80_F-ni4%7t;yWr4l3kpYdGa)C`HCXec88<2|R%&;<2ruV9h*fB%rnMt<!
zskdx7{UYIg&VkQ5>6R<r+-R7$m%n#!uTHv>89m>oeY)mEjd@HyW-{>v4QX(tEM&bN
zTc+U$PUkK?Q&WIG#4_A)4^ra7<g66_iN<HiXT$gge_)_&3%v-j`ngRuoDJ37c?``g
zg-E}Yti~*5P+zg6uZAu~BOT3+S6c`|Y|^$<5}V(%k-?0w;LoN7!J?3^7CcXy!;mA%
zTYeNdANPjl(Yr{}oxzExbY}JvNk7G11;<nijJS3o=(XA5YnI*FX6VJ9$DBTq#hJ>V
zNPHuGq2)oC2dCtMzYtv%FFS7v_vS0ia~mZaBbQQv)`u5l6GdxA0;8p0tvkhn_5@Oa
zcv}X|I&GLS;x|^sVkTo`n3h#>F~ypZy5Aj^Dy{q_NduGft=zTVtChMCn35M+9kkZG
z@;t$!woBn0Djl2ha?UmV#i<l+$7h8Vv7kIKmxDC)Mk(Uu;x1csh_$_th_sToWlmk2
z3j;)eHb`T?LCW^+8_|><{q&u@9VIirl`Xz5Ud54`QnSwmF(y7Z^*Jgl&#;=4UGvBr
zsy?KpBeL%o&ea<A<QJ3uOly!|^4v<-KKj*hpVma{Yi)J27Tc8Ov9h^F$OaH}U1@K)
zb-I`HYTx_fN$#<?n9R8iv~=tLM9le?)T6NbD3@;fbua%fR?!@U1!<0{tit?v!dy=q
zqp7T9<0Hb=FrJ4yz|VfrF|nsKEd`{Y1*_%HOw`Dw?*%2IcOQob7Vb44=3!3#Y!=b|
zW{ZnV=z_vFYvK?iwGL8}ox(1WWtF5aHKd8ep&OGD&LArhG{Ete)qukaN81ofKy6ZD
zs1am+0Y7P|La&*v$%W$gfrjgpSvVxoi*fzd-Q?zuc^G8oiN0@jASQD?W-FL*TiBf5
zl6MI&SKkXq2Mw=+Z!6ZodD4|q@}{YV2xT}ZB|Akn#%om(u_hyjbI)bh%D%PGx4GD#
ziGUvipWZJkLshZGPa;ZDDd0I2SitZ!FEg!d04D*N_S7&>R)daRc?u<ls!j+Y(w}CI
zREhOv>D@MVl6kUqx=FH?_dxYbQ+#<K(=Qgc0k^=goGqgfFs=#3F9g;+m@BJ1dUr<C
zehAv_kGb&c`4CAh_LL?pdeKFTZF!mVQ5H4B!V01i4NA2tMqw6wYsh*eGRmp=6k;e@
z<`i<(7L)7~6v`^ieMpz(jt)<KUuRavfflzo|HI`QohAKDA49`4e;P?y#Sv8ehB1Fy
zY9^7utkTTbtOz_?v&OJ;S%OW}uLf8Qh|-~oOe_X@rLsi?#TqTLrEo(Z7$~38_DYLJ
z#8rRP5EHAyGh=ZRtDx;J=Yu!=fSCIZP)Va1_wfVkGCFTCvOiFJz>qlMehM(p;Thya
zLoC&U+{6pl-=#yt-$<~KtsTtVFz-@um`1Y<m^n)mYlr91O>0BVg=_q#WX`IBYJ=8i
zR4b~1fYv23V`x#;GNNRyY0O@i$k!i;s=-)p$Xu#0%aoqlWizCneo1m>%HpVr5neZz
zyHYU1<J8L0Du1S$_O)kerPuk#Dt^w&ZBZF3&s6h(R^3v?bTj1P=4bil;m`6WzoDgk
z-^RJTI|{XC8igA*qsD#!amdLMg)0^6nnUKhQTUL!_*hK7_wohd+i}kR_9~yTB~gqK
zo*`a5!{g_Rc<2Wjco4FFyHRjni2im1oj!WFqzE(8`J`=*u@I*H*@{1G-oXQK#6MUt
zu{YctVtT0DJY>@u$<Rj=a+mvoD`N7?;2tg{+&#cWFqAT5@8#9NQ3j2FfUF#fl<2(`
zosXmPG^dYp!BF%&RucCFc;@p~nmExI0k^=c^%xogr?Qi;V26;{nV&6}z7v-Z<5+`q
zKM~w{+*9}IxSi=U@K-jj-Dp`RV(`~rx16%Qlu}3WKAw{w6CPTQ!(XS_CqN++sXk_+
z+)92`KIT<TanqYcp5pHw8nV`Px2kLS#ZB{t+_Mn0&T+%{pWhk6nc&UJTSJdCmb-P9
z>3^OpSHA-U*a6W<x>mB|yif}ac&>3JK$}N2MKtqLDBoAJ&LoQzseS~iM^%j*quHJv
z-&@p<aWX6jHKnCdEBG@+P-*W#C-!Krku)){g&8S7&_2()?WwF7zq%)=enqnnP(>#6
zSmBN*?@2N6=@FrD9r~d)(l0G3Fv~V6Lk>le0AbHdE#(c4iR03lEej-JQH<jo#(tIo
zh%xcwyn|B;^|k{o#)NGfPAtqwM=S;g8a`c+YsEoZC!V?V3=-$v^jTq>C=B5;)Mh9u
z9DmaUr<Rr5z2N4kMNXZ+b~EFDi(o0&`=Xc5>7+1VpV}oCOC?Tvzi&dF<lFswyQvVu
z*IUv}YF9{5jE+&f@J{BCx)ry{fR@p_aigPmTFe3Bgj2h3<xv5dfc^0seR=p|Kq0Mr
zT~ycmUr|vlQigz3oqn%6?COcItlaR2g~4!dkLbbF=Y=*Dpq7$p9K?>3xd16Q^RyL{
z76HT0?!!d234zCU&O$bCHut|N?<!0AXDFFr?1~H^Gsu=KU0ph5+~|t<(A*Eba@@SV
z%51t6^qznWL1#VQJBt&~S*(Xli@YHBCwSP&nc`26Yc5~9GR_Jl=%eowIsr4jrvblf
z>=U32Zecx;n2)03-dq%6dV>xP*}`8Xb`-XzI}4mNSM@2?y@)IOycBiGW>}IicI-pl
zNPGh|Kc^;$xh^F+IFJGB?~84sT*lzF2h)&caxa#2xuQp-Y0^U9uMPCLeyCe<cs{gk
z33JU|Qgwh!(dF}X+q`QnPguUEXR{_elu4J4e%-Fu-l&Bw{ezie=d11DGJ?F$m(PuE
zNStPnh!`XcIHsyrUJ@Vm-QZMz)IBg0F1?BvgP$KK8mOAhL2=L#MnCGPCxjQcI1)~q
z1Pj*=BRj0s98w2}F1sUScvdQ4nGQ;xFG<$U6jII{-))OqtAoys2to&Yg1mdO(i~<I
z?Qm1vpNx}k!U;wZ@><<iWJ9$zKSVdafovlBLj{cn%D3^U9N4GOOgwtHG0VuW%#eMC
z0y2wNDCDnVI#e+q@ck&#jxR0EQQ9sQ7TR04?DI%kOM*7luIlmcyH`?$j$PPvHjh>5
zyxc9|ZmLPxR{Rs`z7b{?)Ua!<oH>8)UE##cG;P;^c`U`PvwU1ddVhw(`#^Ua*dcLs
zC86-Gv8JKQN#Wb<{PIBN+6*zKZ<Ie4)a%=d0^q)P#hE*eFZr9i18?$^BeQlCObK=K
z{X(q8@Bli@BS*L3j(I?oy<2#P0cJ2Sm!n%;hY$wIcahTfB6p;A)gG93fTZt>Zg`6f
zcv!cTotUzd{LAmy?kN#&pe=eBE&#nX#r_pl%p24deER(bJVQ@3gJD~qc|5-bTQ}lB
zpGJIF2e;4;c})HvmFXSf?7Xw#$;W<p8SDWZ0=VTtHh_8oGc#@I3$x%9Gb0T-$`{RI
zCd1v|2=FsrFI!-ymXKL<23sPjtjMTNR$Ao5+3Y?gO|Q(tpQ`YTE8D6pcVyDOq$_2{
zWA>#m{HUCzMCeQ5R|l9XJ?x*d*H|FT5a!NoLR2fOtx_e|u<%E1QGAWO5u)ObtY&`9
zkJ+DSVGRv7Az|52?9Ph!Up!gIQ>dhezBoZ(VGM}%VrNEaTLTa{X{-kXy1L1}mw>()
zLq*eCSy4+`LhS-<I$W^^Bl#bbVmj67K;FU)tZ>|*xIIw_;~iL4>@}bZCI;kV`T40O
znFbdD4mUUgJJzL8Q-7ewJ^xG(4qAvq!Gr#Yq+Uu#yVgs3r3#@WIXwNAZbUVc4mh>8
zM+!b^D6xJKJg-XBW5BXV+;1>o{xLH2-RKD>L@V$$=I6+cUQ43a7#+|bOy>p-^}>g#
z_Wc?oQ1ms9b5kDD-S?@%pJxVbiNG^$LEB_(MEmcA0FJ!qfMo-CZG%_7A2E(!Jy?_O
zRS4H({Gxr801vjSu9C&%nFUfWbb|pOZ2eokOG_(Iy-P><@jQN_SLp?ga1IW71OW#z
zUMh){_ON~+@r(ZunfDoJ>~D-I1;EwC7Jcb&i~QX0D?YAbV1RJQ+jm$v=MEuOfipTG
zZE-}Hqk-6gl41@aorzRN-}>7+DE<6NDeRp_6xCS?C+NSaBFkf9deS)ASFVj;NLD&1
zs#H2wE*lYGRwLyKW1r-Q5G*6MpaN==zXu4sQUwCcU$W{{C0zXST@ksrLpv7qS$!ZJ
z@YA3CZ|vp~`}hmH;e~*pe}gd4{{}=rkA%zrZLK5SxIx>TSJ(kZFS-D6A_y6RxG0)o
zvEf*K<x|aAPdFp}pTm=^`7ikt<Y$-GBBe&>H#O&5>?U^X8Dv0IA7o{Czvp*bL`kvr
zb0fa?Ps?wdv%oK?^j`S*V1GDWJk-}SZxVNAK%Q8<r*g+E*kZktf0(fb?)A=#FZRu4
zut-tZJsj?j$y#&K72IGs%TKZVs{XoL=detF>87TziAE4$=p$g$5S(_QaB@>0Hn!m-
zA!88gsCfe{%2ZHtk*iT(;5}qcUh^H+>4-N#r|>T3qo}F1IHf&{YU%$m*M1#48$-tR
zKIOyg2RQ=~$Qw!-)1J>FEt91=Sr&yBpD6h&&Df*$QXC>b`_KsbX)5RB`%npH(cO_=
z@$8$7^q;cSrv?5Z@KDGk7kIhW+Nrse(@LvdNkL5UI{2jCJjqI?yr8=Se%R2Sfaf>@
zK8f>fQezemyj@fV*$dBZ?~?&&ZIXYU8QO5r7jzGcRy5s3L^Bf(=J8nVbtR)Lhtea(
zrID|U_nsFAZ391P6Km>{%JO{C9->H)BF&b(+E%@7h}5u`zF*n~TS>c@^&_cX5U0Kv
zJiQw%>klhEy+Px2+JOAGo&28tzYK+o8}zrGfF4<>ze%D${L&+CC2Hbi<Y-~<Z0Goh
zBmE|@<PB_KIMr)WH5Ex^W>FJM12q?A7})f$ba4Y43u|{E!=EJJV;bY1L~8>x7{LVo
zS5DzSz!fWq1Iz(r<${1=z!;Ph2m*70|6;AAoDHlkjD&2>tWAI%zsm_Z89kC)P%!WB
z=wtsL<E&s#?%x6t1A9pm3o~;V+y$%Vw@BI9#6}GW1JNEw@EDQ&JMuU}7$ju^20n6B
z|KzG3sj~mp#-AEo44r=yWhyXo>rqp`rNRbICcpW#|DR?o9G#p+%ncm>R)DO*UvUul
z50m!q>W0Bt|2j*>Y+;L#S=gEZ+0`v<g>0QH{ucahS>3|e+1v>Ru5p4MN5KK)<^1#c
z80Lij*?))sN{2CXoRI(1{y(+-T_=S1k$Qtbd4W7UkEwq)F!WIh!{)eofV{A2<l%a}
z8bLT7X*CEe4Z;cAe;XbL5X$?Q_P9Ov?eF7b2m*Sf_PDvAf92-}a&m+JggH5ZU>=^|
zJIC)Ml;^QlPFNYx?;IRJE?9^gW=EXR$1;yCKW>i%-*0RWhTqw#+FCrW<_3JcCjN7>
z|J(E*VZlEZEn{K)sN2V$Dg6roba`Y4|3TsX?)cy4qUdO6>|z94L5{)5z{1fE2x0?4
z*f@X;=FZOcPJHYzt`R0Rb2P9ww=i;IvvV|K{BwGUz}A;@wy?7mePkjTMESrRU~Uc&
zhyw)S<mCjja&Xgga4`O}(f<J||7ILT3}EMro!M`*_&tQb2*>~7BHbKKOi?+2ATCsn
zf4zVZZf;I)pegW=49p9|0)f9%fwq6iVCN+VjO%=S{X@nBg`Fn<CWA#l|4Tj|nEL)L
zAD9OMg&FC;$w0iIN5lO$85qLL4V#_+l))zdKV&>ykH+@z`FOa%|Jgq<FPQs3`v->E
z_CNaP>}UYHA~^nD8&KK8!{kv{j~5OlJ3H8<KkEF?SErP%DQs?k+r=M*(!kOAw|2q2
PTwvHjgS27_;;8=*IrA_>
literal 0
HcmV?d00001
diff --git a/hercules_test/hercules_tests/tests/loop_tests.rs b/hercules_test/hercules_tests/tests/loop_tests.rs
index 1d1a050d..722b5bb2 100644
--- a/hercules_test/hercules_tests/tests/loop_tests.rs
+++ b/hercules_test/hercules_tests/tests/loop_tests.rs
@@ -37,16 +37,16 @@ fn alternate_bounds_use_after_loop_no_tid() {
let passes = vec![
Pass::Verify,
- //Pass::Xdot(true),
+ ////Pass::Xdot(True),
Pass::CCP,
Pass::DCE,
Pass::GVN,
- //Pass::Xdot(true),
+ Pass::Xdot(true),
Pass::LoopCanonicalization,
Pass::DCE,
- //Pass::Xdot(true),
- Pass::LoopCanonicalization,
- //Pass::Xdot(true),
+ Pass::Xdot(true),
+ // Pass::LoopCanonicalization,
+ ////Pass::Xdot(True),
Pass::Verify,
];
@@ -69,7 +69,7 @@ fn alternate_bounds_use_after_loop() {
let len = 4;
let dyn_consts = [len];
- let a = vec![3, 4, 5, 6];
+ let a = vec![3, 4, 5, 6, 7];
let module = parse_file("../test_inputs/loop_analysis/alternate_bounds_use_after_loop.hir");
let result_1 = interp_module!(module, dyn_consts, a.clone());
@@ -82,10 +82,10 @@ fn alternate_bounds_use_after_loop() {
Pass::CCP,
Pass::DCE,
Pass::GVN,
- //Pass::Xdot(true),
+ Pass::Xdot(true),
Pass::LoopCanonicalization,
Pass::DCE,
- //Pass::Xdot(true),
+ Pass::Xdot(true),
Pass::Verify,
];
@@ -99,7 +99,7 @@ fn alternate_bounds_use_after_loop() {
//println!("{:?}", result_1);
println!("{:?}", result_2);
- //assert_eq!(result_1, result_2);
+ assert_eq!(result_1, result_2);
}
#[test]
@@ -116,9 +116,9 @@ fn alternate_bounds_internal_control() {
let passes = vec![
Pass::Verify,
- //Pass::Xdot(true),
+ Pass::Xdot(true),
Pass::LoopCanonicalization,
- //Pass::Xdot(true),
+ ////Pass::Xdot(True),
Pass::DCE,
Pass::Verify,
];
@@ -151,12 +151,13 @@ fn alternate_bounds_nested_do_loop() {
let passes = vec![
Pass::Verify,
- //Pass::Xdot(true),
- Pass::LoopCanonicalization,
- //Pass::Xdot(true),
+ Pass::DCE,
+ Pass::GVN,
+ Pass::Xdot(true),
Pass::LoopCanonicalization,
- //Pass::Xdot(true),
Pass::DCE,
+ Pass::Xdot(true),
+
Pass::Verify,
];
@@ -179,7 +180,7 @@ fn alternate_bounds_nested_do_loop_array() {
let len = 1;
let dyn_consts = [10, 5];
- let a = vec![4u64, 4, 4, 4, 4, 100];
+ let a = vec![4u64, 4, 4, 4, 4];
let module = parse_file("../test_inputs/loop_analysis/alternate_bounds_nested_do_loop_array.hir");
let result_1 = interp_module!(module, dyn_consts, a.clone());
@@ -189,9 +190,9 @@ fn alternate_bounds_nested_do_loop_array() {
let passes = vec![
Pass::Verify,
- //Pass::Xdot(true),
+ Pass::Xdot(true),
Pass::LoopCanonicalization,
- //Pass::Xdot(true),
+ Pass::Xdot(true),
Pass::DCE,
Pass::Verify,
];
@@ -213,7 +214,7 @@ fn alternate_bounds_nested_do_loop_array() {
#[test]
fn alternate_bounds_nested_do_loop_guarded() {
let len = 1;
- let dyn_consts = [10, 5];
+ let dyn_consts = [3, 2];
let module = parse_file("../test_inputs/loop_analysis/alternate_bounds_nested_do_loop_guarded.hir");
let result_1 = interp_module!(module, dyn_consts, 3);
@@ -224,11 +225,32 @@ fn alternate_bounds_nested_do_loop_guarded() {
let passes = vec![
Pass::Verify,
- //Pass::Xdot(true),
+ Pass::Xdot(true),
Pass::LoopCanonicalization,
- //Pass::Xdot(true),
+ Pass::DCE,
+ //Pass::Xdot(True),
+ Pass::Verify,
+ ];
+
+ for pass in passes {
+ pm.add_pass(pass);
+ }
+
+ pm.run_passes();
+
+ let module = pm.get_module();
+ let result_2 = interp_module!(module, dyn_consts, 3);
+ println!("{:?}", result_1);
+ println!("{:?}", result_2);
+
+ assert_eq!(result_1, result_2);
+
+ let mut pm = hercules_opt::pass::PassManager::new(module.clone());
+
+ let passes = vec![
+ Pass::Verify,
Pass::LoopCanonicalization,
- //Pass::Xdot(true),
+ //Pass::Xdot(True),
Pass::DCE,
Pass::Verify,
];
@@ -283,12 +305,19 @@ fn do_loop_complex_immediate_guarded() {
Pass::CCP,
Pass::DCE,
Pass::GVN,
- //Pass::Xdot(true),
+ //Pass::Xdot(True),
Pass::LoopCanonicalization,
- Pass::DCE,
- //Pass::Xdot(true),
+ //Pass::Xdot(True),
+ Pass::Forkify,
+ Pass::ForkGuardElim,
+ Pass::Forkify,
+ Pass::ForkGuardElim,
+ Pass::Forkify,
+ Pass::ForkGuardElim,
+ //Pass::Xdot(True),
+ Pass::Verify,
Pass::LoopCanonicalization,
- //Pass::Xdot(true),
+ //Pass::Xdot(True),
Pass::Verify,
];
@@ -332,9 +361,16 @@ fn matmul_pipeline() {
let passes = vec![
Pass::Verify,
- Pass::CCP,
- Pass::DCE,
- Pass::GVN,
+ Pass::Xdot(true),
+ Pass::LoopCanonicalization,
+ Pass::Xdot(true),
+ Pass::Forkify,
+ Pass::ForkGuardElim,
+ Pass::Forkify,
+ Pass::ForkGuardElim,
+ Pass::Forkify,
+ Pass::ForkGuardElim,
+ Pass::Xdot(true),
Pass::Verify,
];
@@ -348,13 +384,15 @@ fn matmul_pipeline() {
let result_2 = interp_module!(module, dyn_consts, m1.clone(), m2.clone());
assert_eq!(result_1, result_2);
+ return;
+
// 1st (innermost) Loop Canonicalization
let mut pm = hercules_opt::pass::PassManager::new(module.clone());
let passes = vec![
- //Pass::Xdot(true),
+ ////Pass::Xdot(True),
Pass::LoopCanonicalization,
- //Pass::Xdot(true),
+ //Pass::Xdot(True),
Pass::Verify,
];
@@ -372,14 +410,14 @@ fn matmul_pipeline() {
let passes = vec![
Pass::Forkify,
Pass::DCE,
- //Pass::Xdot(true),
+ //Pass::Xdot(True),
Pass::Verify,
Pass::ForkGuardElim,
Pass::Forkify,
Pass::ForkGuardElim,
Pass::Forkify,
Pass::DCE,
- //Pass::Xdot(true),
+ //Pass::Xdot(True),
Pass::Verify,
];
@@ -461,7 +499,7 @@ fn matmul_pipeline() {
Pass::LoopCanonicalization,
Pass::Forkify,
Pass::DCE,
- // //Pass::Xdot(true),
+ ////Pass::Xdot(True),
];
for pass in passes {
@@ -480,7 +518,7 @@ fn matmul_pipeline() {
let passes = vec![
Pass::ForkCoalesce,
Pass::DCE,
- // //Pass::Xdot(true),
+ // ////Pass::Xdot(True),
];
for pass in passes {
@@ -500,7 +538,8 @@ fn matmul_pipeline() {
Pass::DCE,
Pass::ForkGuardElim,
Pass::DCE,
- // //Pass::Xdot(true),
+ //Pass::Xdot(True),
+ Pass::Verify,
];
for pass in passes {
diff --git a/hercules_test/test_inputs/loop_analysis/alternate_bounds_use_after_loop.hir b/hercules_test/test_inputs/loop_analysis/alternate_bounds_use_after_loop.hir
index 7851b97c..2fe4ca57 100644
--- a/hercules_test/test_inputs/loop_analysis/alternate_bounds_use_after_loop.hir
+++ b/hercules_test/test_inputs/loop_analysis/alternate_bounds_use_after_loop.hir
@@ -3,6 +3,7 @@ fn sum<1>(a: array(i32, #0)) -> i32
one_idx = constant(u64, 1)
zero_inc = constant(i32, 0)
ten = constant(i32, 10)
+ three = constant(i32, 3)
bound = dynamic_constant(#0)
loop = region(start, if_true)
idx = phi(loop, zero_idx, idx_inc)
@@ -15,4 +16,6 @@ fn sum<1>(a: array(i32, #0)) -> i32
if_false = projection(if, 0)
if_true = projection(if, 1)
plus_ten = add(red_add, ten)
- r = return(if_false, plus_ten)
\ No newline at end of file
+ mult = mul(read, three)
+ final = add(plus_ten, mult)
+ r = return(if_false, final)
\ No newline at end of file
diff --git a/hercules_test/test_inputs/loop_analysis/loop_trip_count.hir b/hercules_test/test_inputs/loop_analysis/loop_trip_count.hir
new file mode 100644
index 00000000..b756f090
--- /dev/null
+++ b/hercules_test/test_inputs/loop_analysis/loop_trip_count.hir
@@ -0,0 +1,19 @@
+fn loop<1>(b: prod(u64, u64)) -> prod(u64, u64)
+ zero_idx = constant(u64, 0)
+ one_idx = constant(u64, 1)
+ zero_var = constant(u64, 0)
+ one_var = constant(u64, 1)
+ c = constant(prod(u64, u64), (0, 0))
+ bound = dynamic_constant(#0)
+ loop = region(start, if_true)
+ var = phi(loop, zero_var, var_inc)
+ var_inc = add(var, one_var)
+ idx = phi(loop, zero_idx, idx_inc)
+ idx_inc = add(idx, one_idx)
+ in_bounds = lt(idx, bound)
+ if = if(loop, in_bounds)
+ if_false = projection(if, 0)
+ if_true = projection(if, 1)
+ tuple1 = write(c, var, field(0))
+ tuple2 = write(tuple1, idx, field(1))
+ r = return(if_false, tuple2)
\ No newline at end of file
--
GitLab
From 0a9e626efa1eaa53300585485753da40f288582f Mon Sep 17 00:00:00 2001
From: Xavier Routh <xrouth2@illinois.edu>
Date: Mon, 20 Jan 2025 16:52:00 -0600
Subject: [PATCH 35/68] git a fwjwgwjeakgljh
---
Cargo.lock | 60 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 60 insertions(+)
diff --git a/Cargo.lock b/Cargo.lock
index de2160f5..5e87d8ee 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -763,6 +763,16 @@ dependencies = [
"wasm-bindgen",
]
+[[package]]
+name = "juno_antideps"
+version = "0.1.0"
+dependencies = [
+ "async-std",
+ "hercules_rt",
+ "juno_build",
+ "with_builtin_macros",
+]
+
[[package]]
name = "juno_build"
version = "0.1.0"
@@ -772,6 +782,15 @@ dependencies = [
"with_builtin_macros",
]
+[[package]]
+name = "juno_casts_and_intrinsics"
+version = "0.1.0"
+dependencies = [
+ "async-std",
+ "juno_build",
+ "with_builtin_macros",
+]
+
[[package]]
name = "juno_frontend"
version = "0.1.0"
@@ -789,6 +808,37 @@ dependencies = [
"phf",
]
+[[package]]
+name = "juno_implicit_clone"
+version = "0.1.0"
+dependencies = [
+ "async-std",
+ "hercules_rt",
+ "juno_build",
+ "with_builtin_macros",
+]
+
+[[package]]
+name = "juno_matmul"
+version = "0.1.0"
+dependencies = [
+ "async-std",
+ "hercules_rt",
+ "juno_build",
+ "rand",
+ "with_builtin_macros",
+]
+
+[[package]]
+name = "juno_nested_ccp"
+version = "0.1.0"
+dependencies = [
+ "async-std",
+ "hercules_rt",
+ "juno_build",
+ "with_builtin_macros",
+]
+
[[package]]
name = "juno_scheduler"
version = "0.0.1"
@@ -799,6 +849,16 @@ dependencies = [
"lrpar",
]
+[[package]]
+name = "juno_simple3"
+version = "0.1.0"
+dependencies = [
+ "async-std",
+ "hercules_rt",
+ "juno_build",
+ "with_builtin_macros",
+]
+
[[package]]
name = "kv-log-macro"
version = "1.0.7"
--
GitLab
From d8b69d21fff6f50d1982d3fd6a876538ed9c1ec1 Mon Sep 17 00:00:00 2001
From: Xavier Routh <xrouth2@illinois.edu>
Date: Mon, 20 Jan 2025 16:55:29 -0600
Subject: [PATCH 36/68] wtf
---
Cargo.lock | 3 +++
1 file changed, 3 insertions(+)
diff --git a/Cargo.lock b/Cargo.lock
index 6dc59e53..87410052 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1076,6 +1076,7 @@ dependencies = [
]
[[package]]
+<<<<<<< Updated upstream
name = "juno_cava"
version = "0.1.0"
dependencies = [
@@ -1098,6 +1099,8 @@ dependencies = [
]
[[package]]
+=======
+>>>>>>> Stashed changes
name = "juno_frontend"
version = "0.1.0"
dependencies = [
--
GitLab
From 32056f4730bc97c672827b23e1a9dc0212a715ae Mon Sep 17 00:00:00 2001
From: Xavier Routh <xrouth2@illinois.edu>
Date: Tue, 21 Jan 2025 00:58:16 -0600
Subject: [PATCH 37/68] forkify pattern match
---
Cargo.lock | 750 +-----------------
hercules_cg/src/cpu.rs | 4 +-
hercules_opt/src/editor.rs | 6 +-
hercules_opt/src/forkify.rs | 25 +-
hercules_opt/src/ivar.rs | 142 +++-
hercules_opt/src/loop_canonicalization.rs | 8 +-
hercules_opt/src/pass.rs | 3 +-
.../hercules_interpreter/src/interpreter.rs | 28 +-
8 files changed, 172 insertions(+), 794 deletions(-)
diff --git a/Cargo.lock b/Cargo.lock
index 87410052..2ffa909c 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2,12 +2,6 @@
# It is not intended for manual editing.
version = 4
-[[package]]
-name = "adler2"
-version = "2.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "512761e0bb2578dd7380c6baaa0f4ce03e84f95e960231d1dec8bf4d7d6e2627"
-
[[package]]
name = "aho-corasick"
version = "1.1.3"
@@ -17,12 +11,6 @@ dependencies = [
"memchr",
]
-[[package]]
-name = "aligned-vec"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4aa90d7ce82d4be67b64039a3d588d38dbcc6736577de4a847025ce5b0c468d1"
-
[[package]]
name = "anstream"
version = "0.6.18"
@@ -79,29 +67,6 @@ version = "1.0.95"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "34ac096ce696dc2fcabef30516bb13c0a68a11d30131d3df6f04711467681b04"
-[[package]]
-name = "arbitrary"
-version = "1.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dde20b3d026af13f561bdd0f15edf01fc734f0dafcedbaf42bba506a9517f223"
-
-[[package]]
-name = "arg_enum_proc_macro"
-version = "0.3.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ae92a5119aa49cdbcf6b9f893fe4e1d98b04ccbf82ee0584ad948a44a734dea"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.96",
-]
-
-[[package]]
-name = "arrayvec"
-version = "0.7.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50"
-
[[package]]
name = "async-channel"
version = "1.9.0"
@@ -236,29 +201,6 @@ version = "1.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ace50bade8e6234aa140d9a2f552bbee1db4d353f69b8217bc503490fc1a9f26"
-[[package]]
-name = "av1-grain"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6678909d8c5d46a42abcf571271e15fdbc0a225e3646cf23762cd415046c78bf"
-dependencies = [
- "anyhow",
- "arrayvec",
- "log",
- "nom",
- "num-rational",
- "v_frame",
-]
-
-[[package]]
-name = "avif-serialize"
-version = "0.8.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e335041290c43101ca215eed6f43ec437eb5a42125573f600fc3fa42b9bddd62"
-dependencies = [
- "arrayvec",
-]
-
[[package]]
name = "base64"
version = "0.21.7"
@@ -280,18 +222,6 @@ dependencies = [
"serde",
]
-[[package]]
-name = "bit_field"
-version = "0.10.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc827186963e592360843fb5ba4b973e145841266c1357f7180c43526f2e5b61"
-
-[[package]]
-name = "bitflags"
-version = "1.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
-
[[package]]
name = "bitflags"
version = "2.8.0"
@@ -301,12 +231,6 @@ dependencies = [
"serde",
]
-[[package]]
-name = "bitstream-io"
-version = "2.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6099cdc01846bc367c4e7dd630dc5966dccf36b652fae7a74e17b640411a91b2"
-
[[package]]
name = "bitvec"
version = "1.0.1"
@@ -332,36 +256,18 @@ dependencies = [
"piper",
]
-[[package]]
-name = "built"
-version = "0.7.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c360505aed52b7ec96a3636c3f039d99103c37d1d9b4f7a8c743d3ea9ffcd03b"
-
[[package]]
name = "bumpalo"
version = "3.16.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "79296716171880943b8470b5f8d03aa55eb2e645a4874bdbb28adb49162e012c"
-[[package]]
-name = "bytemuck"
-version = "1.21.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ef657dfab802224e671f5818e9a4935f9b1957ed18e58292690cc39e7a4092a3"
-
[[package]]
name = "byteorder"
version = "1.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
-[[package]]
-name = "byteorder-lite"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f1fe948ff07f4bd06c30984e69f5b4899c516a3ef74f34df92a2df2ab535495"
-
[[package]]
name = "cactus"
version = "1.0.7"
@@ -378,17 +284,6 @@ dependencies = [
"with_builtin_macros",
]
-[[package]]
-name = "cc"
-version = "1.2.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "13208fcbb66eaeffe09b99fffbe1af420f00a7b35aa99ad683dfc1aa76145229"
-dependencies = [
- "jobserver",
- "libc",
- "shlex",
-]
-
[[package]]
name = "ccp"
version = "0.1.0"
@@ -399,16 +294,6 @@ dependencies = [
"with_builtin_macros",
]
-[[package]]
-name = "cfg-expr"
-version = "0.15.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d067ad48b8650848b989a59a86c6c36a995d02d2bf778d45c3c5d57bc2718f02"
-dependencies = [
- "smallvec",
- "target-lexicon",
-]
-
[[package]]
name = "cfg-if"
version = "1.0.0"
@@ -475,12 +360,6 @@ version = "0.2.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "67ba02a97a2bd10f4b59b25c7973101c79642302776489e030cd13cdab09ed15"
-[[package]]
-name = "color_quant"
-version = "1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3d7b894f5411737b7867f4827955924d7c254fc9f4d91a6aad6b097804b1018b"
-
[[package]]
name = "colorchoice"
version = "1.0.3"
@@ -496,52 +375,18 @@ dependencies = [
"crossbeam-utils",
]
-[[package]]
-name = "crc32fast"
-version = "1.4.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a97769d94ddab943e4510d138150169a2758b5ef3eb191a9ee688de3e23ef7b3"
-dependencies = [
- "cfg-if",
-]
-
[[package]]
name = "critical-section"
version = "1.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "790eea4361631c5e7d22598ecd5723ff611904e3344ce8720784c93e3d83d40b"
-[[package]]
-name = "crossbeam-deque"
-version = "0.8.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9dd111b7b7f7d55b72c0a6ae361660ee5853c9af73f70c3c2ef6858b950e2e51"
-dependencies = [
- "crossbeam-epoch",
- "crossbeam-utils",
-]
-
-[[package]]
-name = "crossbeam-epoch"
-version = "0.9.18"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e"
-dependencies = [
- "crossbeam-utils",
-]
-
[[package]]
name = "crossbeam-utils"
version = "0.8.21"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
-[[package]]
-name = "crunchy"
-version = "0.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a81dae078cea95a014a339291cec439d2f232ebe854a9d672b796c6afafa9b7"
-
[[package]]
name = "deranged"
version = "0.3.11"
@@ -644,21 +489,6 @@ dependencies = [
"pin-project-lite",
]
-[[package]]
-name = "exr"
-version = "1.73.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f83197f59927b46c04a183a619b7c29df34e63e63c7869320862268c0ef687e0"
-dependencies = [
- "bit_field",
- "half",
- "lebe",
- "miniz_oxide",
- "rayon-core",
- "smallvec",
- "zune-inflate",
-]
-
[[package]]
name = "fac"
version = "0.1.0"
@@ -676,15 +506,6 @@ version = "2.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be"
-[[package]]
-name = "fdeflate"
-version = "0.3.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e6853b52649d4ac5c0bd02320cddc5ba956bdb407c4b75a2c6b75bf51500f8c"
-dependencies = [
- "simd-adler32",
-]
-
[[package]]
name = "filetime"
version = "0.2.25"
@@ -697,16 +518,6 @@ dependencies = [
"windows-sys",
]
-[[package]]
-name = "flate2"
-version = "1.0.35"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c936bfdafb507ebbf50b8074c54fa31c5be9a1e7e5f467dd659697041407d07c"
-dependencies = [
- "crc32fast",
- "miniz_oxide",
-]
-
[[package]]
name = "fnv"
version = "1.0.7"
@@ -773,16 +584,6 @@ dependencies = [
"wasi",
]
-[[package]]
-name = "gif"
-version = "0.13.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3fb2d69b19215e18bb912fa30f7ce15846e301408695e44e0ef719f1da9e19f2"
-dependencies = [
- "color_quant",
- "weezl",
-]
-
[[package]]
name = "gloo-timers"
version = "0.3.0"
@@ -795,16 +596,6 @@ dependencies = [
"wasm-bindgen",
]
-[[package]]
-name = "half"
-version = "2.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6dd08c532ae367adf81c312a4580bc67f1d0fe8bc9c460520283f4c0ff277888"
-dependencies = [
- "cfg-if",
- "crunchy",
-]
-
[[package]]
name = "hash32"
version = "0.2.1"
@@ -871,7 +662,7 @@ dependencies = [
"derive_more",
"hercules_ir",
"hercules_opt",
- "itertools 0.14.0",
+ "itertools",
"ordered-float",
"postcard",
"rand",
@@ -897,7 +688,7 @@ dependencies = [
"either",
"hercules_cg",
"hercules_ir",
- "itertools 0.14.0",
+ "itertools",
"nestify",
"ordered-float",
"postcard",
@@ -921,7 +712,7 @@ dependencies = [
"hercules_interpreter",
"hercules_ir",
"hercules_opt",
- "itertools 0.14.0",
+ "itertools",
"ordered-float",
"rand",
]
@@ -932,45 +723,6 @@ version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fbf6a919d6cf397374f7dfeeea91d974c7c0a7221d0d0f4f20d859d329e53fcc"
-[[package]]
-name = "image"
-version = "0.25.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd6f44aed642f18953a158afeb30206f4d50da59fbc66ecb53c66488de73563b"
-dependencies = [
- "bytemuck",
- "byteorder-lite",
- "color_quant",
- "exr",
- "gif",
- "image-webp",
- "num-traits",
- "png",
- "qoi",
- "ravif",
- "rayon",
- "rgb",
- "tiff",
- "zune-core",
- "zune-jpeg",
-]
-
-[[package]]
-name = "image-webp"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b77d01e822461baa8409e156015a1d91735549f0f2c17691bd2d996bef238f7f"
-dependencies = [
- "byteorder-lite",
- "quick-error",
-]
-
-[[package]]
-name = "imgref"
-version = "1.11.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d0263a3d970d5c054ed9312c0057b4f3bde9c0b33836d3637361d4a9e6e7a408"
-
[[package]]
name = "indexmap"
version = "2.7.1"
@@ -981,32 +733,12 @@ dependencies = [
"hashbrown",
]
-[[package]]
-name = "interpolate_name"
-version = "0.2.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c34819042dc3d3971c46c2190835914dfbe0c3c13f61449b2997f4e9722dfa60"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.96",
-]
-
[[package]]
name = "is_terminal_polyfill"
version = "1.70.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7943c866cc5cd64cbc25b2e01621d07fa8eb2a1a23160ee81ce38704e97b8ecf"
-[[package]]
-name = "itertools"
-version = "0.12.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ba291022dbbd398a455acf126c1e341954079855bc60dfdda641363bd6922569"
-dependencies = [
- "either",
-]
-
[[package]]
name = "itertools"
version = "0.14.0"
@@ -1022,21 +754,6 @@ version = "1.0.14"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d75a2a4b1b190afb6f5425f10f6a8f959d2ea0b9c2b1d79553551850539e4674"
-[[package]]
-name = "jobserver"
-version = "0.1.32"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "48d1dbcbbeb6a7fec7e059840aa538bd62aaccf972c7346c4d9d2059312853d0"
-dependencies = [
- "libc",
-]
-
-[[package]]
-name = "jpeg-decoder"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f5d4a7da358eff58addd2877a45865158f0d78c911d43a5784ceb7bbf52833b0"
-
[[package]]
name = "js-sys"
version = "0.3.77"
@@ -1047,16 +764,6 @@ dependencies = [
"wasm-bindgen",
]
-[[package]]
-name = "juno_antideps"
-version = "0.1.0"
-dependencies = [
- "async-std",
- "hercules_rt",
- "juno_build",
- "with_builtin_macros",
-]
-
[[package]]
name = "juno_build"
version = "0.1.0"
@@ -1067,40 +774,6 @@ dependencies = [
]
[[package]]
-name = "juno_casts_and_intrinsics"
-version = "0.1.0"
-dependencies = [
- "async-std",
- "juno_build",
- "with_builtin_macros",
-]
-
-[[package]]
-<<<<<<< Updated upstream
-name = "juno_cava"
-version = "0.1.0"
-dependencies = [
- "async-std",
- "clap",
- "hercules_rt",
- "image",
- "juno_build",
- "with_builtin_macros",
-]
-
-[[package]]
-name = "juno_concat"
-version = "0.1.0"
-dependencies = [
- "async-std",
- "hercules_rt",
- "juno_build",
- "with_builtin_macros",
-]
-
-[[package]]
-=======
->>>>>>> Stashed changes
name = "juno_frontend"
version = "0.1.0"
dependencies = [
@@ -1117,16 +790,6 @@ dependencies = [
"phf",
]
-[[package]]
-name = "juno_implicit_clone"
-version = "0.1.0"
-dependencies = [
- "async-std",
- "hercules_rt",
- "juno_build",
- "with_builtin_macros",
-]
-
[[package]]
name = "juno_matmul"
version = "0.1.0"
@@ -1138,16 +801,6 @@ dependencies = [
"with_builtin_macros",
]
-[[package]]
-name = "juno_nested_ccp"
-version = "0.1.0"
-dependencies = [
- "async-std",
- "hercules_rt",
- "juno_build",
- "with_builtin_macros",
-]
-
[[package]]
name = "juno_scheduler"
version = "0.0.1"
@@ -1158,16 +811,6 @@ dependencies = [
"lrpar",
]
-[[package]]
-name = "juno_simple3"
-version = "0.1.0"
-dependencies = [
- "async-std",
- "hercules_rt",
- "juno_build",
- "with_builtin_macros",
-]
-
[[package]]
name = "kv-log-macro"
version = "1.0.7"
@@ -1183,35 +826,19 @@ version = "1.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
-[[package]]
-name = "lebe"
-version = "0.5.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "03087c2bad5e1034e8cace5926dec053fb3790248370865f5117a7d0213354c8"
-
[[package]]
name = "libc"
version = "0.2.169"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b5aba8db14291edd000dfcc4d620c7ebfb122c613afb886ca8803fa4e128a20a"
-[[package]]
-name = "libfuzzer-sys"
-version = "0.4.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b9569d2f74e257076d8c6bfa73fb505b46b851e51ddaecc825944aa3bed17fa"
-dependencies = [
- "arbitrary",
- "cc",
-]
-
[[package]]
name = "libredox"
version = "0.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c0ff37bd590ca25063e35af745c343cb7a0271906fb7b37e4813e8f79f00268d"
dependencies = [
- "bitflags 2.8.0",
+ "bitflags",
"libc",
"redox_syscall",
]
@@ -1241,15 +868,6 @@ dependencies = [
"value-bag",
]
-[[package]]
-name = "loop9"
-version = "0.1.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fae87c125b03c1d2c0150c90365d7d6bcc53fb73a9acaef207d2d065860f062"
-dependencies = [
- "imgref",
-]
-
[[package]]
name = "lrlex"
version = "0.13.8"
@@ -1316,16 +934,6 @@ dependencies = [
"with_builtin_macros",
]
-[[package]]
-name = "maybe-rayon"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ea1f30cedd69f0a2954655f7188c6a834246d2bcf1e315e2ac40c4b24dc9519"
-dependencies = [
- "cfg-if",
- "rayon",
-]
-
[[package]]
name = "memchr"
version = "2.7.4"
@@ -1338,16 +946,6 @@ version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
-[[package]]
-name = "miniz_oxide"
-version = "0.8.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b8402cab7aefae129c6977bb0ff1b8fd9a04eb5b51efc50a70bea51cda0c7924"
-dependencies = [
- "adler2",
- "simd-adler32",
-]
-
[[package]]
name = "nestify"
version = "0.3.3"
@@ -1360,12 +958,6 @@ dependencies = [
"syn 2.0.96",
]
-[[package]]
-name = "new_debug_unreachable"
-version = "1.0.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "650eef8c711430f1a879fdd01d4745a7deea475becfb90269c06775983bbf086"
-
[[package]]
name = "nom"
version = "7.1.3"
@@ -1376,12 +968,6 @@ dependencies = [
"minimal-lexical",
]
-[[package]]
-name = "noop_proc_macro"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0676bb32a98c1a483ce53e500a81ad9c3d5b3f7c920c28c24e9cb0980d0b5bc8"
-
[[package]]
name = "num-bigint"
version = "0.4.6"
@@ -1398,17 +984,6 @@ version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "51d515d32fb182ee37cda2ccdcb92950d6a3c2893aa280e540671c2cd0f3b1d9"
-[[package]]
-name = "num-derive"
-version = "0.4.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed3955f1a9c7c0c15e092f9c887db08b1fc683305fdf6eb6684f22555355e202"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.96",
-]
-
[[package]]
name = "num-integer"
version = "0.1.46"
@@ -1480,12 +1055,6 @@ version = "2.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f38d5652c16fde515bb1ecef450ab0f6a219d619a7274976324d5e377f7dceba"
-[[package]]
-name = "paste"
-version = "1.0.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"
-
[[package]]
name = "phf"
version = "0.11.3"
@@ -1551,25 +1120,6 @@ dependencies = [
"futures-io",
]
-[[package]]
-name = "pkg-config"
-version = "0.3.31"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "953ec861398dccce10c670dfeaf3ec4911ca479e9c02154b3a215178c5f566f2"
-
-[[package]]
-name = "png"
-version = "0.17.16"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "82151a2fc869e011c153adc57cf2789ccb8d9906ce52c0b39a6b5697749d7526"
-dependencies = [
- "bitflags 1.3.2",
- "crc32fast",
- "fdeflate",
- "flate2",
- "miniz_oxide",
-]
-
[[package]]
name = "polling"
version = "3.7.4"
@@ -1646,40 +1196,6 @@ dependencies = [
"unicode-ident",
]
-[[package]]
-name = "profiling"
-version = "1.0.16"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "afbdc74edc00b6f6a218ca6a5364d6226a259d4b8ea1af4a0ea063f27e179f4d"
-dependencies = [
- "profiling-procmacros",
-]
-
-[[package]]
-name = "profiling-procmacros"
-version = "1.0.16"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a65f2e60fbf1063868558d69c6beacf412dc755f9fc020f514b7955fc914fe30"
-dependencies = [
- "quote",
- "syn 2.0.96",
-]
-
-[[package]]
-name = "qoi"
-version = "0.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f6d64c71eb498fe9eae14ce4ec935c555749aef511cca85b5568910d6e48001"
-dependencies = [
- "bytemuck",
-]
-
-[[package]]
-name = "quick-error"
-version = "2.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a993555f31e5a609f617c12db6250dedcac1b0a85076912c436e6fc9b2c8e6a3"
-
[[package]]
name = "quote"
version = "1.0.38"
@@ -1727,83 +1243,13 @@ dependencies = [
"serde",
]
-[[package]]
-name = "rav1e"
-version = "0.7.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd87ce80a7665b1cce111f8a16c1f3929f6547ce91ade6addf4ec86a8dda5ce9"
-dependencies = [
- "arbitrary",
- "arg_enum_proc_macro",
- "arrayvec",
- "av1-grain",
- "bitstream-io",
- "built",
- "cfg-if",
- "interpolate_name",
- "itertools 0.12.1",
- "libc",
- "libfuzzer-sys",
- "log",
- "maybe-rayon",
- "new_debug_unreachable",
- "noop_proc_macro",
- "num-derive",
- "num-traits",
- "once_cell",
- "paste",
- "profiling",
- "rand",
- "rand_chacha",
- "simd_helpers",
- "system-deps",
- "thiserror",
- "v_frame",
- "wasm-bindgen",
-]
-
-[[package]]
-name = "ravif"
-version = "0.11.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2413fd96bd0ea5cdeeb37eaf446a22e6ed7b981d792828721e74ded1980a45c6"
-dependencies = [
- "avif-serialize",
- "imgref",
- "loop9",
- "quick-error",
- "rav1e",
- "rayon",
- "rgb",
-]
-
-[[package]]
-name = "rayon"
-version = "1.10.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b418a60154510ca1a002a752ca9714984e21e4241e804d32555251faf8b78ffa"
-dependencies = [
- "either",
- "rayon-core",
-]
-
-[[package]]
-name = "rayon-core"
-version = "1.12.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1465873a3dfdaa8ae7cb14b4383657caab0b3e8a0aa9ae8e04b044854c8dfce2"
-dependencies = [
- "crossbeam-deque",
- "crossbeam-utils",
-]
-
[[package]]
name = "redox_syscall"
version = "0.5.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "03a862b389f93e68874fbf580b9de08dd02facb9a788ebadaf4a3fd33cf58834"
dependencies = [
- "bitflags 2.8.0",
+ "bitflags",
]
[[package]]
@@ -1835,12 +1281,6 @@ version = "0.8.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
-[[package]]
-name = "rgb"
-version = "0.8.50"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "57397d16646700483b67d2dd6511d79318f9d057fdbd21a4066aeac8b41d310a"
-
[[package]]
name = "ron"
version = "0.8.1"
@@ -1848,7 +1288,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b91f7eff05f748767f183df4320a63d6936e9c6107d97c9e6bdd9784f4289c94"
dependencies = [
"base64",
- "bitflags 2.8.0",
+ "bitflags",
"serde",
"serde_derive",
]
@@ -1868,7 +1308,7 @@ version = "0.38.43"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a78891ee6bf2340288408954ac787aa063d8e8817e9f53abb37c695c6d834ef6"
dependencies = [
- "bitflags 2.8.0",
+ "bitflags",
"errno",
"libc",
"linux-raw-sys",
@@ -1913,36 +1353,6 @@ dependencies = [
"syn 2.0.96",
]
-[[package]]
-name = "serde_spanned"
-version = "0.6.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "87607cb1398ed59d48732e575a4c28a7a8ebf2454b964fe3f224f2afc07909e1"
-dependencies = [
- "serde",
-]
-
-[[package]]
-name = "shlex"
-version = "1.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
-
-[[package]]
-name = "simd-adler32"
-version = "0.3.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d66dc143e6b11c1eddc06d5c423cfc97062865baf299914ab64caa38182078fe"
-
-[[package]]
-name = "simd_helpers"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "95890f873bec569a0362c235787f3aca6e1e887302ba4840839bcc6459c42da6"
-dependencies = [
- "quote",
-]
-
[[package]]
name = "siphasher"
version = "1.0.1"
@@ -1967,12 +1377,6 @@ dependencies = [
"version_check",
]
-[[package]]
-name = "smallvec"
-version = "1.13.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67"
-
[[package]]
name = "sparsevec"
version = "0.2.1"
@@ -2034,19 +1438,6 @@ dependencies = [
"unicode-ident",
]
-[[package]]
-name = "system-deps"
-version = "6.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a3e535eb8dded36d55ec13eddacd30dec501792ff23a0b1682c38601b8cf2349"
-dependencies = [
- "cfg-expr",
- "heck",
- "pkg-config",
- "toml",
- "version-compare",
-]
-
[[package]]
name = "take_mut"
version = "0.2.2"
@@ -2059,12 +1450,6 @@ version = "1.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
-[[package]]
-name = "target-lexicon"
-version = "0.12.16"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1"
-
[[package]]
name = "tempfile"
version = "3.15.0"
@@ -2079,37 +1464,6 @@ dependencies = [
"windows-sys",
]
-[[package]]
-name = "thiserror"
-version = "1.0.69"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52"
-dependencies = [
- "thiserror-impl",
-]
-
-[[package]]
-name = "thiserror-impl"
-version = "1.0.69"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.96",
-]
-
-[[package]]
-name = "tiff"
-version = "0.9.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ba1310fcea54c6a9a4fd1aad794ecc02c31682f6bfbecdf460bf19533eed1e3e"
-dependencies = [
- "flate2",
- "jpeg-decoder",
- "weezl",
-]
-
[[package]]
name = "time"
version = "0.3.37"
@@ -2143,40 +1497,6 @@ dependencies = [
"time-core",
]
-[[package]]
-name = "toml"
-version = "0.8.19"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1ed1f98e3fdc28d6d910e6737ae6ab1a93bf1985935a1193e68f93eeb68d24e"
-dependencies = [
- "serde",
- "serde_spanned",
- "toml_datetime",
- "toml_edit",
-]
-
-[[package]]
-name = "toml_datetime"
-version = "0.6.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0dd7358ecb8fc2f8d014bf86f6f638ce72ba252a2c3a2572f2a795f1d23efb41"
-dependencies = [
- "serde",
-]
-
-[[package]]
-name = "toml_edit"
-version = "0.22.22"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ae48d6208a266e853d946088ed816055e556cc6028c5e8e2b84d9fa5dd7c7f5"
-dependencies = [
- "indexmap",
- "serde",
- "serde_spanned",
- "toml_datetime",
- "winnow",
-]
-
[[package]]
name = "tracing"
version = "0.1.41"
@@ -2217,17 +1537,6 @@ version = "0.2.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
-[[package]]
-name = "v_frame"
-version = "0.3.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d6f32aaa24bacd11e488aa9ba66369c7cd514885742c9fe08cfe85884db3e92b"
-dependencies = [
- "aligned-vec",
- "num-traits",
- "wasm-bindgen",
-]
-
[[package]]
name = "value-bag"
version = "1.10.0"
@@ -2245,12 +1554,6 @@ dependencies = [
"time",
]
-[[package]]
-name = "version-compare"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "852e951cb7832cb45cb1169900d19760cfa39b82bc0ea9c0e5a14ae88411c98b"
-
[[package]]
name = "version_check"
version = "0.9.5"
@@ -2355,12 +1658,6 @@ dependencies = [
"wasm-bindgen",
]
-[[package]]
-name = "weezl"
-version = "0.1.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "53a85b86a771b1c87058196170769dd264f66c0782acf1ae6cc51bfd64b39082"
-
[[package]]
name = "windows-sys"
version = "0.59.0"
@@ -2434,15 +1731,6 @@ version = "0.52.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
-[[package]]
-name = "winnow"
-version = "0.6.24"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c8d71a593cc5c42ad7876e2c1fda56f314f3754c084128833e64f1345ff8a03a"
-dependencies = [
- "memchr",
-]
-
[[package]]
name = "with_builtin_macros"
version = "0.1.0"
@@ -2492,27 +1780,3 @@ dependencies = [
"quote",
"syn 2.0.96",
]
-
-[[package]]
-name = "zune-core"
-version = "0.4.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3f423a2c17029964870cfaabb1f13dfab7d092a62a29a89264f4d36990ca414a"
-
-[[package]]
-name = "zune-inflate"
-version = "0.2.54"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "73ab332fe2f6680068f3582b16a24f90ad7096d5d39b974d1c0aff0125116f02"
-dependencies = [
- "simd-adler32",
-]
-
-[[package]]
-name = "zune-jpeg"
-version = "0.4.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "99a5bab8d7dedf81405c4bb1f2b83ea057643d9cb28778cea9eecddeedd2e028"
-dependencies = [
- "zune-core",
-]
diff --git a/hercules_cg/src/cpu.rs b/hercules_cg/src/cpu.rs
index 85139b4c..c309b15d 100644
--- a/hercules_cg/src/cpu.rs
+++ b/hercules_cg/src/cpu.rs
@@ -615,14 +615,14 @@ impl<'a> CPUContext<'a> {
)?,
DynamicConstant::Min(left, right) => write!(
body,
- " %dc{} = call @llvm.umin.i64(i64%dc{},i64%dc{})\n",
+ " %dc{} = call i64 @llvm.umin.i64(i64%dc{},i64%dc{})\n",
dc.idx(),
left.idx(),
right.idx()
)?,
DynamicConstant::Max(left, right) => write!(
body,
- " %dc{} = call @llvm.umax.i64(i64%dc{},i64%dc{})\n",
+ " %dc{} = call i64 @llvm.umax.i64(i64%dc{},i64%dc{})\n",
dc.idx(),
left.idx(),
right.idx()
diff --git a/hercules_opt/src/editor.rs b/hercules_opt/src/editor.rs
index 342d3a62..4d694d7c 100644
--- a/hercules_opt/src/editor.rs
+++ b/hercules_opt/src/editor.rs
@@ -646,13 +646,15 @@ pub fn walk_all_users<'a>(node: NodeID, editor: &'a FunctionEditor<'a>) -> NodeI
pub fn walk_all_uses_stop_on<'a>(node: NodeID, editor: &'a FunctionEditor<'a>, stop_on: HashSet<NodeID>) -> NodeIterator<'a> {
let len = editor.func().nodes.len();
- NodeIterator { direction: Direction::Uses, visited: vec![false; len], stack: vec![node], func: editor,
+ let uses = editor.get_uses(node).collect();
+ NodeIterator { direction: Direction::Uses, visited: vec![false; len], stack: uses, func: editor,
stop_on,}
}
pub fn walk_all_users_stop_on<'a>(node: NodeID, editor: &'a FunctionEditor<'a>, stop_on: HashSet<NodeID>) -> NodeIterator<'a> {
let len = editor.func().nodes.len();
- NodeIterator { direction: Direction::Users, visited: vec![false; len], stack: vec![node], func: editor,
+ let users = editor.get_users(node).collect();
+ NodeIterator { direction: Direction::Users, visited: vec![false; len], stack: users, func: editor,
stop_on,}
}
diff --git a/hercules_opt/src/forkify.rs b/hercules_opt/src/forkify.rs
index e963dcbc..70bc3b60 100644
--- a/hercules_opt/src/forkify.rs
+++ b/hercules_opt/src/forkify.rs
@@ -16,10 +16,10 @@ use self::hercules_ir::Subgraph;
use self::hercules_ir::control_subgraph;
-use crate::bound_induction_variables;
use crate::calculate_loop_nodes;
use crate::compute_basic_induction_vars;
use crate::compute_loop_variance;
+use crate::find_loop_bound;
use crate::get_loop_exit_conditions;
use crate::walk_all_users;
use crate::walk_all_users_stop_on;
@@ -55,7 +55,7 @@ pub fn forkify(
if forkify_loop(editor, control_subgraph, fork_join_map, &Loop { header: l.0, control: l.1.clone()}) {
return true;
}
- }
+ }
return false;
@@ -63,7 +63,7 @@ pub fn forkify(
/** Given a node used as a loop bound, return a dynamic constant ID. */
-fn get_dc_bound(editor: &mut FunctionEditor, bound: LoopBound) -> Result<DynamicConstantID, String> {
+pub fn get_bound_as_dc(editor: &mut FunctionEditor, bound: LoopBound) -> Result<DynamicConstantID, String> {
// Check for a constant used as loop bound.
match bound {
LoopBound::DynamicConstant(dynamic_constant_id) => {
@@ -144,21 +144,26 @@ pub fn forkify_loop(
let basic_ivs = compute_basic_induction_vars(function, &l, &loop_variance);
// Compute loop bounds
- let Some(basic_iv) = bound_induction_variables(function, &control_subgraph, &l,
+ let Some(basic_iv) = find_loop_bound(editor, &control_subgraph, &l,
&basic_ivs, &loop_condition, &loop_variance) else {return false};
+ let function = editor.func();
+
// Check reductionable phis, only PHIs depending on the loop are considered,
let candidate_phis: Vec<_> = editor.get_users(l.header)
.filter(|id|function.nodes[id.idx()].is_phi())
.filter(|id| *id != basic_iv.node)
+ .filter(|id| *id != condition_node)
.collect();
let reductionable_phis: Vec<_> = analyze_phis(&editor, &l, &candidate_phis).into_iter().collect();
// Check for a constant used as loop bound.
let Some(bound) = basic_iv.bound else {return false};
- let Ok(bound_dc_id) = get_dc_bound(editor, bound) else {return false};
+ let Ok(bound_dc_id) = get_bound_as_dc(editor, bound) else {return false};
+ let loop_nodes = calculate_loop_nodes(editor, l);
+
// START EDITING
// What we do is:
@@ -263,9 +268,6 @@ pub fn forkify_loop(
let function = editor.func();
let (_, factors) = function.nodes[fork_id.idx()].try_fork().unwrap();
let dimension = factors.len() - 1;
-
-
- let loop_nodes = calculate_loop_nodes(editor, l);
// Create ThreadID
editor.edit(
@@ -367,10 +369,12 @@ pub fn forkify_loop(
}
);
+ // Get rid of loop condition
// DCE should get these, but delete them ourselves because we are nice :)
editor.edit(
|mut edit| {
edit = edit.delete_node(loop_continue_projection)?;
+ edit = edit.delete_node(condition_node)?; // Might have to get rid of other users of this.
edit = edit.delete_node(loop_exit_projection)?;
edit = edit.delete_node(loop_if)?;
edit = edit.delete_node(l.header)?;
@@ -454,8 +458,11 @@ pub fn analyze_phis<'a>(editor: &'a FunctionEditor, natural_loop: &'a Loop, phis
// If there are any cycles containing a phi other than itself.
if set1.intersection(&set2).any(|node| editor.func().nodes[node.idx()].is_phi() && node != phi) {
LoopPHI::LoopDependant(*phi)
- } else {
+ } else if set1.intersection(&set2).any(|node| true){
+ // Any cycle exists
LoopPHI::Reductionable(*phi)
+ } else {
+ LoopPHI::LoopDependant(*phi)
}
})
diff --git a/hercules_opt/src/ivar.rs b/hercules_opt/src/ivar.rs
index 60805efd..85ec1ff7 100644
--- a/hercules_opt/src/ivar.rs
+++ b/hercules_opt/src/ivar.rs
@@ -114,13 +114,15 @@ pub fn calculate_loop_nodes(
return false;
}
).collect();
-
+
let all_users: HashSet<_> = editor.get_users(natural_loop.header).filter(|node| editor.func().nodes[node.idx()].is_phi())
.flat_map(|phi| walk_all_users_stop_on(phi, editor, stop_on.clone()))
+ .chain(editor.get_users(natural_loop.header).filter(|node| editor.func().nodes[node.idx()].is_phi()))
.collect();
let all_uses: HashSet<_> = editor.get_users(natural_loop.header).filter(|node| editor.func().nodes[node.idx()].is_phi())
.flat_map(|phi| walk_all_uses_stop_on(phi, editor, stop_on.clone()))
+ .chain(editor.get_users(natural_loop.header).filter(|node| editor.func().nodes[node.idx()].is_phi()))
.filter(|node|
{
// Get rid of nodes in stop_on
@@ -280,15 +282,105 @@ pub fn get_loop_exit_conditions(function: &Function, l: &Loop, control_subgraph:
}})
}
-/** Add bounds to induction variables that don't have a currently known bound.
- - Induction variables that aren't immediately used in a loop condition will not be bounded. For now, we don't return these at all.
- - The single induction variable used in a loop condition will be given an appropriate bound.
- Returns the single induction variable that is used in the loop exit condition, or None if something is wrong.
+pub fn match_canonicalization_bound(editor: &mut FunctionEditor, natural_loop: &Loop, loop_condition: NodeID, loop_if: NodeID, ivar: BasicInductionVariable) -> Option<NodeID> {
+ // Match for code generated by loop canon
+ let Node::Phi { control, data } = &editor.func().nodes[loop_condition.idx()] else {unreachable!()};
- This gives the beginning and final value of the IV, THIS ISN"T NECESSARILY THE ITERATION COUNT.
- */
-pub fn bound_induction_variables(function: &Function, control_subgraph: &Subgraph, l: &Loop,
+ if *control != natural_loop.header {
+ return None
+ }
+
+ let continue_idx = editor.get_uses(natural_loop.header)
+ .position(|node| natural_loop.control[node.idx()])
+ .unwrap();
+
+ let init_idx = 1 - continue_idx;
+
+ // FIXME: Handle multiple loop entries
+ if editor.get_uses(natural_loop.header).len() > 2 {
+ todo!()
+ }
+
+ let Node::Constant { id } = &editor.func().nodes[data[init_idx].idx()] else {return None};
+
+ // Check that the ID is true.
+ let Constant::Boolean(val) = *editor.get_constant(*id) else {return None};
+ if val != true {return None};
+
+ // Check other phi input.
+
+ // FIXME: Factor this out into diff loop analysis.
+ let Node::Binary { left, right, op } = &editor.func().nodes[data[continue_idx].idx()].clone() else {return None};
+
+ let BinaryOperator::LT = op else {return None};
+
+ let bound = &editor.func().nodes[right.idx()];
+ if !(bound.is_constant() || bound.is_dynamic_constant()) {return None};
+ let bound = match bound {
+ Node::Constant { id } => {
+ let constant = editor.get_constant(*id).clone();
+ let Constant::UnsignedInteger64(v) = constant else {return None};
+ let mut b = DynamicConstantID::new(0);
+ editor.edit(
+ |mut edit| {
+ b = edit.add_dynamic_constant(DynamicConstant::Constant(v.try_into().unwrap()));
+ Ok(edit)
+ }
+ );
+ // Return the ID of the dynamic constant that is generated from the constant
+ // or dynamic constant that is the existing loop bound
+ b
+ }
+ Node::DynamicConstant { id } => *id,
+ _ => unreachable!()
+ };
+
+ let Node::Binary { left: add_left, right: add_right, op: add_op } = &editor.func().nodes[left.idx()] else {return None};
+
+ let (phi, inc) = if let Node::Phi { control, data } = &editor.func().nodes[add_left.idx()] {
+ (add_left, add_right)
+ } else if let Node::Phi { control, data } = &editor.func().nodes[add_right.idx()] {
+ (add_right, add_left)
+ } else {
+ return None;
+ };
+
+ // Check Constant
+ let Node::Constant { id } = &editor.func().nodes[inc.idx()] else {return None};
+
+ if !editor.get_constant(*id).is_one() {
+ return None;
+ }
+
+ // Check PHI
+ let Node::Phi { control: outer_control, data: outer_data } = &editor.func().nodes[phi.idx()] else {unreachable!()};
+
+ // FIXME: Multiple loop predecessors.
+ if outer_data[continue_idx] != *left {return None};
+
+ let Node::Constant { id } = &editor.func().nodes[outer_data[init_idx].idx()] else {return None};
+
+ if !editor.get_constant(*id).is_zero() {
+ return None;
+ }
+
+ // All checks passed, make new DC
+ let mut final_node = NodeID::new(0);
+
+ editor.edit(
+ |mut edit| {
+ let one = edit.add_dynamic_constant(DynamicConstant::Constant(1));
+ let max_dc = edit.add_dynamic_constant(DynamicConstant::Max(one, bound));
+ final_node = edit.add_node(Node::DynamicConstant { id: max_dc });
+ Ok(edit)
+ }
+ );
+
+ Some(final_node)
+}
+
+pub fn find_loop_bound(editor: &mut FunctionEditor, control_subgraph: &Subgraph, l: &Loop,
induction_vars: &[BasicInductionVariable], loop_condition: &LoopExit, loop_variance: &LoopVarianceInfo)
-> Option<BasicInductionVariable> {
@@ -301,8 +393,6 @@ pub fn bound_induction_variables(function: &Function, control_subgraph: &Subgrap
// Q: What happens when the loop condition is based on multiple induction variables, i.e: (i + j < 20)
// A: IDK!
- assert!(matches!(loop_condition, LoopExit::Conditional { .. }));
-
let (exit_if_node, loop_condition) = match loop_condition {
LoopExit::Conditional { if_node, condition_node } => (if_node, condition_node),
LoopExit::Unconditional(node_id) => todo!()
@@ -311,34 +401,36 @@ pub fn bound_induction_variables(function: &Function, control_subgraph: &Subgrap
// Check for an induction variable that interacts reasonably with the loop condition via pattern matching.
// FIXME: Is there a better way to check for loop bounds?
for induction_var in induction_vars {
- let bound = match &function.nodes[loop_condition.idx()] {
+ let bound = match &editor.func().nodes[loop_condition.idx()] {
// All of these node types are valid boolean conditionals, we only handle some currently.
// `None` only because it is unimplemented (laziness), not user error.
- Node::Phi { control, data } => todo!(),
- Node::Reduce { control, init, reduct } => todo!(),
- Node::Parameter { index } => todo!(),
- Node::Constant { id } => todo!(),
- Node::Unary { input, op } => todo!(),
- Node::Ternary { first, second, third, op } => todo!(),
+ Node::Phi { control, data } => {
+ match_canonicalization_bound(editor, l, *loop_condition, *exit_if_node, *induction_var)
+ },
+ Node::Reduce { control, init, reduct } => None,
+ Node::Parameter { index } => None,
+ Node::Constant { id } => None,
+ Node::Unary { input, op } => None,
+ Node::Ternary { first, second, third, op } => None,
Node::Binary { left, right, op } => {
match op {
BinaryOperator::LT => {
// Check for a loop guard condition.
// left < right
if *left == induction_var.node &&
- (function.nodes[right.idx()].is_constant() || function.nodes[right.idx()].is_dynamic_constant()) {
- Some(right)
+ (editor.func().nodes[right.idx()].is_constant() || editor.func().nodes[right.idx()].is_dynamic_constant()) {
+ Some(*right)
}
else {
None
}
}
- BinaryOperator::LTE => todo!(), // like wtf.
- BinaryOperator::GT => todo!(),
- BinaryOperator::GTE => todo!(),
- BinaryOperator::EQ => todo!(),
- BinaryOperator::NE => todo!(),
+ BinaryOperator::LTE => None, // like wtf.
+ BinaryOperator::GT => None,
+ BinaryOperator::GTE => None,
+ BinaryOperator::EQ => None,
+ BinaryOperator::NE => None,
_ => None,
}
}
@@ -353,7 +445,7 @@ pub fn bound_induction_variables(function: &Function, control_subgraph: &Subgrap
// NodeID -> LoopBound
let bound = bound.map(|bound|
{
- match function.nodes[bound.idx()] {
+ match editor.func().nodes[bound.idx()] {
Node::Constant { id } => LoopBound::Constant(id),
Node::DynamicConstant { id } => LoopBound::DynamicConstant(id),
_ => todo!(),
diff --git a/hercules_opt/src/loop_canonicalization.rs b/hercules_opt/src/loop_canonicalization.rs
index ebe6669b..cecf379d 100644
--- a/hercules_opt/src/loop_canonicalization.rs
+++ b/hercules_opt/src/loop_canonicalization.rs
@@ -71,9 +71,9 @@ pub fn loop_canonicalization(
}
}
- // if merge_phis(editor) {
- // return true;
- // }
+ if merge_phis(editor) {
+ return true;
+ }
return false;
}
@@ -105,7 +105,7 @@ pub fn merge_phis(editor: &mut FunctionEditor) -> bool {
continue;
}
- // Find a phi it can be merged with (look through data edges until we find a PHI of the same region)
+ // Try to merge with other phis of the same region
let candidate = editor.get_users(*phi_region).filter(|node| editor.func().nodes[node.idx()].is_phi());
let mut merge_candidates = candidate.filter(|node| {
diff --git a/hercules_opt/src/pass.rs b/hercules_opt/src/pass.rs
index 9ba3988c..d072f302 100644
--- a/hercules_opt/src/pass.rs
+++ b/hercules_opt/src/pass.rs
@@ -452,7 +452,8 @@ impl PassManager {
self.module.functions[idx].delete_gravestones();
}
self.clear_analyses();
- }
+ break;
+ }
}
Pass::PhiElim => {
self.make_def_uses();
diff --git a/hercules_test/hercules_interpreter/src/interpreter.rs b/hercules_test/hercules_interpreter/src/interpreter.rs
index c07351bd..7098c1b0 100644
--- a/hercules_test/hercules_interpreter/src/interpreter.rs
+++ b/hercules_test/hercules_interpreter/src/interpreter.rs
@@ -4,6 +4,7 @@ use std::panic;
use std::collections::hash_map::Entry::Occupied;
use itertools::Itertools;
+use std::cmp::{min, max};
use hercules_ir::*;
@@ -70,6 +71,8 @@ pub fn dyn_const_value(dc: &DynamicConstantID, dyn_const_values: &[DynamicConsta
DynamicConstant::Mul(a, b) => dyn_const_value(a, dyn_const_values, dyn_const_params) * dyn_const_value(b, dyn_const_values, dyn_const_params),
DynamicConstant::Div(a, b) => dyn_const_value(a, dyn_const_values, dyn_const_params) / dyn_const_value(b, dyn_const_values, dyn_const_params),
DynamicConstant::Rem(a, b) => dyn_const_value(a, dyn_const_values, dyn_const_params) % dyn_const_value(b, dyn_const_values, dyn_const_params),
+ DynamicConstant::Max(a, b) => max(dyn_const_value(a, dyn_const_values, dyn_const_params), dyn_const_value(b, dyn_const_values, dyn_const_params)),
+ DynamicConstant::Min(a, b) => min(dyn_const_value(a, dyn_const_values, dyn_const_params), dyn_const_value(b, dyn_const_values, dyn_const_params)),
}
}
@@ -421,13 +424,18 @@ impl<'a> FunctionExecutionState<'a> {
}
Node::Read { collect, indices } => {
let collection = self.handle_data(token, *collect);
+ if let InterpreterVal::Undef(v) = collection {
+ collection
+ } else {
+ let result = self.handle_read(token, collection.clone(), indices);
- let result = self.handle_read(token, collection.clone(), indices);
-
- if VERBOSE {
- println!("{:?} read value : {:?} from {:?}, {:?} at index {:?}", node, result, collect, collection, indices);
+ if VERBOSE {
+ println!("{:?} read value : {:?} from {:?}, {:?} at index {:?}", node, result, collect, collection, indices);
+ }
+ result
}
- result
+
+
}
Node::Write {
collect,
@@ -435,8 +443,12 @@ impl<'a> FunctionExecutionState<'a> {
indices,
} => {
let collection = self.handle_data(token, *collect);
- let data = self.handle_data(token, *data);
- self.handle_write(token, collection, data, indices)
+ if let InterpreterVal::Undef(v) = collection {
+ collection
+ } else {
+ let data = self.handle_data(token, *data);
+ self.handle_write(token, collection, data, indices)
+ }
}
Node::Undef {
ty
@@ -485,7 +497,7 @@ impl<'a> FunctionExecutionState<'a> {
.collect();
let idx = InterpreterVal::array_idx(&extents, &array_indices);
//println!("idx: {:?}", idx);
- if idx > vals.len() {
+ if idx >= vals.len() {
InterpreterVal::Undef(type_id)
} else {
vals[idx] = data;
--
GitLab
From 920f20f4c69df8e289955dc09a037a1c6743f445 Mon Sep 17 00:00:00 2001
From: Xavier Routh <xrouth2@illinois.edu>
Date: Tue, 21 Jan 2025 13:47:34 -0600
Subject: [PATCH 38/68] rewrite fork guard elim
---
hercules_opt/src/editor.rs | 4 +
hercules_opt/src/fork_guard_elim.rs | 261 +++++++++++++++++-----------
hercules_opt/src/ivar.rs | 2 +-
hercules_opt/src/pass.rs | 25 ++-
4 files changed, 185 insertions(+), 107 deletions(-)
diff --git a/hercules_opt/src/editor.rs b/hercules_opt/src/editor.rs
index 4d694d7c..e3ab83d5 100644
--- a/hercules_opt/src/editor.rs
+++ b/hercules_opt/src/editor.rs
@@ -239,6 +239,10 @@ impl<'a: 'b, 'b> FunctionEditor<'a> {
self.dynamic_constants.borrow()
}
+ pub fn get_constants(&self) -> Ref<'_, Vec<Constant>> {
+ self.constants.borrow()
+ }
+
pub fn get_users(&self, id: NodeID) -> impl ExactSizeIterator<Item = NodeID> + '_ {
self.mut_def_use[id.idx()].iter().map(|x| *x)
}
diff --git a/hercules_opt/src/fork_guard_elim.rs b/hercules_opt/src/fork_guard_elim.rs
index 842c8308..2e1f89e7 100644
--- a/hercules_opt/src/fork_guard_elim.rs
+++ b/hercules_opt/src/fork_guard_elim.rs
@@ -1,9 +1,12 @@
use std::collections::{HashMap, HashSet};
+use either::Either;
use hercules_ir::get_uses_mut;
use hercules_ir::ir::*;
use hercules_ir::ImmutableDefUseMap;
+use crate::FunctionEditor;
+
/*
* This is a Hercules IR transformation that:
* - Eliminates guards (directly) surrounding fork-joins when the guard's
@@ -28,27 +31,70 @@ use hercules_ir::ImmutableDefUseMap;
* - A map of NodeIDs for the phi nodes to the reduce they should be replaced
* with, and also the region that joins the guard's branches mapping to the
* fork's join NodeID
+ * - If the replication factor is a max that can be eliminated.
*/
+
+// Simplify factors through max
+enum Factor {
+ Max(usize, DynamicConstantID),
+ Normal(usize, DynamicConstantID)
+}
+
+impl Factor {
+ fn get_id(&self) -> DynamicConstantID {
+ match self {
+ Factor::Max(_, dynamic_constant_id) => *dynamic_constant_id,
+ Factor::Normal(_, dynamic_constant_id) => *dynamic_constant_id,
+ }
+ }
+}
+
+
+struct GuardedFork {
+ fork: NodeID,
+ join: NodeID,
+ guard_if: NodeID,
+ fork_taken_proj: NodeID,
+ fork_skipped_proj: NodeID,
+ guard_pred: NodeID,
+ guard_join_region: NodeID,
+ phi_reduce_map: HashMap<NodeID, NodeID>,
+ factor: Factor, // The factor that matches the guard
+}
+
fn guarded_fork(
- function: &Function,
- constants: &Vec<Constant>,
+ editor: &mut FunctionEditor,
fork_join_map: &HashMap<NodeID, NodeID>,
- def_use: &ImmutableDefUseMap,
- index: usize,
- node: &Node,
-) -> Option<(
- NodeID,
- Box<[DynamicConstantID]>,
- NodeID,
- NodeID,
- NodeID,
- NodeID,
- HashMap<NodeID, NodeID>,
-)> {
+ node: NodeID,
+) -> Option<
+ GuardedFork
+> {
+
+ let function = editor.func();
+
// Identify fork nodes
- let Node::Fork { control, factors } = node else {
+ let Node::Fork { control, factors } = &function.nodes[node.idx()] else {
return None;
};
+
+
+ let factors = factors.iter().enumerate().map(|(idx, dc)| {
+ // FIXME: Can we hide .idx() in an impl Index or something so we don't index Vec<Nodes> iwht DynamicConstantId.idx()
+ let DynamicConstant::Max(l, r) = *editor.get_dynamic_constant(*dc) else {return Factor::Normal(idx, *dc)};
+
+ // There really needs to be a better way to work w/ associativity.
+ let binding = [(l,r), (r,l)];
+ let id = binding.iter().find_map(|(a, b)| {
+ let DynamicConstant::Constant(1) = *editor.get_dynamic_constant(*a) else {return None};
+ Some(b)
+ });
+
+ match id {
+ Some(v) => Factor::Max(idx, *v),
+ None => Factor::Normal(idx, *dc)
+ }
+ });
+
// Whose predecessor is a read from an if
let Node::Projection {
control: if_node,
@@ -70,47 +116,60 @@ fn guarded_fork(
return None;
};
let branch_idx = *selection;
- // branchIdx == 1 means the true branch so we want the condition to be
- // 0 < n or n > 0
- if branch_idx == 1
- && !((op == BinaryOperator::LT
- && function.nodes[left.idx()].is_zero_constant(constants)
- && factors
- .iter()
- .any(|factor| function.nodes[right.idx()].try_dynamic_constant() == Some(*factor)))
- || (op == BinaryOperator::GT
- && function.nodes[right.idx()].is_zero_constant(constants)
- && factors.iter().any(|factor| {
- function.nodes[left.idx()].try_dynamic_constant() == Some(*factor)
- })))
- {
- return None;
- }
- // branchIdx == 0 means the false branch so we want the condition to be
- // n < 0 or 0 > n
- if branch_idx == 0
- && !((op == BinaryOperator::LT
- && factors
- .iter()
- .any(|factor| function.nodes[left.idx()].try_dynamic_constant() == Some(*factor))
- && function.nodes[right.idx()].is_zero_constant(constants))
- || (op == BinaryOperator::GT
- && factors.iter().any(|factor| {
- function.nodes[right.idx()].try_dynamic_constant() == Some(*factor)
- })
- && function.nodes[left.idx()].is_zero_constant(constants)))
- {
- return None;
- }
+
+ let factor = {
+ // branchIdx == 1 means the true branch so we want the condition to be
+ // 0 < n or n > 0
+ if branch_idx == 1 {
+ [(left, BinaryOperator::LT, right), (right, BinaryOperator::GT, left)].iter().find_map(|(pattern_zero, pattern_op, pattern_factor)|
+ {
+ // Match Op
+ if op != *pattern_op {
+ return None
+ }
+ // Match Zero
+ if !function.nodes[pattern_zero.idx()].is_zero_constant(&editor.get_constants()) {
+ return None
+ }
+
+ // Match Factor
+ let factor = factors.clone().find(|factor| function.nodes[pattern_factor.idx()].try_dynamic_constant() == Some(factor.get_id()));
+ // return Factor
+ factor
+ })
+ }
+ // branchIdx == 0 means the false branch so we want the condition to be
+ // n < 0 or 0 > n
+ else if branch_idx == 0 {
+ [(right, BinaryOperator::LT, left), (left, BinaryOperator::GT, right)].iter().find_map(|(pattern_zero, pattern_op, pattern_factor)|
+ {
+ // Match Op
+ if op != *pattern_op {
+ return None
+ }
+ // Match Zero
+ if !function.nodes[pattern_zero.idx()].is_zero_constant(&editor.get_constants()) {
+ return None
+ }
+
+ // Match Factor
+ let factor = factors.clone().find(|factor| function.nodes[pattern_factor.idx()].try_dynamic_constant() == Some(factor.get_id()));
+ // return Factor
+ factor
+ })
+ } else {
+ None
+ }
+ };
+
+ let Some(factor) = factor else {return None};
// Identify the join node and its users
- let join_id = fork_join_map.get(&NodeID::new(index))?;
- let join_users = def_use.get_users(*join_id);
+ let join_id = fork_join_map.get(&node)?;
// Find the unique control use of the join; if it's not a region we can't
// eliminate this guard
- let join_control = join_users
- .iter()
+ let join_control = editor.get_users(*join_id)
.filter(|n| function.nodes[n.idx()].is_region())
.collect::<Vec<_>>();
if join_control.len() != 1 {
@@ -145,21 +204,19 @@ fn guarded_fork(
let else_branch = *selection;
if else_branch == branch_idx {
return None;
- }
+ }
if if_node2 != if_node {
return None;
}
// Finally, identify the phi nodes associated with the region and match
// them with the reduce nodes of the fork-join
- let reduce_nodes = join_users
- .iter()
+ let reduce_nodes = editor.get_users(*join_id)
.filter(|n| function.nodes[n.idx()].is_reduce())
.collect::<HashSet<_>>();
// Construct a map from phi nodes indices to the reduce node index
- let phi_nodes = def_use
- .get_users(*join_control)
- .iter()
+ let phi_nodes = editor
+ .get_users(join_control)
.filter_map(|n| {
let Node::Phi {
control: _,
@@ -169,25 +226,25 @@ fn guarded_fork(
return None;
};
if data.len() != 2 {
- return Some((*n, None));
+ return Some((n, None));
}
let (init_idx, reduce_node) = if reduce_nodes.contains(&data[0]) {
(1, data[0])
} else if reduce_nodes.contains(&data[1]) {
(0, data[1])
} else {
- return Some((*n, None));
+ return Some((n, None));
};
let Node::Reduce {
control: _, init, ..
} = function.nodes[reduce_node.idx()]
else {
- return Some((*n, None));
+ return Some((n, None));
};
if data[init_idx] != init {
- return Some((*n, None));
+ return Some((n, None));
}
- Some((*n, Some(reduce_node)))
+ Some((n, Some(reduce_node)))
})
.collect::<HashMap<_, _>>();
@@ -202,25 +259,23 @@ fn guarded_fork(
.map(|(phi, red)| (phi, red.unwrap()))
.collect::<HashMap<_, _>>();
- // We also add a map from the region to the join to this map so we only
- // need one map to handle all node replacements in the elimination process
- phi_nodes.insert(*join_control, *join_id);
-
// Finally, we return this node's index along with
// - The replication factor of the fork
// - The if node
// - The true and false reads of the if
// - The guard's predecessor
// - The map from phi nodes to reduce nodes and the region to the join
- Some((
- NodeID::new(index),
- factors.clone(),
- if_node,
- *control,
- other_pred,
- if_pred,
- phi_nodes,
- ))
+ Some(GuardedFork {
+ fork: node,
+ join: *join_id,
+ guard_if: if_node,
+ fork_taken_proj: *control,
+ fork_skipped_proj: other_pred,
+ guard_pred: if_pred,
+ guard_join_region: join_control,
+ phi_reduce_map: phi_nodes,
+ factor
+ })
}
/*
@@ -229,37 +284,45 @@ fn guarded_fork(
* containing gravestones.
*/
pub fn fork_guard_elim(
- function: &mut Function,
- constants: &Vec<Constant>,
+ editor: &mut FunctionEditor,
fork_join_map: &HashMap<NodeID, NodeID>,
- def_use: &ImmutableDefUseMap,
) {
- let guard_info = function
- .nodes
- .iter()
- .enumerate()
- .filter_map(|(i, n)| guarded_fork(function, constants, fork_join_map, def_use, i, n))
+ let guard_info = editor.node_ids()
+ .filter_map(|node| guarded_fork(editor, fork_join_map, node))
.collect::<Vec<_>>();
+ // (fork_node, factors, guard_node, guard_proj1, guard_proj2, guard_pred, map)
+ for GuardedFork {fork, join, fork_taken_proj, fork_skipped_proj, guard_pred, phi_reduce_map, factor, guard_if, guard_join_region } in guard_info {
- for (fork_node, factors, guard_node, guard_proj1, guard_proj2, guard_pred, map) in guard_info {
- function.nodes[guard_node.idx()] = Node::Start;
- function.nodes[guard_proj1.idx()] = Node::Start;
- function.nodes[guard_proj2.idx()] = Node::Start;
- function.nodes[fork_node.idx()] = Node::Fork {
- control: guard_pred,
- factors,
+ let new_fork_info = if let Factor::Max(idx, dc) = factor {
+ let Node::Fork { control, mut factors } = editor.func().nodes[fork.idx()].clone() else {unreachable!()};
+ factors[idx] = dc;
+ let new_fork = Node::Fork { control: guard_pred, factors };
+ Some(new_fork)
+ } else {
+ None
};
- for (idx, node) in function.nodes.iter_mut().enumerate() {
- let node_idx = NodeID::new(idx);
- if map.contains_key(&node_idx) {
- *node = Node::Start;
+ editor.edit(|mut edit| {
+ edit = edit.replace_all_uses_where(fork_taken_proj, guard_pred, |usee| *usee == fork)?;
+ edit = edit.delete_node(guard_if)?;
+ edit = edit.delete_node(fork_taken_proj)?;
+ edit = edit.delete_node(fork_skipped_proj)?;
+ edit = edit.replace_all_uses(guard_join_region, join)?;
+ edit = edit.delete_node(guard_join_region)?;
+ // Delete region node
+
+ for (phi, reduce) in phi_reduce_map.iter() {
+ edit = edit.replace_all_uses(*phi, *reduce)?;
+ edit = edit.delete_node(*phi)?;
}
- for u in get_uses_mut(node).as_mut() {
- if let Some(replacement) = map.get(u) {
- **u = *replacement;
- }
+
+ if let Some(new_fork_info) = new_fork_info {
+ let new_fork = edit.add_node(new_fork_info);
+ edit = edit.replace_all_uses(fork, new_fork)?;
+ edit = edit.delete_node(fork)?;
}
- }
+
+ Ok(edit)
+ });
}
}
diff --git a/hercules_opt/src/ivar.rs b/hercules_opt/src/ivar.rs
index 85ec1ff7..50f1bf05 100644
--- a/hercules_opt/src/ivar.rs
+++ b/hercules_opt/src/ivar.rs
@@ -490,7 +490,7 @@ pub fn compute_basic_induction_vars(function: &Function, l: &Loop, loop_variance
let phi_node = &function.nodes[phi_id.idx()];
let (region, data) = phi_node.try_phi().unwrap();
let region_node = &function.nodes[region.idx()];
- let region_inputs = region_node.try_region().unwrap();
+ let Node::Region { preds: region_inputs } = region_node else {continue};
// The initializer index is the first index of the inputs to the region node of that isn't in the loop. (what is loop_header, wtf...)
// FIXME (@xrouth): If there is control flow in the loop, we won't find ... WHAT
diff --git a/hercules_opt/src/pass.rs b/hercules_opt/src/pass.rs
index d072f302..0125dcda 100644
--- a/hercules_opt/src/pass.rs
+++ b/hercules_opt/src/pass.rs
@@ -488,16 +488,27 @@ impl PassManager {
let def_uses = self.def_uses.as_ref().unwrap();
let fork_join_maps = self.fork_join_maps.as_ref().unwrap();
for idx in 0..self.module.functions.len() {
- fork_guard_elim(
+ let constants_ref =
+ RefCell::new(std::mem::take(&mut self.module.constants));
+ let dynamic_constants_ref =
+ RefCell::new(std::mem::take(&mut self.module.dynamic_constants));
+ let types_ref = RefCell::new(std::mem::take(&mut self.module.types));
+ let mut editor = FunctionEditor::new(
&mut self.module.functions[idx],
- &self.module.constants,
- &fork_join_maps[idx],
+ FunctionID::new(idx),
+ &constants_ref,
+ &dynamic_constants_ref,
+ &types_ref,
&def_uses[idx],
);
- let num_nodes = self.module.functions[idx].nodes.len();
- self.module.functions[idx]
- .schedules
- .resize(num_nodes, vec![]);
+
+ fork_guard_elim(
+ &mut editor,
+ &fork_join_maps[idx],
+ );
+ self.module.constants = constants_ref.take();
+ self.module.dynamic_constants = dynamic_constants_ref.take();
+ self.module.types = types_ref.take();
self.module.functions[idx].delete_gravestones();
}
self.clear_analyses();
--
GitLab
From 88618609a2bf9263815a7636ba1825ca494588fc Mon Sep 17 00:00:00 2001
From: Xavier Routh <xrouth2@illinois.edu>
Date: Wed, 22 Jan 2025 10:32:41 -0600
Subject: [PATCH 39/68] canonicalization fixes?
---
hercules_opt/src/ivar.rs | 34 ++++++--
hercules_opt/src/loop_canonicalization.rs | 29 +++----
.../hercules_interpreter/src/interpreter.rs | 2 +-
.../hercules_interpreter/src/value.rs | 24 +++++-
.../hercules_tests/tests/forkify_tests.rs | 2 +
.../hercules_tests/tests/loop_tests.rs | 79 +++++++++++++++++--
.../alternate_bounds_internal_control.hir | 3 +-
.../alternate_bounds_internal_control2.hir | 21 +++++
8 files changed, 162 insertions(+), 32 deletions(-)
create mode 100644 hercules_test/test_inputs/loop_analysis/alternate_bounds_internal_control2.hir
diff --git a/hercules_opt/src/ivar.rs b/hercules_opt/src/ivar.rs
index 50f1bf05..256e983b 100644
--- a/hercules_opt/src/ivar.rs
+++ b/hercules_opt/src/ivar.rs
@@ -115,20 +115,38 @@ pub fn calculate_loop_nodes(
}
).collect();
- let all_users: HashSet<_> = editor.get_users(natural_loop.header).filter(|node| editor.func().nodes[node.idx()].is_phi())
- .flat_map(|phi| walk_all_users_stop_on(phi, editor, stop_on.clone()))
- .chain(editor.get_users(natural_loop.header).filter(|node| editor.func().nodes[node.idx()].is_phi()))
- .collect();
-
- let all_uses: HashSet<_> = editor.get_users(natural_loop.header).filter(|node| editor.func().nodes[node.idx()].is_phi())
- .flat_map(|phi| walk_all_uses_stop_on(phi, editor, stop_on.clone()))
- .chain(editor.get_users(natural_loop.header).filter(|node| editor.func().nodes[node.idx()].is_phi()))
+ let phis: Vec<_> = editor.node_ids().filter(|node| {
+ let Node::Phi { control, ref data } = editor.func().nodes[node.idx()] else {return false};
+ natural_loop.control[control.idx()]
+ }).collect();
+
+ // let all_users: HashSet<_> = editor.get_users(natural_loop.header).filter(|node| editor.func().nodes[node.idx()].is_phi())
+ // .flat_map(|phi| walk_all_users_stop_on(phi, editor, stop_on.clone()))
+ // .chain(editor.get_users(natural_loop.header).filter(|node| editor.func().nodes[node.idx()].is_phi()))
+ // .collect();
+
+ let all_users: HashSet<NodeID> = phis.clone().iter().flat_map(|phi| walk_all_users_stop_on(*phi, editor, stop_on.clone()))
+ .chain(phis.clone())
+ .collect();
+
+ let all_uses: HashSet<_> = phis.clone().iter()
+ .flat_map(|phi| walk_all_uses_stop_on(*phi, editor, stop_on.clone()))
+ .chain(phis)
.filter(|node|
{
// Get rid of nodes in stop_on
!stop_on.contains(node)
})
.collect();
+ // let all_uses: HashSet<_> = editor.get_users(natural_loop.header).filter(|node| editor.func().nodes[node.idx()].is_phi())
+ // .flat_map(|phi| walk_all_uses_stop_on(phi, editor, stop_on.clone()))
+ // .chain(editor.get_users(natural_loop.header).filter(|node| editor.func().nodes[node.idx()].is_phi()))
+ // .filter(|node|
+ // {
+ // // Get rid of nodes in stop_on
+ // !stop_on.contains(node)
+ // })
+ // .collect();
all_users.intersection(&all_uses).cloned().collect()
}
diff --git a/hercules_opt/src/loop_canonicalization.rs b/hercules_opt/src/loop_canonicalization.rs
index cecf379d..142874fa 100644
--- a/hercules_opt/src/loop_canonicalization.rs
+++ b/hercules_opt/src/loop_canonicalization.rs
@@ -244,23 +244,10 @@ pub fn canonicalize_loop(
.next()
.unwrap();
- // for phi_to_add in phis_to_add {
- // editor.edit(|mut edit| {
- // let PhiToAdd { joining_phi, internal_phi, initializer } = phi_to_add;
- // let mut data = Box::new([NodeID::new(0); 2]);
- // data[header_initial_idx] = initializer;
- // data[header_continue_idx] = internal_phi;
- // let node = Node::Phi { control: natural_loop.header, data };
- // let new_phi = edit.add_node(node);
- // edit.replace_all_uses_where(internal_phi, new_phi, |usee| *usee == joining_phi)
- // });
- // println!("adding phi");
- // }
+ // ========= Do transformation ===========:
let num_loop_predecessors = editor.get_uses(natural_loop.header).count();
- // ========= Do transformation ===========:
-
// Add PHIs
for data_in_loop in phis_to_add {
editor.edit(|mut edit| {
@@ -300,6 +287,20 @@ pub fn canonicalize_loop(
Ok(edit)
});
+
+ // for phi_to_add in while_loop_conversion {
+ // editor.edit(|mut edit| {
+ // let PhiToAdd { joining_phi, internal_phi, initializer } = phi_to_add;
+ // let mut data = Box::new([NodeID::new(0); 2]);
+ // data[header_initial_idx] = initializer;
+ // data[header_continue_idx] = internal_phi;
+ // let node = Node::Phi { control: natural_loop.header, data };
+ // let new_phi = edit.add_node(node);
+ // edit.replace_all_uses_where(internal_phi, new_phi, |usee| *usee == joining_phi)
+ // });
+ // println!("adding phi");
+ // }
+
}
// Change loop bounds
diff --git a/hercules_test/hercules_interpreter/src/interpreter.rs b/hercules_test/hercules_interpreter/src/interpreter.rs
index 7098c1b0..a705d6fc 100644
--- a/hercules_test/hercules_interpreter/src/interpreter.rs
+++ b/hercules_test/hercules_interpreter/src/interpreter.rs
@@ -367,7 +367,7 @@ impl<'a> FunctionExecutionState<'a> {
}
Node::Unary { input, op } => {
let val = self.handle_data(token, *input);
- InterpreterVal::unary_op(*op, val)
+ InterpreterVal::unary_op(&self.module.types, *op, val)
}
Node::Binary { left, right, op } => {
let left = self.handle_data(token, *left);
diff --git a/hercules_test/hercules_interpreter/src/value.rs b/hercules_test/hercules_interpreter/src/value.rs
index 9c95d845..6e1b8f70 100644
--- a/hercules_test/hercules_interpreter/src/value.rs
+++ b/hercules_test/hercules_interpreter/src/value.rs
@@ -783,7 +783,7 @@ impl<'a> InterpreterVal {
}
}
- pub fn unary_op(op: UnaryOperator, val: InterpreterVal) -> Self {
+ pub fn unary_op(types: &Vec<Type>, op: UnaryOperator, val: InterpreterVal) -> Self {
match (op, val) {
(UnaryOperator::Not, Self::Boolean(val)) => Self::Boolean(!val),
(UnaryOperator::Not, Self::Integer8(val)) => Self::Integer8(!val),
@@ -800,7 +800,27 @@ impl<'a> InterpreterVal {
(UnaryOperator::Neg, Self::Integer64(val)) => Self::Integer64(-val),
(UnaryOperator::Neg, Self::Float32(val)) => Self::Float32(-val),
(UnaryOperator::Neg, Self::Float64(val)) => Self::Float64(-val),
- (UnaryOperator::Cast(_), _) => todo!("Write cast impl"),
+ (UnaryOperator::Cast(type_id), val) => {
+ // FIXME: This probably doesn't work.
+ let val = val.as_usize();
+ match types[type_id.idx()] {
+ Type::Control => todo!(),
+ Type::Boolean => todo!(),
+ Type::Integer8 => todo!(),
+ Type::Integer16 => todo!(),
+ Type::Integer32 => todo!(),
+ Type::Integer64 => todo!(),
+ Type::UnsignedInteger8 => todo!(),
+ Type::UnsignedInteger16 => todo!(),
+ Type::UnsignedInteger32 => todo!(),
+ Type::UnsignedInteger64 => Self::UnsignedInteger64(val.try_into().unwrap()),
+ Type::Float32 => todo!(),
+ Type::Float64 => todo!(),
+ Type::Product(_) => todo!(),
+ Type::Summation(_) => todo!(),
+ Type::Array(type_id, _) => todo!(),
+ }
+ }
(_, Self::Undef(v)) => InterpreterVal::Undef(v),
_ => panic!("Unsupported combination of unary operation and constant value. Did typechecking succeed?")
}
diff --git a/hercules_test/hercules_tests/tests/forkify_tests.rs b/hercules_test/hercules_tests/tests/forkify_tests.rs
index 40859089..37153bf8 100644
--- a/hercules_test/hercules_tests/tests/forkify_tests.rs
+++ b/hercules_test/hercules_tests/tests/forkify_tests.rs
@@ -108,7 +108,9 @@ fn loop_array_sum() {
let passes = vec![
Pass::Verify,
+ Pass::Xdot(true),
Pass::Forkify,
+ Pass::Xdot(false),
Pass::DCE,
Pass::Verify,
];
diff --git a/hercules_test/hercules_tests/tests/loop_tests.rs b/hercules_test/hercules_tests/tests/loop_tests.rs
index 722b5bb2..afc4deca 100644
--- a/hercules_test/hercules_tests/tests/loop_tests.rs
+++ b/hercules_test/hercules_tests/tests/loop_tests.rs
@@ -104,7 +104,7 @@ fn alternate_bounds_use_after_loop() {
#[test]
fn alternate_bounds_internal_control() {
- let len = 1;
+ let len = 4;
let dyn_consts = [len];
let module = parse_file("../test_inputs/loop_analysis/alternate_bounds_internal_control.hir");
@@ -118,7 +118,42 @@ fn alternate_bounds_internal_control() {
Pass::Verify,
Pass::Xdot(true),
Pass::LoopCanonicalization,
- ////Pass::Xdot(True),
+ Pass::Xdot(true),
+ Pass::DCE,
+ Pass::Verify,
+ ];
+
+ for pass in passes {
+ pm.add_pass(pass);
+ }
+
+ pm.run_passes();
+
+ let module = pm.get_module();
+ let result_2 = interp_module!(module, dyn_consts, 3);
+ println!("{:?}", result_1);
+ println!("{:?}", result_2);
+
+ assert_eq!(result_1, result_2);
+}
+
+#[test]
+fn alternate_bounds_internal_control2() {
+ let len = 4;
+ let dyn_consts = [len];
+
+ let module = parse_file("../test_inputs/loop_analysis/alternate_bounds_internal_control2.hir");
+ let result_1 = interp_module!(module, dyn_consts, 3);
+
+ println!("result: {:?}", result_1);
+
+ let mut pm = hercules_opt::pass::PassManager::new(module.clone());
+
+ let passes = vec![
+ Pass::Verify,
+ Pass::Xdot(true),
+ Pass::LoopCanonicalization,
+ Pass::Xdot(true),
Pass::DCE,
Pass::Verify,
];
@@ -344,6 +379,39 @@ fn loop_canonical_sum() {
println!("result: {:?}", result_1);
}
+
+#[test]
+fn antideps_pipeline() {
+ let len = 1;
+ let dyn_consts = [2, 2, 2];
+
+ // FIXME: This path should not leave the crate
+ let module = parse_module_from_hbin("../../juno_samples/antideps/antideps.hbin");
+ let result_1 = interp_module!(module, dyn_consts, 9i32);
+
+ println!("result: {:?}", result_1);
+
+ let mut pm = hercules_opt::pass::PassManager::new(module.clone());
+
+ let passes = vec![
+ Pass::Verify,
+ Pass::Xdot(true),
+ Pass::LoopCanonicalization,
+ Pass::Xdot(true),
+ Pass::Verify,
+ ];
+
+ for pass in passes {
+ pm.add_pass(pass);
+ }
+ pm.run_passes();
+
+
+ let module = pm.get_module();
+ let result_2 = interp_module!(module, dyn_consts, 9i32);
+ assert_eq!(result_1, result_2);
+}
+
#[test]
fn matmul_pipeline() {
let len = 1;
@@ -361,11 +429,12 @@ fn matmul_pipeline() {
let passes = vec![
Pass::Verify,
- Pass::Xdot(true),
Pass::LoopCanonicalization,
Pass::Xdot(true),
Pass::Forkify,
+ Pass::Xdot(true),
Pass::ForkGuardElim,
+ Pass::Xdot(true),
Pass::Forkify,
Pass::ForkGuardElim,
Pass::Forkify,
@@ -384,8 +453,6 @@ fn matmul_pipeline() {
let result_2 = interp_module!(module, dyn_consts, m1.clone(), m2.clone());
assert_eq!(result_1, result_2);
- return;
-
// 1st (innermost) Loop Canonicalization
let mut pm = hercules_opt::pass::PassManager::new(module.clone());
@@ -538,7 +605,7 @@ fn matmul_pipeline() {
Pass::DCE,
Pass::ForkGuardElim,
Pass::DCE,
- //Pass::Xdot(True),
+ Pass::Xdot(true),
Pass::Verify,
];
diff --git a/hercules_test/test_inputs/loop_analysis/alternate_bounds_internal_control.hir b/hercules_test/test_inputs/loop_analysis/alternate_bounds_internal_control.hir
index 3746b00a..8b4431bf 100644
--- a/hercules_test/test_inputs/loop_analysis/alternate_bounds_internal_control.hir
+++ b/hercules_test/test_inputs/loop_analysis/alternate_bounds_internal_control.hir
@@ -19,4 +19,5 @@ fn sum<1>(a: u64) -> u64
if_true = projection(if, 1)
plus_ten = add(red_add, ten)
red_add_2_plus_blah = add(red2, plus_ten)
- r = return(if_false, red_add_2_plus_blah)
\ No newline at end of file
+ final_add = add(inner_phi, red_add_2_plus_blah)
+ r = return(if_false, final_add)
\ No newline at end of file
diff --git a/hercules_test/test_inputs/loop_analysis/alternate_bounds_internal_control2.hir b/hercules_test/test_inputs/loop_analysis/alternate_bounds_internal_control2.hir
new file mode 100644
index 00000000..f4adf643
--- /dev/null
+++ b/hercules_test/test_inputs/loop_analysis/alternate_bounds_internal_control2.hir
@@ -0,0 +1,21 @@
+fn sum<1>(a: u64) -> u64
+ zero_idx = constant(u64, 0)
+ one_idx = constant(u64, 1)
+ two = constant(u64, 2)
+ ten = constant(u64, 10)
+ bound = dynamic_constant(#0)
+ loop = region(start, if_true)
+ inner_ctrl = region(loop)
+ inner_phi = phi(inner_ctrl, idx)
+ idx = phi(loop, zero_idx, idx_inc)
+ idx_inc = add(idx, one_idx)
+ red = phi(loop, zero_idx, red_add)
+ red_add = add(red, two)
+ in_bounds = lt(idx_inc, bound)
+ if = if(inner_ctrl, in_bounds)
+ if_false = projection(if, 0)
+ if_true = projection(if, 1)
+ plus_ten = add(red_add, ten)
+ red_add_2_plus_blah = add(inner_phi, plus_ten)
+ final_add = add(inner_phi, red_add_2_plus_blah)
+ r = return(if_false, final_add)
\ No newline at end of file
--
GitLab
From 8d3395ab85aa8f3d1ccacb3a9d26693189e4d610 Mon Sep 17 00:00:00 2001
From: Xavier Routh <xrouth2@illinois.edu>
Date: Thu, 23 Jan 2025 11:57:48 -0600
Subject: [PATCH 40/68] non-index read/writes for interpreter
---
.../hercules_interpreter/src/interpreter.rs | 14 ++++---
.../hercules_interpreter/src/value.rs | 40 +++++++++++++++++--
2 files changed, 45 insertions(+), 9 deletions(-)
diff --git a/hercules_test/hercules_interpreter/src/interpreter.rs b/hercules_test/hercules_interpreter/src/interpreter.rs
index a705d6fc..52a004e1 100644
--- a/hercules_test/hercules_interpreter/src/interpreter.rs
+++ b/hercules_test/hercules_interpreter/src/interpreter.rs
@@ -466,11 +466,10 @@ impl<'a> FunctionExecutionState<'a> {
data: InterpreterVal,
indices: &[Index],
) -> InterpreterVal {
- let index = &indices[0];
-
+
// TODO (@xrouth): Recurse on writes correctly
- let val = match index {
- Index::Field(idx) => {
+ let val = match indices.first() {
+ Some(Index::Field(idx)) => {
if let InterpreterVal::Product(type_id, mut vals) = collection {
vals[*idx] = data;
InterpreterVal::Product(type_id, vals)
@@ -478,8 +477,11 @@ impl<'a> FunctionExecutionState<'a> {
panic!("PANIC: Field index on not a product type")
}
},
- Index::Variant(_) => todo!(),
- Index::Position(array_indices) => {
+ None => {
+ collection
+ }
+ Some(Index::Variant(_)) => todo!(),
+ Some(Index::Position(array_indices)) => {
// Arrays also have inner indices...
// Recover dimensional data from types.
let array_indices: Vec<_> = array_indices
diff --git a/hercules_test/hercules_interpreter/src/value.rs b/hercules_test/hercules_interpreter/src/value.rs
index 6e1b8f70..8f01a003 100644
--- a/hercules_test/hercules_interpreter/src/value.rs
+++ b/hercules_test/hercules_interpreter/src/value.rs
@@ -77,6 +77,7 @@ where
{
fn from(value: Vec<T>) -> Self {
let mut values = vec![];
+ values.reserve(value.len());
for i in 0..value.len() {
values.push(value[i].clone().into());
}
@@ -90,8 +91,23 @@ where
{
fn from(value: &[T]) -> Self {
let mut values = vec![];
+ values.reserve(value.len());
for i in 0..value.len() {
- values[i] = value[i].clone().into()
+ values.push(value[i].clone().into());
+ }
+ InterpreterWrapper::Array(values.into_boxed_slice())
+ }
+}
+
+impl<T> From<Box<[T]>> for InterpreterWrapper
+where
+ T: Into<InterpreterWrapper> + Clone,
+{
+ fn from(value: Box<[T]>) -> Self {
+ let mut values = vec![];
+ values.reserve(value.len());
+ for i in 0..value.len() {
+ values.push(value[i].clone().into());
}
InterpreterWrapper::Array(values.into_boxed_slice())
}
@@ -802,13 +818,13 @@ impl<'a> InterpreterVal {
(UnaryOperator::Neg, Self::Float64(val)) => Self::Float64(-val),
(UnaryOperator::Cast(type_id), val) => {
// FIXME: This probably doesn't work.
- let val = val.as_usize();
+ let val = val.as_i128();
match types[type_id.idx()] {
Type::Control => todo!(),
Type::Boolean => todo!(),
Type::Integer8 => todo!(),
Type::Integer16 => todo!(),
- Type::Integer32 => todo!(),
+ Type::Integer32 => Self::Integer32(val.try_into().unwrap()),
Type::Integer64 => todo!(),
Type::UnsignedInteger8 => todo!(),
Type::UnsignedInteger16 => todo!(),
@@ -843,6 +859,24 @@ impl<'a> InterpreterVal {
}
}
+
+ pub fn as_i128(&self) -> i128 {
+ match *self {
+ InterpreterVal::Boolean(v) => v.try_into().unwrap(),
+ InterpreterVal::Integer8(v) => v.try_into().unwrap(),
+ InterpreterVal::Integer16(v) => v.try_into().unwrap(),
+ InterpreterVal::Integer32(v) => v.try_into().unwrap(),
+ InterpreterVal::Integer64(v) => v.try_into().unwrap(),
+ InterpreterVal::UnsignedInteger8(v) => v.try_into().unwrap(),
+ InterpreterVal::UnsignedInteger16(v) => v.try_into().unwrap(),
+ InterpreterVal::UnsignedInteger32(v) => v.try_into().unwrap(),
+ InterpreterVal::UnsignedInteger64(v) => v.try_into().unwrap(),
+ InterpreterVal::DynamicConstant(v) => v.try_into().unwrap(),
+ InterpreterVal::ThreadID(v) => v.try_into().unwrap(),
+ _ => panic!("PANIC: Value not castable to usize"),
+ }
+ }
+
// Defines row major / how we layout our arrays
pub fn array_idx(extents: &[usize], indices: &[usize]) -> usize {
let a = extents
--
GitLab
From 5b0936ff349af89dd87ca25b51c28a26c8f70f07 Mon Sep 17 00:00:00 2001
From: Xavier Routh <xrouth2@illinois.edu>
Date: Thu, 23 Jan 2025 11:58:08 -0600
Subject: [PATCH 41/68] awhfjkh
---
Cargo.lock | 747 ++++++++++++++++++++++++++++++++++++++++++++++++++++-
1 file changed, 740 insertions(+), 7 deletions(-)
diff --git a/Cargo.lock b/Cargo.lock
index 2ffa909c..3e6ff111 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2,6 +2,12 @@
# It is not intended for manual editing.
version = 4
+[[package]]
+name = "adler2"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "512761e0bb2578dd7380c6baaa0f4ce03e84f95e960231d1dec8bf4d7d6e2627"
+
[[package]]
name = "aho-corasick"
version = "1.1.3"
@@ -11,6 +17,12 @@ dependencies = [
"memchr",
]
+[[package]]
+name = "aligned-vec"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4aa90d7ce82d4be67b64039a3d588d38dbcc6736577de4a847025ce5b0c468d1"
+
[[package]]
name = "anstream"
version = "0.6.18"
@@ -67,6 +79,29 @@ version = "1.0.95"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "34ac096ce696dc2fcabef30516bb13c0a68a11d30131d3df6f04711467681b04"
+[[package]]
+name = "arbitrary"
+version = "1.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dde20b3d026af13f561bdd0f15edf01fc734f0dafcedbaf42bba506a9517f223"
+
+[[package]]
+name = "arg_enum_proc_macro"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ae92a5119aa49cdbcf6b9f893fe4e1d98b04ccbf82ee0584ad948a44a734dea"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.96",
+]
+
+[[package]]
+name = "arrayvec"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50"
+
[[package]]
name = "async-channel"
version = "1.9.0"
@@ -201,6 +236,29 @@ version = "1.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ace50bade8e6234aa140d9a2f552bbee1db4d353f69b8217bc503490fc1a9f26"
+[[package]]
+name = "av1-grain"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6678909d8c5d46a42abcf571271e15fdbc0a225e3646cf23762cd415046c78bf"
+dependencies = [
+ "anyhow",
+ "arrayvec",
+ "log",
+ "nom",
+ "num-rational",
+ "v_frame",
+]
+
+[[package]]
+name = "avif-serialize"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e335041290c43101ca215eed6f43ec437eb5a42125573f600fc3fa42b9bddd62"
+dependencies = [
+ "arrayvec",
+]
+
[[package]]
name = "base64"
version = "0.21.7"
@@ -222,6 +280,18 @@ dependencies = [
"serde",
]
+[[package]]
+name = "bit_field"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc827186963e592360843fb5ba4b973e145841266c1357f7180c43526f2e5b61"
+
+[[package]]
+name = "bitflags"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+
[[package]]
name = "bitflags"
version = "2.8.0"
@@ -231,6 +301,12 @@ dependencies = [
"serde",
]
+[[package]]
+name = "bitstream-io"
+version = "2.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6099cdc01846bc367c4e7dd630dc5966dccf36b652fae7a74e17b640411a91b2"
+
[[package]]
name = "bitvec"
version = "1.0.1"
@@ -256,18 +332,36 @@ dependencies = [
"piper",
]
+[[package]]
+name = "built"
+version = "0.7.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c360505aed52b7ec96a3636c3f039d99103c37d1d9b4f7a8c743d3ea9ffcd03b"
+
[[package]]
name = "bumpalo"
version = "3.16.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "79296716171880943b8470b5f8d03aa55eb2e645a4874bdbb28adb49162e012c"
+[[package]]
+name = "bytemuck"
+version = "1.21.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ef657dfab802224e671f5818e9a4935f9b1957ed18e58292690cc39e7a4092a3"
+
[[package]]
name = "byteorder"
version = "1.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
+[[package]]
+name = "byteorder-lite"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f1fe948ff07f4bd06c30984e69f5b4899c516a3ef74f34df92a2df2ab535495"
+
[[package]]
name = "cactus"
version = "1.0.7"
@@ -284,6 +378,17 @@ dependencies = [
"with_builtin_macros",
]
+[[package]]
+name = "cc"
+version = "1.2.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13208fcbb66eaeffe09b99fffbe1af420f00a7b35aa99ad683dfc1aa76145229"
+dependencies = [
+ "jobserver",
+ "libc",
+ "shlex",
+]
+
[[package]]
name = "ccp"
version = "0.1.0"
@@ -294,6 +399,16 @@ dependencies = [
"with_builtin_macros",
]
+[[package]]
+name = "cfg-expr"
+version = "0.15.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d067ad48b8650848b989a59a86c6c36a995d02d2bf778d45c3c5d57bc2718f02"
+dependencies = [
+ "smallvec",
+ "target-lexicon",
+]
+
[[package]]
name = "cfg-if"
version = "1.0.0"
@@ -360,6 +475,12 @@ version = "0.2.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "67ba02a97a2bd10f4b59b25c7973101c79642302776489e030cd13cdab09ed15"
+[[package]]
+name = "color_quant"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d7b894f5411737b7867f4827955924d7c254fc9f4d91a6aad6b097804b1018b"
+
[[package]]
name = "colorchoice"
version = "1.0.3"
@@ -375,18 +496,52 @@ dependencies = [
"crossbeam-utils",
]
+[[package]]
+name = "crc32fast"
+version = "1.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a97769d94ddab943e4510d138150169a2758b5ef3eb191a9ee688de3e23ef7b3"
+dependencies = [
+ "cfg-if",
+]
+
[[package]]
name = "critical-section"
version = "1.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "790eea4361631c5e7d22598ecd5723ff611904e3344ce8720784c93e3d83d40b"
+[[package]]
+name = "crossbeam-deque"
+version = "0.8.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9dd111b7b7f7d55b72c0a6ae361660ee5853c9af73f70c3c2ef6858b950e2e51"
+dependencies = [
+ "crossbeam-epoch",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-epoch"
+version = "0.9.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e"
+dependencies = [
+ "crossbeam-utils",
+]
+
[[package]]
name = "crossbeam-utils"
version = "0.8.21"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
+[[package]]
+name = "crunchy"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "43da5946c66ffcc7745f48db692ffbb10a83bfe0afd96235c5c2a4fb23994929"
+
[[package]]
name = "deranged"
version = "0.3.11"
@@ -489,6 +644,21 @@ dependencies = [
"pin-project-lite",
]
+[[package]]
+name = "exr"
+version = "1.73.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f83197f59927b46c04a183a619b7c29df34e63e63c7869320862268c0ef687e0"
+dependencies = [
+ "bit_field",
+ "half",
+ "lebe",
+ "miniz_oxide",
+ "rayon-core",
+ "smallvec",
+ "zune-inflate",
+]
+
[[package]]
name = "fac"
version = "0.1.0"
@@ -506,6 +676,15 @@ version = "2.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be"
+[[package]]
+name = "fdeflate"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e6853b52649d4ac5c0bd02320cddc5ba956bdb407c4b75a2c6b75bf51500f8c"
+dependencies = [
+ "simd-adler32",
+]
+
[[package]]
name = "filetime"
version = "0.2.25"
@@ -518,6 +697,16 @@ dependencies = [
"windows-sys",
]
+[[package]]
+name = "flate2"
+version = "1.0.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c936bfdafb507ebbf50b8074c54fa31c5be9a1e7e5f467dd659697041407d07c"
+dependencies = [
+ "crc32fast",
+ "miniz_oxide",
+]
+
[[package]]
name = "fnv"
version = "1.0.7"
@@ -584,6 +773,16 @@ dependencies = [
"wasi",
]
+[[package]]
+name = "gif"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3fb2d69b19215e18bb912fa30f7ce15846e301408695e44e0ef719f1da9e19f2"
+dependencies = [
+ "color_quant",
+ "weezl",
+]
+
[[package]]
name = "gloo-timers"
version = "0.3.0"
@@ -596,6 +795,16 @@ dependencies = [
"wasm-bindgen",
]
+[[package]]
+name = "half"
+version = "2.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6dd08c532ae367adf81c312a4580bc67f1d0fe8bc9c460520283f4c0ff277888"
+dependencies = [
+ "cfg-if",
+ "crunchy",
+]
+
[[package]]
name = "hash32"
version = "0.2.1"
@@ -662,7 +871,7 @@ dependencies = [
"derive_more",
"hercules_ir",
"hercules_opt",
- "itertools",
+ "itertools 0.14.0",
"ordered-float",
"postcard",
"rand",
@@ -688,7 +897,7 @@ dependencies = [
"either",
"hercules_cg",
"hercules_ir",
- "itertools",
+ "itertools 0.14.0",
"nestify",
"ordered-float",
"postcard",
@@ -712,7 +921,7 @@ dependencies = [
"hercules_interpreter",
"hercules_ir",
"hercules_opt",
- "itertools",
+ "itertools 0.14.0",
"ordered-float",
"rand",
]
@@ -723,6 +932,45 @@ version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fbf6a919d6cf397374f7dfeeea91d974c7c0a7221d0d0f4f20d859d329e53fcc"
+[[package]]
+name = "image"
+version = "0.25.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cd6f44aed642f18953a158afeb30206f4d50da59fbc66ecb53c66488de73563b"
+dependencies = [
+ "bytemuck",
+ "byteorder-lite",
+ "color_quant",
+ "exr",
+ "gif",
+ "image-webp",
+ "num-traits",
+ "png",
+ "qoi",
+ "ravif",
+ "rayon",
+ "rgb",
+ "tiff",
+ "zune-core",
+ "zune-jpeg",
+]
+
+[[package]]
+name = "image-webp"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b77d01e822461baa8409e156015a1d91735549f0f2c17691bd2d996bef238f7f"
+dependencies = [
+ "byteorder-lite",
+ "quick-error",
+]
+
+[[package]]
+name = "imgref"
+version = "1.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d0263a3d970d5c054ed9312c0057b4f3bde9c0b33836d3637361d4a9e6e7a408"
+
[[package]]
name = "indexmap"
version = "2.7.1"
@@ -733,12 +981,32 @@ dependencies = [
"hashbrown",
]
+[[package]]
+name = "interpolate_name"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c34819042dc3d3971c46c2190835914dfbe0c3c13f61449b2997f4e9722dfa60"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.96",
+]
+
[[package]]
name = "is_terminal_polyfill"
version = "1.70.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7943c866cc5cd64cbc25b2e01621d07fa8eb2a1a23160ee81ce38704e97b8ecf"
+[[package]]
+name = "itertools"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba291022dbbd398a455acf126c1e341954079855bc60dfdda641363bd6922569"
+dependencies = [
+ "either",
+]
+
[[package]]
name = "itertools"
version = "0.14.0"
@@ -754,6 +1022,21 @@ version = "1.0.14"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d75a2a4b1b190afb6f5425f10f6a8f959d2ea0b9c2b1d79553551850539e4674"
+[[package]]
+name = "jobserver"
+version = "0.1.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48d1dbcbbeb6a7fec7e059840aa538bd62aaccf972c7346c4d9d2059312853d0"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "jpeg-decoder"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f5d4a7da358eff58addd2877a45865158f0d78c911d43a5784ceb7bbf52833b0"
+
[[package]]
name = "js-sys"
version = "0.3.77"
@@ -764,6 +1047,16 @@ dependencies = [
"wasm-bindgen",
]
+[[package]]
+name = "juno_antideps"
+version = "0.1.0"
+dependencies = [
+ "async-std",
+ "hercules_rt",
+ "juno_build",
+ "with_builtin_macros",
+]
+
[[package]]
name = "juno_build"
version = "0.1.0"
@@ -773,6 +1066,37 @@ dependencies = [
"with_builtin_macros",
]
+[[package]]
+name = "juno_casts_and_intrinsics"
+version = "0.1.0"
+dependencies = [
+ "async-std",
+ "juno_build",
+ "with_builtin_macros",
+]
+
+[[package]]
+name = "juno_cava"
+version = "0.1.0"
+dependencies = [
+ "async-std",
+ "clap",
+ "hercules_rt",
+ "image",
+ "juno_build",
+ "with_builtin_macros",
+]
+
+[[package]]
+name = "juno_concat"
+version = "0.1.0"
+dependencies = [
+ "async-std",
+ "hercules_rt",
+ "juno_build",
+ "with_builtin_macros",
+]
+
[[package]]
name = "juno_frontend"
version = "0.1.0"
@@ -790,6 +1114,16 @@ dependencies = [
"phf",
]
+[[package]]
+name = "juno_implicit_clone"
+version = "0.1.0"
+dependencies = [
+ "async-std",
+ "hercules_rt",
+ "juno_build",
+ "with_builtin_macros",
+]
+
[[package]]
name = "juno_matmul"
version = "0.1.0"
@@ -801,6 +1135,16 @@ dependencies = [
"with_builtin_macros",
]
+[[package]]
+name = "juno_nested_ccp"
+version = "0.1.0"
+dependencies = [
+ "async-std",
+ "hercules_rt",
+ "juno_build",
+ "with_builtin_macros",
+]
+
[[package]]
name = "juno_scheduler"
version = "0.0.1"
@@ -811,6 +1155,16 @@ dependencies = [
"lrpar",
]
+[[package]]
+name = "juno_simple3"
+version = "0.1.0"
+dependencies = [
+ "async-std",
+ "hercules_rt",
+ "juno_build",
+ "with_builtin_macros",
+]
+
[[package]]
name = "kv-log-macro"
version = "1.0.7"
@@ -826,19 +1180,35 @@ version = "1.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
+[[package]]
+name = "lebe"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "03087c2bad5e1034e8cace5926dec053fb3790248370865f5117a7d0213354c8"
+
[[package]]
name = "libc"
version = "0.2.169"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b5aba8db14291edd000dfcc4d620c7ebfb122c613afb886ca8803fa4e128a20a"
+[[package]]
+name = "libfuzzer-sys"
+version = "0.4.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b9569d2f74e257076d8c6bfa73fb505b46b851e51ddaecc825944aa3bed17fa"
+dependencies = [
+ "arbitrary",
+ "cc",
+]
+
[[package]]
name = "libredox"
version = "0.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c0ff37bd590ca25063e35af745c343cb7a0271906fb7b37e4813e8f79f00268d"
dependencies = [
- "bitflags",
+ "bitflags 2.8.0",
"libc",
"redox_syscall",
]
@@ -868,6 +1238,15 @@ dependencies = [
"value-bag",
]
+[[package]]
+name = "loop9"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fae87c125b03c1d2c0150c90365d7d6bcc53fb73a9acaef207d2d065860f062"
+dependencies = [
+ "imgref",
+]
+
[[package]]
name = "lrlex"
version = "0.13.8"
@@ -934,6 +1313,16 @@ dependencies = [
"with_builtin_macros",
]
+[[package]]
+name = "maybe-rayon"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ea1f30cedd69f0a2954655f7188c6a834246d2bcf1e315e2ac40c4b24dc9519"
+dependencies = [
+ "cfg-if",
+ "rayon",
+]
+
[[package]]
name = "memchr"
version = "2.7.4"
@@ -946,6 +1335,16 @@ version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
+[[package]]
+name = "miniz_oxide"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8402cab7aefae129c6977bb0ff1b8fd9a04eb5b51efc50a70bea51cda0c7924"
+dependencies = [
+ "adler2",
+ "simd-adler32",
+]
+
[[package]]
name = "nestify"
version = "0.3.3"
@@ -958,6 +1357,12 @@ dependencies = [
"syn 2.0.96",
]
+[[package]]
+name = "new_debug_unreachable"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "650eef8c711430f1a879fdd01d4745a7deea475becfb90269c06775983bbf086"
+
[[package]]
name = "nom"
version = "7.1.3"
@@ -968,6 +1373,12 @@ dependencies = [
"minimal-lexical",
]
+[[package]]
+name = "noop_proc_macro"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0676bb32a98c1a483ce53e500a81ad9c3d5b3f7c920c28c24e9cb0980d0b5bc8"
+
[[package]]
name = "num-bigint"
version = "0.4.6"
@@ -984,6 +1395,17 @@ version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "51d515d32fb182ee37cda2ccdcb92950d6a3c2893aa280e540671c2cd0f3b1d9"
+[[package]]
+name = "num-derive"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed3955f1a9c7c0c15e092f9c887db08b1fc683305fdf6eb6684f22555355e202"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.96",
+]
+
[[package]]
name = "num-integer"
version = "0.1.46"
@@ -1055,6 +1477,12 @@ version = "2.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f38d5652c16fde515bb1ecef450ab0f6a219d619a7274976324d5e377f7dceba"
+[[package]]
+name = "paste"
+version = "1.0.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"
+
[[package]]
name = "phf"
version = "0.11.3"
@@ -1120,6 +1548,25 @@ dependencies = [
"futures-io",
]
+[[package]]
+name = "pkg-config"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "953ec861398dccce10c670dfeaf3ec4911ca479e9c02154b3a215178c5f566f2"
+
+[[package]]
+name = "png"
+version = "0.17.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "82151a2fc869e011c153adc57cf2789ccb8d9906ce52c0b39a6b5697749d7526"
+dependencies = [
+ "bitflags 1.3.2",
+ "crc32fast",
+ "fdeflate",
+ "flate2",
+ "miniz_oxide",
+]
+
[[package]]
name = "polling"
version = "3.7.4"
@@ -1196,6 +1643,40 @@ dependencies = [
"unicode-ident",
]
+[[package]]
+name = "profiling"
+version = "1.0.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "afbdc74edc00b6f6a218ca6a5364d6226a259d4b8ea1af4a0ea063f27e179f4d"
+dependencies = [
+ "profiling-procmacros",
+]
+
+[[package]]
+name = "profiling-procmacros"
+version = "1.0.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a65f2e60fbf1063868558d69c6beacf412dc755f9fc020f514b7955fc914fe30"
+dependencies = [
+ "quote",
+ "syn 2.0.96",
+]
+
+[[package]]
+name = "qoi"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f6d64c71eb498fe9eae14ce4ec935c555749aef511cca85b5568910d6e48001"
+dependencies = [
+ "bytemuck",
+]
+
+[[package]]
+name = "quick-error"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a993555f31e5a609f617c12db6250dedcac1b0a85076912c436e6fc9b2c8e6a3"
+
[[package]]
name = "quote"
version = "1.0.38"
@@ -1243,13 +1724,83 @@ dependencies = [
"serde",
]
+[[package]]
+name = "rav1e"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cd87ce80a7665b1cce111f8a16c1f3929f6547ce91ade6addf4ec86a8dda5ce9"
+dependencies = [
+ "arbitrary",
+ "arg_enum_proc_macro",
+ "arrayvec",
+ "av1-grain",
+ "bitstream-io",
+ "built",
+ "cfg-if",
+ "interpolate_name",
+ "itertools 0.12.1",
+ "libc",
+ "libfuzzer-sys",
+ "log",
+ "maybe-rayon",
+ "new_debug_unreachable",
+ "noop_proc_macro",
+ "num-derive",
+ "num-traits",
+ "once_cell",
+ "paste",
+ "profiling",
+ "rand",
+ "rand_chacha",
+ "simd_helpers",
+ "system-deps",
+ "thiserror",
+ "v_frame",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "ravif"
+version = "0.11.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2413fd96bd0ea5cdeeb37eaf446a22e6ed7b981d792828721e74ded1980a45c6"
+dependencies = [
+ "avif-serialize",
+ "imgref",
+ "loop9",
+ "quick-error",
+ "rav1e",
+ "rayon",
+ "rgb",
+]
+
+[[package]]
+name = "rayon"
+version = "1.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b418a60154510ca1a002a752ca9714984e21e4241e804d32555251faf8b78ffa"
+dependencies = [
+ "either",
+ "rayon-core",
+]
+
+[[package]]
+name = "rayon-core"
+version = "1.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1465873a3dfdaa8ae7cb14b4383657caab0b3e8a0aa9ae8e04b044854c8dfce2"
+dependencies = [
+ "crossbeam-deque",
+ "crossbeam-utils",
+]
+
[[package]]
name = "redox_syscall"
version = "0.5.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "03a862b389f93e68874fbf580b9de08dd02facb9a788ebadaf4a3fd33cf58834"
dependencies = [
- "bitflags",
+ "bitflags 2.8.0",
]
[[package]]
@@ -1281,6 +1832,12 @@ version = "0.8.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
+[[package]]
+name = "rgb"
+version = "0.8.50"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "57397d16646700483b67d2dd6511d79318f9d057fdbd21a4066aeac8b41d310a"
+
[[package]]
name = "ron"
version = "0.8.1"
@@ -1288,7 +1845,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b91f7eff05f748767f183df4320a63d6936e9c6107d97c9e6bdd9784f4289c94"
dependencies = [
"base64",
- "bitflags",
+ "bitflags 2.8.0",
"serde",
"serde_derive",
]
@@ -1308,7 +1865,7 @@ version = "0.38.43"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a78891ee6bf2340288408954ac787aa063d8e8817e9f53abb37c695c6d834ef6"
dependencies = [
- "bitflags",
+ "bitflags 2.8.0",
"errno",
"libc",
"linux-raw-sys",
@@ -1353,6 +1910,36 @@ dependencies = [
"syn 2.0.96",
]
+[[package]]
+name = "serde_spanned"
+version = "0.6.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "87607cb1398ed59d48732e575a4c28a7a8ebf2454b964fe3f224f2afc07909e1"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "shlex"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
+
+[[package]]
+name = "simd-adler32"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d66dc143e6b11c1eddc06d5c423cfc97062865baf299914ab64caa38182078fe"
+
+[[package]]
+name = "simd_helpers"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "95890f873bec569a0362c235787f3aca6e1e887302ba4840839bcc6459c42da6"
+dependencies = [
+ "quote",
+]
+
[[package]]
name = "siphasher"
version = "1.0.1"
@@ -1377,6 +1964,12 @@ dependencies = [
"version_check",
]
+[[package]]
+name = "smallvec"
+version = "1.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67"
+
[[package]]
name = "sparsevec"
version = "0.2.1"
@@ -1438,6 +2031,19 @@ dependencies = [
"unicode-ident",
]
+[[package]]
+name = "system-deps"
+version = "6.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a3e535eb8dded36d55ec13eddacd30dec501792ff23a0b1682c38601b8cf2349"
+dependencies = [
+ "cfg-expr",
+ "heck",
+ "pkg-config",
+ "toml",
+ "version-compare",
+]
+
[[package]]
name = "take_mut"
version = "0.2.2"
@@ -1450,6 +2056,12 @@ version = "1.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
+[[package]]
+name = "target-lexicon"
+version = "0.12.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1"
+
[[package]]
name = "tempfile"
version = "3.15.0"
@@ -1464,6 +2076,37 @@ dependencies = [
"windows-sys",
]
+[[package]]
+name = "thiserror"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52"
+dependencies = [
+ "thiserror-impl",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.96",
+]
+
+[[package]]
+name = "tiff"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba1310fcea54c6a9a4fd1aad794ecc02c31682f6bfbecdf460bf19533eed1e3e"
+dependencies = [
+ "flate2",
+ "jpeg-decoder",
+ "weezl",
+]
+
[[package]]
name = "time"
version = "0.3.37"
@@ -1497,6 +2140,40 @@ dependencies = [
"time-core",
]
+[[package]]
+name = "toml"
+version = "0.8.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1ed1f98e3fdc28d6d910e6737ae6ab1a93bf1985935a1193e68f93eeb68d24e"
+dependencies = [
+ "serde",
+ "serde_spanned",
+ "toml_datetime",
+ "toml_edit",
+]
+
+[[package]]
+name = "toml_datetime"
+version = "0.6.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0dd7358ecb8fc2f8d014bf86f6f638ce72ba252a2c3a2572f2a795f1d23efb41"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "toml_edit"
+version = "0.22.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ae48d6208a266e853d946088ed816055e556cc6028c5e8e2b84d9fa5dd7c7f5"
+dependencies = [
+ "indexmap",
+ "serde",
+ "serde_spanned",
+ "toml_datetime",
+ "winnow",
+]
+
[[package]]
name = "tracing"
version = "0.1.41"
@@ -1537,6 +2214,17 @@ version = "0.2.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
+[[package]]
+name = "v_frame"
+version = "0.3.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d6f32aaa24bacd11e488aa9ba66369c7cd514885742c9fe08cfe85884db3e92b"
+dependencies = [
+ "aligned-vec",
+ "num-traits",
+ "wasm-bindgen",
+]
+
[[package]]
name = "value-bag"
version = "1.10.0"
@@ -1554,6 +2242,12 @@ dependencies = [
"time",
]
+[[package]]
+name = "version-compare"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "852e951cb7832cb45cb1169900d19760cfa39b82bc0ea9c0e5a14ae88411c98b"
+
[[package]]
name = "version_check"
version = "0.9.5"
@@ -1658,6 +2352,12 @@ dependencies = [
"wasm-bindgen",
]
+[[package]]
+name = "weezl"
+version = "0.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53a85b86a771b1c87058196170769dd264f66c0782acf1ae6cc51bfd64b39082"
+
[[package]]
name = "windows-sys"
version = "0.59.0"
@@ -1731,6 +2431,15 @@ version = "0.52.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
+[[package]]
+name = "winnow"
+version = "0.6.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8d71a593cc5c42ad7876e2c1fda56f314f3754c084128833e64f1345ff8a03a"
+dependencies = [
+ "memchr",
+]
+
[[package]]
name = "with_builtin_macros"
version = "0.1.0"
@@ -1780,3 +2489,27 @@ dependencies = [
"quote",
"syn 2.0.96",
]
+
+[[package]]
+name = "zune-core"
+version = "0.4.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f423a2c17029964870cfaabb1f13dfab7d092a62a29a89264f4d36990ca414a"
+
+[[package]]
+name = "zune-inflate"
+version = "0.2.54"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "73ab332fe2f6680068f3582b16a24f90ad7096d5d39b974d1c0aff0125116f02"
+dependencies = [
+ "simd-adler32",
+]
+
+[[package]]
+name = "zune-jpeg"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "99a5bab8d7dedf81405c4bb1f2b83ea057643d9cb28778cea9eecddeedd2e028"
+dependencies = [
+ "zune-core",
+]
--
GitLab
From 89a28b236b2f7a81d00fbe8dbe994e4375c50d7d Mon Sep 17 00:00:00 2001
From: Xavier Routh <xrouth2@illinois.edu>
Date: Thu, 23 Jan 2025 15:28:37 -0600
Subject: [PATCH 42/68] integrate new scheduler / pass manager
---
Cargo.lock | 5 +
Cargo.toml | 4 +-
hercules_test/hercules_interpreter/Cargo.toml | 4 +-
hercules_test/hercules_interpreter/src/lib.rs | 24 +-
hercules_test/hercules_tests/Cargo.toml | 1 +
.../tests/fork_transform_tests.rs | 119 ++---
.../hercules_tests/tests/forkify_tests.rs | 394 ++++-----------
.../hercules_tests/tests/interpreter_tests.rs | 10 +-
.../hercules_tests/tests/loop_tests.rs | 470 ++++--------------
.../hercules_tests/tests/opt_tests.rs | 399 +++++++--------
.../implicit_clone/src/implicit_clone.jn | 135 -----
juno_samples/implicit_clone/src/main.rs | 42 +-
juno_samples/matmul/build.rs | 3 +-
juno_samples/nested_ccp/build.rs | 1 -
juno_scheduler/Cargo.toml | 2 +
juno_scheduler/src/compile.rs | 2 +
juno_scheduler/src/default.rs | 12 +-
juno_scheduler/src/ir.rs | 2 +
juno_scheduler/src/lib.rs | 43 +-
juno_scheduler/src/pm.rs | 123 ++++-
20 files changed, 643 insertions(+), 1152 deletions(-)
diff --git a/Cargo.lock b/Cargo.lock
index fab6e152..623fc35c 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -855,9 +855,11 @@ dependencies = [
"hercules_ir",
"hercules_opt",
"itertools 0.14.0",
+ "juno_scheduler",
"ordered-float",
"postcard",
"rand",
+ "serde",
]
[[package]]
@@ -905,6 +907,7 @@ dependencies = [
"hercules_ir",
"hercules_opt",
"itertools 0.14.0",
+ "juno_scheduler",
"ordered-float",
"rand",
]
@@ -1152,6 +1155,8 @@ dependencies = [
"juno_utils",
"lrlex",
"lrpar",
+ "postcard",
+ "serde",
"tempfile",
]
diff --git a/Cargo.toml b/Cargo.toml
index 6a260e71..d31c59f7 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -26,7 +26,7 @@ members = [
"juno_samples/nested_ccp",
"juno_samples/antideps",
"juno_samples/implicit_clone",
- "juno_samples/cava",
+ "juno_samples/cava",
"juno_samples/concat",
- "juno_samples/schedule_test",
+ "juno_samples/schedule_test",
]
diff --git a/hercules_test/hercules_interpreter/Cargo.toml b/hercules_test/hercules_interpreter/Cargo.toml
index 6bad1674..6e02b9b8 100644
--- a/hercules_test/hercules_interpreter/Cargo.toml
+++ b/hercules_test/hercules_interpreter/Cargo.toml
@@ -9,7 +9,9 @@ clap = { version = "*", features = ["derive"] }
rand = "*"
hercules_ir = { path = "../../hercules_ir" }
hercules_opt = { path = "../../hercules_opt" }
+juno_scheduler = { path = "../../juno_scheduler" }
itertools = "*"
ordered-float = "*"
derive_more = {version = "*", features = ["from"]}
-postcard = { version = "*", features = ["alloc"] }
\ No newline at end of file
+postcard = { version = "*", features = ["alloc"] }
+serde = { version = "*", features = ["derive"] }
\ No newline at end of file
diff --git a/hercules_test/hercules_interpreter/src/lib.rs b/hercules_test/hercules_interpreter/src/lib.rs
index 4801c0a2..bc9ff312 100644
--- a/hercules_test/hercules_interpreter/src/lib.rs
+++ b/hercules_test/hercules_interpreter/src/lib.rs
@@ -1,6 +1,7 @@
pub mod interpreter;
pub mod value;
extern crate postcard;
+extern crate juno_scheduler;
use std::fs::File;
use std::io::Read;
@@ -9,6 +10,9 @@ use hercules_ir::Module;
use hercules_ir::TypeID;
use hercules_ir::ID;
+pub use juno_scheduler::PassManager;
+use juno_scheduler::run_schedule_on_hercules;
+
pub use crate::interpreter::*;
pub use crate::value::*;
@@ -97,7 +101,7 @@ pub fn parse_module_from_hbin(path: &str) -> hercules_ir::ir::Module {
#[macro_export]
macro_rules! interp_module {
- ($module:ident, $dynamic_constants:expr, $($args:expr), *) => {
+ ($module:ident, $entry_func:expr, $dynamic_constants:expr, $($args:expr), *) => {
{
//let hir_file = String::from($path);
@@ -106,10 +110,8 @@ macro_rules! interp_module {
let dynamic_constants: Vec<usize> = $dynamic_constants.into();
let module = $module.clone(); //parse_file(hir_file);
- let mut pm = hercules_opt::pass::PassManager::new(module);
- pm.add_pass(hercules_opt::pass::Pass::Verify);
-
- pm.run_passes();
+ let mut pm = PassManager::new(module);
+ pm.make_typing();
pm.make_reverse_postorders();
pm.make_doms();
pm.make_fork_join_maps();
@@ -124,7 +126,6 @@ macro_rules! interp_module {
let def_uses = pm.def_uses.as_ref().unwrap().clone();
let module = pm.get_module();
-
let mut function_contexts = vec![];
for idx in 0..module.functions.len() {
@@ -137,7 +138,7 @@ macro_rules! interp_module {
function_contexts.push(context);
}
- let function_number = 0;
+ let function_number = $entry_func;
let parameter_types = &module.functions[function_number].param_types;
@@ -165,15 +166,8 @@ macro_rules! interp_file_with_passes {
let result_before = interp_module!(module, $dynamic_constants, $($args), *);
- let mut pm = hercules_opt::pass::PassManager::new(module.clone());
+ let module = run_schedule_on_hercules(module, None).unwrap();
- for pass in $passes {
- pm.add_pass(pass);
- }
-
- pm.run_passes();
-
- let module = pm.get_module();
let result_after = interp_module!(module, $dynamic_constants, $($args), *);
assert_eq!(result_after, result_before);
diff --git a/hercules_test/hercules_tests/Cargo.toml b/hercules_test/hercules_tests/Cargo.toml
index 9bd6fe7b..8c140e75 100644
--- a/hercules_test/hercules_tests/Cargo.toml
+++ b/hercules_test/hercules_tests/Cargo.toml
@@ -9,6 +9,7 @@ clap = { version = "*", features = ["derive"] }
rand = "*"
hercules_ir = { path = "../../hercules_ir" }
hercules_opt = { path = "../../hercules_opt" }
+juno_scheduler = { path = "../../juno_scheduler" }
hercules_interpreter = { path = "../hercules_interpreter" }
itertools = "*"
ordered-float = "*"
diff --git a/hercules_test/hercules_tests/tests/fork_transform_tests.rs b/hercules_test/hercules_tests/tests/fork_transform_tests.rs
index 934f0518..3d0a9cd2 100644
--- a/hercules_test/hercules_tests/tests/fork_transform_tests.rs
+++ b/hercules_test/hercules_tests/tests/fork_transform_tests.rs
@@ -1,39 +1,34 @@
use std::{env, fs::File, io::Read, path::Path};
use hercules_interpreter::*;
-use hercules_opt::pass::Pass;
use hercules_ir::ID;
extern crate rand;
+use juno_scheduler::{default_schedule, ir::ScheduleStmt, run_schedule_on_hercules};
use rand::Rng;
+use juno_scheduler::pass;
+
+
#[test]
fn fission_simple1() {
let module = parse_file("../test_inputs/fork_transforms/fork_fission/simple1.hir");
let dyn_consts = [10];
let params = 2; // TODO: (@xrouth) fix macro to take no params as an option.
- let result_1 = interp_module!(module, dyn_consts, 2);
+ let result_1 = interp_module!(module, 0, dyn_consts, 2);
println!("result: {:?}", result_1);
- let mut pm = hercules_opt::pass::PassManager::new(module.clone());
-
- let passes = vec![
- Pass::Verify,
- Pass::ForkFission,
- Pass::DCE,
- // Pass::Xdot(true),
- Pass::Verify,
- ];
-
- for pass in passes {
- pm.add_pass(pass);
- }
- pm.run_passes();
-
- let module = pm.get_module();
- let result_2 = interp_module!(module, dyn_consts, 2);
+ let sched: Option<ScheduleStmt> = Some(default_schedule![
+ Verify,
+ ForkFission,
+ DCE,
+ Verify,
+ ]);
+
+ let module = run_schedule_on_hercules(module, sched).unwrap();
+ let result_2 = interp_module!(module, 0, dyn_consts, 2);
println!("result: {:?}", result_2);
assert_eq!(result_1, result_2)
}
@@ -44,27 +39,19 @@ fn fission_simple2() {
let module = parse_file("../test_inputs/fork_transforms/fork_fission/simple2.hir");
let dyn_consts = [10];
let params = 2; // TODO: (@xrouth) fix macro to take no params as an option.
- let result_1 = interp_module!(module, dyn_consts, 2);
+ let result_1 = interp_module!(module, 0, dyn_consts, 2);
println!("result: {:?}", result_1);
- let mut pm = hercules_opt::pass::PassManager::new(module.clone());
-
- let passes = vec![
- Pass::Verify,
- Pass::ForkFission,
- Pass::DCE,
- // Pass::Xdot(true),
- Pass::Verify,
- ];
-
- for pass in passes {
- pm.add_pass(pass);
- }
- pm.run_passes();
-
- let module = pm.get_module();
- let result_2 = interp_module!(module, dyn_consts, 2);
+ let sched: Option<ScheduleStmt> = Some(default_schedule![
+ Verify,
+ ForkFission,
+ DCE,
+ Verify,
+ ]);
+
+ let module = run_schedule_on_hercules(module, sched).unwrap();
+ let result_2 = interp_module!(module, 0, dyn_consts, 2);
println!("result: {:?}", result_2);
assert_eq!(result_1, result_2)
}
@@ -76,28 +63,19 @@ fn fission_tricky() {
let module = parse_file("../test_inputs/fork_transforms/fork_fission/tricky.hir");
let dyn_consts = [10];
let params = 2; // TODO: (@xrouth) fix macro to take no params as an option.
- let result_1 = interp_module!(module, dyn_consts, 2);
+ let result_1 = interp_module!(module, 0, dyn_consts, 2);
println!("result: {:?}", result_1);
- let mut pm = hercules_opt::pass::PassManager::new(module.clone());
-
- let passes = vec![
- Pass::Verify,
- // Pass::Xdot(true),
- Pass::ForkFission,
- Pass::DCE,
- // Pass::Xdot(true),
- Pass::Verify,
- ];
-
- for pass in passes {
- pm.add_pass(pass);
- }
- pm.run_passes();
-
- let module = pm.get_module();
- let result_2 = interp_module!(module, dyn_consts, 2);
+ let sched: Option<ScheduleStmt> = Some(default_schedule![
+ Verify,
+ ForkFission,
+ DCE,
+ Verify,
+ ]);
+
+ let module = run_schedule_on_hercules(module, sched).unwrap();
+ let result_2 = interp_module!(module, 0, dyn_consts, 2);
println!("result: {:?}", result_2);
assert_eq!(result_1, result_2)
}
@@ -108,28 +86,19 @@ fn inner_loop() {
let module = parse_file("../test_inputs/fork_transforms/fork_fission/inner_loop.hir");
let dyn_consts = [10, 20];
let params = 2; // TODO: (@xrouth) fix macro to take no params as an option.
- let result_1 = interp_module!(module, dyn_consts, 2);
+ let result_1 = interp_module!(module, 0, dyn_consts, 2);
println!("result: {:?}", result_1);
- let mut pm = hercules_opt::pass::PassManager::new(module.clone());
-
- let passes = vec![
- Pass::Verify,
- // Pass::Xdot(true),
- Pass::ForkFission,
- Pass::DCE,
- // Pass::Xdot(false),
- Pass::Verify,
- ];
-
- for pass in passes {
- pm.add_pass(pass);
- }
- pm.run_passes();
-
- let module = pm.get_module();
- let result_2 = interp_module!(module, dyn_consts, 2);
+ let sched: Option<ScheduleStmt> = Some(default_schedule![
+ Verify,
+ ForkFission,
+ DCE,
+ Verify,
+ ]);
+
+ let module = run_schedule_on_hercules(module, sched).unwrap();
+ let result_2 = interp_module!(module, 0, dyn_consts, 2);
println!("result: {:?}", result_2);
assert_eq!(result_1, result_2)
}
\ No newline at end of file
diff --git a/hercules_test/hercules_tests/tests/forkify_tests.rs b/hercules_test/hercules_tests/tests/forkify_tests.rs
index 37153bf8..cb43678d 100644
--- a/hercules_test/hercules_tests/tests/forkify_tests.rs
+++ b/hercules_test/hercules_tests/tests/forkify_tests.rs
@@ -1,37 +1,36 @@
use std::{env, fs::File, io::Read, path::Path};
use hercules_interpreter::*;
-use hercules_opt::pass::Pass;
use hercules_ir::ID;
+use hercules_interpreter::*;
+use juno_scheduler::ir::*;
+use juno_scheduler::pass;
extern crate rand;
+use juno_scheduler::{default_schedule, run_schedule_on_hercules};
use rand::Rng;
+
+
#[test]
fn loop_simple_iv() {
let module = parse_file("../test_inputs/forkify/loop_simple_iv.hir");
let dyn_consts = [10];
let params = 2; // TODO: (@xrouth) fix macro to take no params as an option.
- let result_1 = interp_module!(module, dyn_consts, 2);
+ let result_1 = interp_module!(module, 0, dyn_consts, 2);
println!("result: {:?}", result_1);
- let mut pm = hercules_opt::pass::PassManager::new(module.clone());
+ let sched: Option<ScheduleStmt> = Some(default_schedule![
+ Verify,
+ Forkify,
+ Verify,
+ ]);
- let passes = vec![
- Pass::Verify,
- Pass::Forkify,
- Pass::Verify,
- ];
-
- for pass in passes {
- pm.add_pass(pass);
- }
- pm.run_passes();
+ let module = run_schedule_on_hercules(module, sched).unwrap();
- let module = pm.get_module();
- let result_2 = interp_module!(module, dyn_consts, 2);
+ let result_2 = interp_module!(module, 0, dyn_consts, 2);
println!("result: {:?}", result_2);
assert_eq!(result_1, result_2)
}
@@ -41,26 +40,12 @@ fn loop_sum() {
let module = parse_file("../test_inputs/forkify/loop_sum.hir");
let dyn_consts = [20];
let params = 2; // TODO: (@xrouth) fix macro to take no params as an option.
- let result_1 = interp_module!(module, dyn_consts, 2);
+ let result_1 = interp_module!(module, 0, dyn_consts, 2);
println!("result: {:?}", result_1);
- let mut pm = hercules_opt::pass::PassManager::new(module.clone());
-
- let passes = vec![
- Pass::Verify,
- Pass::Forkify,
- Pass::DCE,
- Pass::Verify,
- ];
-
- for pass in passes {
- pm.add_pass(pass);
- }
- pm.run_passes();
-
- let module = pm.get_module();
- let result_2 = interp_module!(module, dyn_consts, 2);
+ let module = run_schedule_on_hercules(module, None).unwrap();
+ let result_2 = interp_module!(module, 0, dyn_consts, 2);
assert_eq!(result_1, result_2);
println!("{:?}, {:?}", result_1, result_2);
}
@@ -70,26 +55,12 @@ fn loop_tid_sum() {
let module = parse_file("../test_inputs/forkify/loop_tid_sum.hir");
let dyn_consts = [20];
let params = 2; // TODO: (@xrouth) fix macro to take no params as an option.
- let result_1 = interp_module!(module, dyn_consts, 2);
+ let result_1 = interp_module!(module, 0, dyn_consts, 2);
println!("result: {:?}", result_1);
- let mut pm = hercules_opt::pass::PassManager::new(module.clone());
-
- let passes = vec![
- Pass::Verify,
- Pass::Forkify,
- Pass::DCE,
- Pass::Verify,
- ];
-
- for pass in passes {
- pm.add_pass(pass);
- }
- pm.run_passes();
-
- let module = pm.get_module();
- let result_2 = interp_module!(module, dyn_consts, 2);
+ let module = run_schedule_on_hercules(module, None).unwrap();
+ let result_2 = interp_module!(module, 0, dyn_consts, 2);
assert_eq!(result_1, result_2);
println!("{:?}, {:?}", result_1, result_2);
}
@@ -100,28 +71,12 @@ fn loop_array_sum() {
let len = 5;
let dyn_consts = [len];
let params = vec![1, 2, 3, 4, 5]; // TODO: (@xrouth) fix macro to take no params as an option.
- let result_1 = interp_module!(module, dyn_consts, params.clone());
+ let result_1 = interp_module!(module, 0, dyn_consts, params.clone());
println!("result: {:?}", result_1);
- let mut pm = hercules_opt::pass::PassManager::new(module.clone());
-
- let passes = vec![
- Pass::Verify,
- Pass::Xdot(true),
- Pass::Forkify,
- Pass::Xdot(false),
- Pass::DCE,
- Pass::Verify,
- ];
-
- for pass in passes {
- pm.add_pass(pass);
- }
- pm.run_passes();
-
- let module = pm.get_module();
- let result_2 = interp_module!(module, dyn_consts, params);
+ let module = run_schedule_on_hercules(module, None).unwrap();
+ let result_2 = interp_module!(module, 0, dyn_consts, params);
assert_eq!(result_1, result_2);
println!("{:?}, {:?}", result_1, result_2);
}
@@ -142,47 +97,14 @@ fn nested_loop2() {
let len = 5;
let dyn_consts = [5, 6];
let params = vec![1, 2, 3, 4, 5]; // TODO: (@xrouth) fix macro to take no params as an option.
- let result_1 = interp_module!(module, dyn_consts, 2);
+ let result_1 = interp_module!(module, 0, dyn_consts, 2);
println!("result: {:?}", result_1);
- let mut pm = hercules_opt::pass::PassManager::new(module.clone());
-
- let passes = vec![
- Pass::Verify,
- Pass::Forkify,
- Pass::DCE,
- Pass::Verify,
- ];
-
- for pass in passes {
- pm.add_pass(pass);
- }
- pm.run_passes();
-
- let module = pm.get_module();
- let result_2 = interp_module!(module, dyn_consts, 2);
+ let module = run_schedule_on_hercules(module, None).unwrap();
+ let result_2 = interp_module!(module, 0, dyn_consts, 2);
assert_eq!(result_1, result_2);
- let mut pm = hercules_opt::pass::PassManager::new(module.clone());
-
- let passes = vec![
- Pass::Verify,
- Pass::Forkify,
- Pass::DCE,
- Pass::Verify,
- // Pass::Xdot(true),
- ];
-
- for pass in passes {
- pm.add_pass(pass);
- }
- pm.run_passes();
-
- let module = pm.get_module();
- let result_3 = interp_module!(module, dyn_consts, 2);
-
- println!("{:?}, {:?}, {:?}", result_1, result_2, result_3);
}
#[test]
@@ -191,93 +113,14 @@ fn super_nested_loop() {
let len = 5;
let dyn_consts = [5, 10, 15];
let params = vec![1, 2, 3, 4, 5]; // TODO: (@xrouth) fix macro to take no params as an option.
- let result_1 = interp_module!(module, dyn_consts, 2);
-
- println!("result: {:?}", result_1);
-
- let mut pm = hercules_opt::pass::PassManager::new(module.clone());
-
- let passes = vec![
- Pass::Verify,
- Pass::Forkify,
- Pass::DCE,
- Pass::Verify,
- ];
-
- for pass in passes {
- pm.add_pass(pass);
- }
- pm.run_passes();
-
- let module = pm.get_module();
- let result_2 = interp_module!(module, dyn_consts, 2);
- assert_eq!(result_1, result_2);
-
- let mut pm = hercules_opt::pass::PassManager::new(module.clone());
-
- let passes = vec![
- Pass::Verify,
- Pass::Forkify,
- Pass::DCE,
- Pass::Verify,
- ];
-
- for pass in passes {
- pm.add_pass(pass);
- }
- pm.run_passes();
-
- let module = pm.get_module();
- let result_3 = interp_module!(module, dyn_consts, 2);
-
- let mut pm = hercules_opt::pass::PassManager::new(module.clone());
-
- let passes = vec![
- Pass::Verify,
- Pass::Forkify,
- Pass::DCE,
- Pass::Verify,
- ];
-
- for pass in passes {
- pm.add_pass(pass);
- }
- pm.run_passes();
-
- let module = pm.get_module();
- let result_4 = interp_module!(module, dyn_consts, 2);
-
- println!("{:?}, {:?}, {:?}, {:?}", result_1, result_2, result_3, result_4);
-}
-
-
-fn interpret_temp() {
- let module = parse_module_from_hbin("../../a.hbin");
- let len = 5;
- let dyn_consts = [5, 6];
- let params = vec![1, 2, 3, 4, 5]; // TODO: (@xrouth) fix macro to take no params as an option.
- let result_1 = interp_module!(module, dyn_consts, 2);
+ let result_1 = interp_module!(module, 0, dyn_consts, 2);
println!("result: {:?}", result_1);
- let mut pm = hercules_opt::pass::PassManager::new(module.clone());
-
- let passes = vec![
- Pass::Verify,
- Pass::Forkify,
- Pass::DCE,
- Pass::Verify,
- ];
-
- for pass in passes {
- pm.add_pass(pass);
- }
- pm.run_passes();
+ let module = run_schedule_on_hercules(module, None).unwrap();
- let module = pm.get_module();
- let result_2 = interp_module!(module, dyn_consts, 2);
+ let result_2 = interp_module!(module, 0, dyn_consts, 2);
assert_eq!(result_1, result_2);
- println!("{:?}, {:?}", result_1, result_2);
}
@@ -298,26 +141,13 @@ fn control_after_condition() {
*x = rng.gen::<i32>() / 100;
}
- let result_1 = interp_module!(module, dyn_consts, vec.clone());
+ let result_1 = interp_module!(module, 0, dyn_consts, vec.clone());
println!("result: {:?}", result_1);
- let mut pm = hercules_opt::pass::PassManager::new(module.clone());
-
- let passes = vec![
- Pass::Verify,
- Pass::Forkify,
- Pass::DCE,
- Pass::Verify,
- ];
-
- for pass in passes {
- pm.add_pass(pass);
- }
- pm.run_passes();
+ let module = run_schedule_on_hercules(module, None).unwrap();
- let module = pm.get_module();
- let result_2 = interp_module!(module, dyn_consts, vec);
+ let result_2 = interp_module!(module, 0, dyn_consts, vec);
assert_eq!(result_1, result_2);
}
@@ -342,26 +172,19 @@ fn control_before_condition() {
*x = rng.gen::<i32>() / 100;
}
- let result_1 = interp_module!(module, dyn_consts, vec.clone());
+ let result_1 = interp_module!(module, 0, dyn_consts, vec.clone());
println!("result: {:?}", result_1);
-
- let mut pm = hercules_opt::pass::PassManager::new(module.clone());
-
- let passes = vec![
- Pass::Verify,
- Pass::Forkify,
- Pass::DCE,
- Pass::Verify,
- ];
-
- for pass in passes {
- pm.add_pass(pass);
- }
- pm.run_passes();
-
- let module = pm.get_module();
- let result_2 = interp_module!(module, dyn_consts, vec);
+
+ let sched: Option<ScheduleStmt> = Some(default_schedule![
+ Verify,
+ Forkify,
+ DCE,
+ Verify,
+ ]);
+
+ let module = run_schedule_on_hercules(module, sched).unwrap();
+ let result_2 = interp_module!(module, 0, dyn_consts, vec);
assert_eq!(result_1, result_2);
}
@@ -372,46 +195,30 @@ fn nested_tid_sum() {
let len = 5;
let dyn_consts = [5, 6];
let params = vec![1, 2, 3, 4, 5]; // TODO: (@xrouth) fix macro to take no params as an option.
- let result_1 = interp_module!(module, dyn_consts, 2);
+ let result_1 = interp_module!(module, 0, dyn_consts, 2);
println!("result: {:?}", result_1);
- let mut pm = hercules_opt::pass::PassManager::new(module.clone());
-
- let passes = vec![
- // Pass::Xdot(true),
- Pass::Verify,
- Pass::Forkify,
- Pass::DCE,
- Pass::Verify,
- ];
-
- for pass in passes {
- pm.add_pass(pass);
- }
- pm.run_passes();
-
- let module = pm.get_module();
- let result_2 = interp_module!(module, dyn_consts, 2);
+ let sched: Option<ScheduleStmt> = Some(default_schedule![
+ Verify,
+ Forkify,
+ DCE,
+ Verify,
+ ]);
+
+ let module = run_schedule_on_hercules(module, sched).unwrap();
+ let result_2 = interp_module!(module, 0, dyn_consts, 2);
assert_eq!(result_1, result_2);
- let mut pm = hercules_opt::pass::PassManager::new(module.clone());
-
- let passes = vec![
- Pass::Verify,
- Pass::Forkify,
- Pass::DCE,
- Pass::Verify,
- // Pass::Xdot(true),
- ];
-
- for pass in passes {
- pm.add_pass(pass);
- }
- pm.run_passes();
+ let sched: Option<ScheduleStmt> = Some(default_schedule![
+ Verify,
+ Forkify,
+ DCE,
+ Verify,
+ ]);
- let module = pm.get_module();
- let result_3 = interp_module!(module, dyn_consts, 2);
+ let module = run_schedule_on_hercules(module, sched).unwrap();
+ let result_3 = interp_module!(module, 0, dyn_consts, 2);
println!("{:?}, {:?}, {:?}", result_1, result_2, result_3);
}
@@ -422,46 +229,30 @@ fn nested_tid_sum_2() {
let len = 5;
let dyn_consts = [5, 6];
let params = vec![1, 2, 3, 4, 5]; // TODO: (@xrouth) fix macro to take no params as an option.
- let result_1 = interp_module!(module, dyn_consts, 2);
+ let result_1 = interp_module!(module, 0, dyn_consts, 2);
println!("result: {:?}", result_1);
- let mut pm = hercules_opt::pass::PassManager::new(module.clone());
-
- let passes = vec![
- // Pass::Xdot(true),
- Pass::Verify,
- Pass::Forkify,
- Pass::DCE,
- Pass::Verify,
- ];
-
- for pass in passes {
- pm.add_pass(pass);
- }
- pm.run_passes();
-
- let module = pm.get_module();
- let result_2 = interp_module!(module, dyn_consts, 2);
+ let sched: Option<ScheduleStmt> = Some(default_schedule![
+ Verify,
+ Forkify,
+ DCE,
+ Verify,
+ ]);
+
+ let module = run_schedule_on_hercules(module, sched).unwrap();
+ let result_2 = interp_module!(module, 0, dyn_consts, 2);
assert_eq!(result_1, result_2);
- let mut pm = hercules_opt::pass::PassManager::new(module.clone());
-
- let passes = vec![
- Pass::Verify,
- Pass::Forkify,
- Pass::DCE,
- Pass::Verify,
- // Pass::Xdot(true),
- ];
-
- for pass in passes {
- pm.add_pass(pass);
- }
- pm.run_passes();
+ let sched: Option<ScheduleStmt> = Some(default_schedule![
+ Verify,
+ Forkify,
+ DCE,
+ Verify,
+ ]);
- let module = pm.get_module();
- let result_3 = interp_module!(module, dyn_consts, 2);
+ let module = run_schedule_on_hercules(module, sched).unwrap();
+ let result_3 = interp_module!(module, 0, dyn_consts, 2);
println!("{:?}, {:?}, {:?}", result_1, result_2, result_3);
}
@@ -473,26 +264,19 @@ fn inner_fork_complex() {
let module = parse_file("../test_inputs/forkify/inner_fork_complex.hir");
let dyn_consts = [5, 6];
let params = vec![1, 2, 3, 4, 5]; // TODO: (@xrouth) fix macro to take no params as an option.
- let result_1 = interp_module!(module, dyn_consts, 10);
+ let result_1 = interp_module!(module, 0, dyn_consts, 10);
println!("result: {:?}", result_1);
- let mut pm = hercules_opt::pass::PassManager::new(module.clone());
-
- let passes = vec![
- Pass::Verify,
- Pass::Forkify,
- Pass::DCE,
- Pass::Verify,
- ];
-
- for pass in passes {
- pm.add_pass(pass);
- }
- pm.run_passes();
-
- let module = pm.get_module();
- let result_2 = interp_module!(module, dyn_consts, 10);
+ let sched: Option<ScheduleStmt> = Some(default_schedule![
+ Verify,
+ Forkify,
+ DCE,
+ Verify,
+ ]);
+
+ let module = run_schedule_on_hercules(module, sched).unwrap();
+ let result_2 = interp_module!(module, 0, dyn_consts, 10);
assert_eq!(result_1, result_2);
println!("{:?}, {:?}", result_1, result_2);
}
\ No newline at end of file
diff --git a/hercules_test/hercules_tests/tests/interpreter_tests.rs b/hercules_test/hercules_tests/tests/interpreter_tests.rs
index 51c900e4..5f04d398 100644
--- a/hercules_test/hercules_tests/tests/interpreter_tests.rs
+++ b/hercules_test/hercules_tests/tests/interpreter_tests.rs
@@ -1,19 +1,23 @@
use std::env;
use hercules_interpreter::*;
-use hercules_opt::pass::Pass;
+use hercules_interpreter::*;
use hercules_ir::ID;
+use juno_scheduler::ir::*;
+use juno_scheduler::pass;
extern crate rand;
+use juno_scheduler::{default_schedule, run_schedule_on_hercules};
use rand::Rng;
+
#[test]
fn twodeefork() {
let module = parse_file("../test_inputs/2d_fork.hir");
let d1 = 2;
let d2 = 3;
let dyn_consts = [d1, d2];
- let result_1 = interp_module!(module, dyn_consts, 2);
+ let result_1 = interp_module!(module, 0, dyn_consts, 2);
let res = (d1 as i32 * d2 as i32);
let result_2: InterpreterWrapper = res.into();
println!("result: {:?}", result_1); // Should be d1 * d2.
@@ -23,6 +27,6 @@ fn twodeefork() {
fn fivedeefork() {
let module = parse_file("../test_inputs/5d_fork.hir");
let dyn_consts = [1, 2, 3, 4, 5];
- let result_1 = interp_module!(module, dyn_consts, 2);
+ let result_1 = interp_module!(module, 0, dyn_consts, 2);
println!("result: {:?}", result_1); // Should be 1 * 2 * 3 * 4 * 5;
}
diff --git a/hercules_test/hercules_tests/tests/loop_tests.rs b/hercules_test/hercules_tests/tests/loop_tests.rs
index afc4deca..f1d0ad50 100644
--- a/hercules_test/hercules_tests/tests/loop_tests.rs
+++ b/hercules_test/hercules_tests/tests/loop_tests.rs
@@ -1,11 +1,12 @@
use std::{env, fs::File, io::Read, path::Path};
use hercules_interpreter::*;
-use hercules_opt::pass::Pass;
use hercules_ir::ID;
-
+use juno_scheduler::ir::*;
+use juno_scheduler::pass;
extern crate rand;
+use juno_scheduler::{default_schedule, run_schedule_on_hercules};
use rand::Rng;
// Tests canonicalization
@@ -16,7 +17,7 @@ fn loop_trip_count() {
let module = parse_file("../test_inputs/loop_analysis/loop_trip_count.hir");
let dyn_consts = [10];
let params = 2; // TODO: (@xrouth) fix macro to take no params as an option.
- let result_1 = interp_module!(module, dyn_consts, 2);
+ let result_1 = interp_module!(module, 0,dyn_consts, 2);
println!("result: {:?}", result_1);
}
@@ -29,34 +30,13 @@ fn alternate_bounds_use_after_loop_no_tid() {
let dyn_consts = [len];
let module = parse_file("../test_inputs/loop_analysis/alternate_bounds_use_after_loop_no_tid.hir");
- let result_1 = interp_module!(module, dyn_consts, 3);
+ let result_1 = interp_module!(module, 0,dyn_consts, 3);
println!("result: {:?}", result_1);
- let mut pm = hercules_opt::pass::PassManager::new(module.clone());
-
- let passes = vec![
- Pass::Verify,
- ////Pass::Xdot(True),
- Pass::CCP,
- Pass::DCE,
- Pass::GVN,
- Pass::Xdot(true),
- Pass::LoopCanonicalization,
- Pass::DCE,
- Pass::Xdot(true),
- // Pass::LoopCanonicalization,
- ////Pass::Xdot(True),
- Pass::Verify,
- ];
-
- for pass in passes {
- pm.add_pass(pass);
- }
- pm.run_passes();
-
- let module = pm.get_module();
- let result_2 = interp_module!(module, dyn_consts, 3);
+ let module = run_schedule_on_hercules(module, None).unwrap();
+
+ let result_2 = interp_module!(module, 0,dyn_consts, 3);
println!("{:?}", result_1);
println!("{:?}", result_2);
@@ -71,31 +51,13 @@ fn alternate_bounds_use_after_loop() {
let a = vec![3, 4, 5, 6, 7];
let module = parse_file("../test_inputs/loop_analysis/alternate_bounds_use_after_loop.hir");
- let result_1 = interp_module!(module, dyn_consts, a.clone());
+ let result_1 = interp_module!(module, 0,dyn_consts, a.clone());
println!("result: {:?}", result_1);
- let mut pm = hercules_opt::pass::PassManager::new(module.clone());
-
- let passes = vec![
- Pass::Verify,
- Pass::CCP,
- Pass::DCE,
- Pass::GVN,
- Pass::Xdot(true),
- Pass::LoopCanonicalization,
- Pass::DCE,
- Pass::Xdot(true),
- Pass::Verify,
- ];
+ let module = run_schedule_on_hercules(module, None).unwrap();
- for pass in passes {
- pm.add_pass(pass);
- }
- pm.run_passes();
-
- let module = pm.get_module();
- let result_2 = interp_module!(module, dyn_consts, a.clone());
+ let result_2 = interp_module!(module, 0,dyn_consts, a.clone());
//println!("{:?}", result_1);
println!("{:?}", result_2);
@@ -108,29 +70,13 @@ fn alternate_bounds_internal_control() {
let dyn_consts = [len];
let module = parse_file("../test_inputs/loop_analysis/alternate_bounds_internal_control.hir");
- let result_1 = interp_module!(module, dyn_consts, 3);
+ let result_1 = interp_module!(module, 0,dyn_consts, 3);
println!("result: {:?}", result_1);
- let mut pm = hercules_opt::pass::PassManager::new(module.clone());
-
- let passes = vec![
- Pass::Verify,
- Pass::Xdot(true),
- Pass::LoopCanonicalization,
- Pass::Xdot(true),
- Pass::DCE,
- Pass::Verify,
- ];
-
- for pass in passes {
- pm.add_pass(pass);
- }
-
- pm.run_passes();
+ let module = run_schedule_on_hercules(module, None).unwrap();
- let module = pm.get_module();
- let result_2 = interp_module!(module, dyn_consts, 3);
+ let result_2 = interp_module!(module, 0,dyn_consts, 3);
println!("{:?}", result_1);
println!("{:?}", result_2);
@@ -143,29 +89,13 @@ fn alternate_bounds_internal_control2() {
let dyn_consts = [len];
let module = parse_file("../test_inputs/loop_analysis/alternate_bounds_internal_control2.hir");
- let result_1 = interp_module!(module, dyn_consts, 3);
+ let result_1 = interp_module!(module, 0,dyn_consts, 3);
println!("result: {:?}", result_1);
- let mut pm = hercules_opt::pass::PassManager::new(module.clone());
+ let module = run_schedule_on_hercules(module, None).unwrap();
- let passes = vec![
- Pass::Verify,
- Pass::Xdot(true),
- Pass::LoopCanonicalization,
- Pass::Xdot(true),
- Pass::DCE,
- Pass::Verify,
- ];
-
- for pass in passes {
- pm.add_pass(pass);
- }
-
- pm.run_passes();
-
- let module = pm.get_module();
- let result_2 = interp_module!(module, dyn_consts, 3);
+ let result_2 = interp_module!(module, 0,dyn_consts, 3);
println!("{:?}", result_1);
println!("{:?}", result_2);
@@ -178,32 +108,13 @@ fn alternate_bounds_nested_do_loop() {
let dyn_consts = [10, 5];
let module = parse_file("../test_inputs/loop_analysis/alternate_bounds_nested_do_loop.hir");
- let result_1 = interp_module!(module, dyn_consts, 3);
+ let result_1 = interp_module!(module, 0,dyn_consts, 3);
println!("result: {:?}", result_1);
- let mut pm = hercules_opt::pass::PassManager::new(module.clone());
-
- let passes = vec![
- Pass::Verify,
- Pass::DCE,
- Pass::GVN,
- Pass::Xdot(true),
- Pass::LoopCanonicalization,
- Pass::DCE,
- Pass::Xdot(true),
-
- Pass::Verify,
- ];
-
- for pass in passes {
- pm.add_pass(pass);
- }
+ let module = run_schedule_on_hercules(module, None).unwrap();
- pm.run_passes();
-
- let module = pm.get_module();
- let result_2 = interp_module!(module, dyn_consts, 3);
+ let result_2 = interp_module!(module, 0,dyn_consts, 3);
println!("{:?}", result_1);
println!("{:?}", result_2);
@@ -217,29 +128,13 @@ fn alternate_bounds_nested_do_loop_array() {
let a = vec![4u64, 4, 4, 4, 4];
let module = parse_file("../test_inputs/loop_analysis/alternate_bounds_nested_do_loop_array.hir");
- let result_1 = interp_module!(module, dyn_consts, a.clone());
+ let result_1 = interp_module!(module, 0,dyn_consts, a.clone());
println!("result: {:?}", result_1);
- let mut pm = hercules_opt::pass::PassManager::new(module.clone());
-
- let passes = vec![
- Pass::Verify,
- Pass::Xdot(true),
- Pass::LoopCanonicalization,
- Pass::Xdot(true),
- Pass::DCE,
- Pass::Verify,
- ];
-
- for pass in passes {
- pm.add_pass(pass);
- }
-
- pm.run_passes();
+ let module = run_schedule_on_hercules(module, None).unwrap();
- let module = pm.get_module();
- let result_2 = interp_module!(module, dyn_consts, a);
+ let result_2 = interp_module!(module, 0,dyn_consts, a);
println!("{:?}", result_1);
println!("{:?}", result_2);
@@ -252,52 +147,23 @@ fn alternate_bounds_nested_do_loop_guarded() {
let dyn_consts = [3, 2];
let module = parse_file("../test_inputs/loop_analysis/alternate_bounds_nested_do_loop_guarded.hir");
- let result_1 = interp_module!(module, dyn_consts, 3);
+ let result_1 = interp_module!(module, 0,dyn_consts, 3);
println!("result: {:?}", result_1);
- let mut pm = hercules_opt::pass::PassManager::new(module.clone());
+ let module = run_schedule_on_hercules(module, None).unwrap();
- let passes = vec![
- Pass::Verify,
- Pass::Xdot(true),
- Pass::LoopCanonicalization,
- Pass::DCE,
- //Pass::Xdot(True),
- Pass::Verify,
- ];
-
- for pass in passes {
- pm.add_pass(pass);
- }
-
- pm.run_passes();
-
- let module = pm.get_module();
- let result_2 = interp_module!(module, dyn_consts, 3);
+ let result_2 = interp_module!(module, 0,dyn_consts, 3);
println!("{:?}", result_1);
println!("{:?}", result_2);
assert_eq!(result_1, result_2);
- let mut pm = hercules_opt::pass::PassManager::new(module.clone());
-
- let passes = vec![
- Pass::Verify,
- Pass::LoopCanonicalization,
- //Pass::Xdot(True),
- Pass::DCE,
- Pass::Verify,
- ];
+ let mut pm = PassManager::new(module.clone());
- for pass in passes {
- pm.add_pass(pass);
- }
+ let module = run_schedule_on_hercules(module, None).unwrap();
- pm.run_passes();
-
- let module = pm.get_module();
- let result_2 = interp_module!(module, dyn_consts, 3);
+ let result_2 = interp_module!(module, 0,dyn_consts, 3);
println!("{:?}", result_1);
println!("{:?}", result_2);
@@ -315,7 +181,7 @@ fn do_loop_not_continued() {
// let params = vec![1, 2, 3, 4, 5];
// let module = parse_file("../test_inputs/loop_analysis/alternate_bounds_use_after_loop.hir");
- // let result_1 = interp_module!(module, dyn_consts, params);
+ // let result_1 = interp_module!(module, 0,dyn_consts, params);
// println!("result: {:?}", result_1);
}
@@ -328,41 +194,13 @@ fn do_loop_complex_immediate_guarded() {
let dyn_consts = [len];
let module = parse_file("../test_inputs/loop_analysis/do_loop_immediate_guard.hir");
- let result_1 = interp_module!(module, dyn_consts, 3);
-
+ let result_1 = interp_module!(module, 0,dyn_consts, 3);
println!("result: {:?}", result_1);
- let mut pm = hercules_opt::pass::PassManager::new(module.clone());
-
- let passes = vec![
- Pass::Verify,
- Pass::CCP,
- Pass::DCE,
- Pass::GVN,
- //Pass::Xdot(True),
- Pass::LoopCanonicalization,
- //Pass::Xdot(True),
- Pass::Forkify,
- Pass::ForkGuardElim,
- Pass::Forkify,
- Pass::ForkGuardElim,
- Pass::Forkify,
- Pass::ForkGuardElim,
- //Pass::Xdot(True),
- Pass::Verify,
- Pass::LoopCanonicalization,
- //Pass::Xdot(True),
- Pass::Verify,
- ];
+ let module = run_schedule_on_hercules(module, None).unwrap();
- for pass in passes {
- pm.add_pass(pass);
- }
- pm.run_passes();
-
- let module = pm.get_module();
- let result_2 = interp_module!(module, dyn_consts, 3);
+ let result_2 = interp_module!(module, 0,dyn_consts, 3);
assert_eq!(result_1, result_2);
}
@@ -374,7 +212,7 @@ fn loop_canonical_sum() {
let params = vec![1, 2, 3, 4, 5];
let module = parse_file("../test_inputs/loop_analysis/loop_array_sum.hir");
- let result_1 = interp_module!(module, dyn_consts, params);
+ let result_1 = interp_module!(module, 0,dyn_consts, params);
println!("result: {:?}", result_1);
}
@@ -387,28 +225,54 @@ fn antideps_pipeline() {
// FIXME: This path should not leave the crate
let module = parse_module_from_hbin("../../juno_samples/antideps/antideps.hbin");
- let result_1 = interp_module!(module, dyn_consts, 9i32);
+ let result_1 = interp_module!(module, 0,dyn_consts, 9i32);
println!("result: {:?}", result_1);
- let mut pm = hercules_opt::pass::PassManager::new(module.clone());
+ let module = run_schedule_on_hercules(module, None).unwrap();
- let passes = vec![
- Pass::Verify,
- Pass::Xdot(true),
- Pass::LoopCanonicalization,
- Pass::Xdot(true),
- Pass::Verify,
- ];
+ let result_2 = interp_module!(module, 0,dyn_consts, 9i32);
+ assert_eq!(result_1, result_2);
+}
- for pass in passes {
- pm.add_pass(pass);
- }
- pm.run_passes();
+#[test]
+fn implicit_clone_pipeline() {
+ let len = 1;
+ let dyn_consts = [2, 2, 2];
+ // FIXME: This path should not leave the crate
+ let module = parse_module_from_hbin("../../juno_samples/implicit_clone/out.hbin");
+ let result_1 = interp_module!(module, 0,dyn_consts, 2u64, 2u64);
- let module = pm.get_module();
- let result_2 = interp_module!(module, dyn_consts, 9i32);
+ println!("result: {:?}", result_1);
+ let schedule = default_schedule![
+ Xdot,
+ LoopCanonicalization,
+ Forkify,
+ ForkGuardElim,
+ Forkify,
+ ForkGuardElim,
+ Forkify,
+ ForkGuardElim,
+ DCE,
+ ForkSplit,
+ Unforkify,
+ GVN,
+ DCE,
+ DCE,
+ AutoOutline,
+ InterproceduralSROA,
+ SROA,
+ InferSchedules,
+ DCE,
+ GCM,
+ DCE,
+ FloatCollections,
+ GCM,
+ ];
+ let module = run_schedule_on_hercules(module, Some(schedule)).unwrap();
+
+ let result_2 = interp_module!(module, 0,dyn_consts, 2u64, 2u64);
assert_eq!(result_1, result_2);
}
@@ -421,201 +285,39 @@ fn matmul_pipeline() {
// FIXME: This path should not leave the crate
let module = parse_module_from_hbin("../../juno_samples/matmul/matmul.hbin");
- let result_1 = interp_module!(module, dyn_consts, m1.clone(), m2.clone());
+ let result_1 = interp_module!(module, 0,dyn_consts, m1.clone(), m2.clone());
println!("result: {:?}", result_1);
- let mut pm = hercules_opt::pass::PassManager::new(module.clone());
-
- let passes = vec![
- Pass::Verify,
- Pass::LoopCanonicalization,
- Pass::Xdot(true),
- Pass::Forkify,
- Pass::Xdot(true),
- Pass::ForkGuardElim,
- Pass::Xdot(true),
- Pass::Forkify,
- Pass::ForkGuardElim,
- Pass::Forkify,
- Pass::ForkGuardElim,
- Pass::Xdot(true),
- Pass::Verify,
- ];
+ let module = run_schedule_on_hercules(module, None).unwrap();
- for pass in passes {
- pm.add_pass(pass);
- }
- pm.run_passes();
-
-
- let module = pm.get_module();
- let result_2 = interp_module!(module, dyn_consts, m1.clone(), m2.clone());
+ let result_2 = interp_module!(module, 0,dyn_consts, m1.clone(), m2.clone());
assert_eq!(result_1, result_2);
// 1st (innermost) Loop Canonicalization
- let mut pm = hercules_opt::pass::PassManager::new(module.clone());
-
- let passes = vec![
- ////Pass::Xdot(True),
- Pass::LoopCanonicalization,
- //Pass::Xdot(True),
- Pass::Verify,
- ];
+ let module = run_schedule_on_hercules(module, None).unwrap();
- for pass in passes {
- pm.add_pass(pass);
- }
- pm.run_passes();
-
- let module = pm.get_module();
- let result_2 = interp_module!(module, dyn_consts, m1.clone(), m2.clone());
+ let result_2 = interp_module!(module, 0,dyn_consts, m1.clone(), m2.clone());
assert_eq!(result_1, result_2);
// -------------------
- let mut pm = hercules_opt::pass::PassManager::new(module.clone());
-
- let passes = vec![
- Pass::Forkify,
- Pass::DCE,
- //Pass::Xdot(True),
- Pass::Verify,
- Pass::ForkGuardElim,
- Pass::Forkify,
- Pass::ForkGuardElim,
- Pass::Forkify,
- Pass::DCE,
- //Pass::Xdot(True),
- Pass::Verify,
- ];
+ let module = run_schedule_on_hercules(module, None).unwrap();
- for pass in passes {
- pm.add_pass(pass);
- }
- pm.run_passes();
-
- let module = pm.get_module();
- let result_2 = interp_module!(module, dyn_consts, m1.clone(), m2.clone());
+ let result_2 = interp_module!(module, 0,dyn_consts, m1.clone(), m2.clone());
assert_eq!(result_1, result_2);
// -------
- let mut pm = hercules_opt::pass::PassManager::new(module.clone());
-
- let passes = vec![
- Pass::ForkGuardElim,
- Pass::DCE,
- Pass::Verify,
- ];
+ let module = run_schedule_on_hercules(module, None).unwrap();
- for pass in passes {
- pm.add_pass(pass);
- }
- pm.run_passes();
-
- let module = pm.get_module();
- let result_2 = interp_module!(module, dyn_consts, m1.clone(), m2.clone());
+ let result_2 = interp_module!(module, 0,dyn_consts, m1.clone(), m2.clone());
assert_eq!(result_1, result_2);
println!("before failture: {:?}", result_2);
// ========================
// -----
- let mut pm = hercules_opt::pass::PassManager::new(module.clone());
-
- let passes = vec![
- Pass::LoopCanonicalization,
- Pass::Verify,
- ];
-
- for pass in passes {
- pm.add_pass(pass);
- }
- pm.run_passes();
-
-
- let module = pm.get_module();
- let result_2 = interp_module!(module, dyn_consts, m1.clone(), m2.clone());
- assert_eq!(result_1, result_2);
-
- // -------------------
- let mut pm = hercules_opt::pass::PassManager::new(module.clone());
-
- let passes = vec![
- Pass::Forkify,
- Pass::DCE,
- Pass::Verify,
- ];
-
- for pass in passes {
- pm.add_pass(pass);
- }
- pm.run_passes();
-
- let module = pm.get_module();
- let result_2 = interp_module!(module, dyn_consts, m1.clone(), m2.clone());
- println!("2d: {:?}", result_2);
-
- assert_eq!(result_1, result_2);
-
- // -------
- let mut pm = hercules_opt::pass::PassManager::new(module.clone());
-
- let passes = vec![
- Pass::ForkGuardElim,
- Pass::DCE,
- Pass::Verify,
- Pass::LoopCanonicalization,
- Pass::Forkify,
- Pass::DCE,
- ////Pass::Xdot(True),
- ];
-
- for pass in passes {
- pm.add_pass(pass);
- }
- pm.run_passes();
-
- let module = pm.get_module();
- let result_2 = interp_module!(module, dyn_consts, m1.clone(), m2.clone());
-
- assert_eq!(result_1, result_2);
-
- // -------
- let mut pm = hercules_opt::pass::PassManager::new(module.clone());
-
- let passes = vec![
- Pass::ForkCoalesce,
- Pass::DCE,
- // ////Pass::Xdot(True),
- ];
-
- for pass in passes {
- pm.add_pass(pass);
- }
- pm.run_passes();
-
- let module = pm.get_module();
- let result_2 = interp_module!(module, dyn_consts, m1.clone(), m2.clone());
- assert_eq!(result_1, result_2);
-
- // -------
- let mut pm = hercules_opt::pass::PassManager::new(module.clone());
-
- let passes = vec![
- Pass::ForkCoalesce,
- Pass::DCE,
- Pass::ForkGuardElim,
- Pass::DCE,
- Pass::Xdot(true),
- Pass::Verify,
- ];
-
- for pass in passes {
- pm.add_pass(pass);
- }
- pm.run_passes();
+ let module = run_schedule_on_hercules(module, None).unwrap();
- let module = pm.get_module();
- let result_2 = interp_module!(module, dyn_consts, m1.clone(), m2.clone());
+ let result_2 = interp_module!(module, 0,dyn_consts, m1.clone(), m2.clone());
assert_eq!(result_1, result_2);
println!("final: {:?}", result_2);
diff --git a/hercules_test/hercules_tests/tests/opt_tests.rs b/hercules_test/hercules_tests/tests/opt_tests.rs
index b060c253..f994f447 100644
--- a/hercules_test/hercules_tests/tests/opt_tests.rs
+++ b/hercules_test/hercules_tests/tests/opt_tests.rs
@@ -3,206 +3,207 @@ use std::env;
use rand::Rng;
use hercules_interpreter::*;
-use hercules_opt::pass::Pass;
+use juno_scheduler::*;
use hercules_ir::ID;
-#[test]
-fn matmul_int() {
- let module = parse_file("../test_inputs/matmul_int.hir");
- let dyn_consts = [2, 2, 2];
- let m1 = vec![3, 4, 5, 6];
- let m2 = vec![7, 8, 9, 10];
- let result_1 = interp_module!(module, dyn_consts, m1.clone(), m2.clone());
-
- let mut pm = hercules_opt::pass::PassManager::new(module.clone());
-
- let passes = vec![
- // Pass::Verify,
- // Pass::CCP,
- // Pass::DCE,
- // Pass::GVN,
- // Pass::DCE,
- // Pass::Forkify,
- // Pass::DCE,
- // Pass::Predication,
- // Pass::DCE,
- ];
-
- for pass in passes {
- pm.add_pass(pass);
- }
- pm.run_passes();
-
- let module = pm.get_module();
- let result_2 = interp_module!(module, dyn_consts, m1, m2);
- // println!("result: {:?}", result_1);
- assert_eq!(result_1, result_2)
-}
-
-#[test]
-fn ccp_example() {
- let module = parse_file("../test_inputs/ccp_example.hir");
- let dyn_consts = [];
- let x = 34;
- let result_1 = interp_module!(module, dyn_consts, x);
-
- let mut pm = hercules_opt::pass::PassManager::new(module.clone());
-
- let passes = vec![
- Pass::Verify,
- Pass::CCP,
- Pass::DCE,
- Pass::GVN,
- Pass::DCE,
- Pass::Forkify,
- Pass::DCE,
- Pass::Predication,
- Pass::DCE,
- ];
-
- for pass in passes {
- pm.add_pass(pass);
- }
- pm.run_passes();
-
- let module = pm.get_module();
- let result_2 = interp_module!(module, dyn_consts, x);
- assert_eq!(result_1, result_2)
-}
-
-#[test]
-fn gvn_example() {
- let module = parse_file("../test_inputs/gvn_example.hir");
-
- let dyn_consts = [];
- let x: i32 = rand::random();
- let x = x / 32;
- let y: i32 = rand::random();
- let y = y / 32; // prevent overflow,
- let result_1 = interp_module!(module, dyn_consts, x, y);
-
- let mut pm = hercules_opt::pass::PassManager::new(module.clone());
-
- let passes = vec![
- Pass::Verify,
- Pass::CCP,
- Pass::DCE,
- Pass::GVN,
- Pass::DCE,
- Pass::Forkify,
- Pass::DCE,
- Pass::Predication,
- Pass::DCE,
- ];
-
- for pass in passes {
- pm.add_pass(pass);
- }
- pm.run_passes();
-
- let module = pm.get_module();
- let result_2 = interp_module!(module, dyn_consts, x, y);
- assert_eq!(result_1, result_2)
-}
-
-#[test]
-fn sum_int() {
- let module = parse_file("../test_inputs/sum_int1.hir");
-
- let size = 2;
- let dyn_consts = [size];
- let mut vec = vec![0; size];
- let mut rng = rand::thread_rng();
-
- for x in vec.iter_mut() {
- *x = rng.gen::<i32>() / 100;
- }
-
- println!("{:?}", vec);
-
- let result_1 = interp_module!(module, dyn_consts, vec.clone());
-
- println!("{:?}", result_1);
-
- let mut pm = hercules_opt::pass::PassManager::new(module.clone());
-
- let passes = vec![
- Pass::Verify,
- Pass::CCP,
- Pass::DCE,
- Pass::GVN,
- Pass::DCE,
- Pass::Forkify,
- Pass::DCE,
- Pass::Predication,
- Pass::DCE,
- ];
-
- for pass in passes {
- pm.add_pass(pass);
- }
- pm.run_passes();
-
- let module = pm.get_module();
- let result_2 = interp_module!(module, dyn_consts, vec);
+
+// #[test]
+// fn matmul_int() {
+// let module = parse_file("../test_inputs/matmul_int.hir");
+// let dyn_consts = [2, 2, 2];
+// let m1 = vec![3, 4, 5, 6];
+// let m2 = vec![7, 8, 9, 10];
+// let result_1 = interp_module!(module, 0, dyn_consts, m1.clone(), m2.clone());
+
+// let mut pm = hercules_opt::pass::PassManager::new(module.clone());
+
+// let passes = vec![
+// // Pass::Verify,
+// // Pass::CCP,
+// // Pass::DCE,
+// // Pass::GVN,
+// // Pass::DCE,
+// // Pass::Forkify,
+// // Pass::DCE,
+// // Pass::Predication,
+// // Pass::DCE,
+// ];
+
+// for pass in passes {
+// pm.add_pass(pass);
+// }
+// pm.run_passes();
+
+// let module = pm.get_module();
+// let result_2 = interp_module!(module, 0, dyn_consts, m1, m2);
+// // println!("result: {:?}", result_1);
+// assert_eq!(result_1, result_2)
+// }
+
+// #[test]
+// fn ccp_example() {
+// let module = parse_file("../test_inputs/ccp_example.hir");
+// let dyn_consts = [];
+// let x = 34;
+// let result_1 = interp_module!(module, 0, dyn_consts, x);
+
+// let mut pm = hercules_opt::pass::PassManager::new(module.clone());
+
+// let passes = vec![
+// Pass::Verify,
+// Pass::CCP,
+// Pass::DCE,
+// Pass::GVN,
+// Pass::DCE,
+// Pass::Forkify,
+// Pass::DCE,
+// Pass::Predication,
+// Pass::DCE,
+// ];
+
+// for pass in passes {
+// pm.add_pass(pass);
+// }
+// pm.run_passes();
+
+// let module = pm.get_module();
+// let result_2 = interp_module!(module, 0, dyn_consts, x);
+// assert_eq!(result_1, result_2)
+// }
+
+// #[test]
+// fn gvn_example() {
+// let module = parse_file("../test_inputs/gvn_example.hir");
+
+// let dyn_consts = [];
+// let x: i32 = rand::random();
+// let x = x / 32;
+// let y: i32 = rand::random();
+// let y = y / 32; // prevent overflow,
+// let result_1 = interp_module!(module, 0, dyn_consts, x, y);
+
+// let mut pm = hercules_opt::pass::PassManager::new(module.clone());
+
+// let passes = vec![
+// Pass::Verify,
+// Pass::CCP,
+// Pass::DCE,
+// Pass::GVN,
+// Pass::DCE,
+// Pass::Forkify,
+// Pass::DCE,
+// Pass::Predication,
+// Pass::DCE,
+// ];
+
+// for pass in passes {
+// pm.add_pass(pass);
+// }
+// pm.run_passes();
+
+// let module = pm.get_module();
+// let result_2 = interp_module!(module, 0, dyn_consts, x, y);
+// assert_eq!(result_1, result_2)
+// }
+
+// #[test]
+// fn sum_int() {
+// let module = parse_file("../test_inputs/sum_int1.hir");
+
+// let size = 2;
+// let dyn_consts = [size];
+// let mut vec = vec![0; size];
+// let mut rng = rand::thread_rng();
+
+// for x in vec.iter_mut() {
+// *x = rng.gen::<i32>() / 100;
+// }
+
+// println!("{:?}", vec);
+
+// let result_1 = interp_module!(module, 0, dyn_consts, vec.clone());
+
+// println!("{:?}", result_1);
+
+// let mut pm = hercules_opt::pass::PassManager::new(module.clone());
+
+// let passes = vec![
+// Pass::Verify,
+// Pass::CCP,
+// Pass::DCE,
+// Pass::GVN,
+// Pass::DCE,
+// Pass::Forkify,
+// Pass::DCE,
+// Pass::Predication,
+// Pass::DCE,
+// ];
+
+// for pass in passes {
+// pm.add_pass(pass);
+// }
+// pm.run_passes();
+
+// let module = pm.get_module();
+// let result_2 = interp_module!(module, 0, dyn_consts, vec);
- assert_eq!(result_1, result_2)
-}
-
-#[test]
-fn sum_int2() {
- let module = parse_file("../test_inputs/sum_int2.hir");
-
- let size = 10;
- let dyn_consts = [size];
- let mut vec = vec![0; size];
- let mut rng = rand::thread_rng();
-
- for x in vec.iter_mut() {
- *x = rng.gen::<i32>() / 100;
- }
-
- let result_1 = interp_module!(module, dyn_consts, vec.clone());
-
- let mut pm = hercules_opt::pass::PassManager::new(module.clone());
-
- let passes = vec![
- Pass::Verify,
- Pass::CCP,
- Pass::DCE,
- Pass::GVN,
- Pass::DCE,
- Pass::Forkify,
- Pass::DCE,
- Pass::Predication,
- Pass::DCE,
- ];
-
- for pass in passes {
- pm.add_pass(pass);
- }
- pm.run_passes();
-
- let module = pm.get_module();
- let result_2 = interp_module!(module, dyn_consts, vec);
- assert_eq!(result_1, result_2)
-}
-
-#[test]
-fn sum_int2_smaller() {
- interp_file_with_passes!("../test_inputs/sum_int2.hir",
- [100],
- vec![
- Pass::Verify,
- Pass::CCP,
- Pass::DCE,
- Pass::GVN,
- Pass::DCE,
- Pass::Forkify,
- Pass::DCE,
- Pass::Predication,
- Pass::DCE,
- ],
- vec![1; 100]);
-}
+// assert_eq!(result_1, result_2)
+// }
+
+// #[test]
+// fn sum_int2() {
+// let module = parse_file("../test_inputs/sum_int2.hir");
+
+// let size = 10;
+// let dyn_consts = [size];
+// let mut vec = vec![0; size];
+// let mut rng = rand::thread_rng();
+
+// for x in vec.iter_mut() {
+// *x = rng.gen::<i32>() / 100;
+// }
+
+// let result_1 = interp_module!(module, 0, dyn_consts, vec.clone());
+
+// let mut pm = hercules_opt::pass::PassManager::new(module.clone());
+
+// let passes = vec![
+// Pass::Verify,
+// Pass::CCP,
+// Pass::DCE,
+// Pass::GVN,
+// Pass::DCE,
+// Pass::Forkify,
+// Pass::DCE,
+// Pass::Predication,
+// Pass::DCE,
+// ];
+
+// for pass in passes {
+// pm.add_pass(pass);
+// }
+// pm.run_passes();
+
+// let module = pm.get_module();
+// let result_2 = interp_module!(module, 0, dyn_consts, vec);
+// assert_eq!(result_1, result_2)
+// }
+
+// #[test]
+// fn sum_int2_smaller() {
+// interp_file_with_passes!("../test_inputs/sum_int2.hir",
+// [100],
+// vec![
+// Pass::Verify,
+// Pass::CCP,
+// Pass::DCE,
+// Pass::GVN,
+// Pass::DCE,
+// Pass::Forkify,
+// Pass::DCE,
+// Pass::Predication,
+// Pass::DCE,
+// ],
+// vec![1; 100]);
+// }
diff --git a/juno_samples/implicit_clone/src/implicit_clone.jn b/juno_samples/implicit_clone/src/implicit_clone.jn
index 882e5abc..cdeba9e1 100644
--- a/juno_samples/implicit_clone/src/implicit_clone.jn
+++ b/juno_samples/implicit_clone/src/implicit_clone.jn
@@ -1,43 +1,3 @@
-#[entry]
-fn simple_implicit_clone(input : i32) -> i32 {
- let arr : i32[3];
- arr[0] = 2;
- let arr2 = arr;
- arr2[1] = input;
- arr[2] = 4;
- return arr[0] + arr2[0] + arr[1] + arr2[1] + arr[2] + arr2[2];
-}
-
-#[entry]
-fn loop_implicit_clone(input : i32) -> i32 {
- let arr : i32[3];
- let r : i32 = 5;
- while input > 0 {
- r = arr[0];
- let arr2 = arr;
- let x = arr2[input as usize - input as usize];
- arr2[input as usize - input as usize] = 9;
- if x == 0 {
- input -= arr2[0];
- } else {
- r = 99;
- break;
- }
- }
- return r + 7;
-}
-
-#[entry]
-fn double_loop_implicit_clone(a : usize) -> usize {
- for i = 0 to a {
- let arr : i32[1];
- for j = 0 to a {
- arr[0] = 1;
- }
- }
- return 42;
-}
-
#[entry]
fn tricky_loop_implicit_clone(a : usize, b : usize) -> i32 {
let x = 0;
@@ -59,98 +19,3 @@ fn tricky_loop_implicit_clone(a : usize, b : usize) -> i32 {
}
return x;
}
-
-#[entry]
-fn tricky2_loop_implicit_clone(a : usize, b : usize) -> i32 {
- let x = 0;
- for i = 0 to 3 {
- let arr1 : i32[1];
- let arr2 : i32[1];
- if a == b {
- arr1[0] = 6;
- } else {
- arr2[0] = 9;
- }
- arr1[0] = 2;
- for j = 0 to 4 {
- arr2[0] += 1;
- }
- x += arr2[0];
- }
- return x;
-}
-
-#[entry]
-fn tricky3_loop_implicit_clone(a : usize, b : usize) -> usize {
- let x = 0;
- for i = 0 to b {
- let arr1 : usize[10];
- let arr2 : usize[10];
- arr1[1] = 1;
- for kk = 0 to 10 {
- arr2[kk] += arr1[kk];
- }
- x += arr2[1];
- }
- return x;
-}
-
-#[entry]
-fn no_implicit_clone(input : i32) -> i32 {
- let arr : i32[2];
- arr[0] = input;
- while input > 0 {
- arr[0] += 1;
- input -= 1;
- }
- let arr2 : i32[1];
- if input == 0 {
- arr2[0] = 5;
- } else {
- arr2[0] = 3;
- }
- return arr[0] + arr2[0];
-}
-
-#[entry]
-fn mirage_implicit_clone(input : i32) -> i32 {
- let arr1 : i32[2];
- let arr2 : i32[2];
- let arr3 : i32[2];
- let arr4 : i32[2];
- arr1[0] = 7;
- arr1[1] = 3;
- arr2[0] = input;
- arr2[1] = 45;
- arr3[0] = -14;
- arr3[1] = -5;
- arr4[0] = -1;
- arr4[1] = 0;
- arr2 = arr4;
- arr3 = arr2;
- arr2 = arr1;
- let p1 = arr1[0] + arr1[1] + arr2[0] + arr2[1] + arr3[0] + arr3[1] + arr4[0] + arr4[1]; // 18
- arr4 = arr2;
- let p2 = arr1[0] + arr1[1] + arr2[0] + arr2[1] + arr3[0] + arr3[1] + arr4[0] + arr4[1]; // 29
- if input > 0 {
- while input > 10 {
- arr1[0] = arr1[1] + input;
- arr1[1] = arr1[0] + input;
- input -= 10;
- }
- }
- let p3 = arr1[0]; // 592
- let x : i32 = 0;
- while input < 20 {
- let arr5 : i32[2];
- arr5[0] = 7;
- let y = arr5[0] + arr5[1];
- arr5 = arr4;
- arr5[1] += 2;
- y += arr5[1];
- x += 12;
- input += 1;
- }
- let p4 = x; // 204
- return p1 + p2 + p3 + p4;
-}
diff --git a/juno_samples/implicit_clone/src/main.rs b/juno_samples/implicit_clone/src/main.rs
index bc687ed3..c6d2a352 100644
--- a/juno_samples/implicit_clone/src/main.rs
+++ b/juno_samples/implicit_clone/src/main.rs
@@ -4,37 +4,37 @@ juno_build::juno!("implicit_clone");
fn main() {
async_std::task::block_on(async {
- let output = simple_implicit_clone(3).await;
- println!("{}", output);
- assert_eq!(output, 11);
+ // let output = simple_implicit_clone(3).await;
+ // println!("{}", output);
+ // assert_eq!(output, 11);
- let output = loop_implicit_clone(100).await;
- println!("{}", output);
- assert_eq!(output, 7);
+ // let output = loop_implicit_clone(100).await;
+ // println!("{}", output);
+ // assert_eq!(output, 7);
- let output = double_loop_implicit_clone(3).await;
- println!("{}", output);
- assert_eq!(output, 42);
+ // let output = double_loop_implicit_clone(3).await;
+ // println!("{}", output);
+ // assert_eq!(output, 42);
let output = tricky_loop_implicit_clone(2, 2).await;
println!("{}", output);
assert_eq!(output, 130);
- let output = tricky2_loop_implicit_clone(2, 3).await;
- println!("{}", output);
- assert_eq!(output, 39);
+ // let output = tricky2_loop_implicit_clone(2, 3).await;
+ // println!("{}", output);
+ // assert_eq!(output, 39);
- let output = tricky3_loop_implicit_clone(5, 7).await;
- println!("{}", output);
- assert_eq!(output, 7);
+ // let output = tricky3_loop_implicit_clone(5, 7).await;
+ // println!("{}", output);
+ // assert_eq!(output, 7);
- let output = no_implicit_clone(4).await;
- println!("{}", output);
- assert_eq!(output, 13);
+ // let output = no_implicit_clone(4).await;
+ // println!("{}", output);
+ // assert_eq!(output, 13);
- let output = mirage_implicit_clone(73).await;
- println!("{}", output);
- assert_eq!(output, 843);
+ // let output = mirage_implicit_clone(73).await;
+ // println!("{}", output);
+ // assert_eq!(output, 843);
});
}
diff --git a/juno_samples/matmul/build.rs b/juno_samples/matmul/build.rs
index 33835692..cc57731c 100644
--- a/juno_samples/matmul/build.rs
+++ b/juno_samples/matmul/build.rs
@@ -2,9 +2,10 @@ use juno_build::JunoCompiler;
fn main() {
JunoCompiler::new()
- .x_dot(false)
.file_in_src("matmul.jn")
.unwrap()
+ .schedule_in_src("sched.sch")
+ .unwrap()
.build()
.unwrap();
}
diff --git a/juno_samples/nested_ccp/build.rs b/juno_samples/nested_ccp/build.rs
index dc320096..c5c7ca6a 100644
--- a/juno_samples/nested_ccp/build.rs
+++ b/juno_samples/nested_ccp/build.rs
@@ -2,7 +2,6 @@ use juno_build::JunoCompiler;
fn main() {
JunoCompiler::new()
- .x_dot(false)
.file_in_src("nested_ccp.jn")
.unwrap()
.build()
diff --git a/juno_scheduler/Cargo.toml b/juno_scheduler/Cargo.toml
index 1c837d4a..04ab156c 100644
--- a/juno_scheduler/Cargo.toml
+++ b/juno_scheduler/Cargo.toml
@@ -18,3 +18,5 @@ hercules_cg = { path = "../hercules_cg" }
hercules_ir = { path = "../hercules_ir" }
hercules_opt = { path = "../hercules_opt" }
juno_utils = { path = "../juno_utils" }
+postcard = { version = "*", features = ["alloc"] }
+serde = { version = "*", features = ["derive"] }
\ No newline at end of file
diff --git a/juno_scheduler/src/compile.rs b/juno_scheduler/src/compile.rs
index 5317eb86..04ef662e 100644
--- a/juno_scheduler/src/compile.rs
+++ b/juno_scheduler/src/compile.rs
@@ -105,6 +105,7 @@ impl FromStr for Appliable {
"forkify" => Ok(Appliable::Pass(ir::Pass::Forkify)),
"gcm" | "bbs" => Ok(Appliable::Pass(ir::Pass::GCM)),
"gvn" => Ok(Appliable::Pass(ir::Pass::GVN)),
+ "loop-canon" | "loop-canonicalization" => Ok(Appliable::Pass(ir::Pass::LoopCanonicalization)),
"infer-schedules" => Ok(Appliable::Pass(ir::Pass::InferSchedules)),
"inline" => Ok(Appliable::Pass(ir::Pass::Inline)),
"ip-sroa" | "interprocedural-sroa" => {
@@ -118,6 +119,7 @@ impl FromStr for Appliable {
"unforkify" => Ok(Appliable::Pass(ir::Pass::Unforkify)),
"verify" => Ok(Appliable::Pass(ir::Pass::Verify)),
"xdot" => Ok(Appliable::Pass(ir::Pass::Xdot)),
+ "serialize" => Ok(Appliable::Pass(ir::Pass::Serialize)),
"cpu" | "llvm" => Ok(Appliable::Device(Device::LLVM)),
"gpu" | "cuda" | "nvidia" => Ok(Appliable::Device(Device::CUDA)),
diff --git a/juno_scheduler/src/default.rs b/juno_scheduler/src/default.rs
index 8274b81a..faa576cf 100644
--- a/juno_scheduler/src/default.rs
+++ b/juno_scheduler/src/default.rs
@@ -1,5 +1,6 @@
use crate::ir::*;
+#[macro_export]
macro_rules! pass {
($p:ident) => {
ScheduleStmt::Let {
@@ -13,6 +14,7 @@ macro_rules! pass {
};
}
+#[macro_export]
macro_rules! default_schedule {
() => {
ScheduleStmt::Block {
@@ -60,8 +62,14 @@ pub fn default_schedule() -> ScheduleStmt {
DCE,
GVN,
DCE,
- /*Forkify,*/
- /*ForkGuardElim,*/
+ Serialize,
+ LoopCanonicalization,
+ Forkify,
+ ForkGuardElim,
+ Forkify,
+ ForkGuardElim,
+ Forkify,
+ ForkGuardElim,
DCE,
ForkSplit,
Unforkify,
diff --git a/juno_scheduler/src/ir.rs b/juno_scheduler/src/ir.rs
index 16f2de9b..e7a46510 100644
--- a/juno_scheduler/src/ir.rs
+++ b/juno_scheduler/src/ir.rs
@@ -10,6 +10,7 @@ pub enum Pass {
DCE,
DeleteUncalled,
FloatCollections,
+ LoopCanonicalization,
ForkGuardElim,
ForkSplit,
Forkify,
@@ -27,6 +28,7 @@ pub enum Pass {
WritePredication,
Verify,
Xdot,
+ Serialize,
}
impl Pass {
diff --git a/juno_scheduler/src/lib.rs b/juno_scheduler/src/lib.rs
index 1caafe4f..571d1fbf 100644
--- a/juno_scheduler/src/lib.rs
+++ b/juno_scheduler/src/lib.rs
@@ -14,7 +14,7 @@ use crate::parser::lexer;
mod compile;
mod default;
-mod ir;
+pub mod ir;
pub mod labels;
mod pm;
@@ -22,7 +22,7 @@ use crate::compile::*;
use crate::default::*;
use crate::ir::*;
use crate::labels::*;
-use crate::pm::*;
+pub use crate::pm::*;
// Given a schedule's filename parse and process the schedule
fn build_schedule(sched_filename: String) -> Result<ScheduleStmt, String> {
@@ -107,6 +107,45 @@ pub fn schedule_juno(
.map_err(|e| format!("Scheduling Error: {}", e))
}
+pub fn run_schedule_on_hercules(
+ module: Module,
+ sched: Option<ScheduleStmt>,
+) -> Result<Module, String> {
+ let sched = if let Some(sched) = sched {
+ sched
+ } else {
+ default_schedule()
+ };
+
+ // Prepare the scheduler's string table and environment
+ // For this, we put all of the Hercules function names into the environment
+ // and string table
+ let mut strings = StringTable::new();
+ let mut env = Env::new();
+
+ env.open_scope();
+
+ for (idx, func) in module.functions.iter().enumerate() {
+ let func_name = strings.lookup_string(func.name.clone());
+ env.insert(
+ func_name,
+ Value::HerculesFunction {
+ func: FunctionID::new(idx),
+ },
+ );
+ }
+
+ env.open_scope();
+ schedule_module(
+ module,
+ sched,
+ strings,
+ env,
+ JunoFunctions { func_ids: vec![] },
+ )
+ .map_err(|e| format!("Scheduling Error: {}", e))
+}
+
pub fn schedule_hercules(
module: Module,
sched_filename: Option<String>,
diff --git a/juno_scheduler/src/pm.rs b/juno_scheduler/src/pm.rs
index 43fba4fd..ce1e95f1 100644
--- a/juno_scheduler/src/pm.rs
+++ b/juno_scheduler/src/pm.rs
@@ -2,6 +2,10 @@ use crate::ir::*;
use crate::labels::*;
use hercules_cg::*;
use hercules_ir::*;
+use serde::{Deserialize, Serialize};
+use hercules_opt::fork_guard_elim;
+use hercules_opt::forkify;
+use hercules_opt::loop_canonicalization;
use hercules_opt::FunctionEditor;
use hercules_opt::{
ccp, collapse_returns, crc, dce, dumb_outline, ensure_between_control_flow, float_collections,
@@ -139,7 +143,7 @@ impl Value {
}
}
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum SchedulerError {
UndefinedVariable(String),
UndefinedField(String),
@@ -166,8 +170,8 @@ impl fmt::Display for SchedulerError {
}
}
-#[derive(Debug)]
-struct PassManager {
+#[derive(Debug, Clone)]
+pub struct PassManager {
functions: Vec<Function>,
types: RefCell<Vec<Type>>,
constants: RefCell<Vec<Constant>>,
@@ -192,7 +196,7 @@ struct PassManager {
}
impl PassManager {
- fn new(module: Module) -> Self {
+ pub fn new(module: Module) -> Self {
let Module {
functions,
types,
@@ -459,6 +463,31 @@ impl PassManager {
res
}
+ pub fn get_module(&self) -> Module {
+ let PassManager {
+ functions,
+ types,
+ constants,
+ dynamic_constants,
+ labels,
+ typing: _,
+ control_subgraphs: _,
+ bbs: _,
+ collection_objects:_,
+ callgraph: _,
+ ..
+ } = self;
+
+ let module = Module {
+ functions: functions.to_vec(),
+ types: types.clone().into_inner(),
+ constants: constants.clone().into_inner(),
+ dynamic_constants: dynamic_constants.clone().into_inner(),
+ labels: labels.clone().into_inner(),
+ };
+ module
+ }
+
fn codegen(mut self, output_dir: String, module_name: String) -> Result<(), SchedulerError> {
self.make_typing();
self.make_control_subgraphs();
@@ -584,6 +613,18 @@ pub fn schedule_codegen(
pm.codegen(output_dir, module_name)
}
+pub fn schedule_module(
+ module: Module,
+ schedule: ScheduleStmt,
+ mut stringtab: StringTable,
+ mut env: Env<usize, Value>,
+ functions: JunoFunctions,
+) -> Result<Module, SchedulerError> {
+ let mut pm = PassManager::new(module);
+ let _ = schedule_interpret(&mut pm, &schedule, &mut stringtab, &mut env, &functions)?;
+ Ok(pm.get_module())
+}
+
// Interpreter for statements and expressions returns a bool indicating whether
// any optimization ran and changed the IR. This is used for implementing
// the fixpoint
@@ -1166,7 +1207,31 @@ fn run_pass(
pm.clear_analyses();
}
Pass::ForkGuardElim => {
- todo!("Fork Guard Elim doesn't use editor")
+ assert!(args.is_empty());
+ pm.make_fork_join_maps();
+ let fork_join_maps = pm.fork_join_maps.take().unwrap();
+ for (func, fork_join_map) in build_selection(pm, selection)
+ .into_iter()
+ .zip(fork_join_maps.iter())
+ {
+ let Some(mut func) = func else {
+ continue;
+ };
+ fork_guard_elim(&mut func, fork_join_map);
+ changed |= func.modified();
+ }
+ pm.delete_gravestones();
+ pm.clear_analyses();
+ }
+ Pass::Serialize => {
+ // FIXME: How to get module name here?
+ let output_file = "out.hbin";
+ let module = pm.clone().get_module().clone();
+ let module_contents: Vec<u8> = postcard::to_allocvec(&module).unwrap();
+ let mut file = File::create(&output_file)
+ .expect("PANIC: Unable to open output module file.");
+ file.write_all(&module_contents)
+ .expect("PANIC: Unable to write output module file contents.");
}
Pass::ForkSplit => {
assert!(args.is_empty());
@@ -1189,7 +1254,27 @@ fn run_pass(
pm.clear_analyses();
}
Pass::Forkify => {
- todo!("Forkify doesn't use editor")
+ assert!(args.is_empty());
+ pm.make_fork_join_maps();
+ pm.make_control_subgraphs();
+ pm.make_loops();
+ let fork_join_maps = pm.fork_join_maps.take().unwrap();
+ let loops = pm.loops.take().unwrap();
+ let control_subgraphs = pm.control_subgraphs.take().unwrap();
+ for (((func, fork_join_map), loop_nest), control_subgraph) in build_selection(pm, selection)
+ .into_iter()
+ .zip(fork_join_maps.iter())
+ .zip(loops.iter())
+ .zip(control_subgraphs.iter())
+ {
+ let Some(mut func) = func else {
+ continue;
+ };
+ changed |= forkify(&mut func, control_subgraph, fork_join_map, loop_nest);
+ // func.modified();
+ }
+ pm.delete_gravestones();
+ pm.clear_analyses();
}
Pass::GCM => {
assert!(args.is_empty());
@@ -1563,6 +1648,32 @@ fn run_pass(
// Put BasicBlocks back, since it's needed for Codegen.
pm.bbs = bbs;
}
+ Pass::LoopCanonicalization => {
+ assert!(args.is_empty());
+ pm.make_fork_join_maps();
+ pm.make_control_subgraphs();
+ pm.make_loops();
+ pm.make_typing();
+ let fork_join_maps = pm.fork_join_maps.take().unwrap();
+ let loops = pm.loops.take().unwrap();
+ let control_subgraphs = pm.control_subgraphs.take().unwrap();
+ let typing = pm.typing.take().unwrap();
+ for ((((func, fork_join_map), loop_nest), control_subgraph), typing) in build_selection(pm, selection)
+ .into_iter()
+ .zip(fork_join_maps.iter())
+ .zip(loops.iter())
+ .zip(control_subgraphs.iter())
+ .zip(typing.iter())
+ {
+ let Some(mut func) = func else {
+ continue;
+ };
+ changed |= loop_canonicalization(&mut func, control_subgraph, fork_join_map, loop_nest, typing);
+ // func.modified();
+ }
+ pm.delete_gravestones();
+ pm.clear_analyses();
+ }
}
Ok((result, changed))
--
GitLab
From 3f1df292af34471fc248f7157839863d7c68e969 Mon Sep 17 00:00:00 2001
From: Russel Arbore <russel.jma@gmail.com>
Date: Thu, 23 Jan 2025 19:28:37 -0600
Subject: [PATCH 43/68] ugly hack fix that demonstrates things
---
hercules_opt/src/loop_canonicalization.rs | 65 +++++++++++++++++++++--
1 file changed, 61 insertions(+), 4 deletions(-)
diff --git a/hercules_opt/src/loop_canonicalization.rs b/hercules_opt/src/loop_canonicalization.rs
index 142874fa..cded4c7e 100644
--- a/hercules_opt/src/loop_canonicalization.rs
+++ b/hercules_opt/src/loop_canonicalization.rs
@@ -60,13 +60,70 @@ pub fn loop_canonicalization(
// FIXME: Add return type enum of: {transformed, already in transformed form (not modified), unable to transform}.
for l in &natural_loops {
- let Some(loop_exit) = get_loop_exit_conditions(editor.func(), &Loop { header: l.0, control: l.1.clone()}, control_subgraph) else {continue};
+ let Some(loop_exit) = get_loop_exit_conditions(
+ editor.func(),
+ &Loop {
+ header: l.0,
+ control: l.1.clone(),
+ },
+ control_subgraph,
+ ) else {
+ continue;
+ };
loop_exits.insert(l.0, loop_exit);
}
-
+
for l in natural_loops {
- let natural_loop = &Loop { header: l.0, control: l.1.clone()};
- if canonicalize_loop(editor, loop_exits.get(&l.0).copied(), fork_join_map, natural_loop, typing) {
+ let natural_loop = &Loop {
+ header: l.0,
+ control: l.1.clone(),
+ };
+ if canonicalize_loop(
+ editor,
+ loop_exits.get(&l.0).copied(),
+ fork_join_map,
+ natural_loop,
+ typing,
+ ) {
+ let nodes = &editor.func().nodes;
+ let mut xuser = NodeID::new(0);
+ let mut xother_user = NodeID::new(0);
+ for id in editor.node_ids() {
+ if nodes[id.idx()].is_region() {
+ for user in editor.get_users(id) {
+ if let Node::Phi {
+ control: _,
+ ref data,
+ } = nodes[user.idx()]
+ && data.into_iter().any(|id| nodes[id.idx()].is_undef())
+ {
+ for other_user in editor.get_users(id) {
+ if let Node::Phi {
+ control: _,
+ data: ref other_data,
+ } = nodes[other_user.idx()]
+ && data.into_iter().zip(other_data.into_iter()).all(
+ |(datum, other_datum)| {
+ datum == other_datum || nodes[datum.idx()].is_undef()
+ },
+ )
+ && user != other_user
+ {
+ xuser = user;
+ xother_user = other_user;
+ }
+ }
+ }
+ }
+ }
+ }
+ if xuser.idx() != 0 && xother_user.idx() != 0 {
+ editor.edit(|mut edit| {
+ edit = edit.replace_all_uses(xuser, xother_user)?;
+ edit.delete_node(xuser)
+ });
+ }
+
return true;
}
}
--
GitLab
From edf9573ab56949136dff569750eca733f866a947 Mon Sep 17 00:00:00 2001
From: Xavier Routh <xrouth2@illinois.edu>
Date: Mon, 27 Jan 2025 11:49:25 -0600
Subject: [PATCH 44/68] rewrite unforkify
---
hercules_ir/src/ir.rs | 12 +-
hercules_opt/src/editor.rs | 5 +
hercules_opt/src/fork_guard_elim.rs | 16 +-
hercules_opt/src/forkify.rs | 288 +++++++++-------
hercules_opt/src/ivar.rs | 318 +++++++++++-------
hercules_opt/src/lib.rs | 2 -
hercules_opt/src/loop_canonicalization.rs | 1 -
hercules_opt/src/unforkify.rs | 157 +++++++--
.../hercules_interpreter/src/interpreter.rs | 22 +-
hercules_test/hercules_interpreter/src/lib.rs | 2 +-
.../hercules_interpreter/src/value.rs | 5 +-
.../tests/fork_transform_tests.rs | 137 ++++----
.../hercules_tests/tests/forkify_tests.rs | 44 +++
.../hercules_tests/tests/interpreter_tests.rs | 42 +++
.../hercules_tests/tests/loop_tests.rs | 229 ++++++++++---
hercules_test/test_inputs/3d_fork.hir | 8 +
.../test_inputs/forkify/merged_phi_cycle.hir | 18 +
.../test_inputs/forkify/split_phi_cycle.hir | 16 +
.../alternate_bounds_use_after_loop2.hir | 21 ++
.../loop_analysis/do_while_separate_body.hir | 16 +
.../loop_analysis/do_while_separate_body2.hir | 18 +
juno_scheduler/src/default.rs | 6 -
juno_scheduler/src/pm.rs | 11 +-
23 files changed, 988 insertions(+), 406 deletions(-)
create mode 100644 hercules_test/test_inputs/3d_fork.hir
create mode 100644 hercules_test/test_inputs/forkify/merged_phi_cycle.hir
create mode 100644 hercules_test/test_inputs/forkify/split_phi_cycle.hir
create mode 100644 hercules_test/test_inputs/loop_analysis/alternate_bounds_use_after_loop2.hir
create mode 100644 hercules_test/test_inputs/loop_analysis/do_while_separate_body.hir
create mode 100644 hercules_test/test_inputs/loop_analysis/do_while_separate_body2.hir
diff --git a/hercules_ir/src/ir.rs b/hercules_ir/src/ir.rs
index 46d35f25..7b7acea5 100644
--- a/hercules_ir/src/ir.rs
+++ b/hercules_ir/src/ir.rs
@@ -983,7 +983,7 @@ impl Constant {
Constant::Float64(ord) => *ord == OrderedFloat::<f64>(1.0),
_ => false,
}
- }
+ }
}
impl DynamicConstant {
@@ -1352,6 +1352,16 @@ impl Node {
}
}
+ pub fn is_one_constant(&self, constants: &Vec<Constant>) -> bool {
+ if let Node::Constant { id } = self
+ && constants[id.idx()].is_one()
+ {
+ true
+ } else {
+ false
+ }
+ }
+
pub fn try_projection(&self, branch: usize) -> Option<NodeID> {
if let Node::Projection { control, selection } = self
&& branch == *selection
diff --git a/hercules_opt/src/editor.rs b/hercules_opt/src/editor.rs
index 0d6fd3ae..935ee726 100644
--- a/hercules_opt/src/editor.rs
+++ b/hercules_opt/src/editor.rs
@@ -3,6 +3,7 @@ extern crate either;
extern crate hercules_ir;
extern crate itertools;
extern crate nestify;
+use std::borrow::Borrow;
use std::cell::{Ref, RefCell};
use std::collections::{BTreeMap, HashMap, HashSet};
use std::mem::take;
@@ -160,6 +161,10 @@ impl<'a: 'b, 'b> FunctionEditor<'a> {
self.modified
}
+ pub fn node(&self, node: impl Borrow<NodeID>) -> &Node {
+ &self.function.nodes[node.borrow().idx()]
+ }
+
pub fn edit<F>(&'b mut self, edit: F) -> bool
where
F: FnOnce(FunctionEdit<'a, 'b>) -> Result<FunctionEdit<'a, 'b>, FunctionEdit<'a, 'b>>,
diff --git a/hercules_opt/src/fork_guard_elim.rs b/hercules_opt/src/fork_guard_elim.rs
index 2e1f89e7..a1962595 100644
--- a/hercules_opt/src/fork_guard_elim.rs
+++ b/hercules_opt/src/fork_guard_elim.rs
@@ -133,7 +133,21 @@ fn guarded_fork(
}
// Match Factor
- let factor = factors.clone().find(|factor| function.nodes[pattern_factor.idx()].try_dynamic_constant() == Some(factor.get_id()));
+ let factor = factors.clone().find(|factor| {
+ // This clone on the dc is painful.
+ match (&function.nodes[pattern_factor.idx()], editor.get_dynamic_constant(factor.get_id()).clone()) {
+ (Node::Constant { id }, DynamicConstant::Constant(v)) => {
+ let Constant::UnsignedInteger64(pattern_v) = *editor.get_constant(*id) else {
+ return false;
+ };
+ pattern_v == (v as u64)
+ },
+ (Node::DynamicConstant { id }, _) => {
+ *id == factor.get_id()
+ },
+ _ => false
+ }
+ });
// return Factor
factor
})
diff --git a/hercules_opt/src/forkify.rs b/hercules_opt/src/forkify.rs
index 70bc3b60..36bedc88 100644
--- a/hercules_opt/src/forkify.rs
+++ b/hercules_opt/src/forkify.rs
@@ -17,10 +17,11 @@ use self::hercules_ir::Subgraph;
use self::hercules_ir::control_subgraph;
use crate::calculate_loop_nodes;
-use crate::compute_basic_induction_vars;
+use crate::compute_induction_vars;
+use crate::compute_iv_ranges;
use crate::compute_loop_variance;
-use crate::find_loop_bound;
use crate::get_loop_exit_conditions;
+use crate::has_canonical_iv;
use crate::walk_all_users;
use crate::walk_all_users_stop_on;
use crate::walk_all_uses;
@@ -28,14 +29,15 @@ use crate::walk_all_uses_stop_on;
use crate::BasicInductionVariable;
use crate::DenseNodeMap;
use crate::FunctionEditor;
+use crate::InductionVariable;
use crate::Loop;
-use crate::LoopBound;
use crate::LoopExit;
use crate::LoopVarianceInfo;
use hercules_ir::def_use::*;
use hercules_ir::ir::*;
use hercules_ir::loops::*;
+use itertools::Itertools;
pub fn forkify(
editor: &mut FunctionEditor,
@@ -56,21 +58,19 @@ pub fn forkify(
return true;
}
}
-
return false;
-
}
/** Given a node used as a loop bound, return a dynamic constant ID. */
-pub fn get_bound_as_dc(editor: &mut FunctionEditor, bound: LoopBound) -> Result<DynamicConstantID, String> {
+pub fn get_node_as_dc(editor: &mut FunctionEditor, node: NodeID) -> Result<DynamicConstantID, String> {
// Check for a constant used as loop bound.
- match bound {
- LoopBound::DynamicConstant(dynamic_constant_id) => {
- Ok(dynamic_constant_id)
+ match editor.node(node) {
+ Node::DynamicConstant{id: dynamic_constant_id} => {
+ Ok(*dynamic_constant_id)
}
- LoopBound::Constant(constant_id) => {
- let dc = match *editor.get_constant(constant_id) {
+ Node::Constant {id: constant_id} => {
+ let dc = match *editor.get_constant(*constant_id) {
Constant::Integer8(x) => DynamicConstant::Constant(x as _),
Constant::Integer16(x) => DynamicConstant::Constant(x as _),
Constant::Integer32(x) => DynamicConstant::Constant(x as _),
@@ -93,8 +93,7 @@ pub fn get_bound_as_dc(editor: &mut FunctionEditor, bound: LoopBound) -> Result<
// or dynamic constant that is the existing loop bound
Ok(b)
}
- LoopBound::Variable(node_id) => todo!(),
- LoopBound::Unbounded => Err("Bound is not constant or dynamic constant".to_string()),
+ _ => Err("Blah".to_owned())
}
}
@@ -128,42 +127,64 @@ pub fn forkify_loop(
let function = editor.func();
- let loop_pred = editor.get_uses(l.header)
- .filter(|id| !l.control[id.idx()])
- .next()
- .unwrap();
-
let Some(loop_condition) = get_loop_exit_conditions(function, l, control_subgraph) else {return false};
let LoopExit::Conditional { if_node: loop_if, condition_node } = loop_condition.clone() else {return false};
// Compute loop variance
- let loop_variance = compute_loop_variance(editor, &l);
+ let loop_variance = compute_loop_variance(editor, l);
+ let ivs = compute_induction_vars(editor.func(), l, &loop_variance);
+ let ivs = compute_iv_ranges(editor, l, ivs, &loop_condition);
+ let Some(canonical_iv) = has_canonical_iv(editor, l, &ivs) else {return false};
+
+ // Get bound
+ let bound = match canonical_iv {
+ InductionVariable::Basic { node, initializer, update, final_value } => final_value.map(|final_value| get_node_as_dc(editor, final_value)).and_then(|r| r.ok()),
+ InductionVariable::SCEV(node_id) => return false,
+ };
+
+ let Some(bound_dc_id) = bound else {return false};
+ let function = editor.func();
- // Compute induction vars
- let basic_ivs = compute_basic_induction_vars(function, &l, &loop_variance);
+ // Check if it is do-while loop.
+ let loop_exit_projection = editor.get_users(loop_if)
+ .filter(|id| !l.control[id.idx()])
+ .next()
+ .unwrap();
- // Compute loop bounds
- let Some(basic_iv) = find_loop_bound(editor, &control_subgraph, &l,
- &basic_ivs, &loop_condition, &loop_variance) else {return false};
+ let loop_continue_projection = editor.get_users(loop_if)
+ .filter(|id| l.control[id.idx()])
+ .next()
+ .unwrap();
- let function = editor.func();
+ let loop_preds: Vec<_> = editor.get_uses(l.header)
+ .filter(|id| !l.control[id.idx()])
+ .collect();
+
+ if loop_preds.len() != 1 {
+ return false;
+ }
- // Check reductionable phis, only PHIs depending on the loop are considered,
+ let loop_pred = loop_preds[0];
+
+ if !editor.get_uses(l.header).contains(&loop_continue_projection) {
+ return false;
+ }
+
+ // Get all phis used outside of the loop, they need to be reductionable.
+ // For now just assume all phis will be phis used outside of the loop, except for the canonical iv.
+ // FIXME: We need a different definiton of `loop_nodes` to check for phis used outside hte loop than the one
+ // we currently have.
+ let loop_nodes = calculate_loop_nodes(editor, l);
+
+ // // Check reductionable phis, only PHIs depending on the loop are considered,
let candidate_phis: Vec<_> = editor.get_users(l.header)
.filter(|id|function.nodes[id.idx()].is_phi())
- .filter(|id| *id != basic_iv.node)
- .filter(|id| *id != condition_node)
+ .filter(|id| *id != canonical_iv.phi())
.collect();
- let reductionable_phis: Vec<_> = analyze_phis(&editor, &l, &candidate_phis).into_iter().collect();
+ let reductionable_phis: Vec<_> = analyze_phis(&editor, &l, &candidate_phis, &loop_nodes).into_iter().collect();
- // Check for a constant used as loop bound.
- let Some(bound) = basic_iv.bound else {return false};
- let Ok(bound_dc_id) = get_bound_as_dc(editor, bound) else {return false};
-
- let loop_nodes = calculate_loop_nodes(editor, l);
-
// START EDITING
// What we do is:
@@ -178,65 +199,51 @@ pub fn forkify_loop(
let function = editor.func();
- // Get the control portions of the loop.
- let loop_exit_projection = editor.get_users(loop_if)
- .filter(|id| !l.control[id.idx()])
- .next()
- .unwrap();
-
- let loop_continue_projection = editor.get_users(loop_if)
- .filter(|id| l.control[id.idx()])
- .next()
- .unwrap();
// TOOD: Handle multiple loop body lasts.
// If there are multiple candidates for loop body last, return false.
- if editor.get_uses(l.header)
+ if editor.get_uses(loop_if)
.filter(|id| l.control[id.idx()])
.count() > 1 {
return false;
}
- let loop_body_last = editor.get_uses(l.header)
- .filter(|id| l.control[id.idx()])
+ let loop_body_last = editor.get_uses(loop_if)
.next()
.unwrap();
if reductionable_phis.iter()
- .any(|phi| matches!(phi, LoopPHI::LoopDependant(_))) {
+ .any(|phi| !matches!(phi, LoopPHI::Reductionable{..})) {
return false
- }
-
-
- // Analyze the control that is inside the loop:
-
- // Assume while loops, not do while loops.
+ }
// 1) If there is any control between header and loop condition, exit.
let header_control_users: Vec<_> = editor.get_users(l.header)
.filter(|id| function.nodes[id.idx()].is_control())
.collect();
-
- if header_control_users.first() != Some(&loop_if) {
+
+ // Outside uses of IV, then exit;
+ if editor.get_users(canonical_iv.phi()).any(|node| !loop_nodes.contains(&node)) {
return false
}
- // Graft everything between loop_continue_projection (deleted) and header (deleted).
+
+ // Graft everyhting between header and loop condition
// Attach join to right before header (after loop_body_last, unless loop body last *is* the header).
// Attach fork to right after loop_continue_projection.
- // Create fork and join nodes:
+ // // Create fork and join nodes:
let mut join_id = NodeID::new(0);
let mut fork_id = NodeID::new(0);
- // FIXME (@xrouth), handle control in loop body.
+ // // FIXME (@xrouth), handle control in loop body.
editor.edit(
|mut edit| {
let fork = Node::Fork { control: loop_pred, factors: Box::new([bound_dc_id])};
fork_id = edit.add_node(fork);
let join = Node::Join {
- control: if loop_continue_projection == loop_body_last {
+ control: if l.header == loop_body_last {
fork_id
} else {
loop_body_last
@@ -249,21 +256,20 @@ pub fn forkify_loop(
}
);
-
- let function = editor.func();
-
- let update = *zip(
- editor.get_uses(l.header),
- function.nodes[basic_iv.node.idx()]
- .try_phi()
- .unwrap()
- .1
- .iter(),
- )
- .filter(|(c, _)| *c == loop_body_last)
- .next()
- .unwrap()
- .1;
+ // let function = editor.func();
+
+ // let update = *zip(
+ // editor.get_uses(l.header),
+ // function.nodes[canonical_iv.phi().idx()]
+ // .try_phi()
+ // .unwrap()
+ // .1
+ // .iter(),
+ // )
+ // .filter(|(c, _)| *c == loop_body_last)
+ // .next()
+ // .unwrap()
+ // .1;
let function = editor.func();
let (_, factors) = function.nodes[fork_id.idx()].try_fork().unwrap();
@@ -278,38 +284,38 @@ pub fn forkify_loop(
};
let thread_id_id = edit.add_node(thread_id);
- let iv_reduce = Node::Reduce {
- control: join_id,
- init: basic_iv.initializer,
- reduct: update,
- };
+ // let iv_reduce = Node::Reduce {
+ // control: join_id,
+ // init: basic_iv.initializer,
+ // reduct: update,
+ // };
// If a user occurs after the loop is finished, we replace it with the DC that is the IV bound,
// If a user occurs inside the loop, we replace it with the IV.
// Replace uses that are inside with the thread id
- edit = edit.replace_all_uses_where(basic_iv.node, thread_id_id, |node| {
+ edit = edit.replace_all_uses_where(canonical_iv.phi(), thread_id_id, |node| {
loop_nodes.contains(node)
})?;
- // Replace uses that are outside with the DC
+ // Replace uses that are outside with DC - 1. Or just give up.
let bound_dc_node = edit.add_node(Node::DynamicConstant { id: bound_dc_id });
- edit = edit.replace_all_uses_where(basic_iv.node, bound_dc_node, |node| {
+ edit = edit.replace_all_uses_where(canonical_iv.phi(), bound_dc_node, |node| {
!loop_nodes.contains(node)
})?;
- edit.delete_node(basic_iv.node)
+ edit.delete_node(canonical_iv.phi())
}
);
for reduction_phi in reductionable_phis {
- let reduction_phi = reduction_phi.get_phi();
+ let LoopPHI::Reductionable { phi, data_cycle, continue_latch, is_associative } = reduction_phi else {continue};
let function = editor.func();
let init = *zip(
editor.get_uses(l.header),
- function.nodes[reduction_phi.idx()]
+ function.nodes[phi.idx()]
.try_phi()
.unwrap()
.1
@@ -320,31 +326,18 @@ pub fn forkify_loop(
.unwrap()
.1;
- // Loop back edge input to phi is the reduction update expression.
- let update = *zip(
- editor.get_uses(l.header),
- function.nodes[reduction_phi.idx()]
- .try_phi()
- .unwrap()
- .1
- .iter(),
- )
- .filter(|(c, _)| *c == loop_body_last)
- .next()
- .unwrap()
- .1;
-
editor.edit(
|mut edit| {
let reduce = Node::Reduce {
control: join_id,
init,
- reduct: update,
+ reduct: continue_latch,
};
let reduce_id = edit.add_node(reduce);
-
- edit = edit.replace_all_uses(reduction_phi, reduce_id)?;
- edit.delete_node(reduction_phi)
+
+ edit = edit.replace_all_uses_where(phi, reduce_id, |usee| *usee != reduce_id)?;
+ edit = edit.replace_all_uses_where(continue_latch, reduce_id, |usee| !loop_nodes.contains(usee ) && *usee != reduce_id)?;
+ edit.delete_node(phi)
}
);
}
@@ -389,16 +382,23 @@ pub fn forkify_loop(
nest! {
#[derive(Debug)]
pub enum LoopPHI {
- Reductionable(NodeID),
+ Reductionable {
+ phi: NodeID,
+ data_cycle: HashSet<NodeID>, // All nodes in a data cycle with this phi
+ continue_latch: NodeID,
+ is_associative: bool,
+ },
LoopDependant(NodeID),
+ UsedByDependant(NodeID),
}
}
impl LoopPHI {
pub fn get_phi(&self) -> NodeID {
match self {
- LoopPHI::Reductionable(node_id) => *node_id,
+ LoopPHI::Reductionable {phi, data_cycle, ..} => *phi,
LoopPHI::LoopDependant(node_id) => *node_id,
+ LoopPHI::UsedByDependant(node_id) => *node_id,
}
}
}
@@ -411,13 +411,9 @@ impl LoopPHI {
- Every cycle *in the loop* containing the PHI does not contain any other PHI. Or something, IDK.
-
We also need to make it not control dependent on anything other than the loop header. */
-pub fn analyze_phis<'a>(editor: &'a FunctionEditor, natural_loop: &'a Loop, phis: &'a [NodeID])
+pub fn analyze_phis<'a>(editor: &'a FunctionEditor, natural_loop: &'a Loop, phis: &'a [NodeID], loop_nodes: &'a HashSet<NodeID>)
-> impl Iterator<Item = LoopPHI> + 'a
-{
- let function = editor.func();
-
- // // FIXME: (@xrouth)
- // // Check that the PHI actually has a cycle back to it.
+{
phis.into_iter().map(move |phi| {
let stop_on: HashSet<NodeID> = editor.node_ids().filter(|node| {
let data = &editor.func().nodes[node.idx()];
@@ -436,7 +432,7 @@ pub fn analyze_phis<'a>(editor: &'a FunctionEditor, natural_loop: &'a Loop, phis
}
// External Control
- if data.is_control() && !natural_loop.control[node.idx()] {
+ if data.is_control() {//&& !natural_loop.control[node.idx()] {
return true
}
@@ -445,23 +441,71 @@ pub fn analyze_phis<'a>(editor: &'a FunctionEditor, natural_loop: &'a Loop, phis
}).collect();
// TODO: We may need to stop on exiting the loop for looking for data cycles.
- let uses = walk_all_uses_stop_on(*phi, editor, stop_on.clone());
+ let uses = walk_all_uses_stop_on(*phi, editor, stop_on.clone()).filter(|node|
+ {
+ // Get rid of nodes in stop_on
+ !stop_on.contains(node)
+ });
let users = walk_all_users_stop_on(*phi, editor, stop_on.clone()).filter(|node|
{
// Get rid of nodes in stop_on
!stop_on.contains(node)
});
-
+
let set1: HashSet<_> = HashSet::from_iter(uses);
let set2: HashSet<_> = HashSet::from_iter(users);
- // If there are any cycles containing a phi other than itself.
- if set1.intersection(&set2).any(|node| editor.func().nodes[node.idx()].is_phi() && node != phi) {
+ let intersection: HashSet<_> = set1.intersection(&set2).cloned().collect();
+
+ // If this phi uses any other phis the node is loop dependant,
+ // we use `phis` because this phi can actually contain the loop iv and its fine.
+ if set1.clone().iter().any(|node| phis.contains(node) && node != phi) {
LoopPHI::LoopDependant(*phi)
- } else if set1.intersection(&set2).any(|node| true){
- // Any cycle exists
- LoopPHI::Reductionable(*phi)
- } else {
+ } // If this phi is used by other phis in the loop
+ else if set2.clone().iter().any(|node|
+ editor.func().nodes[node.idx()].is_phi()
+ && node != phi
+ && natural_loop.control[editor.func().nodes[node.idx()].try_phi().unwrap().0.idx()] ) {
+ LoopPHI::UsedByDependant(*phi)
+ }
+ else if intersection.clone().iter().any(|node| node == phi) {
+ let continue_idx = editor.get_uses(natural_loop.header)
+ .position(|node| natural_loop.control[node.idx()])
+ .unwrap();
+
+ let loop_continue_latch = editor.node(phi).try_phi().unwrap().1[continue_idx];
+
+ // No nodes in data cycles with this phi (in the loop) are used outside the loop, besides the loop_continue_latch.
+ if intersection.iter()
+ .filter(|node| **node != loop_continue_latch)
+ .any(|data_node| editor.get_users(*data_node).any(|user| !loop_nodes.contains(&user))) {
+ // This phi can be made into a reduce in different ways, if the cycle is associative (contains all the same kind of associative op)
+ // 3) Split the cycle into two phis, add them or multiply them together at the end.
+ // 4) Split the cycle into two reduces, add them or multiply them together at the end.
+ // Somewhere else should handle this.
+ return LoopPHI::LoopDependant(*phi)
+ }
+
+ // if tehre are separate types of ops, or any non associative ops, then its not associative
+
+ // Extract ops
+ // let is_associative = intersection.iter().filter_map(|node| match editor.node(node) {
+ // Node::Unary { input, op } => todo!(),
+ // Node::Binary { left, right, op } => todo!(),
+ // Node::Ternary { first, second, third, op } => todo!(),
+ // });
+ let is_associative = false;
+
+ // No nodes in the data cycle are used outside of the loop, besides the latched value of the phi
+ LoopPHI::Reductionable {
+ phi: *phi,
+ data_cycle: intersection,
+ continue_latch: loop_continue_latch,
+ is_associative,
+ }
+
+
+ } else { // No cycles exist, this isn't a reduction.
LoopPHI::LoopDependant(*phi)
}
})
diff --git a/hercules_opt/src/ivar.rs b/hercules_opt/src/ivar.rs
index 256e983b..b059c6bd 100644
--- a/hercules_opt/src/ivar.rs
+++ b/hercules_opt/src/ivar.rs
@@ -4,6 +4,7 @@ extern crate bitvec;
extern crate nestify;
use std::collections::{BTreeMap, HashMap, HashSet, VecDeque};
+use std::path::Iter;
use self::nestify::nest;
@@ -16,6 +17,8 @@ use self::bitvec::prelude::*;
use self::hercules_ir::LoopTree;
+use crate::walk_all_uses_stop_on;
+
use self::slotmap::{new_key_type, SlotMap};
use self::hercules_ir::ir::*;
@@ -45,6 +48,7 @@ pub enum LoopVariance {
type NodeVec = BitVec<u8, Lsb0>;
+
#[derive(Clone, Debug)]
pub struct Loop {
pub header: NodeID,
@@ -58,7 +62,6 @@ impl Loop {
all_loop_nodes
}
}
-
nest!{
/** Represents a basic induction variable.
NOTE (@xrouth): May switch to using SCEV to represent induction vairables, for now we assume only basic induction variables
@@ -68,20 +71,57 @@ nest!{
pub struct BasicInductionVariable {
pub node: NodeID,
pub initializer: NodeID,
- pub update: NodeID, // TODO: Assume only *constants*, not dynamic constants for now.
- pub bound: Option<
- #[derive(Clone, Copy, Debug, PartialEq)]
- pub enum LoopBound {
- DynamicConstant(DynamicConstantID),
- Constant(ConstantID),
- Variable(NodeID),
- Unbounded,
- },
- >,
+ pub update: NodeID,
+ pub final_value: Option<NodeID>,
}
} // nest
+nest!{
+ #[derive(Clone, Copy, Debug, PartialEq)]*
+ pub enum InductionVariable {
+ pub Basic {
+ node: NodeID,
+ initializer: NodeID,
+ update: NodeID,
+ final_value: Option<NodeID>,
+ },
+ SCEV(NodeID),
+ //ScevAdd(NodeID, NodeID),
+ // ScevMul(NodeID, NodeID),
+ }
+}
+
+impl InductionVariable {
+ pub fn phi(&self) -> NodeID {
+ match self {
+ InductionVariable::Basic { node, initializer, update, final_value } => *node,
+ InductionVariable::SCEV(_) => todo!(),
+ }
+ }
+ // Editor has become just a 'context' that everything needs. This is similar to how analyses / passes are structured,
+ // but editor forces recomputation / bookkeeping of simple / more commonly used info (even though it really is just def use, constants, dyn_constants)
+ // While if the pass writer wants more complicated info, like analyses results, they have to thread it through the pass manager.
+ // This seems fine.
+ // pub fn update_i64(&self, editor: &FunctionEditor) -> Option<i64> {
+ // match self {
+ // InductionVariable::Basic { node, initializer, update, final_value } => {
+ // match editor.node(update) {
+ // Node::Constant {id } => match *editor.get_constant(*id) {
+ // Constant::UnsignedInteger64(v) => v.try_into().ok(),
+ // _ => None,
+ // },
+ // _ => None,
+ // }
+ // },
+ // InductionVariable::SCEV(node_id) => todo!(),
+ // }
+ // }
+
+ // It would be nice for functions, as they (kinda) automatically capture 'self' to also automatically capture a 'context' that is in the same scope,
+ // so I don't have to keep passing a context into every function that needs one.
+ //
+}
// TODO: Optimize.
pub fn calculate_loop_nodes(
editor: &FunctionEditor,
@@ -398,92 +438,37 @@ pub fn match_canonicalization_bound(editor: &mut FunctionEditor, natural_loop: &
Some(final_node)
}
-pub fn find_loop_bound(editor: &mut FunctionEditor, control_subgraph: &Subgraph, l: &Loop,
- induction_vars: &[BasicInductionVariable], loop_condition: &LoopExit, loop_variance: &LoopVarianceInfo)
- -> Option<BasicInductionVariable> {
-
- // Answers the question which PHI node does this loop depend on,
- // Q: What happens if it is a PHI + expression, i.e i = 0; i + 2 < 6; i++
-
- // Q: What happens when the loop exit condition isn't based on simple bound, i.e: i < 6 - 2?
- // A: IDK!
-
- // Q: What happens when the loop condition is based on multiple induction variables, i.e: (i + j < 20)
- // A: IDK!
-
- let (exit_if_node, loop_condition) = match loop_condition {
- LoopExit::Conditional { if_node, condition_node } => (if_node, condition_node),
- LoopExit::Unconditional(node_id) => todo!()
- };
-
- // Check for an induction variable that interacts reasonably with the loop condition via pattern matching.
- // FIXME: Is there a better way to check for loop bounds?
- for induction_var in induction_vars {
- let bound = match &editor.func().nodes[loop_condition.idx()] {
- // All of these node types are valid boolean conditionals, we only handle some currently.
-
- // `None` only because it is unimplemented (laziness), not user error.
- Node::Phi { control, data } => {
- match_canonicalization_bound(editor, l, *loop_condition, *exit_if_node, *induction_var)
- },
- Node::Reduce { control, init, reduct } => None,
- Node::Parameter { index } => None,
- Node::Constant { id } => None,
- Node::Unary { input, op } => None,
- Node::Ternary { first, second, third, op } => None,
- Node::Binary { left, right, op } => {
- match op {
- BinaryOperator::LT => {
- // Check for a loop guard condition.
- // left < right
- if *left == induction_var.node &&
- (editor.func().nodes[right.idx()].is_constant() || editor.func().nodes[right.idx()].is_dynamic_constant()) {
- Some(*right)
- }
- else {
- None
- }
- }
- BinaryOperator::LTE => None, // like wtf.
- BinaryOperator::GT => None,
- BinaryOperator::GTE => None,
- BinaryOperator::EQ => None,
- BinaryOperator::NE => None,
- _ => None,
- }
+pub fn has_const_fields(editor: &FunctionEditor, ivar: InductionVariable) -> bool {
+ match ivar {
+ InductionVariable::Basic { node, initializer, update, final_value } => {
+ if final_value.is_none() {
+ return false;
}
- _ => None,
- };
-
- if bound.is_none() {
- continue;
+ [initializer, update].iter().any(
+ |node| !editor.node(node).is_constant()
+ )
+ },
+ InductionVariable::SCEV(node_id) => false,
+ }
+}
+
+/* Loop has any IV from range 0....N, N can be dynconst iterates +1 per iteration */
+// IVs need to be bounded...
+pub fn has_canonical_iv<'a>(editor: &FunctionEditor, l: &Loop, ivs: &'a[InductionVariable]) -> Option<&'a InductionVariable> {
+ ivs.iter().find(|iv| { match iv {
+ InductionVariable::Basic { node, initializer, update, final_value } => {
+ editor.node(initializer).is_zero_constant(&editor.get_constants())
+ && editor.node(update).is_one_constant(&editor.get_constants())
+ && final_value.map(|val| editor.node(val).is_constant() || editor.node(val).is_dynamic_constant()).is_some()
}
-
- // Simplify our representation of the bound here.
- // NodeID -> LoopBound
- let bound = bound.map(|bound|
- {
- match editor.func().nodes[bound.idx()] {
- Node::Constant { id } => LoopBound::Constant(id),
- Node::DynamicConstant { id } => LoopBound::DynamicConstant(id),
- _ => todo!(),
- }
- }
- );
-
- return Some(BasicInductionVariable {
- node: induction_var.node,
- initializer: induction_var.initializer,
- update: induction_var.update,
- bound: bound,
- });
+ InductionVariable::SCEV(node_id) => false,
}
-
- None
+ })
}
-pub fn compute_basic_induction_vars(function: &Function, l: &Loop, loop_variance: &LoopVarianceInfo)
- -> Vec<BasicInductionVariable> {
+// Need a transformation that forces all IVs to be SCEVs of an IV from range 0...N, +1, else places them in a separate loop?
+pub fn compute_induction_vars(function: &Function, l: &Loop, loop_variance: &LoopVarianceInfo)
+ -> Vec<InductionVariable> {
// 1) Gather PHIs contained in the loop.
// FIXME: (@xrouth) Should this just be PHIs controlled by the header?
@@ -499,7 +484,7 @@ pub fn compute_basic_induction_vars(function: &Function, l: &Loop, loop_variance
// FIXME: (@xrouth) For now, only compute variables that have one assignment,
// (look into this:) possibly treat multiple assignment as separate induction variables.
- let mut induction_variables: Vec<BasicInductionVariable> = vec![];
+ let mut induction_variables: Vec<InductionVariable> = vec![];
/* For each PHI controlled by the loop, check how it is modified */
@@ -520,56 +505,141 @@ pub fn compute_basic_induction_vars(function: &Function, l: &Loop, loop_variance
// Check dynamic constancy:
let initializer = &function.nodes[initializer_id.idx()];
- // println!("initializer_id: {:?}", initializer_id);
// In the case of a non 0 starting value:
- // - a new dynamic constant or constant may need to be created that is the difference between the initiailizer and the loop bounds.
+ // - a new dynamic constant or constant may need to be created that is the difference between the initiailizer and the loop bounds.
+ // Initializer does not necessarily have to be constant, but this is fine for now.
if !(initializer.is_dynamic_constant() || initializer.is_constant()) {
continue;
}
- // Check that intiailizer is 0:
-
- // TODO: (@xrouth) These checks, for initializer and non 0 starting value maybe can be done later, i.e in a different function / transformation.
- // Maybe return all induction variables as long as things are *loop invariant* and then filter by actualy constancy or dynamic constancy later.
-
// Check all data inputs to this phi, that aren't the initializer (i.e the value the comes from control outside of the loop)
// For now we expect only one initializer.
- let basic_ivs = data.iter().filter(
+ let data_inputs = data.iter().filter(
|data_id| NodeID::new(initializer_idx) != **data_id
);
- for data_id in basic_ivs {
+ for data_id in data_inputs {
let node = &function.nodes[data_id.idx()];
for bop in [BinaryOperator::Add] { //, BinaryOperator::Mul, BinaryOperator::Sub] {
if let Some((a, b)) = node.try_binary(bop) {
- if a == phi_id && function.nodes[b.idx()].is_constant() {
- // TODO: (@xrouth), move this is_strictly_scalar check somewhere else for when you actually evalute the constant.
- // let constant_id = function.nodes[b.idx()].try_constant().unwrap();
- // let constant = &module.constants[constant_id.idx()];
- // if !constant.is_strictly_scalar() {
- // break;
- // }
- induction_variables.push(BasicInductionVariable{
- node: phi_id,
- initializer: initializer_id,
- update: b,
- bound: None,
- });
-
- } else if b == phi_id && function.nodes[a.idx()].is_constant() {
- induction_variables.push(BasicInductionVariable{
- node: phi_id,
- initializer: initializer_id,
- update: a,
- bound: None,
+ let iv = [(a, b), (b, a)].iter().find_map(|(pattern_phi, pattern_const)| {
+ if *pattern_phi == phi_id && function.nodes[pattern_const.idx()].is_constant() {
+ return Some(InductionVariable::Basic {
+ node: phi_id,
+ initializer: initializer_id,
+ update: b,
+ final_value: None,
+ }) } else {
+ None
+ }
});
+ if let Some(iv) = iv {
+ induction_variables.push(iv);
}
}
}
}
};
- // println!("basic induction variables: {:?}", induction_variables);
induction_variables
-}
\ No newline at end of file
+}
+
+// Find loop iterations
+pub fn compute_iv_ranges(editor: &FunctionEditor, l: &Loop,
+ induction_vars: Vec<InductionVariable>, loop_condition: &LoopExit)
+ -> Vec<InductionVariable> {
+
+ let (if_node, condition_node) = match loop_condition {
+ LoopExit::Conditional { if_node, condition_node } => (if_node, condition_node),
+ LoopExit::Unconditional(node_id) => todo!()
+ };
+
+ // Find IVs used by the loop condition, not across loop iterations.
+ // without leaving the loop.
+ let stop_on: HashSet<_> = editor.node_ids().filter(|node_id|
+ {
+ if let Node::Phi { control, data } = editor.node(node_id) {
+ *control == l.header
+ } else {
+ false
+ }
+ }
+ ).collect();
+
+ // Bound IVs used in loop bound.
+ let loop_bound_uses: HashSet<_> = walk_all_uses_stop_on(*condition_node, editor, stop_on).collect();
+ let (loop_bound_ivs, other_ivs): (Vec<InductionVariable>, Vec<InductionVariable>) = induction_vars.into_iter().partition(|f| loop_bound_uses.contains(&f.phi()));
+
+ let Some(iv) = loop_bound_ivs.first() else {
+ return other_ivs;
+ };
+
+ if loop_bound_ivs.len() > 1 {
+ return loop_bound_ivs.into_iter().chain(other_ivs).collect();
+ }
+
+ // FIXME: DO linear algerbra to solve for loop bounds with multiple variables involved.
+ let final_value = match &editor.func().nodes[condition_node.idx()] {
+ Node::Phi { control, data } => {
+ None
+ },
+ Node::Reduce { control, init, reduct } => None,
+ Node::Parameter { index } => None,
+ Node::Constant { id } => None,
+ Node::Unary { input, op } => None,
+ Node::Ternary { first, second, third, op } => None,
+ Node::Binary { left, right, op } => {
+ match op {
+ BinaryOperator::LT => {
+ // Check for a loop guard condition.
+ // left < right
+ if *left == iv.phi() &&
+ (editor.func().nodes[right.idx()].is_constant() || editor.func().nodes[right.idx()].is_dynamic_constant()) {
+ Some(*right)
+ }
+ // left + const < right,
+ else if let Node::Binary { left: inner_left, right: inner_right, op: inner_op } = editor.node(left) {
+ let pattern = [(inner_left, inner_right), (inner_right, inner_left)].iter().find_map(|(pattern_iv, pattern_constant)|
+ {
+ if iv.phi()== **pattern_iv && (editor.node(*pattern_constant).is_constant()) {
+ // FIXME: pattern_constant can be anything >= loop_update expression,
+ let update = match iv {
+ InductionVariable::Basic { node, initializer, update, final_value } => update,
+ InductionVariable::SCEV(node_id) => todo!(),
+ };
+ if *pattern_constant == update {
+ Some(*right)
+ } else {
+ None
+ }
+ } else {
+ None
+ }
+ }
+ );
+ pattern.iter().cloned().next()
+ } else {
+ None
+ }
+ }
+ BinaryOperator::LTE => None,
+ BinaryOperator::GT => None,
+ BinaryOperator::GTE => None,
+ BinaryOperator::EQ => None,
+ BinaryOperator::NE => None,
+ _ => None,
+ }
+ }
+ _ => None,
+ };
+
+ let basic = match iv {
+ InductionVariable::Basic { node, initializer, update, final_value: _ } => InductionVariable::Basic { node: *node, initializer: *initializer, update: *update, final_value },
+ InductionVariable::SCEV(node_id) => todo!(),
+ };
+
+ // Propagate bounds to other IVs.
+ vec![basic].into_iter().chain(other_ivs).collect()
+}
+
diff --git a/hercules_opt/src/lib.rs b/hercules_opt/src/lib.rs
index 1f01ce8b..446aba3d 100644
--- a/hercules_opt/src/lib.rs
+++ b/hercules_opt/src/lib.rs
@@ -23,7 +23,6 @@ pub mod fork_transforms;
pub mod ivar;
pub mod unforkify;
pub mod utils;
-pub mod loop_canonicalization;
pub use crate::ccp::*;
pub use crate::crc::*;
@@ -46,6 +45,5 @@ pub use crate::slf::*;
pub use crate::sroa::*;
pub use crate::fork_transforms::*;
pub use crate::ivar::*;
-pub use crate::loop_canonicalization::*;
pub use crate::unforkify::*;
pub use crate::utils::*;
diff --git a/hercules_opt/src/loop_canonicalization.rs b/hercules_opt/src/loop_canonicalization.rs
index 142874fa..9bd4fcef 100644
--- a/hercules_opt/src/loop_canonicalization.rs
+++ b/hercules_opt/src/loop_canonicalization.rs
@@ -27,7 +27,6 @@ use self::hercules_ir::NodeID;
use self::hercules_ir::Subgraph;
use crate::calculate_loop_nodes;
-use crate::compute_basic_induction_vars;
use crate::compute_loop_variance;
use crate::get_loop_exit_conditions;
use crate::BasicInductionVariable;
diff --git a/hercules_opt/src/unforkify.rs b/hercules_opt/src/unforkify.rs
index a5df7a7c..5a479a61 100644
--- a/hercules_opt/src/unforkify.rs
+++ b/hercules_opt/src/unforkify.rs
@@ -1,17 +1,83 @@
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
use std::iter::zip;
-use hercules_ir::ir::*;
+use bitvec::{order::Lsb0, vec::BitVec};
+use hercules_ir::{ir::*, LoopTree};
use crate::*;
+type NodeVec = BitVec<u8, Lsb0>;
+pub fn calculate_fork_nodes(editor: &FunctionEditor, inner_control: &NodeVec, fork: NodeID, join: NodeID) -> HashSet<NodeID> {
+ // Stop on PHIs / reduces outside of loop.
+ let stop_on: HashSet<NodeID> = editor.node_ids().filter(
+ |node|{
+ let data = &editor.func().nodes[node.idx()];
+
+ // External Phi
+ if let Node::Phi { control, data } = data {
+ if match inner_control.get(control.idx()) {
+ Some(v) => !*v, //
+ None => true, // Doesn't exist, must be external
+ } {
+ return true;
+ }
+
+ }
+ // External Reduce
+ if let Node::Reduce { control, init, reduct} = data {
+ if match inner_control.get(control.idx()) {
+ Some(v) => !*v, //
+ None => true, // Doesn't exist, must be external
+ } {
+ return true;
+ }
+ }
+
+ // External Control
+ if data.is_control() {
+ return match inner_control.get(node.idx()) {
+ Some(v) => !*v, //
+ None => true, // Doesn't exist, must be external
+ }
+ }
+ // else
+ return false;
+ }
+ ).collect();
+
+ let reduces: Vec<_> = editor.node_ids().filter(|node| {
+ let Node::Reduce { control, .. } = editor.func().nodes[node.idx()] else {return false};
+ match inner_control.get(control.idx()) {
+ Some(v) => *v,
+ None => false,
+ }
+ }).chain(editor.get_users(fork).filter(|node| {
+ editor.node(node).is_thread_id()
+ })).collect();
+
+ let all_users: HashSet<NodeID> = reduces.clone().iter().flat_map(|phi| walk_all_users_stop_on(*phi, editor, stop_on.clone()))
+ .chain(reduces.clone())
+ .collect();
+
+ let all_uses: HashSet<_> = reduces.clone().iter()
+ .flat_map(|phi| walk_all_uses_stop_on(*phi, editor, stop_on.clone()))
+ .chain(reduces)
+ .filter(|node|
+ {
+ // Get rid of nodes in stop_on
+ !stop_on.contains(node)
+ })
+ .collect();
+
+ all_users.intersection(&all_uses).cloned().collect()
+}
/*
* Convert forks back into loops right before codegen when a backend is not
* lowering a fork-join to vector / parallel code. Lowering fork-joins into
* sequential loops in LLVM is actually not entirely trivial, so it's easier to
* just do this transformation within Hercules IR.
*/
-pub fn unforkify(editor: &mut FunctionEditor, fork_join_map: &HashMap<NodeID, NodeID>) {
+pub fn unforkify(editor: &mut FunctionEditor, fork_join_map: &HashMap<NodeID, NodeID>, loop_tree: &LoopTree) {
let mut zero_cons_id = ConstantID::new(0);
let mut one_cons_id = ConstantID::new(0);
assert!(editor.edit(|mut edit| {
@@ -25,7 +91,18 @@ pub fn unforkify(editor: &mut FunctionEditor, fork_join_map: &HashMap<NodeID, No
// control insides of the fork-join should become the successor of the true
// projection node, and what was the use of the join should become a use of
// the new region.
- for (fork, join) in fork_join_map {
+ for l in loop_tree.bottom_up_loops().into_iter().rev() {
+ if !editor.node(l.0).is_fork() {
+ continue;
+ }
+
+ let fork = &l.0;
+ let join = &fork_join_map[&fork];
+
+ let fork_nodes = calculate_fork_nodes(editor, l.1, *fork, *join);
+
+
+ println!("fork: {:?}", fork);
let nodes = &editor.func().nodes;
let (fork_control, factors) = nodes[fork.idx()].try_fork().unwrap();
if factors.len() > 1 {
@@ -54,20 +131,34 @@ pub fn unforkify(editor: &mut FunctionEditor, fork_join_map: &HashMap<NodeID, No
let add_id = NodeID::new(num_nodes + 7);
let dc_id = NodeID::new(num_nodes + 8);
let neq_id = NodeID::new(num_nodes + 9);
- let phi_ids = (num_nodes + 10..num_nodes + 10 + reduces.len()).map(NodeID::new);
+
+ let guard_if_id = NodeID::new(num_nodes + 10);
+ let guard_join_id = NodeID::new(num_nodes + 11);
+ let guard_taken_proj_id = NodeID::new(num_nodes + 12);
+ let guard_skipped_proj_id = NodeID::new(num_nodes + 13);
+ let guard_cond_id = NodeID::new(num_nodes + 14);
+
+ let phi_ids = (num_nodes + 15..num_nodes + 15 + reduces.len()).map(NodeID::new);
+ let s = num_nodes + 15 + reduces.len();
+ let join_phi_ids = (s..s + reduces.len()).map(NodeID::new);
+
+ let guard_cond = Node::Binary { left: zero_id, right: dc_id, op: BinaryOperator::LT};
+ let guard_if = Node::If { control: fork_control, cond: guard_cond_id};
+ let guard_taken_proj = Node::Projection { control: guard_if_id, selection: 1 };
+ let guard_skipped_proj = Node::Projection { control: guard_if_id, selection: 0 };
+ let guard_join = Node::Region { preds: Box::new([
+ guard_skipped_proj_id,
+ proj_exit_id,
+ ])};
let region = Node::Region {
preds: Box::new([
- fork_control,
- if join_control == *fork {
- proj_back_id
- } else {
- join_control
- },
+ guard_taken_proj_id,
+ proj_back_id,
]),
};
let if_node = Node::If {
- control: region_id,
+ control: join_control,
cond: neq_id,
};
let proj_back = Node::Projection {
@@ -92,19 +183,23 @@ pub fn unforkify(editor: &mut FunctionEditor, fork_join_map: &HashMap<NodeID, No
let dc = Node::DynamicConstant { id: factors[0] };
let neq = Node::Binary {
op: BinaryOperator::NE,
- left: indvar_id,
+ left: add_id,
right: dc_id,
};
- let phis: Vec<_> = reduces
+ let (phis, join_phis): (Vec<_>, Vec<_>) = reduces
.iter()
.map(|reduce_id| {
let (_, init, reduct) = nodes[reduce_id.idx()].try_reduce().unwrap();
- Node::Phi {
+ (Node::Phi {
control: region_id,
data: Box::new([init, reduct]),
- }
+ },
+ Node::Phi {
+ control: guard_join_id,
+ data: Box::new([init, reduct])
+ })
})
- .collect();
+ .unzip();
editor.edit(|mut edit| {
assert_eq!(edit.add_node(region), region_id);
@@ -117,21 +212,34 @@ pub fn unforkify(editor: &mut FunctionEditor, fork_join_map: &HashMap<NodeID, No
assert_eq!(edit.add_node(add), add_id);
assert_eq!(edit.add_node(dc), dc_id);
assert_eq!(edit.add_node(neq), neq_id);
- for (phi_id, phi) in zip(phi_ids.clone(), phis) {
- assert_eq!(edit.add_node(phi), phi_id);
+ assert_eq!(edit.add_node(guard_if), guard_if_id);
+ assert_eq!(edit.add_node(guard_join), guard_join_id);
+ assert_eq!(edit.add_node(guard_taken_proj), guard_taken_proj_id);
+ assert_eq!(edit.add_node(guard_skipped_proj), guard_skipped_proj_id);
+ assert_eq!(edit.add_node(guard_cond), guard_cond_id);
+
+ for (phi_id, phi) in zip(phi_ids.clone(), &phis) {
+ assert_eq!(edit.add_node(phi.clone()), phi_id);
+ }
+ for (phi_id, phi) in zip(join_phi_ids.clone(), &join_phis) {
+ assert_eq!(edit.add_node(phi.clone()), phi_id);
}
- edit = edit.replace_all_uses(*fork, proj_back_id)?;
- edit = edit.replace_all_uses(*join, proj_exit_id)?;
+ edit = edit.replace_all_uses(*fork, region_id)?;
+ edit = edit.replace_all_uses_where(*join, guard_join_id, |usee| *usee != if_id)?;
edit.sub_edit(*fork, region_id);
edit.sub_edit(*join, if_id);
for tid in tids.iter() {
edit.sub_edit(*tid, indvar_id);
edit = edit.replace_all_uses(*tid, indvar_id)?;
}
- for (reduce, phi_id) in zip(reduces.iter(), phi_ids) {
+ for (((reduce, phi_id), phi), join_phi_id) in zip(reduces.iter(), phi_ids).zip(phis).zip(join_phi_ids) {
edit.sub_edit(*reduce, phi_id);
- edit = edit.replace_all_uses(*reduce, phi_id)?;
+ let Node::Phi { control, data } = phi else {panic!()};
+ edit = edit.replace_all_uses_where(*reduce, join_phi_id, |usee| !fork_nodes.contains(usee))?; //, |usee| *usee != *reduct)?;
+ edit = edit.replace_all_uses_where(*reduce, phi_id, |usee| fork_nodes.contains(usee) || *usee == data[1])?;
+ edit = edit.delete_node(*reduce)?;
+
}
edit = edit.delete_node(*fork)?;
@@ -139,9 +247,6 @@ pub fn unforkify(editor: &mut FunctionEditor, fork_join_map: &HashMap<NodeID, No
for tid in tids {
edit = edit.delete_node(tid)?;
}
- for reduce in reduces {
- edit = edit.delete_node(reduce)?;
- }
Ok(edit)
});
diff --git a/hercules_test/hercules_interpreter/src/interpreter.rs b/hercules_test/hercules_interpreter/src/interpreter.rs
index 52a004e1..978e7bdc 100644
--- a/hercules_test/hercules_interpreter/src/interpreter.rs
+++ b/hercules_test/hercules_interpreter/src/interpreter.rs
@@ -221,14 +221,17 @@ impl<'a> FunctionExecutionState<'a> {
for reduction in &reduces {
self.handle_reduction(&token, *reduction);
}
-
+
let thread_values = self.get_thread_factors(&token, join);
+ // println!("join for: {:?}", token);
// dbg!(thread_values.clone());
// This and_modify doesn't do aynthing??
self.join_counters
.entry((thread_values.clone(), join))
.and_modify(|v| *v -= 1);
+ // println!("join, thread_values : {:?}, {:?}", join, thread_values.clone());
+
if *self
.join_counters
.get(&(thread_values.clone(), join))
@@ -311,7 +314,7 @@ impl<'a> FunctionExecutionState<'a> {
Node::Phi { control: _, data: _ } => (*token
.phi_values
.get(&node)
- .expect("PANIC: Phi value not latched."))
+ .expect(&format!("PANIC: Phi {:?} value not latched.", node)))
.clone(),
Node::ThreadID { control, dimension } => {
// `control` is the fork that drives this node.
@@ -547,7 +550,12 @@ impl<'a> FunctionExecutionState<'a> {
.map(|extent| dyn_const_value(extent, &self.module.dynamic_constants, &self.dynamic_constant_params))
.collect();
// FIXME: This type may be wrong.
- vals.get(InterpreterVal::array_idx(&extents, &array_indices)).unwrap_or(&InterpreterVal::Undef(type_id)).clone()
+ let ret = vals.get(InterpreterVal::array_idx(&extents, &array_indices)).unwrap_or(&InterpreterVal::Undef(type_id)).clone();
+ if let InterpreterVal::Undef(_) = ret {
+ panic!("bad read!")
+ }
+ ret
+
} else {
panic!("PANIC: Position index on not an array")
}
@@ -652,7 +660,7 @@ impl<'a> FunctionExecutionState<'a> {
// panic!("multi-dimensional forks unimplemented")
// }
- let factors = factors.iter().map(|f| dyn_const_value(&f, &self.module.dynamic_constants, &self.dynamic_constant_params));
+ let factors = factors.iter().map(|f| dyn_const_value(&f, &self.module.dynamic_constants, &self.dynamic_constant_params)).rev();
let n_tokens: usize = factors.clone().product();
@@ -667,12 +675,13 @@ impl<'a> FunctionExecutionState<'a> {
// Token is at its correct sontrol succesor already.
// Add the new thread index.
+ let num_outer_dims = ctrl_token.thread_indicies.len();
for i in 0..n_tokens {
let mut temp = i;
let mut new_token = ctrl_token.clone(); // Copy map, curr, prev, etc.
for (j, dim) in factors.clone().enumerate().rev() {
- new_token.thread_indicies.push(temp % dim); // Stack of thread indicies
+ new_token.thread_indicies.insert(num_outer_dims, temp % dim); // Stack of thread indicies
temp /= dim;
}
tokens_to_add.push(new_token);
@@ -706,9 +715,10 @@ impl<'a> FunctionExecutionState<'a> {
self.initialize_reduction(&ctrl_token, reduction);
}
-
+ // println!("tokens_to_add: {:?}", tokens_to_add);
self.join_counters.insert((thread_factors, join), n_tokens);
+ tokens_to_add.reverse();
tokens_to_add
}
Node::Join { control: _ } => {
diff --git a/hercules_test/hercules_interpreter/src/lib.rs b/hercules_test/hercules_interpreter/src/lib.rs
index bc9ff312..7792f95a 100644
--- a/hercules_test/hercules_interpreter/src/lib.rs
+++ b/hercules_test/hercules_interpreter/src/lib.rs
@@ -36,7 +36,7 @@ pub fn into_interp_val(module: &Module, wrapper: InterpreterWrapper, target_ty_i
InterpreterWrapper::Array(array) => {
let ty = &module.types[target_ty_id.idx()];
- let ele_type = ty.try_element_type().expect("PANIC: Type ID");
+ let ele_type = ty.try_element_type().expect("PANIC: Invalid parameter type");
// unwrap -> map to rust type, check
let mut values = vec![];
diff --git a/hercules_test/hercules_interpreter/src/value.rs b/hercules_test/hercules_interpreter/src/value.rs
index 8f01a003..2ca043c2 100644
--- a/hercules_test/hercules_interpreter/src/value.rs
+++ b/hercules_test/hercules_interpreter/src/value.rs
@@ -155,7 +155,10 @@ impl<'a> InterpreterVal {
Constant::Float32(v) => Self::Float32(v),
Constant::Float64(v) => Self::Float64(v),
- Constant::Product(_, _) => todo!(),
+ Constant::Product(ref type_id, ref constant_ids) => {
+ // Self::Product((), ())
+ todo!()
+ }
Constant::Summation(_, _, _) => todo!(),
Constant::Array(type_id) => {
// TODO: This is currently only implemented for arrays of primitive types, implement zero initializers for other types.
diff --git a/hercules_test/hercules_tests/tests/fork_transform_tests.rs b/hercules_test/hercules_tests/tests/fork_transform_tests.rs
index 3d0a9cd2..903f4a94 100644
--- a/hercules_test/hercules_tests/tests/fork_transform_tests.rs
+++ b/hercules_test/hercules_tests/tests/fork_transform_tests.rs
@@ -2,10 +2,11 @@ use std::{env, fs::File, io::Read, path::Path};
use hercules_interpreter::*;
use hercules_ir::ID;
+use juno_scheduler::ir::*;
extern crate rand;
-use juno_scheduler::{default_schedule, ir::ScheduleStmt, run_schedule_on_hercules};
+use juno_scheduler::{default_schedule, run_schedule_on_hercules};
use rand::Rng;
use juno_scheduler::pass;
@@ -20,9 +21,11 @@ fn fission_simple1() {
println!("result: {:?}", result_1);
- let sched: Option<ScheduleStmt> = Some(default_schedule![
+ let sched = Some(default_schedule![
Verify,
- ForkFission,
+ Xdot,
+ Unforkify,
+ Xdot,
DCE,
Verify,
]);
@@ -34,71 +37,71 @@ fn fission_simple1() {
}
-#[test]
-fn fission_simple2() {
- let module = parse_file("../test_inputs/fork_transforms/fork_fission/simple2.hir");
- let dyn_consts = [10];
- let params = 2; // TODO: (@xrouth) fix macro to take no params as an option.
- let result_1 = interp_module!(module, 0, dyn_consts, 2);
+// #[test]
+// fn fission_simple2() {
+// let module = parse_file("../test_inputs/fork_transforms/fork_fission/simple2.hir");
+// let dyn_consts = [10];
+// let params = 2; // TODO: (@xrouth) fix macro to take no params as an option.
+// let result_1 = interp_module!(module, 0, dyn_consts, 2);
- println!("result: {:?}", result_1);
+// println!("result: {:?}", result_1);
- let sched: Option<ScheduleStmt> = Some(default_schedule![
- Verify,
- ForkFission,
- DCE,
- Verify,
- ]);
-
- let module = run_schedule_on_hercules(module, sched).unwrap();
- let result_2 = interp_module!(module, 0, dyn_consts, 2);
- println!("result: {:?}", result_2);
- assert_eq!(result_1, result_2)
-}
-
-#[ignore] // Wait
-#[test]
-fn fission_tricky() {
- // This either crashes or gives wrong result depending on the order which reduces are observed in.
- let module = parse_file("../test_inputs/fork_transforms/fork_fission/tricky.hir");
- let dyn_consts = [10];
- let params = 2; // TODO: (@xrouth) fix macro to take no params as an option.
- let result_1 = interp_module!(module, 0, dyn_consts, 2);
-
- println!("result: {:?}", result_1);
+// let sched: Option<ScheduleStmt> = Some(default_schedule![
+// Verify,
+// ForkFission,
+// DCE,
+// Verify,
+// ]);
+
+// let module = run_schedule_on_hercules(module, sched).unwrap();
+// let result_2 = interp_module!(module, 0, dyn_consts, 2);
+// println!("result: {:?}", result_2);
+// assert_eq!(result_1, result_2)
+// }
+
+// #[ignore] // Wait
+// #[test]
+// fn fission_tricky() {
+// // This either crashes or gives wrong result depending on the order which reduces are observed in.
+// let module = parse_file("../test_inputs/fork_transforms/fork_fission/tricky.hir");
+// let dyn_consts = [10];
+// let params = 2; // TODO: (@xrouth) fix macro to take no params as an option.
+// let result_1 = interp_module!(module, 0, dyn_consts, 2);
+
+// println!("result: {:?}", result_1);
- let sched: Option<ScheduleStmt> = Some(default_schedule![
- Verify,
- ForkFission,
- DCE,
- Verify,
- ]);
-
- let module = run_schedule_on_hercules(module, sched).unwrap();
- let result_2 = interp_module!(module, 0, dyn_consts, 2);
- println!("result: {:?}", result_2);
- assert_eq!(result_1, result_2)
-}
-
-#[ignore]
-#[test]
-fn inner_loop() {
- let module = parse_file("../test_inputs/fork_transforms/fork_fission/inner_loop.hir");
- let dyn_consts = [10, 20];
- let params = 2; // TODO: (@xrouth) fix macro to take no params as an option.
- let result_1 = interp_module!(module, 0, dyn_consts, 2);
-
- println!("result: {:?}", result_1);
+// let sched: Option<ScheduleStmt> = Some(default_schedule![
+// Verify,
+// ForkFission,
+// DCE,
+// Verify,
+// ]);
+
+// let module = run_schedule_on_hercules(module, sched).unwrap();
+// let result_2 = interp_module!(module, 0, dyn_consts, 2);
+// println!("result: {:?}", result_2);
+// assert_eq!(result_1, result_2)
+// }
+
+// #[ignore]
+// #[test]
+// fn inner_loop() {
+// let module = parse_file("../test_inputs/fork_transforms/fork_fission/inner_loop.hir");
+// let dyn_consts = [10, 20];
+// let params = 2; // TODO: (@xrouth) fix macro to take no params as an option.
+// let result_1 = interp_module!(module, 0, dyn_consts, 2);
+
+// println!("result: {:?}", result_1);
- let sched: Option<ScheduleStmt> = Some(default_schedule![
- Verify,
- ForkFission,
- DCE,
- Verify,
- ]);
-
- let module = run_schedule_on_hercules(module, sched).unwrap();
- let result_2 = interp_module!(module, 0, dyn_consts, 2);
- println!("result: {:?}", result_2);
- assert_eq!(result_1, result_2)
-}
\ No newline at end of file
+// let sched: Option<ScheduleStmt> = Some(default_schedule![
+// Verify,
+// ForkFission,
+// DCE,
+// Verify,
+// ]);
+
+// let module = run_schedule_on_hercules(module, sched).unwrap();
+// let result_2 = interp_module!(module, 0, dyn_consts, 2);
+// println!("result: {:?}", result_2);
+// assert_eq!(result_1, result_2)
+// }
\ No newline at end of file
diff --git a/hercules_test/hercules_tests/tests/forkify_tests.rs b/hercules_test/hercules_tests/tests/forkify_tests.rs
index cb43678d..dc89e597 100644
--- a/hercules_test/hercules_tests/tests/forkify_tests.rs
+++ b/hercules_test/hercules_tests/tests/forkify_tests.rs
@@ -35,6 +35,50 @@ fn loop_simple_iv() {
assert_eq!(result_1, result_2)
}
+#[test]
+fn merged_phi_cycle() {
+ let module = parse_file("../test_inputs/forkify/merged_phi_cycle.hir");
+ let dyn_consts = [10];
+ let params = 2; // TODO: (@xrouth) fix macro to take no params as an option.
+ let result_1 = interp_module!(module, 0, dyn_consts, 2);
+
+ println!("result: {:?}", result_1);
+
+ let sched: Option<ScheduleStmt> = Some(default_schedule![
+ Verify,
+ Xdot,
+ Verify,
+ ]);
+
+ let module = run_schedule_on_hercules(module, sched).unwrap();
+
+ let result_2 = interp_module!(module, 0, dyn_consts, 2);
+ println!("result: {:?}", result_2);
+ assert_eq!(result_1, result_2)
+}
+
+#[test]
+fn split_phi_cycle() {
+ let module = parse_file("../test_inputs/forkify/split_phi_cycle.hir");
+ let dyn_consts = [10];
+ let params = 2; // TODO: (@xrouth) fix macro to take no params as an option.
+ let result_1 = interp_module!(module, 0, dyn_consts, 2);
+
+ println!("result: {:?}", result_1);
+
+ let sched: Option<ScheduleStmt> = Some(default_schedule![
+ Verify,
+ Xdot,
+ Verify,
+ ]);
+
+ let module = run_schedule_on_hercules(module, sched).unwrap();
+
+ let result_2 = interp_module!(module, 0, dyn_consts, 2);
+ println!("result: {:?}", result_2);
+ assert_eq!(result_1, result_2)
+}
+
#[test]
fn loop_sum() {
let module = parse_file("../test_inputs/forkify/loop_sum.hir");
diff --git a/hercules_test/hercules_tests/tests/interpreter_tests.rs b/hercules_test/hercules_tests/tests/interpreter_tests.rs
index 5f04d398..25f1b8f2 100644
--- a/hercules_test/hercules_tests/tests/interpreter_tests.rs
+++ b/hercules_test/hercules_tests/tests/interpreter_tests.rs
@@ -18,11 +18,53 @@ fn twodeefork() {
let d2 = 3;
let dyn_consts = [d1, d2];
let result_1 = interp_module!(module, 0, dyn_consts, 2);
+
+ let sched = Some(default_schedule![
+ Verify,
+ ForkSplit,
+ Xdot,
+ Unforkify,
+ Xdot,
+ DCE,
+ Verify,
+ ]);
+
+ let module = run_schedule_on_hercules(module, sched).unwrap();
+ let result_2 = interp_module!(module, 0, dyn_consts, 2);
+
let res = (d1 as i32 * d2 as i32);
let result_2: InterpreterWrapper = res.into();
println!("result: {:?}", result_1); // Should be d1 * d2.
}
+#[test]
+fn threedee() {
+ let module = parse_file("../test_inputs/3d_fork.hir");
+ let d1 = 2;
+ let d2 = 3;
+ let d3 = 5;
+ let dyn_consts = [d1, d2, 5];
+ let result_1 = interp_module!(module, 0, dyn_consts, 2);
+
+ let sched = Some(default_schedule![
+ Verify,
+ ForkSplit,
+ Xdot,
+ Unforkify,
+ Xdot,
+ DCE,
+ Verify,
+ ]);
+
+ let module = run_schedule_on_hercules(module, sched).unwrap();
+ let result_2 = interp_module!(module, 0, dyn_consts, 2);
+
+ let res = (d1 as i32 * d2 as i32 * d3 as i32);
+ let result_2: InterpreterWrapper = res.into();
+ println!("result: {:?}", result_1); // Should be d1 * d2.
+}
+
+
#[test]
fn fivedeefork() {
let module = parse_file("../test_inputs/5d_fork.hir");
diff --git a/hercules_test/hercules_tests/tests/loop_tests.rs b/hercules_test/hercules_tests/tests/loop_tests.rs
index f1d0ad50..19769b5d 100644
--- a/hercules_test/hercules_tests/tests/loop_tests.rs
+++ b/hercules_test/hercules_tests/tests/loop_tests.rs
@@ -7,6 +7,7 @@ use juno_scheduler::pass;
extern crate rand;
use juno_scheduler::{default_schedule, run_schedule_on_hercules};
+use rand::random;
use rand::Rng;
// Tests canonicalization
@@ -34,7 +35,13 @@ fn alternate_bounds_use_after_loop_no_tid() {
println!("result: {:?}", result_1);
- let module = run_schedule_on_hercules(module, None).unwrap();
+ let schedule = default_schedule![
+ Xdot,
+ Forkify,
+ Xdot
+ ];
+
+ let module = run_schedule_on_hercules(module, Some(schedule)).unwrap();
let result_2 = interp_module!(module, 0,dyn_consts, 3);
println!("{:?}", result_1);
@@ -49,13 +56,44 @@ fn alternate_bounds_use_after_loop() {
let len = 4;
let dyn_consts = [len];
- let a = vec![3, 4, 5, 6, 7];
+ let a = vec![3, 4, 5, 6];
let module = parse_file("../test_inputs/loop_analysis/alternate_bounds_use_after_loop.hir");
let result_1 = interp_module!(module, 0,dyn_consts, a.clone());
println!("result: {:?}", result_1);
- let module = run_schedule_on_hercules(module, None).unwrap();
+ let schedule = Some(default_schedule![
+ Xdot,
+ Forkify,
+ Xdot
+ ]);
+
+ let module = run_schedule_on_hercules(module, schedule).unwrap();
+
+ let result_2 = interp_module!(module, 0,dyn_consts, a.clone());
+ //println!("{:?}", result_1);
+ println!("{:?}", result_2);
+
+ assert_eq!(result_1, result_2);
+}
+
+// Test canonicalization
+#[test]
+fn alternate_bounds_use_after_loop2() {
+ let len = 4;
+ let dyn_consts = [len];
+
+ let a = vec![3, 4, 5, 6];
+ let module = parse_file("../test_inputs/loop_analysis/alternate_bounds_use_after_loop2.hir");
+ let result_1 = interp_module!(module, 0,dyn_consts, a.clone());
+
+ println!("result: {:?}", result_1);
+
+ let schedule = Some(default_schedule![
+ Xdot,
+ ]);
+
+ let module = run_schedule_on_hercules(module, schedule).unwrap();
let result_2 = interp_module!(module, 0,dyn_consts, a.clone());
//println!("{:?}", result_1);
@@ -64,6 +102,35 @@ fn alternate_bounds_use_after_loop() {
assert_eq!(result_1, result_2);
}
+// Test canonicalization
+#[test]
+fn do_while_separate_body() {
+ let len = 2;
+ let dyn_consts = [len];
+
+ let a = vec![3, 4, 5, 6];
+ let module = parse_file("../test_inputs/loop_analysis/do_while_separate_body2.hir");
+ let result_1 = interp_module!(module, 0, dyn_consts, 2i32);
+
+ println!("result: {:?}", result_1);
+
+ let schedule = Some(default_schedule![
+ Xdot,
+ PhiElim,
+ Xdot,
+ Forkify,
+ Xdot
+ ]);
+
+ let module = run_schedule_on_hercules(module, schedule).unwrap();
+
+ let result_2 = interp_module!(module, 0, dyn_consts, 2i32);
+ //println!("{:?}", result_1);
+ println!("{:?}", result_2);
+
+ assert_eq!(result_1, result_2);
+}
+
#[test]
fn alternate_bounds_internal_control() {
let len = 4;
@@ -74,7 +141,15 @@ fn alternate_bounds_internal_control() {
println!("result: {:?}", result_1);
- let module = run_schedule_on_hercules(module, None).unwrap();
+ let schedule = Some(default_schedule![
+ Xdot,
+ PhiElim,
+ Xdot,
+ Forkify,
+ Xdot
+ ]);
+
+ let module = run_schedule_on_hercules(module, schedule).unwrap();
let result_2 = interp_module!(module, 0,dyn_consts, 3);
println!("{:?}", result_1);
@@ -85,7 +160,7 @@ fn alternate_bounds_internal_control() {
#[test]
fn alternate_bounds_internal_control2() {
- let len = 4;
+ let len = 2;
let dyn_consts = [len];
let module = parse_file("../test_inputs/loop_analysis/alternate_bounds_internal_control2.hir");
@@ -93,7 +168,15 @@ fn alternate_bounds_internal_control2() {
println!("result: {:?}", result_1);
- let module = run_schedule_on_hercules(module, None).unwrap();
+ let schedule = Some(default_schedule![
+ Xdot,
+ PhiElim,
+ Xdot,
+ Forkify,
+ Xdot
+ ]);
+
+ let module = run_schedule_on_hercules(module, schedule).unwrap();
let result_2 = interp_module!(module, 0,dyn_consts, 3);
println!("{:?}", result_1);
@@ -277,49 +360,107 @@ fn implicit_clone_pipeline() {
}
#[test]
-fn matmul_pipeline() {
- let len = 1;
- let dyn_consts = [2, 2, 2];
- let m1 = vec![1, 2, 3, 4];
- let m2 = vec![5, 6, 7, 8];
-
- // FIXME: This path should not leave the crate
- let module = parse_module_from_hbin("../../juno_samples/matmul/matmul.hbin");
- let result_1 = interp_module!(module, 0,dyn_consts, m1.clone(), m2.clone());
-
- println!("result: {:?}", result_1);
-
- let module = run_schedule_on_hercules(module, None).unwrap();
-
- let result_2 = interp_module!(module, 0,dyn_consts, m1.clone(), m2.clone());
- assert_eq!(result_1, result_2);
-
- // 1st (innermost) Loop Canonicalization
- let module = run_schedule_on_hercules(module, None).unwrap();
-
- let result_2 = interp_module!(module, 0,dyn_consts, m1.clone(), m2.clone());
- assert_eq!(result_1, result_2);
- // -------------------
- let module = run_schedule_on_hercules(module, None).unwrap();
-
- let result_2 = interp_module!(module, 0,dyn_consts, m1.clone(), m2.clone());
- assert_eq!(result_1, result_2);
+fn look_at_local() {
+ const I: usize = 4;
+ const J: usize = 4;
+ const K: usize = 4;
+ let a: Vec<i32> = (0..I * J).map(|_| random::<i32>() % 100).collect();
+ let b: Vec<i32> = (0..J * K).map(|_| random::<i32>() % 100).collect();
+ let dyn_consts = [I, J, K];
+ let mut correct_c: Box<[i32]> = (0..I * K).map(|_| 0).collect();
+ for i in 0..I {
+ for k in 0..K {
+ for j in 0..J {
+ correct_c[i * K + k] += a[i * J + j] * b[j * K + k];
+ }
+ }
+ }
+
+ let module = parse_module_from_hbin("/home/xavierrouth/dev/hercules/hercules_test/hercules_tests/save_me.hbin");
+
+ let schedule = Some(default_schedule![
+ Xdot,
+ ]);
- // -------
- let module = run_schedule_on_hercules(module, None).unwrap();
+ let result_1 = interp_module!(module, 0, dyn_consts, a.clone(), b.clone());
- let result_2 = interp_module!(module, 0,dyn_consts, m1.clone(), m2.clone());
- assert_eq!(result_1, result_2);
+ let module = run_schedule_on_hercules(module.clone(), schedule).unwrap();
- println!("before failture: {:?}", result_2);
+ let schedule = Some(default_schedule![
+ Xdot,
+ Unforkify,
+ Verify,
+ Xdot,
+ ]);
+
+ let module = run_schedule_on_hercules(module.clone(), schedule).unwrap();
- // ========================
- // -----
- let module = run_schedule_on_hercules(module, None).unwrap();
+ let result_2 = interp_module!(module, 0, dyn_consts, a.clone(), b.clone());
+
+ println!("golden: {:?}", correct_c);
+ println!("result: {:?}", result_2);
+}
+#[test]
+fn matmul_pipeline() {
+ let len = 1;
+
+ const I: usize = 4;
+ const J: usize = 4;
+ const K: usize = 4;
+ let a: Vec<i32> = (0..I * J).map(|_| random::<i32>() % 100).collect();
+ let b: Vec<i32> = (0..J * K).map(|_| random::<i32>() % 100).collect();
+ let dyn_consts = [I, J, K];
- let result_2 = interp_module!(module, 0,dyn_consts, m1.clone(), m2.clone());
- assert_eq!(result_1, result_2);
+ // FIXME: This path should not leave the crate
+ let mut module = parse_module_from_hbin("../../juno_samples/matmul/out.hbin");
+ //
+ let result_1 = interp_module!(module, 0, dyn_consts, a.clone(), b.clone());
+
+ let mut correct_c: Box<[i32]> = (0..I * K).map(|_| 0).collect();
+ for i in 0..I {
+ for k in 0..K {
+ for j in 0..J {
+ correct_c[i * K + k] += a[i * J + j] * b[j * K + k];
+ }
+ }
+ }
+
+ println!("golden: {:?}", correct_c);
+ println!("result: {:?}", result_1);
- println!("final: {:?}", result_2);
+
+ let schedule = Some(default_schedule![
+ Xdot,
+ ForkSplit,
+ Unforkify,
+ Verify,
+ Xdot,
+ ]);
+
+ module = run_schedule_on_hercules(module.clone(), schedule).unwrap();
+ let result_2 = interp_module!(module, 0, dyn_consts, a.clone(), b.clone());
+ assert_eq!(result_1, result_2);
+
+ let serialize = Some(default_schedule![
+ Serialize
+ ]);
+
+ module = run_schedule_on_hercules(module, serialize).unwrap();
+ println!("result: {:?}", result_2);
+
+ // Verify,
+ // GVN,
+ // DCE,
+ // AutoOutline,
+ // InterproceduralSROA,
+ // SROA,
+ // InferSchedules,
+ // DCE,
+ // GCM,
+ // DCE,
+ // PhiElim,
+ // FloatCollections,
+ // GCM,
+ // Xdot
}
\ No newline at end of file
diff --git a/hercules_test/test_inputs/3d_fork.hir b/hercules_test/test_inputs/3d_fork.hir
new file mode 100644
index 00000000..746fd902
--- /dev/null
+++ b/hercules_test/test_inputs/3d_fork.hir
@@ -0,0 +1,8 @@
+fn twodeefork<3>(x: i32) -> i32
+ zero = constant(i32, 0)
+ one = constant(i32, 1)
+ f = fork(start, #2, #1, #0)
+ j = join(f)
+ add = add(r, one)
+ r = reduce(j, zero, add)
+ z = return(j, r)
\ No newline at end of file
diff --git a/hercules_test/test_inputs/forkify/merged_phi_cycle.hir b/hercules_test/test_inputs/forkify/merged_phi_cycle.hir
new file mode 100644
index 00000000..cee473a0
--- /dev/null
+++ b/hercules_test/test_inputs/forkify/merged_phi_cycle.hir
@@ -0,0 +1,18 @@
+fn sum<1>(a: i32) -> u64
+ zero_idx = constant(u64, 0)
+ one_idx = constant(u64, 1)
+ two = constant(u64, 2)
+ bound = dynamic_constant(#0)
+ loop = region(start, if_true)
+ idx = phi(loop, zero_idx, idx_inc)
+ idx_inc = add(idx, one_idx)
+ first_red = phi(loop, zero_idx, first_red_add)
+ second_red = phi(loop, zero_idx, first_red_add_2)
+ first_red_add = add(first_red, idx)
+ second_red_add_1 = add(first_red, idx)
+ second_red_add_2 = add(first_red_add, two)
+ in_bounds = lt(idx_inc, bound)
+ if = if(loop, in_bounds)
+ if_false = projection(if, 0)
+ if_true = projection(if, 1)
+ r = return(if_false, first_red_add_2)
\ No newline at end of file
diff --git a/hercules_test/test_inputs/forkify/split_phi_cycle.hir b/hercules_test/test_inputs/forkify/split_phi_cycle.hir
new file mode 100644
index 00000000..96de73c8
--- /dev/null
+++ b/hercules_test/test_inputs/forkify/split_phi_cycle.hir
@@ -0,0 +1,16 @@
+fn sum<1>(a: i32) -> u64
+ zero_idx = constant(u64, 0)
+ one_idx = constant(u64, 1)
+ two = constant(u64, 2)
+ bound = dynamic_constant(#0)
+ loop = region(start, if_true)
+ idx = phi(loop, zero_idx, idx_inc)
+ idx_inc = add(idx, one_idx)
+ first_red = phi(loop, zero_idx, first_red_add_2)
+ first_red_add = add(first_red, idx)
+ first_red_add_2 = add(first_red_add, two)
+ in_bounds = lt(idx_inc, bound)
+ if = if(loop, in_bounds)
+ if_false = projection(if, 0)
+ if_true = projection(if, 1)
+ r = return(if_false, first_red_add_2)
\ No newline at end of file
diff --git a/hercules_test/test_inputs/loop_analysis/alternate_bounds_use_after_loop2.hir b/hercules_test/test_inputs/loop_analysis/alternate_bounds_use_after_loop2.hir
new file mode 100644
index 00000000..760ae5ad
--- /dev/null
+++ b/hercules_test/test_inputs/loop_analysis/alternate_bounds_use_after_loop2.hir
@@ -0,0 +1,21 @@
+fn sum<1>(a: array(i32, #0)) -> i32
+ zero_idx = constant(u64, 0)
+ one_idx = constant(u64, 1)
+ zero_inc = constant(i32, 0)
+ ten = constant(i32, 10)
+ three = constant(i32, 3)
+ bound = dynamic_constant(#0)
+ loop = region(start, if_true)
+ idx = phi(loop, zero_idx, idx_inc)
+ idx_inc = add(idx, one_idx)
+ red = phi(loop, zero_inc, red_add)
+ read = read(a, position(idx_inc))
+ red_add = add(red, read)
+ in_bounds = lt(idx_inc, bound)
+ if = if(loop, in_bounds)
+ if_false = projection(if, 0)
+ if_true = projection(if, 1)
+ plus_ten = add(red, ten)
+ mult = mul(read, three)
+ final = add(plus_ten, mult)
+ r = return(if_false, final)
\ No newline at end of file
diff --git a/hercules_test/test_inputs/loop_analysis/do_while_separate_body.hir b/hercules_test/test_inputs/loop_analysis/do_while_separate_body.hir
new file mode 100644
index 00000000..42269040
--- /dev/null
+++ b/hercules_test/test_inputs/loop_analysis/do_while_separate_body.hir
@@ -0,0 +1,16 @@
+fn sum<1>(a: i32) -> u64
+ zero_idx = constant(u64, 0)
+ one_idx = constant(u64, 1)
+ bound = dynamic_constant(#0)
+ loop = region(start, if_true)
+ inner_region = region(loop)
+ inner_red = phi(inner_region, red_add)
+ idx = phi(loop, zero_idx, idx_inc)
+ idx_inc = add(idx, one_idx)
+ outer_red = phi(loop, zero_idx, inner_red)
+ red_add = add(outer_red, idx)
+ in_bounds = lt(idx_inc, bound)
+ if = if(inner_region, in_bounds)
+ if_false = projection(if, 0)
+ if_true = projection(if, 1)
+ r = return(if_false, inner_red)
\ No newline at end of file
diff --git a/hercules_test/test_inputs/loop_analysis/do_while_separate_body2.hir b/hercules_test/test_inputs/loop_analysis/do_while_separate_body2.hir
new file mode 100644
index 00000000..a751952d
--- /dev/null
+++ b/hercules_test/test_inputs/loop_analysis/do_while_separate_body2.hir
@@ -0,0 +1,18 @@
+fn sum<1>(a: i32) -> u64
+ zero_idx = constant(u64, 0)
+ one_idx = constant(u64, 1)
+ two = constant(u64, 1)
+ bound = dynamic_constant(#0)
+ loop = region(start, if_true)
+ inner_region = region(loop)
+ inner_red = phi(inner_region, red_mul)
+ idx = phi(loop, zero_idx, idx_inc)
+ idx_inc = add(idx, one_idx)
+ outer_red = phi(loop, zero_idx, inner_red)
+ red_add = add(outer_red, idx)
+ red_mul = mul(red_add, idx)
+ in_bounds = lt(idx_inc, bound)
+ if = if(inner_region, in_bounds)
+ if_false = projection(if, 0)
+ if_true = projection(if, 1)
+ r = return(if_false, inner_red)
\ No newline at end of file
diff --git a/juno_scheduler/src/default.rs b/juno_scheduler/src/default.rs
index faa576cf..49ced72b 100644
--- a/juno_scheduler/src/default.rs
+++ b/juno_scheduler/src/default.rs
@@ -62,12 +62,6 @@ pub fn default_schedule() -> ScheduleStmt {
DCE,
GVN,
DCE,
- Serialize,
- LoopCanonicalization,
- Forkify,
- ForkGuardElim,
- Forkify,
- ForkGuardElim,
Forkify,
ForkGuardElim,
DCE,
diff --git a/juno_scheduler/src/pm.rs b/juno_scheduler/src/pm.rs
index ce1e95f1..191fb8eb 100644
--- a/juno_scheduler/src/pm.rs
+++ b/juno_scheduler/src/pm.rs
@@ -5,7 +5,6 @@ use hercules_ir::*;
use serde::{Deserialize, Serialize};
use hercules_opt::fork_guard_elim;
use hercules_opt::forkify;
-use hercules_opt::loop_canonicalization;
use hercules_opt::FunctionEditor;
use hercules_opt::{
ccp, collapse_returns, crc, dce, dumb_outline, ensure_between_control_flow, float_collections,
@@ -1567,16 +1566,20 @@ fn run_pass(
Pass::Unforkify => {
assert!(args.is_empty());
pm.make_fork_join_maps();
+ pm.make_loops();
+
let fork_join_maps = pm.fork_join_maps.take().unwrap();
+ let loops = pm.loops.take().unwrap();
- for (func, fork_join_map) in build_selection(pm, selection)
+ for ((func, fork_join_map), loop_tree) in build_selection(pm, selection)
.into_iter()
.zip(fork_join_maps.iter())
+ .zip(loops.iter())
{
let Some(mut func) = func else {
continue;
};
- unforkify(&mut func, fork_join_map);
+ unforkify(&mut func, fork_join_map, loop_tree);
changed |= func.modified();
}
pm.delete_gravestones();
@@ -1668,7 +1671,7 @@ fn run_pass(
let Some(mut func) = func else {
continue;
};
- changed |= loop_canonicalization(&mut func, control_subgraph, fork_join_map, loop_nest, typing);
+ // changed |= loop_canonicalization(&mut func, control_subgraph, fork_join_map, loop_nest, typing);
// func.modified();
}
pm.delete_gravestones();
--
GitLab
From db292705dd6ab42a4b50cd9d36e27079b89a8ba2 Mon Sep 17 00:00:00 2001
From: Xavier Routh <xrouth2@illinois.edu>
Date: Tue, 28 Jan 2025 21:24:28 -0600
Subject: [PATCH 45/68] interpreter + forkify fixes
---
hercules_ir/src/ir.rs | 20 ++++
hercules_opt/src/fork_guard_elim.rs | 4 +-
hercules_opt/src/fork_transforms.rs | 20 ++--
hercules_opt/src/forkify.rs | 40 ++++----
hercules_opt/src/ivar.rs | 10 +-
.../hercules_interpreter/src/interpreter.rs | 35 +++++--
hercules_test/hercules_tests/matmul.hbin | Bin 0 -> 1456 bytes
hercules_test/hercules_tests/out.hbin | Bin 0 -> 1033 bytes
hercules_test/hercules_tests/save_me.hbin | Bin 0 -> 1141 bytes
.../hercules_tests/tests/forkify_tests.rs | 25 +++++
.../hercules_tests/tests/loop_tests.rs | 86 ++++++++++++------
juno_scheduler/src/compile.rs | 1 +
juno_scheduler/src/ir.rs | 1 +
juno_scheduler/src/pm.rs | 26 +++++-
14 files changed, 198 insertions(+), 70 deletions(-)
create mode 100644 hercules_test/hercules_tests/matmul.hbin
create mode 100644 hercules_test/hercules_tests/out.hbin
create mode 100644 hercules_test/hercules_tests/save_me.hbin
diff --git a/hercules_ir/src/ir.rs b/hercules_ir/src/ir.rs
index 7b7acea5..6560e869 100644
--- a/hercules_ir/src/ir.rs
+++ b/hercules_ir/src/ir.rs
@@ -1352,6 +1352,26 @@ impl Node {
}
}
+ pub fn is_zero_dc(&self, dynamic_constants: &Vec<DynamicConstant>) -> bool {
+ if let Node::DynamicConstant { id } = self
+ && dynamic_constants[id.idx()].try_constant() == Some(0)
+ {
+ true
+ } else {
+ false
+ }
+ }
+
+ pub fn is_one_dc(&self, dynamic_constants: &Vec<DynamicConstant>) -> bool {
+ if let Node::DynamicConstant { id } = self
+ && dynamic_constants[id.idx()].try_constant() == Some(1)
+ {
+ true
+ } else {
+ false
+ }
+ }
+
pub fn is_one_constant(&self, constants: &Vec<Constant>) -> bool {
if let Node::Constant { id } = self
&& constants[id.idx()].is_one()
diff --git a/hercules_opt/src/fork_guard_elim.rs b/hercules_opt/src/fork_guard_elim.rs
index a1962595..8f6a98c4 100644
--- a/hercules_opt/src/fork_guard_elim.rs
+++ b/hercules_opt/src/fork_guard_elim.rs
@@ -128,7 +128,7 @@ fn guarded_fork(
return None
}
// Match Zero
- if !function.nodes[pattern_zero.idx()].is_zero_constant(&editor.get_constants()) {
+ if !(function.nodes[pattern_zero.idx()].is_zero_constant(&editor.get_constants()) || editor.node(pattern_zero).is_zero_dc(&editor.get_dynamic_constants())) {
return None
}
@@ -162,7 +162,7 @@ fn guarded_fork(
return None
}
// Match Zero
- if !function.nodes[pattern_zero.idx()].is_zero_constant(&editor.get_constants()) {
+ if !(function.nodes[pattern_zero.idx()].is_zero_constant(&editor.get_constants()) || editor.node(pattern_zero).is_zero_dc(&editor.get_dynamic_constants())) {
return None
}
diff --git a/hercules_opt/src/fork_transforms.rs b/hercules_opt/src/fork_transforms.rs
index 19322c01..79fedcdc 100644
--- a/hercules_opt/src/fork_transforms.rs
+++ b/hercules_opt/src/fork_transforms.rs
@@ -3,6 +3,8 @@ use std::ops::Sub;
extern crate hercules_ir;
extern crate bimap;
+use itertools::Itertools;
+
use self::bimap::BiMap;
use self::hercules_ir::LoopTree;
@@ -369,21 +371,24 @@ pub fn fork_coalesce(
editor: &mut FunctionEditor,
loops: &LoopTree,
fork_join_map: &HashMap<NodeID, NodeID>,
- reduce_cycles: &HashMap<NodeID, HashSet<NodeID>>,
-) -> () {
+) -> bool {
let fork_joins = loops
.bottom_up_loops()
.into_iter()
- .filter(|(k, _)| editor.func().nodes[k.idx()].is_fork());
+ .filter_map(|(k, _)| if editor.func().nodes[k.idx()].is_fork() {Some(k)} else {None});
let fork_joins: Vec<_> = fork_joins.collect();
+ // FIXME: postorder traversal.
- if fork_joins.len() > 1 {
- let inner = fork_joins[0].0;
- let outer = fork_joins[1].0;
- fork_coalesce_helper(editor, outer, inner, fork_join_map, reduce_cycles);
+ // Fixme: This could give us two forks that aren't actually ancestors / related, but then the helper will just retunr false early.
+ //for (inner, outer) in fork_joins.windows(2) {
+ for (inner, outer) in fork_joins.iter().cartesian_product(fork_joins.iter()) {
+ if fork_coalesce_helper(editor, *outer, *inner, fork_join_map) {
+ return true;
+ }
}
+ return false;
}
/** Opposite of fork split, takes two fork-joins
@@ -394,7 +399,6 @@ pub fn fork_coalesce_helper(
outer_fork: NodeID,
inner_fork: NodeID,
fork_join_map: &HashMap<NodeID, NodeID>,
- reduce_cycles: &HashMap<NodeID, HashSet<NodeID>>,
) -> bool {
// Check that all reduces in the outer fork are in *simple* cycles with a unique reduce of the inner fork.
diff --git a/hercules_opt/src/forkify.rs b/hercules_opt/src/forkify.rs
index 36bedc88..5d277a73 100644
--- a/hercules_opt/src/forkify.rs
+++ b/hercules_opt/src/forkify.rs
@@ -420,15 +420,19 @@ pub fn analyze_phis<'a>(editor: &'a FunctionEditor, natural_loop: &'a Loop, phis
// External Phi
if let Node::Phi { control, data } = data {
- if !natural_loop.control[control.idx()] {
+ if *control != natural_loop.header {
return true;
}
+ // if !natural_loop.control[control.idx()] {
+ // return true;
+ // }
}
// External Reduce
if let Node::Reduce { control, init, reduct} = data {
- if !natural_loop.control[control.idx()] {
- return true;
- }
+ // if !natural_loop.control[control.idx()] {
+ // return true;
+ // }
+ return true;
}
// External Control
@@ -441,16 +445,18 @@ pub fn analyze_phis<'a>(editor: &'a FunctionEditor, natural_loop: &'a Loop, phis
}).collect();
// TODO: We may need to stop on exiting the loop for looking for data cycles.
- let uses = walk_all_uses_stop_on(*phi, editor, stop_on.clone()).filter(|node|
- {
- // Get rid of nodes in stop_on
- !stop_on.contains(node)
- });
- let users = walk_all_users_stop_on(*phi, editor, stop_on.clone()).filter(|node|
- {
- // Get rid of nodes in stop_on
- !stop_on.contains(node)
- });
+ let uses = walk_all_uses_stop_on(*phi, editor, stop_on.clone());
+ // .filter(|node|
+ // {
+ // // Get rid of nodes in stop_on
+ // !stop_on.contains(node)
+ // });
+ let users = walk_all_users_stop_on(*phi, editor, stop_on.clone());
+ // .filter(|node|
+ // {
+ // // Get rid of nodes in stop_on
+ // !stop_on.contains(node)
+ // });
let set1: HashSet<_> = HashSet::from_iter(uses);
let set2: HashSet<_> = HashSet::from_iter(users);
@@ -461,14 +467,16 @@ pub fn analyze_phis<'a>(editor: &'a FunctionEditor, natural_loop: &'a Loop, phis
// we use `phis` because this phi can actually contain the loop iv and its fine.
if set1.clone().iter().any(|node| phis.contains(node) && node != phi) {
LoopPHI::LoopDependant(*phi)
- } // If this phi is used by other phis in the loop
+ }
+ // If this phi is used by other phis in the loop, FIXME: include reduces, they are the same as phis right?
+ // DOn't go through nodes that would become a reduction.
else if set2.clone().iter().any(|node|
editor.func().nodes[node.idx()].is_phi()
&& node != phi
&& natural_loop.control[editor.func().nodes[node.idx()].try_phi().unwrap().0.idx()] ) {
LoopPHI::UsedByDependant(*phi)
}
- else if intersection.clone().iter().any(|node| node == phi) {
+ else if intersection.clone().iter().any(|node| true) {
let continue_idx = editor.get_uses(natural_loop.header)
.position(|node| natural_loop.control[node.idx()])
.unwrap();
diff --git a/hercules_opt/src/ivar.rs b/hercules_opt/src/ivar.rs
index b059c6bd..893cf763 100644
--- a/hercules_opt/src/ivar.rs
+++ b/hercules_opt/src/ivar.rs
@@ -457,9 +457,9 @@ pub fn has_const_fields(editor: &FunctionEditor, ivar: InductionVariable) -> boo
pub fn has_canonical_iv<'a>(editor: &FunctionEditor, l: &Loop, ivs: &'a[InductionVariable]) -> Option<&'a InductionVariable> {
ivs.iter().find(|iv| { match iv {
InductionVariable::Basic { node, initializer, update, final_value } => {
- editor.node(initializer).is_zero_constant(&editor.get_constants())
- && editor.node(update).is_one_constant(&editor.get_constants())
- && final_value.map(|val| editor.node(val).is_constant() || editor.node(val).is_dynamic_constant()).is_some()
+ (editor.node(initializer).is_zero_constant(&editor.get_constants()) || editor.node(initializer).is_zero_dc(&editor.get_dynamic_constants()))
+ && (editor.node(update).is_one_constant(&editor.get_constants()) || editor.node(update).is_one_dc(&editor.get_dynamic_constants()))
+ && (final_value.map(|val| editor.node(val).is_constant() || editor.node(val).is_dynamic_constant()).is_some())
}
InductionVariable::SCEV(node_id) => false,
}
@@ -524,7 +524,7 @@ pub fn compute_induction_vars(function: &Function, l: &Loop, loop_variance: &Loo
for bop in [BinaryOperator::Add] { //, BinaryOperator::Mul, BinaryOperator::Sub] {
if let Some((a, b)) = node.try_binary(bop) {
let iv = [(a, b), (b, a)].iter().find_map(|(pattern_phi, pattern_const)| {
- if *pattern_phi == phi_id && function.nodes[pattern_const.idx()].is_constant() {
+ if *pattern_phi == phi_id && function.nodes[pattern_const.idx()].is_constant() || function.nodes[pattern_const.idx()].is_dynamic_constant() {
return Some(InductionVariable::Basic {
node: phi_id,
initializer: initializer_id,
@@ -602,7 +602,7 @@ pub fn compute_iv_ranges(editor: &FunctionEditor, l: &Loop,
else if let Node::Binary { left: inner_left, right: inner_right, op: inner_op } = editor.node(left) {
let pattern = [(inner_left, inner_right), (inner_right, inner_left)].iter().find_map(|(pattern_iv, pattern_constant)|
{
- if iv.phi()== **pattern_iv && (editor.node(*pattern_constant).is_constant()) {
+ if iv.phi()== **pattern_iv && (editor.node(*pattern_constant).is_constant() || editor.node(*pattern_constant).is_dynamic_constant()) {
// FIXME: pattern_constant can be anything >= loop_update expression,
let update = match iv {
InductionVariable::Basic { node, initializer, update, final_value } => update,
diff --git a/hercules_test/hercules_interpreter/src/interpreter.rs b/hercules_test/hercules_interpreter/src/interpreter.rs
index 978e7bdc..3d73eb9f 100644
--- a/hercules_test/hercules_interpreter/src/interpreter.rs
+++ b/hercules_test/hercules_interpreter/src/interpreter.rs
@@ -230,8 +230,9 @@ impl<'a> FunctionExecutionState<'a> {
.entry((thread_values.clone(), join))
.and_modify(|v| *v -= 1);
- // println!("join, thread_values : {:?}, {:?}", join, thread_values.clone());
-
+ if VERBOSE {
+ println!("join, thread_values : {:?}, {:?}", join, thread_values.clone());
+ }
if *self
.join_counters
.get(&(thread_values.clone(), join))
@@ -240,7 +241,7 @@ impl<'a> FunctionExecutionState<'a> {
{
let curr = token.curr;
token.prev = curr;
- token.thread_indicies.pop(); // Get rid of this thread index.
+ token.thread_indicies.truncate(thread_values.len()); // Get rid of this thread index.
token.curr = self.get_control_subgraph().succs(join).next().unwrap();
Some(token)
} else {
@@ -287,7 +288,7 @@ impl<'a> FunctionExecutionState<'a> {
let init = self.handle_data(&token, *init);
if VERBOSE {
- println!("reduction {:?} initailized to: {:?} on thread {:?}", reduce, init, thread_values);
+ println!("reduction {:?} initialized to: {:?} on thread {:?}", reduce, init, thread_values);
}
self.reduce_values.insert((thread_values.clone(), reduce), init);
@@ -303,6 +304,10 @@ impl<'a> FunctionExecutionState<'a> {
let data = self.handle_data(&token, *reduct);
+ if VERBOSE {
+ println!("reduction {:?} write of {:?} on thread {:?}", reduce, data, thread_values);
+ }
+
self.reduce_values.insert((thread_values, reduce), data);
}
@@ -318,13 +323,22 @@ impl<'a> FunctionExecutionState<'a> {
.clone(),
Node::ThreadID { control, dimension } => {
// `control` is the fork that drives this node.
- let nesting_level = self
+
+ let nested_forks = self
.get_fork_join_nest()
.get(control)
.expect("PANIC: No nesting information for thread index!")
- .len();
+ .clone();
+
+ let num_forks_this_level = (self.get_function().nodes[nested_forks.first().unwrap().idx()].try_fork().unwrap().1.len());
+ // println!("num forks this level:{:?} ", num_forks_this_level);
+ let fork_levels: usize = nested_forks.iter().skip(num_forks_this_level).map(|ele|
+ self.get_function().nodes[ele.idx()].try_fork().unwrap().1.len()).sum();
+
+ // println!("nested forks:{:?} ", nested_forks);
+ // println!("fork levels: {:?}", fork_levels);
// dimension might need to instead be dimensions - dimension
- let v = token.thread_indicies[nesting_level + dimension - 1]; // Might have to -1?
+ let v = token.thread_indicies[fork_levels + dimension]; // Might have to -1?
if VERBOSE {
println!("node: {:?} gives tid: {:?} for thread: {:?}, dim: {:?}", node, v, token.thread_indicies, dimension);
}
@@ -342,11 +356,11 @@ impl<'a> FunctionExecutionState<'a> {
// println!("reduction read: {:?}, {:?}", thread_values, node);
let entry = self
.reduce_values
- .entry((thread_values, node));
+ .entry((thread_values.clone(), node));
let val = match entry {
Occupied(v) => v.get().clone(),
- std::collections::hash_map::Entry::Vacant(_) => panic!("Reduce has not been initialized!"),
+ std::collections::hash_map::Entry::Vacant(_) => panic!("Ctrl token: {:?}, Reduce {:?} has not been initialized!, TV: {:?}", token, node, thread_values),
};
// println!("value: {:?}", val.clone());
val
@@ -716,6 +730,9 @@ impl<'a> FunctionExecutionState<'a> {
}
// println!("tokens_to_add: {:?}", tokens_to_add);
+ if VERBOSE {
+ println!("tf, fork, join, n_tokens: {:?}, {:?}, {:?}, {:?}", thread_factors, fork, join, n_tokens);
+ }
self.join_counters.insert((thread_factors, join), n_tokens);
tokens_to_add.reverse();
diff --git a/hercules_test/hercules_tests/matmul.hbin b/hercules_test/hercules_tests/matmul.hbin
new file mode 100644
index 0000000000000000000000000000000000000000..c2893c56e58746a12e23f147c087d1b4c918f8b9
GIT binary patch
literal 1456
zcmds%2UpZU6ou!$B(q_&jItTq+Q8lw?7erf_r^g$1zAy9?7b`YE;j7FVDANcLI09(
zB1iv&o3nS`e7SSqWKMRW68VLBxmg)m@$5vrq>w<Cg<lY15r!u`m@6VwXp*HeU57-H
z4nv0pC=yjY#|otw#%k!A&@~x)DG^fIcxyT2*Vc8Q>oBg@SPf!teTJ9OKsSVL$h2-F
znMzG&NT2MvesOCMm0}5_<}(>Nv;3w1P^+no<Q&iOmsP_ER9n-hokIuEUUz`*z>%H0
zsovZugXxCOx(jp{h8?@g?sO7A!5NuKO{j!mkeQ(dED}+0+g^SAcwZhXv50S+KowN)
zNu&lCV=86VSCiSuCqn}V`-MaP8joWuqAyIq>Iy`E2E~GCl^GXQK#dqlYT+p1KgYs9
z7LPoe^TyvW8?k1qp4?+XIfQ4aL0nGG5i*^E(5bwj965gOG%hAiVH|8fJ=mL!nG=cy
zIWgjsiJ3!8=ES7rEV~S_oa|7xaOYjebo-{6=7sWvJAe3S`=y!Xhw_D6@Et?lf*<H-
zZ!>IhXt8jMj-rKIbOdeOqGM<Z+KA=!80&NibcqNypP-d%)aq3tVyQK2!}J-O`C&I<
zg<cQ6UZ|C89hsnEFCaG<1s%i=P|-f<?J(azA=^N^um`FXyJ3>{U@yXydYJu(uoHSe
zd-p@AUCbTH?v~4pHd|^mtymri2rCoTv|`W|oCeLi2z`pzo~rIs20DxLP~|um^f`|U
z+$a4S_qmEQ(3jYIiTj*o?nriz%axanf}Y?uX#PX!TkN@2op%#-7x$qma4*Qaj|ZHW
zc*c28aR>SldmnM$UFMEt_ZEzikAng91+PH`AE95d>s58)OVC@qhpNQ8An`puaANmw
zocI-Qpg*zq6DPi9?nrj`FErXCE<Xn~YmYepR{yWhfA>Hl#a4m@SU{$th=`D7pk*bI
j<;aj5fhCZXY$Z!qxa9K8vxUe1x6)G(HU#*k;HAF-kT9?0
literal 0
HcmV?d00001
diff --git a/hercules_test/hercules_tests/out.hbin b/hercules_test/hercules_tests/out.hbin
new file mode 100644
index 0000000000000000000000000000000000000000..05e1c67e38d2bdf8ebc63f6d70d53d406a042b2a
GIT binary patch
literal 1033
zcmc(e30D&_5XUEzWRqpnwB3zG6z>ZyqR62l3f>~(t<S5Jqf05a6iN%Nz;}1HiqFRf
z(B1cTlHdIEPj+4gz1m{4)~X^y&RG_Epoawz8its%AxlC!q$H-Tl^$B5ATqj}^#da_
zI^e#_fXXnHK>-|)Ob$O?lB77pu7o3lgE8ZfOj&nPx>>2lrQ-N#@$X~p|2|eAlh+o$
zN(ALJa~c@-WbDW{u!dkR<t%fSpr5vdFA}q%i<pZD964?$N!3em{;2C?u8*KQ=Jn&r
z*IpLIyQp%3{_6WWkuz_I$oJ9OA98+<i1#*7(dsW|3!f#HFS!Bc2FU2jbvs7xg9NKr
z-4Js_1TSCnhOyG2l?7vGc7SGuK|9faZdpgiqvlQ8ai>9it!>9Xp`9R6KNfoJEQyk$
z-?<xY-8&Gi*1{T%f9!^xB*bBxLcD7qJVd+l2%_3bH%kuBinJ;JU`NPvW&!LZ#o0yh
z@<<+Yq*_>viZ3ZXe?g3nn5PqXIi%mrCH2T9CCDW<0onM$N5hS0l+i{QDVOy8(^qN<
z)DjbUx;0{tak;FPL6`17mUUe|cTty5oYLjfXH^|!Nmr+zs5%q<iMB=B4YdJ!vpuCZ
zJGaCzflbu{y?uL2Z{KLDJy3g0Y?FBZ@ICsc^Z&a$WQ7F;MjwXB2n`tI!bdJWrHOEE
zsCAg1;u<sy1O(I-JeAVZ90JS0r=Ftzh3TZVBvqMK0vEF0YQ_z(Rw<RLv8=4G#|;s;
GE6ty4WnPK^
literal 0
HcmV?d00001
diff --git a/hercules_test/hercules_tests/save_me.hbin b/hercules_test/hercules_tests/save_me.hbin
new file mode 100644
index 0000000000000000000000000000000000000000..9a8a55476b57f97255c1e608dd9b00c3bdecdf16
GIT binary patch
literal 1141
zcmdUv2UpZk5QX2Jw6~kxCv2XgizxPvf+!*u#9mMl#4d;4c3CM)la7j@U;{-^u>Mac
zEBYTuPV#2HbKjlGBqvZ^&9VBrs=TUrbyqwYBamU>H$+eb;R+Z284}7VH&m&#NCb2c
zIw(M)h$_4;lwufNqtl?%7`o{pQrg$9wa8niGoUjVZ`iC#Sewak85?yLbQaU~o9t}b
zde8RAeC&1Z0nyVZOm^I7Vm<KM|C8O7OzcOl<#qgJA*g+Rk^L6+AJ93_Ic#_6s4C(j
zc?@T8Sm#6MGd+03E})@aHYio9tXptanx~3eMFd>%_z5q5lGpB5<^w&dsGL+Wi?XRS
zQ&q5t=Rs%Ada-l=M1vm?8S}SJVib|yRL~gd;k9uT>e6LWO;?0BhNcyXORmXwH-CX!
zFdnKxu28lB;To!h!-`sA=aO$)$r~0>>($-i;MQ%X+;uKDWk>yyL{k<~;#oxfp@rEj
z5Uw(30mG_xs)eliiM!@7XZ23KkPR2Fnq8bUJIzA2^qiM1y{F7R25nB8kcokvGBLPU
zCWf||1q@r9E+LbrV={RxZe}w`IDJC)Z*Q0VyE<h5mQHiruhZZR3ps-KxCVNI=b#b1
zhJFVB5~(L02TfoKY7#FYLWY{cD+DR|jwkjOFQBJcI}M>Gm|HfhFO0#SNiCpn_z0@`
z3O&cFxfRD*&^#8Q7VtUcxQH+8nEQhrzvC115^I;(ah|zlv-(Dzz3kulBVG;1Drr-s
yn@W%X-#~suArT_OhlUX#!?GP2f*}wH8(~`tNs=?y6fXZXY*#^;5a5@_TmJwV*LfHK
literal 0
HcmV?d00001
diff --git a/hercules_test/hercules_tests/tests/forkify_tests.rs b/hercules_test/hercules_tests/tests/forkify_tests.rs
index dc89e597..e62fa4f3 100644
--- a/hercules_test/hercules_tests/tests/forkify_tests.rs
+++ b/hercules_test/hercules_tests/tests/forkify_tests.rs
@@ -12,6 +12,31 @@ use juno_scheduler::{default_schedule, run_schedule_on_hercules};
use rand::Rng;
+#[test]
+fn inner_fork_chain() {
+ let module = parse_file("../test_inputs/forkify/inner_fork_chain.hir");
+ let dyn_consts = [10];
+ let params = 2; // TODO: (@xrouth) fix macro to take no params as an option.
+ // let result_1 = interp_module!(module, 0, dyn_consts, 2);
+
+ // println!("result: {:?}", result_1);
+
+ let sched: Option<ScheduleStmt> = Some(default_schedule![
+ Verify,
+ Xdot,
+ Forkify,
+ PhiElim,
+ Xdot,
+ Verify,
+ ]);
+
+ let module = run_schedule_on_hercules(module, sched).unwrap();
+
+ let result_2 = interp_module!(module, 0, dyn_consts, 2);
+ println!("result: {:?}", result_2);
+ // assert_eq!(result_1, result_2)
+}
+
#[test]
fn loop_simple_iv() {
diff --git a/hercules_test/hercules_tests/tests/loop_tests.rs b/hercules_test/hercules_tests/tests/loop_tests.rs
index 19769b5d..023d52bf 100644
--- a/hercules_test/hercules_tests/tests/loop_tests.rs
+++ b/hercules_test/hercules_tests/tests/loop_tests.rs
@@ -407,15 +407,13 @@ fn matmul_pipeline() {
const I: usize = 4;
const J: usize = 4;
const K: usize = 4;
- let a: Vec<i32> = (0..I * J).map(|_| random::<i32>() % 100).collect();
- let b: Vec<i32> = (0..J * K).map(|_| random::<i32>() % 100).collect();
+ let a: Vec<i32> = (0i32..(I * J) as i32).map(|v| v + 1).collect();
+ let b: Vec<i32> = ((I * J) as i32..(J * K) as i32 + (I * J) as i32).map(|v| v + 1).collect();
let dyn_consts = [I, J, K];
// FIXME: This path should not leave the crate
let mut module = parse_module_from_hbin("../../juno_samples/matmul/out.hbin");
//
- let result_1 = interp_module!(module, 0, dyn_consts, a.clone(), b.clone());
-
let mut correct_c: Box<[i32]> = (0..I * K).map(|_| 0).collect();
for i in 0..I {
for k in 0..K {
@@ -425,31 +423,16 @@ fn matmul_pipeline() {
}
}
- println!("golden: {:?}", correct_c);
- println!("result: {:?}", result_1);
-
- let schedule = Some(default_schedule![
- Xdot,
- ForkSplit,
- Unforkify,
- Verify,
- Xdot,
- ]);
-
- module = run_schedule_on_hercules(module.clone(), schedule).unwrap();
- let result_2 = interp_module!(module, 0, dyn_consts, a.clone(), b.clone());
- assert_eq!(result_1, result_2);
-
- let serialize = Some(default_schedule![
- Serialize
- ]);
-
- module = run_schedule_on_hercules(module, serialize).unwrap();
- println!("result: {:?}", result_2);
-
- // Verify,
+
+ let schedule = Some(default_schedule![
+ Forkify,
+ Xdot,
+ //ForkGuardElim,
+
+ // Unforkify,
+ // DCE,
// GVN,
// DCE,
// AutoOutline,
@@ -457,10 +440,55 @@ fn matmul_pipeline() {
// SROA,
// InferSchedules,
// DCE,
- // GCM,
+ // // GCM,
// DCE,
// PhiElim,
// FloatCollections,
// GCM,
- // Xdot
+ ]);
+
+ module = run_schedule_on_hercules(module.clone(), schedule).unwrap();
+ let result_1 = interp_module!(module, 1, dyn_consts, a.clone(), b.clone());
+
+ println!("golden: {:?}", correct_c);
+ println!("result: {:?}", result_1);
+
+ let InterpreterVal::Array(_, d) = result_1.clone() else {panic!()};
+ let InterpreterVal::Integer32(value) = d[0] else {panic!()};
+ assert_eq!(correct_c[0], value);
+
+ let serialize = Some(default_schedule![
+ ForkCoalesce,
+ Verify,
+ //PhiElim,
+ //DCE,
+ Xdot,
+ ]);
+
+ module = run_schedule_on_hercules(module, serialize).unwrap();
+
+ let result_2 = interp_module!(module, 1, dyn_consts, a.clone(), b.clone());
+
+ println!("result: {:?}", result_2);
+ assert_eq!(result_1, result_2);
+
+
+
+
+
+
+ // Verify,
+ // GVN,
+ // DCE,
+ // AutoOutline,
+ // InterproceduralSROA,
+ // SROA,
+ // InferSchedules,
+ // DCE,
+ // GCM,
+ // DCE,
+ // PhiElim,
+ // FloatCollections,
+ // GCM,
+ // Xdot
}
\ No newline at end of file
diff --git a/juno_scheduler/src/compile.rs b/juno_scheduler/src/compile.rs
index 8ac8f9ac..ee2d0bd6 100644
--- a/juno_scheduler/src/compile.rs
+++ b/juno_scheduler/src/compile.rs
@@ -118,6 +118,7 @@ impl FromStr for Appliable {
"slf" | "store-load-forward" => Ok(Appliable::Pass(ir::Pass::SLF)),
"sroa" => Ok(Appliable::Pass(ir::Pass::SROA)),
"unforkify" => Ok(Appliable::Pass(ir::Pass::Unforkify)),
+ "fork-coalesce" => Ok(Appliable::Pass(ir::Pass::ForkCoalesce)),
"verify" => Ok(Appliable::Pass(ir::Pass::Verify)),
"xdot" => Ok(Appliable::Pass(ir::Pass::Xdot)),
"serialize" => Ok(Appliable::Pass(ir::Pass::Serialize)),
diff --git a/juno_scheduler/src/ir.rs b/juno_scheduler/src/ir.rs
index 830e8ada..f16279e7 100644
--- a/juno_scheduler/src/ir.rs
+++ b/juno_scheduler/src/ir.rs
@@ -13,6 +13,7 @@ pub enum Pass {
LoopCanonicalization,
ForkGuardElim,
ForkSplit,
+ ForkCoalesce,
Forkify,
GCM,
GVN,
diff --git a/juno_scheduler/src/pm.rs b/juno_scheduler/src/pm.rs
index efce7133..45a424b8 100644
--- a/juno_scheduler/src/pm.rs
+++ b/juno_scheduler/src/pm.rs
@@ -10,7 +10,7 @@ use hercules_opt::{
ccp, collapse_returns, crc, dce, dumb_outline, ensure_between_control_flow, float_collections,
fork_split, gcm, gvn, infer_parallel_fork, infer_parallel_reduce, infer_tight_associative,
infer_vectorizable, inline, interprocedural_sroa, lift_dc_math, outline, phi_elim, predication,
- slf, sroa, unforkify, write_predication,
+ slf, sroa, unforkify, write_predication, fork_coalesce
};
use tempfile::TempDir;
@@ -1625,6 +1625,30 @@ fn run_pass(
pm.delete_gravestones();
pm.clear_analyses();
}
+ Pass::ForkCoalesce => {
+ assert!(args.is_empty());
+ pm.make_fork_join_maps();
+ pm.make_control_subgraphs();
+ pm.make_loops();
+ pm.make_reduce_cycles();
+ let fork_join_maps = pm.fork_join_maps.take().unwrap();
+ let loops = pm.loops.take().unwrap();
+ let control_subgraphs = pm.control_subgraphs.take().unwrap();
+ for (((func, fork_join_map), loop_nest), control_subgraph) in build_selection(pm, selection)
+ .into_iter()
+ .zip(fork_join_maps.iter())
+ .zip(loops.iter())
+ .zip(control_subgraphs.iter())
+ {
+ let Some(mut func) = func else {
+ continue;
+ };
+ changed |= fork_coalesce(&mut func, loop_nest, fork_join_map);
+ // func.modified();
+ }
+ pm.delete_gravestones();
+ pm.clear_analyses();
+ },
Pass::WritePredication => {
assert!(args.is_empty());
for func in build_selection(pm, selection) {
--
GitLab
From 1402f583d584f9f28407f155e7f175a05efdc51d Mon Sep 17 00:00:00 2001
From: Xavier Routh <xrouth2@illinois.edu>
Date: Wed, 29 Jan 2025 11:30:00 -0600
Subject: [PATCH 46/68] forkify fixes
---
hercules_opt/src/editor.rs | 3 -
hercules_opt/src/forkify.rs | 78 ++++++++++++++-----
.../hercules_interpreter/src/interpreter.rs | 12 ++-
juno_scheduler/src/pm.rs | 2 +
4 files changed, 71 insertions(+), 24 deletions(-)
diff --git a/hercules_opt/src/editor.rs b/hercules_opt/src/editor.rs
index 75d8f477..f9b8b494 100644
--- a/hercules_opt/src/editor.rs
+++ b/hercules_opt/src/editor.rs
@@ -359,9 +359,6 @@ impl<'a: 'b, 'b> FunctionEditor<'a> {
self.dynamic_constants.borrow()
}
- pub fn get_constants(&self) -> Ref<'_, Vec<Constant>> {
- self.constants.borrow()
- }
pub fn get_users(&self, id: NodeID) -> impl ExactSizeIterator<Item = NodeID> + '_ {
self.mut_def_use[id.idx()].iter().map(|x| *x)
diff --git a/hercules_opt/src/forkify.rs b/hercules_opt/src/forkify.rs
index 5d277a73..e3a16583 100644
--- a/hercules_opt/src/forkify.rs
+++ b/hercules_opt/src/forkify.rs
@@ -143,7 +143,10 @@ pub fn forkify_loop(
InductionVariable::SCEV(node_id) => return false,
};
+
let Some(bound_dc_id) = bound else {return false};
+
+
let function = editor.func();
// Check if it is do-while loop.
@@ -227,6 +230,7 @@ pub fn forkify_loop(
return false
}
+ // Start Transformation:
// Graft everyhting between header and loop condition
// Attach join to right before header (after loop_body_last, unless loop body last *is* the header).
@@ -236,6 +240,18 @@ pub fn forkify_loop(
let mut join_id = NodeID::new(0);
let mut fork_id = NodeID::new(0);
+ // Turn dc bound into max (1, bound),
+ let bound_dc_id = {
+ let mut max_id = DynamicConstantID::new(0);
+ editor.edit(|mut edit| {
+ // FIXME: Maybe add dynamic constant should intern?
+ let one_id = edit.add_dynamic_constant(DynamicConstant::Constant(1));
+ max_id = edit.add_dynamic_constant(DynamicConstant::Max(one_id, bound_dc_id));
+ Ok(edit)
+ });
+ max_id
+ };
+
// // FIXME (@xrouth), handle control in loop body.
editor.edit(
|mut edit| {
@@ -429,10 +445,11 @@ pub fn analyze_phis<'a>(editor: &'a FunctionEditor, natural_loop: &'a Loop, phis
}
// External Reduce
if let Node::Reduce { control, init, reduct} = data {
- // if !natural_loop.control[control.idx()] {
- // return true;
- // }
- return true;
+ if !natural_loop.control[control.idx()] {
+ return true;
+ } else {
+ return false;
+ }
}
// External Control
@@ -452,11 +469,30 @@ pub fn analyze_phis<'a>(editor: &'a FunctionEditor, natural_loop: &'a Loop, phis
// !stop_on.contains(node)
// });
let users = walk_all_users_stop_on(*phi, editor, stop_on.clone());
- // .filter(|node|
- // {
- // // Get rid of nodes in stop_on
- // !stop_on.contains(node)
- // });
+
+ let other_stop_on: HashSet<NodeID> = editor.node_ids().filter(|node| {
+ let data = &editor.func().nodes[node.idx()];
+
+ // Phi, Reduce
+ if let Node::Phi { control, data } = data {
+ return true;
+ }
+
+ if let Node::Reduce { control, init, reduct} = data {
+ return true;
+ }
+
+ // External Control
+ if data.is_control() {//&& !natural_loop.control[node.idx()] {
+ return true
+ }
+
+ return false;
+
+ }).collect();
+
+
+ let mut uses_for_dependance = walk_all_users_stop_on(*phi, editor, other_stop_on);
let set1: HashSet<_> = HashSet::from_iter(uses);
let set2: HashSet<_> = HashSet::from_iter(users);
@@ -465,17 +501,14 @@ pub fn analyze_phis<'a>(editor: &'a FunctionEditor, natural_loop: &'a Loop, phis
// If this phi uses any other phis the node is loop dependant,
// we use `phis` because this phi can actually contain the loop iv and its fine.
- if set1.clone().iter().any(|node| phis.contains(node) && node != phi) {
+ if uses_for_dependance.any(|node| phis.contains(&node) && node != *phi) {
LoopPHI::LoopDependant(*phi)
}
- // If this phi is used by other phis in the loop, FIXME: include reduces, they are the same as phis right?
- // DOn't go through nodes that would become a reduction.
- else if set2.clone().iter().any(|node|
- editor.func().nodes[node.idx()].is_phi()
- && node != phi
- && natural_loop.control[editor.func().nodes[node.idx()].try_phi().unwrap().0.idx()] ) {
- LoopPHI::UsedByDependant(*phi)
- }
+ // // If this phi is used by other phis in the loop, FIXME: include reduces, they are the same as phis right?
+ // // DOn't go through nodes that would become a reduction.
+ // else if set2.clone().iter().any(|node| phis.contains(node) && node != phi ) {
+ // LoopPHI::UsedByDependant(*phi)
+ // }
else if intersection.clone().iter().any(|node| true) {
let continue_idx = editor.get_uses(natural_loop.header)
.position(|node| natural_loop.control[node.idx()])
@@ -483,6 +516,15 @@ pub fn analyze_phis<'a>(editor: &'a FunctionEditor, natural_loop: &'a Loop, phis
let loop_continue_latch = editor.node(phi).try_phi().unwrap().1[continue_idx];
+ // Phis on the frontier of the intersection, i.e in uses_for_dependance need
+ // to have headers
+
+ // FIXME: Need to postdominate the loop continue latch
+ // The phi's region needs to postdominate all PHI / Reduceses (that are in the control of the loop, i.e that or uses of the loop_continue_latch)
+ // that it uses, not going through phis / reduces,
+ //
+
+ // let uses =
// No nodes in data cycles with this phi (in the loop) are used outside the loop, besides the loop_continue_latch.
if intersection.iter()
.filter(|node| **node != loop_continue_latch)
diff --git a/hercules_test/hercules_interpreter/src/interpreter.rs b/hercules_test/hercules_interpreter/src/interpreter.rs
index 3d73eb9f..9b8e2e9c 100644
--- a/hercules_test/hercules_interpreter/src/interpreter.rs
+++ b/hercules_test/hercules_interpreter/src/interpreter.rs
@@ -330,10 +330,16 @@ impl<'a> FunctionExecutionState<'a> {
.expect("PANIC: No nesting information for thread index!")
.clone();
- let num_forks_this_level = (self.get_function().nodes[nested_forks.first().unwrap().idx()].try_fork().unwrap().1.len());
+ let num_dims_this_level = (self.get_function().nodes[nested_forks.first().unwrap().idx()].try_fork().unwrap().1.len());
// println!("num forks this level:{:?} ", num_forks_this_level);
- let fork_levels: usize = nested_forks.iter().skip(num_forks_this_level).map(|ele|
- self.get_function().nodes[ele.idx()].try_fork().unwrap().1.len()).sum();
+
+ // Skip forks until we get to this level.
+ // How many forks are outer? idfk.
+ let outer_forks: Vec<NodeID> = nested_forks.iter().cloned().take_while(|fork| *fork != node).collect();
+
+ // println!("otuer_forkes: {:?}", outer_forks);
+
+ let fork_levels: usize = outer_forks.iter().skip(1).map(|ele| self.get_function().nodes[ele.idx()].try_fork().unwrap().1.len()).sum();
// println!("nested forks:{:?} ", nested_forks);
// println!("fork levels: {:?}", fork_levels);
diff --git a/juno_scheduler/src/pm.rs b/juno_scheduler/src/pm.rs
index a73b0c09..fdbc8a69 100644
--- a/juno_scheduler/src/pm.rs
+++ b/juno_scheduler/src/pm.rs
@@ -4,6 +4,8 @@ use hercules_cg::*;
use hercules_ir::*;
use hercules_opt::*;
+use serde::Deserialize;
+use serde::Serialize;
use tempfile::TempDir;
use juno_utils::env::Env;
--
GitLab
From 5a91ed0398708c18b71f4e088925b4a33344c49a Mon Sep 17 00:00:00 2001
From: Xavier Routh <xrouth2@illinois.edu>
Date: Wed, 29 Jan 2025 21:12:19 -0600
Subject: [PATCH 47/68] prep for merge
---
hercules_opt/src/fork_concat_split.rs | 6 ++-
.../hercules_interpreter/src/main.rs | 28 -------------
juno_scheduler/src/default.rs | 5 ++-
juno_scheduler/src/pm.rs | 41 +++++++++++--------
4 files changed, 33 insertions(+), 47 deletions(-)
delete mode 100644 hercules_test/hercules_interpreter/src/main.rs
diff --git a/hercules_opt/src/fork_concat_split.rs b/hercules_opt/src/fork_concat_split.rs
index 186cd6a6..c527a11e 100644
--- a/hercules_opt/src/fork_concat_split.rs
+++ b/hercules_opt/src/fork_concat_split.rs
@@ -42,8 +42,11 @@ pub fn fork_split(
.filter(|(user, reduce)| reduce_cycles[&reduce].contains(&user))
.collect();
+ println!("reduce cycles: {:?}", reduce_cycles.clone());
+ println!("reduce cycle: {:?}", data_in_reduce_cycle.clone());
+
editor.edit(|mut edit| {
- // Create the forks and a thread ID per fork.
+ // Create the forks and a thread ID per fork.
let mut acc_fork = fork_control;
let mut new_tids = vec![];
for factor in factors {
@@ -135,5 +138,6 @@ pub fn fork_split(
Ok(edit)
});
+ break;
}
}
diff --git a/hercules_test/hercules_interpreter/src/main.rs b/hercules_test/hercules_interpreter/src/main.rs
deleted file mode 100644
index 5db31cd7..00000000
--- a/hercules_test/hercules_interpreter/src/main.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-use std::fs::File;
-use std::io::prelude::*;
-
-use clap::Parser;
-
-use hercules_ir::*;
-
-use hercules_interpreter::interpreter::*;
-use hercules_interpreter::*;
-use hercules_interpreter::value;
-
-#[derive(Parser, Debug)]
-#[command(author, version, about, long_about = None)]
-struct Args {
- hir_file: String,
-
- #[arg(short, long, default_value_t = String::new())]
- output: String,
-}
-
-fn main() {
- let args = Args::parse();
- let module = parse_file(&args.hir_file);
- let ret_val = interp_module!(module, [2, 3, 4], 1, 3);
-
- println!("ret val: {:?}", ret_val);
-}
-
diff --git a/juno_scheduler/src/default.rs b/juno_scheduler/src/default.rs
index cc3d49a8..88d55b33 100644
--- a/juno_scheduler/src/default.rs
+++ b/juno_scheduler/src/default.rs
@@ -66,8 +66,8 @@ pub fn default_schedule() -> ScheduleStmt {
DCE,
GVN,
DCE,
- Forkify,
- ForkGuardElim,
+ /*Forkify,*/
+ /*ForkGuardElim,*/
DCE,
ForkSplit,
Unforkify,
@@ -83,5 +83,6 @@ pub fn default_schedule() -> ScheduleStmt {
DCE,
FloatCollections,
GCM,
+
]
}
diff --git a/juno_scheduler/src/pm.rs b/juno_scheduler/src/pm.rs
index 61a5639e..3c14f624 100644
--- a/juno_scheduler/src/pm.rs
+++ b/juno_scheduler/src/pm.rs
@@ -1306,23 +1306,32 @@ fn run_pass(
}
Pass::ForkSplit => {
assert!(args.is_empty());
- pm.make_fork_join_maps();
- pm.make_reduce_cycles();
- let fork_join_maps = pm.fork_join_maps.take().unwrap();
- let reduce_cycles = pm.reduce_cycles.take().unwrap();
- for ((func, fork_join_map), reduce_cycles) in build_selection(pm, selection)
- .into_iter()
- .zip(fork_join_maps.iter())
- .zip(reduce_cycles.iter())
- {
- let Some(mut func) = func else {
- continue;
- };
- fork_split(&mut func, fork_join_map, reduce_cycles);
- changed |= func.modified();
+ // FIXME: I'm not sure if this is the correct way to build fixpoint into the PM,
+ // i.e cloning selection. Does something need to be done to propagate labels between iterations
+ // of this loop?
+ loop {
+ pm.make_fork_join_maps();
+ pm.make_reduce_cycles();
+ let fork_join_maps = pm.fork_join_maps.take().unwrap();
+ let reduce_cycles = pm.reduce_cycles.take().unwrap();
+ for ((func, fork_join_map), reduce_cycles) in build_selection(pm, selection.clone())
+ .into_iter()
+ .zip(fork_join_maps.iter())
+ .zip(reduce_cycles.iter())
+ {
+ let Some(mut func) = func else {
+ continue;
+ };
+ fork_split(&mut func, fork_join_map, reduce_cycles);
+ changed |= func.modified();
+ }
+ pm.delete_gravestones();
+ pm.clear_analyses();
+
+ if !changed {
+ break;
+ }
}
- pm.delete_gravestones();
- pm.clear_analyses();
}
Pass::Forkify => {
assert!(args.is_empty());
--
GitLab
From 20fd62e564940263f10f34f4704e8915780ddaef Mon Sep 17 00:00:00 2001
From: Xavier Routh <xrouth2@illinois.edu>
Date: Wed, 29 Jan 2025 21:18:37 -0600
Subject: [PATCH 48/68] misc
---
hercules_ir/src/loops.rs | 6 +-
hercules_opt/src/gcm.rs | 56 +-
hercules_opt/src/pass.rs | 1286 -----------------
.../hercules_tests/tests/loop_tests.rs | 50 +-
4 files changed, 50 insertions(+), 1348 deletions(-)
delete mode 100644 hercules_opt/src/pass.rs
diff --git a/hercules_ir/src/loops.rs b/hercules_ir/src/loops.rs
index 06d400e1..a425c442 100644
--- a/hercules_ir/src/loops.rs
+++ b/hercules_ir/src/loops.rs
@@ -7,14 +7,14 @@ use bitvec::prelude::*;
use crate::*;
/*
- * Custom type for storing a loop tree. Each node corresponds to either a single
- * loop or a fork join pair in the IR graph. Each node in the tree corresponds to
+ * Custom type for storing a loop tree. Each node corresponds to a single loop
+ * or a fork join pair in the IR graph. Each node in the tree corresponds to
* some subset of the overall IR graph. The root node corresponds to the entire
* IR graph. The children of the root correspond to the top-level loops and fork
* join pairs, and so on. Each node in the loop tree has a representative
* "header" node. For normal loops, this is the region node branched to by a
* dominated if node. For fork join pairs, this is the fork node. A loop is a
- * top-level loop if its parent is the root node of the subgraph. Each control node in
+ * top-level loop if its parent is the root node of the subgraph. Each node in
* the tree is an entry in the loops HashMap - the key is the "header" node for
* the loop, and the value is a pair of the set of control nodes inside the loop
* and this loop's parent header.
diff --git a/hercules_opt/src/gcm.rs b/hercules_opt/src/gcm.rs
index 766bd0d2..0c7665bf 100644
--- a/hercules_opt/src/gcm.rs
+++ b/hercules_opt/src/gcm.rs
@@ -417,34 +417,34 @@ fn basic_blocks(
.chain(schedule_late, schedule_early);
if let Some(mut location) = chain.next() {
- // while let Some(control_node) = chain.next() {
- // // If the next node further up the dominator tree is in a shallower
- // // loop nest or if we can get out of a reduce loop when we don't
- // // need to be in one, place this data node in a higher-up location.
- // let old_nest = loops
- // .header_of(location)
- // .map(|header| loops.nesting(header).unwrap());
- // let new_nest = loops
- // .header_of(control_node)
- // .map(|header| loops.nesting(header).unwrap());
- // let shallower_nest = if let (Some(old_nest), Some(new_nest)) = (old_nest, new_nest)
- // {
- // old_nest > new_nest
- // } else {
- // // If the new location isn't a loop, it's nesting level should
- // // be considered "shallower" if the current location is in a
- // // loop.
- // old_nest.is_some()
- // };
- // // This will move all nodes that don't need to be in reduce loops
- // // outside of reduce loops. Nodes that do need to be in a reduce
- // // loop use the reduce node forming the loop, so the dominator chain
- // // will consist of one block, and this loop won't ever iterate.
- // let currently_at_join = function.nodes[location.idx()].is_join();
- // if shallower_nest || currently_at_join {
- // location = control_node;
- // }
- // }
+ while let Some(control_node) = chain.next() {
+ // If the next node further up the dominator tree is in a shallower
+ // loop nest or if we can get out of a reduce loop when we don't
+ // need to be in one, place this data node in a higher-up location.
+ let old_nest = loops
+ .header_of(location)
+ .map(|header| loops.nesting(header).unwrap());
+ let new_nest = loops
+ .header_of(control_node)
+ .map(|header| loops.nesting(header).unwrap());
+ let shallower_nest = if let (Some(old_nest), Some(new_nest)) = (old_nest, new_nest)
+ {
+ old_nest > new_nest
+ } else {
+ // If the new location isn't a loop, it's nesting level should
+ // be considered "shallower" if the current location is in a
+ // loop.
+ old_nest.is_some()
+ };
+ // This will move all nodes that don't need to be in reduce loops
+ // outside of reduce loops. Nodes that do need to be in a reduce
+ // loop use the reduce node forming the loop, so the dominator chain
+ // will consist of one block, and this loop won't ever iterate.
+ let currently_at_join = function.nodes[location.idx()].is_join();
+ if shallower_nest || currently_at_join {
+ location = control_node;
+ }
+ }
bbs[id.idx()] = Some(location);
num_skip_iters = 0;
diff --git a/hercules_opt/src/pass.rs b/hercules_opt/src/pass.rs
deleted file mode 100644
index 0125dcda..00000000
--- a/hercules_opt/src/pass.rs
+++ /dev/null
@@ -1,1286 +0,0 @@
-use std::cell::RefCell;
-use std::collections::{HashMap, HashSet};
-use std::fs::File;
-use std::io::Write;
-use std::iter::zip;
-use std::process::{Command, Stdio};
-
-use serde::Deserialize;
-
-use tempfile::TempDir;
-
-use hercules_cg::*;
-use hercules_ir::*;
-
-use crate::*;
-
-/*
- * Passes that can be run on a module.
- */
-#[derive(Debug, Clone, Deserialize)]
-pub enum Pass {
- DCE,
- CCP,
- GVN,
- PhiElim,
- Forkify,
- ForkGuardElim,
- SLF,
- WritePredication,
- Predication,
- SROA,
- Inline,
- Outline,
- InterproceduralSROA,
- DeleteUncalled,
- ForkSplit,
- Unforkify,
- InferSchedules,
- GCM,
- FloatCollections,
- Verify,
- // Parameterized over whether analyses that aid visualization are necessary.
- // Useful to set to false if displaying a potentially broken module.
- Xdot(bool),
- // Parameterized over output directory and module name.
- Codegen(String, String),
- // Parameterized over where to serialize module to.
- Serialize(String),
- ForkFission,
- ForkCoalesce,
- LoopCanonicalization,
-}
-
-/*
- * Manages passes to be run on an IR module. Transparently handles analysis
- * requirements for optimizations.
- */
-#[derive(Debug, Clone)]
-pub struct PassManager {
- module: Module,
-
- // Passes to run.
- passes: Vec<Pass>,
-
- // Cached analysis results.
- pub def_uses: Option<Vec<ImmutableDefUseMap>>,
- pub reverse_postorders: Option<Vec<Vec<NodeID>>>,
- pub typing: Option<ModuleTyping>,
- pub control_subgraphs: Option<Vec<Subgraph>>,
- pub doms: Option<Vec<DomTree>>,
- pub postdoms: Option<Vec<DomTree>>,
- pub fork_join_maps: Option<Vec<HashMap<NodeID, NodeID>>>,
- pub fork_join_nests: Option<Vec<HashMap<NodeID, Vec<NodeID>>>>,
- pub loops: Option<Vec<LoopTree>>,
- pub reduce_cycles: Option<Vec<HashMap<NodeID, HashSet<NodeID>>>>,
- pub data_nodes_in_fork_joins: Option<Vec<HashMap<NodeID, HashSet<NodeID>>>>,
- pub bbs: Option<Vec<BasicBlocks>>,
- pub collection_objects: Option<CollectionObjects>,
- pub callgraph: Option<CallGraph>,
-}
-
-impl PassManager {
- pub fn new(module: Module) -> Self {
- PassManager {
- module,
- passes: vec![],
- def_uses: None,
- reverse_postorders: None,
- typing: None,
- control_subgraphs: None,
- doms: None,
- postdoms: None,
- fork_join_maps: None,
- fork_join_nests: None,
- loops: None,
- reduce_cycles: None,
- data_nodes_in_fork_joins: None,
- bbs: None,
- collection_objects: None,
- callgraph: None,
- }
- }
-
- pub fn add_pass(&mut self, pass: Pass) {
- self.passes.push(pass);
- }
-
- pub fn make_def_uses(&mut self) {
- if self.def_uses.is_none() {
- self.def_uses = Some(self.module.functions.iter().map(def_use).collect());
- }
- }
-
- pub fn make_reverse_postorders(&mut self) {
- if self.reverse_postorders.is_none() {
- self.make_def_uses();
- self.reverse_postorders = Some(
- self.def_uses
- .as_ref()
- .unwrap()
- .iter()
- .map(reverse_postorder)
- .collect(),
- );
- }
- }
-
- pub fn make_typing(&mut self) {
- if self.typing.is_none() {
- self.make_reverse_postorders();
- self.typing = Some(
- typecheck(&mut self.module, self.reverse_postorders.as_ref().unwrap()).unwrap(),
- );
- }
- }
-
- pub fn make_control_subgraphs(&mut self) {
- if self.control_subgraphs.is_none() {
- self.make_def_uses();
- self.control_subgraphs = Some(
- zip(&self.module.functions, self.def_uses.as_ref().unwrap())
- .map(|(function, def_use)| control_subgraph(function, def_use))
- .collect(),
- );
- }
- }
-
- pub fn make_doms(&mut self) {
- if self.doms.is_none() {
- self.make_control_subgraphs();
- self.doms = Some(
- self.control_subgraphs
- .as_ref()
- .unwrap()
- .iter()
- .map(|subgraph| dominator(subgraph, NodeID::new(0)))
- .collect(),
- );
- }
- }
-
- pub fn make_postdoms(&mut self) {
- if self.postdoms.is_none() {
- self.make_control_subgraphs();
- self.postdoms = Some(
- zip(
- self.control_subgraphs.as_ref().unwrap().iter(),
- self.module.functions.iter(),
- )
- .map(|(subgraph, function)| dominator(subgraph, NodeID::new(function.nodes.len())))
- .collect(),
- );
- }
- }
-
- pub fn make_fork_join_maps(&mut self) {
- if self.fork_join_maps.is_none() {
- self.make_control_subgraphs();
- self.fork_join_maps = Some(
- zip(
- self.module.functions.iter(),
- self.control_subgraphs.as_ref().unwrap().iter(),
- )
- .map(|(function, subgraph)| fork_join_map(function, subgraph))
- .collect(),
- );
- }
- }
-
- pub fn make_fork_join_nests(&mut self) {
- if self.fork_join_nests.is_none() {
- self.make_doms();
- self.make_fork_join_maps();
- self.fork_join_nests = Some(
- zip(
- self.module.functions.iter(),
- zip(
- self.doms.as_ref().unwrap().iter(),
- self.fork_join_maps.as_ref().unwrap().iter(),
- ),
- )
- .map(|(function, (dom, fork_join_map))| {
- compute_fork_join_nesting(function, dom, fork_join_map)
- })
- .collect(),
- );
- }
- }
-
- pub fn make_loops(&mut self) {
- if self.loops.is_none() {
- self.make_control_subgraphs();
- self.make_doms();
- self.make_fork_join_maps();
- let control_subgraphs = self.control_subgraphs.as_ref().unwrap().iter();
- let doms = self.doms.as_ref().unwrap().iter();
- let fork_join_maps = self.fork_join_maps.as_ref().unwrap().iter();
- self.loops = Some(
- zip(control_subgraphs, zip(doms, fork_join_maps))
- .map(|(control_subgraph, (dom, fork_join_map))| {
- loops(control_subgraph, NodeID::new(0), dom, fork_join_map)
- })
- .collect(),
- );
- }
- }
-
- pub fn make_reduce_cycles(&mut self) {
- if self.reduce_cycles.is_none() {
- self.make_def_uses();
- let def_uses = self.def_uses.as_ref().unwrap().iter();
- self.reduce_cycles = Some(
- zip(self.module.functions.iter(), def_uses)
- .map(|(function, def_use)| reduce_cycles(function, def_use))
- .collect(),
- );
- }
- }
-
- pub fn make_data_nodes_in_fork_joins(&mut self) {
- if self.data_nodes_in_fork_joins.is_none() {
- self.make_def_uses();
- self.make_fork_join_maps();
- self.data_nodes_in_fork_joins = Some(
- zip(
- self.module.functions.iter(),
- zip(
- self.def_uses.as_ref().unwrap().iter(),
- self.fork_join_maps.as_ref().unwrap().iter(),
- ),
- )
- .map(|(function, (def_use, fork_join_map))| {
- data_nodes_in_fork_joins(function, def_use, fork_join_map)
- })
- .collect(),
- );
- }
- }
-
- pub fn make_collection_objects(&mut self) {
- if self.collection_objects.is_none() {
- self.make_reverse_postorders();
- self.make_typing();
- self.make_callgraph();
- let reverse_postorders = self.reverse_postorders.as_ref().unwrap();
- let typing = self.typing.as_ref().unwrap();
- let callgraph = self.callgraph.as_ref().unwrap();
- self.collection_objects = Some(collection_objects(
- &self.module,
- reverse_postorders,
- typing,
- callgraph,
- ));
- }
- }
-
- pub fn make_callgraph(&mut self) {
- if self.callgraph.is_none() {
- self.callgraph = Some(callgraph(&self.module));
- }
- }
-
- pub fn run_passes(&mut self) {
- for pass in self.passes.clone().iter() {
- match pass {
- Pass::DCE => {
- self.make_def_uses();
- let def_uses = self.def_uses.as_ref().unwrap();
- for idx in 0..self.module.functions.len() {
- let constants_ref =
- RefCell::new(std::mem::take(&mut self.module.constants));
- let dynamic_constants_ref =
- RefCell::new(std::mem::take(&mut self.module.dynamic_constants));
- let types_ref = RefCell::new(std::mem::take(&mut self.module.types));
- let mut editor = FunctionEditor::new(
- &mut self.module.functions[idx],
- FunctionID::new(idx),
- &constants_ref,
- &dynamic_constants_ref,
- &types_ref,
- &def_uses[idx],
- );
- dce(&mut editor);
-
- self.module.constants = constants_ref.take();
- self.module.dynamic_constants = dynamic_constants_ref.take();
- self.module.types = types_ref.take();
-
- self.module.functions[idx].delete_gravestones();
- }
- self.clear_analyses();
- }
- Pass::InterproceduralSROA => {
- self.make_def_uses();
- self.make_typing();
-
- let constants_ref = RefCell::new(std::mem::take(&mut self.module.constants));
- let dynamic_constants_ref =
- RefCell::new(std::mem::take(&mut self.module.dynamic_constants));
- let types_ref = RefCell::new(std::mem::take(&mut self.module.types));
-
- let def_uses = self.def_uses.as_ref().unwrap();
-
- let mut editors: Vec<_> = self
- .module
- .functions
- .iter_mut()
- .enumerate()
- .map(|(i, f)| {
- FunctionEditor::new(
- f,
- FunctionID::new(i),
- &constants_ref,
- &dynamic_constants_ref,
- &types_ref,
- &def_uses[i],
- )
- })
- .collect();
-
- interprocedural_sroa(&mut editors);
-
- self.module.constants = constants_ref.take();
- self.module.dynamic_constants = dynamic_constants_ref.take();
- self.module.types = types_ref.take();
-
- for func in self.module.functions.iter_mut() {
- func.delete_gravestones();
- }
-
- self.clear_analyses();
- }
- Pass::CCP => {
- self.make_def_uses();
- self.make_reverse_postorders();
- let def_uses = self.def_uses.as_ref().unwrap();
- let reverse_postorders = self.reverse_postorders.as_ref().unwrap();
- for idx in 0..self.module.functions.len() {
- let constants_ref =
- RefCell::new(std::mem::take(&mut self.module.constants));
- let dynamic_constants_ref =
- RefCell::new(std::mem::take(&mut self.module.dynamic_constants));
- let types_ref = RefCell::new(std::mem::take(&mut self.module.types));
- let mut editor = FunctionEditor::new(
- &mut self.module.functions[idx],
- FunctionID::new(idx),
- &constants_ref,
- &dynamic_constants_ref,
- &types_ref,
- &def_uses[idx],
- );
- ccp(&mut editor, &reverse_postorders[idx]);
-
- self.module.constants = constants_ref.take();
- self.module.dynamic_constants = dynamic_constants_ref.take();
- self.module.types = types_ref.take();
-
- self.module.functions[idx].delete_gravestones();
- }
- self.clear_analyses();
- }
- Pass::GVN => {
- self.make_def_uses();
- let def_uses = self.def_uses.as_ref().unwrap();
- for idx in 0..self.module.functions.len() {
- let constants_ref =
- RefCell::new(std::mem::take(&mut self.module.constants));
- let dynamic_constants_ref =
- RefCell::new(std::mem::take(&mut self.module.dynamic_constants));
- let types_ref = RefCell::new(std::mem::take(&mut self.module.types));
- let mut editor = FunctionEditor::new(
- &mut self.module.functions[idx],
- FunctionID::new(idx),
- &constants_ref,
- &dynamic_constants_ref,
- &types_ref,
- &def_uses[idx],
- );
- gvn(&mut editor, false);
-
- self.module.constants = constants_ref.take();
- self.module.dynamic_constants = dynamic_constants_ref.take();
- self.module.types = types_ref.take();
-
- self.module.functions[idx].delete_gravestones();
- }
- self.clear_analyses();
- }
- Pass::Forkify => {
- let mut changed = true;
- while changed {
- changed = false;
-
- self.make_def_uses();
- self.make_loops();
- self.make_control_subgraphs();
- self.make_fork_join_maps();
- let def_uses = self.def_uses.as_ref().unwrap();
- let loops = self.loops.as_ref().unwrap();
- let fork_join_maps = self.fork_join_maps.as_ref().unwrap();
- for idx in 0..self.module.functions.len() {
- let constants_ref =
- RefCell::new(std::mem::take(&mut self.module.constants));
- let dynamic_constants_ref =
- RefCell::new(std::mem::take(&mut self.module.dynamic_constants));
- let types_ref = RefCell::new(std::mem::take(&mut self.module.types));
- let subgraph = &self.control_subgraphs.as_ref().unwrap()[idx];
- let mut editor = FunctionEditor::new(
- &mut self.module.functions[idx],
- FunctionID::new(idx),
- &constants_ref,
- &dynamic_constants_ref,
- &types_ref,
- &def_uses[idx],
- );
-
- changed |= forkify(
- &mut editor,
- subgraph,
- &fork_join_maps[idx],
- &loops[idx],
- );
-
- self.module.constants = constants_ref.take();
- self.module.dynamic_constants = dynamic_constants_ref.take();
- self.module.types = types_ref.take();
-
- let num_nodes = self.module.functions[idx].nodes.len();
- self.module.functions[idx]
- .schedules
- .resize(num_nodes, vec![]);
- self.module.functions[idx].delete_gravestones();
- }
- self.clear_analyses();
- break;
- }
- }
- Pass::PhiElim => {
- self.make_def_uses();
- let def_uses = self.def_uses.as_ref().unwrap();
- for idx in 0..self.module.functions.len() {
- let constants_ref =
- RefCell::new(std::mem::take(&mut self.module.constants));
- let dynamic_constants_ref =
- RefCell::new(std::mem::take(&mut self.module.dynamic_constants));
- let types_ref = RefCell::new(std::mem::take(&mut self.module.types));
- let mut editor = FunctionEditor::new(
- &mut self.module.functions[idx],
- FunctionID::new(idx),
- &constants_ref,
- &dynamic_constants_ref,
- &types_ref,
- &def_uses[idx],
- );
- phi_elim(&mut editor);
-
- self.module.constants = constants_ref.take();
- self.module.dynamic_constants = dynamic_constants_ref.take();
- self.module.types = types_ref.take();
-
- self.module.functions[idx].delete_gravestones();
- }
- self.clear_analyses();
- }
- Pass::ForkGuardElim => {
- self.make_def_uses();
- self.make_fork_join_maps();
- let def_uses = self.def_uses.as_ref().unwrap();
- let fork_join_maps = self.fork_join_maps.as_ref().unwrap();
- for idx in 0..self.module.functions.len() {
- let constants_ref =
- RefCell::new(std::mem::take(&mut self.module.constants));
- let dynamic_constants_ref =
- RefCell::new(std::mem::take(&mut self.module.dynamic_constants));
- let types_ref = RefCell::new(std::mem::take(&mut self.module.types));
- let mut editor = FunctionEditor::new(
- &mut self.module.functions[idx],
- FunctionID::new(idx),
- &constants_ref,
- &dynamic_constants_ref,
- &types_ref,
- &def_uses[idx],
- );
-
- fork_guard_elim(
- &mut editor,
- &fork_join_maps[idx],
- );
- self.module.constants = constants_ref.take();
- self.module.dynamic_constants = dynamic_constants_ref.take();
- self.module.types = types_ref.take();
- self.module.functions[idx].delete_gravestones();
- }
- self.clear_analyses();
- }
- Pass::SLF => {
- self.make_def_uses();
- self.make_reverse_postorders();
- self.make_typing();
- let def_uses = self.def_uses.as_ref().unwrap();
- let reverse_postorders = self.reverse_postorders.as_ref().unwrap();
- let typing = self.typing.as_ref().unwrap();
- for idx in 0..self.module.functions.len() {
- let constants_ref =
- RefCell::new(std::mem::take(&mut self.module.constants));
- let dynamic_constants_ref =
- RefCell::new(std::mem::take(&mut self.module.dynamic_constants));
- let types_ref = RefCell::new(std::mem::take(&mut self.module.types));
- let mut editor = FunctionEditor::new(
- &mut self.module.functions[idx],
- FunctionID::new(idx),
- &constants_ref,
- &dynamic_constants_ref,
- &types_ref,
- &def_uses[idx],
- );
- slf(&mut editor, &reverse_postorders[idx], &typing[idx]);
-
- self.module.constants = constants_ref.take();
- self.module.dynamic_constants = dynamic_constants_ref.take();
- self.module.types = types_ref.take();
-
- println!("{}", self.module.functions[idx].name);
- self.module.functions[idx].delete_gravestones();
- }
- self.clear_analyses();
- }
- Pass::WritePredication => {
- self.make_def_uses();
- let def_uses = self.def_uses.as_ref().unwrap();
- for idx in 0..self.module.functions.len() {
- let constants_ref =
- RefCell::new(std::mem::take(&mut self.module.constants));
- let dynamic_constants_ref =
- RefCell::new(std::mem::take(&mut self.module.dynamic_constants));
- let types_ref = RefCell::new(std::mem::take(&mut self.module.types));
- let mut editor = FunctionEditor::new(
- &mut self.module.functions[idx],
- FunctionID::new(idx),
- &constants_ref,
- &dynamic_constants_ref,
- &types_ref,
- &def_uses[idx],
- );
- write_predication(&mut editor);
-
- self.module.constants = constants_ref.take();
- self.module.dynamic_constants = dynamic_constants_ref.take();
- self.module.types = types_ref.take();
-
- self.module.functions[idx].delete_gravestones();
- }
- self.clear_analyses();
- }
- Pass::Predication => {
- self.make_def_uses();
- self.make_typing();
- let def_uses = self.def_uses.as_ref().unwrap();
- let typing = self.typing.as_ref().unwrap();
- for idx in 0..self.module.functions.len() {
- let constants_ref =
- RefCell::new(std::mem::take(&mut self.module.constants));
- let dynamic_constants_ref =
- RefCell::new(std::mem::take(&mut self.module.dynamic_constants));
- let types_ref = RefCell::new(std::mem::take(&mut self.module.types));
- let mut editor = FunctionEditor::new(
- &mut self.module.functions[idx],
- FunctionID::new(idx),
- &constants_ref,
- &dynamic_constants_ref,
- &types_ref,
- &def_uses[idx],
- );
- predication(&mut editor, &typing[idx]);
-
- self.module.constants = constants_ref.take();
- self.module.dynamic_constants = dynamic_constants_ref.take();
- self.module.types = types_ref.take();
-
- self.module.functions[idx].delete_gravestones();
- }
- self.clear_analyses();
- }
- Pass::SROA => {
- self.make_def_uses();
- self.make_reverse_postorders();
- self.make_typing();
- let def_uses = self.def_uses.as_ref().unwrap();
- let reverse_postorders = self.reverse_postorders.as_ref().unwrap();
- let typing = self.typing.as_ref().unwrap();
- for idx in 0..self.module.functions.len() {
- let constants_ref =
- RefCell::new(std::mem::take(&mut self.module.constants));
- let dynamic_constants_ref =
- RefCell::new(std::mem::take(&mut self.module.dynamic_constants));
- let types_ref = RefCell::new(std::mem::take(&mut self.module.types));
- let mut editor = FunctionEditor::new(
- &mut self.module.functions[idx],
- FunctionID::new(idx),
- &constants_ref,
- &dynamic_constants_ref,
- &types_ref,
- &def_uses[idx],
- );
- sroa(&mut editor, &reverse_postorders[idx], &typing[idx]);
-
- self.module.constants = constants_ref.take();
- self.module.dynamic_constants = dynamic_constants_ref.take();
- self.module.types = types_ref.take();
-
- self.module.functions[idx].delete_gravestones();
- }
- self.clear_analyses();
- }
- Pass::Inline => {
- self.make_def_uses();
- self.make_callgraph();
- let def_uses = self.def_uses.as_ref().unwrap();
- let callgraph = self.callgraph.as_ref().unwrap();
- let constants_ref = RefCell::new(std::mem::take(&mut self.module.constants));
- let dynamic_constants_ref =
- RefCell::new(std::mem::take(&mut self.module.dynamic_constants));
- let types_ref = RefCell::new(std::mem::take(&mut self.module.types));
- let mut editors: Vec<_> = zip(
- self.module.functions.iter_mut().enumerate(),
- def_uses.iter(),
- )
- .map(|((idx, func), def_use)| {
- FunctionEditor::new(
- func,
- FunctionID::new(idx),
- &constants_ref,
- &dynamic_constants_ref,
- &types_ref,
- def_use,
- )
- })
- .collect();
- inline(&mut editors, callgraph);
-
- self.module.constants = constants_ref.take();
- self.module.dynamic_constants = dynamic_constants_ref.take();
- self.module.types = types_ref.take();
-
- for func in self.module.functions.iter_mut() {
- func.delete_gravestones();
- }
- self.clear_analyses();
- }
- Pass::Outline => {
- self.make_def_uses();
- let def_uses = self.def_uses.as_ref().unwrap();
- let constants_ref = RefCell::new(std::mem::take(&mut self.module.constants));
- let dynamic_constants_ref =
- RefCell::new(std::mem::take(&mut self.module.dynamic_constants));
- let types_ref = RefCell::new(std::mem::take(&mut self.module.types));
- let old_num_funcs = self.module.functions.len();
- let mut editors: Vec<_> = zip(
- self.module.functions.iter_mut().enumerate(),
- def_uses.iter(),
- )
- .map(|((idx, func), def_use)| {
- FunctionEditor::new(
- func,
- FunctionID::new(idx),
- &constants_ref,
- &dynamic_constants_ref,
- &types_ref,
- def_use,
- )
- })
- .collect();
- for editor in editors.iter_mut() {
- collapse_returns(editor);
- ensure_between_control_flow(editor);
- }
- self.module.constants = constants_ref.take();
- self.module.dynamic_constants = dynamic_constants_ref.take();
- self.module.types = types_ref.take();
- self.clear_analyses();
-
- self.make_def_uses();
- self.make_typing();
- self.make_control_subgraphs();
- self.make_doms();
- let def_uses = self.def_uses.as_ref().unwrap();
- let typing = self.typing.as_ref().unwrap();
- let control_subgraphs = self.control_subgraphs.as_ref().unwrap();
- let doms = self.doms.as_ref().unwrap();
- let constants_ref = RefCell::new(std::mem::take(&mut self.module.constants));
- let dynamic_constants_ref =
- RefCell::new(std::mem::take(&mut self.module.dynamic_constants));
- let types_ref = RefCell::new(std::mem::take(&mut self.module.types));
- let mut editors: Vec<_> = zip(
- self.module.functions.iter_mut().enumerate(),
- def_uses.iter(),
- )
- .map(|((idx, func), def_use)| {
- FunctionEditor::new(
- func,
- FunctionID::new(idx),
- &constants_ref,
- &dynamic_constants_ref,
- &types_ref,
- def_use,
- )
- })
- .collect();
- let mut new_funcs = vec![];
- for (idx, editor) in editors.iter_mut().enumerate() {
- let new_func_id = FunctionID::new(old_num_funcs + new_funcs.len());
- let new_func = dumb_outline(
- editor,
- &typing[idx],
- &control_subgraphs[idx],
- &doms[idx],
- new_func_id,
- );
- if let Some(new_func) = new_func {
- new_funcs.push(new_func);
- }
- }
- self.module.constants = constants_ref.take();
- self.module.dynamic_constants = dynamic_constants_ref.take();
- self.module.types = types_ref.take();
-
- for func in self.module.functions.iter_mut() {
- func.delete_gravestones();
- }
- self.module.functions.extend(new_funcs);
- self.clear_analyses();
- }
- Pass::DeleteUncalled => {
- self.make_def_uses();
- self.make_callgraph();
- let def_uses = self.def_uses.as_ref().unwrap();
- let callgraph = self.callgraph.as_ref().unwrap();
- let constants_ref = RefCell::new(std::mem::take(&mut self.module.constants));
- let dynamic_constants_ref =
- RefCell::new(std::mem::take(&mut self.module.dynamic_constants));
- let types_ref = RefCell::new(std::mem::take(&mut self.module.types));
-
- // By default in an editor all nodes are mutable, which is desired in this case
- // since we are only modifying the IDs of functions that we call.
- let mut editors: Vec<_> = zip(
- self.module.functions.iter_mut().enumerate(),
- def_uses.iter(),
- )
- .map(|((idx, func), def_use)| {
- FunctionEditor::new(
- func,
- FunctionID::new(idx),
- &constants_ref,
- &dynamic_constants_ref,
- &types_ref,
- def_use,
- )
- })
- .collect();
-
- let new_idx = delete_uncalled(&mut editors, callgraph);
- self.module.constants = constants_ref.take();
- self.module.dynamic_constants = dynamic_constants_ref.take();
- self.module.types = types_ref.take();
-
- for func in self.module.functions.iter_mut() {
- func.delete_gravestones();
- }
-
- self.fix_deleted_functions(&new_idx);
- self.clear_analyses();
-
- assert!(self.module.functions.len() > 0, "PANIC: There are no entry functions in the Hercules module being compiled, and they all got deleted by DeleteUncalled. Please mark at least one function as an entry!");
- }
- Pass::ForkSplit => {
- self.make_def_uses();
- self.make_fork_join_maps();
- self.make_reduce_cycles();
- let def_uses = self.def_uses.as_ref().unwrap();
- let fork_join_maps = self.fork_join_maps.as_ref().unwrap();
- let reduce_cycles = self.reduce_cycles.as_ref().unwrap();
- for idx in 0..self.module.functions.len() {
- let constants_ref =
- RefCell::new(std::mem::take(&mut self.module.constants));
- let dynamic_constants_ref =
- RefCell::new(std::mem::take(&mut self.module.dynamic_constants));
- let types_ref = RefCell::new(std::mem::take(&mut self.module.types));
- let mut editor = FunctionEditor::new(
- &mut self.module.functions[idx],
- FunctionID::new(idx),
- &constants_ref,
- &dynamic_constants_ref,
- &types_ref,
- &def_uses[idx],
- );
- fork_split(&mut editor, &fork_join_maps[idx], &reduce_cycles[idx]);
-
- self.module.constants = constants_ref.take();
- self.module.dynamic_constants = dynamic_constants_ref.take();
- self.module.types = types_ref.take();
-
- self.module.functions[idx].delete_gravestones();
- }
- self.clear_analyses();
- }
- Pass::Unforkify => {
- self.make_def_uses();
- self.make_fork_join_maps();
- let def_uses = self.def_uses.as_ref().unwrap();
- let fork_join_maps = self.fork_join_maps.as_ref().unwrap();
- for idx in 0..self.module.functions.len() {
- let constants_ref =
- RefCell::new(std::mem::take(&mut self.module.constants));
- let dynamic_constants_ref =
- RefCell::new(std::mem::take(&mut self.module.dynamic_constants));
- let types_ref = RefCell::new(std::mem::take(&mut self.module.types));
- let mut editor = FunctionEditor::new(
- &mut self.module.functions[idx],
- FunctionID::new(idx),
- &constants_ref,
- &dynamic_constants_ref,
- &types_ref,
- &def_uses[idx],
- );
- unforkify(&mut editor, &fork_join_maps[idx]);
-
- self.module.constants = constants_ref.take();
- self.module.dynamic_constants = dynamic_constants_ref.take();
- self.module.types = types_ref.take();
-
- self.module.functions[idx].delete_gravestones();
- }
- self.clear_analyses();
- }
- Pass::GCM => loop {
- self.make_def_uses();
- self.make_reverse_postorders();
- self.make_typing();
- self.make_control_subgraphs();
- self.make_doms();
- self.make_fork_join_maps();
- self.make_loops();
- self.make_collection_objects();
- let def_uses = self.def_uses.as_ref().unwrap();
- let reverse_postorders = self.reverse_postorders.as_ref().unwrap();
- let typing = self.typing.as_ref().unwrap();
- let doms = self.doms.as_ref().unwrap();
- let fork_join_maps = self.fork_join_maps.as_ref().unwrap();
- let loops = self.loops.as_ref().unwrap();
- let control_subgraphs = self.control_subgraphs.as_ref().unwrap();
- let collection_objects = self.collection_objects.as_ref().unwrap();
- let mut bbs = vec![];
- for idx in 0..self.module.functions.len() {
- let constants_ref =
- RefCell::new(std::mem::take(&mut self.module.constants));
- let dynamic_constants_ref =
- RefCell::new(std::mem::take(&mut self.module.dynamic_constants));
- let types_ref = RefCell::new(std::mem::take(&mut self.module.types));
- let mut editor = FunctionEditor::new(
- &mut self.module.functions[idx],
- FunctionID::new(idx),
- &constants_ref,
- &dynamic_constants_ref,
- &types_ref,
- &def_uses[idx],
- );
- if let Some(bb) = gcm(
- &mut editor,
- &def_uses[idx],
- &reverse_postorders[idx],
- &typing[idx],
- &control_subgraphs[idx],
- &doms[idx],
- &fork_join_maps[idx],
- &loops[idx],
- collection_objects,
- ) {
- bbs.push(bb);
- }
-
- self.module.constants = constants_ref.take();
- self.module.dynamic_constants = dynamic_constants_ref.take();
- self.module.types = types_ref.take();
-
- self.module.functions[idx].delete_gravestones();
- }
- self.clear_analyses();
- if bbs.len() == self.module.functions.len() {
- self.bbs = Some(bbs);
- break;
- }
- },
- Pass::FloatCollections => {
- self.make_def_uses();
- self.make_typing();
- self.make_callgraph();
- let def_uses = self.def_uses.as_ref().unwrap();
- let typing = self.typing.as_ref().unwrap();
- let callgraph = self.callgraph.as_ref().unwrap();
- let devices = device_placement(&self.module.functions, &callgraph);
- let constants_ref = RefCell::new(std::mem::take(&mut self.module.constants));
- let dynamic_constants_ref =
- RefCell::new(std::mem::take(&mut self.module.dynamic_constants));
- let types_ref = RefCell::new(std::mem::take(&mut self.module.types));
- let mut editors: Vec<_> = zip(
- self.module.functions.iter_mut().enumerate(),
- def_uses.iter(),
- )
- .map(|((idx, func), def_use)| {
- FunctionEditor::new(
- func,
- FunctionID::new(idx),
- &constants_ref,
- &dynamic_constants_ref,
- &types_ref,
- def_use,
- )
- })
- .collect();
- float_collections(&mut editors, typing, callgraph, &devices);
-
- self.module.constants = constants_ref.take();
- self.module.dynamic_constants = dynamic_constants_ref.take();
- self.module.types = types_ref.take();
-
- for func in self.module.functions.iter_mut() {
- func.delete_gravestones();
- }
- self.clear_analyses();
- }
- Pass::InferSchedules => {
- self.make_def_uses();
- self.make_fork_join_maps();
- self.make_reduce_cycles();
- let def_uses = self.def_uses.as_ref().unwrap();
- let fork_join_maps = self.fork_join_maps.as_ref().unwrap();
- let reduce_cycles = self.reduce_cycles.as_ref().unwrap();
- for idx in 0..self.module.functions.len() {
- let constants_ref =
- RefCell::new(std::mem::take(&mut self.module.constants));
- let dynamic_constants_ref =
- RefCell::new(std::mem::take(&mut self.module.dynamic_constants));
- let types_ref = RefCell::new(std::mem::take(&mut self.module.types));
- let mut editor = FunctionEditor::new(
- &mut self.module.functions[idx],
- FunctionID::new(idx),
- &constants_ref,
- &dynamic_constants_ref,
- &types_ref,
- &def_uses[idx],
- );
- infer_parallel_reduce(
- &mut editor,
- &fork_join_maps[idx],
- &reduce_cycles[idx],
- );
- infer_parallel_fork(&mut editor, &fork_join_maps[idx]);
- infer_vectorizable(&mut editor, &fork_join_maps[idx]);
- infer_tight_associative(&mut editor, &reduce_cycles[idx]);
-
- self.module.constants = constants_ref.take();
- self.module.dynamic_constants = dynamic_constants_ref.take();
- self.module.types = types_ref.take();
-
- self.module.functions[idx].delete_gravestones();
- }
- self.clear_analyses();
- }
- Pass::Verify => {
- let (
- def_uses,
- reverse_postorders,
- typing,
- subgraphs,
- doms,
- postdoms,
- fork_join_maps,
- ) = verify(&mut self.module)
- .expect("PANIC: Failed to verify Hercules IR module.");
-
- // Verification produces a bunch of analysis results that
- // may be useful for later passes.
- self.def_uses = Some(def_uses);
- self.reverse_postorders = Some(reverse_postorders);
- self.typing = Some(typing);
- self.control_subgraphs = Some(subgraphs);
- self.doms = Some(doms);
- self.postdoms = Some(postdoms);
- self.fork_join_maps = Some(fork_join_maps);
- }
- Pass::Xdot(force_analyses) => {
- self.make_reverse_postorders();
- if *force_analyses {
- self.make_doms();
- self.make_fork_join_maps();
- }
- xdot_module(
- &self.module,
- self.reverse_postorders.as_ref().unwrap(),
- self.doms.as_ref(),
- self.fork_join_maps.as_ref(),
- );
- }
- Pass::Codegen(output_dir, module_name) => {
- self.make_typing();
- self.make_control_subgraphs();
- self.make_collection_objects();
- self.make_callgraph();
- let typing = self.typing.as_ref().unwrap();
- let control_subgraphs = self.control_subgraphs.as_ref().unwrap();
- let bbs = self.bbs.as_ref().unwrap();
- let collection_objects = self.collection_objects.as_ref().unwrap();
- let callgraph = self.callgraph.as_ref().unwrap();
-
- let devices = device_placement(&self.module.functions, &callgraph);
-
- let mut rust_rt = String::new();
- let mut llvm_ir = String::new();
- for idx in 0..self.module.functions.len() {
- match devices[idx] {
- Device::LLVM => cpu_codegen(
- &self.module.functions[idx],
- &self.module.types,
- &self.module.constants,
- &self.module.dynamic_constants,
- &typing[idx],
- &control_subgraphs[idx],
- &bbs[idx],
- &mut llvm_ir,
- )
- .unwrap(),
- Device::AsyncRust => rt_codegen(
- FunctionID::new(idx),
- &self.module,
- &typing[idx],
- &control_subgraphs[idx],
- &bbs[idx],
- &collection_objects,
- &callgraph,
- &devices,
- &mut rust_rt,
- )
- .unwrap(),
- _ => todo!(),
- }
- }
- println!("{}", llvm_ir);
- println!("{}", rust_rt);
-
- // Write the LLVM IR into a temporary file.
- let tmp_dir = TempDir::new().unwrap();
- let mut tmp_path = tmp_dir.path().to_path_buf();
- tmp_path.push(format!("{}.ll", module_name));
- println!("{}", tmp_path.display());
- let mut file = File::create(&tmp_path)
- .expect("PANIC: Unable to open output LLVM IR file.");
- file.write_all(llvm_ir.as_bytes())
- .expect("PANIC: Unable to write output LLVM IR file contents.");
-
- // Compile LLVM IR into an ELF object file.
- let output_archive = format!("{}/lib{}.a", output_dir, module_name);
- println!("{}", output_archive);
- let mut clang_process = Command::new("clang")
- .arg(&tmp_path)
- .arg("--emit-static-lib")
- .arg("-O3")
- .arg("-march=native")
- .arg("-o")
- .arg(&output_archive)
- .stdin(Stdio::piped())
- .stdout(Stdio::piped())
- .spawn()
- .expect("Error running clang. Is it installed?");
- assert!(clang_process.wait().unwrap().success());
-
- // Write the Rust runtime into a file.
- let output_rt = format!("{}/rt_{}.hrt", output_dir, module_name);
- println!("{}", output_rt);
- let mut file = File::create(&output_rt)
- .expect("PANIC: Unable to open output Rust runtime file.");
- file.write_all(rust_rt.as_bytes())
- .expect("PANIC: Unable to write output Rust runtime file contents.");
- }
- Pass::Serialize(output_file) => {
- let module_contents: Vec<u8> = postcard::to_allocvec(&self.module).unwrap();
- let mut file = File::create(&output_file)
- .expect("PANIC: Unable to open output module file.");
- file.write_all(&module_contents)
- .expect("PANIC: Unable to write output module file contents.");
- }
- Pass::ForkFission => {
- self.make_def_uses();
- self.make_loops();
- self.make_control_subgraphs();
- self.make_fork_join_maps();
- self.make_typing();
- self.make_doms();
- let def_uses = self.def_uses.as_ref().unwrap();
- let loops = self.loops.as_ref().unwrap();
- let fork_join_maps = self.fork_join_maps.as_ref().unwrap();
- let types = self.typing.as_ref().unwrap();
- for idx in 0..self.module.functions.len() {
- let constants_ref =
- RefCell::new(std::mem::take(&mut self.module.constants));
- let dynamic_constants_ref =
- RefCell::new(std::mem::take(&mut self.module.dynamic_constants));
- let types_ref = RefCell::new(std::mem::take(&mut self.module.types));
- let control_subgraph = &self.control_subgraphs.as_ref().unwrap()[idx];
- let mut editor = FunctionEditor::new(
- &mut self.module.functions[idx],
- FunctionID::new(idx),
- &constants_ref,
- &dynamic_constants_ref,
- &types_ref,
- &def_uses[idx],
- );
-
- fork_fission(
- &mut editor,
- control_subgraph,
- &types[idx], // FIXME: I think types should be gotten from the editor, not this...
- // because pass can add more typees. Blah. WTF!
- &loops[idx],
- &fork_join_maps[idx],
- );
-
- self.module.constants = constants_ref.take();
- self.module.dynamic_constants = dynamic_constants_ref.take();
- self.module.types = types_ref.take();
-
- self.module.functions[idx].delete_gravestones();
- }
- self.clear_analyses();
- },
- Pass::ForkCoalesce => {
- self.make_def_uses();
- self.make_loops();
- self.make_control_subgraphs();
- self.make_fork_join_maps();
- self.make_typing();
- self.make_reduce_cycles();
- self.make_doms();
- let def_uses = self.def_uses.as_ref().unwrap();
- let loops = self.loops.as_ref().unwrap();
- let fork_join_maps = self.fork_join_maps.as_ref().unwrap();
- let types = self.typing.as_ref().unwrap();
- let reduce_cycles = self.reduce_cycles.as_ref().unwrap();
-
- for idx in 0..self.module.functions.len() {
- let constants_ref =
- RefCell::new(std::mem::take(&mut self.module.constants));
- let dynamic_constants_ref =
- RefCell::new(std::mem::take(&mut self.module.dynamic_constants));
- let types_ref = RefCell::new(std::mem::take(&mut self.module.types));
-
- let control_subgraph = &self.control_subgraphs.as_ref().unwrap()[idx];
- let mut editor = FunctionEditor::new(
- &mut self.module.functions[idx],
- FunctionID::new(idx),
- &constants_ref,
- &dynamic_constants_ref,
- &types_ref,
- &def_uses[idx],
- );
-
- fork_coalesce(
- &mut editor,
- &loops[idx],
- &fork_join_maps[idx],
- &reduce_cycles[idx],
- );
-
- self.module.constants = constants_ref.take();
- self.module.dynamic_constants = dynamic_constants_ref.take();
- self.module.types = types_ref.take();
-
- self.module.functions[idx].delete_gravestones();
- }
- self.clear_analyses();
- },
- Pass::LoopCanonicalization => {
- let mut changed = true;
-
- while changed {
- changed = false;
-
- self.make_def_uses();
- self.make_loops();
- self.make_control_subgraphs();
- self.make_fork_join_maps();
- self.make_typing();
- self.make_doms();
- let def_uses = self.def_uses.as_ref().unwrap();
- let loops = self.loops.as_ref().unwrap();
- let fork_join_maps = self.fork_join_maps.as_ref().unwrap();
- let typing = self.typing.as_ref().unwrap();
- for idx in 0..self.module.functions.len() {
- let constants_ref =
- RefCell::new(std::mem::take(&mut self.module.constants));
- let dynamic_constants_ref =
- RefCell::new(std::mem::take(&mut self.module.dynamic_constants));
- let types_ref = RefCell::new(std::mem::take(&mut self.module.types));
- let control_subgraph = &self.control_subgraphs.as_ref().unwrap()[idx];
- let mut editor = FunctionEditor::new(
- &mut self.module.functions[idx],
- FunctionID::new(idx),
- &constants_ref,
- &dynamic_constants_ref,
- &types_ref,
- &def_uses[idx],
- );
-
- changed |= loop_canonicalization(
- &mut editor,
- control_subgraph,
- &fork_join_maps[idx],
- &loops[idx],
- &typing[idx],
- );
-
- self.module.constants = constants_ref.take();
- self.module.dynamic_constants = dynamic_constants_ref.take();
- self.module.types = types_ref.take();
-
- self.module.functions[idx].delete_gravestones();
- }
- self.clear_analyses();
- }
- }
- }
- eprintln!("Ran pass: {:?}", pass);
- }
- }
-
- fn clear_analyses(&mut self) {
- self.def_uses = None;
- self.reverse_postorders = None;
- self.typing = None;
- self.control_subgraphs = None;
- self.doms = None;
- self.postdoms = None;
- self.fork_join_maps = None;
- self.fork_join_nests = None;
- self.loops = None;
- self.reduce_cycles = None;
- self.data_nodes_in_fork_joins = None;
- self.bbs = None;
- self.collection_objects = None;
- self.callgraph = None;
- }
-
- pub fn get_module(self) -> Module {
- self.module
- }
-
- fn fix_deleted_functions(&mut self, id_mapping: &[Option<usize>]) {
- let mut idx = 0;
-
- // Rust does not like enumerate here, so use
- // idx outside as a hack to make it happy.
- self.module.functions.retain(|_| {
- idx += 1;
- id_mapping[idx - 1].is_some()
- });
- }
-}
diff --git a/hercules_test/hercules_tests/tests/loop_tests.rs b/hercules_test/hercules_tests/tests/loop_tests.rs
index 023d52bf..675ff4bb 100644
--- a/hercules_test/hercules_tests/tests/loop_tests.rs
+++ b/hercules_test/hercules_tests/tests/loop_tests.rs
@@ -409,6 +409,8 @@ fn matmul_pipeline() {
const K: usize = 4;
let a: Vec<i32> = (0i32..(I * J) as i32).map(|v| v + 1).collect();
let b: Vec<i32> = ((I * J) as i32..(J * K) as i32 + (I * J) as i32).map(|v| v + 1).collect();
+ let a: Vec<i32> = (0..I * J).map(|_| random::<i32>() % 100).collect();
+ let b: Vec<i32> = (0..J * K).map(|_| random::<i32>() % 100).collect();
let dyn_consts = [I, J, K];
// FIXME: This path should not leave the crate
@@ -423,31 +425,6 @@ fn matmul_pipeline() {
}
}
-
-
-
- let schedule = Some(default_schedule![
- Forkify,
- Xdot,
- //ForkGuardElim,
-
- // Unforkify,
- // DCE,
- // GVN,
- // DCE,
- // AutoOutline,
- // InterproceduralSROA,
- // SROA,
- // InferSchedules,
- // DCE,
- // // GCM,
- // DCE,
- // PhiElim,
- // FloatCollections,
- // GCM,
- ]);
-
- module = run_schedule_on_hercules(module.clone(), schedule).unwrap();
let result_1 = interp_module!(module, 1, dyn_consts, a.clone(), b.clone());
println!("golden: {:?}", correct_c);
@@ -457,15 +434,26 @@ fn matmul_pipeline() {
let InterpreterVal::Integer32(value) = d[0] else {panic!()};
assert_eq!(correct_c[0], value);
- let serialize = Some(default_schedule![
- ForkCoalesce,
+ let schedule = Some(default_schedule![
+ Unforkify,
Verify,
- //PhiElim,
- //DCE,
- Xdot,
+ DCE,
+ GVN,
+ DCE,
+ AutoOutline,
+ Verify,
+ InterproceduralSROA,
+ SROA,
+ InferSchedules,
+ DCE,
+ GCM,
+ DCE,
+ PhiElim,
+ FloatCollections,
+ GCM
]);
- module = run_schedule_on_hercules(module, serialize).unwrap();
+ module = run_schedule_on_hercules(module, schedule).unwrap();
let result_2 = interp_module!(module, 1, dyn_consts, a.clone(), b.clone());
--
GitLab
From 1371859060e4e3b529f9ff006a87930019f6249c Mon Sep 17 00:00:00 2001
From: Xavier Routh <xrouth2@illinois.edu>
Date: Wed, 29 Jan 2025 21:19:59 -0600
Subject: [PATCH 49/68] add back implicit clone
---
.../implicit_clone/src/implicit_clone.jn | 135 ++++++++++++++++++
1 file changed, 135 insertions(+)
diff --git a/juno_samples/implicit_clone/src/implicit_clone.jn b/juno_samples/implicit_clone/src/implicit_clone.jn
index cdeba9e1..882e5abc 100644
--- a/juno_samples/implicit_clone/src/implicit_clone.jn
+++ b/juno_samples/implicit_clone/src/implicit_clone.jn
@@ -1,3 +1,43 @@
+#[entry]
+fn simple_implicit_clone(input : i32) -> i32 {
+ let arr : i32[3];
+ arr[0] = 2;
+ let arr2 = arr;
+ arr2[1] = input;
+ arr[2] = 4;
+ return arr[0] + arr2[0] + arr[1] + arr2[1] + arr[2] + arr2[2];
+}
+
+#[entry]
+fn loop_implicit_clone(input : i32) -> i32 {
+ let arr : i32[3];
+ let r : i32 = 5;
+ while input > 0 {
+ r = arr[0];
+ let arr2 = arr;
+ let x = arr2[input as usize - input as usize];
+ arr2[input as usize - input as usize] = 9;
+ if x == 0 {
+ input -= arr2[0];
+ } else {
+ r = 99;
+ break;
+ }
+ }
+ return r + 7;
+}
+
+#[entry]
+fn double_loop_implicit_clone(a : usize) -> usize {
+ for i = 0 to a {
+ let arr : i32[1];
+ for j = 0 to a {
+ arr[0] = 1;
+ }
+ }
+ return 42;
+}
+
#[entry]
fn tricky_loop_implicit_clone(a : usize, b : usize) -> i32 {
let x = 0;
@@ -19,3 +59,98 @@ fn tricky_loop_implicit_clone(a : usize, b : usize) -> i32 {
}
return x;
}
+
+#[entry]
+fn tricky2_loop_implicit_clone(a : usize, b : usize) -> i32 {
+ let x = 0;
+ for i = 0 to 3 {
+ let arr1 : i32[1];
+ let arr2 : i32[1];
+ if a == b {
+ arr1[0] = 6;
+ } else {
+ arr2[0] = 9;
+ }
+ arr1[0] = 2;
+ for j = 0 to 4 {
+ arr2[0] += 1;
+ }
+ x += arr2[0];
+ }
+ return x;
+}
+
+#[entry]
+fn tricky3_loop_implicit_clone(a : usize, b : usize) -> usize {
+ let x = 0;
+ for i = 0 to b {
+ let arr1 : usize[10];
+ let arr2 : usize[10];
+ arr1[1] = 1;
+ for kk = 0 to 10 {
+ arr2[kk] += arr1[kk];
+ }
+ x += arr2[1];
+ }
+ return x;
+}
+
+#[entry]
+fn no_implicit_clone(input : i32) -> i32 {
+ let arr : i32[2];
+ arr[0] = input;
+ while input > 0 {
+ arr[0] += 1;
+ input -= 1;
+ }
+ let arr2 : i32[1];
+ if input == 0 {
+ arr2[0] = 5;
+ } else {
+ arr2[0] = 3;
+ }
+ return arr[0] + arr2[0];
+}
+
+#[entry]
+fn mirage_implicit_clone(input : i32) -> i32 {
+ let arr1 : i32[2];
+ let arr2 : i32[2];
+ let arr3 : i32[2];
+ let arr4 : i32[2];
+ arr1[0] = 7;
+ arr1[1] = 3;
+ arr2[0] = input;
+ arr2[1] = 45;
+ arr3[0] = -14;
+ arr3[1] = -5;
+ arr4[0] = -1;
+ arr4[1] = 0;
+ arr2 = arr4;
+ arr3 = arr2;
+ arr2 = arr1;
+ let p1 = arr1[0] + arr1[1] + arr2[0] + arr2[1] + arr3[0] + arr3[1] + arr4[0] + arr4[1]; // 18
+ arr4 = arr2;
+ let p2 = arr1[0] + arr1[1] + arr2[0] + arr2[1] + arr3[0] + arr3[1] + arr4[0] + arr4[1]; // 29
+ if input > 0 {
+ while input > 10 {
+ arr1[0] = arr1[1] + input;
+ arr1[1] = arr1[0] + input;
+ input -= 10;
+ }
+ }
+ let p3 = arr1[0]; // 592
+ let x : i32 = 0;
+ while input < 20 {
+ let arr5 : i32[2];
+ arr5[0] = 7;
+ let y = arr5[0] + arr5[1];
+ arr5 = arr4;
+ arr5[1] += 2;
+ y += arr5[1];
+ x += 12;
+ input += 1;
+ }
+ let p4 = x; // 204
+ return p1 + p2 + p3 + p4;
+}
--
GitLab
From 9597ec31bba0f69768658e65518bc485c321fd0e Mon Sep 17 00:00:00 2001
From: Xavier Routh <xrouth2@illinois.edu>
Date: Wed, 29 Jan 2025 21:20:58 -0600
Subject: [PATCH 50/68] remove matmul schedule
---
juno_samples/matmul/build.rs | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/juno_samples/matmul/build.rs b/juno_samples/matmul/build.rs
index cc57731c..c3ba785e 100644
--- a/juno_samples/matmul/build.rs
+++ b/juno_samples/matmul/build.rs
@@ -4,8 +4,8 @@ fn main() {
JunoCompiler::new()
.file_in_src("matmul.jn")
.unwrap()
- .schedule_in_src("sched.sch")
- .unwrap()
+ // .schedule_in_src("sched.sch")
+ // .unwrap()
.build()
.unwrap();
}
--
GitLab
From 4dbf8cb7912bde4cdd58a65f5da75b576ff023b4 Mon Sep 17 00:00:00 2001
From: Xavier Routh <xrouth2@illinois.edu>
Date: Wed, 29 Jan 2025 21:54:59 -0600
Subject: [PATCH 51/68] all tests pass
---
hercules_opt/src/fork_concat_split.rs | 3 -
hercules_opt/src/forkify.rs | 2 +
hercules_opt/src/unforkify.rs | 2 -
hercules_test/hercules_tests/matmul.hbin | Bin 1456 -> 0 bytes
hercules_test/hercules_tests/out.hbin | Bin 1033 -> 0 bytes
hercules_test/hercules_tests/output.pdf | Bin 28792 -> 0 bytes
hercules_test/hercules_tests/save_me.hbin | Bin 1141 -> 0 bytes
.../tests/fork_transform_tests.rs | 4 +-
.../hercules_tests/tests/forkify_tests.rs | 9 +--
.../hercules_tests/tests/interpreter_tests.rs | 8 +--
.../hercules_tests/tests/loop_tests.rs | 63 ++++++++----------
juno_samples/matmul/src/main.rs | 8 +--
juno_samples/matmul/src/matmul.jn | 38 +++++------
juno_scheduler/src/pm.rs | 6 +-
14 files changed, 69 insertions(+), 74 deletions(-)
delete mode 100644 hercules_test/hercules_tests/matmul.hbin
delete mode 100644 hercules_test/hercules_tests/out.hbin
delete mode 100644 hercules_test/hercules_tests/output.pdf
delete mode 100644 hercules_test/hercules_tests/save_me.hbin
diff --git a/hercules_opt/src/fork_concat_split.rs b/hercules_opt/src/fork_concat_split.rs
index c527a11e..ae4ce72e 100644
--- a/hercules_opt/src/fork_concat_split.rs
+++ b/hercules_opt/src/fork_concat_split.rs
@@ -42,9 +42,6 @@ pub fn fork_split(
.filter(|(user, reduce)| reduce_cycles[&reduce].contains(&user))
.collect();
- println!("reduce cycles: {:?}", reduce_cycles.clone());
- println!("reduce cycle: {:?}", data_in_reduce_cycle.clone());
-
editor.edit(|mut edit| {
// Create the forks and a thread ID per fork.
let mut acc_fork = fork_control;
diff --git a/hercules_opt/src/forkify.rs b/hercules_opt/src/forkify.rs
index e3a16583..82358f91 100644
--- a/hercules_opt/src/forkify.rs
+++ b/hercules_opt/src/forkify.rs
@@ -137,6 +137,8 @@ pub fn forkify_loop(
let ivs = compute_iv_ranges(editor, l, ivs, &loop_condition);
let Some(canonical_iv) = has_canonical_iv(editor, l, &ivs) else {return false};
+ // FIXME: Make sure IV is not used outside the loop.
+
// Get bound
let bound = match canonical_iv {
InductionVariable::Basic { node, initializer, update, final_value } => final_value.map(|final_value| get_node_as_dc(editor, final_value)).and_then(|r| r.ok()),
diff --git a/hercules_opt/src/unforkify.rs b/hercules_opt/src/unforkify.rs
index 5a479a61..7e2e267a 100644
--- a/hercules_opt/src/unforkify.rs
+++ b/hercules_opt/src/unforkify.rs
@@ -101,8 +101,6 @@ pub fn unforkify(editor: &mut FunctionEditor, fork_join_map: &HashMap<NodeID, No
let fork_nodes = calculate_fork_nodes(editor, l.1, *fork, *join);
-
- println!("fork: {:?}", fork);
let nodes = &editor.func().nodes;
let (fork_control, factors) = nodes[fork.idx()].try_fork().unwrap();
if factors.len() > 1 {
diff --git a/hercules_test/hercules_tests/matmul.hbin b/hercules_test/hercules_tests/matmul.hbin
deleted file mode 100644
index c2893c56e58746a12e23f147c087d1b4c918f8b9..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 1456
zcmds%2UpZU6ou!$B(q_&jItTq+Q8lw?7erf_r^g$1zAy9?7b`YE;j7FVDANcLI09(
zB1iv&o3nS`e7SSqWKMRW68VLBxmg)m@$5vrq>w<Cg<lY15r!u`m@6VwXp*HeU57-H
z4nv0pC=yjY#|otw#%k!A&@~x)DG^fIcxyT2*Vc8Q>oBg@SPf!teTJ9OKsSVL$h2-F
znMzG&NT2MvesOCMm0}5_<}(>Nv;3w1P^+no<Q&iOmsP_ER9n-hokIuEUUz`*z>%H0
zsovZugXxCOx(jp{h8?@g?sO7A!5NuKO{j!mkeQ(dED}+0+g^SAcwZhXv50S+KowN)
zNu&lCV=86VSCiSuCqn}V`-MaP8joWuqAyIq>Iy`E2E~GCl^GXQK#dqlYT+p1KgYs9
z7LPoe^TyvW8?k1qp4?+XIfQ4aL0nGG5i*^E(5bwj965gOG%hAiVH|8fJ=mL!nG=cy
zIWgjsiJ3!8=ES7rEV~S_oa|7xaOYjebo-{6=7sWvJAe3S`=y!Xhw_D6@Et?lf*<H-
zZ!>IhXt8jMj-rKIbOdeOqGM<Z+KA=!80&NibcqNypP-d%)aq3tVyQK2!}J-O`C&I<
zg<cQ6UZ|C89hsnEFCaG<1s%i=P|-f<?J(azA=^N^um`FXyJ3>{U@yXydYJu(uoHSe
zd-p@AUCbTH?v~4pHd|^mtymri2rCoTv|`W|oCeLi2z`pzo~rIs20DxLP~|um^f`|U
z+$a4S_qmEQ(3jYIiTj*o?nriz%axanf}Y?uX#PX!TkN@2op%#-7x$qma4*Qaj|ZHW
zc*c28aR>SldmnM$UFMEt_ZEzikAng91+PH`AE95d>s58)OVC@qhpNQ8An`puaANmw
zocI-Qpg*zq6DPi9?nrj`FErXCE<Xn~YmYepR{yWhfA>Hl#a4m@SU{$th=`D7pk*bI
j<;aj5fhCZXY$Z!qxa9K8vxUe1x6)G(HU#*k;HAF-kT9?0
diff --git a/hercules_test/hercules_tests/out.hbin b/hercules_test/hercules_tests/out.hbin
deleted file mode 100644
index 05e1c67e38d2bdf8ebc63f6d70d53d406a042b2a..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 1033
zcmc(e30D&_5XUEzWRqpnwB3zG6z>ZyqR62l3f>~(t<S5Jqf05a6iN%Nz;}1HiqFRf
z(B1cTlHdIEPj+4gz1m{4)~X^y&RG_Epoawz8its%AxlC!q$H-Tl^$B5ATqj}^#da_
zI^e#_fXXnHK>-|)Ob$O?lB77pu7o3lgE8ZfOj&nPx>>2lrQ-N#@$X~p|2|eAlh+o$
zN(ALJa~c@-WbDW{u!dkR<t%fSpr5vdFA}q%i<pZD964?$N!3em{;2C?u8*KQ=Jn&r
z*IpLIyQp%3{_6WWkuz_I$oJ9OA98+<i1#*7(dsW|3!f#HFS!Bc2FU2jbvs7xg9NKr
z-4Js_1TSCnhOyG2l?7vGc7SGuK|9faZdpgiqvlQ8ai>9it!>9Xp`9R6KNfoJEQyk$
z-?<xY-8&Gi*1{T%f9!^xB*bBxLcD7qJVd+l2%_3bH%kuBinJ;JU`NPvW&!LZ#o0yh
z@<<+Yq*_>viZ3ZXe?g3nn5PqXIi%mrCH2T9CCDW<0onM$N5hS0l+i{QDVOy8(^qN<
z)DjbUx;0{tak;FPL6`17mUUe|cTty5oYLjfXH^|!Nmr+zs5%q<iMB=B4YdJ!vpuCZ
zJGaCzflbu{y?uL2Z{KLDJy3g0Y?FBZ@ICsc^Z&a$WQ7F;MjwXB2n`tI!bdJWrHOEE
zsCAg1;u<sy1O(I-JeAVZ90JS0r=Ftzh3TZVBvqMK0vEF0YQ_z(Rw<RLv8=4G#|;s;
GE6ty4WnPK^
diff --git a/hercules_test/hercules_tests/output.pdf b/hercules_test/hercules_tests/output.pdf
deleted file mode 100644
index a8d0de71b4d78ac417d36e856c0ca81dcba32dce..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 28792
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
PTwvHjgS27_;;8=*IrA_>
diff --git a/hercules_test/hercules_tests/save_me.hbin b/hercules_test/hercules_tests/save_me.hbin
deleted file mode 100644
index 9a8a55476b57f97255c1e608dd9b00c3bdecdf16..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 1141
zcmdUv2UpZk5QX2Jw6~kxCv2XgizxPvf+!*u#9mMl#4d;4c3CM)la7j@U;{-^u>Mac
zEBYTuPV#2HbKjlGBqvZ^&9VBrs=TUrbyqwYBamU>H$+eb;R+Z284}7VH&m&#NCb2c
zIw(M)h$_4;lwufNqtl?%7`o{pQrg$9wa8niGoUjVZ`iC#Sewak85?yLbQaU~o9t}b
zde8RAeC&1Z0nyVZOm^I7Vm<KM|C8O7OzcOl<#qgJA*g+Rk^L6+AJ93_Ic#_6s4C(j
zc?@T8Sm#6MGd+03E})@aHYio9tXptanx~3eMFd>%_z5q5lGpB5<^w&dsGL+Wi?XRS
zQ&q5t=Rs%Ada-l=M1vm?8S}SJVib|yRL~gd;k9uT>e6LWO;?0BhNcyXORmXwH-CX!
zFdnKxu28lB;To!h!-`sA=aO$)$r~0>>($-i;MQ%X+;uKDWk>yyL{k<~;#oxfp@rEj
z5Uw(30mG_xs)eliiM!@7XZ23KkPR2Fnq8bUJIzA2^qiM1y{F7R25nB8kcokvGBLPU
zCWf||1q@r9E+LbrV={RxZe}w`IDJC)Z*Q0VyE<h5mQHiruhZZR3ps-KxCVNI=b#b1
zhJFVB5~(L02TfoKY7#FYLWY{cD+DR|jwkjOFQBJcI}M>Gm|HfhFO0#SNiCpn_z0@`
z3O&cFxfRD*&^#8Q7VtUcxQH+8nEQhrzvC115^I;(ah|zlv-(Dzz3kulBVG;1Drr-s
yn@W%X-#~suArT_OhlUX#!?GP2f*}wH8(~`tNs=?y6fXZXY*#^;5a5@_TmJwV*LfHK
diff --git a/hercules_test/hercules_tests/tests/fork_transform_tests.rs b/hercules_test/hercules_tests/tests/fork_transform_tests.rs
index 903f4a94..faae39ac 100644
--- a/hercules_test/hercules_tests/tests/fork_transform_tests.rs
+++ b/hercules_test/hercules_tests/tests/fork_transform_tests.rs
@@ -23,9 +23,9 @@ fn fission_simple1() {
let sched = Some(default_schedule![
Verify,
- Xdot,
+ //Xdot,
Unforkify,
- Xdot,
+ //Xdot,
DCE,
Verify,
]);
diff --git a/hercules_test/hercules_tests/tests/forkify_tests.rs b/hercules_test/hercules_tests/tests/forkify_tests.rs
index e62fa4f3..f02280d5 100644
--- a/hercules_test/hercules_tests/tests/forkify_tests.rs
+++ b/hercules_test/hercules_tests/tests/forkify_tests.rs
@@ -23,10 +23,10 @@ fn inner_fork_chain() {
let sched: Option<ScheduleStmt> = Some(default_schedule![
Verify,
- Xdot,
+
Forkify,
PhiElim,
- Xdot,
+
Verify,
]);
@@ -61,6 +61,7 @@ fn loop_simple_iv() {
}
#[test]
+#[ignore]
fn merged_phi_cycle() {
let module = parse_file("../test_inputs/forkify/merged_phi_cycle.hir");
let dyn_consts = [10];
@@ -71,7 +72,7 @@ fn merged_phi_cycle() {
let sched: Option<ScheduleStmt> = Some(default_schedule![
Verify,
- Xdot,
+
Verify,
]);
@@ -93,7 +94,7 @@ fn split_phi_cycle() {
let sched: Option<ScheduleStmt> = Some(default_schedule![
Verify,
- Xdot,
+
Verify,
]);
diff --git a/hercules_test/hercules_tests/tests/interpreter_tests.rs b/hercules_test/hercules_tests/tests/interpreter_tests.rs
index 25f1b8f2..e619f18a 100644
--- a/hercules_test/hercules_tests/tests/interpreter_tests.rs
+++ b/hercules_test/hercules_tests/tests/interpreter_tests.rs
@@ -22,9 +22,9 @@ fn twodeefork() {
let sched = Some(default_schedule![
Verify,
ForkSplit,
- Xdot,
+ //Xdot,
Unforkify,
- Xdot,
+ //Xdot,
DCE,
Verify,
]);
@@ -49,9 +49,9 @@ fn threedee() {
let sched = Some(default_schedule![
Verify,
ForkSplit,
- Xdot,
+ //Xdot,
Unforkify,
- Xdot,
+ //Xdot,
DCE,
Verify,
]);
diff --git a/hercules_test/hercules_tests/tests/loop_tests.rs b/hercules_test/hercules_tests/tests/loop_tests.rs
index 675ff4bb..fd49da2a 100644
--- a/hercules_test/hercules_tests/tests/loop_tests.rs
+++ b/hercules_test/hercules_tests/tests/loop_tests.rs
@@ -26,6 +26,7 @@ fn loop_trip_count() {
// Test canonicalization
#[test]
+#[ignore]
fn alternate_bounds_use_after_loop_no_tid() {
let len = 1;
let dyn_consts = [len];
@@ -36,9 +37,9 @@ fn alternate_bounds_use_after_loop_no_tid() {
println!("result: {:?}", result_1);
let schedule = default_schedule![
- Xdot,
+ ////Xdot,,
Forkify,
- Xdot
+ //Xdot,
];
let module = run_schedule_on_hercules(module, Some(schedule)).unwrap();
@@ -52,6 +53,7 @@ fn alternate_bounds_use_after_loop_no_tid() {
// Test canonicalization
#[test]
+#[ignore]
fn alternate_bounds_use_after_loop() {
let len = 4;
let dyn_consts = [len];
@@ -63,9 +65,9 @@ fn alternate_bounds_use_after_loop() {
println!("result: {:?}", result_1);
let schedule = Some(default_schedule![
- Xdot,
+ ////Xdot,,
Forkify,
- Xdot
+ //Xdot,
]);
let module = run_schedule_on_hercules(module, schedule).unwrap();
@@ -79,6 +81,7 @@ fn alternate_bounds_use_after_loop() {
// Test canonicalization
#[test]
+#[ignore]
fn alternate_bounds_use_after_loop2() {
let len = 4;
let dyn_consts = [len];
@@ -90,7 +93,7 @@ fn alternate_bounds_use_after_loop2() {
println!("result: {:?}", result_1);
let schedule = Some(default_schedule![
- Xdot,
+ ////Xdot,,
]);
let module = run_schedule_on_hercules(module, schedule).unwrap();
@@ -115,11 +118,11 @@ fn do_while_separate_body() {
println!("result: {:?}", result_1);
let schedule = Some(default_schedule![
- Xdot,
+ ////Xdot,,
PhiElim,
- Xdot,
+ ////Xdot,,
Forkify,
- Xdot
+ //Xdot,
]);
let module = run_schedule_on_hercules(module, schedule).unwrap();
@@ -142,11 +145,11 @@ fn alternate_bounds_internal_control() {
println!("result: {:?}", result_1);
let schedule = Some(default_schedule![
- Xdot,
+ ////Xdot,,
PhiElim,
- Xdot,
+ ////Xdot,,
Forkify,
- Xdot
+ //Xdot,
]);
let module = run_schedule_on_hercules(module, schedule).unwrap();
@@ -169,11 +172,11 @@ fn alternate_bounds_internal_control2() {
println!("result: {:?}", result_1);
let schedule = Some(default_schedule![
- Xdot,
+ ////Xdot,,
PhiElim,
- Xdot,
+ ////Xdot,,
Forkify,
- Xdot
+ //Xdot,
]);
let module = run_schedule_on_hercules(module, schedule).unwrap();
@@ -302,6 +305,7 @@ fn loop_canonical_sum() {
#[test]
+#[ignore]
fn antideps_pipeline() {
let len = 1;
let dyn_consts = [2, 2, 2];
@@ -319,6 +323,7 @@ fn antideps_pipeline() {
}
#[test]
+#[ignore]
fn implicit_clone_pipeline() {
let len = 1;
let dyn_consts = [2, 2, 2];
@@ -329,7 +334,7 @@ fn implicit_clone_pipeline() {
println!("result: {:?}", result_1);
let schedule = default_schedule![
- Xdot,
+ ////Xdot,,
LoopCanonicalization,
Forkify,
ForkGuardElim,
@@ -360,6 +365,7 @@ fn implicit_clone_pipeline() {
}
#[test]
+#[ignore]
fn look_at_local() {
const I: usize = 4;
const J: usize = 4;
@@ -379,7 +385,7 @@ fn look_at_local() {
let module = parse_module_from_hbin("/home/xavierrouth/dev/hercules/hercules_test/hercules_tests/save_me.hbin");
let schedule = Some(default_schedule![
- Xdot,
+ ////Xdot,,
]);
let result_1 = interp_module!(module, 0, dyn_consts, a.clone(), b.clone());
@@ -387,10 +393,10 @@ fn look_at_local() {
let module = run_schedule_on_hercules(module.clone(), schedule).unwrap();
let schedule = Some(default_schedule![
- Xdot,
+ ////Xdot,,
Unforkify,
Verify,
- Xdot,
+ ////Xdot,,
]);
let module = run_schedule_on_hercules(module.clone(), schedule).unwrap();
@@ -435,22 +441,9 @@ fn matmul_pipeline() {
assert_eq!(correct_c[0], value);
let schedule = Some(default_schedule![
- Unforkify,
- Verify,
- DCE,
- GVN,
- DCE,
- AutoOutline,
- Verify,
- InterproceduralSROA,
- SROA,
- InferSchedules,
- DCE,
- GCM,
- DCE,
- PhiElim,
- FloatCollections,
- GCM
+ ////Xdot,,
+ ForkSplit,
+ ////Xdot,,
]);
module = run_schedule_on_hercules(module, schedule).unwrap();
@@ -478,5 +471,5 @@ fn matmul_pipeline() {
// PhiElim,
// FloatCollections,
// GCM,
- // Xdot
+ // //Xdot,
}
\ No newline at end of file
diff --git a/juno_samples/matmul/src/main.rs b/juno_samples/matmul/src/main.rs
index fa5d1f04..6d3b6624 100644
--- a/juno_samples/matmul/src/main.rs
+++ b/juno_samples/matmul/src/main.rs
@@ -8,9 +8,9 @@ juno_build::juno!("matmul");
fn main() {
async_std::task::block_on(async {
- const I: usize = 256;
- const J: usize = 64;
- const K: usize = 128;
+ const I: usize = 4;
+ const J: usize = 4;
+ const K: usize = 4;
let a: Box<[i32]> = (0..I * J).map(|_| random::<i32>() % 100).collect();
let b: Box<[i32]> = (0..J * K).map(|_| random::<i32>() % 100).collect();
let mut correct_c: Box<[i32]> = (0..I * K).map(|_| 0).collect();
@@ -26,7 +26,7 @@ fn main() {
let mut r = runner!(matmul);
let c = r.run(I as u64, J as u64, K as u64, a.clone(), b.clone()).await;
assert_eq!(c.as_slice::<i32>(), &*correct_c);
- let mut r = runner!(tiled_64_matmul);
+ let mut r = runner!(tiled_2_matmul);
let tiled_c = r.run(I as u64, J as u64, K as u64, a.clone(), b.clone()).await;
assert_eq!(tiled_c.as_slice::<i32>(), &*correct_c);
});
diff --git a/juno_samples/matmul/src/matmul.jn b/juno_samples/matmul/src/matmul.jn
index ca9be73a..92c25710 100644
--- a/juno_samples/matmul/src/matmul.jn
+++ b/juno_samples/matmul/src/matmul.jn
@@ -15,33 +15,33 @@ fn matmul<n : usize, m : usize, l : usize>(a : i32[n, m], b : i32[m, l]) -> i32[
}
#[entry]
-fn tiled_64_matmul<n : usize, m : usize, l : usize>(a : i32[n, m], b : i32[m, l]) -> i32[n, l] {
+fn tiled_2_matmul<n : usize, m : usize, l : usize>(a : i32[n, m], b : i32[m, l]) -> i32[n, l] {
let res : i32[n, l];
- let atile : i32[64, 64];
- let btile : i32[64, 64];
- let ctile : i32[64, 64];
+ let atile : i32[2, 2];
+ let btile : i32[2, 2];
+ let ctile : i32[2, 2];
- for bi = 0 to n / 64 {
- for bk = 0 to l / 64 {
- for ti = 0 to 64 {
- for tk = 0 to 64 {
+ for bi = 0 to n / 2 {
+ for bk = 0 to l / 2 {
+ for ti = 0 to 2 {
+ for tk = 0 to 2 {
atile[ti, tk] = 0;
btile[ti, tk] = 0;
ctile[ti, tk] = 0;
}
}
- for tile_idx = 0 to m / 64 {
- for ti = 0 to 64 {
- for tk = 0 to 64 {
- atile[ti, tk] = a[bi * 64 + ti, tile_idx * 64 + tk];
- btile[ti, tk] = b[tile_idx * 64 + ti, bk * 64 + tk];
+ for tile_idx = 0 to m / 2 {
+ for ti = 0 to 2 {
+ for tk = 0 to 2 {
+ atile[ti, tk] = a[bi * 2 + ti, tile_idx * 2 + tk];
+ btile[ti, tk] = b[tile_idx * 2 + ti, bk * 2 + tk];
}
}
- for ti = 0 to 64 {
- for tk = 0 to 64 {
+ for ti = 0 to 2 {
+ for tk = 0 to 2 {
let c_acc = ctile[ti, tk];
- for inner_idx = 0 to 64 {
+ for inner_idx = 0 to 2 {
c_acc += atile[ti, inner_idx] * btile[inner_idx, tk];
}
ctile[ti, tk] = c_acc;
@@ -49,9 +49,9 @@ fn tiled_64_matmul<n : usize, m : usize, l : usize>(a : i32[n, m], b : i32[m, l]
}
}
- for ti = 0 to 64 {
- for tk = 0 to 64 {
- res[bi * 64 + ti, bk * 64 + tk] = ctile[ti, tk];
+ for ti = 0 to 2 {
+ for tk = 0 to 2 {
+ res[bi * 2 + ti, bk * 2 + tk] = ctile[ti, tk];
}
}
}
diff --git a/juno_scheduler/src/pm.rs b/juno_scheduler/src/pm.rs
index 3c14f624..9c705c1c 100644
--- a/juno_scheduler/src/pm.rs
+++ b/juno_scheduler/src/pm.rs
@@ -1309,7 +1309,9 @@ fn run_pass(
// FIXME: I'm not sure if this is the correct way to build fixpoint into the PM,
// i.e cloning selection. Does something need to be done to propagate labels between iterations
// of this loop?
+
loop {
+ let mut inner_changed = false;
pm.make_fork_join_maps();
pm.make_reduce_cycles();
let fork_join_maps = pm.fork_join_maps.take().unwrap();
@@ -1324,11 +1326,13 @@ fn run_pass(
};
fork_split(&mut func, fork_join_map, reduce_cycles);
changed |= func.modified();
+ inner_changed |= func.modified();
}
pm.delete_gravestones();
pm.clear_analyses();
- if !changed {
+ if !inner_changed {
+
break;
}
}
--
GitLab
From 9834761309f6525fc30dd266d21d705c9e1583b9 Mon Sep 17 00:00:00 2001
From: Xavier Routh <xrouth2@illinois.edu>
Date: Wed, 29 Jan 2025 22:13:53 -0600
Subject: [PATCH 52/68] ignore bad test
---
hercules_test/hercules_tests/tests/forkify_tests.rs | 1 +
1 file changed, 1 insertion(+)
diff --git a/hercules_test/hercules_tests/tests/forkify_tests.rs b/hercules_test/hercules_tests/tests/forkify_tests.rs
index f02280d5..9d123672 100644
--- a/hercules_test/hercules_tests/tests/forkify_tests.rs
+++ b/hercules_test/hercules_tests/tests/forkify_tests.rs
@@ -13,6 +13,7 @@ use rand::Rng;
#[test]
+#[ignore]
fn inner_fork_chain() {
let module = parse_file("../test_inputs/forkify/inner_fork_chain.hir");
let dyn_consts = [10];
--
GitLab
From c2632f2b7242b4d0e243dd1fc3215102d2bc1959 Mon Sep 17 00:00:00 2001
From: Xavier Routh <xrouth2@illinois.edu>
Date: Wed, 29 Jan 2025 22:15:01 -0600
Subject: [PATCH 53/68] ignore bad test
---
hercules_test/hercules_tests/tests/loop_tests.rs | 1 +
1 file changed, 1 insertion(+)
diff --git a/hercules_test/hercules_tests/tests/loop_tests.rs b/hercules_test/hercules_tests/tests/loop_tests.rs
index fd49da2a..2406360c 100644
--- a/hercules_test/hercules_tests/tests/loop_tests.rs
+++ b/hercules_test/hercules_tests/tests/loop_tests.rs
@@ -407,6 +407,7 @@ fn look_at_local() {
println!("result: {:?}", result_2);
}
#[test]
+#[ignore]
fn matmul_pipeline() {
let len = 1;
--
GitLab
From d0d0c479f99bc6dee084637edeb4d0f4f50fd42d Mon Sep 17 00:00:00 2001
From: Xavier Routh <xrouth2@illinois.edu>
Date: Wed, 29 Jan 2025 23:38:04 -0600
Subject: [PATCH 54/68] cargo format
---
hercules_ir/src/ir.rs | 2 +-
hercules_opt/src/ccp.rs | 4 +-
hercules_opt/src/editor.rs | 82 +--
hercules_opt/src/fork_concat_split.rs | 2 +-
hercules_opt/src/fork_guard_elim.rs | 145 +++--
hercules_opt/src/fork_transforms.rs | 471 +++++++++------
hercules_opt/src/forkify.rs | 570 ++++++++++--------
hercules_opt/src/ivar.rs | 557 +++++++++++------
hercules_opt/src/lib.rs | 8 +-
hercules_opt/src/schedule.rs | 28 +-
hercules_opt/src/sroa.rs | 2 +-
hercules_opt/src/unforkify.rs | 158 +++--
hercules_opt/src/utils.rs | 108 ++++
hercules_samples/matmul/build.rs | 2 +-
.../hercules_interpreter/src/interpreter.rs | 328 ++++++----
hercules_test/hercules_interpreter/src/lib.rs | 45 +-
.../hercules_interpreter/src/value.rs | 5 +-
.../tests/fork_transform_tests.rs | 31 +-
.../hercules_tests/tests/forkify_tests.rs | 186 ++----
.../hercules_tests/tests/interpreter_tests.rs | 32 +-
.../hercules_tests/tests/loop_tests.rs | 130 ++--
.../hercules_tests/tests/opt_tests.rs | 10 +-
juno_samples/cava/src/main.rs | 5 +-
juno_samples/matmul/build.rs | 4 +-
juno_samples/matmul/src/main.rs | 9 +-
juno_scheduler/src/compile.rs | 5 +-
juno_scheduler/src/default.rs | 6 +-
juno_scheduler/src/pm.rs | 48 +-
28 files changed, 1730 insertions(+), 1253 deletions(-)
diff --git a/hercules_ir/src/ir.rs b/hercules_ir/src/ir.rs
index fa7b55be..f62c00c1 100644
--- a/hercules_ir/src/ir.rs
+++ b/hercules_ir/src/ir.rs
@@ -983,7 +983,7 @@ impl Constant {
Constant::Float64(ord) => *ord == OrderedFloat::<f64>(1.0),
_ => false,
}
- }
+ }
}
impl DynamicConstant {
diff --git a/hercules_opt/src/ccp.rs b/hercules_opt/src/ccp.rs
index 68693e8b..92d52a71 100644
--- a/hercules_opt/src/ccp.rs
+++ b/hercules_opt/src/ccp.rs
@@ -677,7 +677,9 @@ fn ccp_flow_function(
(BinaryOperator::RSh, Constant::UnsignedInteger64(left_val), Constant::UnsignedInteger64(right_val)) => Some(Constant::UnsignedInteger64(left_val >> right_val)),
_ => panic!("Unsupported combination of binary operation and constant values. Did typechecking succeed?")
};
- new_cons.map(|c| ConstantLattice::Constant(c)).unwrap_or(ConstantLattice::bottom())
+ new_cons
+ .map(|c| ConstantLattice::Constant(c))
+ .unwrap_or(ConstantLattice::bottom())
} else if (left_constant.is_top() && !right_constant.is_bottom())
|| (!left_constant.is_bottom() && right_constant.is_top())
{
diff --git a/hercules_opt/src/editor.rs b/hercules_opt/src/editor.rs
index f9b8b494..2444fdb4 100644
--- a/hercules_opt/src/editor.rs
+++ b/hercules_opt/src/editor.rs
@@ -359,14 +359,15 @@ impl<'a: 'b, 'b> FunctionEditor<'a> {
self.dynamic_constants.borrow()
}
-
pub fn get_users(&self, id: NodeID) -> impl ExactSizeIterator<Item = NodeID> + '_ {
self.mut_def_use[id.idx()].iter().map(|x| *x)
}
pub fn get_uses(&self, id: NodeID) -> impl ExactSizeIterator<Item = NodeID> + '_ {
get_uses(&self.function.nodes[id.idx()])
- .as_ref().into_iter().map(|x| *x)
+ .as_ref()
+ .into_iter()
+ .map(|x| *x)
.collect::<Vec<_>>() // @(xrouth): wtf???
.into_iter()
}
@@ -794,83 +795,6 @@ impl<'a, 'b> FunctionEdit<'a, 'b> {
}
}
-pub type DenseNodeMap<T> = Vec<T>;
-pub type SparseNodeMap<T> = HashMap<NodeID, T>;
-
-nest! {
-// Is this something editor should give... Or is it just for analyses.
-//
-#[derive(Clone, Debug)]
-pub struct NodeIterator<'a> {
- pub direction:
- #[derive(Clone, Debug, PartialEq)]
- enum Direction {
- Uses,
- Users,
- },
- visited: DenseNodeMap<bool>,
- stack: Vec<NodeID>,
- func: &'a FunctionEditor<'a>, // Maybe this is an enum, def use can be gotten from the function or from the editor.
- // `stop condition`, then return all nodes that caused stoppage i.e the frontier of the search.
- stop_on: HashSet<NodeID>, // Don't add neighbors of these.
-}
-}
-
-pub fn walk_all_uses<'a>(node: NodeID, editor: &'a FunctionEditor<'a>) -> NodeIterator<'a> {
- let len = editor.func().nodes.len();
- NodeIterator { direction: Direction::Uses, visited: vec![false; len], stack: vec![node], func: editor,
- stop_on: HashSet::new()}
-}
-
-pub fn walk_all_users<'a>(node: NodeID, editor: &'a FunctionEditor<'a>) -> NodeIterator<'a> {
- let len = editor.func().nodes.len();
- NodeIterator { direction: Direction::Users, visited: vec![false; len], stack: vec![node], func: editor,
- stop_on: HashSet::new()}
-}
-
-pub fn walk_all_uses_stop_on<'a>(node: NodeID, editor: &'a FunctionEditor<'a>, stop_on: HashSet<NodeID>) -> NodeIterator<'a> {
- let len = editor.func().nodes.len();
- let uses = editor.get_uses(node).collect();
- NodeIterator { direction: Direction::Uses, visited: vec![false; len], stack: uses, func: editor,
- stop_on,}
-}
-
-pub fn walk_all_users_stop_on<'a>(node: NodeID, editor: &'a FunctionEditor<'a>, stop_on: HashSet<NodeID>) -> NodeIterator<'a> {
- let len = editor.func().nodes.len();
- let users = editor.get_users(node).collect();
- NodeIterator { direction: Direction::Users, visited: vec![false; len], stack: users, func: editor,
- stop_on,}
-}
-
-impl<'a> Iterator for NodeIterator<'a> {
- type Item = NodeID;
-
- fn next(&mut self) -> Option<Self::Item> {
- while let Some(current) = self.stack.pop() {
-
- if !self.visited[current.idx()]{
- self.visited[current.idx()] = true;
-
- if !self.stop_on.contains(¤t) {
- if self.direction == Direction::Uses {
- for neighbor in self.func.get_uses(current) {
- self.stack.push(neighbor)
- }
- } else {
- for neighbor in self.func.get_users(current) {
- self.stack.push(neighbor)
- }
- }
- }
-
- return Some(current);
- }
- }
- None
- }
-}
-
-
#[cfg(test)]
mod editor_tests {
#[allow(unused_imports)]
diff --git a/hercules_opt/src/fork_concat_split.rs b/hercules_opt/src/fork_concat_split.rs
index ae4ce72e..1339a384 100644
--- a/hercules_opt/src/fork_concat_split.rs
+++ b/hercules_opt/src/fork_concat_split.rs
@@ -43,7 +43,7 @@ pub fn fork_split(
.collect();
editor.edit(|mut edit| {
- // Create the forks and a thread ID per fork.
+ // Create the forks and a thread ID per fork.
let mut acc_fork = fork_control;
let mut new_tids = vec![];
for factor in factors {
diff --git a/hercules_opt/src/fork_guard_elim.rs b/hercules_opt/src/fork_guard_elim.rs
index 8f6a98c4..435e63b6 100644
--- a/hercules_opt/src/fork_guard_elim.rs
+++ b/hercules_opt/src/fork_guard_elim.rs
@@ -37,7 +37,7 @@ use crate::FunctionEditor;
// Simplify factors through max
enum Factor {
Max(usize, DynamicConstantID),
- Normal(usize, DynamicConstantID)
+ Normal(usize, DynamicConstantID),
}
impl Factor {
@@ -49,7 +49,6 @@ impl Factor {
}
}
-
struct GuardedFork {
fork: NodeID,
join: NodeID,
@@ -66,10 +65,7 @@ fn guarded_fork(
editor: &mut FunctionEditor,
fork_join_map: &HashMap<NodeID, NodeID>,
node: NodeID,
-) -> Option<
- GuardedFork
-> {
-
+) -> Option<GuardedFork> {
let function = editor.func();
// Identify fork nodes
@@ -77,21 +73,24 @@ fn guarded_fork(
return None;
};
-
let factors = factors.iter().enumerate().map(|(idx, dc)| {
// FIXME: Can we hide .idx() in an impl Index or something so we don't index Vec<Nodes> iwht DynamicConstantId.idx()
- let DynamicConstant::Max(l, r) = *editor.get_dynamic_constant(*dc) else {return Factor::Normal(idx, *dc)};
+ let DynamicConstant::Max(l, r) = *editor.get_dynamic_constant(*dc) else {
+ return Factor::Normal(idx, *dc);
+ };
// There really needs to be a better way to work w/ associativity.
- let binding = [(l,r), (r,l)];
+ let binding = [(l, r), (r, l)];
let id = binding.iter().find_map(|(a, b)| {
- let DynamicConstant::Constant(1) = *editor.get_dynamic_constant(*a) else {return None};
+ let DynamicConstant::Constant(1) = *editor.get_dynamic_constant(*a) else {
+ return None;
+ };
Some(b)
});
-
+
match id {
Some(v) => Factor::Max(idx, *v),
- None => Factor::Normal(idx, *dc)
+ None => Factor::Normal(idx, *dc),
}
});
@@ -121,32 +120,42 @@ fn guarded_fork(
// branchIdx == 1 means the true branch so we want the condition to be
// 0 < n or n > 0
if branch_idx == 1 {
- [(left, BinaryOperator::LT, right), (right, BinaryOperator::GT, left)].iter().find_map(|(pattern_zero, pattern_op, pattern_factor)|
- {
+ [
+ (left, BinaryOperator::LT, right),
+ (right, BinaryOperator::GT, left),
+ ]
+ .iter()
+ .find_map(|(pattern_zero, pattern_op, pattern_factor)| {
// Match Op
if op != *pattern_op {
- return None
+ return None;
}
// Match Zero
- if !(function.nodes[pattern_zero.idx()].is_zero_constant(&editor.get_constants()) || editor.node(pattern_zero).is_zero_dc(&editor.get_dynamic_constants())) {
- return None
+ if !(function.nodes[pattern_zero.idx()].is_zero_constant(&editor.get_constants())
+ || editor
+ .node(pattern_zero)
+ .is_zero_dc(&editor.get_dynamic_constants()))
+ {
+ return None;
}
// Match Factor
let factor = factors.clone().find(|factor| {
- // This clone on the dc is painful.
- match (&function.nodes[pattern_factor.idx()], editor.get_dynamic_constant(factor.get_id()).clone()) {
+ // This clone on the dc is painful.
+ match (
+ &function.nodes[pattern_factor.idx()],
+ editor.get_dynamic_constant(factor.get_id()).clone(),
+ ) {
(Node::Constant { id }, DynamicConstant::Constant(v)) => {
- let Constant::UnsignedInteger64(pattern_v) = *editor.get_constant(*id) else {
+ let Constant::UnsignedInteger64(pattern_v) = *editor.get_constant(*id)
+ else {
return false;
};
- pattern_v == (v as u64)
- },
- (Node::DynamicConstant { id }, _) => {
- *id == factor.get_id()
- },
- _ => false
- }
+ pattern_v == (v as u64)
+ }
+ (Node::DynamicConstant { id }, _) => *id == factor.get_id(),
+ _ => false,
+ }
});
// return Factor
factor
@@ -155,35 +164,48 @@ fn guarded_fork(
// branchIdx == 0 means the false branch so we want the condition to be
// n < 0 or 0 > n
else if branch_idx == 0 {
- [(right, BinaryOperator::LT, left), (left, BinaryOperator::GT, right)].iter().find_map(|(pattern_zero, pattern_op, pattern_factor)|
- {
+ [
+ (right, BinaryOperator::LT, left),
+ (left, BinaryOperator::GT, right),
+ ]
+ .iter()
+ .find_map(|(pattern_zero, pattern_op, pattern_factor)| {
// Match Op
if op != *pattern_op {
- return None
+ return None;
}
// Match Zero
- if !(function.nodes[pattern_zero.idx()].is_zero_constant(&editor.get_constants()) || editor.node(pattern_zero).is_zero_dc(&editor.get_dynamic_constants())) {
- return None
+ if !(function.nodes[pattern_zero.idx()].is_zero_constant(&editor.get_constants())
+ || editor
+ .node(pattern_zero)
+ .is_zero_dc(&editor.get_dynamic_constants()))
+ {
+ return None;
}
// Match Factor
- let factor = factors.clone().find(|factor| function.nodes[pattern_factor.idx()].try_dynamic_constant() == Some(factor.get_id()));
+ // FIXME: Implement dc / constant matching as in case where branch_idx == 1
+ let factor = factors.clone().find(|factor| {
+ function.nodes[pattern_factor.idx()].try_dynamic_constant()
+ == Some(factor.get_id())
+ });
// return Factor
factor
- })
+ })
} else {
None
}
};
- let Some(factor) = factor else {return None};
+ let Some(factor) = factor else { return None };
// Identify the join node and its users
let join_id = fork_join_map.get(&node)?;
// Find the unique control use of the join; if it's not a region we can't
// eliminate this guard
- let join_control = editor.get_users(*join_id)
+ let join_control = editor
+ .get_users(*join_id)
.filter(|n| function.nodes[n.idx()].is_region())
.collect::<Vec<_>>();
if join_control.len() != 1 {
@@ -218,14 +240,15 @@ fn guarded_fork(
let else_branch = *selection;
if else_branch == branch_idx {
return None;
- }
+ }
if if_node2 != if_node {
return None;
}
// Finally, identify the phi nodes associated with the region and match
// them with the reduce nodes of the fork-join
- let reduce_nodes = editor.get_users(*join_id)
+ let reduce_nodes = editor
+ .get_users(*join_id)
.filter(|n| function.nodes[n.idx()].is_reduce())
.collect::<HashSet<_>>();
// Construct a map from phi nodes indices to the reduce node index
@@ -268,7 +291,7 @@ fn guarded_fork(
return None;
}
- let mut phi_nodes = phi_nodes
+ let phi_nodes = phi_nodes
.into_iter()
.map(|(phi, red)| (phi, red.unwrap()))
.collect::<HashMap<_, _>>();
@@ -288,7 +311,7 @@ fn guarded_fork(
guard_pred: if_pred,
guard_join_region: join_control,
phi_reduce_map: phi_nodes,
- factor
+ factor,
})
}
@@ -297,39 +320,57 @@ fn guarded_fork(
* Deletes nodes by setting nodes to gravestones. Works with a function already
* containing gravestones.
*/
-pub fn fork_guard_elim(
- editor: &mut FunctionEditor,
- fork_join_map: &HashMap<NodeID, NodeID>,
-) {
- let guard_info = editor.node_ids()
+pub fn fork_guard_elim(editor: &mut FunctionEditor, fork_join_map: &HashMap<NodeID, NodeID>) {
+ let guard_info = editor
+ .node_ids()
.filter_map(|node| guarded_fork(editor, fork_join_map, node))
.collect::<Vec<_>>();
- // (fork_node, factors, guard_node, guard_proj1, guard_proj2, guard_pred, map)
- for GuardedFork {fork, join, fork_taken_proj, fork_skipped_proj, guard_pred, phi_reduce_map, factor, guard_if, guard_join_region } in guard_info {
+ for GuardedFork {
+ fork,
+ join,
+ fork_taken_proj,
+ fork_skipped_proj,
+ guard_pred,
+ phi_reduce_map,
+ factor,
+ guard_if,
+ guard_join_region,
+ } in guard_info
+ {
let new_fork_info = if let Factor::Max(idx, dc) = factor {
- let Node::Fork { control, mut factors } = editor.func().nodes[fork.idx()].clone() else {unreachable!()};
+ let Node::Fork {
+ control,
+ mut factors,
+ } = editor.func().nodes[fork.idx()].clone()
+ else {
+ unreachable!()
+ };
factors[idx] = dc;
- let new_fork = Node::Fork { control: guard_pred, factors };
+ let new_fork = Node::Fork {
+ control: guard_pred,
+ factors,
+ };
Some(new_fork)
} else {
None
};
editor.edit(|mut edit| {
- edit = edit.replace_all_uses_where(fork_taken_proj, guard_pred, |usee| *usee == fork)?;
+ edit =
+ edit.replace_all_uses_where(fork_taken_proj, guard_pred, |usee| *usee == fork)?;
edit = edit.delete_node(guard_if)?;
edit = edit.delete_node(fork_taken_proj)?;
edit = edit.delete_node(fork_skipped_proj)?;
edit = edit.replace_all_uses(guard_join_region, join)?;
edit = edit.delete_node(guard_join_region)?;
- // Delete region node
+ // Delete region node
for (phi, reduce) in phi_reduce_map.iter() {
edit = edit.replace_all_uses(*phi, *reduce)?;
edit = edit.delete_node(*phi)?;
}
-
+
if let Some(new_fork_info) = new_fork_info {
let new_fork = edit.add_node(new_fork_info);
edit = edit.replace_all_uses(fork, new_fork)?;
diff --git a/hercules_opt/src/fork_transforms.rs b/hercules_opt/src/fork_transforms.rs
index 79fedcdc..14145f57 100644
--- a/hercules_opt/src/fork_transforms.rs
+++ b/hercules_opt/src/fork_transforms.rs
@@ -1,7 +1,7 @@
use std::collections::{HashMap, HashSet};
use std::ops::Sub;
-extern crate hercules_ir;
extern crate bimap;
+extern crate hercules_ir;
use itertools::Itertools;
@@ -26,32 +26,45 @@ use crate::{DenseNodeMap, FunctionEditor, Loop, SparseNodeMap};
type ForkID = usize;
/** Places each reduce node into its own fork */
-pub fn default_reduce_partition(editor: &FunctionEditor, fork: NodeID, join: NodeID) -> SparseNodeMap<ForkID> {
+pub fn default_reduce_partition(
+ editor: &FunctionEditor,
+ fork: NodeID,
+ join: NodeID,
+) -> SparseNodeMap<ForkID> {
let mut map = SparseNodeMap::new();
- editor.get_users(join)
+ editor
+ .get_users(join)
.filter(|id| editor.func().nodes[id.idx()].is_reduce())
.enumerate()
- .for_each(|(fork, reduce)| { map.insert(reduce, fork); });
+ .for_each(|(fork, reduce)| {
+ map.insert(reduce, fork);
+ });
map
}
-// TODO: Refine these conditions.
+// TODO: Refine these conditions.
/** */
-pub fn find_reduce_dependencies<'a>(function: &'a Function, reduce: NodeID, fork: NodeID
-) -> impl IntoIterator<Item = NodeID> + 'a
-{
+pub fn find_reduce_dependencies<'a>(
+ function: &'a Function,
+ reduce: NodeID,
+ fork: NodeID,
+) -> impl IntoIterator<Item = NodeID> + 'a {
let len = function.nodes.len();
-
let mut visited: DenseNodeMap<bool> = vec![false; len];
let mut depdendent: DenseNodeMap<bool> = vec![false; len];
// Does `fork` need to be a parameter here? It never changes. If this was a closure could it just capture it?
- fn recurse(function: &Function, node: NodeID, fork: NodeID,
- dependent_map: &mut DenseNodeMap<bool>, visited: &mut DenseNodeMap<bool>
- ) -> () { // return through dependent_map {
+ fn recurse(
+ function: &Function,
+ node: NodeID,
+ fork: NodeID,
+ dependent_map: &mut DenseNodeMap<bool>,
+ visited: &mut DenseNodeMap<bool>,
+ ) -> () {
+ // return through dependent_map {
if visited[node.idx()] {
return;
@@ -70,13 +83,13 @@ pub fn find_reduce_dependencies<'a>(function: &'a Function, reduce: NodeID, fork
for used in uses {
recurse(function, *used, fork, dependent_map, visited);
}
-
+
dependent_map[node.idx()] = uses.iter().map(|id| dependent_map[id.idx()]).any(|a| a);
return;
}
// Note: HACKY, the condition wwe want is 'all nodes on any path from the fork to the reduce (in the forward graph), or the reduce to the fork (in the directed graph)
- // cycles break this, but we assume for now that the only cycles are ones that involve the reduce node
+ // cycles break this, but we assume for now that the only cycles are ones that involve the reduce node
// NOTE: (control may break this (i.e loop inside fork) is a cycle that isn't the reduce)
// the current solution is just to mark the reduce as dependent at the start of traversing the graph.
depdendent[reduce.idx()] = true;
@@ -84,42 +97,52 @@ pub fn find_reduce_dependencies<'a>(function: &'a Function, reduce: NodeID, fork
recurse(function, reduce, fork, &mut depdendent, &mut visited);
// Return node IDs that are dependent
- let a: Vec<_> = depdendent.iter().enumerate()
- .filter_map(|(idx, dependent)| if *dependent {Some(NodeID::new(idx))} else {None})
+ let a: Vec<_> = depdendent
+ .iter()
+ .enumerate()
+ .filter_map(|(idx, dependent)| {
+ if *dependent {
+ Some(NodeID::new(idx))
+ } else {
+ None
+ }
+ })
.collect();
a
}
-pub fn copy_subgraph(editor: &mut FunctionEditor, subgraph: HashSet<NodeID>)
--> (HashSet<NodeID>, HashMap<NodeID, NodeID>, Vec<(NodeID, NodeID)>) // set of all nodes, set of new nodes, outside node. s.t old node-> outside node exists as an edge.
+pub fn copy_subgraph(
+ editor: &mut FunctionEditor,
+ subgraph: HashSet<NodeID>,
+) -> (
+ HashSet<NodeID>,
+ HashMap<NodeID, NodeID>,
+ Vec<(NodeID, NodeID)>,
+) // set of all nodes, set of new nodes, outside node. s.t old node-> outside node exists as an edge.
{
let mut map: HashMap<NodeID, NodeID> = HashMap::new();
let mut new_nodes: HashSet<NodeID> = HashSet::new();
-
+
// Copy nodes
for old_id in subgraph.iter() {
- editor.edit(|mut edit|
- {
- let new_id = edit.copy_node(*old_id);
- map.insert(*old_id, new_id);
- new_nodes.insert(new_id);
- Ok(edit)
- }
- );
+ editor.edit(|mut edit| {
+ let new_id = edit.copy_node(*old_id);
+ map.insert(*old_id, new_id);
+ new_nodes.insert(new_id);
+ Ok(edit)
+ });
}
// Update edges to new nodes
for old_id in subgraph.iter() {
// Replace all uses of old_id w/ new_id, where the use is in new_node
- editor.edit(|edit|
- {
- edit.replace_all_uses_where(*old_id, map[old_id], |node_id| new_nodes.contains(node_id))
- }
- );
+ editor.edit(|edit| {
+ edit.replace_all_uses_where(*old_id, map[old_id], |node_id| new_nodes.contains(node_id))
+ });
}
- // Get all users that aren't in new_nodes.
+ // Get all users that aren't in new_nodes.
let mut outside_users = Vec::new();
for node in new_nodes.iter() {
@@ -133,68 +156,67 @@ pub fn copy_subgraph(editor: &mut FunctionEditor, subgraph: HashSet<NodeID>)
(new_nodes, map, outside_users)
}
-pub fn fork_fission<'a> (
+pub fn fork_fission<'a>(
editor: &'a mut FunctionEditor,
control_subgraph: &Subgraph,
types: &Vec<TypeID>,
loop_tree: &LoopTree,
fork_join_map: &HashMap<NodeID, NodeID>,
-)-> () {
- let forks: Vec<_> = editor.func().nodes.iter().enumerate().filter_map(|(idx, node)| {
- if node.is_fork() {
- Some(NodeID::new(idx))
- } else {None}
- }).collect();
+) -> () {
+ let forks: Vec<_> = editor
+ .func()
+ .nodes
+ .iter()
+ .enumerate()
+ .filter_map(|(idx, node)| {
+ if node.is_fork() {
+ Some(NodeID::new(idx))
+ } else {
+ None
+ }
+ })
+ .collect();
let mut control_pred = NodeID::new(0);
// This does the reduction fission:
- if true {
- for fork in forks.clone() {
- // FIXME: If there is control in between fork and join, give up.
- let join = fork_join_map[&fork];
- let join_pred = editor.func().nodes[join.idx()].try_join().unwrap();
- if join_pred != fork {
- todo!("Can't do fork fission on nodes with internal control")
- // Inner control LOOPs are hard
- // inner control in general *should* work right now without modifications.
- }
- let reduce_partition = default_reduce_partition(editor, fork, join);
-
- let (new_fork, new_join) = fork_reduce_fission_helper(editor, fork_join_map, reduce_partition, control_pred, fork);
- // control_pred = new_join;
+ for fork in forks.clone() {
+ // FIXME: If there is control in between fork and join, don't just give up.
+ let join = fork_join_map[&fork];
+ let join_pred = editor.func().nodes[join.idx()].try_join().unwrap();
+ if join_pred != fork {
+ todo!("Can't do fork fission on nodes with internal control")
+ // Inner control LOOPs are hard
+ // inner control in general *should* work right now without modifications.
}
- } else {
- // This does the bufferization:
- let edge = (NodeID::new(15), NodeID::new(16));
- // let edge = (NodeID::new(4), NodeID::new(9));
- let mut edges = HashSet::new();
- edges.insert(edge);
- let fork = loop_tree.bottom_up_loops().first().unwrap().0;
- //let fork = forks.first().unwrap();
- fork_bufferize_fission_helper(editor, fork_join_map, edges, NodeID::new(0), types, fork);
+ let reduce_partition = default_reduce_partition(editor, fork, join);
+
+ let (new_fork, new_join) =
+ fork_reduce_fission_helper(editor, fork_join_map, reduce_partition, control_pred, fork);
+ // control_pred = new_join;
}
}
/** Split a 1D fork into two forks, placing select intermediate data into buffers. */
-pub fn fork_bufferize_fission_helper<'a> (
+pub fn fork_bufferize_fission_helper<'a>(
editor: &'a mut FunctionEditor,
fork_join_map: &HashMap<NodeID, NodeID>,
- bufferized_edges: HashSet<(NodeID, NodeID)>, // Describes what intermediate data should be bufferized.
- original_control_pred: NodeID, // What the new fork connects to.
+ bufferized_edges: HashSet<(NodeID, NodeID)>, // Describes what intermediate data should be bufferized.
+ original_control_pred: NodeID, // What the new fork connects to.
types: &Vec<TypeID>,
fork: NodeID,
-) -> (NodeID, NodeID) { // Returns the two forks that it generates.
-
- // TODO: Check that bufferized edges src doesn't depend on anything that comes after the fork.
+) -> (NodeID, NodeID) {
+ // Returns the two forks that it generates.
+
+ // TODO: Check that bufferized edges src doesn't depend on anything that comes after the fork.
- // Copy fork + control intermediates + join to new fork + join,
- // How does control get partitioned?
+ // Copy fork + control intermediates + join to new fork + join,
+ // How does control get partitioned?
// (depending on how it affects the data nodes on each side of the bufferized_edges)
- // may end up in each loop, fix me later.
+ // may end up in each loop, fix me later.
// place new fork + join after join of first.
- // Only handle fork+joins with no inner control for now.
+ // Only handle fork+joins with no inner control for now.
// Create fork + join + Thread control
let join = fork_join_map[&fork];
@@ -204,77 +226,95 @@ pub fn fork_bufferize_fission_helper<'a> (
editor.edit(|mut edit| {
new_join_id = edit.add_node(Node::Join { control: fork });
let factors = edit.get_node(fork).try_fork().unwrap().1.clone();
- new_fork_id = edit.add_node(Node::Fork { control: new_join_id, factors: factors.into() });
+ new_fork_id = edit.add_node(Node::Fork {
+ control: new_join_id,
+ factors: factors.into(),
+ });
edit.replace_all_uses_where(fork, new_fork_id, |usee| *usee == join)
});
for (src, dst) in bufferized_edges {
// FIXME: Disgusting cloning and allocationing and iterators.
- let factors: Vec<_> = editor.func().nodes[fork.idx()].try_fork().unwrap().1.iter().cloned().collect();
- editor.edit(|mut edit|
- {
- // Create write to buffer
-
- let thread_stuff_it = factors.into_iter().enumerate();
-
- // FIxme: try to use unzip here? Idk why it wasn't working.
- let (tids) = thread_stuff_it.clone().map(|(dim, factor)|
- (
- edit.add_node(Node::ThreadID { control: fork, dimension: dim })
- )
- );
-
- let array_dims = thread_stuff_it.clone().map(|(dim, factor)|
- (
- factor
- )
- );
-
- // Assume 1-d fork only for now.
- // let tid = edit.add_node(Node::ThreadID { control: fork, dimension: 0 });
- let position_idx = Index::Position(tids.collect::<Vec<_>>().into_boxed_slice());
- let write = edit.add_node(Node::Write { collect: NodeID::new(0), data: src, indices: vec![position_idx].into() });
- let ele_type = types[src.idx()];
- let empty_buffer = edit.add_type(hercules_ir::Type::Array(ele_type, array_dims.collect::<Vec<_>>().into_boxed_slice()));
- let empty_buffer = edit.add_zero_constant(empty_buffer);
- let empty_buffer = edit.add_node(Node::Constant { id: empty_buffer });
- let reduce = Node::Reduce { control: new_join_id, init: empty_buffer, reduct: write };
- let reduce = edit.add_node(reduce);
- // Fix write node
- edit = edit.replace_all_uses_where(NodeID::new(0), reduce, |usee| *usee == write)?;
-
-
- // Create read from buffer
- let (tids) = thread_stuff_it.clone().map(|(dim, factor)|
- (
- edit.add_node(Node::ThreadID { control: new_fork_id, dimension: dim })
- )
- );
-
- let position_idx = Index::Position(tids.collect::<Vec<_>>().into_boxed_slice());
-
- let read = edit.add_node(Node::Read { collect: reduce, indices: vec![position_idx].into() });
-
- edit = edit.replace_all_uses_where(src, read, |usee| *usee == dst)?;
-
- Ok(edit)
- }
- );
+ let factors: Vec<_> = editor.func().nodes[fork.idx()]
+ .try_fork()
+ .unwrap()
+ .1
+ .iter()
+ .cloned()
+ .collect();
+ editor.edit(|mut edit| {
+ // Create write to buffer
+
+ let thread_stuff_it = factors.into_iter().enumerate();
+
+ // FIxme: try to use unzip here? Idk why it wasn't working.
+ let (tids) = thread_stuff_it.clone().map(|(dim, factor)| {
+ (edit.add_node(Node::ThreadID {
+ control: fork,
+ dimension: dim,
+ }))
+ });
+
+ let array_dims = thread_stuff_it.clone().map(|(dim, factor)| (factor));
+
+ // Assume 1-d fork only for now.
+ // let tid = edit.add_node(Node::ThreadID { control: fork, dimension: 0 });
+ let position_idx = Index::Position(tids.collect::<Vec<_>>().into_boxed_slice());
+ let write = edit.add_node(Node::Write {
+ collect: NodeID::new(0),
+ data: src,
+ indices: vec![position_idx].into(),
+ });
+ let ele_type = types[src.idx()];
+ let empty_buffer = edit.add_type(hercules_ir::Type::Array(
+ ele_type,
+ array_dims.collect::<Vec<_>>().into_boxed_slice(),
+ ));
+ let empty_buffer = edit.add_zero_constant(empty_buffer);
+ let empty_buffer = edit.add_node(Node::Constant { id: empty_buffer });
+ let reduce = Node::Reduce {
+ control: new_join_id,
+ init: empty_buffer,
+ reduct: write,
+ };
+ let reduce = edit.add_node(reduce);
+ // Fix write node
+ edit = edit.replace_all_uses_where(NodeID::new(0), reduce, |usee| *usee == write)?;
+
+ // Create read from buffer
+ let (tids) = thread_stuff_it.clone().map(|(dim, factor)| {
+ (edit.add_node(Node::ThreadID {
+ control: new_fork_id,
+ dimension: dim,
+ }))
+ });
+
+ let position_idx = Index::Position(tids.collect::<Vec<_>>().into_boxed_slice());
+
+ let read = edit.add_node(Node::Read {
+ collect: reduce,
+ indices: vec![position_idx].into(),
+ });
+
+ edit = edit.replace_all_uses_where(src, read, |usee| *usee == dst)?;
+
+ Ok(edit)
+ });
}
(fork, new_fork_id)
-
}
/** Split a 1D fork into a separate fork for each reduction. */
-pub fn fork_reduce_fission_helper<'a> (
+pub fn fork_reduce_fission_helper<'a>(
editor: &'a mut FunctionEditor,
fork_join_map: &HashMap<NodeID, NodeID>,
reduce_partition: SparseNodeMap<ForkID>, // Describes how the reduces of the fork should be split,
- original_control_pred: NodeID, // What the new fork connects to.
+ original_control_pred: NodeID, // What the new fork connects to.
fork: NodeID,
-) -> (NodeID, NodeID) { // returns Fork, Join pair {
+) -> (NodeID, NodeID) {
+ // returns Fork, Join pair {
let join = fork_join_map[&fork];
// If there is control in between then j give up.
@@ -284,16 +324,16 @@ pub fn fork_reduce_fission_helper<'a> (
// Get nodes to copy
// let factors: Box<[DynamicConstantID]> = edit..nodes[fork.idx()].try_fork().unwrap().1.into();
- // None of this matters, just assume we have DCE for control flow.
+ // None of this matters, just assume we have DCE for control flow.
// Make new fork put it after the existing loop (deal with dependencies later.)
// Make new join, put it after fork (FIXME: THIS IS WRONG)
// Make copies of all control + data nodes, including the reduce and join, with equivalent uses / users, mark them as NEW
- // - Need an editor utility to copy a subsection of the graph.
+ // - Need an editor utility to copy a subsection of the graph.
// 1) Edges going into the subsection stay the same, i.e something new still *uses* something old.
- // 2) Edges leaving the subsection need to be handled by the user, (can't force outgoing new edges into nodes)
- // return a list of outgoing (but unattatached) edges + the old destination to the programmer.
-
- // Important edges are: Reduces,
+ // 2) Edges leaving the subsection need to be handled by the user, (can't force outgoing new edges into nodes)
+ // return a list of outgoing (but unattatached) edges + the old destination to the programmer.
+
+ // Important edges are: Reduces,
// NOTE:
// Say two reduce are in a fork, s.t reduce A depends on reduce B
@@ -306,13 +346,13 @@ pub fn fork_reduce_fission_helper<'a> (
// for now, DONT HANDLE IT. LOL.
// NOTE:
- //
+ //
// Replace all
- // Replace all uses of (fork, reduce, ) w/ predicate that they are the newly copied nodes.
+ // Replace all uses of (fork, reduce, ) w/ predicate that they are the newly copied nodes.
// repalce uses
- let mut new_fork = NodeID::new(0);
+ let mut new_fork = NodeID::new(0);
let mut new_join = NodeID::new(0);
// Gets everything between fork & join that this reduce needs. (ALL CONTROL)
@@ -321,28 +361,30 @@ pub fn fork_reduce_fission_helper<'a> (
let function = editor.func();
let subgraph = find_reduce_dependencies(function, reduce, fork);
-
+
let mut subgraph: HashSet<NodeID> = subgraph.into_iter().collect();
-
+
subgraph.insert(join);
subgraph.insert(fork);
subgraph.insert(reduce);
-
+
// println!("subgraph for {:?}: \n{:?}", reduce, subgraph);
-
+
let (new_nodes, mapping, _) = copy_subgraph(editor, subgraph);
-
+
// println!("new_nodes: {:?} ", new_nodes);
// println!("mapping: {:?} ",mapping);
-
+
new_fork = mapping[&fork];
new_join = mapping[&join];
-
+
editor.edit(|mut edit| {
// Atttach new_fork after control_pred
let (old_control_pred, factors) = edit.get_node(new_fork).try_fork().unwrap().clone();
- edit = edit.replace_all_uses_where(old_control_pred, new_control_pred, |usee| *usee == new_fork)?;
-
+ edit = edit.replace_all_uses_where(old_control_pred, new_control_pred, |usee| {
+ *usee == new_fork
+ })?;
+
// Replace uses of reduce
edit = edit.replace_all_uses(reduce, mapping[&reduce])?;
Ok(edit)
@@ -351,7 +393,6 @@ pub fn fork_reduce_fission_helper<'a> (
new_control_pred = new_join;
}
-
editor.edit(|mut edit| {
// Replace original join w/ new final join
edit = edit.replace_all_uses_where(join, new_join, |_| true)?;
@@ -359,7 +400,7 @@ pub fn fork_reduce_fission_helper<'a> (
// Delete original join (all reduce users have been moved)
edit = edit.delete_node(join)?;
- // Replace all users of original fork, and then delete it, leftover users will be DCE'd.
+ // Replace all users of original fork, and then delete it, leftover users will be DCE'd.
edit = edit.replace_all_uses(fork, new_fork)?;
edit.delete_node(fork)
});
@@ -372,14 +413,16 @@ pub fn fork_coalesce(
loops: &LoopTree,
fork_join_map: &HashMap<NodeID, NodeID>,
) -> bool {
-
- let fork_joins = loops
- .bottom_up_loops()
- .into_iter()
- .filter_map(|(k, _)| if editor.func().nodes[k.idx()].is_fork() {Some(k)} else {None});
+ let fork_joins = loops.bottom_up_loops().into_iter().filter_map(|(k, _)| {
+ if editor.func().nodes[k.idx()].is_fork() {
+ Some(k)
+ } else {
+ None
+ }
+ });
let fork_joins: Vec<_> = fork_joins.collect();
- // FIXME: postorder traversal.
+ // FIXME: postorder traversal.
// Fixme: This could give us two forks that aren't actually ancestors / related, but then the helper will just retunr false early.
//for (inner, outer) in fork_joins.windows(2) {
@@ -391,7 +434,7 @@ pub fn fork_coalesce(
return false;
}
-/** Opposite of fork split, takes two fork-joins
+/** Opposite of fork split, takes two fork-joins
with no control between them, and merges them into a single fork-join.
*/
pub fn fork_coalesce_helper(
@@ -400,29 +443,43 @@ pub fn fork_coalesce_helper(
inner_fork: NodeID,
fork_join_map: &HashMap<NodeID, NodeID>,
) -> bool {
-
// Check that all reduces in the outer fork are in *simple* cycles with a unique reduce of the inner fork.
let outer_join = fork_join_map[&outer_fork];
let inner_join = fork_join_map[&inner_fork];
-
- let mut pairs: BiMap<NodeID, NodeID> = BiMap::new(); // Outer <-> Inner
- // FIXME: Iterate all control uses of joins to really collect all reduces
- // (reduces can be attached to inner control)
- for outer_reduce in editor.get_users(outer_join).filter(|node| editor.func().nodes[node.idx()].is_reduce()) {
+ let mut pairs: BiMap<NodeID, NodeID> = BiMap::new(); // Outer <-> Inner
+ // FIXME: Iterate all control uses of joins to really collect all reduces
+ // (reduces can be attached to inner control)
+ for outer_reduce in editor
+ .get_users(outer_join)
+ .filter(|node| editor.func().nodes[node.idx()].is_reduce())
+ {
// check that inner reduce is of the inner join
- let (outer_control, outer_init, outer_reduct) = editor.func().nodes[outer_reduce.idx()].try_reduce().unwrap();
+ let (outer_control, outer_init, outer_reduct) = editor.func().nodes[outer_reduce.idx()]
+ .try_reduce()
+ .unwrap();
let inner_reduce = outer_reduct;
let inner_reduce_node = &editor.func().nodes[outer_reduct.idx()];
- let Node::Reduce { control: inner_control, init: inner_init, reduct: inner_reduct } = inner_reduce_node else {return false};
+ let Node::Reduce {
+ control: inner_control,
+ init: inner_init,
+ reduct: inner_reduct,
+ } = inner_reduce_node
+ else {
+ return false;
+ };
// FIXME: check this condition better (i.e reduce might not be attached to join)
- if *inner_control != inner_join {return false};
- if *inner_init != outer_reduce {return false};
+ if *inner_control != inner_join {
+ return false;
+ };
+ if *inner_init != outer_reduce {
+ return false;
+ };
if pairs.contains_left(&outer_reduce) || pairs.contains_right(&inner_reduce) {
return false;
@@ -431,16 +488,27 @@ pub fn fork_coalesce_helper(
}
}
- // Check Control between joins and forks
- // FIXME: use control subgraph.
- let Some(user) = editor.get_users(outer_fork)
- .filter(|node| editor.func().nodes[node.idx()].is_control()).next() else { return false};
+ // Check for control between join-join and fork-fork
+ let Some(user) = editor
+ .get_users(outer_fork)
+ .filter(|node| editor.func().nodes[node.idx()].is_control())
+ .next()
+ else {
+ return false;
+ };
if user != inner_fork {
return false;
}
- let Some(user) = editor.get_users(inner_join).filter(|node| editor.func().nodes[node.idx()].is_control()).next() else { return false};
+ let Some(user) = editor
+ .get_users(inner_join)
+ .filter(|node| editor.func().nodes[node.idx()].is_control())
+ .next()
+ else {
+ return false;
+ };
+
if user != outer_join {
return false;
}
@@ -449,24 +517,30 @@ pub fn fork_coalesce_helper(
// Add outers dimension to front of inner fork.
// Fuse reductions
// - Initializer becomes outer initializer
- // -
+ // -
// Replace uses of outer fork w/ inner fork.
// Replace uses of outer join w/ inner join.
// Delete outer fork-join
- let inner_tids: Vec<NodeID> = editor.get_users(inner_fork).filter(|node| editor.func().nodes[node.idx()].is_thread_id()).collect();
+ let inner_tids: Vec<NodeID> = editor
+ .get_users(inner_fork)
+ .filter(|node| editor.func().nodes[node.idx()].is_thread_id())
+ .collect();
let (outer_pred, outer_dims) = editor.func().nodes[outer_fork.idx()].try_fork().unwrap();
let (_, inner_dims) = editor.func().nodes[inner_fork.idx()].try_fork().unwrap();
let num_outer_dims = outer_dims.len();
let mut new_factors = outer_dims.to_vec();
- // FIXME: Might need to be added the other way.
+ // CHECK ME: Might need to be added the other way.
new_factors.append(&mut inner_dims.to_vec());
-
+
for tid in inner_tids {
let (fork, dim) = editor.func().nodes[tid.idx()].try_thread_id().unwrap();
- let new_tid = Node::ThreadID { control: fork, dimension: dim + num_outer_dims};
+ let new_tid = Node::ThreadID {
+ control: fork,
+ dimension: dim + num_outer_dims,
+ };
editor.edit(|mut edit| {
let new_tid = edit.add_node(new_tid);
@@ -475,13 +549,18 @@ pub fn fork_coalesce_helper(
});
}
- // Fuse Reductions
+ // Fuse Reductions
for (outer_reduce, inner_reduce) in pairs {
- let (outer_control, outer_init, outer_reduct) = editor.func().nodes[outer_reduce.idx()].try_reduce().unwrap();
- let (inner_control, inner_init, inner_reduct) = editor.func().nodes[inner_reduce.idx()].try_reduce().unwrap();
+ let (outer_control, outer_init, outer_reduct) = editor.func().nodes[outer_reduce.idx()]
+ .try_reduce()
+ .unwrap();
+ let (inner_control, inner_init, inner_reduct) = editor.func().nodes[inner_reduce.idx()]
+ .try_reduce()
+ .unwrap();
editor.edit(|mut edit| {
// Set inner init to outer init.
- edit = edit.replace_all_uses_where(inner_init, outer_init, |usee| *usee == inner_reduce)?;
+ edit =
+ edit.replace_all_uses_where(inner_init, outer_init, |usee| *usee == inner_reduce)?;
edit = edit.replace_all_uses(outer_reduce, inner_reduce)?;
edit = edit.delete_node(outer_reduce)?;
@@ -489,22 +568,22 @@ pub fn fork_coalesce_helper(
});
}
- editor.edit(
- |mut edit| {
- let new_fork = Node::Fork {control: outer_pred, factors: new_factors.into()};
- let new_fork = edit.add_node(new_fork);
-
- edit = edit.replace_all_uses(inner_fork, new_fork)?;
- edit = edit.replace_all_uses(outer_fork, new_fork)?;
- edit = edit.replace_all_uses(outer_join, inner_join)?;
- edit = edit.delete_node(outer_join)?;
- edit = edit.delete_node(inner_fork)?;
- edit = edit.delete_node(outer_fork)?;
-
- Ok(edit)
- }
- );
+ editor.edit(|mut edit| {
+ let new_fork = Node::Fork {
+ control: outer_pred,
+ factors: new_factors.into(),
+ };
+ let new_fork = edit.add_node(new_fork);
+
+ edit = edit.replace_all_uses(inner_fork, new_fork)?;
+ edit = edit.replace_all_uses(outer_fork, new_fork)?;
+ edit = edit.replace_all_uses(outer_join, inner_join)?;
+ edit = edit.delete_node(outer_join)?;
+ edit = edit.delete_node(inner_fork)?;
+ edit = edit.delete_node(outer_fork)?;
+
+ Ok(edit)
+ });
true
-
-}
\ No newline at end of file
+}
diff --git a/hercules_opt/src/forkify.rs b/hercules_opt/src/forkify.rs
index 82358f91..c7acfe6b 100644
--- a/hercules_opt/src/forkify.rs
+++ b/hercules_opt/src/forkify.rs
@@ -1,5 +1,5 @@
-extern crate hercules_ir;
extern crate bitvec;
+extern crate hercules_ir;
extern crate nestify;
use std::collections::HashMap;
@@ -46,30 +46,40 @@ pub fn forkify(
loops: &LoopTree,
) -> bool {
let natural_loops = loops
- .bottom_up_loops()
- .into_iter()
- .filter(|(k, _)| editor.func().nodes[k.idx()].is_region());
+ .bottom_up_loops()
+ .into_iter()
+ .filter(|(k, _)| editor.func().nodes[k.idx()].is_region());
let natural_loops: Vec<_> = natural_loops.collect();
-
+
for l in natural_loops {
- // FIXME: Run on all-bottom level loops, as they can be independently optimized without recomputing analyses.
- if forkify_loop(editor, control_subgraph, fork_join_map, &Loop { header: l.0, control: l.1.clone()}) {
+ // FIXME: Run on all-bottom level loops, as they can be independently optimized without recomputing analyses.
+ if forkify_loop(
+ editor,
+ control_subgraph,
+ fork_join_map,
+ &Loop {
+ header: l.0,
+ control: l.1.clone(),
+ },
+ ) {
return true;
}
- }
+ }
return false;
}
-
/** Given a node used as a loop bound, return a dynamic constant ID. */
-pub fn get_node_as_dc(editor: &mut FunctionEditor, node: NodeID) -> Result<DynamicConstantID, String> {
+pub fn get_node_as_dc(
+ editor: &mut FunctionEditor,
+ node: NodeID,
+) -> Result<DynamicConstantID, String> {
// Check for a constant used as loop bound.
match editor.node(node) {
- Node::DynamicConstant{id: dynamic_constant_id} => {
- Ok(*dynamic_constant_id)
- }
- Node::Constant {id: constant_id} => {
+ Node::DynamicConstant {
+ id: dynamic_constant_id,
+ } => Ok(*dynamic_constant_id),
+ Node::Constant { id: constant_id } => {
let dc = match *editor.get_constant(*constant_id) {
Constant::Integer8(x) => DynamicConstant::Constant(x as _),
Constant::Integer16(x) => DynamicConstant::Constant(x as _),
@@ -83,23 +93,21 @@ pub fn get_node_as_dc(editor: &mut FunctionEditor, node: NodeID) -> Result<Dynam
};
let mut b = DynamicConstantID::new(0);
- editor.edit(
- |mut edit| {
- b = edit.add_dynamic_constant(dc);
- Ok(edit)
- }
- );
- // Return the ID of the dynamic constant that is generated from the constant
+ editor.edit(|mut edit| {
+ b = edit.add_dynamic_constant(dc);
+ Ok(edit)
+ });
+ // Return the ID of the dynamic constant that is generated from the constant
// or dynamic constant that is the existing loop bound
- Ok(b)
+ Ok(b)
}
- _ => Err("Blah".to_owned())
+ _ => Err("Blah".to_owned()),
}
}
-fn all_same_variant<I, T>(mut iter: I) -> bool
+fn all_same_variant<I, T>(mut iter: I) -> bool
where
- I: Iterator<Item = T>
+ I: Iterator<Item = T>,
{
// Empty iterator case - return true
let first = match iter.next() {
@@ -109,60 +117,79 @@ where
// Get discriminant of first item
let first_discriminant = std::mem::discriminant(&first);
-
+
// Check all remaining items have same discriminant
iter.all(|x| std::mem::discriminant(&x) == first_discriminant)
}
/**
- Top level function to convert natural loops with simple induction variables
- into fork-joins.
- */
+ Top level function to convert natural loops with simple induction variables
+ into fork-joins.
+*/
pub fn forkify_loop(
editor: &mut FunctionEditor,
control_subgraph: &Subgraph,
fork_join_map: &HashMap<NodeID, NodeID>,
l: &Loop,
) -> bool {
-
let function = editor.func();
- let Some(loop_condition) = get_loop_exit_conditions(function, l, control_subgraph) else {return false};
+ let Some(loop_condition) = get_loop_exit_conditions(function, l, control_subgraph) else {
+ return false;
+ };
- let LoopExit::Conditional { if_node: loop_if, condition_node } = loop_condition.clone() else {return false};
+ let LoopExit::Conditional {
+ if_node: loop_if,
+ condition_node,
+ } = loop_condition.clone()
+ else {
+ return false;
+ };
// Compute loop variance
let loop_variance = compute_loop_variance(editor, l);
let ivs = compute_induction_vars(editor.func(), l, &loop_variance);
let ivs = compute_iv_ranges(editor, l, ivs, &loop_condition);
- let Some(canonical_iv) = has_canonical_iv(editor, l, &ivs) else {return false};
+ let Some(canonical_iv) = has_canonical_iv(editor, l, &ivs) else {
+ return false;
+ };
// FIXME: Make sure IV is not used outside the loop.
// Get bound
let bound = match canonical_iv {
- InductionVariable::Basic { node, initializer, update, final_value } => final_value.map(|final_value| get_node_as_dc(editor, final_value)).and_then(|r| r.ok()),
+ InductionVariable::Basic {
+ node,
+ initializer,
+ update,
+ final_value,
+ } => final_value
+ .map(|final_value| get_node_as_dc(editor, final_value))
+ .and_then(|r| r.ok()),
InductionVariable::SCEV(node_id) => return false,
};
-
- let Some(bound_dc_id) = bound else {return false};
-
+ let Some(bound_dc_id) = bound else {
+ return false;
+ };
let function = editor.func();
- // Check if it is do-while loop.
- let loop_exit_projection = editor.get_users(loop_if)
+ // Check if it is do-while loop.
+ let loop_exit_projection = editor
+ .get_users(loop_if)
.filter(|id| !l.control[id.idx()])
.next()
.unwrap();
- let loop_continue_projection = editor.get_users(loop_if)
+ let loop_continue_projection = editor
+ .get_users(loop_if)
.filter(|id| l.control[id.idx()])
.next()
.unwrap();
-
- let loop_preds: Vec<_> = editor.get_uses(l.header)
+
+ let loop_preds: Vec<_> = editor
+ .get_uses(l.header)
.filter(|id| !l.control[id.idx()])
.collect();
@@ -172,71 +199,83 @@ pub fn forkify_loop(
let loop_pred = loop_preds[0];
- if !editor.get_uses(l.header).contains(&loop_continue_projection) {
+ if !editor
+ .get_uses(l.header)
+ .contains(&loop_continue_projection)
+ {
return false;
}
- // Get all phis used outside of the loop, they need to be reductionable.
- // For now just assume all phis will be phis used outside of the loop, except for the canonical iv.
- // FIXME: We need a different definiton of `loop_nodes` to check for phis used outside hte loop than the one
- // we currently have.
+ // Get all phis used outside of the loop, they need to be reductionable.
+ // For now just assume all phis will be phis used outside of the loop, except for the canonical iv.
+ // FIXME: We need a different definiton of `loop_nodes` to check for phis used outside hte loop than the one
+ // we currently have.
let loop_nodes = calculate_loop_nodes(editor, l);
// // Check reductionable phis, only PHIs depending on the loop are considered,
- let candidate_phis: Vec<_> = editor.get_users(l.header)
- .filter(|id|function.nodes[id.idx()].is_phi())
+ let candidate_phis: Vec<_> = editor
+ .get_users(l.header)
+ .filter(|id| function.nodes[id.idx()].is_phi())
.filter(|id| *id != canonical_iv.phi())
.collect();
- let reductionable_phis: Vec<_> = analyze_phis(&editor, &l, &candidate_phis, &loop_nodes).into_iter().collect();
-
+ let reductionable_phis: Vec<_> = analyze_phis(&editor, &l, &candidate_phis, &loop_nodes)
+ .into_iter()
+ .collect();
+
// START EDITING
-
+
// What we do is:
// 1) Find a (the?) basic induction variable, create a ThreadID + Fork + Join over it.
- // 2) Turn reductionable PHIs into reduces (including the redcutionable PHI)
- // - a) If the PHI is the IV:
- // Uses of the IV become:
+ // 2) Turn reductionable PHIs into reduces (including the redcutionable PHI)
+ // - a) If the PHI is the IV:
+ // Uses of the IV become:
// 1) Inside the loop: Uses of the ThreadID
// 2) Outside the loop: Uses of the reduction node.
- // - b) if the PHI is not the IV:
+ // - b) if the PHI is not the IV:
// Make it a reduce
-
- let function = editor.func();
+ let function = editor.func();
// TOOD: Handle multiple loop body lasts.
// If there are multiple candidates for loop body last, return false.
- if editor.get_uses(loop_if)
+ if editor
+ .get_uses(loop_if)
.filter(|id| l.control[id.idx()])
- .count() > 1 {
- return false;
- }
+ .count()
+ > 1
+ {
+ return false;
+ }
- let loop_body_last = editor.get_uses(loop_if)
- .next()
- .unwrap();
-
- if reductionable_phis.iter()
- .any(|phi| !matches!(phi, LoopPHI::Reductionable{..})) {
- return false
- }
+ let loop_body_last = editor.get_uses(loop_if).next().unwrap();
+
+ if reductionable_phis
+ .iter()
+ .any(|phi| !matches!(phi, LoopPHI::Reductionable { .. }))
+ {
+ return false;
+ }
// 1) If there is any control between header and loop condition, exit.
- let header_control_users: Vec<_> = editor.get_users(l.header)
+ let header_control_users: Vec<_> = editor
+ .get_users(l.header)
.filter(|id| function.nodes[id.idx()].is_control())
.collect();
-
+
// Outside uses of IV, then exit;
- if editor.get_users(canonical_iv.phi()).any(|node| !loop_nodes.contains(&node)) {
- return false
+ if editor
+ .get_users(canonical_iv.phi())
+ .any(|node| !loop_nodes.contains(&node))
+ {
+ return false;
}
// Start Transformation:
// Graft everyhting between header and loop condition
// Attach join to right before header (after loop_body_last, unless loop body last *is* the header).
- // Attach fork to right after loop_continue_projection.
+ // Attach fork to right after loop_continue_projection.
// // Create fork and join nodes:
let mut join_id = NodeID::new(0);
@@ -255,25 +294,26 @@ pub fn forkify_loop(
};
// // FIXME (@xrouth), handle control in loop body.
- editor.edit(
- |mut edit| {
- let fork = Node::Fork { control: loop_pred, factors: Box::new([bound_dc_id])};
- fork_id = edit.add_node(fork);
-
- let join = Node::Join {
- control: if l.header == loop_body_last {
- fork_id
- } else {
- loop_body_last
- },
- };
-
- join_id = edit.add_node(join);
+ editor.edit(|mut edit| {
+ let fork = Node::Fork {
+ control: loop_pred,
+ factors: Box::new([bound_dc_id]),
+ };
+ fork_id = edit.add_node(fork);
+
+ let join = Node::Join {
+ control: if l.header == loop_body_last {
+ fork_id
+ } else {
+ loop_body_last
+ },
+ };
+
+ join_id = edit.add_node(join);
+
+ Ok(edit)
+ });
- Ok(edit)
- }
- );
-
// let function = editor.func();
// let update = *zip(
@@ -288,115 +328,101 @@ pub fn forkify_loop(
// .next()
// .unwrap()
// .1;
-
+
let function = editor.func();
let (_, factors) = function.nodes[fork_id.idx()].try_fork().unwrap();
let dimension = factors.len() - 1;
// Create ThreadID
- editor.edit(
- |mut edit| {
- let thread_id = Node::ThreadID {
- control: fork_id,
- dimension: dimension,
- };
- let thread_id_id = edit.add_node(thread_id);
-
- // let iv_reduce = Node::Reduce {
- // control: join_id,
- // init: basic_iv.initializer,
- // reduct: update,
- // };
-
- // If a user occurs after the loop is finished, we replace it with the DC that is the IV bound,
- // If a user occurs inside the loop, we replace it with the IV.
-
- // Replace uses that are inside with the thread id
- edit = edit.replace_all_uses_where(canonical_iv.phi(), thread_id_id, |node| {
- loop_nodes.contains(node)
- })?;
-
- // Replace uses that are outside with DC - 1. Or just give up.
- let bound_dc_node = edit.add_node(Node::DynamicConstant { id: bound_dc_id });
- edit = edit.replace_all_uses_where(canonical_iv.phi(), bound_dc_node, |node| {
- !loop_nodes.contains(node)
- })?;
-
- edit.delete_node(canonical_iv.phi())
- }
- );
+ editor.edit(|mut edit| {
+ let thread_id = Node::ThreadID {
+ control: fork_id,
+ dimension: dimension,
+ };
+ let thread_id_id = edit.add_node(thread_id);
+
+ // let iv_reduce = Node::Reduce {
+ // control: join_id,
+ // init: basic_iv.initializer,
+ // reduct: update,
+ // };
+
+ // If a user occurs after the loop is finished, we replace it with the DC that is the IV bound,
+ // If a user occurs inside the loop, we replace it with the IV.
+
+ // Replace uses that are inside with the thread id
+ edit = edit.replace_all_uses_where(canonical_iv.phi(), thread_id_id, |node| {
+ loop_nodes.contains(node)
+ })?;
+
+ // Replace uses that are outside with DC - 1. Or just give up.
+ let bound_dc_node = edit.add_node(Node::DynamicConstant { id: bound_dc_id });
+ edit = edit.replace_all_uses_where(canonical_iv.phi(), bound_dc_node, |node| {
+ !loop_nodes.contains(node)
+ })?;
+
+ edit.delete_node(canonical_iv.phi())
+ });
for reduction_phi in reductionable_phis {
- let LoopPHI::Reductionable { phi, data_cycle, continue_latch, is_associative } = reduction_phi else {continue};
+ let LoopPHI::Reductionable {
+ phi,
+ data_cycle,
+ continue_latch,
+ is_associative,
+ } = reduction_phi
+ else {
+ continue;
+ };
let function = editor.func();
let init = *zip(
editor.get_uses(l.header),
- function.nodes[phi.idx()]
- .try_phi()
- .unwrap()
- .1
- .iter(),
- )
- .filter(|(c, _)| *c == loop_pred)
- .next()
- .unwrap()
- .1;
-
- editor.edit(
- |mut edit| {
- let reduce = Node::Reduce {
- control: join_id,
- init,
- reduct: continue_latch,
- };
- let reduce_id = edit.add_node(reduce);
-
- edit = edit.replace_all_uses_where(phi, reduce_id, |usee| *usee != reduce_id)?;
- edit = edit.replace_all_uses_where(continue_latch, reduce_id, |usee| !loop_nodes.contains(usee ) && *usee != reduce_id)?;
- edit.delete_node(phi)
- }
- );
+ function.nodes[phi.idx()].try_phi().unwrap().1.iter(),
+ )
+ .filter(|(c, _)| *c == loop_pred)
+ .next()
+ .unwrap()
+ .1;
+
+ editor.edit(|mut edit| {
+ let reduce = Node::Reduce {
+ control: join_id,
+ init,
+ reduct: continue_latch,
+ };
+ let reduce_id = edit.add_node(reduce);
+
+ edit = edit.replace_all_uses_where(phi, reduce_id, |usee| *usee != reduce_id)?;
+ edit = edit.replace_all_uses_where(continue_latch, reduce_id, |usee| {
+ !loop_nodes.contains(usee) && *usee != reduce_id
+ })?;
+ edit.delete_node(phi)
+ });
}
-
// Replace all uses of the loop header with the fork
- editor.edit(
- |mut edit| {
- edit.replace_all_uses(l.header, fork_id)
- }
- );
+ editor.edit(|mut edit| edit.replace_all_uses(l.header, fork_id));
- editor.edit(
- |mut edit| {
- edit.replace_all_uses(loop_continue_projection, fork_id)
- }
- );
+ editor.edit(|mut edit| edit.replace_all_uses(loop_continue_projection, fork_id));
- editor.edit(
- |mut edit| {
- edit.replace_all_uses(loop_exit_projection, join_id)
- }
- );
+ editor.edit(|mut edit| edit.replace_all_uses(loop_exit_projection, join_id));
// Get rid of loop condition
// DCE should get these, but delete them ourselves because we are nice :)
- editor.edit(
- |mut edit| {
- edit = edit.delete_node(loop_continue_projection)?;
- edit = edit.delete_node(condition_node)?; // Might have to get rid of other users of this.
- edit = edit.delete_node(loop_exit_projection)?;
- edit = edit.delete_node(loop_if)?;
- edit = edit.delete_node(l.header)?;
- Ok(edit)
- }
- );
+ editor.edit(|mut edit| {
+ edit = edit.delete_node(loop_continue_projection)?;
+ edit = edit.delete_node(condition_node)?; // Might have to get rid of other users of this.
+ edit = edit.delete_node(loop_exit_projection)?;
+ edit = edit.delete_node(loop_if)?;
+ edit = edit.delete_node(l.header)?;
+ Ok(edit)
+ });
return true;
}
-
nest! {
#[derive(Debug)]
pub enum LoopPHI {
@@ -414,56 +440,68 @@ nest! {
impl LoopPHI {
pub fn get_phi(&self) -> NodeID {
match self {
- LoopPHI::Reductionable {phi, data_cycle, ..} => *phi,
+ LoopPHI::Reductionable {
+ phi, data_cycle, ..
+ } => *phi,
LoopPHI::LoopDependant(node_id) => *node_id,
LoopPHI::UsedByDependant(node_id) => *node_id,
}
}
}
-
-/**
- Checks some conditions on loop variables that will need to be converted into reductions to be forkified.
- To convert a phi into a reduce we need to check that every cycle containing the PHI does not contain any other PHI.
- I think this restriction can be loosened (more specified)
- - Every cycle *in the loop* containing the PHI does not contain any other PHI. Or something, IDK.
- -
- We also need to make it not control dependent on anything other than the loop header. */
-pub fn analyze_phis<'a>(editor: &'a FunctionEditor, natural_loop: &'a Loop, phis: &'a [NodeID], loop_nodes: &'a HashSet<NodeID>)
- -> impl Iterator<Item = LoopPHI> + 'a
-{
+/**
+Checks some conditions on loop variables that will need to be converted into reductions to be forkified.
+ To convert a phi into a reduce we need to check that every cycle containing the PHI does not contain any other PHI.
+I think this restriction can be loosened (more specified)
+ - Every cycle *in the loop* containing the PHI does not contain any other PHI. Or something, IDK.
+ -
+We also need to make it not control dependent on anything other than the loop header. */
+pub fn analyze_phis<'a>(
+ editor: &'a FunctionEditor,
+ natural_loop: &'a Loop,
+ phis: &'a [NodeID],
+ loop_nodes: &'a HashSet<NodeID>,
+) -> impl Iterator<Item = LoopPHI> + 'a {
phis.into_iter().map(move |phi| {
- let stop_on: HashSet<NodeID> = editor.node_ids().filter(|node| {
- let data = &editor.func().nodes[node.idx()];
-
- // External Phi
- if let Node::Phi { control, data } = data {
- if *control != natural_loop.header {
- return true;
+ let stop_on: HashSet<NodeID> = editor
+ .node_ids()
+ .filter(|node| {
+ let data = &editor.func().nodes[node.idx()];
+
+ // External Phi
+ if let Node::Phi { control, data } = data {
+ if *control != natural_loop.header {
+ return true;
+ }
+ // if !natural_loop.control[control.idx()] {
+ // return true;
+ // }
}
- // if !natural_loop.control[control.idx()] {
- // return true;
- // }
- }
- // External Reduce
- if let Node::Reduce { control, init, reduct} = data {
- if !natural_loop.control[control.idx()] {
- return true;
- } else {
- return false;
+ // External Reduce
+ if let Node::Reduce {
+ control,
+ init,
+ reduct,
+ } = data
+ {
+ if !natural_loop.control[control.idx()] {
+ return true;
+ } else {
+ return false;
+ }
}
- }
- // External Control
- if data.is_control() {//&& !natural_loop.control[node.idx()] {
- return true
- }
+ // External Control
+ if data.is_control() {
+ //&& !natural_loop.control[node.idx()] {
+ return true;
+ }
- return false;
+ return false;
+ })
+ .collect();
- }).collect();
-
- // TODO: We may need to stop on exiting the loop for looking for data cycles.
+ // TODO: We may need to stop on exiting the loop for looking for data cycles.
let uses = walk_all_uses_stop_on(*phi, editor, stop_on.clone());
// .filter(|node|
// {
@@ -472,74 +510,88 @@ pub fn analyze_phis<'a>(editor: &'a FunctionEditor, natural_loop: &'a Loop, phis
// });
let users = walk_all_users_stop_on(*phi, editor, stop_on.clone());
- let other_stop_on: HashSet<NodeID> = editor.node_ids().filter(|node| {
- let data = &editor.func().nodes[node.idx()];
-
- // Phi, Reduce
- if let Node::Phi { control, data } = data {
- return true;
- }
-
- if let Node::Reduce { control, init, reduct} = data {
- return true;
- }
+ let other_stop_on: HashSet<NodeID> = editor
+ .node_ids()
+ .filter(|node| {
+ let data = &editor.func().nodes[node.idx()];
- // External Control
- if data.is_control() {//&& !natural_loop.control[node.idx()] {
- return true
- }
+ // Phi, Reduce
+ if let Node::Phi { control, data } = data {
+ return true;
+ }
- return false;
+ if let Node::Reduce {
+ control,
+ init,
+ reduct,
+ } = data
+ {
+ return true;
+ }
- }).collect();
+ // External Control
+ if data.is_control() {
+ //&& !natural_loop.control[node.idx()] {
+ return true;
+ }
+ return false;
+ })
+ .collect();
let mut uses_for_dependance = walk_all_users_stop_on(*phi, editor, other_stop_on);
-
+
let set1: HashSet<_> = HashSet::from_iter(uses);
let set2: HashSet<_> = HashSet::from_iter(users);
let intersection: HashSet<_> = set1.intersection(&set2).cloned().collect();
// If this phi uses any other phis the node is loop dependant,
- // we use `phis` because this phi can actually contain the loop iv and its fine.
+ // we use `phis` because this phi can actually contain the loop iv and its fine.
if uses_for_dependance.any(|node| phis.contains(&node) && node != *phi) {
LoopPHI::LoopDependant(*phi)
- }
- // // If this phi is used by other phis in the loop, FIXME: include reduces, they are the same as phis right?
- // // DOn't go through nodes that would become a reduction.
+ }
+ // // If this phi is used by other phis in the loop, FIXME: include reduces, they are the same as phis right?
+ // // DOn't go through nodes that would become a reduction.
// else if set2.clone().iter().any(|node| phis.contains(node) && node != phi ) {
// LoopPHI::UsedByDependant(*phi)
// }
else if intersection.clone().iter().any(|node| true) {
- let continue_idx = editor.get_uses(natural_loop.header)
+ let continue_idx = editor
+ .get_uses(natural_loop.header)
.position(|node| natural_loop.control[node.idx()])
.unwrap();
let loop_continue_latch = editor.node(phi).try_phi().unwrap().1[continue_idx];
- // Phis on the frontier of the intersection, i.e in uses_for_dependance need
- // to have headers
+ // Phis on the frontier of the intersection, i.e in uses_for_dependance need
+ // to have headers
// FIXME: Need to postdominate the loop continue latch
- // The phi's region needs to postdominate all PHI / Reduceses (that are in the control of the loop, i.e that or uses of the loop_continue_latch)
- // that it uses, not going through phis / reduces,
- //
+ // The phi's region needs to postdominate all PHI / Reduceses (that are in the control of the loop, i.e that or uses of the loop_continue_latch)
+ // that it uses, not going through phis / reduces,
+ //
- // let uses =
+ // let uses =
// No nodes in data cycles with this phi (in the loop) are used outside the loop, besides the loop_continue_latch.
- if intersection.iter()
+ if intersection
+ .iter()
.filter(|node| **node != loop_continue_latch)
- .any(|data_node| editor.get_users(*data_node).any(|user| !loop_nodes.contains(&user))) {
- // This phi can be made into a reduce in different ways, if the cycle is associative (contains all the same kind of associative op)
- // 3) Split the cycle into two phis, add them or multiply them together at the end.
- // 4) Split the cycle into two reduces, add them or multiply them together at the end.
- // Somewhere else should handle this.
- return LoopPHI::LoopDependant(*phi)
- }
-
+ .any(|data_node| {
+ editor
+ .get_users(*data_node)
+ .any(|user| !loop_nodes.contains(&user))
+ })
+ {
+ // This phi can be made into a reduce in different ways, if the cycle is associative (contains all the same kind of associative op)
+ // 3) Split the cycle into two phis, add them or multiply them together at the end.
+ // 4) Split the cycle into two reduces, add them or multiply them together at the end.
+ // Somewhere else should handle this.
+ return LoopPHI::LoopDependant(*phi);
+ }
+
// if tehre are separate types of ops, or any non associative ops, then its not associative
-
+
// Extract ops
// let is_associative = intersection.iter().filter_map(|node| match editor.node(node) {
// Node::Unary { input, op } => todo!(),
@@ -555,11 +607,9 @@ pub fn analyze_phis<'a>(editor: &'a FunctionEditor, natural_loop: &'a Loop, phis
continue_latch: loop_continue_latch,
is_associative,
}
-
-
- } else { // No cycles exist, this isn't a reduction.
+ } else {
+ // No cycles exist, this isn't a reduction.
LoopPHI::LoopDependant(*phi)
}
})
-
-}
\ No newline at end of file
+}
diff --git a/hercules_opt/src/ivar.rs b/hercules_opt/src/ivar.rs
index 893cf763..7f76b0f5 100644
--- a/hercules_opt/src/ivar.rs
+++ b/hercules_opt/src/ivar.rs
@@ -1,7 +1,7 @@
-extern crate hercules_ir;
-extern crate slotmap;
extern crate bitvec;
+extern crate hercules_ir;
extern crate nestify;
+extern crate slotmap;
use std::collections::{BTreeMap, HashMap, HashSet, VecDeque};
use std::path::Iter;
@@ -11,9 +11,9 @@ use self::nestify::nest;
use self::hercules_ir::Subgraph;
use self::bitvec::order::Lsb0;
+use self::bitvec::prelude::*;
use self::bitvec::vec::BitVec;
use self::hercules_ir::get_uses;
-use self::bitvec::prelude::*;
use self::hercules_ir::LoopTree;
@@ -30,13 +30,12 @@ use crate::*;
*/
/* ASIDE: (@xrouth) I want a word for something that can be 'queried', but doesn't reveal anything about the underlying data structure,
- single loop only... */
-
+single loop only... */
#[derive(Debug)]
pub struct LoopVarianceInfo {
- pub loop_header: NodeID,
- pub map: DenseNodeMap<LoopVariance>
+ pub loop_header: NodeID,
+ pub map: DenseNodeMap<LoopVariance>,
}
#[derive(Clone, Copy, Debug, PartialEq)]
@@ -48,11 +47,10 @@ pub enum LoopVariance {
type NodeVec = BitVec<u8, Lsb0>;
-
#[derive(Clone, Debug)]
pub struct Loop {
pub header: NodeID,
- pub control: NodeVec, //
+ pub control: NodeVec, //
}
impl Loop {
@@ -62,8 +60,8 @@ impl Loop {
all_loop_nodes
}
}
-nest!{
-/** Represents a basic induction variable.
+nest! {
+/** Represents a basic induction variable.
NOTE (@xrouth): May switch to using SCEV to represent induction vairables, for now we assume only basic induction variables
with a constant update (not even linear). Eventually add dynamic constant updates, and linear updates
*/
@@ -76,7 +74,7 @@ pub struct BasicInductionVariable {
}
} // nest
-nest!{
+nest! {
#[derive(Clone, Copy, Debug, PartialEq)]*
pub enum InductionVariable {
pub Basic {
@@ -86,7 +84,7 @@ nest!{
final_value: Option<NodeID>,
},
SCEV(NodeID),
- //ScevAdd(NodeID, NodeID),
+ //ScevAdd(NodeID, NodeID),
// ScevMul(NodeID, NodeID),
}
}
@@ -94,15 +92,20 @@ nest!{
impl InductionVariable {
pub fn phi(&self) -> NodeID {
match self {
- InductionVariable::Basic { node, initializer, update, final_value } => *node,
+ InductionVariable::Basic {
+ node,
+ initializer,
+ update,
+ final_value,
+ } => *node,
InductionVariable::SCEV(_) => todo!(),
}
}
// Editor has become just a 'context' that everything needs. This is similar to how analyses / passes are structured,
// but editor forces recomputation / bookkeeping of simple / more commonly used info (even though it really is just def use, constants, dyn_constants)
- // While if the pass writer wants more complicated info, like analyses results, they have to thread it through the pass manager.
- // This seems fine.
+ // While if the pass writer wants more complicated info, like analyses results, they have to thread it through the pass manager.
+ // This seems fine.
// pub fn update_i64(&self, editor: &FunctionEditor) -> Option<i64> {
// match self {
// InductionVariable::Basic { node, initializer, update, final_value } => {
@@ -118,19 +121,16 @@ impl InductionVariable {
// }
// }
- // It would be nice for functions, as they (kinda) automatically capture 'self' to also automatically capture a 'context' that is in the same scope,
- // so I don't have to keep passing a context into every function that needs one.
- //
+ // It would be nice for functions, as they (kinda) automatically capture 'self' to also automatically capture a 'context' that is in the same scope,
+ // so I don't have to keep passing a context into every function that needs one.
+ //
}
-// TODO: Optimize.
-pub fn calculate_loop_nodes(
- editor: &FunctionEditor,
- natural_loop: &Loop,
-) -> HashSet<NodeID> {
-
- // Stop on PHIs / reduces outside of loop.
- let stop_on: HashSet<NodeID> = editor.node_ids().filter(
- |node|{
+// TODO: Optimize.
+pub fn calculate_loop_nodes(editor: &FunctionEditor, natural_loop: &Loop) -> HashSet<NodeID> {
+ // Stop on PHIs / reduces outside of loop.
+ let stop_on: HashSet<NodeID> = editor
+ .node_ids()
+ .filter(|node| {
let data = &editor.func().nodes[node.idx()];
// External Phi
@@ -140,7 +140,12 @@ pub fn calculate_loop_nodes(
}
}
// External Reduce
- if let Node::Reduce { control, init, reduct} = data {
+ if let Node::Reduce {
+ control,
+ init,
+ reduct,
+ } = data
+ {
if !natural_loop.control[control.idx()] {
return true;
}
@@ -148,32 +153,41 @@ pub fn calculate_loop_nodes(
// External Control
if data.is_control() && !natural_loop.control[node.idx()] {
- return true
+ return true;
}
return false;
- }
- ).collect();
-
- let phis: Vec<_> = editor.node_ids().filter(|node| {
- let Node::Phi { control, ref data } = editor.func().nodes[node.idx()] else {return false};
- natural_loop.control[control.idx()]
- }).collect();
+ })
+ .collect();
+
+ let phis: Vec<_> = editor
+ .node_ids()
+ .filter(|node| {
+ let Node::Phi { control, ref data } = editor.func().nodes[node.idx()] else {
+ return false;
+ };
+ natural_loop.control[control.idx()]
+ })
+ .collect();
// let all_users: HashSet<_> = editor.get_users(natural_loop.header).filter(|node| editor.func().nodes[node.idx()].is_phi())
// .flat_map(|phi| walk_all_users_stop_on(phi, editor, stop_on.clone()))
// .chain(editor.get_users(natural_loop.header).filter(|node| editor.func().nodes[node.idx()].is_phi()))
// .collect();
- let all_users: HashSet<NodeID> = phis.clone().iter().flat_map(|phi| walk_all_users_stop_on(*phi, editor, stop_on.clone()))
- .chain(phis.clone())
- .collect();
+ let all_users: HashSet<NodeID> = phis
+ .clone()
+ .iter()
+ .flat_map(|phi| walk_all_users_stop_on(*phi, editor, stop_on.clone()))
+ .chain(phis.clone())
+ .collect();
- let all_uses: HashSet<_> = phis.clone().iter()
+ let all_uses: HashSet<_> = phis
+ .clone()
+ .iter()
.flat_map(|phi| walk_all_uses_stop_on(*phi, editor, stop_on.clone()))
.chain(phis)
- .filter(|node|
- {
+ .filter(|node| {
// Get rid of nodes in stop_on
!stop_on.contains(node)
})
@@ -192,9 +206,15 @@ pub fn calculate_loop_nodes(
}
/** returns PHIs that are *in* a loop */
-pub fn get_all_loop_phis<'a>(function: &'a Function, l: &'a Loop) -> impl Iterator<Item = NodeID> + 'a {
- function.nodes.iter().enumerate().filter_map(
- move |(node_id, node)| {
+pub fn get_all_loop_phis<'a>(
+ function: &'a Function,
+ l: &'a Loop,
+) -> impl Iterator<Item = NodeID> + 'a {
+ function
+ .nodes
+ .iter()
+ .enumerate()
+ .filter_map(move |(node_id, node)| {
if let Some((control, _)) = node.try_phi() {
if l.control[control.idx()] {
Some(NodeID::new(node_id))
@@ -204,18 +224,17 @@ pub fn get_all_loop_phis<'a>(function: &'a Function, l: &'a Loop) -> impl Iterat
} else {
None
}
- }
- )
+ })
}
// FIXME: Need a trait that Editor and Function both implement, that gives us UseDefInfo
/** Given a loop determine for each data node if the value might change upon each iteration of the loop */
pub fn compute_loop_variance(editor: &FunctionEditor, l: &Loop) -> LoopVarianceInfo {
- // Gather all Phi nodes that are controlled by this loop.
+ // Gather all Phi nodes that are controlled by this loop.
let mut loop_vars: Vec<NodeID> = vec![];
- for node_id in editor.get_users(l.header) {
+ for node_id in editor.get_users(l.header) {
let node = &editor.func().nodes[node_id.idx()];
if let Some((control, _)) = node.try_phi() {
if l.control[control.idx()] {
@@ -229,38 +248,42 @@ pub fn compute_loop_variance(editor: &FunctionEditor, l: &Loop) -> LoopVarianceI
let mut all_loop_nodes = l.control.clone();
all_loop_nodes.set(l.header.idx(), true);
-
- let mut variance_map: DenseNodeMap<LoopVariance> = vec![LoopVariance::Unknown; len];
- fn recurse(function: &Function, node: NodeID, all_loop_nodes: &BitVec<u8, Lsb0>,
- variance_map: &mut DenseNodeMap<LoopVariance>, visited: &mut DenseNodeMap<bool>)
- -> LoopVariance {
+ let mut variance_map: DenseNodeMap<LoopVariance> = vec![LoopVariance::Unknown; len];
+ fn recurse(
+ function: &Function,
+ node: NodeID,
+ all_loop_nodes: &BitVec<u8, Lsb0>,
+ variance_map: &mut DenseNodeMap<LoopVariance>,
+ visited: &mut DenseNodeMap<bool>,
+ ) -> LoopVariance {
if visited[node.idx()] {
return variance_map[node.idx()];
}
visited[node.idx()] = true;
-
- let node_variance = match variance_map[node.idx()] {
+
+ let node_variance = match variance_map[node.idx()] {
LoopVariance::Invariant => LoopVariance::Invariant,
LoopVariance::Variant => LoopVariance::Variant,
LoopVariance::Unknown => {
-
let mut node_variance = LoopVariance::Invariant;
// Two conditions cause something to be loop variant:
for node_use in get_uses(&function.nodes[node.idx()]).as_ref() {
// 1) The use is a PHI *controlled* by the loop
if let Some((control, data)) = function.nodes[node_use.idx()].try_phi() {
- if *all_loop_nodes.get(control.idx()).unwrap() {
+ if *all_loop_nodes.get(control.idx()).unwrap() {
node_variance = LoopVariance::Variant;
break;
- }
+ }
}
-
+
// 2) Any of the nodes uses are loop variant
- if recurse(function, *node_use, all_loop_nodes, variance_map, visited) == LoopVariance::Variant {
+ if recurse(function, *node_use, all_loop_nodes, variance_map, visited)
+ == LoopVariance::Variant
+ {
node_variance = LoopVariance::Variant;
break;
}
@@ -271,17 +294,26 @@ pub fn compute_loop_variance(editor: &FunctionEditor, l: &Loop) -> LoopVarianceI
node_variance
}
};
-
+
return node_variance;
}
let mut visited: DenseNodeMap<bool> = vec![false; len];
for node in (0..len).map(NodeID::new) {
- recurse(editor.func(), node, &all_loop_nodes, &mut variance_map, &mut visited);
- };
+ recurse(
+ editor.func(),
+ node,
+ &all_loop_nodes,
+ &mut variance_map,
+ &mut visited,
+ );
+ }
- return LoopVarianceInfo { loop_header: l.header, map: variance_map };
+ return LoopVarianceInfo {
+ loop_header: l.header,
+ map: variance_map,
+ };
}
nest! {
@@ -291,22 +323,27 @@ pub enum LoopExit {
if_node: NodeID,
condition_node: NodeID,
},
- Unconditional(NodeID) // Probably a region.
+ Unconditional(NodeID) // Probably a region.
}
}
-pub fn get_loop_exit_conditions(function: &Function, l: &Loop, control_subgraph: &Subgraph) -> Option<LoopExit> { // impl IntoIterator<Item = LoopExit>
- // DFS Traversal on loop control subgraph until we find a node that is outside the loop, find the last IF on this path.
- let mut last_if_on_path: DenseNodeMap<Option<NodeID>> = vec![None; function.nodes.len()];
+pub fn get_loop_exit_conditions(
+ function: &Function,
+ l: &Loop,
+ control_subgraph: &Subgraph,
+) -> Option<LoopExit> {
+ // impl IntoIterator<Item = LoopExit>
+ // DFS Traversal on loop control subgraph until we find a node that is outside the loop, find the last IF on this path.
+ let mut last_if_on_path: DenseNodeMap<Option<NodeID>> = vec![None; function.nodes.len()];
// FIXME: (@xrouth) THIS IS MOST CERTAINLY BUGGED
// this might be bugged... i.e might need to udpate `last if` even if already defined.
- // needs to be `saturating` kinda, more iterative. May need to visit nodes more than once?
+ // needs to be `saturating` kinda, more iterative. May need to visit nodes more than once?
- // FIXME: (@xrouth) Right now we assume only one exit from the loop, later: check for multiple exits on the loop,
+ // FIXME: (@xrouth) Right now we assume only one exit from the loop, later: check for multiple exits on the loop,
// either as an assertion here or some other part of forkify or analysis.
let mut bag_of_control_nodes = vec![l.header];
let mut visited: DenseNodeMap<bool> = vec![false; function.nodes.len()];
-
+
let mut final_if: Option<NodeID> = None;
// do WFS
@@ -317,39 +354,50 @@ pub fn get_loop_exit_conditions(function: &Function, l: &Loop, control_subgraph:
}
visited[node.idx()] = true;
- final_if =
- if function.nodes[node.idx()].is_if() {
- Some(node)
- } else {
- last_if_on_path[node.idx()]
- };
-
+ final_if = if function.nodes[node.idx()].is_if() {
+ Some(node)
+ } else {
+ last_if_on_path[node.idx()]
+ };
+
if !l.control[node.idx()] {
break;
}
-
+
for succ in control_subgraph.succs(node) {
last_if_on_path[succ.idx()] = final_if;
bag_of_control_nodes.push(succ.clone());
}
}
- final_if.map(|v| {LoopExit::Conditional {
- if_node: v,
- condition_node: if let Node::If{ control: _, cond } = function.nodes[v.idx()] {cond} else {unreachable!()}
- }})
+ final_if.map(|v| LoopExit::Conditional {
+ if_node: v,
+ condition_node: if let Node::If { control: _, cond } = function.nodes[v.idx()] {
+ cond
+ } else {
+ unreachable!()
+ },
+ })
}
-
-pub fn match_canonicalization_bound(editor: &mut FunctionEditor, natural_loop: &Loop, loop_condition: NodeID, loop_if: NodeID, ivar: BasicInductionVariable) -> Option<NodeID> {
+pub fn match_canonicalization_bound(
+ editor: &mut FunctionEditor,
+ natural_loop: &Loop,
+ loop_condition: NodeID,
+ loop_if: NodeID,
+ ivar: BasicInductionVariable,
+) -> Option<NodeID> {
// Match for code generated by loop canon
- let Node::Phi { control, data } = &editor.func().nodes[loop_condition.idx()] else {unreachable!()};
+ let Node::Phi { control, data } = &editor.func().nodes[loop_condition.idx()] else {
+ unreachable!()
+ };
if *control != natural_loop.header {
- return None
+ return None;
}
- let continue_idx = editor.get_uses(natural_loop.header)
+ let continue_idx = editor
+ .get_uses(natural_loop.header)
.position(|node| natural_loop.control[node.idx()])
.unwrap();
@@ -360,121 +408,176 @@ pub fn match_canonicalization_bound(editor: &mut FunctionEditor, natural_loop: &
todo!()
}
- let Node::Constant { id } = &editor.func().nodes[data[init_idx].idx()] else {return None};
+ let Node::Constant { id } = &editor.func().nodes[data[init_idx].idx()] else {
+ return None;
+ };
- // Check that the ID is true.
- let Constant::Boolean(val) = *editor.get_constant(*id) else {return None};
- if val != true {return None};
+ // Check that the ID is true.
+ let Constant::Boolean(val) = *editor.get_constant(*id) else {
+ return None;
+ };
+ if val != true {
+ return None;
+ };
// Check other phi input.
// FIXME: Factor this out into diff loop analysis.
- let Node::Binary { left, right, op } = &editor.func().nodes[data[continue_idx].idx()].clone() else {return None};
+ let Node::Binary { left, right, op } = &editor.func().nodes[data[continue_idx].idx()].clone()
+ else {
+ return None;
+ };
+
+ let BinaryOperator::LT = op else { return None };
- let BinaryOperator::LT = op else {return None};
-
let bound = &editor.func().nodes[right.idx()];
- if !(bound.is_constant() || bound.is_dynamic_constant()) {return None};
+ if !(bound.is_constant() || bound.is_dynamic_constant()) {
+ return None;
+ };
let bound = match bound {
Node::Constant { id } => {
let constant = editor.get_constant(*id).clone();
- let Constant::UnsignedInteger64(v) = constant else {return None};
+ let Constant::UnsignedInteger64(v) = constant else {
+ return None;
+ };
let mut b = DynamicConstantID::new(0);
- editor.edit(
- |mut edit| {
- b = edit.add_dynamic_constant(DynamicConstant::Constant(v.try_into().unwrap()));
- Ok(edit)
- }
- );
- // Return the ID of the dynamic constant that is generated from the constant
+ editor.edit(|mut edit| {
+ b = edit.add_dynamic_constant(DynamicConstant::Constant(v.try_into().unwrap()));
+ Ok(edit)
+ });
+ // Return the ID of the dynamic constant that is generated from the constant
// or dynamic constant that is the existing loop bound
b
}
Node::DynamicConstant { id } => *id,
- _ => unreachable!()
+ _ => unreachable!(),
+ };
+
+ let Node::Binary {
+ left: add_left,
+ right: add_right,
+ op: add_op,
+ } = &editor.func().nodes[left.idx()]
+ else {
+ return None;
};
- let Node::Binary { left: add_left, right: add_right, op: add_op } = &editor.func().nodes[left.idx()] else {return None};
-
- let (phi, inc) = if let Node::Phi { control, data } = &editor.func().nodes[add_left.idx()] {
+ let (phi, inc) = if let Node::Phi { control, data } = &editor.func().nodes[add_left.idx()] {
(add_left, add_right)
- } else if let Node::Phi { control, data } = &editor.func().nodes[add_right.idx()] {
+ } else if let Node::Phi { control, data } = &editor.func().nodes[add_right.idx()] {
(add_right, add_left)
} else {
return None;
};
// Check Constant
- let Node::Constant { id } = &editor.func().nodes[inc.idx()] else {return None};
+ let Node::Constant { id } = &editor.func().nodes[inc.idx()] else {
+ return None;
+ };
if !editor.get_constant(*id).is_one() {
return None;
}
// Check PHI
- let Node::Phi { control: outer_control, data: outer_data } = &editor.func().nodes[phi.idx()] else {unreachable!()};
+ let Node::Phi {
+ control: outer_control,
+ data: outer_data,
+ } = &editor.func().nodes[phi.idx()]
+ else {
+ unreachable!()
+ };
// FIXME: Multiple loop predecessors.
- if outer_data[continue_idx] != *left {return None};
+ if outer_data[continue_idx] != *left {
+ return None;
+ };
- let Node::Constant { id } = &editor.func().nodes[outer_data[init_idx].idx()] else {return None};
+ let Node::Constant { id } = &editor.func().nodes[outer_data[init_idx].idx()] else {
+ return None;
+ };
if !editor.get_constant(*id).is_zero() {
return None;
}
- // All checks passed, make new DC
+ // All checks passed, make new DC
let mut final_node = NodeID::new(0);
- editor.edit(
- |mut edit| {
- let one = edit.add_dynamic_constant(DynamicConstant::Constant(1));
- let max_dc = edit.add_dynamic_constant(DynamicConstant::Max(one, bound));
- final_node = edit.add_node(Node::DynamicConstant { id: max_dc });
- Ok(edit)
- }
- );
+ editor.edit(|mut edit| {
+ let one = edit.add_dynamic_constant(DynamicConstant::Constant(1));
+ let max_dc = edit.add_dynamic_constant(DynamicConstant::Max(one, bound));
+ final_node = edit.add_node(Node::DynamicConstant { id: max_dc });
+ Ok(edit)
+ });
Some(final_node)
}
pub fn has_const_fields(editor: &FunctionEditor, ivar: InductionVariable) -> bool {
match ivar {
- InductionVariable::Basic { node, initializer, update, final_value } => {
+ InductionVariable::Basic {
+ node,
+ initializer,
+ update,
+ final_value,
+ } => {
if final_value.is_none() {
return false;
}
- [initializer, update].iter().any(
- |node| !editor.node(node).is_constant()
- )
- },
+ [initializer, update]
+ .iter()
+ .any(|node| !editor.node(node).is_constant())
+ }
InductionVariable::SCEV(node_id) => false,
}
-}
+}
/* Loop has any IV from range 0....N, N can be dynconst iterates +1 per iteration */
-// IVs need to be bounded...
-pub fn has_canonical_iv<'a>(editor: &FunctionEditor, l: &Loop, ivs: &'a[InductionVariable]) -> Option<&'a InductionVariable> {
- ivs.iter().find(|iv| { match iv {
- InductionVariable::Basic { node, initializer, update, final_value } => {
- (editor.node(initializer).is_zero_constant(&editor.get_constants()) || editor.node(initializer).is_zero_dc(&editor.get_dynamic_constants()))
- && (editor.node(update).is_one_constant(&editor.get_constants()) || editor.node(update).is_one_dc(&editor.get_dynamic_constants()))
- && (final_value.map(|val| editor.node(val).is_constant() || editor.node(val).is_dynamic_constant()).is_some())
+// IVs need to be bounded...
+pub fn has_canonical_iv<'a>(
+ editor: &FunctionEditor,
+ l: &Loop,
+ ivs: &'a [InductionVariable],
+) -> Option<&'a InductionVariable> {
+ ivs.iter().find(|iv| match iv {
+ InductionVariable::Basic {
+ node,
+ initializer,
+ update,
+ final_value,
+ } => {
+ (editor
+ .node(initializer)
+ .is_zero_constant(&editor.get_constants())
+ || editor
+ .node(initializer)
+ .is_zero_dc(&editor.get_dynamic_constants()))
+ && (editor.node(update).is_one_constant(&editor.get_constants())
+ || editor
+ .node(update)
+ .is_one_dc(&editor.get_dynamic_constants()))
+ && (final_value
+ .map(|val| {
+ editor.node(val).is_constant() || editor.node(val).is_dynamic_constant()
+ })
+ .is_some())
}
InductionVariable::SCEV(node_id) => false,
- }
})
}
// Need a transformation that forces all IVs to be SCEVs of an IV from range 0...N, +1, else places them in a separate loop?
-pub fn compute_induction_vars(function: &Function, l: &Loop, loop_variance: &LoopVarianceInfo)
- -> Vec<InductionVariable> {
-
+pub fn compute_induction_vars(
+ function: &Function,
+ l: &Loop,
+ loop_variance: &LoopVarianceInfo,
+) -> Vec<InductionVariable> {
// 1) Gather PHIs contained in the loop.
// FIXME: (@xrouth) Should this just be PHIs controlled by the header?
let mut loop_vars: Vec<NodeID> = vec![];
- for (node_id, node) in function.nodes.iter().enumerate() {
+ for (node_id, node) in function.nodes.iter().enumerate() {
if let Some((control, _)) = node.try_phi() {
if l.control[control.idx()] {
loop_vars.push(NodeID::new(node_id));
@@ -482,22 +585,30 @@ pub fn compute_induction_vars(function: &Function, l: &Loop, loop_variance: &Loo
}
}
- // FIXME: (@xrouth) For now, only compute variables that have one assignment,
- // (look into this:) possibly treat multiple assignment as separate induction variables.
+ // FIXME: (@xrouth) For now, only compute variables that have one assignment,
+ // (look into this:) possibly treat multiple assignment as separate induction variables.
let mut induction_variables: Vec<InductionVariable> = vec![];
/* For each PHI controlled by the loop, check how it is modified */
- // It's initializer needs to be loop invariant, it's update needs to be loop variant.
+ // It's initializer needs to be loop invariant, it's update needs to be loop variant.
for phi_id in loop_vars {
let phi_node = &function.nodes[phi_id.idx()];
let (region, data) = phi_node.try_phi().unwrap();
let region_node = &function.nodes[region.idx()];
- let Node::Region { preds: region_inputs } = region_node else {continue};
+ let Node::Region {
+ preds: region_inputs,
+ } = region_node
+ else {
+ continue;
+ };
// The initializer index is the first index of the inputs to the region node of that isn't in the loop. (what is loop_header, wtf...)
// FIXME (@xrouth): If there is control flow in the loop, we won't find ... WHAT
- let Some(initializer_idx) = region_inputs.iter().position(|&node_id| !l.control[node_id.idx()]) else {
+ let Some(initializer_idx) = region_inputs
+ .iter()
+ .position(|&node_id| !l.control[node_id.idx()])
+ else {
continue;
};
@@ -507,30 +618,37 @@ pub fn compute_induction_vars(function: &Function, l: &Loop, loop_variance: &Loo
let initializer = &function.nodes[initializer_id.idx()];
// In the case of a non 0 starting value:
- // - a new dynamic constant or constant may need to be created that is the difference between the initiailizer and the loop bounds.
- // Initializer does not necessarily have to be constant, but this is fine for now.
+ // - a new dynamic constant or constant may need to be created that is the difference between the initiailizer and the loop bounds.
+ // Initializer does not necessarily have to be constant, but this is fine for now.
if !(initializer.is_dynamic_constant() || initializer.is_constant()) {
continue;
}
// Check all data inputs to this phi, that aren't the initializer (i.e the value the comes from control outside of the loop)
- // For now we expect only one initializer.
- let data_inputs = data.iter().filter(
- |data_id| NodeID::new(initializer_idx) != **data_id
- );
+ // For now we expect only one initializer.
+ let data_inputs = data
+ .iter()
+ .filter(|data_id| NodeID::new(initializer_idx) != **data_id);
for data_id in data_inputs {
let node = &function.nodes[data_id.idx()];
- for bop in [BinaryOperator::Add] { //, BinaryOperator::Mul, BinaryOperator::Sub] {
+ for bop in [BinaryOperator::Add] {
+ //, BinaryOperator::Mul, BinaryOperator::Sub] {
if let Some((a, b)) = node.try_binary(bop) {
- let iv = [(a, b), (b, a)].iter().find_map(|(pattern_phi, pattern_const)| {
- if *pattern_phi == phi_id && function.nodes[pattern_const.idx()].is_constant() || function.nodes[pattern_const.idx()].is_dynamic_constant() {
- return Some(InductionVariable::Basic {
- node: phi_id,
- initializer: initializer_id,
- update: b,
- final_value: None,
- }) } else {
+ let iv = [(a, b), (b, a)]
+ .iter()
+ .find_map(|(pattern_phi, pattern_const)| {
+ if *pattern_phi == phi_id
+ && function.nodes[pattern_const.idx()].is_constant()
+ || function.nodes[pattern_const.idx()].is_dynamic_constant()
+ {
+ return Some(InductionVariable::Basic {
+ node: phi_id,
+ initializer: initializer_id,
+ update: b,
+ final_value: None,
+ });
+ } else {
None
}
});
@@ -540,36 +658,46 @@ pub fn compute_induction_vars(function: &Function, l: &Loop, loop_variance: &Loo
}
}
}
- };
+ }
induction_variables
}
// Find loop iterations
-pub fn compute_iv_ranges(editor: &FunctionEditor, l: &Loop,
- induction_vars: Vec<InductionVariable>, loop_condition: &LoopExit)
- -> Vec<InductionVariable> {
-
+pub fn compute_iv_ranges(
+ editor: &FunctionEditor,
+ l: &Loop,
+ induction_vars: Vec<InductionVariable>,
+ loop_condition: &LoopExit,
+) -> Vec<InductionVariable> {
let (if_node, condition_node) = match loop_condition {
- LoopExit::Conditional { if_node, condition_node } => (if_node, condition_node),
- LoopExit::Unconditional(node_id) => todo!()
+ LoopExit::Conditional {
+ if_node,
+ condition_node,
+ } => (if_node, condition_node),
+ LoopExit::Unconditional(node_id) => todo!(),
};
-
+
// Find IVs used by the loop condition, not across loop iterations.
// without leaving the loop.
- let stop_on: HashSet<_> = editor.node_ids().filter(|node_id|
- {
+ let stop_on: HashSet<_> = editor
+ .node_ids()
+ .filter(|node_id| {
if let Node::Phi { control, data } = editor.node(node_id) {
*control == l.header
} else {
false
}
- }
- ).collect();
-
+ })
+ .collect();
+
// Bound IVs used in loop bound.
- let loop_bound_uses: HashSet<_> = walk_all_uses_stop_on(*condition_node, editor, stop_on).collect();
- let (loop_bound_ivs, other_ivs): (Vec<InductionVariable>, Vec<InductionVariable>) = induction_vars.into_iter().partition(|f| loop_bound_uses.contains(&f.phi()));
+ let loop_bound_uses: HashSet<_> =
+ walk_all_uses_stop_on(*condition_node, editor, stop_on).collect();
+ let (loop_bound_ivs, other_ivs): (Vec<InductionVariable>, Vec<InductionVariable>) =
+ induction_vars
+ .into_iter()
+ .partition(|f| loop_bound_uses.contains(&f.phi()));
let Some(iv) = loop_bound_ivs.first() else {
return other_ivs;
@@ -579,45 +707,67 @@ pub fn compute_iv_ranges(editor: &FunctionEditor, l: &Loop,
return loop_bound_ivs.into_iter().chain(other_ivs).collect();
}
- // FIXME: DO linear algerbra to solve for loop bounds with multiple variables involved.
+ // FIXME: DO linear algerbra to solve for loop bounds with multiple variables involved.
let final_value = match &editor.func().nodes[condition_node.idx()] {
- Node::Phi { control, data } => {
- None
- },
- Node::Reduce { control, init, reduct } => None,
+ Node::Phi { control, data } => None,
+ Node::Reduce {
+ control,
+ init,
+ reduct,
+ } => None,
Node::Parameter { index } => None,
Node::Constant { id } => None,
Node::Unary { input, op } => None,
- Node::Ternary { first, second, third, op } => None,
+ Node::Ternary {
+ first,
+ second,
+ third,
+ op,
+ } => None,
Node::Binary { left, right, op } => {
match op {
BinaryOperator::LT => {
// Check for a loop guard condition.
// left < right
- if *left == iv.phi() &&
- (editor.func().nodes[right.idx()].is_constant() || editor.func().nodes[right.idx()].is_dynamic_constant()) {
- Some(*right)
- }
+ if *left == iv.phi()
+ && (editor.func().nodes[right.idx()].is_constant()
+ || editor.func().nodes[right.idx()].is_dynamic_constant())
+ {
+ Some(*right)
+ }
// left + const < right,
- else if let Node::Binary { left: inner_left, right: inner_right, op: inner_op } = editor.node(left) {
- let pattern = [(inner_left, inner_right), (inner_right, inner_left)].iter().find_map(|(pattern_iv, pattern_constant)|
- {
- if iv.phi()== **pattern_iv && (editor.node(*pattern_constant).is_constant() || editor.node(*pattern_constant).is_dynamic_constant()) {
- // FIXME: pattern_constant can be anything >= loop_update expression,
+ else if let Node::Binary {
+ left: inner_left,
+ right: inner_right,
+ op: inner_op,
+ } = editor.node(left)
+ {
+ let pattern = [(inner_left, inner_right), (inner_right, inner_left)]
+ .iter()
+ .find_map(|(pattern_iv, pattern_constant)| {
+ if iv.phi() == **pattern_iv
+ && (editor.node(*pattern_constant).is_constant()
+ || editor.node(*pattern_constant).is_dynamic_constant())
+ {
+ // FIXME: pattern_constant can be anything >= loop_update expression,
let update = match iv {
- InductionVariable::Basic { node, initializer, update, final_value } => update,
+ InductionVariable::Basic {
+ node,
+ initializer,
+ update,
+ final_value,
+ } => update,
InductionVariable::SCEV(node_id) => todo!(),
};
if *pattern_constant == update {
Some(*right)
} else {
None
- }
+ }
} else {
None
}
- }
- );
+ });
pattern.iter().cloned().next()
} else {
None
@@ -635,11 +785,20 @@ pub fn compute_iv_ranges(editor: &FunctionEditor, l: &Loop,
};
let basic = match iv {
- InductionVariable::Basic { node, initializer, update, final_value: _ } => InductionVariable::Basic { node: *node, initializer: *initializer, update: *update, final_value },
+ InductionVariable::Basic {
+ node,
+ initializer,
+ update,
+ final_value: _,
+ } => InductionVariable::Basic {
+ node: *node,
+ initializer: *initializer,
+ update: *update,
+ final_value,
+ },
InductionVariable::SCEV(node_id) => todo!(),
};
- // Propagate bounds to other IVs.
+ // Propagate bounds to other IVs.
vec![basic].into_iter().chain(other_ivs).collect()
}
-
diff --git a/hercules_opt/src/lib.rs b/hercules_opt/src/lib.rs
index c74f5875..01ae1c99 100644
--- a/hercules_opt/src/lib.rs
+++ b/hercules_opt/src/lib.rs
@@ -9,11 +9,13 @@ pub mod editor;
pub mod float_collections;
pub mod fork_concat_split;
pub mod fork_guard_elim;
+pub mod fork_transforms;
pub mod forkify;
pub mod gcm;
pub mod gvn;
pub mod inline;
pub mod interprocedural_sroa;
+pub mod ivar;
pub mod lift_dc_math;
pub mod outline;
pub mod phi_elim;
@@ -21,8 +23,6 @@ pub mod pred;
pub mod schedule;
pub mod slf;
pub mod sroa;
-pub mod fork_transforms;
-pub mod ivar;
pub mod unforkify;
pub mod utils;
@@ -35,11 +35,13 @@ pub use crate::editor::*;
pub use crate::float_collections::*;
pub use crate::fork_concat_split::*;
pub use crate::fork_guard_elim::*;
+pub use crate::fork_transforms::*;
pub use crate::forkify::*;
pub use crate::gcm::*;
pub use crate::gvn::*;
pub use crate::inline::*;
pub use crate::interprocedural_sroa::*;
+pub use crate::ivar::*;
pub use crate::lift_dc_math::*;
pub use crate::outline::*;
pub use crate::phi_elim::*;
@@ -47,7 +49,5 @@ pub use crate::pred::*;
pub use crate::schedule::*;
pub use crate::slf::*;
pub use crate::sroa::*;
-pub use crate::fork_transforms::*;
-pub use crate::ivar::*;
pub use crate::unforkify::*;
pub use crate::utils::*;
diff --git a/hercules_opt/src/schedule.rs b/hercules_opt/src/schedule.rs
index 2c8209aa..f9f720be 100644
--- a/hercules_opt/src/schedule.rs
+++ b/hercules_opt/src/schedule.rs
@@ -29,7 +29,7 @@ pub fn infer_parallel_fork(editor: &mut FunctionEditor, fork_join_map: &HashMap<
/*
* Infer parallel reductions consisting of a simple cycle between a Reduce node
* and a Write node, where indices of the Write are position indices using the
- * ThreadID nodes attached to the corresponding Fork, and data of the Write is
+ * ThreadID nodes attached to the corresponding Fork, and data of the Write is
* not in the Reduce node's cycle. This procedure also adds the ParallelReduce
* schedule to Reduce nodes reducing over a parallelized Reduce, as long as the
* base Write node also has position indices of the ThreadID of the outer fork.
@@ -37,7 +37,11 @@ pub fn infer_parallel_fork(editor: &mut FunctionEditor, fork_join_map: &HashMap<
* as long as each ThreadID dimension appears in the positional indexing of the
* original Write.
*/
-pub fn infer_parallel_reduce(editor: &mut FunctionEditor, fork_join_map: &HashMap<NodeID, NodeID>, reduce_cycles: &HashMap<NodeID, HashSet<NodeID>>) {
+pub fn infer_parallel_reduce(
+ editor: &mut FunctionEditor,
+ fork_join_map: &HashMap<NodeID, NodeID>,
+ reduce_cycles: &HashMap<NodeID, HashSet<NodeID>>,
+) {
for id in editor.node_ids() {
let func = editor.func();
if !func.nodes[id.idx()].is_reduce() {
@@ -146,11 +150,17 @@ pub fn infer_vectorizable(editor: &mut FunctionEditor, fork_join_map: &HashMap<N
* operation's operands must be the Reduce node, and all other operands must
* not be in the Reduce node's cycle.
*/
-pub fn infer_tight_associative(editor: &mut FunctionEditor, reduce_cycles: &HashMap<NodeID, HashSet<NodeID>>) {
- let is_binop_associative = |op| matches!(op,
- BinaryOperator::Add | BinaryOperator::Or | BinaryOperator::And | BinaryOperator::Xor);
- let is_intrinsic_associative = |intrinsic| matches!(intrinsic,
- Intrinsic::Max | Intrinsic::Min);
+pub fn infer_tight_associative(
+ editor: &mut FunctionEditor,
+ reduce_cycles: &HashMap<NodeID, HashSet<NodeID>>,
+) {
+ let is_binop_associative = |op| {
+ matches!(
+ op,
+ BinaryOperator::Add | BinaryOperator::Or | BinaryOperator::And | BinaryOperator::Xor
+ )
+ };
+ let is_intrinsic_associative = |intrinsic| matches!(intrinsic, Intrinsic::Max | Intrinsic::Min);
for id in editor.node_ids() {
let func = editor.func();
@@ -162,8 +172,8 @@ pub fn infer_tight_associative(editor: &mut FunctionEditor, reduce_cycles: &Hash
&& (matches!(func.nodes[reduct.idx()], Node::Binary { left, right, op }
if ((left == id && !reduce_cycles[&id].contains(&right)) ||
(right == id && !reduce_cycles[&id].contains(&left))) &&
- is_binop_associative(op)) ||
- matches!(&func.nodes[reduct.idx()], Node::IntrinsicCall { intrinsic, args }
+ is_binop_associative(op))
+ || matches!(&func.nodes[reduct.idx()], Node::IntrinsicCall { intrinsic, args }
if (args.contains(&id) && is_intrinsic_associative(*intrinsic) &&
args.iter().filter(|arg| **arg != id).all(|arg| !reduce_cycles[&id].contains(arg)))))
{
diff --git a/hercules_opt/src/sroa.rs b/hercules_opt/src/sroa.rs
index 3bcc689e..66d11d69 100644
--- a/hercules_opt/src/sroa.rs
+++ b/hercules_opt/src/sroa.rs
@@ -389,7 +389,7 @@ pub fn sroa(editor: &mut FunctionEditor, reverse_postorder: &Vec<NodeID>, types:
},
AllocatedTernary {
cond: NodeID,
- thn: NodeID,
+ thn: NodeID,
els: NodeID,
node: NodeID,
fields: IndexTree<NodeID>,
diff --git a/hercules_opt/src/unforkify.rs b/hercules_opt/src/unforkify.rs
index 7e2e267a..0efd0b85 100644
--- a/hercules_opt/src/unforkify.rs
+++ b/hercules_opt/src/unforkify.rs
@@ -7,27 +7,37 @@ use hercules_ir::{ir::*, LoopTree};
use crate::*;
type NodeVec = BitVec<u8, Lsb0>;
-pub fn calculate_fork_nodes(editor: &FunctionEditor, inner_control: &NodeVec, fork: NodeID, join: NodeID) -> HashSet<NodeID> {
- // Stop on PHIs / reduces outside of loop.
- let stop_on: HashSet<NodeID> = editor.node_ids().filter(
- |node|{
+pub fn calculate_fork_nodes(
+ editor: &FunctionEditor,
+ inner_control: &NodeVec,
+ fork: NodeID,
+ join: NodeID,
+) -> HashSet<NodeID> {
+ // Stop on PHIs / reduces outside of loop.
+ let stop_on: HashSet<NodeID> = editor
+ .node_ids()
+ .filter(|node| {
let data = &editor.func().nodes[node.idx()];
// External Phi
if let Node::Phi { control, data } = data {
if match inner_control.get(control.idx()) {
- Some(v) => !*v, //
- None => true, // Doesn't exist, must be external
+ Some(v) => !*v, //
+ None => true, // Doesn't exist, must be external
} {
return true;
}
-
}
// External Reduce
- if let Node::Reduce { control, init, reduct} = data {
+ if let Node::Reduce {
+ control,
+ init,
+ reduct,
+ } = data
+ {
if match inner_control.get(control.idx()) {
- Some(v) => !*v, //
- None => true, // Doesn't exist, must be external
+ Some(v) => !*v, //
+ None => true, // Doesn't exist, must be external
} {
return true;
}
@@ -36,37 +46,49 @@ pub fn calculate_fork_nodes(editor: &FunctionEditor, inner_control: &NodeVec, fo
// External Control
if data.is_control() {
return match inner_control.get(node.idx()) {
- Some(v) => !*v, //
- None => true, // Doesn't exist, must be external
- }
+ Some(v) => !*v, //
+ None => true, // Doesn't exist, must be external
+ };
}
// else
return false;
- }
- ).collect();
+ })
+ .collect();
- let reduces: Vec<_> = editor.node_ids().filter(|node| {
- let Node::Reduce { control, .. } = editor.func().nodes[node.idx()] else {return false};
- match inner_control.get(control.idx()) {
- Some(v) => *v,
- None => false,
- }
- }).chain(editor.get_users(fork).filter(|node| {
- editor.node(node).is_thread_id()
- })).collect();
+ let reduces: Vec<_> = editor
+ .node_ids()
+ .filter(|node| {
+ let Node::Reduce { control, .. } = editor.func().nodes[node.idx()] else {
+ return false;
+ };
+ match inner_control.get(control.idx()) {
+ Some(v) => *v,
+ None => false,
+ }
+ })
+ .chain(
+ editor
+ .get_users(fork)
+ .filter(|node| editor.node(node).is_thread_id()),
+ )
+ .collect();
- let all_users: HashSet<NodeID> = reduces.clone().iter().flat_map(|phi| walk_all_users_stop_on(*phi, editor, stop_on.clone()))
+ let all_users: HashSet<NodeID> = reduces
+ .clone()
+ .iter()
+ .flat_map(|phi| walk_all_users_stop_on(*phi, editor, stop_on.clone()))
.chain(reduces.clone())
.collect();
- let all_uses: HashSet<_> = reduces.clone().iter()
+ let all_uses: HashSet<_> = reduces
+ .clone()
+ .iter()
.flat_map(|phi| walk_all_uses_stop_on(*phi, editor, stop_on.clone()))
.chain(reduces)
- .filter(|node|
- {
+ .filter(|node| {
// Get rid of nodes in stop_on
!stop_on.contains(node)
- })
+ })
.collect();
all_users.intersection(&all_uses).cloned().collect()
@@ -77,7 +99,13 @@ pub fn calculate_fork_nodes(editor: &FunctionEditor, inner_control: &NodeVec, fo
* sequential loops in LLVM is actually not entirely trivial, so it's easier to
* just do this transformation within Hercules IR.
*/
-pub fn unforkify(editor: &mut FunctionEditor, fork_join_map: &HashMap<NodeID, NodeID>, loop_tree: &LoopTree) {
+
+// FIXME: Only works on fully split fork nests.
+pub fn unforkify(
+ editor: &mut FunctionEditor,
+ fork_join_map: &HashMap<NodeID, NodeID>,
+ loop_tree: &LoopTree,
+) {
let mut zero_cons_id = ConstantID::new(0);
let mut one_cons_id = ConstantID::new(0);
assert!(editor.edit(|mut edit| {
@@ -129,7 +157,7 @@ pub fn unforkify(editor: &mut FunctionEditor, fork_join_map: &HashMap<NodeID, No
let add_id = NodeID::new(num_nodes + 7);
let dc_id = NodeID::new(num_nodes + 8);
let neq_id = NodeID::new(num_nodes + 9);
-
+
let guard_if_id = NodeID::new(num_nodes + 10);
let guard_join_id = NodeID::new(num_nodes + 11);
let guard_taken_proj_id = NodeID::new(num_nodes + 12);
@@ -140,20 +168,29 @@ pub fn unforkify(editor: &mut FunctionEditor, fork_join_map: &HashMap<NodeID, No
let s = num_nodes + 15 + reduces.len();
let join_phi_ids = (s..s + reduces.len()).map(NodeID::new);
- let guard_cond = Node::Binary { left: zero_id, right: dc_id, op: BinaryOperator::LT};
- let guard_if = Node::If { control: fork_control, cond: guard_cond_id};
- let guard_taken_proj = Node::Projection { control: guard_if_id, selection: 1 };
- let guard_skipped_proj = Node::Projection { control: guard_if_id, selection: 0 };
- let guard_join = Node::Region { preds: Box::new([
- guard_skipped_proj_id,
- proj_exit_id,
- ])};
+ let guard_cond = Node::Binary {
+ left: zero_id,
+ right: dc_id,
+ op: BinaryOperator::LT,
+ };
+ let guard_if = Node::If {
+ control: fork_control,
+ cond: guard_cond_id,
+ };
+ let guard_taken_proj = Node::Projection {
+ control: guard_if_id,
+ selection: 1,
+ };
+ let guard_skipped_proj = Node::Projection {
+ control: guard_if_id,
+ selection: 0,
+ };
+ let guard_join = Node::Region {
+ preds: Box::new([guard_skipped_proj_id, proj_exit_id]),
+ };
let region = Node::Region {
- preds: Box::new([
- guard_taken_proj_id,
- proj_back_id,
- ]),
+ preds: Box::new([guard_taken_proj_id, proj_back_id]),
};
let if_node = Node::If {
control: join_control,
@@ -188,14 +225,16 @@ pub fn unforkify(editor: &mut FunctionEditor, fork_join_map: &HashMap<NodeID, No
.iter()
.map(|reduce_id| {
let (_, init, reduct) = nodes[reduce_id.idx()].try_reduce().unwrap();
- (Node::Phi {
- control: region_id,
- data: Box::new([init, reduct]),
- },
- Node::Phi {
- control: guard_join_id,
- data: Box::new([init, reduct])
- })
+ (
+ Node::Phi {
+ control: region_id,
+ data: Box::new([init, reduct]),
+ },
+ Node::Phi {
+ control: guard_join_id,
+ data: Box::new([init, reduct]),
+ },
+ )
})
.unzip();
@@ -231,13 +270,20 @@ pub fn unforkify(editor: &mut FunctionEditor, fork_join_map: &HashMap<NodeID, No
edit.sub_edit(*tid, indvar_id);
edit = edit.replace_all_uses(*tid, indvar_id)?;
}
- for (((reduce, phi_id), phi), join_phi_id) in zip(reduces.iter(), phi_ids).zip(phis).zip(join_phi_ids) {
+ for (((reduce, phi_id), phi), join_phi_id) in
+ zip(reduces.iter(), phi_ids).zip(phis).zip(join_phi_ids)
+ {
edit.sub_edit(*reduce, phi_id);
- let Node::Phi { control, data } = phi else {panic!()};
- edit = edit.replace_all_uses_where(*reduce, join_phi_id, |usee| !fork_nodes.contains(usee))?; //, |usee| *usee != *reduct)?;
- edit = edit.replace_all_uses_where(*reduce, phi_id, |usee| fork_nodes.contains(usee) || *usee == data[1])?;
+ let Node::Phi { control, data } = phi else {
+ panic!()
+ };
+ edit = edit.replace_all_uses_where(*reduce, join_phi_id, |usee| {
+ !fork_nodes.contains(usee)
+ })?; //, |usee| *usee != *reduct)?;
+ edit = edit.replace_all_uses_where(*reduce, phi_id, |usee| {
+ fork_nodes.contains(usee) || *usee == data[1]
+ })?;
edit = edit.delete_node(*reduce)?;
-
}
edit = edit.delete_node(*fork)?;
diff --git a/hercules_opt/src/utils.rs b/hercules_opt/src/utils.rs
index aa0d53fe..67225bff 100644
--- a/hercules_opt/src/utils.rs
+++ b/hercules_opt/src/utils.rs
@@ -1,7 +1,12 @@
+extern crate nestify;
+
+use std::collections::HashMap;
+use std::collections::HashSet;
use std::iter::zip;
use hercules_ir::def_use::*;
use hercules_ir::ir::*;
+use nestify::nest;
use crate::*;
@@ -376,3 +381,106 @@ pub(crate) fn indices_may_overlap(indices1: &[Index], indices2: &[Index]) -> boo
// may overlap when one indexes a larger sub-value than the other.
true
}
+
+pub type DenseNodeMap<T> = Vec<T>;
+pub type SparseNodeMap<T> = HashMap<NodeID, T>;
+
+nest! {
+// Is this something editor should give... Or is it just for analyses.
+//
+#[derive(Clone, Debug)]
+pub struct NodeIterator<'a> {
+ pub direction:
+ #[derive(Clone, Debug, PartialEq)]
+ enum Direction {
+ Uses,
+ Users,
+ },
+ visited: DenseNodeMap<bool>,
+ stack: Vec<NodeID>,
+ func: &'a FunctionEditor<'a>, // Maybe this is an enum, def use can be gotten from the function or from the editor.
+ // `stop condition`, then return all nodes that caused stoppage i.e the frontier of the search.
+ stop_on: HashSet<NodeID>, // Don't add neighbors of these.
+}
+}
+
+pub fn walk_all_uses<'a>(node: NodeID, editor: &'a FunctionEditor<'a>) -> NodeIterator<'a> {
+ let len = editor.func().nodes.len();
+ NodeIterator {
+ direction: Direction::Uses,
+ visited: vec![false; len],
+ stack: vec![node],
+ func: editor,
+ stop_on: HashSet::new(),
+ }
+}
+
+pub fn walk_all_users<'a>(node: NodeID, editor: &'a FunctionEditor<'a>) -> NodeIterator<'a> {
+ let len = editor.func().nodes.len();
+ NodeIterator {
+ direction: Direction::Users,
+ visited: vec![false; len],
+ stack: vec![node],
+ func: editor,
+ stop_on: HashSet::new(),
+ }
+}
+
+pub fn walk_all_uses_stop_on<'a>(
+ node: NodeID,
+ editor: &'a FunctionEditor<'a>,
+ stop_on: HashSet<NodeID>,
+) -> NodeIterator<'a> {
+ let len = editor.func().nodes.len();
+ let uses = editor.get_uses(node).collect();
+ NodeIterator {
+ direction: Direction::Uses,
+ visited: vec![false; len],
+ stack: uses,
+ func: editor,
+ stop_on,
+ }
+}
+
+pub fn walk_all_users_stop_on<'a>(
+ node: NodeID,
+ editor: &'a FunctionEditor<'a>,
+ stop_on: HashSet<NodeID>,
+) -> NodeIterator<'a> {
+ let len = editor.func().nodes.len();
+ let users = editor.get_users(node).collect();
+ NodeIterator {
+ direction: Direction::Users,
+ visited: vec![false; len],
+ stack: users,
+ func: editor,
+ stop_on,
+ }
+}
+
+impl<'a> Iterator for NodeIterator<'a> {
+ type Item = NodeID;
+
+ fn next(&mut self) -> Option<Self::Item> {
+ while let Some(current) = self.stack.pop() {
+ if !self.visited[current.idx()] {
+ self.visited[current.idx()] = true;
+
+ if !self.stop_on.contains(¤t) {
+ if self.direction == Direction::Uses {
+ for neighbor in self.func.get_uses(current) {
+ self.stack.push(neighbor)
+ }
+ } else {
+ for neighbor in self.func.get_users(current) {
+ self.stack.push(neighbor)
+ }
+ }
+ }
+
+ return Some(current);
+ }
+ }
+ None
+ }
+}
diff --git a/hercules_samples/matmul/build.rs b/hercules_samples/matmul/build.rs
index f895af86..c15ca97f 100644
--- a/hercules_samples/matmul/build.rs
+++ b/hercules_samples/matmul/build.rs
@@ -4,7 +4,7 @@ fn main() {
JunoCompiler::new()
.ir_in_src("matmul.hir")
.unwrap()
- //.schedule_in_src(if cfg!(feature = "cuda") { "gpu.sch" } else { "cpu.sch" })
+ // .schedule_in_src(if cfg!(feature = "cuda") { "gpu.sch" } else { "cpu.sch" })
.schedule_in_src("cpu.sch")
.unwrap()
.build()
diff --git a/hercules_test/hercules_interpreter/src/interpreter.rs b/hercules_test/hercules_interpreter/src/interpreter.rs
index 9b8e2e9c..1ef70561 100644
--- a/hercules_test/hercules_interpreter/src/interpreter.rs
+++ b/hercules_test/hercules_interpreter/src/interpreter.rs
@@ -1,10 +1,9 @@
-
+use std::collections::hash_map::Entry::Occupied;
use std::collections::HashMap;
use std::panic;
-use std::collections::hash_map::Entry::Occupied;
use itertools::Itertools;
-use std::cmp::{min, max};
+use std::cmp::{max, min};
use hercules_ir::*;
@@ -44,8 +43,8 @@ pub struct FunctionContext<'a> {
fork_join_nest: &'a HashMap<NodeID, Vec<NodeID>>,
}
-impl <'a> FunctionContext<'a> {
- pub fn new (
+impl<'a> FunctionContext<'a> {
+ pub fn new(
control_subgraph: &'a Subgraph,
def_use: &'a ImmutableDefUseMap,
fork_join_map: &'a HashMap<NodeID, NodeID>, // Map forks -> joins
@@ -61,18 +60,43 @@ impl <'a> FunctionContext<'a> {
}
// TODO: (@xrouth) I feel like this funcitonality should be provided by the manager that holds and allocates dynamic constants & IDs.
-pub fn dyn_const_value(dc: &DynamicConstantID, dyn_const_values: &[DynamicConstant], dyn_const_params: &[usize]) -> usize {
+pub fn dyn_const_value(
+ dc: &DynamicConstantID,
+ dyn_const_values: &[DynamicConstant],
+ dyn_const_params: &[usize],
+) -> usize {
let dc = &dyn_const_values[dc.idx()];
match dc {
DynamicConstant::Constant(v) => *v,
DynamicConstant::Parameter(v) => dyn_const_params[*v],
- DynamicConstant::Add(a, b) => dyn_const_value(a, dyn_const_values, dyn_const_params) + dyn_const_value(b, dyn_const_values, dyn_const_params),
- DynamicConstant::Sub(a, b) => dyn_const_value(a, dyn_const_values, dyn_const_params) - dyn_const_value(b, dyn_const_values, dyn_const_params),
- DynamicConstant::Mul(a, b) => dyn_const_value(a, dyn_const_values, dyn_const_params) * dyn_const_value(b, dyn_const_values, dyn_const_params),
- DynamicConstant::Div(a, b) => dyn_const_value(a, dyn_const_values, dyn_const_params) / dyn_const_value(b, dyn_const_values, dyn_const_params),
- DynamicConstant::Rem(a, b) => dyn_const_value(a, dyn_const_values, dyn_const_params) % dyn_const_value(b, dyn_const_values, dyn_const_params),
- DynamicConstant::Max(a, b) => max(dyn_const_value(a, dyn_const_values, dyn_const_params), dyn_const_value(b, dyn_const_values, dyn_const_params)),
- DynamicConstant::Min(a, b) => min(dyn_const_value(a, dyn_const_values, dyn_const_params), dyn_const_value(b, dyn_const_values, dyn_const_params)),
+ DynamicConstant::Add(a, b) => {
+ dyn_const_value(a, dyn_const_values, dyn_const_params)
+ + dyn_const_value(b, dyn_const_values, dyn_const_params)
+ }
+ DynamicConstant::Sub(a, b) => {
+ dyn_const_value(a, dyn_const_values, dyn_const_params)
+ - dyn_const_value(b, dyn_const_values, dyn_const_params)
+ }
+ DynamicConstant::Mul(a, b) => {
+ dyn_const_value(a, dyn_const_values, dyn_const_params)
+ * dyn_const_value(b, dyn_const_values, dyn_const_params)
+ }
+ DynamicConstant::Div(a, b) => {
+ dyn_const_value(a, dyn_const_values, dyn_const_params)
+ / dyn_const_value(b, dyn_const_values, dyn_const_params)
+ }
+ DynamicConstant::Rem(a, b) => {
+ dyn_const_value(a, dyn_const_values, dyn_const_params)
+ % dyn_const_value(b, dyn_const_values, dyn_const_params)
+ }
+ DynamicConstant::Max(a, b) => max(
+ dyn_const_value(a, dyn_const_values, dyn_const_params),
+ dyn_const_value(b, dyn_const_values, dyn_const_params),
+ ),
+ DynamicConstant::Min(a, b) => min(
+ dyn_const_value(a, dyn_const_values, dyn_const_params),
+ dyn_const_value(b, dyn_const_values, dyn_const_params),
+ ),
}
}
@@ -91,7 +115,12 @@ pub struct ControlToken {
impl ControlToken {
pub fn moved_to(&self, next: NodeID) -> ControlToken {
- ControlToken { curr: next, prev: self.curr, thread_indicies: self.thread_indicies.clone(), phi_values: self.phi_values.clone() }
+ ControlToken {
+ curr: next,
+ prev: self.curr,
+ thread_indicies: self.thread_indicies.clone(),
+ phi_values: self.phi_values.clone(),
+ }
}
}
impl<'a> FunctionExecutionState<'a> {
@@ -102,9 +131,15 @@ impl<'a> FunctionExecutionState<'a> {
function_contexts: &'a Vec<FunctionContext>,
dynamic_constant_params: Vec<usize>,
) -> Self {
- println!("param types: {:?}", module.functions[function_id.idx()].param_types);
+ println!(
+ "param types: {:?}",
+ module.functions[function_id.idx()].param_types
+ );
- assert_eq!(args.len(), module.functions[function_id.idx()].param_types.len());
+ assert_eq!(
+ args.len(),
+ module.functions[function_id.idx()].param_types.len()
+ );
FunctionExecutionState {
args,
@@ -138,15 +173,10 @@ impl<'a> FunctionExecutionState<'a> {
}
/* Drives PHI values of this region for a control token, returns the next control node. */
- pub fn handle_region(
- &mut self,
- token: &mut ControlToken,
- preds: &Box<[NodeID]>,
- ) -> NodeID {
-
+ pub fn handle_region(&mut self, token: &mut ControlToken, preds: &Box<[NodeID]>) -> NodeID {
let prev = token.prev;
let node = token.curr;
-
+
// Gather PHI nodes for this region node.
let phis: Vec<NodeID> = self
.get_def_use()
@@ -193,12 +223,12 @@ impl<'a> FunctionExecutionState<'a> {
.try_phi()
.expect("PANIC: handle_phi on non-phi node.");
let value_node = data[edge];
-
+
let value = self.handle_data(token, value_node);
if VERBOSE {
println!("Latching PHI {:?} to {:?}", phi.idx(), value);
}
-
+
(phi, value)
}
@@ -221,7 +251,7 @@ impl<'a> FunctionExecutionState<'a> {
for reduction in &reduces {
self.handle_reduction(&token, *reduction);
}
-
+
let thread_values = self.get_thread_factors(&token, join);
// println!("join for: {:?}", token);
// dbg!(thread_values.clone());
@@ -231,7 +261,11 @@ impl<'a> FunctionExecutionState<'a> {
.and_modify(|v| *v -= 1);
if VERBOSE {
- println!("join, thread_values : {:?}, {:?}", join, thread_values.clone());
+ println!(
+ "join, thread_values : {:?}, {:?}",
+ join,
+ thread_values.clone()
+ );
}
if *self
.join_counters
@@ -259,15 +293,28 @@ impl<'a> FunctionExecutionState<'a> {
// Take the top N entries such that it matches the length of the TRF in the control token.
// Get the depth of the control token that is requesting this reduction node.
-
+
// Sum over all thread dimensions in nested forks
- let fork_levels: usize = nested_forks.iter().map(|ele|
- self.get_function().nodes[ele.idx()].try_fork().unwrap().1.len()).sum();
-
+ let fork_levels: usize = nested_forks
+ .iter()
+ .map(|ele| {
+ self.get_function().nodes[ele.idx()]
+ .try_fork()
+ .unwrap()
+ .1
+ .len()
+ })
+ .sum();
+
let len = if nested_forks.is_empty() {
fork_levels - 1
} else {
- fork_levels - (self.get_function().nodes[nested_forks.first().unwrap().idx()].try_fork().unwrap().1.len())
+ fork_levels
+ - (self.get_function().nodes[nested_forks.first().unwrap().idx()]
+ .try_fork()
+ .unwrap()
+ .1
+ .len())
};
let mut thread_values = token.thread_indicies.clone();
@@ -276,7 +323,6 @@ impl<'a> FunctionExecutionState<'a> {
}
pub fn initialize_reduction(&mut self, token_at_fork: &ControlToken, reduce: NodeID) {
-
let token = token_at_fork;
let (control, init, _) = &self.get_function().nodes[reduce.idx()]
@@ -286,12 +332,16 @@ impl<'a> FunctionExecutionState<'a> {
let thread_values = self.get_thread_factors(token, *control);
let init = self.handle_data(&token, *init);
-
+
if VERBOSE {
- println!("reduction {:?} initialized to: {:?} on thread {:?}", reduce, init, thread_values);
+ println!(
+ "reduction {:?} initialized to: {:?} on thread {:?}",
+ reduce, init, thread_values
+ );
}
- self.reduce_values.insert((thread_values.clone(), reduce), init);
+ self.reduce_values
+ .insert((thread_values.clone(), reduce), init);
}
// Drive the reduction, this will be invoked for each control token.
@@ -305,7 +355,10 @@ impl<'a> FunctionExecutionState<'a> {
let data = self.handle_data(&token, *reduct);
if VERBOSE {
- println!("reduction {:?} write of {:?} on thread {:?}", reduce, data, thread_values);
+ println!(
+ "reduction {:?} write of {:?} on thread {:?}",
+ reduce, data, thread_values
+ );
}
self.reduce_values.insert((thread_values, reduce), data);
@@ -315,8 +368,11 @@ impl<'a> FunctionExecutionState<'a> {
// println!("Data Node: {} {:?}", node.idx(), &self.get_function().nodes[node.idx()]);
// Partial borrow complaint. :/
- match &self.module.functions[self.function_id.idx()].nodes[node.idx()]{
- Node::Phi { control: _, data: _ } => (*token
+ match &self.module.functions[self.function_id.idx()].nodes[node.idx()] {
+ Node::Phi {
+ control: _,
+ data: _,
+ } => (*token
.phi_values
.get(&node)
.expect(&format!("PANIC: Phi {:?} value not latched.", node)))
@@ -330,23 +386,45 @@ impl<'a> FunctionExecutionState<'a> {
.expect("PANIC: No nesting information for thread index!")
.clone();
- let num_dims_this_level = (self.get_function().nodes[nested_forks.first().unwrap().idx()].try_fork().unwrap().1.len());
+ let num_dims_this_level = (self.get_function().nodes
+ [nested_forks.first().unwrap().idx()]
+ .try_fork()
+ .unwrap()
+ .1
+ .len());
// println!("num forks this level:{:?} ", num_forks_this_level);
- // Skip forks until we get to this level.
- // How many forks are outer? idfk.
- let outer_forks: Vec<NodeID> = nested_forks.iter().cloned().take_while(|fork| *fork != node).collect();
+ // Skip forks until we get to this level.
+ // How many forks are outer? idfk.
+ let outer_forks: Vec<NodeID> = nested_forks
+ .iter()
+ .cloned()
+ .take_while(|fork| *fork != node)
+ .collect();
// println!("otuer_forkes: {:?}", outer_forks);
-
- let fork_levels: usize = outer_forks.iter().skip(1).map(|ele| self.get_function().nodes[ele.idx()].try_fork().unwrap().1.len()).sum();
+
+ let fork_levels: usize = outer_forks
+ .iter()
+ .skip(1)
+ .map(|ele| {
+ self.get_function().nodes[ele.idx()]
+ .try_fork()
+ .unwrap()
+ .1
+ .len()
+ })
+ .sum();
// println!("nested forks:{:?} ", nested_forks);
// println!("fork levels: {:?}", fork_levels);
// dimension might need to instead be dimensions - dimension
let v = token.thread_indicies[fork_levels + dimension]; // Might have to -1?
if VERBOSE {
- println!("node: {:?} gives tid: {:?} for thread: {:?}, dim: {:?}", node, v, token.thread_indicies, dimension);
+ println!(
+ "node: {:?} gives tid: {:?} for thread: {:?}, dim: {:?}",
+ node, v, token.thread_indicies, dimension
+ );
}
InterpreterVal::DynamicConstant((v).into())
}
@@ -360,13 +438,14 @@ impl<'a> FunctionExecutionState<'a> {
let thread_values = self.get_thread_factors(token, *control);
// println!("reduction read: {:?}, {:?}", thread_values, node);
- let entry = self
- .reduce_values
- .entry((thread_values.clone(), node));
-
+ let entry = self.reduce_values.entry((thread_values.clone(), node));
+
let val = match entry {
Occupied(v) => v.get().clone(),
- std::collections::hash_map::Entry::Vacant(_) => panic!("Ctrl token: {:?}, Reduce {:?} has not been initialized!, TV: {:?}", token, node, thread_values),
+ std::collections::hash_map::Entry::Vacant(_) => panic!(
+ "Ctrl token: {:?}, Reduce {:?} has not been initialized!, TV: {:?}",
+ token, node, thread_values
+ ),
};
// println!("value: {:?}", val.clone());
val
@@ -379,12 +458,16 @@ impl<'a> FunctionExecutionState<'a> {
&self.module.constants,
&self.module.types,
&self.module.dynamic_constants,
- &self.dynamic_constant_params
+ &self.dynamic_constant_params,
)
}
Node::DynamicConstant { id } => {
- let v = dyn_const_value(id, &self.module.dynamic_constants, &self.dynamic_constant_params);
-
+ let v = dyn_const_value(
+ id,
+ &self.module.dynamic_constants,
+ &self.dynamic_constant_params,
+ );
+
// TODO: Figure out what type / semantics are of thread ID and dynamic const.
InterpreterVal::UnsignedInteger64(v.try_into().expect("too big dyn const!"))
}
@@ -425,15 +508,21 @@ impl<'a> FunctionExecutionState<'a> {
control,
} => {
// todo!("call currently dissabled lol");
- let args = args.into_iter()
- .map(|arg_node| self.handle_data(token, *arg_node))
- .collect();
-
+ let args = args
+ .into_iter()
+ .map(|arg_node| self.handle_data(token, *arg_node))
+ .collect();
- let dynamic_constant_params = dynamic_constants.into_iter()
- .map(|id| {
- dyn_const_value(id, &self.module.dynamic_constants, &self.dynamic_constant_params)
- }).collect_vec();
+ let dynamic_constant_params = dynamic_constants
+ .into_iter()
+ .map(|id| {
+ dyn_const_value(
+ id,
+ &self.module.dynamic_constants,
+ &self.dynamic_constant_params,
+ )
+ })
+ .collect_vec();
let mut state = FunctionExecutionState::new(
args,
@@ -453,12 +542,13 @@ impl<'a> FunctionExecutionState<'a> {
let result = self.handle_read(token, collection.clone(), indices);
if VERBOSE {
- println!("{:?} read value : {:?} from {:?}, {:?} at index {:?}", node, result, collect, collection, indices);
+ println!(
+ "{:?} read value : {:?} from {:?}, {:?} at index {:?}",
+ node, result, collect, collection, indices
+ );
}
result
}
-
-
}
Node::Write {
collect,
@@ -473,11 +563,7 @@ impl<'a> FunctionExecutionState<'a> {
self.handle_write(token, collection, data, indices)
}
}
- Node::Undef {
- ty
- } => {
- InterpreterVal::Undef(*ty)
- }
+ Node::Undef { ty } => InterpreterVal::Undef(*ty),
_ => todo!(),
}
}
@@ -489,7 +575,6 @@ impl<'a> FunctionExecutionState<'a> {
data: InterpreterVal,
indices: &[Index],
) -> InterpreterVal {
-
// TODO (@xrouth): Recurse on writes correctly
let val = match indices.first() {
Some(Index::Field(idx)) => {
@@ -499,10 +584,8 @@ impl<'a> FunctionExecutionState<'a> {
} else {
panic!("PANIC: Field index on not a product type")
}
- },
- None => {
- collection
}
+ None => collection,
Some(Index::Variant(_)) => todo!(),
Some(Index::Position(array_indices)) => {
// Arrays also have inner indices...
@@ -518,7 +601,13 @@ impl<'a> FunctionExecutionState<'a> {
.try_extents()
.expect("PANIC: wrong type for array")
.into_iter()
- .map(|extent| dyn_const_value(extent, &self.module.dynamic_constants, &self.dynamic_constant_params))
+ .map(|extent| {
+ dyn_const_value(
+ extent,
+ &self.module.dynamic_constants,
+ &self.dynamic_constant_params,
+ )
+ })
.collect();
let idx = InterpreterVal::array_idx(&extents, &array_indices);
//println!("idx: {:?}", idx);
@@ -528,7 +617,6 @@ impl<'a> FunctionExecutionState<'a> {
vals[idx] = data;
InterpreterVal::Array(type_id, vals)
}
-
} else {
panic!("PANIC: Position index on not an array")
}
@@ -556,10 +644,10 @@ impl<'a> FunctionExecutionState<'a> {
.map(|idx| self.handle_data(token, *idx).as_usize())
.collect();
- if VERBOSE{
+ if VERBOSE {
println!("read at rt indicies: {:?}", array_indices);
}
-
+
// TODO: Implemenet . try_array() and other try_conversions on the InterpreterVal type
if let InterpreterVal::Array(type_id, vals) = collection {
// TODO: Make this its own funciton to reuse w/ array_size
@@ -567,15 +655,23 @@ impl<'a> FunctionExecutionState<'a> {
.try_extents()
.expect("PANIC: wrong type for array")
.into_iter()
- .map(|extent| dyn_const_value(extent, &self.module.dynamic_constants, &self.dynamic_constant_params))
+ .map(|extent| {
+ dyn_const_value(
+ extent,
+ &self.module.dynamic_constants,
+ &self.dynamic_constant_params,
+ )
+ })
.collect();
- // FIXME: This type may be wrong.
- let ret = vals.get(InterpreterVal::array_idx(&extents, &array_indices)).unwrap_or(&InterpreterVal::Undef(type_id)).clone();
+ // FIXME: This type may be wrong.
+ let ret = vals
+ .get(InterpreterVal::array_idx(&extents, &array_indices))
+ .unwrap_or(&InterpreterVal::Undef(type_id))
+ .clone();
if let InterpreterVal::Undef(_) = ret {
panic!("bad read!")
}
ret
-
} else {
panic!("PANIC: Position index on not an array")
}
@@ -603,10 +699,11 @@ impl<'a> FunctionExecutionState<'a> {
let mut live_tokens: Vec<ControlToken> = Vec::new();
live_tokens.push(start_token);
-
// To do reduction nodes correctly we have to traverse control tokens in a depth-first fashion (i.e immediately handle spawned threads).
'outer: loop {
- let mut ctrl_token = live_tokens.pop().expect("PANIC: Interpreter ran out of control tokens without returning.");
+ let mut ctrl_token = live_tokens
+ .pop()
+ .expect("PANIC: Interpreter ran out of control tokens without returning.");
// println!(
// "\n\nNew Token at: Control State: {} threads: {:?}, {:?}",
@@ -614,28 +711,34 @@ impl<'a> FunctionExecutionState<'a> {
// ctrl_token.thread_indicies.clone(),
// &self.get_function().nodes[ctrl_token.curr.idx()]
// );
- // TODO: (@xrouth): Enable this + PHI latch logging wi/ a simple debug flag.
+ // TODO: (@xrouth): Enable this + PHI latch logging wi/ a simple debug flag.
// Tracking PHI vals and control state is very useful for debugging.
-
if VERBOSE {
- println!("control token {} {}", ctrl_token.curr.idx(), &self.get_function().nodes[ctrl_token.curr.idx()].lower_case_name());
+ println!(
+ "control token {} {}",
+ ctrl_token.curr.idx(),
+ &self.get_function().nodes[ctrl_token.curr.idx()].lower_case_name()
+ );
}
// TODO: Rust is annoying and can't recognize that this is a partial borrow.
- // Can't partial borrow, so need a clone.
+ // Can't partial borrow, so need a clone.
let node = &self.get_function().nodes[ctrl_token.curr.idx()].clone();
let new_tokens = match node {
Node::Start => {
- let next: NodeID = self.get_control_subgraph().succs(ctrl_token.curr).next().unwrap();
+ let next: NodeID = self
+ .get_control_subgraph()
+ .succs(ctrl_token.curr)
+ .next()
+ .unwrap();
let ctrl_token = ctrl_token.moved_to(next);
-
+
vec![ctrl_token]
}
Node::Region { preds } => {
-
- // Updates
+ // Updates
let next = self.handle_region(&mut ctrl_token, &preds);
let ctrl_token = ctrl_token.moved_to(next);
@@ -666,7 +769,11 @@ impl<'a> FunctionExecutionState<'a> {
vec![ctrl_token]
}
Node::Projection { .. } => {
- let next: NodeID = self.get_control_subgraph().succs(ctrl_token.curr).next().unwrap();
+ let next: NodeID = self
+ .get_control_subgraph()
+ .succs(ctrl_token.curr)
+ .next()
+ .unwrap();
let ctrl_token = ctrl_token.moved_to(next);
@@ -674,18 +781,34 @@ impl<'a> FunctionExecutionState<'a> {
}
Node::Match { control: _, sum: _ } => todo!(),
- Node::Fork { control: _, factors } => {
+ Node::Fork {
+ control: _,
+ factors,
+ } => {
let fork = ctrl_token.curr;
// if factors.len() > 1 {
// panic!("multi-dimensional forks unimplemented")
// }
- let factors = factors.iter().map(|f| dyn_const_value(&f, &self.module.dynamic_constants, &self.dynamic_constant_params)).rev();
+ let factors = factors
+ .iter()
+ .map(|f| {
+ dyn_const_value(
+ &f,
+ &self.module.dynamic_constants,
+ &self.dynamic_constant_params,
+ )
+ })
+ .rev();
let n_tokens: usize = factors.clone().product();
- // Update control token
- let next = self.get_control_subgraph().succs(ctrl_token.curr).nth(0).unwrap();
+ // Update control token
+ let next = self
+ .get_control_subgraph()
+ .succs(ctrl_token.curr)
+ .nth(0)
+ .unwrap();
let ctrl_token = ctrl_token.moved_to(next);
let mut tokens_to_add = Vec::with_capacity(n_tokens);
@@ -707,7 +830,6 @@ impl<'a> FunctionExecutionState<'a> {
tokens_to_add.push(new_token);
}
-
let thread_factors = self.get_thread_factors(&ctrl_token, ctrl_token.curr);
// Find join and initialize them, and set their reduction counters as well.
@@ -729,7 +851,7 @@ impl<'a> FunctionExecutionState<'a> {
}
})
.collect();
-
+
for reduction in reduces {
// TODO: Is this the correct reduction?
self.initialize_reduction(&ctrl_token, reduction);
@@ -737,7 +859,10 @@ impl<'a> FunctionExecutionState<'a> {
// println!("tokens_to_add: {:?}", tokens_to_add);
if VERBOSE {
- println!("tf, fork, join, n_tokens: {:?}, {:?}, {:?}, {:?}", thread_factors, fork, join, n_tokens);
+ println!(
+ "tf, fork, join, n_tokens: {:?}, {:?}, {:?}, {:?}",
+ thread_factors, fork, join, n_tokens
+ );
}
self.join_counters.insert((thread_factors, join), n_tokens);
@@ -767,9 +892,6 @@ impl<'a> FunctionExecutionState<'a> {
for i in new_tokens {
live_tokens.push(i);
}
-
}
}
}
-
-
diff --git a/hercules_test/hercules_interpreter/src/lib.rs b/hercules_test/hercules_interpreter/src/lib.rs
index 7792f95a..baf0093e 100644
--- a/hercules_test/hercules_interpreter/src/lib.rs
+++ b/hercules_test/hercules_interpreter/src/lib.rs
@@ -1,7 +1,7 @@
pub mod interpreter;
pub mod value;
-extern crate postcard;
extern crate juno_scheduler;
+extern crate postcard;
use std::fs::File;
use std::io::Read;
@@ -10,15 +10,18 @@ use hercules_ir::Module;
use hercules_ir::TypeID;
use hercules_ir::ID;
-pub use juno_scheduler::PassManager;
use juno_scheduler::run_schedule_on_hercules;
+pub use juno_scheduler::PassManager;
pub use crate::interpreter::*;
pub use crate::value::*;
-// Get a vec of
-pub fn into_interp_val(module: &Module, wrapper: InterpreterWrapper, target_ty_id: TypeID) -> InterpreterVal
-{
+// Get a vec of
+pub fn into_interp_val(
+ module: &Module,
+ wrapper: InterpreterWrapper,
+ target_ty_id: TypeID,
+) -> InterpreterVal {
match wrapper {
InterpreterWrapper::Boolean(v) => InterpreterVal::Boolean(v),
InterpreterWrapper::Integer8(v) => InterpreterVal::Integer8(v),
@@ -36,31 +39,34 @@ pub fn into_interp_val(module: &Module, wrapper: InterpreterWrapper, target_ty_i
InterpreterWrapper::Array(array) => {
let ty = &module.types[target_ty_id.idx()];
- let ele_type = ty.try_element_type().expect("PANIC: Invalid parameter type");
- // unwrap -> map to rust type, check
-
+ let ele_type = ty
+ .try_element_type()
+ .expect("PANIC: Invalid parameter type");
+ // unwrap -> map to rust type, check
+
let mut values = vec![];
-
+
for i in 0..array.len() {
values.push(into_interp_val(module, array[i].clone(), TypeID::new(0)));
}
-
+
InterpreterVal::Array(target_ty_id, values.into_boxed_slice())
}
}
-}
+}
-pub fn array_from_interp_val<T: Clone>(module: &Module, interp_val: InterpreterVal) -> Vec<T>
- where value::InterpreterVal: Into<T>
+pub fn array_from_interp_val<T: Clone>(module: &Module, interp_val: InterpreterVal) -> Vec<T>
+where
+ value::InterpreterVal: Into<T>,
{
- vec![]
+ vec![]
}
// Recursively turns rt args into interpreter wrappers.
#[macro_export]
macro_rules! parse_rt_args {
($arg:expr) => {
- {
+ {
let mut values: Vec<InterpreterWrapper> = vec![];
@@ -70,7 +76,7 @@ macro_rules! parse_rt_args {
}
};
( $arg:expr, $($tail_args:expr), +) => {
- {
+ {
let mut values: Vec<InterpreterWrapper> = vec![];
values.push($arg.into());
@@ -157,20 +163,19 @@ macro_rules! interp_module {
};
}
-
#[macro_export]
macro_rules! interp_file_with_passes {
($path:literal, $dynamic_constants:expr, $passes:expr, $($args:expr), *) => {
{
let module = parse_file($path);
-
+
let result_before = interp_module!(module, $dynamic_constants, $($args), *);
let module = run_schedule_on_hercules(module, None).unwrap();
- let result_after = interp_module!(module, $dynamic_constants, $($args), *);
+ let result_after = interp_module!(module, $dynamic_constants, $($args), *);
assert_eq!(result_after, result_before);
}
};
-}
\ No newline at end of file
+}
diff --git a/hercules_test/hercules_interpreter/src/value.rs b/hercules_test/hercules_interpreter/src/value.rs
index 2ca043c2..c84b4849 100644
--- a/hercules_test/hercules_interpreter/src/value.rs
+++ b/hercules_test/hercules_interpreter/src/value.rs
@@ -215,10 +215,10 @@ impl<'a> InterpreterVal {
) -> InterpreterVal {
// If either are undef, propogate undef
if let InterpreterVal::Undef(v) = left {
- return InterpreterVal::Undef(v)
+ return InterpreterVal::Undef(v);
}
if let InterpreterVal::Undef(v) = right {
- return InterpreterVal::Undef(v)
+ return InterpreterVal::Undef(v);
}
// Do some type conversion first.
@@ -862,7 +862,6 @@ impl<'a> InterpreterVal {
}
}
-
pub fn as_i128(&self) -> i128 {
match *self {
InterpreterVal::Boolean(v) => v.try_into().unwrap(),
diff --git a/hercules_test/hercules_tests/tests/fork_transform_tests.rs b/hercules_test/hercules_tests/tests/fork_transform_tests.rs
index faae39ac..16813b03 100644
--- a/hercules_test/hercules_tests/tests/fork_transform_tests.rs
+++ b/hercules_test/hercules_tests/tests/fork_transform_tests.rs
@@ -4,39 +4,32 @@ use hercules_interpreter::*;
use hercules_ir::ID;
use juno_scheduler::ir::*;
-
extern crate rand;
-use juno_scheduler::{default_schedule, run_schedule_on_hercules};
-use rand::Rng;
use juno_scheduler::pass;
-
-
+use juno_scheduler::{default_schedule, run_schedule_on_hercules};
+use rand::Rng;
#[test]
fn fission_simple1() {
let module = parse_file("../test_inputs/fork_transforms/fork_fission/simple1.hir");
let dyn_consts = [10];
let params = 2; // TODO: (@xrouth) fix macro to take no params as an option.
- let result_1 = interp_module!(module, 0, dyn_consts, 2);
+ let result_1 = interp_module!(module, 0, dyn_consts, 2);
println!("result: {:?}", result_1);
-
+
let sched = Some(default_schedule![
- Verify,
- //Xdot,
- Unforkify,
- //Xdot,
- DCE,
- Verify,
+ Verify, //Xdot,
+ Unforkify, //Xdot,
+ DCE, Verify,
]);
let module = run_schedule_on_hercules(module, sched).unwrap();
- let result_2 = interp_module!(module, 0, dyn_consts, 2);
+ let result_2 = interp_module!(module, 0, dyn_consts, 2);
println!("result: {:?}", result_2);
assert_eq!(result_1, result_2)
}
-
// #[test]
// fn fission_simple2() {
// let module = parse_file("../test_inputs/fork_transforms/fork_fission/simple2.hir");
@@ -45,7 +38,7 @@ fn fission_simple1() {
// let result_1 = interp_module!(module, 0, dyn_consts, 2);
// println!("result: {:?}", result_1);
-
+
// let sched: Option<ScheduleStmt> = Some(default_schedule![
// Verify,
// ForkFission,
@@ -69,7 +62,7 @@ fn fission_simple1() {
// let result_1 = interp_module!(module, 0, dyn_consts, 2);
// println!("result: {:?}", result_1);
-
+
// let sched: Option<ScheduleStmt> = Some(default_schedule![
// Verify,
// ForkFission,
@@ -92,7 +85,7 @@ fn fission_simple1() {
// let result_1 = interp_module!(module, 0, dyn_consts, 2);
// println!("result: {:?}", result_1);
-
+
// let sched: Option<ScheduleStmt> = Some(default_schedule![
// Verify,
// ForkFission,
@@ -104,4 +97,4 @@ fn fission_simple1() {
// let result_2 = interp_module!(module, 0, dyn_consts, 2);
// println!("result: {:?}", result_2);
// assert_eq!(result_1, result_2)
-// }
\ No newline at end of file
+// }
diff --git a/hercules_test/hercules_tests/tests/forkify_tests.rs b/hercules_test/hercules_tests/tests/forkify_tests.rs
index 9d123672..025aaad3 100644
--- a/hercules_test/hercules_tests/tests/forkify_tests.rs
+++ b/hercules_test/hercules_tests/tests/forkify_tests.rs
@@ -11,52 +11,39 @@ extern crate rand;
use juno_scheduler::{default_schedule, run_schedule_on_hercules};
use rand::Rng;
-
#[test]
#[ignore]
fn inner_fork_chain() {
let module = parse_file("../test_inputs/forkify/inner_fork_chain.hir");
let dyn_consts = [10];
let params = 2; // TODO: (@xrouth) fix macro to take no params as an option.
- // let result_1 = interp_module!(module, 0, dyn_consts, 2);
+ // let result_1 = interp_module!(module, 0, dyn_consts, 2);
// println!("result: {:?}", result_1);
-
- let sched: Option<ScheduleStmt> = Some(default_schedule![
- Verify,
-
- Forkify,
- PhiElim,
-
- Verify,
- ]);
+
+ let sched: Option<ScheduleStmt> = Some(default_schedule![Verify, Forkify, PhiElim, Verify,]);
let module = run_schedule_on_hercules(module, sched).unwrap();
- let result_2 = interp_module!(module, 0, dyn_consts, 2);
+ let result_2 = interp_module!(module, 0, dyn_consts, 2);
println!("result: {:?}", result_2);
// assert_eq!(result_1, result_2)
}
-
#[test]
fn loop_simple_iv() {
let module = parse_file("../test_inputs/forkify/loop_simple_iv.hir");
let dyn_consts = [10];
let params = 2; // TODO: (@xrouth) fix macro to take no params as an option.
- let result_1 = interp_module!(module, 0, dyn_consts, 2);
+ let result_1 = interp_module!(module, 0, dyn_consts, 2);
println!("result: {:?}", result_1);
-
- let sched: Option<ScheduleStmt> = Some(default_schedule![
- Verify,
- Forkify,
- Verify,
- ]);
+
+ let sched: Option<ScheduleStmt> = Some(default_schedule![Verify, Forkify, Verify,]);
let module = run_schedule_on_hercules(module, sched).unwrap();
- let result_2 = interp_module!(module, 0, dyn_consts, 2);
+ let result_2 = interp_module!(module, 0, dyn_consts, 2);
println!("result: {:?}", result_2);
assert_eq!(result_1, result_2)
}
@@ -67,19 +54,15 @@ fn merged_phi_cycle() {
let module = parse_file("../test_inputs/forkify/merged_phi_cycle.hir");
let dyn_consts = [10];
let params = 2; // TODO: (@xrouth) fix macro to take no params as an option.
- let result_1 = interp_module!(module, 0, dyn_consts, 2);
+ let result_1 = interp_module!(module, 0, dyn_consts, 2);
println!("result: {:?}", result_1);
-
- let sched: Option<ScheduleStmt> = Some(default_schedule![
- Verify,
-
- Verify,
- ]);
+
+ let sched: Option<ScheduleStmt> = Some(default_schedule![Verify, Verify,]);
let module = run_schedule_on_hercules(module, sched).unwrap();
- let result_2 = interp_module!(module, 0, dyn_consts, 2);
+ let result_2 = interp_module!(module, 0, dyn_consts, 2);
println!("result: {:?}", result_2);
assert_eq!(result_1, result_2)
}
@@ -89,19 +72,15 @@ fn split_phi_cycle() {
let module = parse_file("../test_inputs/forkify/split_phi_cycle.hir");
let dyn_consts = [10];
let params = 2; // TODO: (@xrouth) fix macro to take no params as an option.
- let result_1 = interp_module!(module, 0, dyn_consts, 2);
+ let result_1 = interp_module!(module, 0, dyn_consts, 2);
println!("result: {:?}", result_1);
-
- let sched: Option<ScheduleStmt> = Some(default_schedule![
- Verify,
-
- Verify,
- ]);
+
+ let sched: Option<ScheduleStmt> = Some(default_schedule![Verify, Verify,]);
let module = run_schedule_on_hercules(module, sched).unwrap();
- let result_2 = interp_module!(module, 0, dyn_consts, 2);
+ let result_2 = interp_module!(module, 0, dyn_consts, 2);
println!("result: {:?}", result_2);
assert_eq!(result_1, result_2)
}
@@ -111,12 +90,12 @@ fn loop_sum() {
let module = parse_file("../test_inputs/forkify/loop_sum.hir");
let dyn_consts = [20];
let params = 2; // TODO: (@xrouth) fix macro to take no params as an option.
- let result_1 = interp_module!(module, 0, dyn_consts, 2);
+ let result_1 = interp_module!(module, 0, dyn_consts, 2);
println!("result: {:?}", result_1);
-
+
let module = run_schedule_on_hercules(module, None).unwrap();
- let result_2 = interp_module!(module, 0, dyn_consts, 2);
+ let result_2 = interp_module!(module, 0, dyn_consts, 2);
assert_eq!(result_1, result_2);
println!("{:?}, {:?}", result_1, result_2);
}
@@ -126,12 +105,12 @@ fn loop_tid_sum() {
let module = parse_file("../test_inputs/forkify/loop_tid_sum.hir");
let dyn_consts = [20];
let params = 2; // TODO: (@xrouth) fix macro to take no params as an option.
- let result_1 = interp_module!(module, 0, dyn_consts, 2);
+ let result_1 = interp_module!(module, 0, dyn_consts, 2);
println!("result: {:?}", result_1);
-
+
let module = run_schedule_on_hercules(module, None).unwrap();
- let result_2 = interp_module!(module, 0, dyn_consts, 2);
+ let result_2 = interp_module!(module, 0, dyn_consts, 2);
assert_eq!(result_1, result_2);
println!("{:?}, {:?}", result_1, result_2);
}
@@ -142,24 +121,24 @@ fn loop_array_sum() {
let len = 5;
let dyn_consts = [len];
let params = vec![1, 2, 3, 4, 5]; // TODO: (@xrouth) fix macro to take no params as an option.
- let result_1 = interp_module!(module, 0, dyn_consts, params.clone());
+ let result_1 = interp_module!(module, 0, dyn_consts, params.clone());
println!("result: {:?}", result_1);
-
+
let module = run_schedule_on_hercules(module, None).unwrap();
- let result_2 = interp_module!(module, 0, dyn_consts, params);
+ let result_2 = interp_module!(module, 0, dyn_consts, params);
assert_eq!(result_1, result_2);
println!("{:?}, {:?}", result_1, result_2);
}
-/** Nested loop 2 is 2 nested loops with different dyn var parameter dimensions.
+/** Nested loop 2 is 2 nested loops with different dyn var parameter dimensions.
* It is a add of 1 for each iteration, so the result should be dim1 x dim2
* The loop PHIs are structured such that on every outer iteration, inner loop increment is set to the running sum,
- * Notice how there is no outer_var_inc.
- *
- * The alternative, seen in nested_loop1, is to intiailize the inner loop to 0 every time, and track
+ * Notice how there is no outer_var_inc.
+ *
+ * The alternative, seen in nested_loop1, is to intiailize the inner loop to 0 every time, and track
* the outer sum more separaetly.
- *
+ *
* Idk what im yapping about.
*/
#[test]
@@ -168,14 +147,13 @@ fn nested_loop2() {
let len = 5;
let dyn_consts = [5, 6];
let params = vec![1, 2, 3, 4, 5]; // TODO: (@xrouth) fix macro to take no params as an option.
- let result_1 = interp_module!(module, 0, dyn_consts, 2);
+ let result_1 = interp_module!(module, 0, dyn_consts, 2);
println!("result: {:?}", result_1);
-
+
let module = run_schedule_on_hercules(module, None).unwrap();
- let result_2 = interp_module!(module, 0, dyn_consts, 2);
+ let result_2 = interp_module!(module, 0, dyn_consts, 2);
assert_eq!(result_1, result_2);
-
}
#[test]
@@ -184,20 +162,19 @@ fn super_nested_loop() {
let len = 5;
let dyn_consts = [5, 10, 15];
let params = vec![1, 2, 3, 4, 5]; // TODO: (@xrouth) fix macro to take no params as an option.
- let result_1 = interp_module!(module, 0, dyn_consts, 2);
+ let result_1 = interp_module!(module, 0, dyn_consts, 2);
println!("result: {:?}", result_1);
-
+
let module = run_schedule_on_hercules(module, None).unwrap();
- let result_2 = interp_module!(module, 0, dyn_consts, 2);
+ let result_2 = interp_module!(module, 0, dyn_consts, 2);
assert_eq!(result_1, result_2);
}
-
/**
- * Tests forkify on a loop where there is control in between the continue projection
- * and the header. aka control *after* the `loop condition / guard`. This should forkify.
+ * Tests forkify on a loop where there is control in between the continue projection
+ * and the header. aka control *after* the `loop condition / guard`. This should forkify.
*/
#[test]
fn control_after_condition() {
@@ -212,21 +189,20 @@ fn control_after_condition() {
*x = rng.gen::<i32>() / 100;
}
- let result_1 = interp_module!(module, 0, dyn_consts, vec.clone());
+ let result_1 = interp_module!(module, 0, dyn_consts, vec.clone());
println!("result: {:?}", result_1);
-
+
let module = run_schedule_on_hercules(module, None).unwrap();
- let result_2 = interp_module!(module, 0, dyn_consts, vec);
+ let result_2 = interp_module!(module, 0, dyn_consts, vec);
assert_eq!(result_1, result_2);
-
}
/**
- * Tests forkify on a loop where there is control before the loop condition, so in between the header
- * and the loop condition. This should not forkify.
- *
+ * Tests forkify on a loop where there is control before the loop condition, so in between the header
+ * and the loop condition. This should not forkify.
+ *
* This example is bugged, it reads out of bounds even before forkify.
*/
#[ignore]
@@ -243,21 +219,15 @@ fn control_before_condition() {
*x = rng.gen::<i32>() / 100;
}
- let result_1 = interp_module!(module, 0, dyn_consts, vec.clone());
+ let result_1 = interp_module!(module, 0, dyn_consts, vec.clone());
println!("result: {:?}", result_1);
-
- let sched: Option<ScheduleStmt> = Some(default_schedule![
- Verify,
- Forkify,
- DCE,
- Verify,
- ]);
+
+ let sched: Option<ScheduleStmt> = Some(default_schedule![Verify, Forkify, DCE, Verify,]);
let module = run_schedule_on_hercules(module, sched).unwrap();
- let result_2 = interp_module!(module, 0, dyn_consts, vec);
+ let result_2 = interp_module!(module, 0, dyn_consts, vec);
assert_eq!(result_1, result_2);
-
}
#[test]
@@ -266,30 +236,20 @@ fn nested_tid_sum() {
let len = 5;
let dyn_consts = [5, 6];
let params = vec![1, 2, 3, 4, 5]; // TODO: (@xrouth) fix macro to take no params as an option.
- let result_1 = interp_module!(module, 0, dyn_consts, 2);
+ let result_1 = interp_module!(module, 0, dyn_consts, 2);
println!("result: {:?}", result_1);
-
- let sched: Option<ScheduleStmt> = Some(default_schedule![
- Verify,
- Forkify,
- DCE,
- Verify,
- ]);
+
+ let sched: Option<ScheduleStmt> = Some(default_schedule![Verify, Forkify, DCE, Verify,]);
let module = run_schedule_on_hercules(module, sched).unwrap();
- let result_2 = interp_module!(module, 0, dyn_consts, 2);
+ let result_2 = interp_module!(module, 0, dyn_consts, 2);
assert_eq!(result_1, result_2);
- let sched: Option<ScheduleStmt> = Some(default_schedule![
- Verify,
- Forkify,
- DCE,
- Verify,
- ]);
+ let sched: Option<ScheduleStmt> = Some(default_schedule![Verify, Forkify, DCE, Verify,]);
let module = run_schedule_on_hercules(module, sched).unwrap();
- let result_3 = interp_module!(module, 0, dyn_consts, 2);
+ let result_3 = interp_module!(module, 0, dyn_consts, 2);
println!("{:?}, {:?}, {:?}", result_1, result_2, result_3);
}
@@ -300,54 +260,38 @@ fn nested_tid_sum_2() {
let len = 5;
let dyn_consts = [5, 6];
let params = vec![1, 2, 3, 4, 5]; // TODO: (@xrouth) fix macro to take no params as an option.
- let result_1 = interp_module!(module, 0, dyn_consts, 2);
+ let result_1 = interp_module!(module, 0, dyn_consts, 2);
println!("result: {:?}", result_1);
-
- let sched: Option<ScheduleStmt> = Some(default_schedule![
- Verify,
- Forkify,
- DCE,
- Verify,
- ]);
+
+ let sched: Option<ScheduleStmt> = Some(default_schedule![Verify, Forkify, DCE, Verify,]);
let module = run_schedule_on_hercules(module, sched).unwrap();
- let result_2 = interp_module!(module, 0, dyn_consts, 2);
+ let result_2 = interp_module!(module, 0, dyn_consts, 2);
assert_eq!(result_1, result_2);
- let sched: Option<ScheduleStmt> = Some(default_schedule![
- Verify,
- Forkify,
- DCE,
- Verify,
- ]);
+ let sched: Option<ScheduleStmt> = Some(default_schedule![Verify, Forkify, DCE, Verify,]);
let module = run_schedule_on_hercules(module, sched).unwrap();
- let result_3 = interp_module!(module, 0, dyn_consts, 2);
+ let result_3 = interp_module!(module, 0, dyn_consts, 2);
println!("{:?}, {:?}, {:?}", result_1, result_2, result_3);
}
-
/** Tests weird control in outer loop for possible 2d fork-join pair. */
#[test]
fn inner_fork_complex() {
let module = parse_file("../test_inputs/forkify/inner_fork_complex.hir");
let dyn_consts = [5, 6];
let params = vec![1, 2, 3, 4, 5]; // TODO: (@xrouth) fix macro to take no params as an option.
- let result_1 = interp_module!(module, 0, dyn_consts, 10);
+ let result_1 = interp_module!(module, 0, dyn_consts, 10);
println!("result: {:?}", result_1);
-
- let sched: Option<ScheduleStmt> = Some(default_schedule![
- Verify,
- Forkify,
- DCE,
- Verify,
- ]);
+
+ let sched: Option<ScheduleStmt> = Some(default_schedule![Verify, Forkify, DCE, Verify,]);
let module = run_schedule_on_hercules(module, sched).unwrap();
- let result_2 = interp_module!(module, 0, dyn_consts, 10);
+ let result_2 = interp_module!(module, 0, dyn_consts, 10);
assert_eq!(result_1, result_2);
println!("{:?}, {:?}", result_1, result_2);
-}
\ No newline at end of file
+}
diff --git a/hercules_test/hercules_tests/tests/interpreter_tests.rs b/hercules_test/hercules_tests/tests/interpreter_tests.rs
index e619f18a..69e1920e 100644
--- a/hercules_test/hercules_tests/tests/interpreter_tests.rs
+++ b/hercules_test/hercules_tests/tests/interpreter_tests.rs
@@ -10,27 +10,22 @@ extern crate rand;
use juno_scheduler::{default_schedule, run_schedule_on_hercules};
use rand::Rng;
-
#[test]
fn twodeefork() {
let module = parse_file("../test_inputs/2d_fork.hir");
let d1 = 2;
let d2 = 3;
let dyn_consts = [d1, d2];
- let result_1 = interp_module!(module, 0, dyn_consts, 2);
+ let result_1 = interp_module!(module, 0, dyn_consts, 2);
let sched = Some(default_schedule![
- Verify,
- ForkSplit,
- //Xdot,
- Unforkify,
- //Xdot,
- DCE,
- Verify,
+ Verify, ForkSplit, //Xdot,
+ Unforkify, //Xdot,
+ DCE, Verify,
]);
let module = run_schedule_on_hercules(module, sched).unwrap();
- let result_2 = interp_module!(module, 0, dyn_consts, 2);
+ let result_2 = interp_module!(module, 0, dyn_consts, 2);
let res = (d1 as i32 * d2 as i32);
let result_2: InterpreterWrapper = res.into();
@@ -44,31 +39,26 @@ fn threedee() {
let d2 = 3;
let d3 = 5;
let dyn_consts = [d1, d2, 5];
- let result_1 = interp_module!(module, 0, dyn_consts, 2);
+ let result_1 = interp_module!(module, 0, dyn_consts, 2);
let sched = Some(default_schedule![
- Verify,
- ForkSplit,
- //Xdot,
- Unforkify,
- //Xdot,
- DCE,
- Verify,
+ Verify, ForkSplit, //Xdot,
+ Unforkify, //Xdot,
+ DCE, Verify,
]);
let module = run_schedule_on_hercules(module, sched).unwrap();
- let result_2 = interp_module!(module, 0, dyn_consts, 2);
+ let result_2 = interp_module!(module, 0, dyn_consts, 2);
let res = (d1 as i32 * d2 as i32 * d3 as i32);
let result_2: InterpreterWrapper = res.into();
println!("result: {:?}", result_1); // Should be d1 * d2.
}
-
#[test]
fn fivedeefork() {
let module = parse_file("../test_inputs/5d_fork.hir");
let dyn_consts = [1, 2, 3, 4, 5];
- let result_1 = interp_module!(module, 0, dyn_consts, 2);
+ let result_1 = interp_module!(module, 0, dyn_consts, 2);
println!("result: {:?}", result_1); // Should be 1 * 2 * 3 * 4 * 5;
}
diff --git a/hercules_test/hercules_tests/tests/loop_tests.rs b/hercules_test/hercules_tests/tests/loop_tests.rs
index 2406360c..29b8692b 100644
--- a/hercules_test/hercules_tests/tests/loop_tests.rs
+++ b/hercules_test/hercules_tests/tests/loop_tests.rs
@@ -18,12 +18,11 @@ fn loop_trip_count() {
let module = parse_file("../test_inputs/loop_analysis/loop_trip_count.hir");
let dyn_consts = [10];
let params = 2; // TODO: (@xrouth) fix macro to take no params as an option.
- let result_1 = interp_module!(module, 0,dyn_consts, 2);
+ let result_1 = interp_module!(module, 0, dyn_consts, 2);
println!("result: {:?}", result_1);
}
-
// Test canonicalization
#[test]
#[ignore]
@@ -31,8 +30,9 @@ fn alternate_bounds_use_after_loop_no_tid() {
let len = 1;
let dyn_consts = [len];
- let module = parse_file("../test_inputs/loop_analysis/alternate_bounds_use_after_loop_no_tid.hir");
- let result_1 = interp_module!(module, 0,dyn_consts, 3);
+ let module =
+ parse_file("../test_inputs/loop_analysis/alternate_bounds_use_after_loop_no_tid.hir");
+ let result_1 = interp_module!(module, 0, dyn_consts, 3);
println!("result: {:?}", result_1);
@@ -43,8 +43,8 @@ fn alternate_bounds_use_after_loop_no_tid() {
];
let module = run_schedule_on_hercules(module, Some(schedule)).unwrap();
-
- let result_2 = interp_module!(module, 0,dyn_consts, 3);
+
+ let result_2 = interp_module!(module, 0, dyn_consts, 3);
println!("{:?}", result_1);
println!("{:?}", result_2);
@@ -60,7 +60,7 @@ fn alternate_bounds_use_after_loop() {
let a = vec![3, 4, 5, 6];
let module = parse_file("../test_inputs/loop_analysis/alternate_bounds_use_after_loop.hir");
- let result_1 = interp_module!(module, 0,dyn_consts, a.clone());
+ let result_1 = interp_module!(module, 0, dyn_consts, a.clone());
println!("result: {:?}", result_1);
@@ -72,7 +72,7 @@ fn alternate_bounds_use_after_loop() {
let module = run_schedule_on_hercules(module, schedule).unwrap();
- let result_2 = interp_module!(module, 0,dyn_consts, a.clone());
+ let result_2 = interp_module!(module, 0, dyn_consts, a.clone());
//println!("{:?}", result_1);
println!("{:?}", result_2);
@@ -88,7 +88,7 @@ fn alternate_bounds_use_after_loop2() {
let a = vec![3, 4, 5, 6];
let module = parse_file("../test_inputs/loop_analysis/alternate_bounds_use_after_loop2.hir");
- let result_1 = interp_module!(module, 0,dyn_consts, a.clone());
+ let result_1 = interp_module!(module, 0, dyn_consts, a.clone());
println!("result: {:?}", result_1);
@@ -98,7 +98,7 @@ fn alternate_bounds_use_after_loop2() {
let module = run_schedule_on_hercules(module, schedule).unwrap();
- let result_2 = interp_module!(module, 0,dyn_consts, a.clone());
+ let result_2 = interp_module!(module, 0, dyn_consts, a.clone());
//println!("{:?}", result_1);
println!("{:?}", result_2);
@@ -119,8 +119,7 @@ fn do_while_separate_body() {
let schedule = Some(default_schedule![
////Xdot,,
- PhiElim,
- ////Xdot,,
+ PhiElim, ////Xdot,,
Forkify,
//Xdot,
]);
@@ -140,21 +139,20 @@ fn alternate_bounds_internal_control() {
let dyn_consts = [len];
let module = parse_file("../test_inputs/loop_analysis/alternate_bounds_internal_control.hir");
- let result_1 = interp_module!(module, 0,dyn_consts, 3);
+ let result_1 = interp_module!(module, 0, dyn_consts, 3);
println!("result: {:?}", result_1);
let schedule = Some(default_schedule![
////Xdot,,
- PhiElim,
- ////Xdot,,
+ PhiElim, ////Xdot,,
Forkify,
//Xdot,
]);
let module = run_schedule_on_hercules(module, schedule).unwrap();
- let result_2 = interp_module!(module, 0,dyn_consts, 3);
+ let result_2 = interp_module!(module, 0, dyn_consts, 3);
println!("{:?}", result_1);
println!("{:?}", result_2);
@@ -167,21 +165,20 @@ fn alternate_bounds_internal_control2() {
let dyn_consts = [len];
let module = parse_file("../test_inputs/loop_analysis/alternate_bounds_internal_control2.hir");
- let result_1 = interp_module!(module, 0,dyn_consts, 3);
+ let result_1 = interp_module!(module, 0, dyn_consts, 3);
println!("result: {:?}", result_1);
let schedule = Some(default_schedule![
////Xdot,,
- PhiElim,
- ////Xdot,,
+ PhiElim, ////Xdot,,
Forkify,
//Xdot,
]);
let module = run_schedule_on_hercules(module, schedule).unwrap();
- let result_2 = interp_module!(module, 0,dyn_consts, 3);
+ let result_2 = interp_module!(module, 0, dyn_consts, 3);
println!("{:?}", result_1);
println!("{:?}", result_2);
@@ -194,13 +191,13 @@ fn alternate_bounds_nested_do_loop() {
let dyn_consts = [10, 5];
let module = parse_file("../test_inputs/loop_analysis/alternate_bounds_nested_do_loop.hir");
- let result_1 = interp_module!(module, 0,dyn_consts, 3);
+ let result_1 = interp_module!(module, 0, dyn_consts, 3);
println!("result: {:?}", result_1);
let module = run_schedule_on_hercules(module, None).unwrap();
- let result_2 = interp_module!(module, 0,dyn_consts, 3);
+ let result_2 = interp_module!(module, 0, dyn_consts, 3);
println!("{:?}", result_1);
println!("{:?}", result_2);
@@ -213,14 +210,15 @@ fn alternate_bounds_nested_do_loop_array() {
let dyn_consts = [10, 5];
let a = vec![4u64, 4, 4, 4, 4];
- let module = parse_file("../test_inputs/loop_analysis/alternate_bounds_nested_do_loop_array.hir");
- let result_1 = interp_module!(module, 0,dyn_consts, a.clone());
+ let module =
+ parse_file("../test_inputs/loop_analysis/alternate_bounds_nested_do_loop_array.hir");
+ let result_1 = interp_module!(module, 0, dyn_consts, a.clone());
println!("result: {:?}", result_1);
let module = run_schedule_on_hercules(module, None).unwrap();
- let result_2 = interp_module!(module, 0,dyn_consts, a);
+ let result_2 = interp_module!(module, 0, dyn_consts, a);
println!("{:?}", result_1);
println!("{:?}", result_2);
@@ -232,14 +230,15 @@ fn alternate_bounds_nested_do_loop_guarded() {
let len = 1;
let dyn_consts = [3, 2];
- let module = parse_file("../test_inputs/loop_analysis/alternate_bounds_nested_do_loop_guarded.hir");
- let result_1 = interp_module!(module, 0,dyn_consts, 3);
+ let module =
+ parse_file("../test_inputs/loop_analysis/alternate_bounds_nested_do_loop_guarded.hir");
+ let result_1 = interp_module!(module, 0, dyn_consts, 3);
println!("result: {:?}", result_1);
let module = run_schedule_on_hercules(module, None).unwrap();
- let result_2 = interp_module!(module, 0,dyn_consts, 3);
+ let result_2 = interp_module!(module, 0, dyn_consts, 3);
println!("{:?}", result_1);
println!("{:?}", result_2);
@@ -249,16 +248,16 @@ fn alternate_bounds_nested_do_loop_guarded() {
let module = run_schedule_on_hercules(module, None).unwrap();
- let result_2 = interp_module!(module, 0,dyn_consts, 3);
+ let result_2 = interp_module!(module, 0, dyn_consts, 3);
println!("{:?}", result_1);
println!("{:?}", result_2);
assert_eq!(result_1, result_2);
}
-// Tests a do while loop that only iterates once,
-// canonicalization *should not* transform this to a while loop, as there is no
-// guard that replicates the loop condition.
+// Tests a do while loop that only iterates once,
+// canonicalization *should not* transform this to a while loop, as there is no
+// guard that replicates the loop condition.
#[ignore]
#[test]
fn do_loop_not_continued() {
@@ -272,21 +271,21 @@ fn do_loop_not_continued() {
// println!("result: {:?}", result_1);
}
-// Tests a do while loop that is guarded, so should be canonicalized
-// It also has
+// Tests a do while loop that is guarded, so should be canonicalized
+// It also has
#[test]
fn do_loop_complex_immediate_guarded() {
let len = 1;
let dyn_consts = [len];
let module = parse_file("../test_inputs/loop_analysis/do_loop_immediate_guard.hir");
- let result_1 = interp_module!(module, 0,dyn_consts, 3);
+ let result_1 = interp_module!(module, 0, dyn_consts, 3);
println!("result: {:?}", result_1);
let module = run_schedule_on_hercules(module, None).unwrap();
- let result_2 = interp_module!(module, 0,dyn_consts, 3);
+ let result_2 = interp_module!(module, 0, dyn_consts, 3);
assert_eq!(result_1, result_2);
}
@@ -298,12 +297,11 @@ fn loop_canonical_sum() {
let params = vec![1, 2, 3, 4, 5];
let module = parse_file("../test_inputs/loop_analysis/loop_array_sum.hir");
- let result_1 = interp_module!(module, 0,dyn_consts, params);
+ let result_1 = interp_module!(module, 0, dyn_consts, params);
println!("result: {:?}", result_1);
}
-
#[test]
#[ignore]
fn antideps_pipeline() {
@@ -312,13 +310,13 @@ fn antideps_pipeline() {
// FIXME: This path should not leave the crate
let module = parse_module_from_hbin("../../juno_samples/antideps/antideps.hbin");
- let result_1 = interp_module!(module, 0,dyn_consts, 9i32);
+ let result_1 = interp_module!(module, 0, dyn_consts, 9i32);
println!("result: {:?}", result_1);
let module = run_schedule_on_hercules(module, None).unwrap();
- let result_2 = interp_module!(module, 0,dyn_consts, 9i32);
+ let result_2 = interp_module!(module, 0, dyn_consts, 9i32);
assert_eq!(result_1, result_2);
}
@@ -330,8 +328,8 @@ fn implicit_clone_pipeline() {
// FIXME: This path should not leave the crate
let module = parse_module_from_hbin("../../juno_samples/implicit_clone/out.hbin");
- let result_1 = interp_module!(module, 0,dyn_consts, 2u64, 2u64);
-
+ let result_1 = interp_module!(module, 0, dyn_consts, 2u64, 2u64);
+
println!("result: {:?}", result_1);
let schedule = default_schedule![
////Xdot,,
@@ -359,8 +357,8 @@ fn implicit_clone_pipeline() {
GCM,
];
let module = run_schedule_on_hercules(module, Some(schedule)).unwrap();
-
- let result_2 = interp_module!(module, 0,dyn_consts, 2u64, 2u64);
+
+ let result_2 = interp_module!(module, 0, dyn_consts, 2u64, 2u64);
assert_eq!(result_1, result_2);
}
@@ -382,7 +380,9 @@ fn look_at_local() {
}
}
- let module = parse_module_from_hbin("/home/xavierrouth/dev/hercules/hercules_test/hercules_tests/save_me.hbin");
+ let module = parse_module_from_hbin(
+ "/home/xavierrouth/dev/hercules/hercules_test/hercules_tests/save_me.hbin",
+ );
let schedule = Some(default_schedule![
////Xdot,,
@@ -394,15 +394,14 @@ fn look_at_local() {
let schedule = Some(default_schedule![
////Xdot,,
- Unforkify,
- Verify,
+ Unforkify, Verify,
////Xdot,,
]);
-
+
let module = run_schedule_on_hercules(module.clone(), schedule).unwrap();
let result_2 = interp_module!(module, 0, dyn_consts, a.clone(), b.clone());
-
+
println!("golden: {:?}", correct_c);
println!("result: {:?}", result_2);
}
@@ -410,19 +409,21 @@ fn look_at_local() {
#[ignore]
fn matmul_pipeline() {
let len = 1;
-
+
const I: usize = 4;
const J: usize = 4;
const K: usize = 4;
let a: Vec<i32> = (0i32..(I * J) as i32).map(|v| v + 1).collect();
- let b: Vec<i32> = ((I * J) as i32..(J * K) as i32 + (I * J) as i32).map(|v| v + 1).collect();
+ let b: Vec<i32> = ((I * J) as i32..(J * K) as i32 + (I * J) as i32)
+ .map(|v| v + 1)
+ .collect();
let a: Vec<i32> = (0..I * J).map(|_| random::<i32>() % 100).collect();
let b: Vec<i32> = (0..J * K).map(|_| random::<i32>() % 100).collect();
let dyn_consts = [I, J, K];
// FIXME: This path should not leave the crate
let mut module = parse_module_from_hbin("../../juno_samples/matmul/out.hbin");
- //
+ //
let mut correct_c: Box<[i32]> = (0..I * K).map(|_| 0).collect();
for i in 0..I {
for k in 0..K {
@@ -437,27 +438,22 @@ fn matmul_pipeline() {
println!("golden: {:?}", correct_c);
println!("result: {:?}", result_1);
- let InterpreterVal::Array(_, d) = result_1.clone() else {panic!()};
- let InterpreterVal::Integer32(value) = d[0] else {panic!()};
+ let InterpreterVal::Array(_, d) = result_1.clone() else {
+ panic!()
+ };
+ let InterpreterVal::Integer32(value) = d[0] else {
+ panic!()
+ };
assert_eq!(correct_c[0], value);
- let schedule = Some(default_schedule![
- ////Xdot,,
- ForkSplit,
- ////Xdot,,
- ]);
-
+ let schedule = Some(default_schedule![Xdot, ForkSplit, Unforkify, Xdot,]);
+
module = run_schedule_on_hercules(module, schedule).unwrap();
let result_2 = interp_module!(module, 1, dyn_consts, a.clone(), b.clone());
println!("result: {:?}", result_2);
- assert_eq!(result_1, result_2);
-
-
-
-
-
+ assert_eq!(result_1, result_2);
// Verify,
// GVN,
@@ -473,4 +469,4 @@ fn matmul_pipeline() {
// FloatCollections,
// GCM,
// //Xdot,
-}
\ No newline at end of file
+}
diff --git a/hercules_test/hercules_tests/tests/opt_tests.rs b/hercules_test/hercules_tests/tests/opt_tests.rs
index f994f447..2f85b78b 100644
--- a/hercules_test/hercules_tests/tests/opt_tests.rs
+++ b/hercules_test/hercules_tests/tests/opt_tests.rs
@@ -3,9 +3,8 @@ use std::env;
use rand::Rng;
use hercules_interpreter::*;
-use juno_scheduler::*;
use hercules_ir::ID;
-
+use juno_scheduler::*;
// #[test]
// fn matmul_int() {
@@ -79,7 +78,7 @@ use hercules_ir::ID;
// let x: i32 = rand::random();
// let x = x / 32;
// let y: i32 = rand::random();
-// let y = y / 32; // prevent overflow,
+// let y = y / 32; // prevent overflow,
// let result_1 = interp_module!(module, 0, dyn_consts, x, y);
// let mut pm = hercules_opt::pass::PassManager::new(module.clone());
@@ -147,7 +146,6 @@ use hercules_ir::ID;
// let module = pm.get_module();
// let result_2 = interp_module!(module, 0, dyn_consts, vec);
-
// assert_eq!(result_1, result_2)
// }
@@ -192,8 +190,8 @@ use hercules_ir::ID;
// #[test]
// fn sum_int2_smaller() {
-// interp_file_with_passes!("../test_inputs/sum_int2.hir",
-// [100],
+// interp_file_with_passes!("../test_inputs/sum_int2.hir",
+// [100],
// vec![
// Pass::Verify,
// Pass::CCP,
diff --git a/juno_samples/cava/src/main.rs b/juno_samples/cava/src/main.rs
index 73a75a94..8ad6824f 100644
--- a/juno_samples/cava/src/main.rs
+++ b/juno_samples/cava/src/main.rs
@@ -59,7 +59,10 @@ fn run_cava(
tonemap,
)
.await
- }).as_slice::<u8>().to_vec().into_boxed_slice()
+ })
+ .as_slice::<u8>()
+ .to_vec()
+ .into_boxed_slice()
}
enum Error {
diff --git a/juno_samples/matmul/build.rs b/juno_samples/matmul/build.rs
index c3ba785e..511bf483 100644
--- a/juno_samples/matmul/build.rs
+++ b/juno_samples/matmul/build.rs
@@ -4,8 +4,8 @@ fn main() {
JunoCompiler::new()
.file_in_src("matmul.jn")
.unwrap()
- // .schedule_in_src("sched.sch")
- // .unwrap()
+ //.schedule_in_src("sched.sch")
+ //.unwrap()
.build()
.unwrap();
}
diff --git a/juno_samples/matmul/src/main.rs b/juno_samples/matmul/src/main.rs
index 6d3b6624..e40c429d 100644
--- a/juno_samples/matmul/src/main.rs
+++ b/juno_samples/matmul/src/main.rs
@@ -24,10 +24,14 @@ fn main() {
let a = HerculesCPURef::from_slice(&a);
let b = HerculesCPURef::from_slice(&b);
let mut r = runner!(matmul);
- let c = r.run(I as u64, J as u64, K as u64, a.clone(), b.clone()).await;
+ let c = r
+ .run(I as u64, J as u64, K as u64, a.clone(), b.clone())
+ .await;
assert_eq!(c.as_slice::<i32>(), &*correct_c);
let mut r = runner!(tiled_2_matmul);
- let tiled_c = r.run(I as u64, J as u64, K as u64, a.clone(), b.clone()).await;
+ let tiled_c = r
+ .run(I as u64, J as u64, K as u64, a.clone(), b.clone())
+ .await;
assert_eq!(tiled_c.as_slice::<i32>(), &*correct_c);
});
}
@@ -36,4 +40,3 @@ fn main() {
fn matmul_test() {
main();
}
-
diff --git a/juno_scheduler/src/compile.rs b/juno_scheduler/src/compile.rs
index ee2d0bd6..0b3264ac 100644
--- a/juno_scheduler/src/compile.rs
+++ b/juno_scheduler/src/compile.rs
@@ -105,7 +105,9 @@ impl FromStr for Appliable {
"forkify" => Ok(Appliable::Pass(ir::Pass::Forkify)),
"gcm" | "bbs" => Ok(Appliable::Pass(ir::Pass::GCM)),
"gvn" => Ok(Appliable::Pass(ir::Pass::GVN)),
- "loop-canon" | "loop-canonicalization" => Ok(Appliable::Pass(ir::Pass::LoopCanonicalization)),
+ "loop-canon" | "loop-canonicalization" => {
+ Ok(Appliable::Pass(ir::Pass::LoopCanonicalization))
+ }
"infer-schedules" => Ok(Appliable::Pass(ir::Pass::InferSchedules)),
"inline" => Ok(Appliable::Pass(ir::Pass::Inline)),
"ip-sroa" | "interprocedural-sroa" => {
@@ -122,6 +124,7 @@ impl FromStr for Appliable {
"verify" => Ok(Appliable::Pass(ir::Pass::Verify)),
"xdot" => Ok(Appliable::Pass(ir::Pass::Xdot)),
"serialize" => Ok(Appliable::Pass(ir::Pass::Serialize)),
+ "write-predication" => Ok(Appliable::Pass(ir::Pass::WritePredication)),
"cpu" | "llvm" => Ok(Appliable::Device(Device::LLVM)),
"gpu" | "cuda" | "nvidia" => Ok(Appliable::Device(Device::CUDA)),
diff --git a/juno_scheduler/src/default.rs b/juno_scheduler/src/default.rs
index 88d55b33..fd45a371 100644
--- a/juno_scheduler/src/default.rs
+++ b/juno_scheduler/src/default.rs
@@ -66,8 +66,9 @@ pub fn default_schedule() -> ScheduleStmt {
DCE,
GVN,
DCE,
- /*Forkify,*/
- /*ForkGuardElim,*/
+ // Forkify,
+ // ForkGuardElim,
+ // ForkCoalesce,
DCE,
ForkSplit,
Unforkify,
@@ -83,6 +84,5 @@ pub fn default_schedule() -> ScheduleStmt {
DCE,
FloatCollections,
GCM,
-
]
}
diff --git a/juno_scheduler/src/pm.rs b/juno_scheduler/src/pm.rs
index 9c705c1c..33a7b480 100644
--- a/juno_scheduler/src/pm.rs
+++ b/juno_scheduler/src/pm.rs
@@ -512,7 +512,7 @@ impl PassManager {
typing: _,
control_subgraphs: _,
bbs: _,
- collection_objects:_,
+ collection_objects: _,
callgraph: _,
..
} = self;
@@ -1299,17 +1299,17 @@ fn run_pass(
let output_file = "out.hbin";
let module = pm.clone().get_module().clone();
let module_contents: Vec<u8> = postcard::to_allocvec(&module).unwrap();
- let mut file = File::create(&output_file)
- .expect("PANIC: Unable to open output module file.");
+ let mut file =
+ File::create(&output_file).expect("PANIC: Unable to open output module file.");
file.write_all(&module_contents)
.expect("PANIC: Unable to write output module file contents.");
}
Pass::ForkSplit => {
assert!(args.is_empty());
// FIXME: I'm not sure if this is the correct way to build fixpoint into the PM,
- // i.e cloning selection. Does something need to be done to propagate labels between iterations
+ // i.e cloning selection. Does something need to be done to propagate labels between iterations
// of this loop?
-
+
loop {
let mut inner_changed = false;
pm.make_fork_join_maps();
@@ -1332,7 +1332,6 @@ fn run_pass(
pm.clear_analyses();
if !inner_changed {
-
break;
}
}
@@ -1345,11 +1344,12 @@ fn run_pass(
let fork_join_maps = pm.fork_join_maps.take().unwrap();
let loops = pm.loops.take().unwrap();
let control_subgraphs = pm.control_subgraphs.take().unwrap();
- for (((func, fork_join_map), loop_nest), control_subgraph) in build_selection(pm, selection)
- .into_iter()
- .zip(fork_join_maps.iter())
- .zip(loops.iter())
- .zip(control_subgraphs.iter())
+ for (((func, fork_join_map), loop_nest), control_subgraph) in
+ build_selection(pm, selection)
+ .into_iter()
+ .zip(fork_join_maps.iter())
+ .zip(loops.iter())
+ .zip(control_subgraphs.iter())
{
let Some(mut func) = func else {
continue;
@@ -1700,11 +1700,12 @@ fn run_pass(
let fork_join_maps = pm.fork_join_maps.take().unwrap();
let loops = pm.loops.take().unwrap();
let control_subgraphs = pm.control_subgraphs.take().unwrap();
- for (((func, fork_join_map), loop_nest), control_subgraph) in build_selection(pm, selection)
- .into_iter()
- .zip(fork_join_maps.iter())
- .zip(loops.iter())
- .zip(control_subgraphs.iter())
+ for (((func, fork_join_map), loop_nest), control_subgraph) in
+ build_selection(pm, selection)
+ .into_iter()
+ .zip(fork_join_maps.iter())
+ .zip(loops.iter())
+ .zip(control_subgraphs.iter())
{
let Some(mut func) = func else {
continue;
@@ -1714,7 +1715,7 @@ fn run_pass(
}
pm.delete_gravestones();
pm.clear_analyses();
- },
+ }
Pass::WritePredication => {
assert!(args.is_empty());
for func in build_selection(pm, selection) {
@@ -1794,12 +1795,13 @@ fn run_pass(
let loops = pm.loops.take().unwrap();
let control_subgraphs = pm.control_subgraphs.take().unwrap();
let typing = pm.typing.take().unwrap();
- for ((((func, fork_join_map), loop_nest), control_subgraph), typing) in build_selection(pm, selection)
- .into_iter()
- .zip(fork_join_maps.iter())
- .zip(loops.iter())
- .zip(control_subgraphs.iter())
- .zip(typing.iter())
+ for ((((func, fork_join_map), loop_nest), control_subgraph), typing) in
+ build_selection(pm, selection)
+ .into_iter()
+ .zip(fork_join_maps.iter())
+ .zip(loops.iter())
+ .zip(control_subgraphs.iter())
+ .zip(typing.iter())
{
let Some(mut func) = func else {
continue;
--
GitLab
From b2d0899df264c2081a979798311877bd70c81632 Mon Sep 17 00:00:00 2001
From: Xavier Routh <xrouth2@illinois.edu>
Date: Thu, 30 Jan 2025 00:53:03 -0600
Subject: [PATCH 55/68] forkify iv use condition refined
---
hercules_opt/src/fork_transforms.rs | 47 +---
hercules_opt/src/forkify.rs | 136 ++++--------
hercules_opt/src/ivar.rs | 205 +-----------------
.../hercules_interpreter/src/interpreter.rs | 3 -
juno_samples/matmul/src/main.rs | 17 +-
juno_samples/matmul/src/matmul.jn | 38 ++--
juno_samples/matmul/src/sched.sch | 76 +++++++
7 files changed, 167 insertions(+), 355 deletions(-)
create mode 100644 juno_samples/matmul/src/sched.sch
diff --git a/hercules_opt/src/fork_transforms.rs b/hercules_opt/src/fork_transforms.rs
index 14145f57..c0196ca0 100644
--- a/hercules_opt/src/fork_transforms.rs
+++ b/hercules_opt/src/fork_transforms.rs
@@ -97,7 +97,7 @@ pub fn find_reduce_dependencies<'a>(
recurse(function, reduce, fork, &mut depdendent, &mut visited);
// Return node IDs that are dependent
- let a: Vec<_> = depdendent
+ let ret_val: Vec<_> = depdendent
.iter()
.enumerate()
.filter_map(|(idx, dependent)| {
@@ -109,7 +109,7 @@ pub fn find_reduce_dependencies<'a>(
})
.collect();
- a
+ ret_val
}
pub fn copy_subgraph(
@@ -119,7 +119,9 @@ pub fn copy_subgraph(
HashSet<NodeID>,
HashMap<NodeID, NodeID>,
Vec<(NodeID, NodeID)>,
-) // set of all nodes, set of new nodes, outside node. s.t old node-> outside node exists as an edge.
+) // returns all new nodes, a map from old nodes to new nodes, and
+ // a vec of pairs of nodes (old node, outside node) s.t old node -> outside node,
+ // outside means not part of the original subgraph.
{
let mut map: HashMap<NodeID, NodeID> = HashMap::new();
let mut new_nodes: HashSet<NodeID> = HashSet::new();
@@ -314,25 +316,9 @@ pub fn fork_reduce_fission_helper<'a>(
fork: NodeID,
) -> (NodeID, NodeID) {
- // returns Fork, Join pair {
-
let join = fork_join_map[&fork];
- // If there is control in between then j give up.
let mut new_control_pred: NodeID = original_control_pred;
-
- // Get nodes to copy
- // let factors: Box<[DynamicConstantID]> = edit..nodes[fork.idx()].try_fork().unwrap().1.into();
-
- // None of this matters, just assume we have DCE for control flow.
- // Make new fork put it after the existing loop (deal with dependencies later.)
- // Make new join, put it after fork (FIXME: THIS IS WRONG)
- // Make copies of all control + data nodes, including the reduce and join, with equivalent uses / users, mark them as NEW
- // - Need an editor utility to copy a subsection of the graph.
- // 1) Edges going into the subsection stay the same, i.e something new still *uses* something old.
- // 2) Edges leaving the subsection need to be handled by the user, (can't force outgoing new edges into nodes)
- // return a list of outgoing (but unattatached) edges + the old destination to the programmer.
-
// Important edges are: Reduces,
// NOTE:
@@ -341,17 +327,6 @@ pub fn fork_reduce_fission_helper<'a>(
// - we can simply refuse
// - or we can duplicate B
- // OR we can allow reduces to end up in multiple forks, (no restrictions on the reduce->fork mapping function).
- // And complain when user doesn't put them in the same fork correctly.
- // for now, DONT HANDLE IT. LOL.
-
- // NOTE:
- //
-
- // Replace all
- // Replace all uses of (fork, reduce, ) w/ predicate that they are the newly copied nodes.
- // repalce uses
-
let mut new_fork = NodeID::new(0);
let mut new_join = NodeID::new(0);
@@ -422,10 +397,10 @@ pub fn fork_coalesce(
});
let fork_joins: Vec<_> = fork_joins.collect();
- // FIXME: postorder traversal.
+ // FIXME: Add a postorder traversal to optimize this.
- // Fixme: This could give us two forks that aren't actually ancestors / related, but then the helper will just retunr false early.
- //for (inner, outer) in fork_joins.windows(2) {
+ // FIXME: This could give us two forks that aren't actually ancestors / related, but then the helper will just return false early.
+ // something like: `fork_joins.postorder_iter().windows(2)` is ideal here.
for (inner, outer) in fork_joins.iter().cartesian_product(fork_joins.iter()) {
if fork_coalesce_helper(editor, *outer, *inner, fork_join_map) {
return true;
@@ -513,11 +488,11 @@ pub fn fork_coalesce_helper(
return false;
}
+ // Checklist:
// Increment inner TIDs
- // Add outers dimension to front of inner fork.
+ // Add outer fork's dimension to front of inner fork.
// Fuse reductions
// - Initializer becomes outer initializer
- // -
// Replace uses of outer fork w/ inner fork.
// Replace uses of outer join w/ inner join.
// Delete outer fork-join
@@ -532,7 +507,7 @@ pub fn fork_coalesce_helper(
let num_outer_dims = outer_dims.len();
let mut new_factors = outer_dims.to_vec();
- // CHECK ME: Might need to be added the other way.
+ // CHECKME / FIXME: Might need to be added the other way.
new_factors.append(&mut inner_dims.to_vec());
for tid in inner_tids {
diff --git a/hercules_opt/src/forkify.rs b/hercules_opt/src/forkify.rs
index c7acfe6b..abd0aaca 100644
--- a/hercules_opt/src/forkify.rs
+++ b/hercules_opt/src/forkify.rs
@@ -2,6 +2,7 @@ extern crate bitvec;
extern crate hercules_ir;
extern crate nestify;
+use core::panic;
use std::collections::HashMap;
use std::collections::HashSet;
use std::iter::zip;
@@ -26,7 +27,6 @@ use crate::walk_all_users;
use crate::walk_all_users_stop_on;
use crate::walk_all_uses;
use crate::walk_all_uses_stop_on;
-use crate::BasicInductionVariable;
use crate::DenseNodeMap;
use crate::FunctionEditor;
use crate::InductionVariable;
@@ -212,7 +212,7 @@ pub fn forkify_loop(
// we currently have.
let loop_nodes = calculate_loop_nodes(editor, l);
- // // Check reductionable phis, only PHIs depending on the loop are considered,
+ // Check phis to see if they are reductionable, only PHIs depending on the loop are considered,
let candidate_phis: Vec<_> = editor
.get_users(l.header)
.filter(|id| function.nodes[id.idx()].is_phi())
@@ -223,21 +223,9 @@ pub fn forkify_loop(
.into_iter()
.collect();
- // START EDITING
-
- // What we do is:
- // 1) Find a (the?) basic induction variable, create a ThreadID + Fork + Join over it.
- // 2) Turn reductionable PHIs into reduces (including the redcutionable PHI)
- // - a) If the PHI is the IV:
- // Uses of the IV become:
- // 1) Inside the loop: Uses of the ThreadID
- // 2) Outside the loop: Uses of the reduction node.
- // - b) if the PHI is not the IV:
- // Make it a reduce
-
let function = editor.func();
- // TOOD: Handle multiple loop body lasts.
+ // TODO: Handle multiple loop body lasts.
// If there are multiple candidates for loop body last, return false.
if editor
.get_uses(loop_if)
@@ -257,23 +245,41 @@ pub fn forkify_loop(
return false;
}
- // 1) If there is any control between header and loop condition, exit.
- let header_control_users: Vec<_> = editor
- .get_users(l.header)
- .filter(|id| function.nodes[id.idx()].is_control())
- .collect();
+ let phi_latches: Vec<_> = reductionable_phis.iter().map(|phi| {
+ let LoopPHI::Reductionable { phi, data_cycle, continue_latch, is_associative } = phi else {unreachable!()};
+ continue_latch
+ }).collect();
- // Outside uses of IV, then exit;
- if editor
- .get_users(canonical_iv.phi())
- .any(|node| !loop_nodes.contains(&node))
- {
+ let stop_on: HashSet<_> = editor.node_ids().filter(|node| {
+ if editor.node(node).is_phi() {
+ return true;
+ }
+ if editor.node(node).is_reduce() {
+ return true;
+ }
+ if editor.node(node).is_control() {
+ return true;
+ }
+ if phi_latches.contains(&node) {
+ return true;
+ }
+
+ false
+ }).collect();
+
+
+ // Outside loop users of IV, then exit;
+ // Unless the outside user is through the loop latch of a reducing phi,
+ // then we know how to replace this edge, so its fine!
+ let iv_users: Vec<_> = walk_all_users_stop_on(canonical_iv.phi(), editor, stop_on.clone()).collect();
+
+ if iv_users.iter().any(|node| !loop_nodes.contains(&node) && *node != loop_if) {
return false;
}
// Start Transformation:
- // Graft everyhting between header and loop condition
+ // Graft everything between header and loop condition
// Attach join to right before header (after loop_body_last, unless loop body last *is* the header).
// Attach fork to right after loop_continue_projection.
@@ -285,7 +291,7 @@ pub fn forkify_loop(
let bound_dc_id = {
let mut max_id = DynamicConstantID::new(0);
editor.edit(|mut edit| {
- // FIXME: Maybe add dynamic constant should intern?
+ // FIXME: Maybe add_dynamic_constant should intern?
let one_id = edit.add_dynamic_constant(DynamicConstant::Constant(1));
max_id = edit.add_dynamic_constant(DynamicConstant::Max(one_id, bound_dc_id));
Ok(edit)
@@ -293,7 +299,7 @@ pub fn forkify_loop(
max_id
};
- // // FIXME (@xrouth), handle control in loop body.
+ // FIXME: (@xrouth) double check handling of control in loop body.
editor.edit(|mut edit| {
let fork = Node::Fork {
control: loop_pred,
@@ -314,21 +320,6 @@ pub fn forkify_loop(
Ok(edit)
});
- // let function = editor.func();
-
- // let update = *zip(
- // editor.get_uses(l.header),
- // function.nodes[canonical_iv.phi().idx()]
- // .try_phi()
- // .unwrap()
- // .1
- // .iter(),
- // )
- // .filter(|(c, _)| *c == loop_body_last)
- // .next()
- // .unwrap()
- // .1;
-
let function = editor.func();
let (_, factors) = function.nodes[fork_id.idx()].try_fork().unwrap();
let dimension = factors.len() - 1;
@@ -341,15 +332,6 @@ pub fn forkify_loop(
};
let thread_id_id = edit.add_node(thread_id);
- // let iv_reduce = Node::Reduce {
- // control: join_id,
- // init: basic_iv.initializer,
- // reduct: update,
- // };
-
- // If a user occurs after the loop is finished, we replace it with the DC that is the IV bound,
- // If a user occurs inside the loop, we replace it with the IV.
-
// Replace uses that are inside with the thread id
edit = edit.replace_all_uses_where(canonical_iv.phi(), thread_id_id, |node| {
loop_nodes.contains(node)
@@ -372,7 +354,7 @@ pub fn forkify_loop(
is_associative,
} = reduction_phi
else {
- continue;
+ panic!();
};
let function = editor.func();
@@ -451,11 +433,10 @@ impl LoopPHI {
/**
Checks some conditions on loop variables that will need to be converted into reductions to be forkified.
- To convert a phi into a reduce we need to check that every cycle containing the PHI does not contain any other PHI.
-I think this restriction can be loosened (more specified)
- - Every cycle *in the loop* containing the PHI does not contain any other PHI. Or something, IDK.
- -
-We also need to make it not control dependent on anything other than the loop header. */
+ - The phi is in a cycle *in the loop* with itself.
+ - Every cycle *in the loop* containing the phi does not contain any other phi of the loop header.
+ - The phi does not immediatley (not blocked by another phi or another reduce) use any other phis of the loop header.
+ */
pub fn analyze_phis<'a>(
editor: &'a FunctionEditor,
natural_loop: &'a Loop,
@@ -473,9 +454,6 @@ pub fn analyze_phis<'a>(
if *control != natural_loop.header {
return true;
}
- // if !natural_loop.control[control.idx()] {
- // return true;
- // }
}
// External Reduce
if let Node::Reduce {
@@ -491,9 +469,8 @@ pub fn analyze_phis<'a>(
}
}
- // External Control
+ // Data Cycles Only
if data.is_control() {
- //&& !natural_loop.control[node.idx()] {
return true;
}
@@ -503,11 +480,6 @@ pub fn analyze_phis<'a>(
// TODO: We may need to stop on exiting the loop for looking for data cycles.
let uses = walk_all_uses_stop_on(*phi, editor, stop_on.clone());
- // .filter(|node|
- // {
- // // Get rid of nodes in stop_on
- // !stop_on.contains(node)
- // });
let users = walk_all_users_stop_on(*phi, editor, stop_on.clone());
let other_stop_on: HashSet<NodeID> = editor
@@ -531,7 +503,6 @@ pub fn analyze_phis<'a>(
// External Control
if data.is_control() {
- //&& !natural_loop.control[node.idx()] {
return true;
}
@@ -551,11 +522,6 @@ pub fn analyze_phis<'a>(
if uses_for_dependance.any(|node| phis.contains(&node) && node != *phi) {
LoopPHI::LoopDependant(*phi)
}
- // // If this phi is used by other phis in the loop, FIXME: include reduces, they are the same as phis right?
- // // DOn't go through nodes that would become a reduction.
- // else if set2.clone().iter().any(|node| phis.contains(node) && node != phi ) {
- // LoopPHI::UsedByDependant(*phi)
- // }
else if intersection.clone().iter().any(|node| true) {
let continue_idx = editor
.get_uses(natural_loop.header)
@@ -564,16 +530,12 @@ pub fn analyze_phis<'a>(
let loop_continue_latch = editor.node(phi).try_phi().unwrap().1[continue_idx];
- // Phis on the frontier of the intersection, i.e in uses_for_dependance need
- // to have headers
+ // PHIs on the frontier of the uses by the candidate phi, i.e in uses_for_dependance need
+ // to have headers that postdominate the loop continue latch. The value of the PHI used needs to be defined
+ // by the time the reduce is triggered (at the end of the loop's internal control).
- // FIXME: Need to postdominate the loop continue latch
- // The phi's region needs to postdominate all PHI / Reduceses (that are in the control of the loop, i.e that or uses of the loop_continue_latch)
- // that it uses, not going through phis / reduces,
- //
-
- // let uses =
// No nodes in data cycles with this phi (in the loop) are used outside the loop, besides the loop_continue_latch.
+ // If some other node in the cycle is used, there is not a valid node to assign it after making the cycle a reduce.
if intersection
.iter()
.filter(|node| **node != loop_continue_latch)
@@ -590,14 +552,8 @@ pub fn analyze_phis<'a>(
return LoopPHI::LoopDependant(*phi);
}
- // if tehre are separate types of ops, or any non associative ops, then its not associative
-
- // Extract ops
- // let is_associative = intersection.iter().filter_map(|node| match editor.node(node) {
- // Node::Unary { input, op } => todo!(),
- // Node::Binary { left, right, op } => todo!(),
- // Node::Ternary { first, second, third, op } => todo!(),
- // });
+ // FIXME: Do we want to calculate associativity here, there might be a case where this information is used in forkify
+ // i.e as described above.
let is_associative = false;
// No nodes in the data cycle are used outside of the loop, besides the latched value of the phi
diff --git a/hercules_opt/src/ivar.rs b/hercules_opt/src/ivar.rs
index 7f76b0f5..bde3bde3 100644
--- a/hercules_opt/src/ivar.rs
+++ b/hercules_opt/src/ivar.rs
@@ -25,12 +25,7 @@ use self::hercules_ir::ir::*;
use crate::*;
-/**
- * This represents induction vairable analysis, to be used by forkify!
- */
-/* ASIDE: (@xrouth) I want a word for something that can be 'queried', but doesn't reveal anything about the underlying data structure,
-single loop only... */
#[derive(Debug)]
pub struct LoopVarianceInfo {
@@ -60,19 +55,6 @@ impl Loop {
all_loop_nodes
}
}
-nest! {
-/** Represents a basic induction variable.
- NOTE (@xrouth): May switch to using SCEV to represent induction vairables, for now we assume only basic induction variables
- with a constant update (not even linear). Eventually add dynamic constant updates, and linear updates
- */
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub struct BasicInductionVariable {
- pub node: NodeID,
- pub initializer: NodeID,
- pub update: NodeID,
- pub final_value: Option<NodeID>,
-}
-} // nest
nest! {
#[derive(Clone, Copy, Debug, PartialEq)]*
@@ -83,9 +65,7 @@ nest! {
update: NodeID,
final_value: Option<NodeID>,
},
- SCEV(NodeID),
- //ScevAdd(NodeID, NodeID),
- // ScevMul(NodeID, NodeID),
+ SCEV(NodeID), // TODO @(xrouth)
}
}
@@ -101,30 +81,8 @@ impl InductionVariable {
InductionVariable::SCEV(_) => todo!(),
}
}
-
- // Editor has become just a 'context' that everything needs. This is similar to how analyses / passes are structured,
- // but editor forces recomputation / bookkeeping of simple / more commonly used info (even though it really is just def use, constants, dyn_constants)
- // While if the pass writer wants more complicated info, like analyses results, they have to thread it through the pass manager.
- // This seems fine.
- // pub fn update_i64(&self, editor: &FunctionEditor) -> Option<i64> {
- // match self {
- // InductionVariable::Basic { node, initializer, update, final_value } => {
- // match editor.node(update) {
- // Node::Constant {id } => match *editor.get_constant(*id) {
- // Constant::UnsignedInteger64(v) => v.try_into().ok(),
- // _ => None,
- // },
- // _ => None,
- // }
- // },
- // InductionVariable::SCEV(node_id) => todo!(),
- // }
- // }
-
- // It would be nice for functions, as they (kinda) automatically capture 'self' to also automatically capture a 'context' that is in the same scope,
- // so I don't have to keep passing a context into every function that needs one.
- //
}
+
// TODO: Optimize.
pub fn calculate_loop_nodes(editor: &FunctionEditor, natural_loop: &Loop) -> HashSet<NodeID> {
// Stop on PHIs / reduces outside of loop.
@@ -170,11 +128,6 @@ pub fn calculate_loop_nodes(editor: &FunctionEditor, natural_loop: &Loop) -> Has
})
.collect();
- // let all_users: HashSet<_> = editor.get_users(natural_loop.header).filter(|node| editor.func().nodes[node.idx()].is_phi())
- // .flat_map(|phi| walk_all_users_stop_on(phi, editor, stop_on.clone()))
- // .chain(editor.get_users(natural_loop.header).filter(|node| editor.func().nodes[node.idx()].is_phi()))
- // .collect();
-
let all_users: HashSet<NodeID> = phis
.clone()
.iter()
@@ -186,26 +139,17 @@ pub fn calculate_loop_nodes(editor: &FunctionEditor, natural_loop: &Loop) -> Has
.clone()
.iter()
.flat_map(|phi| walk_all_uses_stop_on(*phi, editor, stop_on.clone()))
- .chain(phis)
+ .chain(phis.clone())
.filter(|node| {
// Get rid of nodes in stop_on
!stop_on.contains(node)
})
.collect();
- // let all_uses: HashSet<_> = editor.get_users(natural_loop.header).filter(|node| editor.func().nodes[node.idx()].is_phi())
- // .flat_map(|phi| walk_all_uses_stop_on(phi, editor, stop_on.clone()))
- // .chain(editor.get_users(natural_loop.header).filter(|node| editor.func().nodes[node.idx()].is_phi()))
- // .filter(|node|
- // {
- // // Get rid of nodes in stop_on
- // !stop_on.contains(node)
- // })
- // .collect();
-
- all_users.intersection(&all_uses).cloned().collect()
+
+ all_users.intersection(&all_uses).chain(phis.iter()).cloned().collect()
}
-/** returns PHIs that are *in* a loop */
+/** returns PHIs that are on any regions inside the loop. */
pub fn get_all_loop_phis<'a>(
function: &'a Function,
l: &'a Loop,
@@ -323,7 +267,7 @@ pub enum LoopExit {
if_node: NodeID,
condition_node: NodeID,
},
- Unconditional(NodeID) // Probably a region.
+ Unconditional(NodeID)
}
}
@@ -335,6 +279,7 @@ pub fn get_loop_exit_conditions(
// impl IntoIterator<Item = LoopExit>
// DFS Traversal on loop control subgraph until we find a node that is outside the loop, find the last IF on this path.
let mut last_if_on_path: DenseNodeMap<Option<NodeID>> = vec![None; function.nodes.len()];
+
// FIXME: (@xrouth) THIS IS MOST CERTAINLY BUGGED
// this might be bugged... i.e might need to udpate `last if` even if already defined.
// needs to be `saturating` kinda, more iterative. May need to visit nodes more than once?
@@ -380,140 +325,6 @@ pub fn get_loop_exit_conditions(
})
}
-pub fn match_canonicalization_bound(
- editor: &mut FunctionEditor,
- natural_loop: &Loop,
- loop_condition: NodeID,
- loop_if: NodeID,
- ivar: BasicInductionVariable,
-) -> Option<NodeID> {
- // Match for code generated by loop canon
- let Node::Phi { control, data } = &editor.func().nodes[loop_condition.idx()] else {
- unreachable!()
- };
-
- if *control != natural_loop.header {
- return None;
- }
-
- let continue_idx = editor
- .get_uses(natural_loop.header)
- .position(|node| natural_loop.control[node.idx()])
- .unwrap();
-
- let init_idx = 1 - continue_idx;
-
- // FIXME: Handle multiple loop entries
- if editor.get_uses(natural_loop.header).len() > 2 {
- todo!()
- }
-
- let Node::Constant { id } = &editor.func().nodes[data[init_idx].idx()] else {
- return None;
- };
-
- // Check that the ID is true.
- let Constant::Boolean(val) = *editor.get_constant(*id) else {
- return None;
- };
- if val != true {
- return None;
- };
-
- // Check other phi input.
-
- // FIXME: Factor this out into diff loop analysis.
- let Node::Binary { left, right, op } = &editor.func().nodes[data[continue_idx].idx()].clone()
- else {
- return None;
- };
-
- let BinaryOperator::LT = op else { return None };
-
- let bound = &editor.func().nodes[right.idx()];
- if !(bound.is_constant() || bound.is_dynamic_constant()) {
- return None;
- };
- let bound = match bound {
- Node::Constant { id } => {
- let constant = editor.get_constant(*id).clone();
- let Constant::UnsignedInteger64(v) = constant else {
- return None;
- };
- let mut b = DynamicConstantID::new(0);
- editor.edit(|mut edit| {
- b = edit.add_dynamic_constant(DynamicConstant::Constant(v.try_into().unwrap()));
- Ok(edit)
- });
- // Return the ID of the dynamic constant that is generated from the constant
- // or dynamic constant that is the existing loop bound
- b
- }
- Node::DynamicConstant { id } => *id,
- _ => unreachable!(),
- };
-
- let Node::Binary {
- left: add_left,
- right: add_right,
- op: add_op,
- } = &editor.func().nodes[left.idx()]
- else {
- return None;
- };
-
- let (phi, inc) = if let Node::Phi { control, data } = &editor.func().nodes[add_left.idx()] {
- (add_left, add_right)
- } else if let Node::Phi { control, data } = &editor.func().nodes[add_right.idx()] {
- (add_right, add_left)
- } else {
- return None;
- };
-
- // Check Constant
- let Node::Constant { id } = &editor.func().nodes[inc.idx()] else {
- return None;
- };
-
- if !editor.get_constant(*id).is_one() {
- return None;
- }
-
- // Check PHI
- let Node::Phi {
- control: outer_control,
- data: outer_data,
- } = &editor.func().nodes[phi.idx()]
- else {
- unreachable!()
- };
-
- // FIXME: Multiple loop predecessors.
- if outer_data[continue_idx] != *left {
- return None;
- };
-
- let Node::Constant { id } = &editor.func().nodes[outer_data[init_idx].idx()] else {
- return None;
- };
-
- if !editor.get_constant(*id).is_zero() {
- return None;
- }
-
- // All checks passed, make new DC
- let mut final_node = NodeID::new(0);
-
- editor.edit(|mut edit| {
- let one = edit.add_dynamic_constant(DynamicConstant::Constant(1));
- let max_dc = edit.add_dynamic_constant(DynamicConstant::Max(one, bound));
- final_node = edit.add_node(Node::DynamicConstant { id: max_dc });
- Ok(edit)
- });
-
- Some(final_node)
-}
-
pub fn has_const_fields(editor: &FunctionEditor, ivar: InductionVariable) -> bool {
match ivar {
InductionVariable::Basic {
diff --git a/hercules_test/hercules_interpreter/src/interpreter.rs b/hercules_test/hercules_interpreter/src/interpreter.rs
index 1ef70561..730f6216 100644
--- a/hercules_test/hercules_interpreter/src/interpreter.rs
+++ b/hercules_test/hercules_interpreter/src/interpreter.rs
@@ -668,9 +668,6 @@ impl<'a> FunctionExecutionState<'a> {
.get(InterpreterVal::array_idx(&extents, &array_indices))
.unwrap_or(&InterpreterVal::Undef(type_id))
.clone();
- if let InterpreterVal::Undef(_) = ret {
- panic!("bad read!")
- }
ret
} else {
panic!("PANIC: Position index on not an array")
diff --git a/juno_samples/matmul/src/main.rs b/juno_samples/matmul/src/main.rs
index e40c429d..fa5d1f04 100644
--- a/juno_samples/matmul/src/main.rs
+++ b/juno_samples/matmul/src/main.rs
@@ -8,9 +8,9 @@ juno_build::juno!("matmul");
fn main() {
async_std::task::block_on(async {
- const I: usize = 4;
- const J: usize = 4;
- const K: usize = 4;
+ const I: usize = 256;
+ const J: usize = 64;
+ const K: usize = 128;
let a: Box<[i32]> = (0..I * J).map(|_| random::<i32>() % 100).collect();
let b: Box<[i32]> = (0..J * K).map(|_| random::<i32>() % 100).collect();
let mut correct_c: Box<[i32]> = (0..I * K).map(|_| 0).collect();
@@ -24,14 +24,10 @@ fn main() {
let a = HerculesCPURef::from_slice(&a);
let b = HerculesCPURef::from_slice(&b);
let mut r = runner!(matmul);
- let c = r
- .run(I as u64, J as u64, K as u64, a.clone(), b.clone())
- .await;
+ let c = r.run(I as u64, J as u64, K as u64, a.clone(), b.clone()).await;
assert_eq!(c.as_slice::<i32>(), &*correct_c);
- let mut r = runner!(tiled_2_matmul);
- let tiled_c = r
- .run(I as u64, J as u64, K as u64, a.clone(), b.clone())
- .await;
+ let mut r = runner!(tiled_64_matmul);
+ let tiled_c = r.run(I as u64, J as u64, K as u64, a.clone(), b.clone()).await;
assert_eq!(tiled_c.as_slice::<i32>(), &*correct_c);
});
}
@@ -40,3 +36,4 @@ fn main() {
fn matmul_test() {
main();
}
+
diff --git a/juno_samples/matmul/src/matmul.jn b/juno_samples/matmul/src/matmul.jn
index 92c25710..ca9be73a 100644
--- a/juno_samples/matmul/src/matmul.jn
+++ b/juno_samples/matmul/src/matmul.jn
@@ -15,33 +15,33 @@ fn matmul<n : usize, m : usize, l : usize>(a : i32[n, m], b : i32[m, l]) -> i32[
}
#[entry]
-fn tiled_2_matmul<n : usize, m : usize, l : usize>(a : i32[n, m], b : i32[m, l]) -> i32[n, l] {
+fn tiled_64_matmul<n : usize, m : usize, l : usize>(a : i32[n, m], b : i32[m, l]) -> i32[n, l] {
let res : i32[n, l];
- let atile : i32[2, 2];
- let btile : i32[2, 2];
- let ctile : i32[2, 2];
+ let atile : i32[64, 64];
+ let btile : i32[64, 64];
+ let ctile : i32[64, 64];
- for bi = 0 to n / 2 {
- for bk = 0 to l / 2 {
- for ti = 0 to 2 {
- for tk = 0 to 2 {
+ for bi = 0 to n / 64 {
+ for bk = 0 to l / 64 {
+ for ti = 0 to 64 {
+ for tk = 0 to 64 {
atile[ti, tk] = 0;
btile[ti, tk] = 0;
ctile[ti, tk] = 0;
}
}
- for tile_idx = 0 to m / 2 {
- for ti = 0 to 2 {
- for tk = 0 to 2 {
- atile[ti, tk] = a[bi * 2 + ti, tile_idx * 2 + tk];
- btile[ti, tk] = b[tile_idx * 2 + ti, bk * 2 + tk];
+ for tile_idx = 0 to m / 64 {
+ for ti = 0 to 64 {
+ for tk = 0 to 64 {
+ atile[ti, tk] = a[bi * 64 + ti, tile_idx * 64 + tk];
+ btile[ti, tk] = b[tile_idx * 64 + ti, bk * 64 + tk];
}
}
- for ti = 0 to 2 {
- for tk = 0 to 2 {
+ for ti = 0 to 64 {
+ for tk = 0 to 64 {
let c_acc = ctile[ti, tk];
- for inner_idx = 0 to 2 {
+ for inner_idx = 0 to 64 {
c_acc += atile[ti, inner_idx] * btile[inner_idx, tk];
}
ctile[ti, tk] = c_acc;
@@ -49,9 +49,9 @@ fn tiled_2_matmul<n : usize, m : usize, l : usize>(a : i32[n, m], b : i32[m, l])
}
}
- for ti = 0 to 2 {
- for tk = 0 to 2 {
- res[bi * 2 + ti, bk * 2 + tk] = ctile[ti, tk];
+ for ti = 0 to 64 {
+ for tk = 0 to 64 {
+ res[bi * 64 + ti, bk * 64 + tk] = ctile[ti, tk];
}
}
}
diff --git a/juno_samples/matmul/src/sched.sch b/juno_samples/matmul/src/sched.sch
new file mode 100644
index 00000000..3999f923
--- /dev/null
+++ b/juno_samples/matmul/src/sched.sch
@@ -0,0 +1,76 @@
+macro juno-setup!(X) {
+ gvn(X);
+ dce(X);
+ phi-elim(X);
+}
+
+macro default!(X) {
+ dce(X);
+ crc(X);
+ dce(X);
+ slf(X);
+ dce(X);
+ inline(X);
+ ip-sroa(X);
+ sroa(X);
+ phi-elim(X);
+ dce(X);
+ ccp(X);
+ dce(X);
+ gvn(X);
+ dce(X);
+ write-predication(X);
+ phi-elim(X);
+ dce(X);
+ crc(X);
+ dce(X);
+ slf(X);
+ dce(X);
+ predication(X);
+ dce(X);
+ ccp(X);
+ dce(X);
+ gvn(X);
+ dce(X);
+ lift-dc-math(X);
+ dce(X);
+ gvn(X);
+ dce(X);
+}
+
+macro codegen-prep!(X) {
+ verify(*);
+ ip-sroa(*);
+ sroa(*);
+ infer-schedules(X);
+ dce(X);
+ gcm(X);
+ dce(X);
+ phi-elim(X);
+ float-collections(X);
+ gcm(X);
+}
+
+juno-setup!(*);
+default!(*);
+// your stuff here.
+
+fixpoint stop after 13 {
+ forkify(*);
+ fork-guard-elim(*);
+ fork-coalesce(*);
+ phi-elim(*);
+ dce(*);
+}
+
+xdot[true](*);
+// serialize(*);
+
+fork-split(*);
+unforkify(*);
+
+gvn(*);
+dce(*);
+
+auto-outline(*);
+codegen-prep!(*);
--
GitLab
From 8aabec77960f670699491ed1214bdb44b0c9ccf7 Mon Sep 17 00:00:00 2001
From: Xavier Routh <xrouth2@illinois.edu>
Date: Thu, 30 Jan 2025 09:34:14 -0600
Subject: [PATCH 56/68] better phi reduce condition
---
hercules_opt/src/forkify.rs | 23 ++++++++++++++---------
1 file changed, 14 insertions(+), 9 deletions(-)
diff --git a/hercules_opt/src/forkify.rs b/hercules_opt/src/forkify.rs
index abd0aaca..f3ce186e 100644
--- a/hercules_opt/src/forkify.rs
+++ b/hercules_opt/src/forkify.rs
@@ -477,10 +477,17 @@ pub fn analyze_phis<'a>(
return false;
})
.collect();
+
+ let continue_idx = editor
+ .get_uses(natural_loop.header)
+ .position(|node| natural_loop.control[node.idx()])
+ .unwrap();
+
+ let loop_continue_latch = editor.node(phi).try_phi().unwrap().1[continue_idx];
// TODO: We may need to stop on exiting the loop for looking for data cycles.
- let uses = walk_all_uses_stop_on(*phi, editor, stop_on.clone());
- let users = walk_all_users_stop_on(*phi, editor, stop_on.clone());
+ let uses = walk_all_uses_stop_on(loop_continue_latch, editor, stop_on.clone());
+ let users = walk_all_users_stop_on(loop_continue_latch, editor, stop_on.clone());
let other_stop_on: HashSet<NodeID> = editor
.node_ids()
@@ -509,8 +516,10 @@ pub fn analyze_phis<'a>(
return false;
})
.collect();
+
+
- let mut uses_for_dependance = walk_all_users_stop_on(*phi, editor, other_stop_on);
+ let mut uses_for_dependance = walk_all_users_stop_on(loop_continue_latch, editor, other_stop_on);
let set1: HashSet<_> = HashSet::from_iter(uses);
let set2: HashSet<_> = HashSet::from_iter(users);
@@ -523,12 +532,7 @@ pub fn analyze_phis<'a>(
LoopPHI::LoopDependant(*phi)
}
else if intersection.clone().iter().any(|node| true) {
- let continue_idx = editor
- .get_uses(natural_loop.header)
- .position(|node| natural_loop.control[node.idx()])
- .unwrap();
- let loop_continue_latch = editor.node(phi).try_phi().unwrap().1[continue_idx];
// PHIs on the frontier of the uses by the candidate phi, i.e in uses_for_dependance need
// to have headers that postdominate the loop continue latch. The value of the PHI used needs to be defined
@@ -538,7 +542,8 @@ pub fn analyze_phis<'a>(
// If some other node in the cycle is used, there is not a valid node to assign it after making the cycle a reduce.
if intersection
.iter()
- .filter(|node| **node != loop_continue_latch)
+ .filter(|node| **node != loop_continue_latch )
+ .filter(|node| !(editor.node(*node).is_reduce() || editor.node(*node).is_phi()))
.any(|data_node| {
editor
.get_users(*data_node)
--
GitLab
From 1a4c197e9d93d705c156f65b8d7639b10679ec5b Mon Sep 17 00:00:00 2001
From: Russel Arbore <russel.jma@gmail.com>
Date: Thu, 30 Jan 2025 09:56:16 -0600
Subject: [PATCH 57/68] remove extern crates
---
hercules_opt/src/editor.rs | 11 +++-------
hercules_opt/src/fork_transforms.rs | 18 +++++++---------
hercules_opt/src/forkify.rs | 14 +++++-------
hercules_opt/src/ivar.rs | 25 ++++++++--------------
hercules_opt/src/loop_canonicalization.rs | 26 ++++++++++-------------
hercules_opt/src/utils.rs | 2 --
juno_samples/cava/build.rs | 1 -
juno_scheduler/src/compile.rs | 3 +--
juno_scheduler/src/ir.rs | 4 +---
juno_utils/src/stringtab.rs | 4 +---
10 files changed, 39 insertions(+), 69 deletions(-)
diff --git a/hercules_opt/src/editor.rs b/hercules_opt/src/editor.rs
index 2444fdb4..f6a00c85 100644
--- a/hercules_opt/src/editor.rs
+++ b/hercules_opt/src/editor.rs
@@ -1,18 +1,13 @@
-extern crate bitvec;
-extern crate either;
-extern crate hercules_ir;
-extern crate itertools;
-extern crate nestify;
use std::borrow::Borrow;
use std::cell::{Ref, RefCell};
use std::collections::{BTreeMap, HashMap, HashSet};
use std::mem::take;
use std::ops::Deref;
-use self::nestify::nest;
+use nestify::nest;
-use self::bitvec::prelude::*;
-use self::either::Either;
+use bitvec::prelude::*;
+use either::Either;
use hercules_ir::def_use::*;
use hercules_ir::ir::*;
diff --git a/hercules_opt/src/fork_transforms.rs b/hercules_opt/src/fork_transforms.rs
index c0196ca0..edf26911 100644
--- a/hercules_opt/src/fork_transforms.rs
+++ b/hercules_opt/src/fork_transforms.rs
@@ -1,25 +1,23 @@
use std::collections::{HashMap, HashSet};
use std::ops::Sub;
-extern crate bimap;
-extern crate hercules_ir;
use itertools::Itertools;
-use self::bimap::BiMap;
+use bimap::BiMap;
-use self::hercules_ir::LoopTree;
+use hercules_ir::LoopTree;
-use self::hercules_ir::{Index, TypeID};
+use hercules_ir::{Index, TypeID};
-use self::hercules_ir::Subgraph;
+use hercules_ir::Subgraph;
-use self::hercules_ir::DynamicConstantID;
+use hercules_ir::DynamicConstantID;
-use self::hercules_ir::Node;
+use hercules_ir::Node;
-use self::hercules_ir::{get_uses, Function};
+use hercules_ir::{get_uses, Function};
-use self::hercules_ir::{NodeID, ID};
+use hercules_ir::{NodeID, ID};
use crate::{DenseNodeMap, FunctionEditor, Loop, SparseNodeMap};
diff --git a/hercules_opt/src/forkify.rs b/hercules_opt/src/forkify.rs
index f3ce186e..10a8fe21 100644
--- a/hercules_opt/src/forkify.rs
+++ b/hercules_opt/src/forkify.rs
@@ -1,21 +1,17 @@
-extern crate bitvec;
-extern crate hercules_ir;
-extern crate nestify;
-
use core::panic;
use std::collections::HashMap;
use std::collections::HashSet;
use std::iter::zip;
use std::iter::FromIterator;
-use self::nestify::nest;
+use nestify::nest;
-use self::bitvec::order::Lsb0;
-use self::bitvec::vec::BitVec;
+use bitvec::order::Lsb0;
+use bitvec::vec::BitVec;
-use self::hercules_ir::Subgraph;
+use hercules_ir::Subgraph;
-use self::hercules_ir::control_subgraph;
+use hercules_ir::control_subgraph;
use crate::calculate_loop_nodes;
use crate::compute_induction_vars;
diff --git a/hercules_opt/src/ivar.rs b/hercules_opt/src/ivar.rs
index bde3bde3..1f31e220 100644
--- a/hercules_opt/src/ivar.rs
+++ b/hercules_opt/src/ivar.rs
@@ -1,32 +1,25 @@
-extern crate bitvec;
-extern crate hercules_ir;
-extern crate nestify;
-extern crate slotmap;
-
use std::collections::{BTreeMap, HashMap, HashSet, VecDeque};
use std::path::Iter;
-use self::nestify::nest;
+use nestify::nest;
-use self::hercules_ir::Subgraph;
+use hercules_ir::Subgraph;
-use self::bitvec::order::Lsb0;
-use self::bitvec::prelude::*;
-use self::bitvec::vec::BitVec;
-use self::hercules_ir::get_uses;
+use bitvec::order::Lsb0;
+use bitvec::prelude::*;
+use bitvec::vec::BitVec;
+use hercules_ir::get_uses;
-use self::hercules_ir::LoopTree;
+use hercules_ir::LoopTree;
use crate::walk_all_uses_stop_on;
-use self::slotmap::{new_key_type, SlotMap};
+use slotmap::{new_key_type, SlotMap};
-use self::hercules_ir::ir::*;
+use hercules_ir::ir::*;
use crate::*;
-
-
#[derive(Debug)]
pub struct LoopVarianceInfo {
pub loop_header: NodeID,
diff --git a/hercules_opt/src/loop_canonicalization.rs b/hercules_opt/src/loop_canonicalization.rs
index 64727e70..12d8fd3b 100644
--- a/hercules_opt/src/loop_canonicalization.rs
+++ b/hercules_opt/src/loop_canonicalization.rs
@@ -1,7 +1,3 @@
-extern crate hercules_ir;
-extern crate itertools;
-extern crate nestify;
-
use std::collections::HashMap;
use std::collections::HashSet;
use std::iter::FromIterator;
@@ -9,22 +5,22 @@ use std::iter::FromIterator;
use hercules_ir::Constant;
use hercules_ir::TypeID;
-use self::nestify::nest;
+use nestify::nest;
-use self::hercules_ir::get_uses;
+use hercules_ir::get_uses;
-use self::itertools::Itertools;
+use itertools::Itertools;
-use self::hercules_ir::BinaryOperator;
+use hercules_ir::BinaryOperator;
-use self::hercules_ir::Function;
-use self::hercules_ir::Node;
+use hercules_ir::Function;
+use hercules_ir::Node;
-use self::hercules_ir::ID;
+use hercules_ir::ID;
-use self::hercules_ir::NodeID;
+use hercules_ir::NodeID;
-use self::hercules_ir::Subgraph;
+use hercules_ir::Subgraph;
use crate::calculate_loop_nodes;
use crate::compute_loop_variance;
@@ -36,7 +32,7 @@ use crate::LoopExit;
use crate::LoopVariance;
use crate::LoopVarianceInfo;
-use self::hercules_ir::LoopTree;
+use hercules_ir::LoopTree;
/** On return `true` means the function has been modified, and loop_canonicalization can be ran again
(with newly analysis info), to canonicalze more loops. */
@@ -900,4 +896,4 @@ pub fn canonicalize_loop_old(
// changed
false
-}
\ No newline at end of file
+}
diff --git a/hercules_opt/src/utils.rs b/hercules_opt/src/utils.rs
index 67225bff..cc7abc7f 100644
--- a/hercules_opt/src/utils.rs
+++ b/hercules_opt/src/utils.rs
@@ -1,5 +1,3 @@
-extern crate nestify;
-
use std::collections::HashMap;
use std::collections::HashSet;
use std::iter::zip;
diff --git a/juno_samples/cava/build.rs b/juno_samples/cava/build.rs
index 929d3eba..7f60f801 100644
--- a/juno_samples/cava/build.rs
+++ b/juno_samples/cava/build.rs
@@ -1,4 +1,3 @@
-extern crate juno_build;
use juno_build::JunoCompiler;
fn main() {
diff --git a/juno_scheduler/src/compile.rs b/juno_scheduler/src/compile.rs
index 0b3264ac..14dd828b 100644
--- a/juno_scheduler/src/compile.rs
+++ b/juno_scheduler/src/compile.rs
@@ -4,8 +4,7 @@ use crate::parser;
use juno_utils::env::Env;
use juno_utils::stringtab::StringTable;
-extern crate hercules_ir;
-use self::hercules_ir::ir::{Device, Schedule};
+use hercules_ir::ir::{Device, Schedule};
use lrlex::DefaultLexerTypes;
use lrpar::NonStreamingLexer;
diff --git a/juno_scheduler/src/ir.rs b/juno_scheduler/src/ir.rs
index f16279e7..aa9b2367 100644
--- a/juno_scheduler/src/ir.rs
+++ b/juno_scheduler/src/ir.rs
@@ -1,6 +1,4 @@
-extern crate hercules_ir;
-
-use self::hercules_ir::ir::{Device, Schedule};
+use hercules_ir::ir::{Device, Schedule};
#[derive(Debug, Copy, Clone)]
pub enum Pass {
diff --git a/juno_utils/src/stringtab.rs b/juno_utils/src/stringtab.rs
index e151b830..45ee0864 100644
--- a/juno_utils/src/stringtab.rs
+++ b/juno_utils/src/stringtab.rs
@@ -1,6 +1,4 @@
-extern crate serde;
-
-use self::serde::{Deserialize, Serialize};
+use serde::{Deserialize, Serialize};
use std::collections::HashMap;
--
GitLab
From 23990a61e958d2b5a36728140eda4daefe8cfa4e Mon Sep 17 00:00:00 2001
From: Xavier Routh <xrouth2@illinois.edu>
Date: Thu, 30 Jan 2025 10:00:13 -0600
Subject: [PATCH 58/68] remove loop canon
---
hercules_opt/src/loop_canonicalization.rs | 903 ----------------------
1 file changed, 903 deletions(-)
delete mode 100644 hercules_opt/src/loop_canonicalization.rs
diff --git a/hercules_opt/src/loop_canonicalization.rs b/hercules_opt/src/loop_canonicalization.rs
deleted file mode 100644
index 64727e70..00000000
--- a/hercules_opt/src/loop_canonicalization.rs
+++ /dev/null
@@ -1,903 +0,0 @@
-extern crate hercules_ir;
-extern crate itertools;
-extern crate nestify;
-
-use std::collections::HashMap;
-use std::collections::HashSet;
-use std::iter::FromIterator;
-
-use hercules_ir::Constant;
-use hercules_ir::TypeID;
-
-use self::nestify::nest;
-
-use self::hercules_ir::get_uses;
-
-use self::itertools::Itertools;
-
-use self::hercules_ir::BinaryOperator;
-
-use self::hercules_ir::Function;
-use self::hercules_ir::Node;
-
-use self::hercules_ir::ID;
-
-use self::hercules_ir::NodeID;
-
-use self::hercules_ir::Subgraph;
-
-use crate::calculate_loop_nodes;
-use crate::compute_loop_variance;
-use crate::get_loop_exit_conditions;
-use crate::BasicInductionVariable;
-use crate::FunctionEditor;
-use crate::Loop;
-use crate::LoopExit;
-use crate::LoopVariance;
-use crate::LoopVarianceInfo;
-
-use self::hercules_ir::LoopTree;
-
-/** On return `true` means the function has been modified, and loop_canonicalization can be ran again
- (with newly analysis info), to canonicalze more loops. */
-pub fn loop_canonicalization(
- editor: &mut FunctionEditor,
- control_subgraph: &Subgraph,
- fork_join_map: &HashMap<NodeID, NodeID>,
- loops: &LoopTree,
- typing: &Vec<TypeID>,
-) -> bool {
-
- let natural_loops = loops
- .bottom_up_loops()
- .into_iter()
- .filter(|(k, _)| editor.func().nodes[k.idx()].is_region());
-
- let natural_loops: Vec<_> = natural_loops.collect();
-
- let mut loop_exits = HashMap::new();
-
- // FIXME: Add return type enum of: {transformed, already in transformed form (not modified), unable to transform}.
- for l in &natural_loops {
- let Some(loop_exit) = get_loop_exit_conditions(
- editor.func(),
- &Loop {
- header: l.0,
- control: l.1.clone(),
- },
- control_subgraph,
- ) else {
- continue;
- };
- loop_exits.insert(l.0, loop_exit);
- }
-
- for l in natural_loops {
- let natural_loop = &Loop {
- header: l.0,
- control: l.1.clone(),
- };
- if canonicalize_loop(
- editor,
- loop_exits.get(&l.0).copied(),
- fork_join_map,
- natural_loop,
- typing,
- ) {
- let nodes = &editor.func().nodes;
- let mut xuser = NodeID::new(0);
- let mut xother_user = NodeID::new(0);
- for id in editor.node_ids() {
- if nodes[id.idx()].is_region() {
- for user in editor.get_users(id) {
- if let Node::Phi {
- control: _,
- ref data,
- } = nodes[user.idx()]
- && data.into_iter().any(|id| nodes[id.idx()].is_undef())
- {
- for other_user in editor.get_users(id) {
- if let Node::Phi {
- control: _,
- data: ref other_data,
- } = nodes[other_user.idx()]
- && data.into_iter().zip(other_data.into_iter()).all(
- |(datum, other_datum)| {
- datum == other_datum || nodes[datum.idx()].is_undef()
- },
- )
- && user != other_user
- {
- xuser = user;
- xother_user = other_user;
- }
- }
- }
- }
- }
- }
- if xuser.idx() != 0 && xother_user.idx() != 0 {
- editor.edit(|mut edit| {
- edit = edit.replace_all_uses(xuser, xother_user)?;
- edit.delete_node(xuser)
- });
- }
-
- return true;
- }
- }
-
- if merge_phis(editor) {
- return true;
- }
-
- return false;
-}
-
-
-
-/**
- * Replaces undef's in PHIs to use already existing PHIs.
- */
-pub fn merge_phis(editor: &mut FunctionEditor) -> bool {
-
- let mut changed = false;
- let mut worklist: Vec<NodeID> = editor.node_ids().filter(|node| editor.func().nodes[node.idx()].is_phi()).collect();
-
-
- while let Some(phi) = worklist.pop() {
- let Node::Phi { control: phi_region, data: phi_data } = &editor.func().nodes[phi.idx()] else {unreachable!()};
-
- // undef_idx
- // FIXME: Enumerate + Partition
- let undefs: Vec<_> = phi_data.iter().positions(|usee| editor.func().nodes[usee.idx()].is_undef()).collect();
- let non_undefs: Vec<_> = phi_data.iter().positions(|usee| !editor.func().nodes[usee.idx()].is_undef()).collect();
-
- if undefs.is_empty() {
- continue;
- }
-
- if non_undefs.is_empty() {
- continue;
- }
-
- // Try to merge with other phis of the same region
- let candidate = editor.get_users(*phi_region).filter(|node| editor.func().nodes[node.idx()].is_phi());
-
- let mut merge_candidates = candidate.filter(|node| {
- if phi == *node {
- return false;
- }
-
- if let Node::Phi { control: candidate_region, data: candidate_data } = &editor.func().nodes[node.idx()] {
-
- // Regions have to match
- if candidate_region != phi_region {
- return false;
- }
-
- // FIXME: Sort by candidate that can replace the most undefs.
- // All undefs need to have data.
- if undefs.iter().any(|idx| editor.func().nodes[candidate_data[*idx].idx()].is_undef()) {
- return false;
- }
-
- // All non_undefs need to be the same.
- if non_undefs.iter().any(|idx| candidate_data[*idx] != phi_data[*idx]) {
- return false;
- }
- true
- } else {
- false
- }
- });
-
-
- let Some(data) = merge_candidates.next() else {continue};
- drop(merge_candidates);
-
- editor.edit(|mut edit|{
- let edit = edit.replace_all_uses(phi, data)?;
- edit.delete_node(phi)
- });
- changed = true;
-
- }
- changed
-}
-
-/**
-
- */
-pub fn canonicalize_loop(
- editor: &mut FunctionEditor,
- loop_exit: Option<LoopExit>,
- fork_join_map: &HashMap<NodeID, NodeID>,
- natural_loop: &Loop,
- typing: &Vec<TypeID>
-) -> bool {
-
- let Some(loop_condition) = loop_exit else {return false};
- let LoopExit::Conditional { if_node: loop_if, condition_node } = loop_condition.clone() else {return false};
-
- // let Some((iv_expression, base_iv)) = has_alternate_bounds(editor.func(),
- // natural_loop, condition_node, &basic_ivs, loop_variance)
- // else {return false};
-
- // Find nodes that are `in the loop`
- // - used by a phi (or the loop region)
- // - uses a phi (the loop region)
- // All other nodes are 'out of the loop'
- // All edges from the loop to out of the loop need to have a phi added,
- // controlled by the loop header. The loop entry edge is undef, the loop continued data node is
- // the edge it is being inserted in.
- //
- // Inner control needs to be moved, with PHIs being inserted as appropriate for now undef'd variables.
-
- let loop_nodes = calculate_loop_nodes(editor, natural_loop);
-
- let header_initial_idx = editor.get_uses(natural_loop.header)
- .position(|node| !natural_loop.control[node.idx()] // Position of the predecessor (used by header but not in loop body.)
- ).unwrap();
-
- let header_continue_idx = editor.get_uses(natural_loop.header)
- .position(|node| natural_loop.control[node.idx()]
- ).unwrap();
-
-
- // Check loop variables that are used by smthn outside the loop.
- let binding = loop_nodes.clone();
- let phis_to_add: Vec<NodeID> = binding.iter()
- .filter(
- |loop_node| !editor.func().nodes[loop_node.idx()].is_control()
- )
- .filter(
- |loop_node|
- {
- editor.get_users(**loop_node).any(|user|!loop_nodes.contains(&user))
- }
- ).cloned().collect();
-
- // If all loop variables are contained w/ PHIs already, no point in canonicalizing.
- if phis_to_add.iter().all(
- |node| {
- let Node::Phi { ref control, ref data } = editor.func().nodes[node.idx()] else {return false};
- if *control == natural_loop.header {
- true
- } else {
- false
- }
- }
- ) {
- return false;
-
- }
-
- if phis_to_add.is_empty() {
- return false;
- }
-
- let loop_before_if_first = editor.get_users(natural_loop.header)
- .filter(|id| natural_loop.control[id.idx()])
- .next()
- .unwrap();
-
- let loop_before_if_last = editor.get_uses(loop_if).next().unwrap();
-
- let loop_exit_projection = editor.get_users(loop_if)
- .filter(|id| !natural_loop.control[id.idx()])
- .next()
- .unwrap();
-
- let loop_continue_projection = editor.get_users(loop_if)
- .filter(|id| natural_loop.control[id.idx()])
- .next()
- .unwrap();
-
- // Control goes after the loop_continue_projection, and before whatever is after loop_continue_projection.
- let loop_body_last = editor.get_uses(natural_loop.header)
- .filter(|id| natural_loop.control[id.idx()])
- .next()
- .unwrap();
-
- // ========= Do transformation ===========:
-
- let num_loop_predecessors = editor.get_uses(natural_loop.header).count();
-
- // Add PHIs
- for data_in_loop in phis_to_add {
- editor.edit(|mut edit| {
- let ty = typing[data_in_loop.idx()];
- let undef = Node::Undef { ty };
- let undef = edit.add_node(undef);
- let mut data = vec![undef; num_loop_predecessors];
- data[header_continue_idx] = data_in_loop;
- let new_phi = Node::Phi { control: natural_loop.header, data: data.into()};
- let new_phi = edit.add_node(new_phi);
- edit.replace_all_uses_where(data_in_loop, new_phi, |usee| !loop_nodes.contains(usee) && *usee != new_phi)
- });
- }
-
- // Add PHI for loop condition
- editor.edit(|mut edit| {
- let bool_ty = typing[condition_node.idx()];
- let true_const = Constant::Boolean(true);
- let true_const = edit.add_constant(true_const);
- let true_const = Node::Constant { id: true_const };
- let true_const = edit.add_node(true_const);
-
- let mut data = vec![true_const; num_loop_predecessors];
- data[header_continue_idx] = condition_node;
- let new_phi = Node::Phi { control: natural_loop.header, data: data.into()};
- let new_phi = edit.add_node(new_phi);
- edit.replace_all_uses_where(condition_node, new_phi, |usee| *usee == loop_if)
- });
-
- // Convert to while loop if not a while loop already.
- if !editor.get_users(natural_loop.header).contains(&loop_if) {
- editor.edit(|mut edit| {
- // Have fun understanding this!
- edit = edit.replace_all_uses(loop_continue_projection, loop_before_if_last)?;
- edit = edit.replace_all_uses_where(natural_loop.header, loop_continue_projection, |usee| *usee == loop_before_if_first)?;
- edit = edit.replace_all_uses_where(loop_before_if_last, natural_loop.header, |usee| *usee == loop_if)?;
-
- Ok(edit)
- });
-
- // for phi_to_add in while_loop_conversion {
- // editor.edit(|mut edit| {
- // let PhiToAdd { joining_phi, internal_phi, initializer } = phi_to_add;
- // let mut data = Box::new([NodeID::new(0); 2]);
- // data[header_initial_idx] = initializer;
- // data[header_continue_idx] = internal_phi;
- // let node = Node::Phi { control: natural_loop.header, data };
- // let new_phi = edit.add_node(node);
- // edit.replace_all_uses_where(internal_phi, new_phi, |usee| *usee == joining_phi)
- // });
- // println!("adding phi");
- // }
-
- }
-
- // Change loop bounds
- // editor.edit(|edit|
- // edit.replace_all_uses_where(iv_expression, base_iv.node, |usee| *usee == condition_node)
- // );
-
- true
-
-
-}
-
-pub struct LoopGuard {
- guard_if: NodeID,
- loop_entered: NodeID,
- loop_avoided: NodeID,
-}
-
-// Returns the
-pub fn get_guard(
- editor: &mut FunctionEditor,
- natural_loop: &Loop,
- if_node: NodeID,
-) -> Option<LoopGuard> {
- // Given loop condition (iv_phi ? bound_expr)
-
- // Q: What if iv_phi isn't a PHI, but instead a more complex expression.
- // A: Idk!
-
- // Q: What if idx_phi.init changes from when the loop is entered vs where the guard is?
- // A: Guards have to be immediate, later we can look through control dominators blah blah.
-
- // Search for a condition (idx_phi.init ? bound_expr) immediately before the loop is entered
- // (header predecessor)
- let Node::If { control: pred, cond: loop_condition } =
- editor.func().nodes[if_node.idx()] else {return None};
-
- // Rely on GVN that the initializers will be the same exact node.
- let mut header_preds = editor.get_uses(natural_loop.header)
- .filter(|pred| !natural_loop.control[pred.idx()]);
-
- let Some(loop_pred) = header_preds.next() else {return None};
- if header_preds.next().is_some() {return None}; // If there is more than one header predecessor.
-
- let Node::Projection { control: guard_if_node, ref selection } =
- editor.func().nodes[loop_pred.idx()] else {return None};
-
- let Node::If { control: guard_if_pred, cond: guard_cond } =
- editor.func().nodes[guard_if_node.idx()] else {return None};
-
- let loop_entered_proj = loop_pred;
-
- // The if user that isn't the entered proj:
- let Some(loop_avoided_proj) = editor.get_users(guard_if_node).filter(|n| *n != loop_entered_proj).next() else {return None};
-
- let Node::Binary { left: guard_cond_left, right: guard_cond_right, op: guard_cond_op } =
- editor.func().nodes[guard_cond.idx()] else {return None};
-
- // Check that the side of the exit condition is the same, or the initializer is the same.
- let Node::Binary {left: latch_left, right: latch_right, op: latch_op } =
- editor.func().nodes[loop_condition.idx()] else {return None};
-
- // Check for Specific Pattern for do-while loops that have weird ivar + 1 < dc bound.
- // This is the worst code I have ever written in my life.
- let blah = {
- if let Node::Binary { left: latch_add_left, right: latch_add_right, op: add_op } = &editor.func().nodes[latch_left.idx()] {
-
- // FIXME: Better utilities for comparing equiv of expressions. Blah.
- let left_is_one = if let Node::Constant { id } = &editor.func().nodes[latch_add_left.idx()] {
- editor.get_constant(*id).is_one()
- } else {
- false
- };
-
- let right_is_one = if let Node::Constant { id } = &editor.func().nodes[latch_add_right.idx()] {
- editor.get_constant(*id).is_one()
- } else {
- false
- };
-
- if !(right_is_one || left_is_one) {
- false
- } else if !(*add_op == BinaryOperator::Add) {
- false
- } else {
- let n = if (right_is_one) {
- &editor.func().nodes[latch_add_left.idx()]
- } else {
- &editor.func().nodes[latch_add_right.idx()]
- };
-
- if let Node::Phi {control: phi_control, data} = n {
- if *phi_control == natural_loop.header {
- let Node::Region { preds } = &editor.func().nodes[natural_loop.header.idx()] else {panic!()};
- let init_idx = preds.iter().position(|node| *node == loop_pred ).unwrap();
- let init_value = data[init_idx];
-
- // Now, we have all the pieces, compare to the guard condition.
- if latch_op == guard_cond_op && guard_cond_left == init_value && guard_cond_right == latch_right {
- return Some(LoopGuard { guard_if: guard_if_node, loop_entered: loop_entered_proj, loop_avoided: loop_avoided_proj });
- } else {
- return None;
- }
- } else {
- false
- }
- } else {
- false
- }
- }
-
- } else {
- false
- }
- };
-
- if blah {
- return Some(LoopGuard { guard_if: guard_if_node, loop_entered: loop_entered_proj, loop_avoided: loop_avoided_proj });
- }
-
-
- // Replace phis in the loop latch w/ their initializers.
-
- // General Case:
- let latch_left = if let Node::Phi { control: left_control, data } = &editor.func().nodes[latch_left.idx()] {
- if *left_control == natural_loop.header {
- let Node::Region { preds } = &editor.func().nodes[natural_loop.header.idx()] else {panic!()};
- let init_idx = preds.iter().position(|node| *node == loop_pred ).unwrap();
-
- data[init_idx]
- } else {
- latch_left
- }
- } else {
- latch_left
- };
-
- let latch_right = if let Node::Phi { control: right_control, data } = &editor.func().nodes[latch_right.idx()] {
- if *right_control == natural_loop.header {
- let Node::Region { preds } = &editor.func().nodes[natural_loop.header.idx()] else {panic!()};
- let init_idx = preds.iter().position(|node| *node == loop_pred ).unwrap();
-
- data[init_idx]
- } else {
- latch_right
- }
- } else {
- latch_right
- };
-
- // FIXME: More comprehensive condition equivalance.
- // Check condition equivalence:
- if latch_op == guard_cond_op && guard_cond_left == latch_left && guard_cond_right == latch_right {
- return Some(LoopGuard { guard_if: guard_if_node, loop_entered: loop_entered_proj, loop_avoided: loop_avoided_proj });
- } else {
- return None;
- }
-}
-
-/** Attempts to converts a simple natural loop to a while loop
- by moving all control between the loop header and the loop condition to after the loop true condition,
- but before the header.
- * */
-pub fn convert_to_while_loop(
- editor: &mut FunctionEditor,
- natural_loop: &Loop,
- loop_exit: Option<LoopExit>,
- add_guard_flag: bool,
-) -> bool {
-
- // FIXME: Check that Loop is simple.
- let Some(LoopExit::Conditional { if_node, condition_node: _ }) = loop_exit.clone() else {return false};
-
- // FIXME: Check whether the loop is guaranteed to be entered.
- // i.e add a guard if needed.
- let guard = match get_guard(editor, natural_loop, if_node) {
- Some(v) => v,
- None => return false,
- };
-
- // Find the joining region for the guard and the loop exit.
- // FIXME: For now, just assume its always the node following the guard loop_avoided projection. This is probably always the case.
- let LoopGuard { guard_if, loop_entered, loop_avoided } = guard;
- let Some(joining_region) = editor.get_users(loop_avoided).next() else {return false;};
-
- // For PHIs in the loop (but not of the loop header), that this joining region controls, need
- // to add a version to the loop header, initialized to the same thing as the loop non-taken, and
- // updated when the loop is taken to be the internal version.
- let loop_exit_proj = editor.get_users(if_node).filter(|node| !natural_loop.control[node.idx()]).next().unwrap();
-
- // Indicies for joining phis
- let joining_loop_avoided_idx = editor.func().nodes[joining_region.idx()].try_region().unwrap().iter().position(|pred| *pred == loop_avoided).unwrap();
- let joining_loop_exit_idx = editor.func().nodes[joining_region.idx()].try_region().unwrap().iter().position(|pred| *pred == loop_exit_proj).unwrap();
-
- let header_initial_idx = editor.func().nodes[natural_loop.header.idx()].try_region().unwrap().iter().position(|pred| !natural_loop.control[pred.idx()]).unwrap();
- let header_continue_idx = editor.func().nodes[natural_loop.header.idx()].try_region().unwrap().iter().position(|pred| natural_loop.control[pred.idx()]).unwrap();
-
- let joining_phis = editor.get_users(joining_region).filter(|node| editor.func().nodes[node.idx()].is_phi());
-
- // If the PHI in the joining region attempts to pull from a phi on the loop_exit_idx edge, which is internal to the loop
- // (in loop but not in loop header, add a phi to loop header)
- struct PhiToAdd {
- joining_phi: NodeID, //
- internal_phi: NodeID,
- initializer: NodeID,
- }
-
- let phis_to_add: Vec<_> = joining_phis.filter_map(|phi| {
- let Node::Phi { control, ref data } = &editor.func().nodes[phi.idx()] else {unreachable!()};
-
- // control is joining_region.
-
- let loop_exit_node = data[joining_loop_exit_idx];
-
- let Node::Phi {control: loop_phi_control, data: ref _loop_phi_data} = editor.func().nodes[loop_exit_node.idx()] else {return None};
-
- if loop_phi_control == natural_loop.header {return None};
-
- if !natural_loop.control[loop_phi_control.idx()] {
- todo!("WHAT")
- }
-
- // Initializer is whatever the phi in the joining region takes if the loop is never run.
- let initializer = data[joining_loop_avoided_idx];
-
- Some(PhiToAdd {joining_phi: phi, internal_phi: loop_exit_node, initializer: initializer })
- }).collect();
-
- // Get the control in between the header and before the condition,
-
- // If the header -> if, then there is no control before the condition, so it's a while loop.
- if editor.get_uses(if_node).contains(&natural_loop.header) {
- return false
- }
-
- let loop_before_if_first = editor.get_users(natural_loop.header)
- .filter(|id| natural_loop.control[id.idx()])
- .next()
- .unwrap();
-
- let loop_before_if_last = editor.get_uses(if_node).next().unwrap();
-
- // assert_ne!(loop_before_if_first, loop_before_if_last);
-
- let loop_exit_projection = editor.get_users(if_node)
- .filter(|id| !natural_loop.control[id.idx()])
- .next()
- .unwrap();
-
- let loop_continue_projection = editor.get_users(if_node)
- .filter(|id| natural_loop.control[id.idx()])
- .next()
- .unwrap();
-
- // Control goes after the loop_continue_projection, and before whatever is after loop_continue_projection.
- let loop_body_last = editor.get_uses(natural_loop.header)
- .filter(|id| natural_loop.control[id.idx()])
- .next()
- .unwrap();
-
-
- for phi_to_add in phis_to_add {
- editor.edit(|mut edit| {
- let PhiToAdd { joining_phi, internal_phi, initializer } = phi_to_add;
- let mut data = Box::new([NodeID::new(0); 2]);
- data[header_initial_idx] = initializer;
- data[header_continue_idx] = internal_phi;
- let node = Node::Phi { control: natural_loop.header, data };
- let new_phi = edit.add_node(node);
- edit.replace_all_uses_where(internal_phi, new_phi, |usee| *usee == joining_phi)
- });
- println!("adding phi");
- }
-
- editor.edit(|mut edit| {
- // Have fun understanding this!
- edit = edit.replace_all_uses(loop_continue_projection, loop_before_if_last)?;
- edit = edit.replace_all_uses_where(natural_loop.header, loop_continue_projection, |usee| *usee == loop_before_if_first)?;
- edit = edit.replace_all_uses_where(loop_before_if_last, natural_loop.header, |usee| *usee == if_node)?;
-
- Ok(edit)
- });
- true
-}
-
-pub fn has_alternate_bounds(
- function: &Function,
- l: &Loop,
- condition_node: NodeID,
- basic_ivs: &[BasicInductionVariable],
- loop_variance: LoopVarianceInfo,
-) -> Option<(NodeID, BasicInductionVariable)> // iv_expression, base_iv
-{
- // Analyze Loop Bound (pattern match w/ )
- let alternate_iv = basic_ivs.iter().filter_map(|iv|
- {
- match &function.nodes[condition_node.idx()] {
- Node::Start => todo!(),
- Node::Phi { control, data } => todo!(),
- Node::Reduce { control, init, reduct } => todo!(),
- Node::Parameter { index } => todo!(),
- Node::Constant { id } => todo!(),
- Node::Unary { input, op } => todo!(),
- Node::Ternary { first, second, third, op } => todo!(),
- Node::Binary { left, right, op } => {
- match op {
- BinaryOperator::LT => {
- // Check for a loop guard condition.
- // ADDME: Check if the condition is *normal* already, and then check if the rest of the loop is normal.
-
- // left + 1 < right
- let Node::Binary { left: inner_left, right: inner_right, op: inner_op } = function.nodes[left.idx()] else {return None};
- if inner_op == BinaryOperator::Add &&
- ((inner_left == iv.update && inner_right == iv.node) ||
- (inner_right == iv.update && inner_left == iv.node)) &&
- loop_variance.map[right.idx()] == LoopVariance::Invariant
- {
- return Some((left.clone(), iv.clone()));
- } else {
- return None;
- }
-
- }
- BinaryOperator::LTE => todo!(),
- BinaryOperator::GT => todo!(),
- BinaryOperator::GTE => todo!(),
- BinaryOperator::EQ => todo!(),
- BinaryOperator::NE => todo!(),
- _ => None,
- }
-
- }
- _ => None,
- }
- }
- ).next();
- alternate_iv
-}
-
-
-pub fn canonicalize_loop_old(
- editor: &mut FunctionEditor,
- loop_exit: Option<LoopExit>,
- fork_join_map: &HashMap<NodeID, NodeID>,
- l: &Loop,
-) -> bool {
-
- let Some(loop_condition) = loop_exit else {return false};
-
- let LoopExit::Conditional { if_node: loop_if, condition_node } = loop_condition.clone() else {return false};
-
- // FIXME: Need to be more careful abo ut changing the conditions if we are a do-while loop,
-
- // Changing loop conditions in canonicalization *actually* changes the number of times the loop runs.
- // If there is no internal control, this doesn't matter.
- // If there is internal control, then changing loop iterations might mater.
-
- // If the IF doesn't directly use the header, then there might be side-effects inside the loop,
- // so we don't canonicalize
- if !editor.get_uses(loop_if).contains(&l.header) {
- return false
- }
-
- let function = editor.func();
-
- // Compute loop variance
- let loop_variance = compute_loop_variance(&editor, &l);
-
- // Compute induction vars
- let basic_ivs = compute_basic_induction_vars(function, &l, &loop_variance);
-
- // let Some((iv_expression, base_iv)) = None; //has_alternate_bounds(editor.func(), l, condition_node, &basic_ivs, loop_variance) else {return false};
- // let iv_expression = iv_expression.clone();
- // let base_iv = base_iv.clone();
-
- // // If there are users of iv_expression (not just the loop bound condition), then abort
- // if editor.get_users(iv_expression).count() > 2 {return false};
-
- // // Replace external_uses uses of data with phi.
- // // Panic on internal uses.
- // struct PhiDataCycle {
- // phi: NodeID,
- // data: NodeID,
- // external_uses: Vec<NodeID>,
- // internal_uses: Vec<NodeID>
- // }
-
- // // The initiailzer position for all loop phis.
- // let loop_phi_init_idx = editor.get_uses(l.header)
- // .position(|node| !l.control[node.idx()] // Position of the predecessor (used by header but not in loop body.)
- // ).unwrap();
-
- // let data_use_locations = get_loop_data_location(editor, l);
-
- // let mut changed = false;
-
- // // Check all PHIs controlled by the loop
- // let loop_phis: Option<Vec<PhiDataCycle>> = editor.get_users(l.header).filter(|n| editor.func().nodes[n.idx()].is_phi())
- // .filter(|phi| *phi != base_iv.node)
- // .map(|phi: NodeID| {
-
- // // There should only be one candidate data,
- // // but possibly multiple external uses. z
-
- // let initializer_node_id = editor.func().nodes[phi.idx()].try_phi().unwrap().1[loop_phi_init_idx];
-
- // // Check if any use is in a cycle w/ the phi.
- // let mut data_cycles =
- // editor.get_uses(phi)
- // .filter(|phi_use|
- // *phi_use != initializer_node_id) // Not the initializer.
- // .filter_map(|phi_use| {
-
- // // If the data node is not in a cycle w/ the phi,
- // if !walk_all_uses(phi_use, editor).contains(&phi) {return None};
-
- // // Find users of phi_use that are outside the loop, these we will change to use the phi.
- // let (internal_uses, external_uses) = editor
- // .get_users(phi_use)
- // .filter_map(|data_user| {
- // Some(data_user)
- // }).partition(|data_user| {
- // match data_use_locations[data_user.idx()] {
- // DataUseLoopLocation::Unknown => todo!(),
- // DataUseLoopLocation::Inside => true,
- // DataUseLoopLocation::Outside => false,
- // }
- // });
-
- // Some((phi_use, internal_uses, external_uses))
- // });
-
-
- // let Some((data, internal_uses, external_uses)) = data_cycles.next() else {
- // return None;
- // };
-
- // // There should only be one cycle
- // if data_cycles.next().is_some() {
- // return None;
- // }
-
- // Some(PhiDataCycle {
- // phi,
- // data,
- // external_uses,
- // internal_uses,
- // })
- // }).collect();
-
- // // If any PHIs are invalid, (not in cycles, )
- // let Some(loop_phis) = loop_phis else {
- // return false;
- // };
-
- // // Make sure all phi data cycles are fully contained.
- // let used_outside_loop = loop_phis.iter()
- // .any(|transform_info: &PhiDataCycle|
- // {
- // let PhiDataCycle { phi, data, external_uses, internal_uses } = transform_info;
-
- // // Check usres of the PHI, make sure they aren't outside the loop
- // // Unless they would be outside because of the use we are going to get rid of,
- // // need a more complicated use location analysis for this.
- // if editor.get_users(*phi)
- // .any(|node|
- // {
- // if node == *data {
- // return false;
- // }
-
- // let stop_on: HashSet<NodeID> = editor.node_ids().filter(|n| {
- // if *n == *data {
- // return true
- // };
-
- // let node_data = &editor.func().nodes[n.idx()];
-
- // // Stop on Control.
- // if node_data.is_control() {
- // return true;
- // }
- // // Stop on PHIs.
- // if node_data.is_phi() {
- // // Need to maybe not stop on PHIs, but only stop on some of their incoming edges,
- // // depending
- // let control = node_data.try_phi().unwrap().0;
- // return l.control[control.idx()];
- // }
-
- // // Stop on Reduces.
- // if node_data.is_reduce() {
- // let control = node_data.try_reduce().unwrap().0;
- // return l.control[control.idx()];
- // }
-
- // false
- // }).collect();
-
- // let outside_loop = editor.node_ids().filter(|n| editor.func().nodes[n.idx()].is_control() && !l.control[n.idx()]);
-
- // // If any uses are control nodes *outside* the loop,
- // let node_uses = walk_all_users_stop_on(node, editor, stop_on);
-
- // // TODO: Do intersection lazily?
- // let set1: HashSet<_> = HashSet::from_iter(outside_loop);
- // let set2: HashSet<_> = HashSet::from_iter(node_uses);
-
- // // If there is no intersection, then it is inside the loop
- // if set1.intersection(&set2).next().is_none() {
- // false // No intersection, so all users of this phi are good
- // } else {
- // true // Intersection, so some user of this phi leaves the loop, and we can't fix it by transforming.
- // }
- // }
- // ) {
- // return true;
- // } else {
- // return false;
- // }
- // });
-
- // if used_outside_loop {
- // return changed;
- // }
-
- // // Change loop bounds
- // editor.edit(|edit|
- // edit.replace_all_uses_where(iv_expression, base_iv.node, |usee| *usee == condition_node)
- // );
-
- // changed = true;
-
- // for transform_info in loop_phis {
- // editor.edit(|mut edit|
- // {
- // edit.replace_all_uses_where(transform_info.data, transform_info.phi, |usee| transform_info.external_uses.contains(usee))
- // }
- // );
- // }
-
- // changed
- false
-}
\ No newline at end of file
--
GitLab
From 78028bb253d03891a11109d7b76aef1618cf08cb Mon Sep 17 00:00:00 2001
From: Xavier Routh <xrouth2@illinois.edu>
Date: Thu, 30 Jan 2025 10:01:03 -0600
Subject: [PATCH 59/68] remove loop canon from scheduler
---
juno_scheduler/src/compile.rs | 3 ---
juno_scheduler/src/pm.rs | 27 ---------------------------
2 files changed, 30 deletions(-)
diff --git a/juno_scheduler/src/compile.rs b/juno_scheduler/src/compile.rs
index 0b3264ac..7bf3c5c5 100644
--- a/juno_scheduler/src/compile.rs
+++ b/juno_scheduler/src/compile.rs
@@ -105,9 +105,6 @@ impl FromStr for Appliable {
"forkify" => Ok(Appliable::Pass(ir::Pass::Forkify)),
"gcm" | "bbs" => Ok(Appliable::Pass(ir::Pass::GCM)),
"gvn" => Ok(Appliable::Pass(ir::Pass::GVN)),
- "loop-canon" | "loop-canonicalization" => {
- Ok(Appliable::Pass(ir::Pass::LoopCanonicalization))
- }
"infer-schedules" => Ok(Appliable::Pass(ir::Pass::InferSchedules)),
"inline" => Ok(Appliable::Pass(ir::Pass::Inline)),
"ip-sroa" | "interprocedural-sroa" => {
diff --git a/juno_scheduler/src/pm.rs b/juno_scheduler/src/pm.rs
index 33a7b480..76e81ee9 100644
--- a/juno_scheduler/src/pm.rs
+++ b/juno_scheduler/src/pm.rs
@@ -1785,33 +1785,6 @@ fn run_pass(
// Put BasicBlocks back, since it's needed for Codegen.
pm.bbs = bbs;
}
- Pass::LoopCanonicalization => {
- assert!(args.is_empty());
- pm.make_fork_join_maps();
- pm.make_control_subgraphs();
- pm.make_loops();
- pm.make_typing();
- let fork_join_maps = pm.fork_join_maps.take().unwrap();
- let loops = pm.loops.take().unwrap();
- let control_subgraphs = pm.control_subgraphs.take().unwrap();
- let typing = pm.typing.take().unwrap();
- for ((((func, fork_join_map), loop_nest), control_subgraph), typing) in
- build_selection(pm, selection)
- .into_iter()
- .zip(fork_join_maps.iter())
- .zip(loops.iter())
- .zip(control_subgraphs.iter())
- .zip(typing.iter())
- {
- let Some(mut func) = func else {
- continue;
- };
- // changed |= loop_canonicalization(&mut func, control_subgraph, fork_join_map, loop_nest, typing);
- // func.modified();
- }
- pm.delete_gravestones();
- pm.clear_analyses();
- }
}
println!("Ran Pass: {:?}", pass);
--
GitLab
From ae334572d2a178505665be0943c2be5891045ff4 Mon Sep 17 00:00:00 2001
From: Russel Arbore <russel.jma@gmail.com>
Date: Thu, 30 Jan 2025 10:01:51 -0600
Subject: [PATCH 60/68] remove loop-canon
---
hercules_opt/src/loop_canonicalization.rs | 899 ------------------
hercules_test/hercules_interpreter/src/lib.rs | 2 -
.../tests/fork_transform_tests.rs | 1 -
.../hercules_tests/tests/forkify_tests.rs | 1 -
.../hercules_tests/tests/interpreter_tests.rs | 1 -
.../hercules_tests/tests/loop_tests.rs | 2 -
juno_scheduler/src/compile.rs | 3 -
juno_scheduler/src/ir.rs | 1 -
juno_scheduler/src/pm.rs | 27 -
9 files changed, 937 deletions(-)
delete mode 100644 hercules_opt/src/loop_canonicalization.rs
diff --git a/hercules_opt/src/loop_canonicalization.rs b/hercules_opt/src/loop_canonicalization.rs
deleted file mode 100644
index 12d8fd3b..00000000
--- a/hercules_opt/src/loop_canonicalization.rs
+++ /dev/null
@@ -1,899 +0,0 @@
-use std::collections::HashMap;
-use std::collections::HashSet;
-use std::iter::FromIterator;
-
-use hercules_ir::Constant;
-use hercules_ir::TypeID;
-
-use nestify::nest;
-
-use hercules_ir::get_uses;
-
-use itertools::Itertools;
-
-use hercules_ir::BinaryOperator;
-
-use hercules_ir::Function;
-use hercules_ir::Node;
-
-use hercules_ir::ID;
-
-use hercules_ir::NodeID;
-
-use hercules_ir::Subgraph;
-
-use crate::calculate_loop_nodes;
-use crate::compute_loop_variance;
-use crate::get_loop_exit_conditions;
-use crate::BasicInductionVariable;
-use crate::FunctionEditor;
-use crate::Loop;
-use crate::LoopExit;
-use crate::LoopVariance;
-use crate::LoopVarianceInfo;
-
-use hercules_ir::LoopTree;
-
-/** On return `true` means the function has been modified, and loop_canonicalization can be ran again
- (with newly analysis info), to canonicalze more loops. */
-pub fn loop_canonicalization(
- editor: &mut FunctionEditor,
- control_subgraph: &Subgraph,
- fork_join_map: &HashMap<NodeID, NodeID>,
- loops: &LoopTree,
- typing: &Vec<TypeID>,
-) -> bool {
-
- let natural_loops = loops
- .bottom_up_loops()
- .into_iter()
- .filter(|(k, _)| editor.func().nodes[k.idx()].is_region());
-
- let natural_loops: Vec<_> = natural_loops.collect();
-
- let mut loop_exits = HashMap::new();
-
- // FIXME: Add return type enum of: {transformed, already in transformed form (not modified), unable to transform}.
- for l in &natural_loops {
- let Some(loop_exit) = get_loop_exit_conditions(
- editor.func(),
- &Loop {
- header: l.0,
- control: l.1.clone(),
- },
- control_subgraph,
- ) else {
- continue;
- };
- loop_exits.insert(l.0, loop_exit);
- }
-
- for l in natural_loops {
- let natural_loop = &Loop {
- header: l.0,
- control: l.1.clone(),
- };
- if canonicalize_loop(
- editor,
- loop_exits.get(&l.0).copied(),
- fork_join_map,
- natural_loop,
- typing,
- ) {
- let nodes = &editor.func().nodes;
- let mut xuser = NodeID::new(0);
- let mut xother_user = NodeID::new(0);
- for id in editor.node_ids() {
- if nodes[id.idx()].is_region() {
- for user in editor.get_users(id) {
- if let Node::Phi {
- control: _,
- ref data,
- } = nodes[user.idx()]
- && data.into_iter().any(|id| nodes[id.idx()].is_undef())
- {
- for other_user in editor.get_users(id) {
- if let Node::Phi {
- control: _,
- data: ref other_data,
- } = nodes[other_user.idx()]
- && data.into_iter().zip(other_data.into_iter()).all(
- |(datum, other_datum)| {
- datum == other_datum || nodes[datum.idx()].is_undef()
- },
- )
- && user != other_user
- {
- xuser = user;
- xother_user = other_user;
- }
- }
- }
- }
- }
- }
- if xuser.idx() != 0 && xother_user.idx() != 0 {
- editor.edit(|mut edit| {
- edit = edit.replace_all_uses(xuser, xother_user)?;
- edit.delete_node(xuser)
- });
- }
-
- return true;
- }
- }
-
- if merge_phis(editor) {
- return true;
- }
-
- return false;
-}
-
-
-
-/**
- * Replaces undef's in PHIs to use already existing PHIs.
- */
-pub fn merge_phis(editor: &mut FunctionEditor) -> bool {
-
- let mut changed = false;
- let mut worklist: Vec<NodeID> = editor.node_ids().filter(|node| editor.func().nodes[node.idx()].is_phi()).collect();
-
-
- while let Some(phi) = worklist.pop() {
- let Node::Phi { control: phi_region, data: phi_data } = &editor.func().nodes[phi.idx()] else {unreachable!()};
-
- // undef_idx
- // FIXME: Enumerate + Partition
- let undefs: Vec<_> = phi_data.iter().positions(|usee| editor.func().nodes[usee.idx()].is_undef()).collect();
- let non_undefs: Vec<_> = phi_data.iter().positions(|usee| !editor.func().nodes[usee.idx()].is_undef()).collect();
-
- if undefs.is_empty() {
- continue;
- }
-
- if non_undefs.is_empty() {
- continue;
- }
-
- // Try to merge with other phis of the same region
- let candidate = editor.get_users(*phi_region).filter(|node| editor.func().nodes[node.idx()].is_phi());
-
- let mut merge_candidates = candidate.filter(|node| {
- if phi == *node {
- return false;
- }
-
- if let Node::Phi { control: candidate_region, data: candidate_data } = &editor.func().nodes[node.idx()] {
-
- // Regions have to match
- if candidate_region != phi_region {
- return false;
- }
-
- // FIXME: Sort by candidate that can replace the most undefs.
- // All undefs need to have data.
- if undefs.iter().any(|idx| editor.func().nodes[candidate_data[*idx].idx()].is_undef()) {
- return false;
- }
-
- // All non_undefs need to be the same.
- if non_undefs.iter().any(|idx| candidate_data[*idx] != phi_data[*idx]) {
- return false;
- }
- true
- } else {
- false
- }
- });
-
-
- let Some(data) = merge_candidates.next() else {continue};
- drop(merge_candidates);
-
- editor.edit(|mut edit|{
- let edit = edit.replace_all_uses(phi, data)?;
- edit.delete_node(phi)
- });
- changed = true;
-
- }
- changed
-}
-
-/**
-
- */
-pub fn canonicalize_loop(
- editor: &mut FunctionEditor,
- loop_exit: Option<LoopExit>,
- fork_join_map: &HashMap<NodeID, NodeID>,
- natural_loop: &Loop,
- typing: &Vec<TypeID>
-) -> bool {
-
- let Some(loop_condition) = loop_exit else {return false};
- let LoopExit::Conditional { if_node: loop_if, condition_node } = loop_condition.clone() else {return false};
-
- // let Some((iv_expression, base_iv)) = has_alternate_bounds(editor.func(),
- // natural_loop, condition_node, &basic_ivs, loop_variance)
- // else {return false};
-
- // Find nodes that are `in the loop`
- // - used by a phi (or the loop region)
- // - uses a phi (the loop region)
- // All other nodes are 'out of the loop'
- // All edges from the loop to out of the loop need to have a phi added,
- // controlled by the loop header. The loop entry edge is undef, the loop continued data node is
- // the edge it is being inserted in.
- //
- // Inner control needs to be moved, with PHIs being inserted as appropriate for now undef'd variables.
-
- let loop_nodes = calculate_loop_nodes(editor, natural_loop);
-
- let header_initial_idx = editor.get_uses(natural_loop.header)
- .position(|node| !natural_loop.control[node.idx()] // Position of the predecessor (used by header but not in loop body.)
- ).unwrap();
-
- let header_continue_idx = editor.get_uses(natural_loop.header)
- .position(|node| natural_loop.control[node.idx()]
- ).unwrap();
-
-
- // Check loop variables that are used by smthn outside the loop.
- let binding = loop_nodes.clone();
- let phis_to_add: Vec<NodeID> = binding.iter()
- .filter(
- |loop_node| !editor.func().nodes[loop_node.idx()].is_control()
- )
- .filter(
- |loop_node|
- {
- editor.get_users(**loop_node).any(|user|!loop_nodes.contains(&user))
- }
- ).cloned().collect();
-
- // If all loop variables are contained w/ PHIs already, no point in canonicalizing.
- if phis_to_add.iter().all(
- |node| {
- let Node::Phi { ref control, ref data } = editor.func().nodes[node.idx()] else {return false};
- if *control == natural_loop.header {
- true
- } else {
- false
- }
- }
- ) {
- return false;
-
- }
-
- if phis_to_add.is_empty() {
- return false;
- }
-
- let loop_before_if_first = editor.get_users(natural_loop.header)
- .filter(|id| natural_loop.control[id.idx()])
- .next()
- .unwrap();
-
- let loop_before_if_last = editor.get_uses(loop_if).next().unwrap();
-
- let loop_exit_projection = editor.get_users(loop_if)
- .filter(|id| !natural_loop.control[id.idx()])
- .next()
- .unwrap();
-
- let loop_continue_projection = editor.get_users(loop_if)
- .filter(|id| natural_loop.control[id.idx()])
- .next()
- .unwrap();
-
- // Control goes after the loop_continue_projection, and before whatever is after loop_continue_projection.
- let loop_body_last = editor.get_uses(natural_loop.header)
- .filter(|id| natural_loop.control[id.idx()])
- .next()
- .unwrap();
-
- // ========= Do transformation ===========:
-
- let num_loop_predecessors = editor.get_uses(natural_loop.header).count();
-
- // Add PHIs
- for data_in_loop in phis_to_add {
- editor.edit(|mut edit| {
- let ty = typing[data_in_loop.idx()];
- let undef = Node::Undef { ty };
- let undef = edit.add_node(undef);
- let mut data = vec![undef; num_loop_predecessors];
- data[header_continue_idx] = data_in_loop;
- let new_phi = Node::Phi { control: natural_loop.header, data: data.into()};
- let new_phi = edit.add_node(new_phi);
- edit.replace_all_uses_where(data_in_loop, new_phi, |usee| !loop_nodes.contains(usee) && *usee != new_phi)
- });
- }
-
- // Add PHI for loop condition
- editor.edit(|mut edit| {
- let bool_ty = typing[condition_node.idx()];
- let true_const = Constant::Boolean(true);
- let true_const = edit.add_constant(true_const);
- let true_const = Node::Constant { id: true_const };
- let true_const = edit.add_node(true_const);
-
- let mut data = vec![true_const; num_loop_predecessors];
- data[header_continue_idx] = condition_node;
- let new_phi = Node::Phi { control: natural_loop.header, data: data.into()};
- let new_phi = edit.add_node(new_phi);
- edit.replace_all_uses_where(condition_node, new_phi, |usee| *usee == loop_if)
- });
-
- // Convert to while loop if not a while loop already.
- if !editor.get_users(natural_loop.header).contains(&loop_if) {
- editor.edit(|mut edit| {
- // Have fun understanding this!
- edit = edit.replace_all_uses(loop_continue_projection, loop_before_if_last)?;
- edit = edit.replace_all_uses_where(natural_loop.header, loop_continue_projection, |usee| *usee == loop_before_if_first)?;
- edit = edit.replace_all_uses_where(loop_before_if_last, natural_loop.header, |usee| *usee == loop_if)?;
-
- Ok(edit)
- });
-
- // for phi_to_add in while_loop_conversion {
- // editor.edit(|mut edit| {
- // let PhiToAdd { joining_phi, internal_phi, initializer } = phi_to_add;
- // let mut data = Box::new([NodeID::new(0); 2]);
- // data[header_initial_idx] = initializer;
- // data[header_continue_idx] = internal_phi;
- // let node = Node::Phi { control: natural_loop.header, data };
- // let new_phi = edit.add_node(node);
- // edit.replace_all_uses_where(internal_phi, new_phi, |usee| *usee == joining_phi)
- // });
- // println!("adding phi");
- // }
-
- }
-
- // Change loop bounds
- // editor.edit(|edit|
- // edit.replace_all_uses_where(iv_expression, base_iv.node, |usee| *usee == condition_node)
- // );
-
- true
-
-
-}
-
-pub struct LoopGuard {
- guard_if: NodeID,
- loop_entered: NodeID,
- loop_avoided: NodeID,
-}
-
-// Returns the
-pub fn get_guard(
- editor: &mut FunctionEditor,
- natural_loop: &Loop,
- if_node: NodeID,
-) -> Option<LoopGuard> {
- // Given loop condition (iv_phi ? bound_expr)
-
- // Q: What if iv_phi isn't a PHI, but instead a more complex expression.
- // A: Idk!
-
- // Q: What if idx_phi.init changes from when the loop is entered vs where the guard is?
- // A: Guards have to be immediate, later we can look through control dominators blah blah.
-
- // Search for a condition (idx_phi.init ? bound_expr) immediately before the loop is entered
- // (header predecessor)
- let Node::If { control: pred, cond: loop_condition } =
- editor.func().nodes[if_node.idx()] else {return None};
-
- // Rely on GVN that the initializers will be the same exact node.
- let mut header_preds = editor.get_uses(natural_loop.header)
- .filter(|pred| !natural_loop.control[pred.idx()]);
-
- let Some(loop_pred) = header_preds.next() else {return None};
- if header_preds.next().is_some() {return None}; // If there is more than one header predecessor.
-
- let Node::Projection { control: guard_if_node, ref selection } =
- editor.func().nodes[loop_pred.idx()] else {return None};
-
- let Node::If { control: guard_if_pred, cond: guard_cond } =
- editor.func().nodes[guard_if_node.idx()] else {return None};
-
- let loop_entered_proj = loop_pred;
-
- // The if user that isn't the entered proj:
- let Some(loop_avoided_proj) = editor.get_users(guard_if_node).filter(|n| *n != loop_entered_proj).next() else {return None};
-
- let Node::Binary { left: guard_cond_left, right: guard_cond_right, op: guard_cond_op } =
- editor.func().nodes[guard_cond.idx()] else {return None};
-
- // Check that the side of the exit condition is the same, or the initializer is the same.
- let Node::Binary {left: latch_left, right: latch_right, op: latch_op } =
- editor.func().nodes[loop_condition.idx()] else {return None};
-
- // Check for Specific Pattern for do-while loops that have weird ivar + 1 < dc bound.
- // This is the worst code I have ever written in my life.
- let blah = {
- if let Node::Binary { left: latch_add_left, right: latch_add_right, op: add_op } = &editor.func().nodes[latch_left.idx()] {
-
- // FIXME: Better utilities for comparing equiv of expressions. Blah.
- let left_is_one = if let Node::Constant { id } = &editor.func().nodes[latch_add_left.idx()] {
- editor.get_constant(*id).is_one()
- } else {
- false
- };
-
- let right_is_one = if let Node::Constant { id } = &editor.func().nodes[latch_add_right.idx()] {
- editor.get_constant(*id).is_one()
- } else {
- false
- };
-
- if !(right_is_one || left_is_one) {
- false
- } else if !(*add_op == BinaryOperator::Add) {
- false
- } else {
- let n = if (right_is_one) {
- &editor.func().nodes[latch_add_left.idx()]
- } else {
- &editor.func().nodes[latch_add_right.idx()]
- };
-
- if let Node::Phi {control: phi_control, data} = n {
- if *phi_control == natural_loop.header {
- let Node::Region { preds } = &editor.func().nodes[natural_loop.header.idx()] else {panic!()};
- let init_idx = preds.iter().position(|node| *node == loop_pred ).unwrap();
- let init_value = data[init_idx];
-
- // Now, we have all the pieces, compare to the guard condition.
- if latch_op == guard_cond_op && guard_cond_left == init_value && guard_cond_right == latch_right {
- return Some(LoopGuard { guard_if: guard_if_node, loop_entered: loop_entered_proj, loop_avoided: loop_avoided_proj });
- } else {
- return None;
- }
- } else {
- false
- }
- } else {
- false
- }
- }
-
- } else {
- false
- }
- };
-
- if blah {
- return Some(LoopGuard { guard_if: guard_if_node, loop_entered: loop_entered_proj, loop_avoided: loop_avoided_proj });
- }
-
-
- // Replace phis in the loop latch w/ their initializers.
-
- // General Case:
- let latch_left = if let Node::Phi { control: left_control, data } = &editor.func().nodes[latch_left.idx()] {
- if *left_control == natural_loop.header {
- let Node::Region { preds } = &editor.func().nodes[natural_loop.header.idx()] else {panic!()};
- let init_idx = preds.iter().position(|node| *node == loop_pred ).unwrap();
-
- data[init_idx]
- } else {
- latch_left
- }
- } else {
- latch_left
- };
-
- let latch_right = if let Node::Phi { control: right_control, data } = &editor.func().nodes[latch_right.idx()] {
- if *right_control == natural_loop.header {
- let Node::Region { preds } = &editor.func().nodes[natural_loop.header.idx()] else {panic!()};
- let init_idx = preds.iter().position(|node| *node == loop_pred ).unwrap();
-
- data[init_idx]
- } else {
- latch_right
- }
- } else {
- latch_right
- };
-
- // FIXME: More comprehensive condition equivalance.
- // Check condition equivalence:
- if latch_op == guard_cond_op && guard_cond_left == latch_left && guard_cond_right == latch_right {
- return Some(LoopGuard { guard_if: guard_if_node, loop_entered: loop_entered_proj, loop_avoided: loop_avoided_proj });
- } else {
- return None;
- }
-}
-
-/** Attempts to converts a simple natural loop to a while loop
- by moving all control between the loop header and the loop condition to after the loop true condition,
- but before the header.
- * */
-pub fn convert_to_while_loop(
- editor: &mut FunctionEditor,
- natural_loop: &Loop,
- loop_exit: Option<LoopExit>,
- add_guard_flag: bool,
-) -> bool {
-
- // FIXME: Check that Loop is simple.
- let Some(LoopExit::Conditional { if_node, condition_node: _ }) = loop_exit.clone() else {return false};
-
- // FIXME: Check whether the loop is guaranteed to be entered.
- // i.e add a guard if needed.
- let guard = match get_guard(editor, natural_loop, if_node) {
- Some(v) => v,
- None => return false,
- };
-
- // Find the joining region for the guard and the loop exit.
- // FIXME: For now, just assume its always the node following the guard loop_avoided projection. This is probably always the case.
- let LoopGuard { guard_if, loop_entered, loop_avoided } = guard;
- let Some(joining_region) = editor.get_users(loop_avoided).next() else {return false;};
-
- // For PHIs in the loop (but not of the loop header), that this joining region controls, need
- // to add a version to the loop header, initialized to the same thing as the loop non-taken, and
- // updated when the loop is taken to be the internal version.
- let loop_exit_proj = editor.get_users(if_node).filter(|node| !natural_loop.control[node.idx()]).next().unwrap();
-
- // Indicies for joining phis
- let joining_loop_avoided_idx = editor.func().nodes[joining_region.idx()].try_region().unwrap().iter().position(|pred| *pred == loop_avoided).unwrap();
- let joining_loop_exit_idx = editor.func().nodes[joining_region.idx()].try_region().unwrap().iter().position(|pred| *pred == loop_exit_proj).unwrap();
-
- let header_initial_idx = editor.func().nodes[natural_loop.header.idx()].try_region().unwrap().iter().position(|pred| !natural_loop.control[pred.idx()]).unwrap();
- let header_continue_idx = editor.func().nodes[natural_loop.header.idx()].try_region().unwrap().iter().position(|pred| natural_loop.control[pred.idx()]).unwrap();
-
- let joining_phis = editor.get_users(joining_region).filter(|node| editor.func().nodes[node.idx()].is_phi());
-
- // If the PHI in the joining region attempts to pull from a phi on the loop_exit_idx edge, which is internal to the loop
- // (in loop but not in loop header, add a phi to loop header)
- struct PhiToAdd {
- joining_phi: NodeID, //
- internal_phi: NodeID,
- initializer: NodeID,
- }
-
- let phis_to_add: Vec<_> = joining_phis.filter_map(|phi| {
- let Node::Phi { control, ref data } = &editor.func().nodes[phi.idx()] else {unreachable!()};
-
- // control is joining_region.
-
- let loop_exit_node = data[joining_loop_exit_idx];
-
- let Node::Phi {control: loop_phi_control, data: ref _loop_phi_data} = editor.func().nodes[loop_exit_node.idx()] else {return None};
-
- if loop_phi_control == natural_loop.header {return None};
-
- if !natural_loop.control[loop_phi_control.idx()] {
- todo!("WHAT")
- }
-
- // Initializer is whatever the phi in the joining region takes if the loop is never run.
- let initializer = data[joining_loop_avoided_idx];
-
- Some(PhiToAdd {joining_phi: phi, internal_phi: loop_exit_node, initializer: initializer })
- }).collect();
-
- // Get the control in between the header and before the condition,
-
- // If the header -> if, then there is no control before the condition, so it's a while loop.
- if editor.get_uses(if_node).contains(&natural_loop.header) {
- return false
- }
-
- let loop_before_if_first = editor.get_users(natural_loop.header)
- .filter(|id| natural_loop.control[id.idx()])
- .next()
- .unwrap();
-
- let loop_before_if_last = editor.get_uses(if_node).next().unwrap();
-
- // assert_ne!(loop_before_if_first, loop_before_if_last);
-
- let loop_exit_projection = editor.get_users(if_node)
- .filter(|id| !natural_loop.control[id.idx()])
- .next()
- .unwrap();
-
- let loop_continue_projection = editor.get_users(if_node)
- .filter(|id| natural_loop.control[id.idx()])
- .next()
- .unwrap();
-
- // Control goes after the loop_continue_projection, and before whatever is after loop_continue_projection.
- let loop_body_last = editor.get_uses(natural_loop.header)
- .filter(|id| natural_loop.control[id.idx()])
- .next()
- .unwrap();
-
-
- for phi_to_add in phis_to_add {
- editor.edit(|mut edit| {
- let PhiToAdd { joining_phi, internal_phi, initializer } = phi_to_add;
- let mut data = Box::new([NodeID::new(0); 2]);
- data[header_initial_idx] = initializer;
- data[header_continue_idx] = internal_phi;
- let node = Node::Phi { control: natural_loop.header, data };
- let new_phi = edit.add_node(node);
- edit.replace_all_uses_where(internal_phi, new_phi, |usee| *usee == joining_phi)
- });
- println!("adding phi");
- }
-
- editor.edit(|mut edit| {
- // Have fun understanding this!
- edit = edit.replace_all_uses(loop_continue_projection, loop_before_if_last)?;
- edit = edit.replace_all_uses_where(natural_loop.header, loop_continue_projection, |usee| *usee == loop_before_if_first)?;
- edit = edit.replace_all_uses_where(loop_before_if_last, natural_loop.header, |usee| *usee == if_node)?;
-
- Ok(edit)
- });
- true
-}
-
-pub fn has_alternate_bounds(
- function: &Function,
- l: &Loop,
- condition_node: NodeID,
- basic_ivs: &[BasicInductionVariable],
- loop_variance: LoopVarianceInfo,
-) -> Option<(NodeID, BasicInductionVariable)> // iv_expression, base_iv
-{
- // Analyze Loop Bound (pattern match w/ )
- let alternate_iv = basic_ivs.iter().filter_map(|iv|
- {
- match &function.nodes[condition_node.idx()] {
- Node::Start => todo!(),
- Node::Phi { control, data } => todo!(),
- Node::Reduce { control, init, reduct } => todo!(),
- Node::Parameter { index } => todo!(),
- Node::Constant { id } => todo!(),
- Node::Unary { input, op } => todo!(),
- Node::Ternary { first, second, third, op } => todo!(),
- Node::Binary { left, right, op } => {
- match op {
- BinaryOperator::LT => {
- // Check for a loop guard condition.
- // ADDME: Check if the condition is *normal* already, and then check if the rest of the loop is normal.
-
- // left + 1 < right
- let Node::Binary { left: inner_left, right: inner_right, op: inner_op } = function.nodes[left.idx()] else {return None};
- if inner_op == BinaryOperator::Add &&
- ((inner_left == iv.update && inner_right == iv.node) ||
- (inner_right == iv.update && inner_left == iv.node)) &&
- loop_variance.map[right.idx()] == LoopVariance::Invariant
- {
- return Some((left.clone(), iv.clone()));
- } else {
- return None;
- }
-
- }
- BinaryOperator::LTE => todo!(),
- BinaryOperator::GT => todo!(),
- BinaryOperator::GTE => todo!(),
- BinaryOperator::EQ => todo!(),
- BinaryOperator::NE => todo!(),
- _ => None,
- }
-
- }
- _ => None,
- }
- }
- ).next();
- alternate_iv
-}
-
-
-pub fn canonicalize_loop_old(
- editor: &mut FunctionEditor,
- loop_exit: Option<LoopExit>,
- fork_join_map: &HashMap<NodeID, NodeID>,
- l: &Loop,
-) -> bool {
-
- let Some(loop_condition) = loop_exit else {return false};
-
- let LoopExit::Conditional { if_node: loop_if, condition_node } = loop_condition.clone() else {return false};
-
- // FIXME: Need to be more careful abo ut changing the conditions if we are a do-while loop,
-
- // Changing loop conditions in canonicalization *actually* changes the number of times the loop runs.
- // If there is no internal control, this doesn't matter.
- // If there is internal control, then changing loop iterations might mater.
-
- // If the IF doesn't directly use the header, then there might be side-effects inside the loop,
- // so we don't canonicalize
- if !editor.get_uses(loop_if).contains(&l.header) {
- return false
- }
-
- let function = editor.func();
-
- // Compute loop variance
- let loop_variance = compute_loop_variance(&editor, &l);
-
- // Compute induction vars
- let basic_ivs = compute_basic_induction_vars(function, &l, &loop_variance);
-
- // let Some((iv_expression, base_iv)) = None; //has_alternate_bounds(editor.func(), l, condition_node, &basic_ivs, loop_variance) else {return false};
- // let iv_expression = iv_expression.clone();
- // let base_iv = base_iv.clone();
-
- // // If there are users of iv_expression (not just the loop bound condition), then abort
- // if editor.get_users(iv_expression).count() > 2 {return false};
-
- // // Replace external_uses uses of data with phi.
- // // Panic on internal uses.
- // struct PhiDataCycle {
- // phi: NodeID,
- // data: NodeID,
- // external_uses: Vec<NodeID>,
- // internal_uses: Vec<NodeID>
- // }
-
- // // The initiailzer position for all loop phis.
- // let loop_phi_init_idx = editor.get_uses(l.header)
- // .position(|node| !l.control[node.idx()] // Position of the predecessor (used by header but not in loop body.)
- // ).unwrap();
-
- // let data_use_locations = get_loop_data_location(editor, l);
-
- // let mut changed = false;
-
- // // Check all PHIs controlled by the loop
- // let loop_phis: Option<Vec<PhiDataCycle>> = editor.get_users(l.header).filter(|n| editor.func().nodes[n.idx()].is_phi())
- // .filter(|phi| *phi != base_iv.node)
- // .map(|phi: NodeID| {
-
- // // There should only be one candidate data,
- // // but possibly multiple external uses. z
-
- // let initializer_node_id = editor.func().nodes[phi.idx()].try_phi().unwrap().1[loop_phi_init_idx];
-
- // // Check if any use is in a cycle w/ the phi.
- // let mut data_cycles =
- // editor.get_uses(phi)
- // .filter(|phi_use|
- // *phi_use != initializer_node_id) // Not the initializer.
- // .filter_map(|phi_use| {
-
- // // If the data node is not in a cycle w/ the phi,
- // if !walk_all_uses(phi_use, editor).contains(&phi) {return None};
-
- // // Find users of phi_use that are outside the loop, these we will change to use the phi.
- // let (internal_uses, external_uses) = editor
- // .get_users(phi_use)
- // .filter_map(|data_user| {
- // Some(data_user)
- // }).partition(|data_user| {
- // match data_use_locations[data_user.idx()] {
- // DataUseLoopLocation::Unknown => todo!(),
- // DataUseLoopLocation::Inside => true,
- // DataUseLoopLocation::Outside => false,
- // }
- // });
-
- // Some((phi_use, internal_uses, external_uses))
- // });
-
-
- // let Some((data, internal_uses, external_uses)) = data_cycles.next() else {
- // return None;
- // };
-
- // // There should only be one cycle
- // if data_cycles.next().is_some() {
- // return None;
- // }
-
- // Some(PhiDataCycle {
- // phi,
- // data,
- // external_uses,
- // internal_uses,
- // })
- // }).collect();
-
- // // If any PHIs are invalid, (not in cycles, )
- // let Some(loop_phis) = loop_phis else {
- // return false;
- // };
-
- // // Make sure all phi data cycles are fully contained.
- // let used_outside_loop = loop_phis.iter()
- // .any(|transform_info: &PhiDataCycle|
- // {
- // let PhiDataCycle { phi, data, external_uses, internal_uses } = transform_info;
-
- // // Check usres of the PHI, make sure they aren't outside the loop
- // // Unless they would be outside because of the use we are going to get rid of,
- // // need a more complicated use location analysis for this.
- // if editor.get_users(*phi)
- // .any(|node|
- // {
- // if node == *data {
- // return false;
- // }
-
- // let stop_on: HashSet<NodeID> = editor.node_ids().filter(|n| {
- // if *n == *data {
- // return true
- // };
-
- // let node_data = &editor.func().nodes[n.idx()];
-
- // // Stop on Control.
- // if node_data.is_control() {
- // return true;
- // }
- // // Stop on PHIs.
- // if node_data.is_phi() {
- // // Need to maybe not stop on PHIs, but only stop on some of their incoming edges,
- // // depending
- // let control = node_data.try_phi().unwrap().0;
- // return l.control[control.idx()];
- // }
-
- // // Stop on Reduces.
- // if node_data.is_reduce() {
- // let control = node_data.try_reduce().unwrap().0;
- // return l.control[control.idx()];
- // }
-
- // false
- // }).collect();
-
- // let outside_loop = editor.node_ids().filter(|n| editor.func().nodes[n.idx()].is_control() && !l.control[n.idx()]);
-
- // // If any uses are control nodes *outside* the loop,
- // let node_uses = walk_all_users_stop_on(node, editor, stop_on);
-
- // // TODO: Do intersection lazily?
- // let set1: HashSet<_> = HashSet::from_iter(outside_loop);
- // let set2: HashSet<_> = HashSet::from_iter(node_uses);
-
- // // If there is no intersection, then it is inside the loop
- // if set1.intersection(&set2).next().is_none() {
- // false // No intersection, so all users of this phi are good
- // } else {
- // true // Intersection, so some user of this phi leaves the loop, and we can't fix it by transforming.
- // }
- // }
- // ) {
- // return true;
- // } else {
- // return false;
- // }
- // });
-
- // if used_outside_loop {
- // return changed;
- // }
-
- // // Change loop bounds
- // editor.edit(|edit|
- // edit.replace_all_uses_where(iv_expression, base_iv.node, |usee| *usee == condition_node)
- // );
-
- // changed = true;
-
- // for transform_info in loop_phis {
- // editor.edit(|mut edit|
- // {
- // edit.replace_all_uses_where(transform_info.data, transform_info.phi, |usee| transform_info.external_uses.contains(usee))
- // }
- // );
- // }
-
- // changed
- false
-}
diff --git a/hercules_test/hercules_interpreter/src/lib.rs b/hercules_test/hercules_interpreter/src/lib.rs
index baf0093e..3f12618c 100644
--- a/hercules_test/hercules_interpreter/src/lib.rs
+++ b/hercules_test/hercules_interpreter/src/lib.rs
@@ -1,7 +1,5 @@
pub mod interpreter;
pub mod value;
-extern crate juno_scheduler;
-extern crate postcard;
use std::fs::File;
use std::io::Read;
diff --git a/hercules_test/hercules_tests/tests/fork_transform_tests.rs b/hercules_test/hercules_tests/tests/fork_transform_tests.rs
index 16813b03..432fdda0 100644
--- a/hercules_test/hercules_tests/tests/fork_transform_tests.rs
+++ b/hercules_test/hercules_tests/tests/fork_transform_tests.rs
@@ -4,7 +4,6 @@ use hercules_interpreter::*;
use hercules_ir::ID;
use juno_scheduler::ir::*;
-extern crate rand;
use juno_scheduler::pass;
use juno_scheduler::{default_schedule, run_schedule_on_hercules};
use rand::Rng;
diff --git a/hercules_test/hercules_tests/tests/forkify_tests.rs b/hercules_test/hercules_tests/tests/forkify_tests.rs
index 025aaad3..5a8bff1a 100644
--- a/hercules_test/hercules_tests/tests/forkify_tests.rs
+++ b/hercules_test/hercules_tests/tests/forkify_tests.rs
@@ -7,7 +7,6 @@ use hercules_interpreter::*;
use juno_scheduler::ir::*;
use juno_scheduler::pass;
-extern crate rand;
use juno_scheduler::{default_schedule, run_schedule_on_hercules};
use rand::Rng;
diff --git a/hercules_test/hercules_tests/tests/interpreter_tests.rs b/hercules_test/hercules_tests/tests/interpreter_tests.rs
index 69e1920e..a779c70b 100644
--- a/hercules_test/hercules_tests/tests/interpreter_tests.rs
+++ b/hercules_test/hercules_tests/tests/interpreter_tests.rs
@@ -6,7 +6,6 @@ use hercules_ir::ID;
use juno_scheduler::ir::*;
use juno_scheduler::pass;
-extern crate rand;
use juno_scheduler::{default_schedule, run_schedule_on_hercules};
use rand::Rng;
diff --git a/hercules_test/hercules_tests/tests/loop_tests.rs b/hercules_test/hercules_tests/tests/loop_tests.rs
index 29b8692b..55da702d 100644
--- a/hercules_test/hercules_tests/tests/loop_tests.rs
+++ b/hercules_test/hercules_tests/tests/loop_tests.rs
@@ -5,7 +5,6 @@ use hercules_ir::ID;
use juno_scheduler::ir::*;
use juno_scheduler::pass;
-extern crate rand;
use juno_scheduler::{default_schedule, run_schedule_on_hercules};
use rand::random;
use rand::Rng;
@@ -333,7 +332,6 @@ fn implicit_clone_pipeline() {
println!("result: {:?}", result_1);
let schedule = default_schedule![
////Xdot,,
- LoopCanonicalization,
Forkify,
ForkGuardElim,
Forkify,
diff --git a/juno_scheduler/src/compile.rs b/juno_scheduler/src/compile.rs
index 14dd828b..11a8ec53 100644
--- a/juno_scheduler/src/compile.rs
+++ b/juno_scheduler/src/compile.rs
@@ -104,9 +104,6 @@ impl FromStr for Appliable {
"forkify" => Ok(Appliable::Pass(ir::Pass::Forkify)),
"gcm" | "bbs" => Ok(Appliable::Pass(ir::Pass::GCM)),
"gvn" => Ok(Appliable::Pass(ir::Pass::GVN)),
- "loop-canon" | "loop-canonicalization" => {
- Ok(Appliable::Pass(ir::Pass::LoopCanonicalization))
- }
"infer-schedules" => Ok(Appliable::Pass(ir::Pass::InferSchedules)),
"inline" => Ok(Appliable::Pass(ir::Pass::Inline)),
"ip-sroa" | "interprocedural-sroa" => {
diff --git a/juno_scheduler/src/ir.rs b/juno_scheduler/src/ir.rs
index aa9b2367..d6a41baf 100644
--- a/juno_scheduler/src/ir.rs
+++ b/juno_scheduler/src/ir.rs
@@ -8,7 +8,6 @@ pub enum Pass {
DCE,
DeleteUncalled,
FloatCollections,
- LoopCanonicalization,
ForkGuardElim,
ForkSplit,
ForkCoalesce,
diff --git a/juno_scheduler/src/pm.rs b/juno_scheduler/src/pm.rs
index 33a7b480..76e81ee9 100644
--- a/juno_scheduler/src/pm.rs
+++ b/juno_scheduler/src/pm.rs
@@ -1785,33 +1785,6 @@ fn run_pass(
// Put BasicBlocks back, since it's needed for Codegen.
pm.bbs = bbs;
}
- Pass::LoopCanonicalization => {
- assert!(args.is_empty());
- pm.make_fork_join_maps();
- pm.make_control_subgraphs();
- pm.make_loops();
- pm.make_typing();
- let fork_join_maps = pm.fork_join_maps.take().unwrap();
- let loops = pm.loops.take().unwrap();
- let control_subgraphs = pm.control_subgraphs.take().unwrap();
- let typing = pm.typing.take().unwrap();
- for ((((func, fork_join_map), loop_nest), control_subgraph), typing) in
- build_selection(pm, selection)
- .into_iter()
- .zip(fork_join_maps.iter())
- .zip(loops.iter())
- .zip(control_subgraphs.iter())
- .zip(typing.iter())
- {
- let Some(mut func) = func else {
- continue;
- };
- // changed |= loop_canonicalization(&mut func, control_subgraph, fork_join_map, loop_nest, typing);
- // func.modified();
- }
- pm.delete_gravestones();
- pm.clear_analyses();
- }
}
println!("Ran Pass: {:?}", pass);
--
GitLab
From 472bca07231c3178e3d181f19c0e3d5831aeb658 Mon Sep 17 00:00:00 2001
From: Russel Arbore <russel.jma@gmail.com>
Date: Thu, 30 Jan 2025 10:06:24 -0600
Subject: [PATCH 61/68] some cleanup
---
hercules_opt/src/editor.rs | 12 +--
hercules_opt/src/fork_transforms.rs | 8 +-
hercules_opt/src/forkify.rs | 91 +++++++++++--------
hercules_opt/src/ivar.rs | 6 +-
.../tests/fork_transform_tests.rs | 2 +-
juno_samples/matmul/src/main.rs | 9 +-
6 files changed, 73 insertions(+), 55 deletions(-)
diff --git a/hercules_opt/src/editor.rs b/hercules_opt/src/editor.rs
index f6a00c85..e6db7459 100644
--- a/hercules_opt/src/editor.rs
+++ b/hercules_opt/src/editor.rs
@@ -4,8 +4,6 @@ use std::collections::{BTreeMap, HashMap, HashSet};
use std::mem::take;
use std::ops::Deref;
-use nestify::nest;
-
use bitvec::prelude::*;
use either::Either;
@@ -156,10 +154,6 @@ impl<'a: 'b, 'b> FunctionEditor<'a> {
self.modified
}
- pub fn node(&self, node: impl Borrow<NodeID>) -> &Node {
- &self.function.nodes[node.borrow().idx()]
- }
-
pub fn edit<F>(&'b mut self, edit: F) -> bool
where
F: FnOnce(FunctionEdit<'a, 'b>) -> Result<FunctionEdit<'a, 'b>, FunctionEdit<'a, 'b>>,
@@ -342,6 +336,10 @@ impl<'a: 'b, 'b> FunctionEditor<'a> {
self.function_id
}
+ pub fn node(&self, node: impl Borrow<NodeID>) -> &Node {
+ &self.function.nodes[node.borrow().idx()]
+ }
+
pub fn get_types(&self) -> Ref<'_, Vec<Type>> {
self.types.borrow()
}
@@ -363,7 +361,7 @@ impl<'a: 'b, 'b> FunctionEditor<'a> {
.as_ref()
.into_iter()
.map(|x| *x)
- .collect::<Vec<_>>() // @(xrouth): wtf???
+ .collect::<Vec<_>>()
.into_iter()
}
diff --git a/hercules_opt/src/fork_transforms.rs b/hercules_opt/src/fork_transforms.rs
index edf26911..5a6d5ff2 100644
--- a/hercules_opt/src/fork_transforms.rs
+++ b/hercules_opt/src/fork_transforms.rs
@@ -107,7 +107,7 @@ pub fn find_reduce_dependencies<'a>(
})
.collect();
- ret_val
+ ret_val
}
pub fn copy_subgraph(
@@ -119,7 +119,7 @@ pub fn copy_subgraph(
Vec<(NodeID, NodeID)>,
) // returns all new nodes, a map from old nodes to new nodes, and
// a vec of pairs of nodes (old node, outside node) s.t old node -> outside node,
- // outside means not part of the original subgraph.
+ // outside means not part of the original subgraph.
{
let mut map: HashMap<NodeID, NodeID> = HashMap::new();
let mut new_nodes: HashSet<NodeID> = HashSet::new();
@@ -395,7 +395,7 @@ pub fn fork_coalesce(
});
let fork_joins: Vec<_> = fork_joins.collect();
- // FIXME: Add a postorder traversal to optimize this.
+ // FIXME: Add a postorder traversal to optimize this.
// FIXME: This could give us two forks that aren't actually ancestors / related, but then the helper will just return false early.
// something like: `fork_joins.postorder_iter().windows(2)` is ideal here.
@@ -486,7 +486,7 @@ pub fn fork_coalesce_helper(
return false;
}
- // Checklist:
+ // Checklist:
// Increment inner TIDs
// Add outer fork's dimension to front of inner fork.
// Fuse reductions
diff --git a/hercules_opt/src/forkify.rs b/hercules_opt/src/forkify.rs
index 10a8fe21..fd4fc838 100644
--- a/hercules_opt/src/forkify.rs
+++ b/hercules_opt/src/forkify.rs
@@ -241,35 +241,52 @@ pub fn forkify_loop(
return false;
}
- let phi_latches: Vec<_> = reductionable_phis.iter().map(|phi| {
- let LoopPHI::Reductionable { phi, data_cycle, continue_latch, is_associative } = phi else {unreachable!()};
- continue_latch
- }).collect();
+ let phi_latches: Vec<_> = reductionable_phis
+ .iter()
+ .map(|phi| {
+ let LoopPHI::Reductionable {
+ phi,
+ data_cycle,
+ continue_latch,
+ is_associative,
+ } = phi
+ else {
+ unreachable!()
+ };
+ continue_latch
+ })
+ .collect();
- let stop_on: HashSet<_> = editor.node_ids().filter(|node| {
- if editor.node(node).is_phi() {
- return true;
- }
- if editor.node(node).is_reduce() {
- return true;
- }
- if editor.node(node).is_control() {
- return true;
- }
- if phi_latches.contains(&node) {
- return true;
- }
+ let stop_on: HashSet<_> = editor
+ .node_ids()
+ .filter(|node| {
+ if editor.node(node).is_phi() {
+ return true;
+ }
+ if editor.node(node).is_reduce() {
+ return true;
+ }
+ if editor.node(node).is_control() {
+ return true;
+ }
+ if phi_latches.contains(&node) {
+ return true;
+ }
+
+ false
+ })
+ .collect();
- false
- }).collect();
-
-
// Outside loop users of IV, then exit;
- // Unless the outside user is through the loop latch of a reducing phi,
+ // Unless the outside user is through the loop latch of a reducing phi,
// then we know how to replace this edge, so its fine!
- let iv_users: Vec<_> = walk_all_users_stop_on(canonical_iv.phi(), editor, stop_on.clone()).collect();
-
- if iv_users.iter().any(|node| !loop_nodes.contains(&node) && *node != loop_if) {
+ let iv_users: Vec<_> =
+ walk_all_users_stop_on(canonical_iv.phi(), editor, stop_on.clone()).collect();
+
+ if iv_users
+ .iter()
+ .any(|node| !loop_nodes.contains(&node) && *node != loop_if)
+ {
return false;
}
@@ -429,9 +446,9 @@ impl LoopPHI {
/**
Checks some conditions on loop variables that will need to be converted into reductions to be forkified.
- - The phi is in a cycle *in the loop* with itself.
+ - The phi is in a cycle *in the loop* with itself.
- Every cycle *in the loop* containing the phi does not contain any other phi of the loop header.
- - The phi does not immediatley (not blocked by another phi or another reduce) use any other phis of the loop header.
+ - The phi does not immediatley (not blocked by another phi or another reduce) use any other phis of the loop header.
*/
pub fn analyze_phis<'a>(
editor: &'a FunctionEditor,
@@ -473,7 +490,7 @@ pub fn analyze_phis<'a>(
return false;
})
.collect();
-
+
let continue_idx = editor
.get_uses(natural_loop.header)
.position(|node| natural_loop.control[node.idx()])
@@ -512,10 +529,9 @@ pub fn analyze_phis<'a>(
return false;
})
.collect();
-
-
- let mut uses_for_dependance = walk_all_users_stop_on(loop_continue_latch, editor, other_stop_on);
+ let mut uses_for_dependance =
+ walk_all_users_stop_on(loop_continue_latch, editor, other_stop_on);
let set1: HashSet<_> = HashSet::from_iter(uses);
let set2: HashSet<_> = HashSet::from_iter(users);
@@ -526,19 +542,16 @@ pub fn analyze_phis<'a>(
// we use `phis` because this phi can actually contain the loop iv and its fine.
if uses_for_dependance.any(|node| phis.contains(&node) && node != *phi) {
LoopPHI::LoopDependant(*phi)
- }
- else if intersection.clone().iter().any(|node| true) {
-
-
+ } else if intersection.clone().iter().any(|node| true) {
// PHIs on the frontier of the uses by the candidate phi, i.e in uses_for_dependance need
// to have headers that postdominate the loop continue latch. The value of the PHI used needs to be defined
// by the time the reduce is triggered (at the end of the loop's internal control).
// No nodes in data cycles with this phi (in the loop) are used outside the loop, besides the loop_continue_latch.
- // If some other node in the cycle is used, there is not a valid node to assign it after making the cycle a reduce.
+ // If some other node in the cycle is used, there is not a valid node to assign it after making the cycle a reduce.
if intersection
.iter()
- .filter(|node| **node != loop_continue_latch )
+ .filter(|node| **node != loop_continue_latch)
.filter(|node| !(editor.node(*node).is_reduce() || editor.node(*node).is_phi()))
.any(|data_node| {
editor
@@ -553,8 +566,8 @@ pub fn analyze_phis<'a>(
return LoopPHI::LoopDependant(*phi);
}
- // FIXME: Do we want to calculate associativity here, there might be a case where this information is used in forkify
- // i.e as described above.
+ // FIXME: Do we want to calculate associativity here, there might be a case where this information is used in forkify
+ // i.e as described above.
let is_associative = false;
// No nodes in the data cycle are used outside of the loop, besides the latched value of the phi
diff --git a/hercules_opt/src/ivar.rs b/hercules_opt/src/ivar.rs
index 1f31e220..15f9416c 100644
--- a/hercules_opt/src/ivar.rs
+++ b/hercules_opt/src/ivar.rs
@@ -139,7 +139,11 @@ pub fn calculate_loop_nodes(editor: &FunctionEditor, natural_loop: &Loop) -> Has
})
.collect();
- all_users.intersection(&all_uses).chain(phis.iter()).cloned().collect()
+ all_users
+ .intersection(&all_uses)
+ .chain(phis.iter())
+ .cloned()
+ .collect()
}
/** returns PHIs that are on any regions inside the loop. */
diff --git a/hercules_test/hercules_tests/tests/fork_transform_tests.rs b/hercules_test/hercules_tests/tests/fork_transform_tests.rs
index 432fdda0..3799ca0a 100644
--- a/hercules_test/hercules_tests/tests/fork_transform_tests.rs
+++ b/hercules_test/hercules_tests/tests/fork_transform_tests.rs
@@ -18,7 +18,7 @@ fn fission_simple1() {
println!("result: {:?}", result_1);
let sched = Some(default_schedule![
- Verify, //Xdot,
+ Verify, //Xdot,
Unforkify, //Xdot,
DCE, Verify,
]);
diff --git a/juno_samples/matmul/src/main.rs b/juno_samples/matmul/src/main.rs
index fa5d1f04..624ee565 100644
--- a/juno_samples/matmul/src/main.rs
+++ b/juno_samples/matmul/src/main.rs
@@ -24,10 +24,14 @@ fn main() {
let a = HerculesCPURef::from_slice(&a);
let b = HerculesCPURef::from_slice(&b);
let mut r = runner!(matmul);
- let c = r.run(I as u64, J as u64, K as u64, a.clone(), b.clone()).await;
+ let c = r
+ .run(I as u64, J as u64, K as u64, a.clone(), b.clone())
+ .await;
assert_eq!(c.as_slice::<i32>(), &*correct_c);
let mut r = runner!(tiled_64_matmul);
- let tiled_c = r.run(I as u64, J as u64, K as u64, a.clone(), b.clone()).await;
+ let tiled_c = r
+ .run(I as u64, J as u64, K as u64, a.clone(), b.clone())
+ .await;
assert_eq!(tiled_c.as_slice::<i32>(), &*correct_c);
});
}
@@ -36,4 +40,3 @@ fn main() {
fn matmul_test() {
main();
}
-
--
GitLab
From c63b72a64691c606d9a09503b9b39e2cc3e6fded Mon Sep 17 00:00:00 2001
From: Russel Arbore <russel.jma@gmail.com>
Date: Thu, 30 Jan 2025 10:20:05 -0600
Subject: [PATCH 62/68] cleanup fork_guard_elim
---
hercules_opt/src/fork_concat_split.rs | 3 +-
hercules_opt/src/fork_guard_elim.rs | 53 +++++++++++----------------
2 files changed, 24 insertions(+), 32 deletions(-)
diff --git a/hercules_opt/src/fork_concat_split.rs b/hercules_opt/src/fork_concat_split.rs
index 1339a384..bb3a2cff 100644
--- a/hercules_opt/src/fork_concat_split.rs
+++ b/hercules_opt/src/fork_concat_split.rs
@@ -7,7 +7,8 @@ use crate::*;
/*
* Split multi-dimensional fork-joins into separate one-dimensional fork-joins.
- * Useful for code generation.
+ * Useful for code generation. A single iteration of `fork_split` only splits
+ * at most one fork-join, it must be called repeatedly to split all fork-joins.
*/
pub fn fork_split(
editor: &mut FunctionEditor,
diff --git a/hercules_opt/src/fork_guard_elim.rs b/hercules_opt/src/fork_guard_elim.rs
index 435e63b6..9384a8c1 100644
--- a/hercules_opt/src/fork_guard_elim.rs
+++ b/hercules_opt/src/fork_guard_elim.rs
@@ -1,11 +1,10 @@
use std::collections::{HashMap, HashSet};
use either::Either;
-use hercules_ir::get_uses_mut;
-use hercules_ir::ir::*;
-use hercules_ir::ImmutableDefUseMap;
-use crate::FunctionEditor;
+use hercules_ir::*;
+
+use crate::*;
/*
* This is a Hercules IR transformation that:
@@ -20,20 +19,6 @@ use crate::FunctionEditor;
* guard remains and in these cases the guard is no longer needed.
*/
-/* Given a node index and the node itself, return None if the node is not
- * a guarded fork where we can eliminate the guard.
- * If the node is a fork with a guard we can eliminate returns a tuple of
- * - This node's NodeID
- * - The replication factor of the fork
- * - The ID of the if of the guard
- * - The ID of the projections of the if
- * - The guard's predecessor
- * - A map of NodeIDs for the phi nodes to the reduce they should be replaced
- * with, and also the region that joins the guard's branches mapping to the
- * fork's join NodeID
- * - If the replication factor is a max that can be eliminated.
- */
-
// Simplify factors through max
enum Factor {
Max(usize, DynamicConstantID),
@@ -61,6 +46,19 @@ struct GuardedFork {
factor: Factor, // The factor that matches the guard
}
+/* Given a node index and the node itself, return None if the node is not
+ * a guarded fork where we can eliminate the guard.
+ * If the node is a fork with a guard we can eliminate returns a tuple of
+ * - This node's NodeID
+ * - The replication factor of the fork
+ * - The ID of the if of the guard
+ * - The ID of the projections of the if
+ * - The guard's predecessor
+ * - A map of NodeIDs for the phi nodes to the reduce they should be replaced
+ * with, and also the region that joins the guard's branches mapping to the
+ * fork's join NodeID
+ * - If the replication factor is a max that can be eliminated.
+ */
fn guarded_fork(
editor: &mut FunctionEditor,
fork_join_map: &HashMap<NodeID, NodeID>,
@@ -73,8 +71,7 @@ fn guarded_fork(
return None;
};
- let factors = factors.iter().enumerate().map(|(idx, dc)| {
- // FIXME: Can we hide .idx() in an impl Index or something so we don't index Vec<Nodes> iwht DynamicConstantId.idx()
+ let mut factors = factors.iter().enumerate().map(|(idx, dc)| {
let DynamicConstant::Max(l, r) = *editor.get_dynamic_constant(*dc) else {
return Factor::Normal(idx, *dc);
};
@@ -140,24 +137,22 @@ fn guarded_fork(
}
// Match Factor
- let factor = factors.clone().find(|factor| {
- // This clone on the dc is painful.
+ let factor = factors.find(|factor| {
match (
&function.nodes[pattern_factor.idx()],
- editor.get_dynamic_constant(factor.get_id()).clone(),
+ &*editor.get_dynamic_constant(factor.get_id()),
) {
(Node::Constant { id }, DynamicConstant::Constant(v)) => {
let Constant::UnsignedInteger64(pattern_v) = *editor.get_constant(*id)
else {
return false;
};
- pattern_v == (v as u64)
+ pattern_v == (*v as u64)
}
(Node::DynamicConstant { id }, _) => *id == factor.get_id(),
_ => false,
}
});
- // return Factor
factor
})
}
@@ -184,12 +179,10 @@ fn guarded_fork(
}
// Match Factor
- // FIXME: Implement dc / constant matching as in case where branch_idx == 1
- let factor = factors.clone().find(|factor| {
+ let factor = factors.find(|factor| {
function.nodes[pattern_factor.idx()].try_dynamic_constant()
== Some(factor.get_id())
});
- // return Factor
factor
})
} else {
@@ -229,7 +222,7 @@ fn guarded_fork(
} else {
return None;
};
- // Other predecessor needs to be the other read from the guard's if
+ // Other predecessor needs to be the other projection from the guard's if
let Node::Projection {
control: if_node2,
ref selection,
@@ -317,8 +310,6 @@ fn guarded_fork(
/*
* Top level function to run fork guard elimination, as described above.
- * Deletes nodes by setting nodes to gravestones. Works with a function already
- * containing gravestones.
*/
pub fn fork_guard_elim(editor: &mut FunctionEditor, fork_join_map: &HashMap<NodeID, NodeID>) {
let guard_info = editor
--
GitLab
From 09fda4a82daa0ea864a5298cc1b0c348c6365b7b Mon Sep 17 00:00:00 2001
From: Russel Arbore <russel.jma@gmail.com>
Date: Thu, 30 Jan 2025 10:38:10 -0600
Subject: [PATCH 63/68] fix a bunch of warnings
---
hercules_opt/src/fork_guard_elim.rs | 8 +--
hercules_opt/src/fork_transforms.rs | 2 +-
hercules_opt/src/forkify.rs | 47 ++++--------
hercules_opt/src/gcm.rs | 4 +-
hercules_opt/src/ivar.rs | 72 +++++++++----------
hercules_opt/src/unforkify.rs | 11 ++-
hercules_opt/src/utils.rs | 3 +-
.../hercules_interpreter/src/interpreter.rs | 42 ++---------
hercules_test/hercules_interpreter/src/lib.rs | 11 +--
9 files changed, 71 insertions(+), 129 deletions(-)
diff --git a/hercules_opt/src/fork_guard_elim.rs b/hercules_opt/src/fork_guard_elim.rs
index 9384a8c1..a375f809 100644
--- a/hercules_opt/src/fork_guard_elim.rs
+++ b/hercules_opt/src/fork_guard_elim.rs
@@ -22,14 +22,14 @@ use crate::*;
// Simplify factors through max
enum Factor {
Max(usize, DynamicConstantID),
- Normal(usize, DynamicConstantID),
+ Normal(DynamicConstantID),
}
impl Factor {
fn get_id(&self) -> DynamicConstantID {
match self {
Factor::Max(_, dynamic_constant_id) => *dynamic_constant_id,
- Factor::Normal(_, dynamic_constant_id) => *dynamic_constant_id,
+ Factor::Normal(dynamic_constant_id) => *dynamic_constant_id,
}
}
}
@@ -73,7 +73,7 @@ fn guarded_fork(
let mut factors = factors.iter().enumerate().map(|(idx, dc)| {
let DynamicConstant::Max(l, r) = *editor.get_dynamic_constant(*dc) else {
- return Factor::Normal(idx, *dc);
+ return Factor::Normal(*dc);
};
// There really needs to be a better way to work w/ associativity.
@@ -87,7 +87,7 @@ fn guarded_fork(
match id {
Some(v) => Factor::Max(idx, *v),
- None => Factor::Normal(idx, *dc),
+ None => Factor::Normal(*dc),
}
});
diff --git a/hercules_opt/src/fork_transforms.rs b/hercules_opt/src/fork_transforms.rs
index 5a6d5ff2..b45de643 100644
--- a/hercules_opt/src/fork_transforms.rs
+++ b/hercules_opt/src/fork_transforms.rs
@@ -225,7 +225,7 @@ pub fn fork_bufferize_fission_helper<'a>(
editor.edit(|mut edit| {
new_join_id = edit.add_node(Node::Join { control: fork });
- let factors = edit.get_node(fork).try_fork().unwrap().1.clone();
+ let factors = edit.get_node(fork).try_fork().unwrap().1;
new_fork_id = edit.add_node(Node::Fork {
control: new_join_id,
factors: factors.into(),
diff --git a/hercules_opt/src/forkify.rs b/hercules_opt/src/forkify.rs
index fd4fc838..d99c15d7 100644
--- a/hercules_opt/src/forkify.rs
+++ b/hercules_opt/src/forkify.rs
@@ -101,23 +101,6 @@ pub fn get_node_as_dc(
}
}
-fn all_same_variant<I, T>(mut iter: I) -> bool
-where
- I: Iterator<Item = T>,
-{
- // Empty iterator case - return true
- let first = match iter.next() {
- None => return true,
- Some(val) => val,
- };
-
- // Get discriminant of first item
- let first_discriminant = std::mem::discriminant(&first);
-
- // Check all remaining items have same discriminant
- iter.all(|x| std::mem::discriminant(&x) == first_discriminant)
-}
-
/**
Top level function to convert natural loops with simple induction variables
into fork-joins.
@@ -125,7 +108,7 @@ where
pub fn forkify_loop(
editor: &mut FunctionEditor,
control_subgraph: &Subgraph,
- fork_join_map: &HashMap<NodeID, NodeID>,
+ _fork_join_map: &HashMap<NodeID, NodeID>,
l: &Loop,
) -> bool {
let function = editor.func();
@@ -155,14 +138,14 @@ pub fn forkify_loop(
// Get bound
let bound = match canonical_iv {
InductionVariable::Basic {
- node,
- initializer,
- update,
+ node: _,
+ initializer: _,
+ update: _,
final_value,
} => final_value
.map(|final_value| get_node_as_dc(editor, final_value))
.and_then(|r| r.ok()),
- InductionVariable::SCEV(node_id) => return false,
+ InductionVariable::SCEV(_) => return false,
};
let Some(bound_dc_id) = bound else {
@@ -219,8 +202,6 @@ pub fn forkify_loop(
.into_iter()
.collect();
- let function = editor.func();
-
// TODO: Handle multiple loop body lasts.
// If there are multiple candidates for loop body last, return false.
if editor
@@ -245,10 +226,10 @@ pub fn forkify_loop(
.iter()
.map(|phi| {
let LoopPHI::Reductionable {
- phi,
- data_cycle,
+ phi: _,
+ data_cycle: _,
continue_latch,
- is_associative,
+ is_associative: _,
} = phi
else {
unreachable!()
@@ -362,9 +343,9 @@ pub fn forkify_loop(
for reduction_phi in reductionable_phis {
let LoopPHI::Reductionable {
phi,
- data_cycle,
+ data_cycle: _,
continue_latch,
- is_associative,
+ is_associative: _,
} = reduction_phi
else {
panic!();
@@ -398,11 +379,11 @@ pub fn forkify_loop(
}
// Replace all uses of the loop header with the fork
- editor.edit(|mut edit| edit.replace_all_uses(l.header, fork_id));
+ editor.edit(|edit| edit.replace_all_uses(l.header, fork_id));
- editor.edit(|mut edit| edit.replace_all_uses(loop_continue_projection, fork_id));
+ editor.edit(|edit| edit.replace_all_uses(loop_continue_projection, fork_id));
- editor.edit(|mut edit| edit.replace_all_uses(loop_exit_projection, join_id));
+ editor.edit(|edit| edit.replace_all_uses(loop_exit_projection, join_id));
// Get rid of loop condition
// DCE should get these, but delete them ourselves because we are nice :)
@@ -436,7 +417,7 @@ impl LoopPHI {
pub fn get_phi(&self) -> NodeID {
match self {
LoopPHI::Reductionable {
- phi, data_cycle, ..
+ phi, ..
} => *phi,
LoopPHI::LoopDependant(node_id) => *node_id,
LoopPHI::UsedByDependant(node_id) => *node_id,
diff --git a/hercules_opt/src/gcm.rs b/hercules_opt/src/gcm.rs
index 0c7665bf..f919acc7 100644
--- a/hercules_opt/src/gcm.rs
+++ b/hercules_opt/src/gcm.rs
@@ -1022,7 +1022,7 @@ fn liveness_dataflow(
* device clones when a single node may potentially be on different devices.
*/
fn color_nodes(
- editor: &mut FunctionEditor,
+ _editor: &mut FunctionEditor,
reverse_postorder: &Vec<NodeID>,
objects: &FunctionCollectionObjects,
object_device_demands: &FunctionObjectDeviceDemands,
@@ -1138,7 +1138,7 @@ fn object_allocation(
typing: &Vec<TypeID>,
node_colors: &FunctionNodeColors,
alignments: &Vec<usize>,
- liveness: &Liveness,
+ _liveness: &Liveness,
backing_allocations: &BackingAllocations,
) -> FunctionBackingAllocation {
let mut fba = BTreeMap::new();
diff --git a/hercules_opt/src/ivar.rs b/hercules_opt/src/ivar.rs
index 15f9416c..929f3a40 100644
--- a/hercules_opt/src/ivar.rs
+++ b/hercules_opt/src/ivar.rs
@@ -67,9 +67,9 @@ impl InductionVariable {
match self {
InductionVariable::Basic {
node,
- initializer,
- update,
- final_value,
+ initializer: _,
+ update: _,
+ final_value: _,
} => *node,
InductionVariable::SCEV(_) => todo!(),
}
@@ -85,7 +85,7 @@ pub fn calculate_loop_nodes(editor: &FunctionEditor, natural_loop: &Loop) -> Has
let data = &editor.func().nodes[node.idx()];
// External Phi
- if let Node::Phi { control, data } = data {
+ if let Node::Phi { control, data: _ } = data {
if !natural_loop.control[control.idx()] {
return true;
}
@@ -93,8 +93,8 @@ pub fn calculate_loop_nodes(editor: &FunctionEditor, natural_loop: &Loop) -> Has
// External Reduce
if let Node::Reduce {
control,
- init,
- reduct,
+ init: _,
+ reduct: _,
} = data
{
if !natural_loop.control[control.idx()] {
@@ -114,7 +114,7 @@ pub fn calculate_loop_nodes(editor: &FunctionEditor, natural_loop: &Loop) -> Has
let phis: Vec<_> = editor
.node_ids()
.filter(|node| {
- let Node::Phi { control, ref data } = editor.func().nodes[node.idx()] else {
+ let Node::Phi { control, data: _ } = editor.func().nodes[node.idx()] else {
return false;
};
natural_loop.control[control.idx()]
@@ -214,7 +214,7 @@ pub fn compute_loop_variance(editor: &FunctionEditor, l: &Loop) -> LoopVarianceI
// Two conditions cause something to be loop variant:
for node_use in get_uses(&function.nodes[node.idx()]).as_ref() {
// 1) The use is a PHI *controlled* by the loop
- if let Some((control, data)) = function.nodes[node_use.idx()].try_phi() {
+ if let Some((control, _)) = function.nodes[node_use.idx()].try_phi() {
if *all_loop_nodes.get(control.idx()).unwrap() {
node_variance = LoopVariance::Variant;
break;
@@ -325,7 +325,7 @@ pub fn get_loop_exit_conditions(
pub fn has_const_fields(editor: &FunctionEditor, ivar: InductionVariable) -> bool {
match ivar {
InductionVariable::Basic {
- node,
+ node: _,
initializer,
update,
final_value,
@@ -337,7 +337,7 @@ pub fn has_const_fields(editor: &FunctionEditor, ivar: InductionVariable) -> boo
.iter()
.any(|node| !editor.node(node).is_constant())
}
- InductionVariable::SCEV(node_id) => false,
+ InductionVariable::SCEV(_) => false,
}
}
@@ -345,12 +345,12 @@ pub fn has_const_fields(editor: &FunctionEditor, ivar: InductionVariable) -> boo
// IVs need to be bounded...
pub fn has_canonical_iv<'a>(
editor: &FunctionEditor,
- l: &Loop,
+ _l: &Loop,
ivs: &'a [InductionVariable],
) -> Option<&'a InductionVariable> {
ivs.iter().find(|iv| match iv {
InductionVariable::Basic {
- node,
+ node: _,
initializer,
update,
final_value,
@@ -371,7 +371,7 @@ pub fn has_canonical_iv<'a>(
})
.is_some())
}
- InductionVariable::SCEV(node_id) => false,
+ InductionVariable::SCEV(_) => false,
})
}
@@ -379,7 +379,7 @@ pub fn has_canonical_iv<'a>(
pub fn compute_induction_vars(
function: &Function,
l: &Loop,
- loop_variance: &LoopVarianceInfo,
+ _loop_variance: &LoopVarianceInfo,
) -> Vec<InductionVariable> {
// 1) Gather PHIs contained in the loop.
// FIXME: (@xrouth) Should this just be PHIs controlled by the header?
@@ -478,12 +478,12 @@ pub fn compute_iv_ranges(
induction_vars: Vec<InductionVariable>,
loop_condition: &LoopExit,
) -> Vec<InductionVariable> {
- let (if_node, condition_node) = match loop_condition {
+ let condition_node = match loop_condition {
LoopExit::Conditional {
- if_node,
+ if_node: _,
condition_node,
- } => (if_node, condition_node),
- LoopExit::Unconditional(node_id) => todo!(),
+ } => condition_node,
+ LoopExit::Unconditional(_) => todo!(),
};
// Find IVs used by the loop condition, not across loop iterations.
@@ -491,7 +491,7 @@ pub fn compute_iv_ranges(
let stop_on: HashSet<_> = editor
.node_ids()
.filter(|node_id| {
- if let Node::Phi { control, data } = editor.node(node_id) {
+ if let Node::Phi { control, data: _ } = editor.node(node_id) {
*control == l.header
} else {
false
@@ -517,20 +517,20 @@ pub fn compute_iv_ranges(
// FIXME: DO linear algerbra to solve for loop bounds with multiple variables involved.
let final_value = match &editor.func().nodes[condition_node.idx()] {
- Node::Phi { control, data } => None,
+ Node::Phi { control: _, data: _ } => None,
Node::Reduce {
- control,
- init,
- reduct,
+ control: _,
+ init: _,
+ reduct: _,
} => None,
- Node::Parameter { index } => None,
- Node::Constant { id } => None,
- Node::Unary { input, op } => None,
+ Node::Parameter { index: _ } => None,
+ Node::Constant { id: _ } => None,
+ Node::Unary { input: _, op: _ } => None,
Node::Ternary {
- first,
- second,
- third,
- op,
+ first: _,
+ second: _,
+ third: _,
+ op: _,
} => None,
Node::Binary { left, right, op } => {
match op {
@@ -547,7 +547,7 @@ pub fn compute_iv_ranges(
else if let Node::Binary {
left: inner_left,
right: inner_right,
- op: inner_op,
+ op: _,
} = editor.node(left)
{
let pattern = [(inner_left, inner_right), (inner_right, inner_left)]
@@ -560,12 +560,12 @@ pub fn compute_iv_ranges(
// FIXME: pattern_constant can be anything >= loop_update expression,
let update = match iv {
InductionVariable::Basic {
- node,
- initializer,
+ node: _,
+ initializer: _,
update,
- final_value,
+ final_value: _,
} => update,
- InductionVariable::SCEV(node_id) => todo!(),
+ InductionVariable::SCEV(_) => todo!(),
};
if *pattern_constant == update {
Some(*right)
@@ -604,7 +604,7 @@ pub fn compute_iv_ranges(
update: *update,
final_value,
},
- InductionVariable::SCEV(node_id) => todo!(),
+ InductionVariable::SCEV(_) => todo!(),
};
// Propagate bounds to other IVs.
diff --git a/hercules_opt/src/unforkify.rs b/hercules_opt/src/unforkify.rs
index 0efd0b85..85ffd233 100644
--- a/hercules_opt/src/unforkify.rs
+++ b/hercules_opt/src/unforkify.rs
@@ -11,7 +11,6 @@ pub fn calculate_fork_nodes(
editor: &FunctionEditor,
inner_control: &NodeVec,
fork: NodeID,
- join: NodeID,
) -> HashSet<NodeID> {
// Stop on PHIs / reduces outside of loop.
let stop_on: HashSet<NodeID> = editor
@@ -20,7 +19,7 @@ pub fn calculate_fork_nodes(
let data = &editor.func().nodes[node.idx()];
// External Phi
- if let Node::Phi { control, data } = data {
+ if let Node::Phi { control, data: _ } = data {
if match inner_control.get(control.idx()) {
Some(v) => !*v, //
None => true, // Doesn't exist, must be external
@@ -31,8 +30,8 @@ pub fn calculate_fork_nodes(
// External Reduce
if let Node::Reduce {
control,
- init,
- reduct,
+ init: _,
+ reduct: _,
} = data
{
if match inner_control.get(control.idx()) {
@@ -127,7 +126,7 @@ pub fn unforkify(
let fork = &l.0;
let join = &fork_join_map[&fork];
- let fork_nodes = calculate_fork_nodes(editor, l.1, *fork, *join);
+ let fork_nodes = calculate_fork_nodes(editor, l.1, *fork);
let nodes = &editor.func().nodes;
let (fork_control, factors) = nodes[fork.idx()].try_fork().unwrap();
@@ -274,7 +273,7 @@ pub fn unforkify(
zip(reduces.iter(), phi_ids).zip(phis).zip(join_phi_ids)
{
edit.sub_edit(*reduce, phi_id);
- let Node::Phi { control, data } = phi else {
+ let Node::Phi { control: _, data } = phi else {
panic!()
};
edit = edit.replace_all_uses_where(*reduce, join_phi_id, |usee| {
diff --git a/hercules_opt/src/utils.rs b/hercules_opt/src/utils.rs
index cc7abc7f..7ad48c1c 100644
--- a/hercules_opt/src/utils.rs
+++ b/hercules_opt/src/utils.rs
@@ -384,13 +384,12 @@ pub type DenseNodeMap<T> = Vec<T>;
pub type SparseNodeMap<T> = HashMap<NodeID, T>;
nest! {
-// Is this something editor should give... Or is it just for analyses.
//
#[derive(Clone, Debug)]
pub struct NodeIterator<'a> {
pub direction:
#[derive(Clone, Debug, PartialEq)]
- enum Direction {
+ pub enum Direction {
Uses,
Users,
},
diff --git a/hercules_test/hercules_interpreter/src/interpreter.rs b/hercules_test/hercules_interpreter/src/interpreter.rs
index 730f6216..a78330e4 100644
--- a/hercules_test/hercules_interpreter/src/interpreter.rs
+++ b/hercules_test/hercules_interpreter/src/interpreter.rs
@@ -253,8 +253,6 @@ impl<'a> FunctionExecutionState<'a> {
}
let thread_values = self.get_thread_factors(&token, join);
- // println!("join for: {:?}", token);
- // dbg!(thread_values.clone());
// This and_modify doesn't do aynthing??
self.join_counters
.entry((thread_values.clone(), join))
@@ -365,8 +363,6 @@ impl<'a> FunctionExecutionState<'a> {
}
pub fn handle_data(&mut self, token: &ControlToken, node: NodeID) -> InterpreterVal {
- // println!("Data Node: {} {:?}", node.idx(), &self.get_function().nodes[node.idx()]);
-
// Partial borrow complaint. :/
match &self.module.functions[self.function_id.idx()].nodes[node.idx()] {
Node::Phi {
@@ -386,14 +382,6 @@ impl<'a> FunctionExecutionState<'a> {
.expect("PANIC: No nesting information for thread index!")
.clone();
- let num_dims_this_level = (self.get_function().nodes
- [nested_forks.first().unwrap().idx()]
- .try_fork()
- .unwrap()
- .1
- .len());
- // println!("num forks this level:{:?} ", num_forks_this_level);
-
// Skip forks until we get to this level.
// How many forks are outer? idfk.
let outer_forks: Vec<NodeID> = nested_forks
@@ -402,8 +390,6 @@ impl<'a> FunctionExecutionState<'a> {
.take_while(|fork| *fork != node)
.collect();
- // println!("otuer_forkes: {:?}", outer_forks);
-
let fork_levels: usize = outer_forks
.iter()
.skip(1)
@@ -416,9 +402,7 @@ impl<'a> FunctionExecutionState<'a> {
})
.sum();
- // println!("nested forks:{:?} ", nested_forks);
- // println!("fork levels: {:?}", fork_levels);
- // dimension might need to instead be dimensions - dimension
+ // Dimension might need to instead be dimensions - dimension
let v = token.thread_indicies[fork_levels + dimension]; // Might have to -1?
if VERBOSE {
println!(
@@ -432,12 +416,11 @@ impl<'a> FunctionExecutionState<'a> {
// This probably isn't the exact condition, but somethign similar. Anyways, we achieve correctness by iterating control nodes recursively.
Node::Reduce {
control,
- init,
+ init: _,
reduct: _,
} => {
let thread_values = self.get_thread_factors(token, *control);
- // println!("reduction read: {:?}, {:?}", thread_values, node);
let entry = self.reduce_values.entry((thread_values.clone(), node));
let val = match entry {
@@ -447,7 +430,6 @@ impl<'a> FunctionExecutionState<'a> {
token, node, thread_values
),
};
- // println!("value: {:?}", val.clone());
val
}
Node::Parameter { index } => self.args[*index].clone(),
@@ -502,12 +484,11 @@ impl<'a> FunctionExecutionState<'a> {
}
}
Node::Call {
+ control: _,
function,
dynamic_constants,
args,
- control,
} => {
- // todo!("call currently dissabled lol");
let args = args
.into_iter()
.map(|arg_node| self.handle_data(token, *arg_node))
@@ -536,7 +517,7 @@ impl<'a> FunctionExecutionState<'a> {
}
Node::Read { collect, indices } => {
let collection = self.handle_data(token, *collect);
- if let InterpreterVal::Undef(v) = collection {
+ if let InterpreterVal::Undef(_) = collection {
collection
} else {
let result = self.handle_read(token, collection.clone(), indices);
@@ -556,7 +537,7 @@ impl<'a> FunctionExecutionState<'a> {
indices,
} => {
let collection = self.handle_data(token, *collect);
- if let InterpreterVal::Undef(v) = collection {
+ if let InterpreterVal::Undef(_) = collection {
collection
} else {
let data = self.handle_data(token, *data);
@@ -610,7 +591,6 @@ impl<'a> FunctionExecutionState<'a> {
})
.collect();
let idx = InterpreterVal::array_idx(&extents, &array_indices);
- //println!("idx: {:?}", idx);
if idx >= vals.len() {
InterpreterVal::Undef(type_id)
} else {
@@ -702,12 +682,6 @@ impl<'a> FunctionExecutionState<'a> {
.pop()
.expect("PANIC: Interpreter ran out of control tokens without returning.");
- // println!(
- // "\n\nNew Token at: Control State: {} threads: {:?}, {:?}",
- // ctrl_token.curr.idx(),
- // ctrl_token.thread_indicies.clone(),
- // &self.get_function().nodes[ctrl_token.curr.idx()]
- // );
// TODO: (@xrouth): Enable this + PHI latch logging wi/ a simple debug flag.
// Tracking PHI vals and control state is very useful for debugging.
@@ -747,7 +721,7 @@ impl<'a> FunctionExecutionState<'a> {
// Convert condition to usize
let cond: usize = match cond {
InterpreterVal::Boolean(v) => v.into(),
- InterpreterVal::Undef(v) => panic!("PANIC: Undef reached IF"),
+ InterpreterVal::Undef(_) => panic!("PANIC: Undef reached IF"),
_ => panic!("PANIC: Invalid condition for IF, please typecheck."),
};
@@ -820,7 +794,7 @@ impl<'a> FunctionExecutionState<'a> {
let mut temp = i;
let mut new_token = ctrl_token.clone(); // Copy map, curr, prev, etc.
- for (j, dim) in factors.clone().enumerate().rev() {
+ for (_, dim) in factors.clone().enumerate().rev() {
new_token.thread_indicies.insert(num_outer_dims, temp % dim); // Stack of thread indicies
temp /= dim;
}
@@ -854,7 +828,6 @@ impl<'a> FunctionExecutionState<'a> {
self.initialize_reduction(&ctrl_token, reduction);
}
- // println!("tokens_to_add: {:?}", tokens_to_add);
if VERBOSE {
println!(
"tf, fork, join, n_tokens: {:?}, {:?}, {:?}, {:?}",
@@ -878,7 +851,6 @@ impl<'a> FunctionExecutionState<'a> {
}
Node::Return { control: _, data } => {
let result = self.handle_data(&ctrl_token, *data);
- // println!("result = {:?}", result);
break 'outer result;
}
_ => {
diff --git a/hercules_test/hercules_interpreter/src/lib.rs b/hercules_test/hercules_interpreter/src/lib.rs
index 3f12618c..75a974ec 100644
--- a/hercules_test/hercules_interpreter/src/lib.rs
+++ b/hercules_test/hercules_interpreter/src/lib.rs
@@ -8,7 +8,6 @@ use hercules_ir::Module;
use hercules_ir::TypeID;
use hercules_ir::ID;
-use juno_scheduler::run_schedule_on_hercules;
pub use juno_scheduler::PassManager;
pub use crate::interpreter::*;
@@ -37,10 +36,9 @@ pub fn into_interp_val(
InterpreterWrapper::Array(array) => {
let ty = &module.types[target_ty_id.idx()];
- let ele_type = ty
+ ty
.try_element_type()
.expect("PANIC: Invalid parameter type");
- // unwrap -> map to rust type, check
let mut values = vec![];
@@ -53,13 +51,6 @@ pub fn into_interp_val(
}
}
-pub fn array_from_interp_val<T: Clone>(module: &Module, interp_val: InterpreterVal) -> Vec<T>
-where
- value::InterpreterVal: Into<T>,
-{
- vec![]
-}
-
// Recursively turns rt args into interpreter wrappers.
#[macro_export]
macro_rules! parse_rt_args {
--
GitLab
From 5943607abc8b460c0b9140296a4e365f7d935579 Mon Sep 17 00:00:00 2001
From: Russel Arbore <russel.jma@gmail.com>
Date: Thu, 30 Jan 2025 10:42:35 -0600
Subject: [PATCH 64/68] more warning fixes
---
hercules_opt/src/fork_guard_elim.rs | 2 +-
hercules_opt/src/fork_transforms.rs | 40 ++++++++-----------
hercules_opt/src/forkify.rs | 4 +-
hercules_opt/src/ivar.rs | 17 ++------
hercules_test/hercules_interpreter/src/lib.rs | 3 +-
.../hercules_interpreter/src/value.rs | 2 +-
6 files changed, 24 insertions(+), 44 deletions(-)
diff --git a/hercules_opt/src/fork_guard_elim.rs b/hercules_opt/src/fork_guard_elim.rs
index a375f809..319d32b8 100644
--- a/hercules_opt/src/fork_guard_elim.rs
+++ b/hercules_opt/src/fork_guard_elim.rs
@@ -331,7 +331,7 @@ pub fn fork_guard_elim(editor: &mut FunctionEditor, fork_join_map: &HashMap<Node
{
let new_fork_info = if let Factor::Max(idx, dc) = factor {
let Node::Fork {
- control,
+ control: _,
mut factors,
} = editor.func().nodes[fork.idx()].clone()
else {
diff --git a/hercules_opt/src/fork_transforms.rs b/hercules_opt/src/fork_transforms.rs
index b45de643..8b2c6327 100644
--- a/hercules_opt/src/fork_transforms.rs
+++ b/hercules_opt/src/fork_transforms.rs
@@ -26,7 +26,7 @@ type ForkID = usize;
/** Places each reduce node into its own fork */
pub fn default_reduce_partition(
editor: &FunctionEditor,
- fork: NodeID,
+ _fork: NodeID,
join: NodeID,
) -> SparseNodeMap<ForkID> {
let mut map = SparseNodeMap::new();
@@ -158,9 +158,9 @@ pub fn copy_subgraph(
pub fn fork_fission<'a>(
editor: &'a mut FunctionEditor,
- control_subgraph: &Subgraph,
- types: &Vec<TypeID>,
- loop_tree: &LoopTree,
+ _control_subgraph: &Subgraph,
+ _types: &Vec<TypeID>,
+ _loop_tree: &LoopTree,
fork_join_map: &HashMap<NodeID, NodeID>,
) -> () {
let forks: Vec<_> = editor
@@ -177,7 +177,7 @@ pub fn fork_fission<'a>(
})
.collect();
- let mut control_pred = NodeID::new(0);
+ let control_pred = NodeID::new(0);
// This does the reduction fission:
for fork in forks.clone() {
@@ -190,10 +190,7 @@ pub fn fork_fission<'a>(
// inner control in general *should* work right now without modifications.
}
let reduce_partition = default_reduce_partition(editor, fork, join);
-
- let (new_fork, new_join) =
- fork_reduce_fission_helper(editor, fork_join_map, reduce_partition, control_pred, fork);
- // control_pred = new_join;
+ fork_reduce_fission_helper(editor, fork_join_map, reduce_partition, control_pred, fork);
}
}
@@ -202,7 +199,7 @@ pub fn fork_bufferize_fission_helper<'a>(
editor: &'a mut FunctionEditor,
fork_join_map: &HashMap<NodeID, NodeID>,
bufferized_edges: HashSet<(NodeID, NodeID)>, // Describes what intermediate data should be bufferized.
- original_control_pred: NodeID, // What the new fork connects to.
+ _original_control_pred: NodeID, // What the new fork connects to.
types: &Vec<TypeID>,
fork: NodeID,
) -> (NodeID, NodeID) {
@@ -248,14 +245,14 @@ pub fn fork_bufferize_fission_helper<'a>(
let thread_stuff_it = factors.into_iter().enumerate();
// FIxme: try to use unzip here? Idk why it wasn't working.
- let (tids) = thread_stuff_it.clone().map(|(dim, factor)| {
+ let (tids) = thread_stuff_it.clone().map(|(dim, _)| {
(edit.add_node(Node::ThreadID {
control: fork,
dimension: dim,
}))
});
- let array_dims = thread_stuff_it.clone().map(|(dim, factor)| (factor));
+ let array_dims = thread_stuff_it.clone().map(|(_, factor)| (factor));
// Assume 1-d fork only for now.
// let tid = edit.add_node(Node::ThreadID { control: fork, dimension: 0 });
@@ -282,7 +279,7 @@ pub fn fork_bufferize_fission_helper<'a>(
edit = edit.replace_all_uses_where(NodeID::new(0), reduce, |usee| *usee == write)?;
// Create read from buffer
- let (tids) = thread_stuff_it.clone().map(|(dim, factor)| {
+ let (tids) = thread_stuff_it.clone().map(|(dim, _)| {
(edit.add_node(Node::ThreadID {
control: new_fork_id,
dimension: dim,
@@ -341,19 +338,14 @@ pub fn fork_reduce_fission_helper<'a>(
subgraph.insert(fork);
subgraph.insert(reduce);
- // println!("subgraph for {:?}: \n{:?}", reduce, subgraph);
-
- let (new_nodes, mapping, _) = copy_subgraph(editor, subgraph);
-
- // println!("new_nodes: {:?} ", new_nodes);
- // println!("mapping: {:?} ",mapping);
+ let (_, mapping, _) = copy_subgraph(editor, subgraph);
new_fork = mapping[&fork];
new_join = mapping[&join];
editor.edit(|mut edit| {
// Atttach new_fork after control_pred
- let (old_control_pred, factors) = edit.get_node(new_fork).try_fork().unwrap().clone();
+ let (old_control_pred, _) = edit.get_node(new_fork).try_fork().unwrap().clone();
edit = edit.replace_all_uses_where(old_control_pred, new_control_pred, |usee| {
*usee == new_fork
})?;
@@ -430,7 +422,7 @@ pub fn fork_coalesce_helper(
.filter(|node| editor.func().nodes[node.idx()].is_reduce())
{
// check that inner reduce is of the inner join
- let (outer_control, outer_init, outer_reduct) = editor.func().nodes[outer_reduce.idx()]
+ let (_, _, outer_reduct) = editor.func().nodes[outer_reduce.idx()]
.try_reduce()
.unwrap();
@@ -440,7 +432,7 @@ pub fn fork_coalesce_helper(
let Node::Reduce {
control: inner_control,
init: inner_init,
- reduct: inner_reduct,
+ reduct: _,
} = inner_reduce_node
else {
return false;
@@ -524,10 +516,10 @@ pub fn fork_coalesce_helper(
// Fuse Reductions
for (outer_reduce, inner_reduce) in pairs {
- let (outer_control, outer_init, outer_reduct) = editor.func().nodes[outer_reduce.idx()]
+ let (_, outer_init, _) = editor.func().nodes[outer_reduce.idx()]
.try_reduce()
.unwrap();
- let (inner_control, inner_init, inner_reduct) = editor.func().nodes[inner_reduce.idx()]
+ let (_, inner_init, _) = editor.func().nodes[inner_reduce.idx()]
.try_reduce()
.unwrap();
editor.edit(|mut edit| {
diff --git a/hercules_opt/src/forkify.rs b/hercules_opt/src/forkify.rs
index d99c15d7..96fb96d2 100644
--- a/hercules_opt/src/forkify.rs
+++ b/hercules_opt/src/forkify.rs
@@ -416,9 +416,7 @@ nest! {
impl LoopPHI {
pub fn get_phi(&self) -> NodeID {
match self {
- LoopPHI::Reductionable {
- phi, ..
- } => *phi,
+ LoopPHI::Reductionable { phi, .. } => *phi,
LoopPHI::LoopDependant(node_id) => *node_id,
LoopPHI::UsedByDependant(node_id) => *node_id,
}
diff --git a/hercules_opt/src/ivar.rs b/hercules_opt/src/ivar.rs
index 929f3a40..dd1d0ab6 100644
--- a/hercules_opt/src/ivar.rs
+++ b/hercules_opt/src/ivar.rs
@@ -2,18 +2,6 @@ use std::collections::{BTreeMap, HashMap, HashSet, VecDeque};
use std::path::Iter;
use nestify::nest;
-
-use hercules_ir::Subgraph;
-
-use bitvec::order::Lsb0;
-use bitvec::prelude::*;
-use bitvec::vec::BitVec;
-use hercules_ir::get_uses;
-
-use hercules_ir::LoopTree;
-
-use crate::walk_all_uses_stop_on;
-
use slotmap::{new_key_type, SlotMap};
use hercules_ir::ir::*;
@@ -517,7 +505,10 @@ pub fn compute_iv_ranges(
// FIXME: DO linear algerbra to solve for loop bounds with multiple variables involved.
let final_value = match &editor.func().nodes[condition_node.idx()] {
- Node::Phi { control: _, data: _ } => None,
+ Node::Phi {
+ control: _,
+ data: _,
+ } => None,
Node::Reduce {
control: _,
init: _,
diff --git a/hercules_test/hercules_interpreter/src/lib.rs b/hercules_test/hercules_interpreter/src/lib.rs
index 75a974ec..66f8c4ea 100644
--- a/hercules_test/hercules_interpreter/src/lib.rs
+++ b/hercules_test/hercules_interpreter/src/lib.rs
@@ -36,8 +36,7 @@ pub fn into_interp_val(
InterpreterWrapper::Array(array) => {
let ty = &module.types[target_ty_id.idx()];
- ty
- .try_element_type()
+ ty.try_element_type()
.expect("PANIC: Invalid parameter type");
let mut values = vec![];
diff --git a/hercules_test/hercules_interpreter/src/value.rs b/hercules_test/hercules_interpreter/src/value.rs
index c84b4849..53911e05 100644
--- a/hercules_test/hercules_interpreter/src/value.rs
+++ b/hercules_test/hercules_interpreter/src/value.rs
@@ -821,7 +821,7 @@ impl<'a> InterpreterVal {
(UnaryOperator::Neg, Self::Float64(val)) => Self::Float64(-val),
(UnaryOperator::Cast(type_id), val) => {
// FIXME: This probably doesn't work.
- let val = val.as_i128();
+ let val = val.as_i128();
match types[type_id.idx()] {
Type::Control => todo!(),
Type::Boolean => todo!(),
--
GitLab
From c46b7587209de283a34cbcaf8deef3edbdd59678 Mon Sep 17 00:00:00 2001
From: Russel Arbore <russel.jma@gmail.com>
Date: Thu, 30 Jan 2025 10:49:15 -0600
Subject: [PATCH 65/68] more warning fixes
---
hercules_opt/src/editor.rs | 2 +-
hercules_opt/src/fork_guard_elim.rs | 2 --
hercules_opt/src/fork_transforms.rs | 32 ++++++------------
hercules_opt/src/forkify.rs | 50 ++++++-----------------------
hercules_opt/src/ivar.rs | 7 ++--
hercules_opt/src/outline.rs | 1 -
6 files changed, 23 insertions(+), 71 deletions(-)
diff --git a/hercules_opt/src/editor.rs b/hercules_opt/src/editor.rs
index e6db7459..39f1184c 100644
--- a/hercules_opt/src/editor.rs
+++ b/hercules_opt/src/editor.rs
@@ -1,6 +1,6 @@
use std::borrow::Borrow;
use std::cell::{Ref, RefCell};
-use std::collections::{BTreeMap, HashMap, HashSet};
+use std::collections::{BTreeMap, HashSet};
use std::mem::take;
use std::ops::Deref;
diff --git a/hercules_opt/src/fork_guard_elim.rs b/hercules_opt/src/fork_guard_elim.rs
index 319d32b8..1abb8967 100644
--- a/hercules_opt/src/fork_guard_elim.rs
+++ b/hercules_opt/src/fork_guard_elim.rs
@@ -1,7 +1,5 @@
use std::collections::{HashMap, HashSet};
-use either::Either;
-
use hercules_ir::*;
use crate::*;
diff --git a/hercules_opt/src/fork_transforms.rs b/hercules_opt/src/fork_transforms.rs
index 8b2c6327..a4605bec 100644
--- a/hercules_opt/src/fork_transforms.rs
+++ b/hercules_opt/src/fork_transforms.rs
@@ -1,25 +1,11 @@
use std::collections::{HashMap, HashSet};
-use std::ops::Sub;
-
-use itertools::Itertools;
use bimap::BiMap;
+use itertools::Itertools;
-use hercules_ir::LoopTree;
-
-use hercules_ir::{Index, TypeID};
-
-use hercules_ir::Subgraph;
-
-use hercules_ir::DynamicConstantID;
-
-use hercules_ir::Node;
-
-use hercules_ir::{get_uses, Function};
-
-use hercules_ir::{NodeID, ID};
+use hercules_ir::*;
-use crate::{DenseNodeMap, FunctionEditor, Loop, SparseNodeMap};
+use crate::*;
type ForkID = usize;
@@ -245,11 +231,11 @@ pub fn fork_bufferize_fission_helper<'a>(
let thread_stuff_it = factors.into_iter().enumerate();
// FIxme: try to use unzip here? Idk why it wasn't working.
- let (tids) = thread_stuff_it.clone().map(|(dim, _)| {
- (edit.add_node(Node::ThreadID {
+ let tids = thread_stuff_it.clone().map(|(dim, _)| {
+ edit.add_node(Node::ThreadID {
control: fork,
dimension: dim,
- }))
+ })
});
let array_dims = thread_stuff_it.clone().map(|(_, factor)| (factor));
@@ -279,11 +265,11 @@ pub fn fork_bufferize_fission_helper<'a>(
edit = edit.replace_all_uses_where(NodeID::new(0), reduce, |usee| *usee == write)?;
// Create read from buffer
- let (tids) = thread_stuff_it.clone().map(|(dim, _)| {
- (edit.add_node(Node::ThreadID {
+ let tids = thread_stuff_it.clone().map(|(dim, _)| {
+ edit.add_node(Node::ThreadID {
control: new_fork_id,
dimension: dim,
- }))
+ })
});
let position_idx = Index::Position(tids.collect::<Vec<_>>().into_boxed_slice());
diff --git a/hercules_opt/src/forkify.rs b/hercules_opt/src/forkify.rs
index 96fb96d2..73077678 100644
--- a/hercules_opt/src/forkify.rs
+++ b/hercules_opt/src/forkify.rs
@@ -1,39 +1,14 @@
-use core::panic;
use std::collections::HashMap;
use std::collections::HashSet;
use std::iter::zip;
use std::iter::FromIterator;
+use itertools::Itertools;
use nestify::nest;
-use bitvec::order::Lsb0;
-use bitvec::vec::BitVec;
-
-use hercules_ir::Subgraph;
-
-use hercules_ir::control_subgraph;
-
-use crate::calculate_loop_nodes;
-use crate::compute_induction_vars;
-use crate::compute_iv_ranges;
-use crate::compute_loop_variance;
-use crate::get_loop_exit_conditions;
-use crate::has_canonical_iv;
-use crate::walk_all_users;
-use crate::walk_all_users_stop_on;
-use crate::walk_all_uses;
-use crate::walk_all_uses_stop_on;
-use crate::DenseNodeMap;
-use crate::FunctionEditor;
-use crate::InductionVariable;
-use crate::Loop;
-use crate::LoopExit;
-use crate::LoopVarianceInfo;
-
-use hercules_ir::def_use::*;
-use hercules_ir::ir::*;
-use hercules_ir::loops::*;
-use itertools::Itertools;
+use hercules_ir::*;
+
+use crate::*;
pub fn forkify(
editor: &mut FunctionEditor,
@@ -442,7 +417,7 @@ pub fn analyze_phis<'a>(
let data = &editor.func().nodes[node.idx()];
// External Phi
- if let Node::Phi { control, data } = data {
+ if let Node::Phi { control, data: _ } = data {
if *control != natural_loop.header {
return true;
}
@@ -450,8 +425,8 @@ pub fn analyze_phis<'a>(
// External Reduce
if let Node::Reduce {
control,
- init,
- reduct,
+ init: _,
+ reduct: _,
} = data
{
if !natural_loop.control[control.idx()] {
@@ -487,16 +462,11 @@ pub fn analyze_phis<'a>(
let data = &editor.func().nodes[node.idx()];
// Phi, Reduce
- if let Node::Phi { control, data } = data {
+ if data.is_phi() {
return true;
}
- if let Node::Reduce {
- control,
- init,
- reduct,
- } = data
- {
+ if data.is_reduce() {
return true;
}
@@ -521,7 +491,7 @@ pub fn analyze_phis<'a>(
// we use `phis` because this phi can actually contain the loop iv and its fine.
if uses_for_dependance.any(|node| phis.contains(&node) && node != *phi) {
LoopPHI::LoopDependant(*phi)
- } else if intersection.clone().iter().any(|node| true) {
+ } else if intersection.clone().iter().next().is_some() {
// PHIs on the frontier of the uses by the candidate phi, i.e in uses_for_dependance need
// to have headers that postdominate the loop continue latch. The value of the PHI used needs to be defined
// by the time the reduce is triggered (at the end of the loop's internal control).
diff --git a/hercules_opt/src/ivar.rs b/hercules_opt/src/ivar.rs
index dd1d0ab6..f7252d29 100644
--- a/hercules_opt/src/ivar.rs
+++ b/hercules_opt/src/ivar.rs
@@ -1,10 +1,9 @@
-use std::collections::{BTreeMap, HashMap, HashSet, VecDeque};
-use std::path::Iter;
+use std::collections::HashSet;
+use bitvec::prelude::*;
use nestify::nest;
-use slotmap::{new_key_type, SlotMap};
-use hercules_ir::ir::*;
+use hercules_ir::*;
use crate::*;
diff --git a/hercules_opt/src/outline.rs b/hercules_opt/src/outline.rs
index e59c815d..8fe978c5 100644
--- a/hercules_opt/src/outline.rs
+++ b/hercules_opt/src/outline.rs
@@ -4,7 +4,6 @@ use std::sync::atomic::{AtomicUsize, Ordering};
use hercules_ir::def_use::*;
use hercules_ir::dom::*;
-use hercules_ir::fork_join_analysis::*;
use hercules_ir::ir::*;
use hercules_ir::subgraph::*;
--
GitLab
From fd436596a516aca90ffd5951435cc2518c653a91 Mon Sep 17 00:00:00 2001
From: Russel Arbore <russel.jma@gmail.com>
Date: Thu, 30 Jan 2025 10:56:12 -0600
Subject: [PATCH 66/68] more cleanup
---
.../hercules_tests/tests/forkify_tests.rs | 4 +-
.../hercules_tests/tests/loop_tests.rs | 42 ++-----------------
2 files changed, 5 insertions(+), 41 deletions(-)
diff --git a/hercules_test/hercules_tests/tests/forkify_tests.rs b/hercules_test/hercules_tests/tests/forkify_tests.rs
index 5a8bff1a..8ba8e135 100644
--- a/hercules_test/hercules_tests/tests/forkify_tests.rs
+++ b/hercules_test/hercules_tests/tests/forkify_tests.rs
@@ -18,15 +18,13 @@ fn inner_fork_chain() {
let params = 2; // TODO: (@xrouth) fix macro to take no params as an option.
// let result_1 = interp_module!(module, 0, dyn_consts, 2);
- // println!("result: {:?}", result_1);
-
let sched: Option<ScheduleStmt> = Some(default_schedule![Verify, Forkify, PhiElim, Verify,]);
let module = run_schedule_on_hercules(module, sched).unwrap();
let result_2 = interp_module!(module, 0, dyn_consts, 2);
println!("result: {:?}", result_2);
- // assert_eq!(result_1, result_2)
+ //assert_eq!(result_1, result_2)
}
#[test]
diff --git a/hercules_test/hercules_tests/tests/loop_tests.rs b/hercules_test/hercules_tests/tests/loop_tests.rs
index 55da702d..5832a161 100644
--- a/hercules_test/hercules_tests/tests/loop_tests.rs
+++ b/hercules_test/hercules_tests/tests/loop_tests.rs
@@ -36,9 +36,7 @@ fn alternate_bounds_use_after_loop_no_tid() {
println!("result: {:?}", result_1);
let schedule = default_schedule![
- ////Xdot,,
Forkify,
- //Xdot,
];
let module = run_schedule_on_hercules(module, Some(schedule)).unwrap();
@@ -64,15 +62,12 @@ fn alternate_bounds_use_after_loop() {
println!("result: {:?}", result_1);
let schedule = Some(default_schedule![
- ////Xdot,,
Forkify,
- //Xdot,
]);
let module = run_schedule_on_hercules(module, schedule).unwrap();
let result_2 = interp_module!(module, 0, dyn_consts, a.clone());
- //println!("{:?}", result_1);
println!("{:?}", result_2);
assert_eq!(result_1, result_2);
@@ -91,14 +86,11 @@ fn alternate_bounds_use_after_loop2() {
println!("result: {:?}", result_1);
- let schedule = Some(default_schedule![
- ////Xdot,,
- ]);
+ let schedule = Some(default_schedule![]);
let module = run_schedule_on_hercules(module, schedule).unwrap();
let result_2 = interp_module!(module, 0, dyn_consts, a.clone());
- //println!("{:?}", result_1);
println!("{:?}", result_2);
assert_eq!(result_1, result_2);
@@ -117,16 +109,13 @@ fn do_while_separate_body() {
println!("result: {:?}", result_1);
let schedule = Some(default_schedule![
- ////Xdot,,
- PhiElim, ////Xdot,,
+ PhiElim,
Forkify,
- //Xdot,
]);
let module = run_schedule_on_hercules(module, schedule).unwrap();
let result_2 = interp_module!(module, 0, dyn_consts, 2i32);
- //println!("{:?}", result_1);
println!("{:?}", result_2);
assert_eq!(result_1, result_2);
@@ -143,10 +132,8 @@ fn alternate_bounds_internal_control() {
println!("result: {:?}", result_1);
let schedule = Some(default_schedule![
- ////Xdot,,
- PhiElim, ////Xdot,,
+ PhiElim,
Forkify,
- //Xdot,
]);
let module = run_schedule_on_hercules(module, schedule).unwrap();
@@ -169,10 +156,8 @@ fn alternate_bounds_internal_control2() {
println!("result: {:?}", result_1);
let schedule = Some(default_schedule![
- ////Xdot,,
- PhiElim, ////Xdot,,
+ PhiElim,
Forkify,
- //Xdot,
]);
let module = run_schedule_on_hercules(module, schedule).unwrap();
@@ -331,7 +316,6 @@ fn implicit_clone_pipeline() {
println!("result: {:?}", result_1);
let schedule = default_schedule![
- ////Xdot,,
Forkify,
ForkGuardElim,
Forkify,
@@ -383,7 +367,6 @@ fn look_at_local() {
);
let schedule = Some(default_schedule![
- ////Xdot,,
]);
let result_1 = interp_module!(module, 0, dyn_consts, a.clone(), b.clone());
@@ -391,9 +374,7 @@ fn look_at_local() {
let module = run_schedule_on_hercules(module.clone(), schedule).unwrap();
let schedule = Some(default_schedule![
- ////Xdot,,
Unforkify, Verify,
- ////Xdot,,
]);
let module = run_schedule_on_hercules(module.clone(), schedule).unwrap();
@@ -452,19 +433,4 @@ fn matmul_pipeline() {
println!("result: {:?}", result_2);
assert_eq!(result_1, result_2);
-
- // Verify,
- // GVN,
- // DCE,
- // AutoOutline,
- // InterproceduralSROA,
- // SROA,
- // InferSchedules,
- // DCE,
- // GCM,
- // DCE,
- // PhiElim,
- // FloatCollections,
- // GCM,
- // //Xdot,
}
--
GitLab
From 48231de6c188a2fcf3f2ca2cefed5022ff57fcfd Mon Sep 17 00:00:00 2001
From: Russel Arbore <russel.jma@gmail.com>
Date: Thu, 30 Jan 2025 11:04:50 -0600
Subject: [PATCH 67/68] add TODO comments
---
hercules_opt/src/forkify.rs | 5 +++++
juno_scheduler/src/pm.rs | 8 +++-----
2 files changed, 8 insertions(+), 5 deletions(-)
diff --git a/hercules_opt/src/forkify.rs b/hercules_opt/src/forkify.rs
index 73077678..356dd67a 100644
--- a/hercules_opt/src/forkify.rs
+++ b/hercules_opt/src/forkify.rs
@@ -10,6 +10,11 @@ use hercules_ir::*;
use crate::*;
+/*
+ * TODO: Forkify currently makes a bunch of small edits - this needs to be
+ * changed so that every loop that gets forkified corresponds to a single edit
+ * + sub-edits. This would allow us to run forkify on a subset of a function.
+ */
pub fn forkify(
editor: &mut FunctionEditor,
control_subgraph: &Subgraph,
diff --git a/juno_scheduler/src/pm.rs b/juno_scheduler/src/pm.rs
index 8b3e9050..9888f3d2 100644
--- a/juno_scheduler/src/pm.rs
+++ b/juno_scheduler/src/pm.rs
@@ -1306,10 +1306,6 @@ fn run_pass(
}
Pass::ForkSplit => {
assert!(args.is_empty());
- // FIXME: I'm not sure if this is the correct way to build fixpoint into the PM,
- // i.e cloning selection. Does something need to be done to propagate labels between iterations
- // of this loop?
-
loop {
let mut inner_changed = false;
pm.make_fork_join_maps();
@@ -1354,8 +1350,10 @@ fn run_pass(
let Some(mut func) = func else {
continue;
};
+ // TODO: uses direct return from forkify for now instead of
+ // func.modified, see comment on top of `forkify` for why. Fix
+ // this eventually.
changed |= forkify(&mut func, control_subgraph, fork_join_map, loop_nest);
- // func.modified();
}
pm.delete_gravestones();
pm.clear_analyses();
--
GitLab
From 8f22a8e2b94007a25401c5adf1044a005c9d604a Mon Sep 17 00:00:00 2001
From: Xavier Routh <xrouth2@illinois.edu>
Date: Thu, 30 Jan 2025 13:20:18 -0600
Subject: [PATCH 68/68] forkify fixes
---
hercules_opt/src/forkify.rs | 19 +++++++++++++------
1 file changed, 13 insertions(+), 6 deletions(-)
diff --git a/hercules_opt/src/forkify.rs b/hercules_opt/src/forkify.rs
index 10a8fe21..49ba98a6 100644
--- a/hercules_opt/src/forkify.rs
+++ b/hercules_opt/src/forkify.rs
@@ -439,6 +439,10 @@ pub fn analyze_phis<'a>(
phis: &'a [NodeID],
loop_nodes: &'a HashSet<NodeID>,
) -> impl Iterator<Item = LoopPHI> + 'a {
+
+ // Find data cycles within the loop of this phi,
+ // Start from the phis loop_continue_latch, and walk its uses until we find the original phi.
+
phis.into_iter().map(move |phi| {
let stop_on: HashSet<NodeID> = editor
.node_ids()
@@ -451,6 +455,12 @@ pub fn analyze_phis<'a>(
return true;
}
}
+
+ // This phi
+ if node == phi {
+ return true;
+ }
+
// External Reduce
if let Node::Reduce {
control,
@@ -480,10 +490,9 @@ pub fn analyze_phis<'a>(
.unwrap();
let loop_continue_latch = editor.node(phi).try_phi().unwrap().1[continue_idx];
-
- // TODO: We may need to stop on exiting the loop for looking for data cycles.
+
let uses = walk_all_uses_stop_on(loop_continue_latch, editor, stop_on.clone());
- let users = walk_all_users_stop_on(loop_continue_latch, editor, stop_on.clone());
+ let users = walk_all_users_stop_on(*phi, editor, stop_on.clone());
let other_stop_on: HashSet<NodeID> = editor
.node_ids()
@@ -514,8 +523,7 @@ pub fn analyze_phis<'a>(
.collect();
-
- let mut uses_for_dependance = walk_all_users_stop_on(loop_continue_latch, editor, other_stop_on);
+ let mut uses_for_dependance = walk_all_uses_stop_on(loop_continue_latch, editor, other_stop_on);
let set1: HashSet<_> = HashSet::from_iter(uses);
let set2: HashSet<_> = HashSet::from_iter(users);
@@ -539,7 +547,6 @@ pub fn analyze_phis<'a>(
if intersection
.iter()
.filter(|node| **node != loop_continue_latch )
- .filter(|node| !(editor.node(*node).is_reduce() || editor.node(*node).is_phi()))
.any(|data_node| {
editor
.get_users(*data_node)
--
GitLab