diff --git a/Cargo.lock b/Cargo.lock
index 27bf3c1e6319f1652f967c878d8ab43d9fe65ee2..8b9e4c9e4d4ee280978801aed1b4b1ddc404c05a 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -395,6 +395,16 @@ dependencies = [
"syn",
]
+[[package]]
+name = "dot"
+version = "0.1.0"
+dependencies = [
+ "async-std",
+ "clap",
+ "hercules_rt",
+ "rand",
+]
+
[[package]]
name = "either"
version = "1.13.0"
@@ -450,6 +460,16 @@ dependencies = [
"pin-project-lite",
]
+[[package]]
+name = "fac"
+version = "0.1.0"
+dependencies = [
+ "async-std",
+ "clap",
+ "hercules_rt",
+ "rand",
+]
+
[[package]]
name = "fastrand"
version = "2.1.1"
@@ -592,16 +612,6 @@ dependencies = [
"serde",
]
-[[package]]
-name = "hercules_dot"
-version = "0.1.0"
-dependencies = [
- "async-std",
- "clap",
- "hercules_rt",
- "rand",
-]
-
[[package]]
name = "hercules_driver"
version = "0.1.0"
@@ -638,16 +648,6 @@ dependencies = [
"serde",
]
-[[package]]
-name = "hercules_matmul"
-version = "0.1.0"
-dependencies = [
- "async-std",
- "clap",
- "hercules_rt",
- "rand",
-]
-
[[package]]
name = "hercules_opt"
version = "0.1.0"
@@ -862,6 +862,16 @@ dependencies = [
"vob",
]
+[[package]]
+name = "matmul"
+version = "0.1.0"
+dependencies = [
+ "async-std",
+ "clap",
+ "hercules_rt",
+ "rand",
+]
+
[[package]]
name = "memchr"
version = "2.7.2"
diff --git a/Cargo.toml b/Cargo.toml
index 31639dce49115fca9a53fbd56a5d10cbb355b7be..322aa33dc141e68fc046f7c095a4b7062869df2d 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -11,11 +11,10 @@ members = [
"hercules_test/hercules_tests",
"hercules_tools/hercules_driver",
- #"hercules_tools/hercules_hbin_dump",
"juno_frontend",
"hercules_samples/dot",
"hercules_samples/matmul",
- #"hercules_samples/task_parallel"
+ "hercules_samples/fac",
]
diff --git a/hercules_cg/src/sched_gen.rs b/hercules_cg/src/sched_gen.rs
index 758eb786cc42eb423df06c2188c21e50205456a1..4f9decce5d66e44e3017090d574c38b7d7813793 100644
--- a/hercules_cg/src/sched_gen.rs
+++ b/hercules_cg/src/sched_gen.rs
@@ -948,20 +948,30 @@ impl<'a> FunctionContext<'a> {
// of the SFunction corresponding to this phi.
found_in_partition_predecessor = true;
Some((*block_id, get_svalue(*data_id).clone()))
- } else {
- // Don't add multiple inputs for block #0.
+ } else if let Some(param_idx) = manifest.partitions[partition_idx]
+ .parameters
+ .iter()
+ .position(|(_, kind)| *kind == ParameterKind::DataInput(id))
+ {
+ // This input to the phi is corresponds to all of
+ // the inputs from control locations outside this
+ // partition. This does *not* include constant nodes
+ // in other partitions - those get propagated (see
+ // below). Don't add multiple inputs for block #0.
if found_out_of_partition_predecessor {
return None;
}
- // This predecessor for the phi gets passed in via a
- // parameter set up for this phi.
+ // This predecessor for the phi gets passed in
+ // via a parameter set up for this phi.
found_out_of_partition_predecessor = true;
- let param_idx = manifest.partitions[partition_idx]
- .parameters
- .iter()
- .position(|(_, kind)| *kind == ParameterKind::DataInput(id))
- .unwrap();
Some((BlockID::new(0), SValue::VirtualRegister(param_idx)))
+ } else {
+ // This input to the phi is a constant located
+ // outside this partition these get propagated in
+ // schedule IR.
+ found_in_partition_predecessor = true;
+ let svalue = get_svalue(*data_id).clone();
+ Some((BlockID::new(0), svalue))
}
})
.collect();
diff --git a/hercules_ir/src/dot.rs b/hercules_ir/src/dot.rs
index 156433885ea09a3dc9f907fdbb6cc729d28f3b4c..97520382fb5ae63d1c6e2fa5b50632e09a9db8e2 100644
--- a/hercules_ir/src/dot.rs
+++ b/hercules_ir/src/dot.rs
@@ -27,7 +27,7 @@ pub fn xdot_module(
let mut rng = rand::thread_rng();
let num: u64 = rng.gen();
tmp_path.push(format!("hercules_dot_{}.dot", num));
- let mut file = File::create(tmp_path.clone()).expect("PANIC: Unable to open output file.");
+ let mut file = File::create(&tmp_path).expect("PANIC: Unable to open output file.");
let mut contents = String::new();
write_dot(
&module,
@@ -77,6 +77,7 @@ pub fn write_dot<W: Write>(
// Step 1: draw IR graph itself. This includes all IR nodes and all edges
// between IR nodes.
for partition_idx in 0..plan.map_or(1, |plan| plan.num_partitions) {
+ // First, write all the nodes in their subgraph.
let partition_color = plan.map(|plan| match plan.partition_devices[partition_idx] {
Device::CPU => "lightblue",
Device::GPU => "darkseagreen",
@@ -84,7 +85,6 @@ pub fn write_dot<W: Write>(
if let Some(partition_color) = partition_color {
write_partition_header(function_id, partition_idx, module, partition_color, w)?;
}
-
let nodes_ids = if let Some(partition_to_node_map) = &mut partition_to_node_map {
let mut empty = vec![];
std::mem::swap(&mut partition_to_node_map[partition_idx], &mut empty);
@@ -109,7 +109,15 @@ pub fn write_dot<W: Write>(
plan.map_or(&vec![], |plan| &plan.schedules[node_id.idx()]),
w,
)?;
+ }
+ if plans.is_some() {
+ write_graph_footer(w)?;
+ }
+ // Second, write all the edges coming out of a node.
+ for node_id in nodes_ids.iter() {
+ let node = &function.nodes[node_id.idx()];
+ let dst_control = node.is_control();
for u in def_use::get_uses(&node).as_ref() {
let src_control = function.nodes[u.idx()].is_control();
@@ -151,9 +159,6 @@ pub fn write_dot<W: Write>(
)?;
}
}
- if plans.is_some() {
- write_graph_footer(w)?;
- }
}
// Step 2: draw dominance edges in dark green. Don't draw post dominance
diff --git a/hercules_ir/src/schedule.rs b/hercules_ir/src/schedule.rs
index 2c6335147658dac3d590458c5585f92956c93d42..7c9fdc1058aa30601b04f3e4f7de37c85784c8dc 100644
--- a/hercules_ir/src/schedule.rs
+++ b/hercules_ir/src/schedule.rs
@@ -1,5 +1,4 @@
-use std::collections::HashMap;
-use std::collections::VecDeque;
+use std::collections::{HashMap, VecDeque};
use std::iter::{repeat, zip};
use crate::*;
@@ -288,6 +287,9 @@ impl Plan {
let partition_graph = partition_graph(function, def_use, self);
let dom = dominator(&partition_graph, NodeID::new(self.partitions[0].idx()));
for id in (0..function.nodes.len()).map(NodeID::new) {
+ if function.nodes[id.idx()].is_control() {
+ continue;
+ }
let part = self.partitions[id.idx()];
// Check condition #1.
@@ -416,17 +418,19 @@ impl Plan {
let data_inputs = &mut data_inputs[self.partitions[id.idx()].idx()];
let uses = get_uses(&function.nodes[id.idx()]);
for use_id in uses.as_ref() {
- // For every phi node, if any one of its uses is defined in a
- // different partition, then the phi node itself, not its
- // outside uses, is considered a data input. This is because a
- // phi node whose uses are all in a different partition should
- // be lowered to a single parameter to the corresponding simple
- // IR function. Note that for a phi node with some uses outside
- // and some uses inside the partition, the uses outside the
- // partition become a single parameter to the schedule IR
- // function, and that parameter and all of the "inside" uses
- // become the inputs to a phi inside the simple IR function.
+ // For every phi node, if any one of its non-constant uses is
+ // defined in a different partition, then the phi node itself,
+ // not its outside uses, is considered a data input. This is
+ // because a phi node whose uses are all in a different
+ // partition should be lowered to a single parameter to the
+ // corresponding simple IR function. Note that for a phi node
+ // with some uses outside and some uses inside the partition,
+ // the uses outside the partition become a single parameter to
+ // the schedule IR function, and that parameter and all of the
+ // "inside" uses become the inputs to a phi inside the simple IR
+ // function.
if self.partitions[id.idx()] != self.partitions[use_id.idx()]
+ && !function.nodes[use_id.idx()].is_constant()
&& !data_inputs.contains(&id)
{
data_inputs.push(id);
@@ -484,62 +488,30 @@ impl Plan {
}
data_outputs
}
-}
-impl GraveUpdatable for Plan {
- fn fix_gravestones(&mut self, grave_mapping: &Vec<NodeID>) {
- self.schedules.fix_gravestones(grave_mapping);
- self.partitions.fix_gravestones(grave_mapping);
- self.partition_devices.fix_gravestones(grave_mapping);
+ pub fn renumber_partitions(&mut self) {
let mut renumber_partitions = HashMap::new();
for id in self.partitions.iter_mut() {
let next_id = PartitionID::new(renumber_partitions.len());
- *id = *renumber_partitions.entry(*id).or_insert(next_id);
+ let old_id = *id;
+ let new_id = *renumber_partitions.entry(old_id).or_insert(next_id);
+ *id = new_id;
+ }
+ let mut new_devices = vec![Device::CPU; renumber_partitions.len()];
+ for (old_id, new_id) in renumber_partitions.iter() {
+ new_devices[new_id.idx()] = self.partition_devices[old_id.idx()];
}
+ self.partition_devices = new_devices;
self.num_partitions = renumber_partitions.len();
}
}
-/*
- * A "default" plan should be available, where few schedules are used and
- * conservative partitioning is enacted. Only schedules that can be proven safe
- * by the compiler should be included.
- */
-pub fn default_plan(
- function: &Function,
- dynamic_constants: &Vec<DynamicConstant>,
- def_use: &ImmutableDefUseMap,
- reverse_postorder: &Vec<NodeID>,
- fork_join_map: &HashMap<NodeID, NodeID>,
- fork_join_nesting: &HashMap<NodeID, Vec<NodeID>>,
- bbs: &Vec<NodeID>,
-) -> Plan {
- // Start by creating a completely bare-bones plan doing nothing interesting.
- let mut plan = Plan {
- schedules: vec![vec![]; function.nodes.len()],
- partitions: vec![PartitionID::new(0); function.nodes.len()],
- partition_devices: vec![Device::CPU; 1],
- num_partitions: 1,
- };
-
- // Infer schedules.
- infer_parallel_reduce(function, fork_join_map, &mut plan);
- infer_parallel_fork(
- function,
- def_use,
- fork_join_map,
- fork_join_nesting,
- &mut plan,
- );
- infer_vectorizable(function, dynamic_constants, fork_join_map, &mut plan);
- infer_associative(function, &mut plan);
-
- // Infer a partitioning.
- partition_out_forks(function, reverse_postorder, fork_join_map, bbs, &mut plan);
- // TODO: uncomment once GPU backend is implemented.
- // place_fork_partitions_on_gpu(function, &mut plan);
-
- plan
+impl GraveUpdatable for Plan {
+ fn fix_gravestones(&mut self, grave_mapping: &Vec<NodeID>) {
+ self.schedules.fix_gravestones(grave_mapping);
+ self.partitions.fix_gravestones(grave_mapping);
+ self.renumber_partitions();
+ }
}
/*
diff --git a/hercules_opt/src/editor.rs b/hercules_opt/src/editor.rs
index 6b26e493ddb25ea56bd67871808a8e95e3e50e8d..0bd4397be4f40e29d2ef2ac765ea06129e1bafb8 100644
--- a/hercules_opt/src/editor.rs
+++ b/hercules_opt/src/editor.rs
@@ -3,7 +3,8 @@ extern crate either;
extern crate hercules_ir;
extern crate itertools;
-use std::collections::{BTreeMap, HashSet};
+use std::collections::{BTreeMap, HashMap, HashSet, VecDeque};
+use std::iter::FromIterator;
use std::mem::take;
use self::bitvec::prelude::*;
@@ -383,14 +384,18 @@ pub fn repair_plan(plan: &mut Plan, new_function: &Function, edits: &[Edit]) {
.map(|part| Some(part))
.collect();
new_partitions.resize(new_function.nodes.len(), None);
- // Iterate the added control nodes in reverse postorder.
- for control_id in added_control_nodes {
+ // Iterate the added control nodes using a worklist.
+ let mut worklist = VecDeque::from(added_control_nodes);
+ while let Some(control_id) = worklist.pop_front() {
let node = &new_function.nodes[control_id.idx()];
- // There are three cases where this control node needs to start a new
+ // There are five cases where this control node needs to start a new
// partition:
- // 1. It's a top-level fork.
- // 2. One of its control predecessors is a top-level join.
- // 3. It's a region node where not every predecessor is in the same
+ // 1. It's a non-gravestone start node. This is any start node visited
+ // by the reverse postorder.
+ // 2. It's a return node.
+ // 3. It's a top-level fork.
+ // 4. One of its control predecessors is a top-level join.
+ // 5. It's a region node where not every predecessor is in the same
// partition (equivalently, not every predecessor is in the same
// partition - only region nodes can have multiple predecessors).
let top_level_fork = node.is_fork() && fork_join_nesting[&control_id].len() == 1;
@@ -404,7 +409,12 @@ pub fn repair_plan(plan: &mut Plan, new_function: &Function, edits: &[Edit]) {
.map(|pred| new_partitions[pred.idx()])
.all_equal();
- if top_level_fork || top_level_join || multi_pred_region {
+ if node.is_start()
+ || node.is_return()
+ || top_level_fork
+ || top_level_join
+ || multi_pred_region
+ {
// This control node goes in a new partition.
let part_id = PartitionID::new(plan.num_partitions);
plan.num_partitions += 1;
@@ -412,10 +422,12 @@ pub fn repair_plan(plan: &mut Plan, new_function: &Function, edits: &[Edit]) {
} else {
// This control node goes in the partition of any one of its
// predecessors. They're all the same by condition 3 above.
- new_partitions[control_id.idx()] = control_subgraph
- .preds(control_id)
- .filter_map(|pred_id| new_partitions[pred_id.idx()])
- .next();
+ let any_pred = control_subgraph.preds(control_id).next().unwrap();
+ if new_partitions[any_pred.idx()].is_some() {
+ new_partitions[control_id.idx()] = new_partitions[any_pred.idx()];
+ } else {
+ worklist.push_back(control_id);
+ }
}
}
@@ -439,7 +451,56 @@ pub fn repair_plan(plan: &mut Plan, new_function: &Function, edits: &[Edit]) {
// Step 6: wrap everything up.
plan.partitions = new_partitions.into_iter().map(|id| id.unwrap()).collect();
plan.partition_devices
- .resize(new_function.nodes.len(), Device::CPU);
+ .resize(plan.num_partitions, Device::CPU);
+}
+
+/*
+ * Default plans can be constructed by conservatively inferring schedules and
+ * creating partitions by "repairing" a partition where the edit is adding every
+ * node in the function.
+ */
+pub fn default_plan(
+ function: &Function,
+ dynamic_constants: &Vec<DynamicConstant>,
+ def_use: &ImmutableDefUseMap,
+ reverse_postorder: &Vec<NodeID>,
+ fork_join_map: &HashMap<NodeID, NodeID>,
+ fork_join_nesting: &HashMap<NodeID, Vec<NodeID>>,
+ bbs: &Vec<NodeID>,
+) -> Plan {
+ // Start by creating a completely bare-bones plan doing nothing interesting.
+ let mut plan = Plan {
+ schedules: vec![vec![]; function.nodes.len()],
+ partitions: vec![],
+ partition_devices: vec![],
+ num_partitions: 1,
+ };
+
+ // Infer a partitioning by using `repair_plan`, where the "edit" is creating
+ // the entire function.
+ let edit = (
+ HashSet::new(),
+ HashSet::from_iter((0..function.nodes.len()).map(NodeID::new)),
+ );
+ repair_plan(&mut plan, function, &[edit]);
+ plan.renumber_partitions();
+
+ // Infer schedules.
+ infer_parallel_reduce(function, fork_join_map, &mut plan);
+ infer_parallel_fork(
+ function,
+ def_use,
+ fork_join_map,
+ fork_join_nesting,
+ &mut plan,
+ );
+ infer_vectorizable(function, dynamic_constants, fork_join_map, &mut plan);
+ infer_associative(function, &mut plan);
+
+ // TODO: uncomment once GPU backend is implemented.
+ // place_fork_partitions_on_gpu(function, &mut plan);
+
+ plan
}
#[cfg(test)]
diff --git a/hercules_samples/dot/Cargo.toml b/hercules_samples/dot/Cargo.toml
index fe5873abd363aea21b8c4e24bdc497c26ecd27f1..ab10aedaeb3c680c1c26f3bc425178f34c6485c9 100644
--- a/hercules_samples/dot/Cargo.toml
+++ b/hercules_samples/dot/Cargo.toml
@@ -1,5 +1,5 @@
[package]
-name = "hercules_dot"
+name = "dot"
version = "0.1.0"
authors = ["Russel Arbore <rarbore2@illinois.edu>"]
edition = "2021"
diff --git a/hercules_samples/dot/src/main.rs b/hercules_samples/dot/src/main.rs
index 624c193761b2c1996dcc91eee3e182775103ddaa..dbf18713465c10f7fafc7de0e180a6d43f0003a6 100644
--- a/hercules_samples/dot/src/main.rs
+++ b/hercules_samples/dot/src/main.rs
@@ -3,9 +3,9 @@ extern crate clap;
extern crate hercules_rt;
// To compile currently, run from the Hercules project root directory:
-// cargo run --bin hercules_driver hercules_samples/dot/dot.hir "Codegen"
+// cargo run --bin hercules_driver hercules_samples/dot/dot.hir "Codegen(\"hercules_samples/dot\",\"dot\")"
// Then, you can execute this example with:
-// cargo run --bin hercules_dot
+// cargo run --bin dot
hercules_rt::use_hman!("hercules_samples/dot/dot.hman");
fn main() {
diff --git a/hercules_samples/task_parallel/Cargo.toml b/hercules_samples/fac/Cargo.toml
similarity index 87%
rename from hercules_samples/task_parallel/Cargo.toml
rename to hercules_samples/fac/Cargo.toml
index 76b678cc3b4ac042f0f48bb247c7ed58f4dc5efa..bef11a91f027edf84f1e719538168e4ce8fd21e7 100644
--- a/hercules_samples/task_parallel/Cargo.toml
+++ b/hercules_samples/fac/Cargo.toml
@@ -1,5 +1,5 @@
[package]
-name = "hercules_task_parallel"
+name = "fac"
version = "0.1.0"
authors = ["Russel Arbore <rarbore2@illinois.edu>"]
edition = "2021"
@@ -7,4 +7,5 @@ edition = "2021"
[dependencies]
clap = { version = "*", features = ["derive"] }
hercules_rt = { path = "../../hercules_rt" }
+rand = "*"
async-std = "*"
diff --git a/hercules_samples/fac/build.rs b/hercules_samples/fac/build.rs
new file mode 100644
index 0000000000000000000000000000000000000000..f43f9fbd956813de7f530d93c3afbb94a29995c6
--- /dev/null
+++ b/hercules_samples/fac/build.rs
@@ -0,0 +1,12 @@
+use std::env::current_dir;
+
+fn main() {
+ println!(
+ "cargo::rustc-link-search=native={}",
+ current_dir().unwrap().display()
+ );
+ println!("cargo::rustc-link-lib=static=fac");
+
+ println!("cargo::rerun-if-changed=fac.hman");
+ println!("cargo::rerun-if-changed=libfac.a");
+}
diff --git a/hercules_samples/fac/fac.hir b/hercules_samples/fac/fac.hir
new file mode 100644
index 0000000000000000000000000000000000000000..e43dd8cae1a605bca7c3ceac4eb7c029665e86e6
--- /dev/null
+++ b/hercules_samples/fac/fac.hir
@@ -0,0 +1,13 @@
+fn fac(x: i32) -> i32
+ zero = constant(i32, 0)
+ one = constant(i32, 1)
+ loop = region(start, if_true)
+ idx = phi(loop, zero, idx_inc)
+ idx_inc = add(idx, one)
+ fac = phi(loop, one, fac_acc)
+ fac_acc = mul(fac, idx_inc)
+ in_bounds = lt(idx_inc, x)
+ if = if(loop, in_bounds)
+ if_false = projection(if, 0)
+ if_true = projection(if, 1)
+ r = return(if_false, fac_acc)
diff --git a/hercules_samples/fac/src/main.rs b/hercules_samples/fac/src/main.rs
new file mode 100644
index 0000000000000000000000000000000000000000..5e5b4ddefb73835c45b399009e9709b06e056217
--- /dev/null
+++ b/hercules_samples/fac/src/main.rs
@@ -0,0 +1,16 @@
+extern crate async_std;
+extern crate clap;
+extern crate hercules_rt;
+
+// To compile currently, run from the Hercules project root directory:
+// cargo run --bin hercules_driver hercules_samples/fac/fac.hir "Codegen(\"hercules_samples/fac\",\"fac\")"
+// Then, you can execute this example with:
+// cargo run --bin fac
+hercules_rt::use_hman!("hercules_samples/fac/fac.hman");
+
+fn main() {
+ async_std::task::block_on(async {
+ let f = unsafe { fac(8).await };
+ println!("{}", f);
+ });
+}
diff --git a/hercules_samples/invalid/bad_phi.hir b/hercules_samples/invalid/bad_phi.hir
deleted file mode 100644
index f04a020276657a0bc0e8bee9844df29711f9552a..0000000000000000000000000000000000000000
--- a/hercules_samples/invalid/bad_phi.hir
+++ /dev/null
@@ -1,14 +0,0 @@
-fn func(x: i32) -> i32
- zero = constant(i32, 0)
- cond = lt(x, zero)
- if1 = if(start, cond)
- a1 = read_prod(if1, 0)
- b1 = read_prod(if1, 1)
- reg1 = region(a1, b1)
- phi1 = phi(reg1, x, phi2)
- if2 = if(reg1, cond)
- a2 = read_prod(if2, 0)
- b2 = read_prod(if2, 1)
- reg2 = region(a2, b2)
- phi2 = phi(reg2, phi1, x)
- r = return(reg2, x)
\ No newline at end of file
diff --git a/hercules_samples/invalid/bad_phi2.hir b/hercules_samples/invalid/bad_phi2.hir
deleted file mode 100644
index c03628cb01c55c9b49c7d85d9d81849edaf2de0e..0000000000000000000000000000000000000000
--- a/hercules_samples/invalid/bad_phi2.hir
+++ /dev/null
@@ -1,18 +0,0 @@
-fn tricky(x: i32) -> i32
- one = constant(i32, 1)
- two = constant(i32, 2)
- loop = region(start, if2_true)
- idx = phi(loop, x, idx_dec)
- val = phi(loop, later_val, one)
- b = ne(one, val)
- if1 = if(loop, b)
- if1_false = read_prod(if1, 0)
- if1_true = read_prod(if1, 1)
- middle = region(if1_false, if1_true)
- later_val = phi(middle, val, two)
- idx_dec = sub(idx, one)
- cond = gte(idx_dec, one)
- if2 = if(middle, cond)
- if2_false = read_prod(if2, 0)
- if2_true = read_prod(if2, 1)
- r = return(if2_false, later_val)
diff --git a/hercules_samples/matmul/Cargo.toml b/hercules_samples/matmul/Cargo.toml
index 723e9b523c693657a48a5a0213deab99ab875852..744b3f596a1007d0e22f55e2975b0357f70c663e 100644
--- a/hercules_samples/matmul/Cargo.toml
+++ b/hercules_samples/matmul/Cargo.toml
@@ -1,5 +1,5 @@
[package]
-name = "hercules_matmul"
+name = "matmul"
version = "0.1.0"
authors = ["Russel Arbore <rarbore2@illinois.edu>"]
edition = "2021"
diff --git a/hercules_samples/matmul/src/main.rs b/hercules_samples/matmul/src/main.rs
index 1fcee18cb1648ebfe13b4620caa458fdc1d203c2..ac5e96b26e65aa16adc266a784a9a727ce5d76e0 100644
--- a/hercules_samples/matmul/src/main.rs
+++ b/hercules_samples/matmul/src/main.rs
@@ -7,7 +7,7 @@ extern crate hercules_rt;
// To compile currently, run from the Hercules project root directory:
// cargo run --bin hercules_driver hercules_samples/matmul/matmul.hir "Codegen(\"hercules_samples/matmul\",\"matmul\")"
// Then, you can execute this example with:
-// cargo run --bin hercules_matmul
+// cargo run --bin matmul
hercules_rt::use_hman!("hercules_samples/matmul/matmul.hman");
fn main() {
diff --git a/hercules_samples/task_parallel/src/main.rs b/hercules_samples/task_parallel/src/main.rs
deleted file mode 100644
index 01480279fa5b9f94e42f6d3b274dad82baeb393d..0000000000000000000000000000000000000000
--- a/hercules_samples/task_parallel/src/main.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-extern crate async_std;
-extern crate clap;
-extern crate hercules_rt;
-
-hercules_rt::use_hbin!("task_parallel.hbin");
-
-fn main() {
- async_std::task::block_on(async {
- println!("{}", task_parallel(16).await);
- });
-}
diff --git a/hercules_samples/task_parallel/task_parallel.hir b/hercules_samples/task_parallel/task_parallel.hir
deleted file mode 100644
index 6386d5ec0dd09132250d00be3affe77a04613394..0000000000000000000000000000000000000000
--- a/hercules_samples/task_parallel/task_parallel.hir
+++ /dev/null
@@ -1,14 +0,0 @@
-fn task_parallel<1>() -> u64
- f_ctrl1 = fork(start, #0)
- j_ctrl1 = join(f_ctrl1)
- zero = constant(u64, 0)
- x1 = thread_id(f_ctrl1)
- data1 = reduce(j_ctrl1, zero, sum1)
- sum1 = add(data1, x1)
- f_ctrl2 = fork(j_ctrl1, #0)
- j_ctrl2 = join(f_ctrl2)
- x2 = thread_id(f_ctrl2)
- data2 = reduce(j_ctrl2, zero, sum2)
- sum2 = add(data2, x2)
- final = add(data1, data2)
- r = return(j_ctrl2, final)
diff --git a/hercules_tools/hercules_hbin_dump/Cargo.toml b/hercules_tools/hercules_hbin_dump/Cargo.toml
deleted file mode 100644
index 44504cb58c8f008d88632dd26cbd3ff1745b6109..0000000000000000000000000000000000000000
--- a/hercules_tools/hercules_hbin_dump/Cargo.toml
+++ /dev/null
@@ -1,11 +0,0 @@
-[package]
-name = "hercules_hbin_dump"
-version = "0.1.0"
-authors = ["Russel Arbore <rarbore2@illinois.edu>"]
-edition = "2021"
-
-[dependencies]
-clap = { version = "*", features = ["derive"] }
-postcard = { version = "*", features = ["alloc"] }
-serde = { version = "*", features = ["derive"] }
-hercules_ir = { path = "../../hercules_ir" }
\ No newline at end of file
diff --git a/hercules_tools/hercules_hbin_dump/src/main.rs b/hercules_tools/hercules_hbin_dump/src/main.rs
deleted file mode 100644
index 0b258ab4e534b189f86b53d03dc60a040de87be0..0000000000000000000000000000000000000000
--- a/hercules_tools/hercules_hbin_dump/src/main.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-extern crate clap;
-extern crate hercules_ir;
-extern crate postcard;
-
-use std::fs::File;
-use std::io::prelude::*;
-
-use clap::Parser;
-
-#[derive(Parser, Debug)]
-#[command(author, version, about, long_about = None)]
-struct Args {
- hbin_file: String,
-}
-
-fn main() {
- let args = Args::parse();
- if !args.hbin_file.ends_with(".hbin") {
- eprintln!("WARNING: Running hercules_hbin_dump on a file without a .hbin extension - interpreting as a Hercules binary file.");
- }
-
- let mut f = File::open(args.hbin_file).unwrap();
- let mut buffer = vec![];
- f.read_to_end(&mut buffer).unwrap();
- let (manifest, _): (hercules_ir::ModuleManifest, Vec<u8>) =
- postcard::from_bytes(&buffer).unwrap();
- println!("{:#?}", manifest);
-}