2024-03-09 17:59:55 +01:00
|
|
|
use nu_cli::{eval_source, evaluate_commands};
|
2023-01-11 02:51:25 +01:00
|
|
|
use nu_parser::parse;
|
2024-02-25 23:32:50 +01:00
|
|
|
use nu_plugin::{Encoder, EncodingType, PluginCallResponse, PluginOutput};
|
2024-02-27 18:55:26 +01:00
|
|
|
use nu_protocol::{
|
2024-03-26 16:17:44 +01:00
|
|
|
engine::{EngineState, Stack},
|
|
|
|
eval_const::create_nu_constant,
|
|
|
|
PipelineData, Span, Spanned, Value, NU_VARIABLE_ID,
|
2024-02-27 18:55:26 +01:00
|
|
|
};
|
2024-03-09 17:59:55 +01:00
|
|
|
use nu_std::load_standard_library;
|
2023-01-11 02:51:25 +01:00
|
|
|
use nu_utils::{get_default_config, get_default_env};
|
2023-12-07 15:13:50 +01:00
|
|
|
use std::path::{Path, PathBuf};
|
2023-01-11 02:51:25 +01:00
|
|
|
|
2024-03-01 19:09:21 +01:00
|
|
|
fn main() {
|
|
|
|
// Run registered benchmarks.
|
|
|
|
divan::main();
|
|
|
|
}
|
|
|
|
|
2023-06-17 14:41:29 +02:00
|
|
|
fn load_bench_commands() -> EngineState {
|
|
|
|
nu_command::add_shell_command_context(nu_cmd_lang::create_default_context())
|
|
|
|
}
|
2023-12-07 15:13:50 +01:00
|
|
|
|
|
|
|
fn canonicalize_path(engine_state: &EngineState, path: &Path) -> PathBuf {
|
|
|
|
let cwd = engine_state.current_work_dir();
|
|
|
|
|
|
|
|
if path.exists() {
|
|
|
|
match nu_path::canonicalize_with(path, cwd) {
|
|
|
|
Ok(canon_path) => canon_path,
|
|
|
|
Err(_) => path.to_owned(),
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
path.to_owned()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn get_home_path(engine_state: &EngineState) -> PathBuf {
|
2023-12-16 21:06:42 +01:00
|
|
|
nu_path::home_dir()
|
|
|
|
.map(|path| canonicalize_path(engine_state, &path))
|
|
|
|
.unwrap_or_default()
|
2023-12-07 15:13:50 +01:00
|
|
|
}
|
|
|
|
|
2024-03-01 19:09:21 +01:00
|
|
|
fn setup_engine() -> EngineState {
|
2023-06-17 14:41:29 +02:00
|
|
|
let mut engine_state = load_bench_commands();
|
2023-12-07 15:13:50 +01:00
|
|
|
let home_path = get_home_path(&engine_state);
|
|
|
|
|
|
|
|
// parsing config.nu breaks without PWD set, so set a valid path
|
2023-01-11 02:51:25 +01:00
|
|
|
engine_state.add_env_var(
|
|
|
|
"PWD".into(),
|
2023-12-07 15:13:50 +01:00
|
|
|
Value::string(home_path.to_string_lossy(), Span::test_data()),
|
2023-01-11 02:51:25 +01:00
|
|
|
);
|
|
|
|
|
2024-03-01 19:09:21 +01:00
|
|
|
let nu_const = create_nu_constant(&engine_state, Span::unknown())
|
|
|
|
.expect("Failed to create nushell constant.");
|
|
|
|
engine_state.set_variable_const_val(NU_VARIABLE_ID, nu_const);
|
|
|
|
|
|
|
|
engine_state
|
2023-01-11 02:51:25 +01:00
|
|
|
}
|
|
|
|
|
2024-03-26 16:17:44 +01:00
|
|
|
fn bench_command(bencher: divan::Bencher, scaled_command: String) {
|
|
|
|
bench_command_with_custom_stack_and_engine(
|
|
|
|
bencher,
|
|
|
|
scaled_command,
|
|
|
|
Stack::new(),
|
|
|
|
setup_engine(),
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
|
|
|
fn bench_command_with_custom_stack_and_engine(
|
|
|
|
bencher: divan::Bencher,
|
|
|
|
scaled_command: String,
|
|
|
|
stack: nu_protocol::engine::Stack,
|
|
|
|
mut engine: EngineState,
|
|
|
|
) {
|
|
|
|
load_standard_library(&mut engine).unwrap();
|
|
|
|
let commands = Spanned {
|
|
|
|
span: Span::unknown(),
|
|
|
|
item: scaled_command,
|
|
|
|
};
|
|
|
|
|
|
|
|
bencher
|
|
|
|
.with_inputs(|| engine.clone())
|
|
|
|
.bench_values(|mut engine| {
|
|
|
|
evaluate_commands(
|
|
|
|
&commands,
|
|
|
|
&mut engine,
|
|
|
|
&mut stack.clone(),
|
|
|
|
PipelineData::empty(),
|
|
|
|
None,
|
2024-04-09 16:04:00 +02:00
|
|
|
false,
|
2024-03-26 16:17:44 +01:00
|
|
|
)
|
|
|
|
.unwrap();
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
|
|
|
fn setup_stack_and_engine_from_command(command: &str) -> (Stack, EngineState) {
|
|
|
|
let mut engine = setup_engine();
|
|
|
|
let commands = Spanned {
|
|
|
|
span: Span::unknown(),
|
|
|
|
item: command.to_string(),
|
|
|
|
};
|
|
|
|
|
|
|
|
let mut stack = Stack::new();
|
|
|
|
evaluate_commands(
|
|
|
|
&commands,
|
|
|
|
&mut engine,
|
|
|
|
&mut stack,
|
|
|
|
PipelineData::empty(),
|
|
|
|
None,
|
2024-04-09 16:04:00 +02:00
|
|
|
false,
|
2024-03-26 16:17:44 +01:00
|
|
|
)
|
|
|
|
.unwrap();
|
|
|
|
|
|
|
|
(stack, engine)
|
|
|
|
}
|
|
|
|
|
2024-03-01 19:09:21 +01:00
|
|
|
// FIXME: All benchmarks live in this 1 file to speed up build times when benchmarking.
|
|
|
|
// When the *_benchmarks functions were in different files, `cargo bench` would build
|
|
|
|
// an executable for every single one - incredibly slowly. Would be nice to figure out
|
|
|
|
// a way to split things up again.
|
2023-12-07 15:13:50 +01:00
|
|
|
|
2024-03-09 17:59:55 +01:00
|
|
|
#[divan::bench]
|
|
|
|
fn load_standard_lib(bencher: divan::Bencher) {
|
|
|
|
let engine = setup_engine();
|
|
|
|
bencher
|
|
|
|
.with_inputs(|| engine.clone())
|
|
|
|
.bench_values(|mut engine| {
|
|
|
|
load_standard_library(&mut engine).unwrap();
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
|
|
|
#[divan::bench_group]
|
2024-03-26 16:17:44 +01:00
|
|
|
mod record {
|
|
|
|
|
2024-03-09 17:59:55 +01:00
|
|
|
use super::*;
|
|
|
|
|
2024-03-26 16:17:44 +01:00
|
|
|
fn create_flat_record_string(n: i32) -> String {
|
|
|
|
let mut s = String::from("let record = {");
|
|
|
|
for i in 0..n {
|
|
|
|
s.push_str(&format!("col_{}: {}", i, i));
|
|
|
|
if i < n - 1 {
|
|
|
|
s.push_str(", ");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
s.push('}');
|
|
|
|
s
|
2024-03-09 17:59:55 +01:00
|
|
|
}
|
|
|
|
|
2024-03-26 16:17:44 +01:00
|
|
|
fn create_nested_record_string(depth: i32) -> String {
|
|
|
|
let mut s = String::from("let record = {");
|
|
|
|
for _ in 0..depth {
|
2024-03-26 20:37:46 +01:00
|
|
|
s.push_str("col: {");
|
2024-03-26 16:17:44 +01:00
|
|
|
}
|
|
|
|
s.push_str("col_final: 0");
|
|
|
|
for _ in 0..depth {
|
|
|
|
s.push('}');
|
|
|
|
}
|
|
|
|
s.push('}');
|
|
|
|
s
|
|
|
|
}
|
|
|
|
|
|
|
|
#[divan::bench(args = [1, 10, 100, 1000])]
|
|
|
|
fn create(bencher: divan::Bencher, n: i32) {
|
|
|
|
bench_command(bencher, create_flat_record_string(n));
|
|
|
|
}
|
|
|
|
|
|
|
|
#[divan::bench(args = [1, 10, 100, 1000])]
|
|
|
|
fn flat_access(bencher: divan::Bencher, n: i32) {
|
|
|
|
let (stack, engine) = setup_stack_and_engine_from_command(&create_flat_record_string(n));
|
|
|
|
bench_command_with_custom_stack_and_engine(
|
|
|
|
bencher,
|
|
|
|
"$record.col_0 | ignore".to_string(),
|
|
|
|
stack,
|
|
|
|
engine,
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
#[divan::bench(args = [1, 2, 4, 8, 16, 32, 64, 128])]
|
|
|
|
fn nest_access(bencher: divan::Bencher, depth: i32) {
|
|
|
|
let (stack, engine) =
|
|
|
|
setup_stack_and_engine_from_command(&create_nested_record_string(depth));
|
|
|
|
let nested_access = ".col".repeat(depth as usize);
|
|
|
|
bench_command_with_custom_stack_and_engine(
|
|
|
|
bencher,
|
|
|
|
format!("$record{} | ignore", nested_access),
|
|
|
|
stack,
|
|
|
|
engine,
|
|
|
|
);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-03-26 18:59:52 +01:00
|
|
|
#[divan::bench_group]
|
|
|
|
mod table {
|
|
|
|
|
|
|
|
use super::*;
|
|
|
|
|
|
|
|
fn create_example_table_nrows(n: i32) -> String {
|
|
|
|
let mut s = String::from("let table = [[foo bar baz]; ");
|
|
|
|
for i in 0..n {
|
|
|
|
s.push_str(&format!("[0, 1, {i}]"));
|
|
|
|
if i < n - 1 {
|
|
|
|
s.push_str(", ");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
s.push(']');
|
|
|
|
s
|
|
|
|
}
|
|
|
|
|
|
|
|
#[divan::bench(args = [1, 10, 100, 1000])]
|
|
|
|
fn create(bencher: divan::Bencher, n: i32) {
|
|
|
|
bench_command(bencher, create_example_table_nrows(n));
|
|
|
|
}
|
|
|
|
|
|
|
|
#[divan::bench(args = [1, 10, 100, 1000])]
|
|
|
|
fn get(bencher: divan::Bencher, n: i32) {
|
|
|
|
let (stack, engine) = setup_stack_and_engine_from_command(&create_example_table_nrows(n));
|
|
|
|
bench_command_with_custom_stack_and_engine(
|
|
|
|
bencher,
|
|
|
|
"$table | get bar | math sum | ignore".to_string(),
|
|
|
|
stack,
|
|
|
|
engine,
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
#[divan::bench(args = [1, 10, 100, 1000])]
|
|
|
|
fn select(bencher: divan::Bencher, n: i32) {
|
|
|
|
let (stack, engine) = setup_stack_and_engine_from_command(&create_example_table_nrows(n));
|
|
|
|
bench_command_with_custom_stack_and_engine(
|
|
|
|
bencher,
|
|
|
|
"$table | select foo baz | ignore".to_string(),
|
|
|
|
stack,
|
|
|
|
engine,
|
|
|
|
);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-03-26 16:17:44 +01:00
|
|
|
#[divan::bench_group]
|
|
|
|
mod eval_commands {
|
|
|
|
use super::*;
|
|
|
|
|
2024-03-12 13:10:37 +01:00
|
|
|
#[divan::bench(args = [100, 1_000, 10_000])]
|
|
|
|
fn interleave(bencher: divan::Bencher, n: i32) {
|
|
|
|
bench_command(
|
|
|
|
bencher,
|
|
|
|
format!("seq 1 {n} | wrap a | interleave {{ seq 1 {n} | wrap b }} | ignore"),
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
|
|
|
#[divan::bench(args = [100, 1_000, 10_000])]
|
|
|
|
fn interleave_with_ctrlc(bencher: divan::Bencher, n: i32) {
|
2024-03-09 17:59:55 +01:00
|
|
|
let mut engine = setup_engine();
|
2024-03-12 13:10:37 +01:00
|
|
|
engine.ctrlc = Some(std::sync::Arc::new(std::sync::atomic::AtomicBool::new(
|
|
|
|
false,
|
|
|
|
)));
|
2024-03-09 17:59:55 +01:00
|
|
|
load_standard_library(&mut engine).unwrap();
|
|
|
|
let commands = Spanned {
|
|
|
|
span: Span::unknown(),
|
2024-03-12 13:10:37 +01:00
|
|
|
item: format!("seq 1 {n} | wrap a | interleave {{ seq 1 {n} | wrap b }} | ignore"),
|
2024-03-09 17:59:55 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
bencher
|
2024-03-12 13:10:37 +01:00
|
|
|
.with_inputs(|| engine.clone())
|
|
|
|
.bench_values(|mut engine| {
|
2024-03-09 17:59:55 +01:00
|
|
|
evaluate_commands(
|
|
|
|
&commands,
|
|
|
|
&mut engine,
|
2024-03-12 13:10:37 +01:00
|
|
|
&mut nu_protocol::engine::Stack::new(),
|
2024-03-09 17:59:55 +01:00
|
|
|
PipelineData::empty(),
|
|
|
|
None,
|
2024-04-09 16:04:00 +02:00
|
|
|
false,
|
2024-03-09 17:59:55 +01:00
|
|
|
)
|
|
|
|
.unwrap();
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
|
|
|
#[divan::bench(args = [1, 5, 10, 100, 1_000])]
|
2024-03-12 13:10:37 +01:00
|
|
|
fn for_range(bencher: divan::Bencher, n: i32) {
|
|
|
|
bench_command(bencher, format!("(for $x in (1..{}) {{ sleep 50ns }})", n))
|
|
|
|
}
|
2024-03-09 17:59:55 +01:00
|
|
|
|
2024-03-12 13:10:37 +01:00
|
|
|
#[divan::bench(args = [1, 5, 10, 100, 1_000])]
|
|
|
|
fn each(bencher: divan::Bencher, n: i32) {
|
|
|
|
bench_command(
|
|
|
|
bencher,
|
|
|
|
format!("(1..{}) | each {{|_| sleep 50ns }} | ignore", n),
|
|
|
|
)
|
2024-03-09 17:59:55 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
#[divan::bench(args = [1, 5, 10, 100, 1_000])]
|
|
|
|
fn par_each_1t(bencher: divan::Bencher, n: i32) {
|
2024-03-12 13:10:37 +01:00
|
|
|
bench_command(
|
|
|
|
bencher,
|
|
|
|
format!("(1..{}) | par-each -t 1 {{|_| sleep 50ns }} | ignore", n),
|
|
|
|
)
|
2024-03-09 17:59:55 +01:00
|
|
|
}
|
2024-03-12 13:10:37 +01:00
|
|
|
|
2024-03-09 17:59:55 +01:00
|
|
|
#[divan::bench(args = [1, 5, 10, 100, 1_000])]
|
|
|
|
fn par_each_2t(bencher: divan::Bencher, n: i32) {
|
2024-03-12 13:10:37 +01:00
|
|
|
bench_command(
|
|
|
|
bencher,
|
|
|
|
format!("(1..{}) | par-each -t 2 {{|_| sleep 50ns }} | ignore", n),
|
|
|
|
)
|
2024-03-09 17:59:55 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-03-01 19:09:21 +01:00
|
|
|
#[divan::bench_group()]
|
|
|
|
mod parser_benchmarks {
|
|
|
|
use super::*;
|
2023-12-07 15:13:50 +01:00
|
|
|
|
2024-03-01 19:09:21 +01:00
|
|
|
#[divan::bench()]
|
|
|
|
fn parse_default_config_file(bencher: divan::Bencher) {
|
|
|
|
let engine_state = setup_engine();
|
|
|
|
let default_env = get_default_config().as_bytes();
|
|
|
|
|
|
|
|
bencher
|
|
|
|
.with_inputs(|| nu_protocol::engine::StateWorkingSet::new(&engine_state))
|
2024-03-09 18:23:32 +01:00
|
|
|
.bench_refs(|working_set| parse(working_set, None, default_env, false))
|
2024-03-01 19:09:21 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
#[divan::bench()]
|
|
|
|
fn parse_default_env_file(bencher: divan::Bencher) {
|
|
|
|
let engine_state = setup_engine();
|
|
|
|
let default_env = get_default_env().as_bytes();
|
|
|
|
|
|
|
|
bencher
|
|
|
|
.with_inputs(|| nu_protocol::engine::StateWorkingSet::new(&engine_state))
|
2024-03-09 18:23:32 +01:00
|
|
|
.bench_refs(|working_set| parse(working_set, None, default_env, false))
|
2024-03-01 19:09:21 +01:00
|
|
|
}
|
|
|
|
}
|
2024-02-27 18:55:26 +01:00
|
|
|
|
2024-03-01 19:09:21 +01:00
|
|
|
#[divan::bench_group()]
|
|
|
|
mod eval_benchmarks {
|
|
|
|
use super::*;
|
|
|
|
|
|
|
|
#[divan::bench()]
|
|
|
|
fn eval_default_env(bencher: divan::Bencher) {
|
|
|
|
let default_env = get_default_env().as_bytes();
|
|
|
|
let fname = "default_env.nu";
|
|
|
|
bencher
|
|
|
|
.with_inputs(|| (setup_engine(), nu_protocol::engine::Stack::new()))
|
|
|
|
.bench_values(|(mut engine_state, mut stack)| {
|
|
|
|
eval_source(
|
|
|
|
&mut engine_state,
|
|
|
|
&mut stack,
|
|
|
|
default_env,
|
|
|
|
fname,
|
|
|
|
PipelineData::empty(),
|
|
|
|
false,
|
|
|
|
)
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
|
|
|
#[divan::bench()]
|
|
|
|
fn eval_default_config(bencher: divan::Bencher) {
|
|
|
|
let default_env = get_default_config().as_bytes();
|
|
|
|
let fname = "default_config.nu";
|
|
|
|
bencher
|
|
|
|
.with_inputs(|| (setup_engine(), nu_protocol::engine::Stack::new()))
|
|
|
|
.bench_values(|(mut engine_state, mut stack)| {
|
|
|
|
eval_source(
|
|
|
|
&mut engine_state,
|
|
|
|
&mut stack,
|
|
|
|
default_env,
|
|
|
|
fname,
|
|
|
|
PipelineData::empty(),
|
|
|
|
false,
|
|
|
|
)
|
|
|
|
})
|
|
|
|
}
|
2023-01-11 02:51:25 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// generate a new table data with `row_cnt` rows, `col_cnt` columns.
|
|
|
|
fn encoding_test_data(row_cnt: usize, col_cnt: usize) -> Value {
|
Create `Record` type (#10103)
# Description
This PR creates a new `Record` type to reduce duplicate code and
possibly bugs as well. (This is an edited version of #9648.)
- `Record` implements `FromIterator` and `IntoIterator` and so can be
iterated over or collected into. For example, this helps with
conversions to and from (hash)maps. (Also, no more
`cols.iter().zip(vals)`!)
- `Record` has a `push(col, val)` function to help insure that the
number of columns is equal to the number of values. I caught a few
potential bugs thanks to this (e.g. in the `ls` command).
- Finally, this PR also adds a `record!` macro that helps simplify
record creation. It is used like so:
```rust
record! {
"key1" => some_value,
"key2" => Value::string("text", span),
"key3" => Value::int(optional_int.unwrap_or(0), span),
"key4" => Value::bool(config.setting, span),
}
```
Since macros hinder formatting, etc., the right hand side values should
be relatively short and sweet like the examples above.
Where possible, prefer `record!` or `.collect()` on an iterator instead
of multiple `Record::push`s, since the first two automatically set the
record capacity and do less work overall.
# User-Facing Changes
Besides the changes in `nu-protocol` the only other breaking changes are
to `nu-table::{ExpandedTable::build_map, JustTable::kv_table}`.
2023-08-24 21:50:29 +02:00
|
|
|
let record = Value::test_record(
|
|
|
|
(0..col_cnt)
|
|
|
|
.map(|x| (format!("col_{x}"), Value::test_int(x as i64)))
|
|
|
|
.collect(),
|
|
|
|
);
|
2023-01-11 02:51:25 +01:00
|
|
|
|
2023-09-03 16:27:29 +02:00
|
|
|
Value::list(vec![record; row_cnt], Span::test_data())
|
2023-01-11 02:51:25 +01:00
|
|
|
}
|
|
|
|
|
2024-03-01 19:09:21 +01:00
|
|
|
#[divan::bench_group()]
|
|
|
|
mod encoding_benchmarks {
|
|
|
|
use super::*;
|
|
|
|
|
|
|
|
#[divan::bench(args = [(100, 5), (10000, 15)])]
|
|
|
|
fn json_encode(bencher: divan::Bencher, (row_cnt, col_cnt): (usize, usize)) {
|
|
|
|
let test_data = PluginOutput::CallResponse(
|
|
|
|
0,
|
|
|
|
PluginCallResponse::value(encoding_test_data(row_cnt, col_cnt)),
|
|
|
|
);
|
|
|
|
let encoder = EncodingType::try_from_bytes(b"json").unwrap();
|
|
|
|
bencher
|
2024-03-09 18:23:32 +01:00
|
|
|
.with_inputs(Vec::new)
|
2024-03-01 19:09:21 +01:00
|
|
|
.bench_values(|mut res| encoder.encode(&test_data, &mut res))
|
2023-01-11 02:51:25 +01:00
|
|
|
}
|
|
|
|
|
2024-03-01 19:09:21 +01:00
|
|
|
#[divan::bench(args = [(100, 5), (10000, 15)])]
|
|
|
|
fn msgpack_encode(bencher: divan::Bencher, (row_cnt, col_cnt): (usize, usize)) {
|
|
|
|
let test_data = PluginOutput::CallResponse(
|
|
|
|
0,
|
|
|
|
PluginCallResponse::value(encoding_test_data(row_cnt, col_cnt)),
|
|
|
|
);
|
|
|
|
let encoder = EncodingType::try_from_bytes(b"msgpack").unwrap();
|
|
|
|
bencher
|
2024-03-09 18:23:32 +01:00
|
|
|
.with_inputs(Vec::new)
|
2024-03-01 19:09:21 +01:00
|
|
|
.bench_values(|mut res| encoder.encode(&test_data, &mut res))
|
2023-01-11 02:51:25 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-03-01 19:09:21 +01:00
|
|
|
#[divan::bench_group()]
|
|
|
|
mod decoding_benchmarks {
|
|
|
|
use super::*;
|
|
|
|
|
|
|
|
#[divan::bench(args = [(100, 5), (10000, 15)])]
|
|
|
|
fn json_decode(bencher: divan::Bencher, (row_cnt, col_cnt): (usize, usize)) {
|
|
|
|
let test_data = PluginOutput::CallResponse(
|
|
|
|
0,
|
|
|
|
PluginCallResponse::value(encoding_test_data(row_cnt, col_cnt)),
|
|
|
|
);
|
|
|
|
let encoder = EncodingType::try_from_bytes(b"json").unwrap();
|
|
|
|
let mut res = vec![];
|
|
|
|
encoder.encode(&test_data, &mut res).unwrap();
|
|
|
|
bencher
|
|
|
|
.with_inputs(|| {
|
|
|
|
let mut binary_data = std::io::Cursor::new(res.clone());
|
|
|
|
binary_data.set_position(0);
|
|
|
|
binary_data
|
|
|
|
})
|
|
|
|
.bench_values(|mut binary_data| -> Result<Option<PluginOutput>, _> {
|
|
|
|
encoder.decode(&mut binary_data)
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
|
|
|
#[divan::bench(args = [(100, 5), (10000, 15)])]
|
|
|
|
fn msgpack_decode(bencher: divan::Bencher, (row_cnt, col_cnt): (usize, usize)) {
|
|
|
|
let test_data = PluginOutput::CallResponse(
|
|
|
|
0,
|
|
|
|
PluginCallResponse::value(encoding_test_data(row_cnt, col_cnt)),
|
|
|
|
);
|
|
|
|
let encoder = EncodingType::try_from_bytes(b"msgpack").unwrap();
|
|
|
|
let mut res = vec![];
|
|
|
|
encoder.encode(&test_data, &mut res).unwrap();
|
|
|
|
bencher
|
|
|
|
.with_inputs(|| {
|
|
|
|
let mut binary_data = std::io::Cursor::new(res.clone());
|
|
|
|
binary_data.set_position(0);
|
|
|
|
binary_data
|
|
|
|
})
|
|
|
|
.bench_values(|mut binary_data| -> Result<Option<PluginOutput>, _> {
|
|
|
|
encoder.decode(&mut binary_data)
|
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|