Parser benchmarks (#16)

crates/air-parser/benches/parser.rs

@@ -0,0 +1,130 @@
+/*
+ * Copyright 2020 Fluence Labs Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#[macro_use]
+extern crate fstrings;
+
+use std::rc::Rc;
+
+use criterion::criterion_group;
+use criterion::criterion_main;
+use criterion::Criterion;
+
+use air_parser::InstrParser;
+
+const SOURCE_CODE_BAD: &'static str = r#"(seq
+        (seq
+            (call node ("identity" "") [] void[])
+            (call provider (service_id "{fname}") {arg_list} result)
+        )
+        (seq
+            (call node ("identity" "") [] void[])
+            (call "{LOCAL_VM}" ("return" "result") [result] void[])
+        )
+    )"#;
+
+const SOURCE_CODE_GOOD: &'static str = r#"
+    (seq
+        (seq
+            (call node ("identity" "") [] void[])
+            (call provider (service_id "fname") [arg list] result)
+        )
+        (seq
+            (call node ("identity" "") [] void[])
+            (call "local_vm" ("return" "result") [result] void[])
+        )
+    )"#;
+
+#[cfg(test)]
+mod gen {
+    use crate::SOURCE_CODE_GOOD;
+
+    pub fn seq(left: &str, right: &str) -> String {
+        f!(r"(seq {left} {right})")
+    }
+
+    pub fn deep_seq(mut depth: usize) -> String {
+        let mut instr = SOURCE_CODE_GOOD.to_string();
+        loop {
+            depth -= 1;
+            if depth == 0 {
+                break;
+            }
+            instr = seq(&instr, &instr)
+        }
+
+        instr
+    }
+}
+
+fn bench_creation(c: &mut Criterion) {
+    c.bench_function("create_parser", move |b| b.iter(move || InstrParser::new()));
+}
+
+fn parse(c: &mut Criterion) {
+    let parser = Rc::new(InstrParser::new());
+    c.bench_function(
+        format!("parse {} bytes", SOURCE_CODE_GOOD.len()).as_str(),
+        move |b| {
+            let parser = parser.clone();
+            b.iter(move || {
+                parser
+                    .clone()
+                    .parse(&mut Vec::new(), SOURCE_CODE_GOOD)
+                    .expect("success")
+            })
+        },
+    );
+}
+
+fn parse_to_fail(c: &mut Criterion) {
+    let parser = Rc::new(InstrParser::new());
+    c.bench_function(
+        format!("parse {} bytes to FAIL", SOURCE_CODE_BAD.len()).as_str(),
+        move |b| {
+            let parser = parser.clone();
+            b.iter(move || parser.clone().parse(&mut Vec::new(), SOURCE_CODE_BAD))
+        },
+    );
+}
+
+fn parse_deep(c: &mut Criterion) {
+    let parser = Rc::new(InstrParser::new());
+    let source_code: Vec<_> = (1..10).map(gen::deep_seq).collect();
+    let index: Vec<_> = source_code
+        .iter()
+        .enumerate()
+        .map(|(i, code)| (i, code.len()))
+        .collect();
+
+    c.bench_function_over_inputs(
+        "parse generated script",
+        move |b, (i, _)| {
+            let parser = parser.clone();
+            let code = &source_code[*i];
+            b.iter(move || {
+                parser
+                    .clone()
+                    .parse(&mut Vec::new(), code)
+                    .expect("success")
+            });
+        },
+        index,
+    );
+}
+
+criterion_group!(benches, bench_creation, parse, parse_to_fail, parse_deep);
+criterion_main!(benches);