Set up cava benchmark

• Set up cava benchmark w/ criterion.
• GPU schedule for cava.
• Convert a bunch of benchmarks from using hercules refs to use hercules boxes.
• Define AlignedAlloc global allocator in hercules_rt that aligns everything to 32 bytes.
• Bump nom version.

hercules_ir/src/parse.rs

@@ -3,6 +3,8 @@ use std::collections::{HashMap, HashSet};
 use std::ops::Deref;
 use std::str::FromStr;
 
+use nom::Parser;
+
 use crate::*;
 
 /*
@@ -128,9 +130,8 @@ fn parse_module<'a>(ir_text: &'a str, context: Context<'a>) -> nom::IResult<&'a
     // If there is any text left after successfully parsing some functions,
     // treat that as an error.
     let (rest, functions) =
-        nom::combinator::all_consuming(nom::multi::many0(|x| parse_function(x, &context)))(
-            ir_text,
-        )?;
+        nom::combinator::all_consuming(nom::multi::many0(|x| parse_function(x, &context)))
+            .parse(ir_text)?;
     let mut context = context.into_inner();
 
     // Functions, as returned by parsing, is in parse order, which may differ
@@ -215,7 +216,7 @@ fn parse_function<'a>(
         Ok((ir_text, num_dynamic_constants))
     };
     let (ir_text, num_dynamic_constants) =
-        nom::combinator::opt(parse_num_dynamic_constants)(ir_text)?;
+        nom::combinator::opt(parse_num_dynamic_constants).parse(ir_text)?;
 
     // If unspecified, assumed function has no dynamic constant arguments.
     let num_dynamic_constants = num_dynamic_constants.unwrap_or(0);
@@ -223,7 +224,7 @@ fn parse_function<'a>(
     let ir_text = nom::character::complete::char('(')(ir_text)?.0;
     let (ir_text, params) = nom::multi::separated_list0(
         nom::character::complete::char(','),
-        nom::sequence::tuple((
+        (
             nom::character::complete::multispace0,
             parse_identifier,
             nom::character::complete::multispace0,
@@ -231,8 +232,9 @@ fn parse_function<'a>(
             nom::character::complete::multispace0,
             |x| parse_type_id(x, context),
             nom::character::complete::multispace0,
-        )),
-    )(ir_text)?;
+        ),
+    )
+    .parse(ir_text)?;
 
     // The start node is not explicitly specified in the textual IR, so create
     // it manually.
@@ -246,7 +248,7 @@ fn parse_function<'a>(
     let ir_text = nom::character::complete::multispace0(ir_text)?.0;
     let ir_text = nom::bytes::complete::tag("->")(ir_text)?.0;
     let (ir_text, return_type) = parse_type_id(ir_text, context)?;
-    let (ir_text, nodes) = nom::multi::many1(|x| parse_node(x, context))(ir_text)?;
+    let (ir_text, nodes) = nom::multi::many1(|x| parse_node(x, context)).parse(ir_text)?;
 
     // `nodes`, as returned by parsing, is in parse order, which may differ from
     // the order dictated by NodeIDs in the node name intern map.
@@ -383,11 +385,11 @@ fn parse_region<'a>(
     // explicitly using nom's separated list functionality. This example here
     // is a bit of an abuse of what parse_tupleN functions are meant for.
     let (ir_text, (preds,)) = parse_tuple1(nom::multi::separated_list1(
-        nom::sequence::tuple((
+        (
             nom::character::complete::multispace0,
             nom::character::complete::char(','),
             nom::character::complete::multispace0,
-        )),
+        ),
         parse_identifier,
     ))(ir_text)?;
 
@@ -411,11 +413,11 @@ fn parse_fork<'a>(ir_text: &'a str, context: &RefCell<Context<'a>>) -> nom::IRes
     let (ir_text, (control, factors)) = parse_tuple2(
         parse_identifier,
         nom::multi::separated_list1(
-            nom::sequence::tuple((
+            (
                 nom::character::complete::multispace0,
                 nom::character::complete::char(','),
                 nom::character::complete::multispace0,
-            )),
+            ),
             |x| parse_dynamic_constant_id(x, context),
         ),
     )(ir_text)?;
@@ -440,11 +442,11 @@ fn parse_phi<'a>(ir_text: &'a str, context: &RefCell<Context<'a>>) -> nom::IResu
     let (ir_text, (control, data)) = parse_tuple2(
         parse_identifier,
         nom::multi::separated_list1(
-            nom::sequence::tuple((
+            (
                 nom::character::complete::multispace0,
                 nom::character::complete::char(','),
                 nom::character::complete::multispace0,
-            )),
+            ),
             parse_identifier,
         ),
     )(ir_text)?;
@@ -575,29 +577,32 @@ fn parse_call<'a>(ir_text: &'a str, context: &RefCell<Context<'a>>) -> nom::IRes
             let ir_text = nom::character::complete::char('<')(ir_text)?.0;
             let ir_text = nom::character::complete::multispace0(ir_text)?.0;
             let (ir_text, dynamic_constants) = nom::multi::separated_list1(
-                nom::sequence::tuple((
+                (
                     nom::character::complete::multispace0,
                     nom::character::complete::char(','),
                     nom::character::complete::multispace0,
-                )),
+                ),
                 |x| parse_dynamic_constant_id(x, context),
-            )(ir_text)?;
+            )
+            .parse(ir_text)?;
             let ir_text = nom::character::complete::multispace0(ir_text)?.0;
             let ir_text = nom::character::complete::char('>')(ir_text)?.0;
             Ok((ir_text, dynamic_constants))
         };
-    let (ir_text, dynamic_constants) = nom::combinator::opt(parse_dynamic_constants)(ir_text)?;
+    let (ir_text, dynamic_constants) =
+        nom::combinator::opt(parse_dynamic_constants).parse(ir_text)?;
     let dynamic_constants = dynamic_constants.unwrap_or(vec![]);
     let ir_text = nom::character::complete::char('(')(ir_text)?.0;
     let ir_text = nom::character::complete::multispace0(ir_text)?.0;
     let (ir_text, mut function_and_args) = nom::multi::separated_list1(
-        nom::sequence::tuple((
+        (
             nom::character::complete::multispace0,
             nom::character::complete::char(','),
             nom::character::complete::multispace0,
-        )),
+        ),
         parse_identifier,
-    )(ir_text)?;
+    )
+    .parse(ir_text)?;
     let function = function_and_args.remove(0);
     let mut args: Vec<NodeID> = function_and_args
         .into_iter()
@@ -628,13 +633,14 @@ fn parse_intrinsic<'a>(
     let ir_text = nom::character::complete::char('(')(ir_text)?.0;
     let ir_text = nom::character::complete::multispace0(ir_text)?.0;
     let (ir_text, mut intrinsic_and_args) = nom::multi::separated_list1(
-        nom::sequence::tuple((
+        (
             nom::character::complete::multispace0,
             nom::character::complete::char(','),
             nom::character::complete::multispace0,
-        )),
+        ),
         parse_identifier,
-    )(ir_text)?;
+    )
+    .parse(ir_text)?;
     let intrinsic = intrinsic_and_args.remove(0);
     let args: Vec<NodeID> = intrinsic_and_args
         .into_iter()
@@ -661,7 +667,7 @@ fn parse_index<'a>(
 ) -> nom::IResult<&'a str, Index> {
     let (ir_text, idx) = nom::branch::alt((
         nom::combinator::map(
-            nom::sequence::tuple((
+            (
                 nom::character::complete::multispace0,
                 nom::bytes::complete::tag("field"),
                 nom::character::complete::multispace0,
@@ -671,11 +677,11 @@ fn parse_index<'a>(
                 nom::character::complete::multispace0,
                 nom::character::complete::char(')'),
                 nom::character::complete::multispace0,
-            )),
+            ),
             |(_, _, _, _, _, x, _, _, _)| Index::Field(x),
         ),
         nom::combinator::map(
-            nom::sequence::tuple((
+            (
                 nom::character::complete::multispace0,
                 nom::bytes::complete::tag("variant"),
                 nom::character::complete::multispace0,
@@ -685,28 +691,28 @@ fn parse_index<'a>(
                 nom::character::complete::multispace0,
                 nom::character::complete::char(')'),
                 nom::character::complete::multispace0,
-            )),
+            ),
             |(_, _, _, _, _, x, _, _, _)| Index::Variant(x),
         ),
         nom::combinator::map(
-            nom::sequence::tuple((
+            (
                 nom::character::complete::multispace0,
                 nom::bytes::complete::tag("position"),
                 nom::character::complete::multispace0,
                 nom::character::complete::char('('),
                 nom::character::complete::multispace0,
                 nom::multi::separated_list1(
-                    nom::sequence::tuple((
+                    (
                         nom::character::complete::multispace0,
                         nom::character::complete::char(','),
                         nom::character::complete::multispace0,
-                    )),
+                    ),
                     parse_identifier,
                 ),
                 nom::character::complete::multispace0,
                 nom::character::complete::char(')'),
                 nom::character::complete::multispace0,
-            )),
+            ),
             |(_, _, _, _, _, x, _, _, _)| {
                 Index::Position(
                     x.into_iter()
@@ -715,7 +721,8 @@ fn parse_index<'a>(
                 )
             },
         ),
-    ))(ir_text)?;
+    ))
+    .parse(ir_text)?;
     Ok((ir_text, idx))
 }
 
@@ -744,13 +751,14 @@ fn parse_read<'a>(ir_text: &'a str, context: &RefCell<Context<'a>>) -> nom::IRes
     let ir_text = nom::character::complete::char(',')(ir_text)?.0;
     let ir_text = nom::character::complete::multispace0(ir_text)?.0;
     let (ir_text, indices) = nom::multi::separated_list1(
-        nom::sequence::tuple((
+        (
             nom::character::complete::multispace0,
             nom::character::complete::char(','),
             nom::character::complete::multispace0,
-        )),
+        ),
         |x| parse_index(x, context),
-    )(ir_text)?;
+    )
+    .parse(ir_text)?;
     let ir_text = nom::character::complete::multispace0(ir_text)?.0;
     let ir_text = nom::character::complete::char(')')(ir_text)?.0;
     let collect = context.borrow_mut().get_node_id(collect);
@@ -779,13 +787,14 @@ fn parse_write<'a>(
     let ir_text = nom::character::complete::char(',')(ir_text)?.0;
     let ir_text = nom::character::complete::multispace0(ir_text)?.0;
     let (ir_text, indices) = nom::multi::separated_list1(
-        nom::sequence::tuple((
+        (
             nom::character::complete::multispace0,
             nom::character::complete::char(','),
             nom::character::complete::multispace0,
-        )),
+        ),
         |x| parse_index(x, context),
-    )(ir_text)?;
+    )
+    .parse(ir_text)?;
     let ir_text = nom::character::complete::multispace0(ir_text)?.0;
     let ir_text = nom::character::complete::char(')')(ir_text)?.0;
     let collect = context.borrow_mut().get_node_id(collect);
@@ -844,48 +853,48 @@ fn parse_type<'a>(ir_text: &'a str, context: &RefCell<Context<'a>>) -> nom::IRes
         nom::combinator::map(nom::bytes::complete::tag("f64"), |_| Type::Float64),
         // Product types are parsed as a list of their element types.
         nom::combinator::map(
-            nom::sequence::tuple((
+            (
                 nom::bytes::complete::tag("prod"),
                 nom::character::complete::multispace0,
                 nom::character::complete::char('('),
                 nom::character::complete::multispace0,
                 nom::multi::separated_list1(
-                    nom::sequence::tuple((
+                    (
                         nom::character::complete::multispace0,
                         nom::character::complete::char(','),
                         nom::character::complete::multispace0,
-                    )),
+                    ),
                     |x| parse_type_id(x, context),
                 ),
                 nom::character::complete::multispace0,
                 nom::character::complete::char(')'),
-            )),
+            ),
             |(_, _, _, _, ids, _, _)| Type::Product(ids.into_boxed_slice()),
         ),
         // Sum types are parsed as a list of their variant types.
         nom::combinator::map(
-            nom::sequence::tuple((
+            (
                 nom::bytes::complete::tag("sum"),
                 nom::character::complete::multispace0,
                 nom::character::complete::char('('),
                 nom::character::complete::multispace0,
                 nom::multi::separated_list1(
-                    nom::sequence::tuple((
+                    (
                         nom::character::complete::multispace0,
                         nom::character::complete::char(','),
                         nom::character::complete::multispace0,
-                    )),
+                    ),
                     |x| parse_type_id(x, context),
                 ),
                 nom::character::complete::multispace0,
                 nom::character::complete::char(')'),
-            )),
+            ),
             |(_, _, _, _, ids, _, _)| Type::Summation(ids.into_boxed_slice()),
         ),
         // Array types are just a list of an element type and at least one
         // dynamic constant representing its extent.
         nom::combinator::map(
-            nom::sequence::tuple((
+            (
                 nom::bytes::complete::tag("array"),
                 nom::character::complete::multispace0,
                 nom::character::complete::char('('),
@@ -895,21 +904,22 @@ fn parse_type<'a>(ir_text: &'a str, context: &RefCell<Context<'a>>) -> nom::IRes
                 nom::character::complete::char(','),
                 nom::character::complete::multispace0,
                 nom::multi::separated_list1(
-                    nom::sequence::tuple((
+                    (
                         nom::character::complete::multispace0,
                         nom::character::complete::char(','),
                         nom::character::complete::multispace0,
-                    )),
+                    ),
                     |x| parse_dynamic_constant_id(x, context),
                 ),
                 nom::character::complete::multispace0,
                 nom::character::complete::char(')'),
-            )),
+            ),
             |(_, _, _, _, ty_id, _, _, _, dc_ids, _, _)| {
                 Type::Array(ty_id, dc_ids.into_boxed_slice())
             },
         ),
-    ))(ir_text)?;
+    ))
+    .parse(ir_text)?;
     Ok((ir_text, ty))
 }
 
@@ -940,20 +950,20 @@ fn parse_dynamic_constant<'a>(
         // Parameter dynamic constants of a function are written by preprending
         // a '#' to the parameter's number.
         nom::combinator::map(
-            nom::sequence::tuple((nom::character::complete::char('#'), |x| {
+            (nom::character::complete::char('#'), |x| {
                 parse_prim::<usize>(x, "1234567890")
-            })),
+            }),
             |(_, x)| DynamicConstant::Parameter(x),
         ),
         // Dynamic constant math is written using a prefix function
         nom::combinator::map(
-            nom::sequence::tuple((
+            (
                 nom::character::complete::one_of("+-*/%"),
                 parse_tuple2(
                     |x| parse_dynamic_constant_id(x, context),
                     |x| parse_dynamic_constant_id(x, context),
                 ),
