Add Criterion benchmarks for parser (#7686)

This PR sets up [Criterion](https://github.com/bheisler/criterion.rs)
for benchmarking in the main `nu` crate, and adds some simple parser
benchmarks.

To run the benchmarks, just do `cargo bench` or `cargo bench -- <regex
matching benchmark names>` in the repo root:

```bash
〉cargo bench -- parse
...
     Running benches/parser_benchmark.rs (target/release/deps/parser_benchmark-75d224bac82d5b0b)
parse_default_env_file  time:   [221.17 µs 222.34 µs 223.61 µs]
Found 8 outliers among 100 measurements (8.00%)
  5 (5.00%) high mild
  3 (3.00%) high severe

parse_default_config_file
                        time:   [1.4935 ms 1.4993 ms 1.5059 ms]
Found 11 outliers among 100 measurements (11.00%)
  7 (7.00%) high mild
  4 (4.00%) high severe
```

Existing benchmarks from `nu-plugin` have been moved into the main `nu`
crate to keep all our benchmarks in one place.

benches/README.md

@@ -0,0 +1,7 @@
+# Criterion benchmarks
+
+These are benchmarks using [Criterion](https://github.com/bheisler/criterion.rs), a microbenchmarking tool for Rust.
+
+Run all benchmarks with `cargo bench`
+
+Or run individual benchmarks like `cargo bench -- <regex>` e.g. `cargo bench -- parse`

benches/encoder_benchmark.rs

@@ -0,0 +1,76 @@
+use criterion::{criterion_group, criterion_main, Criterion};
+use nu_plugin::{EncodingType, PluginResponse};
+use nu_protocol::{Span, Value};
+
+// generate a new table data with `row_cnt` rows, `col_cnt` columns.
+fn new_test_data(row_cnt: usize, col_cnt: usize) -> Value {
+    let columns: Vec<String> = (0..col_cnt).map(|x| format!("col_{x}")).collect();
+    let vals: Vec<Value> = (0..col_cnt as i64).map(Value::test_int).collect();
+
+    Value::List {
+        vals: (0..row_cnt)
+            .map(|_| Value::test_record(columns.clone(), vals.clone()))
+            .collect(),
+        span: Span::test_data(),
+    }
+}
+
+fn bench_encoding(c: &mut Criterion) {
+    let mut group = c.benchmark_group("Encoding");
+    let test_cnt_pairs = [
+        (100, 5),
+        (100, 10),
+        (100, 15),
+        (1000, 5),
+        (1000, 10),
+        (1000, 15),
+        (10000, 5),
+        (10000, 10),
+        (10000, 15),
+    ];
+    for (row_cnt, col_cnt) in test_cnt_pairs.into_iter() {
+        for fmt in ["json", "msgpack"] {
+            group.bench_function(&format!("{fmt} encode {row_cnt} * {col_cnt}"), |b| {
+                let mut res = vec![];
+                let test_data = PluginResponse::Value(Box::new(new_test_data(row_cnt, col_cnt)));
+                let encoder = EncodingType::try_from_bytes(fmt.as_bytes()).unwrap();
+                b.iter(|| encoder.encode_response(&test_data, &mut res))
+            });
+        }
+    }
+    group.finish();
+}
+
+fn bench_decoding(c: &mut Criterion) {
+    let mut group = c.benchmark_group("Decoding");
+    let test_cnt_pairs = [
+        (100, 5),
+        (100, 10),
+        (100, 15),
+        (1000, 5),
+        (1000, 10),
+        (1000, 15),
+        (10000, 5),
+        (10000, 10),
+        (10000, 15),
+    ];
+    for (row_cnt, col_cnt) in test_cnt_pairs.into_iter() {
+        for fmt in ["json", "msgpack"] {
+            group.bench_function(&format!("{fmt} decode for {row_cnt} * {col_cnt}"), |b| {
+                let mut res = vec![];
+                let test_data = PluginResponse::Value(Box::new(new_test_data(row_cnt, col_cnt)));
+                let encoder = EncodingType::try_from_bytes(fmt.as_bytes()).unwrap();
+                encoder.encode_response(&test_data, &mut res).unwrap();
+                let mut binary_data = std::io::Cursor::new(res);
+                b.iter(|| {
+                    binary_data.set_position(0);
+                    encoder.decode_response(&mut binary_data)
+                })
+            });
+        }
+    }
+    group.finish();
+}
+
+criterion_group!(benches, bench_encoding, bench_decoding);
+criterion_main!(benches);

benches/parser_benchmark.rs

@@ -0,0 +1,34 @@
+use criterion::{criterion_group, criterion_main, BatchSize, Criterion};
+use nu_parser::parse;
+use nu_protocol::{Span, Value};
+use nu_utils::{get_default_config, get_default_env};
+
+fn criterion_benchmark(c: &mut Criterion) {
+    let mut engine_state = nu_command::create_default_context();
+    // parsing config.nu breaks without PWD set
+    engine_state.add_env_var(
+        "PWD".into(),
+        Value::string("/some/dir".to_string(), Span::test_data()),
+    );
+
+    let default_env = get_default_env().as_bytes();
+    c.bench_function("parse_default_env_file", |b| {
+        b.iter_batched(
+            || nu_protocol::engine::StateWorkingSet::new(&engine_state),
+            |mut working_set| parse(&mut working_set, None, default_env, false, &[]),
+            BatchSize::SmallInput,
+        )
+    });
+
+    let default_config = get_default_config().as_bytes();
+    c.bench_function("parse_default_config_file", |b| {
+        b.iter_batched(
+            || nu_protocol::engine::StateWorkingSet::new(&engine_state),
+            |mut working_set| parse(&mut working_set, None, default_config, false, &[]),
+            BatchSize::SmallInput,
+        )
+    });
+}
+
+criterion_group!(benches, criterion_benchmark);
+criterion_main!(benches);