microsoft/qdk
Publicmirrored from https://github.com/microsoft/qdkAvailable
compiler/qsc/benches/eval.rs
136lines · modecode
| 1 | // Copyright (c) Microsoft Corporation. |
| 2 | // Licensed under the MIT License. |
| 3 | |
| 4 | use criterion::{criterion_group, criterion_main, Criterion}; |
| 5 | use indoc::indoc; |
| 6 | use qsc::{interpret::stateful, PackageType}; |
| 7 | use qsc_eval::output::GenericReceiver; |
| 8 | use qsc_frontend::compile::{RuntimeCapabilityFlags, SourceMap}; |
| 9 | |
| 10 | const TELEPORT: &str = include_str!("../../../samples/algorithms/Teleportation.qs"); |
| 11 | const DEUTSCHJOZSA: &str = include_str!("../../../samples/algorithms/DeutschJozsa.qs"); |
| 12 | const LARGE: &str = include_str!("./large.qs"); |
| 13 | |
| 14 | pub fn teleport(c: &mut Criterion) { |
| 15 | c.bench_function("Teleport evaluation", |b| { |
| 16 | let sources = SourceMap::new([("Teleportation.qs".into(), TELEPORT.into())], None); |
| 17 | let mut evaluator = stateful::Interpreter::new( |
| 18 | true, |
| 19 | sources, |
| 20 | PackageType::Exe, |
| 21 | RuntimeCapabilityFlags::all(), |
| 22 | ) |
| 23 | .expect("code should compile"); |
| 24 | b.iter(move || { |
| 25 | let mut out = Vec::new(); |
| 26 | let mut rec = GenericReceiver::new(&mut out); |
| 27 | assert!(evaluator.eval_entry(&mut rec).is_ok()); |
| 28 | }) |
| 29 | }); |
| 30 | } |
| 31 | |
| 32 | pub fn deutsch_jozsa(c: &mut Criterion) { |
| 33 | c.bench_function("Deutsch-Jozsa evaluation", |b| { |
| 34 | let sources = SourceMap::new([("DeutschJozsa.qs".into(), DEUTSCHJOZSA.into())], None); |
| 35 | let mut evaluator = stateful::Interpreter::new( |
| 36 | true, |
| 37 | sources, |
| 38 | PackageType::Exe, |
| 39 | RuntimeCapabilityFlags::all(), |
| 40 | ) |
| 41 | .expect("code should compile"); |
| 42 | b.iter(move || { |
| 43 | let mut out = Vec::new(); |
| 44 | let mut rec = GenericReceiver::new(&mut out); |
| 45 | assert!(evaluator.eval_entry(&mut rec).is_ok()); |
| 46 | }) |
| 47 | }); |
| 48 | } |
| 49 | |
| 50 | pub fn large_file(c: &mut Criterion) { |
| 51 | c.bench_function("Large file parity evaluation", |b| { |
| 52 | let sources = SourceMap::new([("large.qs".into(), LARGE.into())], None); |
| 53 | let mut evaluator = stateful::Interpreter::new( |
| 54 | true, |
| 55 | sources, |
| 56 | PackageType::Exe, |
| 57 | RuntimeCapabilityFlags::all(), |
| 58 | ) |
| 59 | .expect("code should compile"); |
| 60 | b.iter(move || { |
| 61 | let mut out = Vec::new(); |
| 62 | let mut rec = GenericReceiver::new(&mut out); |
| 63 | assert!(evaluator.eval_entry(&mut rec).is_ok()); |
| 64 | }) |
| 65 | }); |
| 66 | } |
| 67 | |
| 68 | pub fn array_append(c: &mut Criterion) { |
| 69 | c.bench_function("Array append evaluation", |b| { |
| 70 | let sources = SourceMap::new( |
| 71 | [("none".into(), "".into())], |
| 72 | Some( |
| 73 | indoc! {"{ |
| 74 | mutable arr = []; |
| 75 | for i in 0..999 { |
| 76 | set arr += [i]; |
| 77 | } |
| 78 | arr |
| 79 | }"} |
| 80 | .into(), |
| 81 | ), |
| 82 | ); |
| 83 | let mut evaluator = stateful::Interpreter::new( |
| 84 | true, |
| 85 | sources, |
| 86 | PackageType::Exe, |
| 87 | RuntimeCapabilityFlags::all(), |
| 88 | ) |
| 89 | .expect("code should compile"); |
| 90 | b.iter(move || { |
| 91 | let mut out = Vec::new(); |
| 92 | let mut rec = GenericReceiver::new(&mut out); |
| 93 | assert!(evaluator.eval_entry(&mut rec).is_ok()); |
| 94 | }) |
| 95 | }); |
| 96 | } |
| 97 | |
| 98 | pub fn array_update(c: &mut Criterion) { |
| 99 | c.bench_function("Array update evaluation", |b| { |
| 100 | let sources = SourceMap::new( |
| 101 | [("none".into(), "".into())], |
| 102 | Some( |
| 103 | indoc! {"{ |
| 104 | mutable arr = [0, size = 10000]; |
| 105 | for i in 0..999 { |
| 106 | set arr w/= i <- i; |
| 107 | } |
| 108 | arr |
| 109 | }"} |
| 110 | .into(), |
| 111 | ), |
| 112 | ); |
| 113 | let mut evaluator = stateful::Interpreter::new( |
| 114 | true, |
| 115 | sources, |
| 116 | PackageType::Exe, |
| 117 | RuntimeCapabilityFlags::all(), |
| 118 | ) |
| 119 | .expect("code should compile"); |
| 120 | b.iter(move || { |
| 121 | let mut out = Vec::new(); |
| 122 | let mut rec = GenericReceiver::new(&mut out); |
| 123 | assert!(evaluator.eval_entry(&mut rec).is_ok()); |
| 124 | }) |
| 125 | }); |
| 126 | } |
| 127 | |
| 128 | criterion_group!( |
| 129 | benches, |
| 130 | teleport, |
| 131 | deutsch_jozsa, |
| 132 | large_file, |
| 133 | array_append, |
| 134 | array_update |
| 135 | ); |
| 136 | criterion_main!(benches); |
| 137 | |