Refactor evaluator to reduce stack use (#294)

This change refactors the evaluator to use a "stackless" design where
the stack is tracked manually via data structures instead of via literal
progam stack. This allows for better avoidance of stack overflow at the
cost of some performance. To help track performance characteristics,
this also introduces benchmarks based on evaluating some programs from
the samples folder.

Author: swernli

compiler/qsc/Cargo.toml

@@ -26,10 +26,25 @@ thiserror = { workspace = true }
 criterion = { workspace = true, features = ["cargo_bench_support"] }
 indoc = { workspace = true }
 
+[lib]
+bench = false
+
+[[bin]]
+name = "qsc"
+bench = false
+
+[[bin]]
+name = "qsi"
+bench = false
+
 [[bench]]
 name = "nqueens"
 harness = false
 
 [[bench]]
 name = "library"
 harness = false
+
+[[bench]]
+name = "eval"
+harness = false

compiler/qsc/benches/eval.rs

@@ -0,0 +1,37 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+use criterion::{criterion_group, criterion_main, Criterion};
+use qsc::interpret::stateless;
+use qsc_eval::output::GenericReceiver;
+use qsc_frontend::compile::SourceMap;
+
+const TELEPORT: &str = include_str!("../../../samples/Teleportation.qs");
+const DEUTSCHJOZSA: &str = include_str!("../../../samples/DeutschJozsa.qs");
+
+pub fn teleport(c: &mut Criterion) {
+    c.bench_function("Teleport evaluation", |b| {
+        let sources = SourceMap::new([("Teleportation.qs".into(), TELEPORT.into())], None);
+        let evaluator = stateless::Context::new(true, sources).expect("code should compile");
+        b.iter(move || {
+            let mut out = Vec::new();
+            let mut rec = GenericReceiver::new(&mut out);
+            assert!(evaluator.eval(&mut rec).is_ok());
+        })
+    });
+}
+
+pub fn deutsch_jozsa(c: &mut Criterion) {
+    c.bench_function("Deutsch-Jozsa evaluation", |b| {
+        let sources = SourceMap::new([("DeutschJozsa.qs".into(), DEUTSCHJOZSA.into())], None);
+        let evaluator = stateless::Context::new(true, sources).expect("code should compile");
+        b.iter(move || {
+            let mut out = Vec::new();
+            let mut rec = GenericReceiver::new(&mut out);
+            assert!(evaluator.eval(&mut rec).is_ok());
+        })
+    });
+}
+
+criterion_group!(benches, teleport, deutsch_jozsa);
+criterion_main!(benches);

compiler/qsc/src/compile.rs

@@ -4,8 +4,8 @@
 use crate::error::WithSource;
 use miette::{Diagnostic, Report};
 use qsc_frontend::compile::{CompileUnit, PackageStore, SourceMap};
-use qsc_hir::{global, hir::PackageId};
-use qsc_passes::run_default_passes;
+use qsc_hir::hir::PackageId;
+use qsc_passes::{run_core_passes, run_default_passes};
 use thiserror::Error;
 
 #[derive(Clone, Debug, Diagnostic, Error)]
@@ -45,18 +45,8 @@ pub fn compile(
 #[must_use]
 pub fn core() -> CompileUnit {
     let mut unit = qsc_frontend::compile::core();
-    let table = global::iter_package(None, &unit.package).collect();
-    let pass_errors = run_default_passes(&table, &mut unit);
-    if pass_errors.is_empty() {
-        unit
-    } else {
-        for error in pass_errors {
-            let report = Report::new(WithSource::from_map(&unit.sources, error, None));
-            eprintln!("{report:?}");
-        }
-
-        panic!("could not compile core library")
-    }
+    run_core_passes(&mut unit);
+    unit
 }
 
 /// Compiles the standard library.

compiler/qsc/src/interpret/stateful/tests.rs

@@ -222,6 +222,23 @@ mod given_interpreter {
             );
             is_unit_with_output(&result, &output, "before\nafter");
         }
+
+        #[test]
+        fn global_qubits() {
+            let mut interpreter = get_interpreter();
+            let (result, output) = line(&mut interpreter, "open Microsoft.Quantum.Diagnostics;");
+            is_only_value(&result, &output, &Value::unit());
+            let (result, output) = line(&mut interpreter, "DumpMachine()");
+            is_unit_with_output(&result, &output, "STATE:\n|0⟩: 1+0i");
+            let (result, output) = line(&mut interpreter, "use (q0, qs) = (Qubit(), Qubit[3]);");
+            is_only_value(&result, &output, &Value::unit());
+            let (result, output) = line(&mut interpreter, "DumpMachine()");
+            is_unit_with_output(&result, &output, "STATE:\n|0000⟩: 1+0i");
+            let (result, output) = line(&mut interpreter, "X(q0); X(qs[1]);");
+            is_only_value(&result, &output, &Value::unit());
+            let (result, output) = line(&mut interpreter, "DumpMachine()");
+            is_unit_with_output(&result, &output, "STATE:\n|0101⟩: 1+0i");
+        }
     }
 
     #[cfg(test)]