-            )),
+            ),
             |(op, (x, y))| match op {
                 '+' => DynamicConstant::Add(vec![x, y]),
                 '-' => DynamicConstant::Sub(x, y),
@@ -963,7 +973,8 @@ fn parse_dynamic_constant<'a>(
                 _ => panic!("Invalid parse"),
             },
         ),
-    ))(ir_text)?;
+    ))
+    .parse(ir_text)?;
     Ok((ir_text, dc))
 }
 
@@ -1041,7 +1052,8 @@ fn parse_boolean<'a>(ir_text: &'a str) -> nom::IResult<&'a str, Constant> {
     let (ir_text, val) = nom::branch::alt((
         nom::combinator::map(nom::bytes::complete::tag("false"), |_| false),
         nom::combinator::map(nom::bytes::complete::tag("true"), |_| true),
-    ))(ir_text)?;
+    ))
+    .parse(ir_text)?;
     Ok((ir_text, Constant::Boolean(val)))
 }
 
@@ -1178,7 +1190,8 @@ fn parse_identifier<'a>(ir_text: &'a str) -> nom::IResult<&'a str, &'a str> {
             "1234567890_@ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
         ),
         |s: &str| s.len() > 0,
-    )(ir_text)
+    )
+    .parse(ir_text)
 }
 
 /*
@@ -1186,7 +1199,7 @@ fn parse_identifier<'a>(ir_text: &'a str) -> nom::IResult<&'a str, &'a str> {
  */
 fn parse_tuple1<'a, A, AF>(mut parse_a: AF) -> impl FnMut(&'a str) -> nom::IResult<&'a str, (A,)>
 where
