1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

// This file is part of Tetcore.

// Copyright (C) 2020-2021 Parity Technologies (UK) Ltd.
// SPDX-License-Identifier: Apache-2.0

// 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.

mod command;
mod writer;

use tc_cli::{ExecutionStrategy, WasmExecutionMethod};
use std::fmt::Debug;

/// The `benchmark` command used to benchmark FABRIC Nobles.
#[derive(Debug, structopt::StructOpt)]
pub struct BenchmarkCmd {
	/// Select a FABRIC Noble to benchmark, or `*` for all (in which case `extrinsic` must be `*`).
	#[structopt(short, long)]
	pub noble: String,

	/// Select an extrinsic inside the noble to benchmark, or `*` for all.
	#[structopt(short, long)]
	pub extrinsic: String,

	/// Select how many samples we should take across the variable components.
	#[structopt(short, long, use_delimiter = true)]
	pub steps: Vec<u32>,

	/// Indicates lowest values for each of the component ranges.
	#[structopt(long = "low", use_delimiter = true)]
	pub lowest_range_values: Vec<u32>,

	/// Indicates highest values for each of the component ranges.
	#[structopt(long = "high", use_delimiter = true)]
	pub highest_range_values: Vec<u32>,

	/// Select how many repetitions of this benchmark should run.
	#[structopt(short, long, default_value = "1")]
	pub repeat: u32,

	/// Print the raw results.
	#[structopt(long = "raw")]
	pub raw_data: bool,

	/// Don't print the median-slopes linear regression analysis.
	#[structopt(long)]
	pub no_median_slopes: bool,

	/// Don't print the min-squares linear regression analysis.
	#[structopt(long)]
	pub no_min_squares: bool,

	/// Output the benchmarks to a Rust file at the given path.
	#[structopt(long)]
	pub output: Option<std::path::PathBuf>,

	/// Add a header file to your outputted benchmarks
	#[structopt(long)]
	pub header: Option<std::path::PathBuf>,

	/// Path to Handlebars template file used for outputting benchmark results. (Optional)
	#[structopt(long)]
	pub template: Option<std::path::PathBuf>,

	/// Set the heap pages while running benchmarks.
	#[structopt(long)]
	pub heap_pages: Option<u64>,

	/// Disable verification logic when running benchmarks.
	#[structopt(long)]
	pub no_verify: bool,

	/// Display and run extra benchmarks that would otherwise not be needed for weight construction.
	#[structopt(long)]
	pub extra: bool,

	#[allow(missing_docs)]
	#[structopt(flatten)]
	pub shared_params: tc_cli::SharedParams,

	/// The execution strategy that should be used for benchmarks
	#[structopt(
		long = "execution",
		value_name = "STRATEGY",
		possible_values = &ExecutionStrategy::variants(),
		case_insensitive = true,
	)]
	pub execution: Option<ExecutionStrategy>,

	/// Method for executing Wasm runtime code.
	#[structopt(
		long = "wasm-execution",
		value_name = "METHOD",
		possible_values = &WasmExecutionMethod::enabled_variants(),
		case_insensitive = true,
		default_value = "Interpreted"
	)]
	pub wasm_method: WasmExecutionMethod,

	/// Limit the memory the database cache can use.
	#[structopt(long = "db-cache", value_name = "MiB", default_value = "128")]
	pub database_cache_size: u32,
}