-    AF: nom::Parser<&'a str, A, nom::error::Error<&'a str>>,
+    AF: nom::Parser<&'a str, Output = A, Error = nom::error::Error<&'a str>>,
 {
     move |ir_text: &'a str| {
         let ir_text = nom::character::complete::multispace0(ir_text)?.0;
@@ -1204,8 +1217,8 @@ fn parse_tuple2<'a, A, B, AF, BF>(
     mut parse_b: BF,
 ) -> impl FnMut(&'a str) -> nom::IResult<&'a str, (A, B)>
 where
-    AF: nom::Parser<&'a str, A, nom::error::Error<&'a str>>,
-    BF: nom::Parser<&'a str, B, nom::error::Error<&'a str>>,
+    AF: nom::Parser<&'a str, Output = A, Error = nom::error::Error<&'a str>>,
+    BF: nom::Parser<&'a str, Output = B, Error = nom::error::Error<&'a str>>,
 {
     move |ir_text: &'a str| {
         let ir_text = nom::character::complete::multispace0(ir_text)?.0;
@@ -1228,9 +1241,9 @@ fn parse_tuple3<'a, A, B, C, AF, BF, CF>(
     mut parse_c: CF,
 ) -> impl FnMut(&'a str) -> nom::IResult<&'a str, (A, B, C)>
 where
-    AF: nom::Parser<&'a str, A, nom::error::Error<&'a str>>,
-    BF: nom::Parser<&'a str, B, nom::error::Error<&'a str>>,
-    CF: nom::Parser<&'a str, C, nom::error::Error<&'a str>>,
+    AF: nom::Parser<&'a str, Output = A, Error = nom::error::Error<&'a str>>,
+    BF: nom::Parser<&'a str, Output = B, Error = nom::error::Error<&'a str>>,
+    CF: nom::Parser<&'a str, Output = C, Error = nom::error::Error<&'a str>>,
 {
     move |ir_text: &'a str| {
         let ir_text = nom::character::complete::multispace0(ir_text)?.0;