pezkuwichain/revive
1
0
Fork 0
mirror of https://github.com/pezkuwichain/revive.git synced 2026-06-13 20:01:04 +00:00
Code Issues Packages Projects Releases Wiki Activity

switch to pallet_revive runtime (#40)

Browse Source 
Signed-off-by: xermicus <cyrill@parity.io>
This commit is contained in:
Cyrill Leutwiler
2024-09-03 17:18:22 +02:00
committed by GitHub
parent 41c8d4e955
commit d2f76b645f
66 changed files with 3023 additions and 2911 deletions
Download Patch File Download Diff File Expand all files Collapse all files
crates/benchmarks/benches/execute.rs
+31 -117
View File
@@ -1,104 +1,42 @@
#![cfg(any(feature = "bench-pvm-interpreter", feature = "bench-evm"))]
use alloy_primitives::U256;
use criterion::{
criterion_group, criterion_main, measurement::Measurement, BenchmarkGroup, BenchmarkId,
Criterion,
criterion_group, criterion_main,
measurement::{Measurement, WallTime},
BenchmarkGroup, BenchmarkId, Criterion,
};
use revive_integration::cases::Contract;
fn bench<P, L, I, M>(mut group: BenchmarkGroup<'_, M>, parameters: &[P], labels: &[L], contract: I)
where
fn bench<P, L, I>(
mut group: BenchmarkGroup<'_, WallTime>,
parameters: &[P],
labels: &[L],
contract: I,
) where
P: Clone,
L: std::fmt::Display,
I: Fn(P) -> Contract,
M: Measurement,
{
assert_eq!(parameters.len(), labels.len());
group.sample_size(10);
for (p, l) in parameters.iter().zip(labels.iter()) {
let contract = contract(p.clone());
#[cfg(feature = "bench-evm")]
{
let contract = contract(p.clone());
group.bench_with_input(BenchmarkId::new("EVM", l), p, move |b, _| {
b.iter(|| {
revive_differential::execute(revive_differential::prepare(
contract.evm_runtime.clone(),
contract.calldata.clone(),
));
});
});
}
group.bench_with_input(BenchmarkId::new("EVM", l), p, |b, _| {
let code = &contract.evm_runtime;
let input = &contract.calldata;
b.iter_custom(|iters| revive_benchmarks::measure_evm(code, input, iters));
});
#[cfg(not(feature = "bench-extensive"))]
{
#[cfg(all(feature = "bench-pvm-interpreter", not(feature = "bench-extensive")))]
{
let contract = contract(p.clone());
let (transaction, mut instance, export) = revive_benchmarks::prepare_pvm(
&contract.pvm_runtime,
contract.calldata,
polkavm::BackendKind::Interpreter,
);
group.bench_with_input(BenchmarkId::new("PVMInterpreter", l), p, |b, _| {
b.iter(|| {
let _ = transaction.clone().call_on(&mut instance, export);
});
});
}
#[cfg(all(feature = "bench-pvm", not(feature = "bench-extensive")))]
{
let contract = contract(p.clone());
let (transaction, mut instance, export) = revive_benchmarks::prepare_pvm(
&contract.pvm_runtime,
contract.calldata,
polkavm::BackendKind::Compiler,
);
group.bench_with_input(BenchmarkId::new("PVM", l), p, |b, _| {
b.iter(|| {
let _ = transaction.clone().call_on(&mut instance, export);
});
});
}
}
#[cfg(feature = "bench-extensive")]
{
use revive_benchmarks::instantiate_engine;
use revive_integration::mock_runtime::{instantiate_module, recompile_code, State};
#[cfg(feature = "bench-pvm-interpreter")]
{
let contract = contract(p.clone());
let engine = instantiate_engine(polkavm::BackendKind::Interpreter);
let module = recompile_code(&contract.pvm_runtime, &engine);
let transaction = State::default()
.transaction()
.with_default_account(&contract.pvm_runtime)
.calldata(contract.calldata);
group.bench_with_input(BenchmarkId::new("PVMInterpreter", l), p, |b, _| {
b.iter(|| {
let (mut instance, export) = instantiate_module(&module, &engine);
let _ = transaction.clone().call_on(&mut instance, export);
});
});
}
#[cfg(feature = "bench-pvm")]
{
let contract = contract(p.clone());
let engine = instantiate_engine(polkavm::BackendKind::Compiler);
let module = recompile_code(&contract.pvm_runtime, &engine);
let transaction = State::default()
.transaction()
.with_default_account(&contract.pvm_runtime)
.calldata(contract.calldata);
group.bench_with_input(BenchmarkId::new("PVM", l), p, |b, _| {
b.iter(|| {
let (mut instance, export) = instantiate_module(&module, &engine);
let _ = transaction.clone().call_on(&mut instance, export);
});
});
}
}
#[cfg(feature = "bench-pvm-interpreter")]
group.bench_with_input(BenchmarkId::new("PVMInterpreter", l), p, |b, _| {
let specs = revive_benchmarks::create_specs(&contract);
b.iter_custom(|iters| revive_benchmarks::measure_pvm(&specs, iters));
});
}
group.finish();
@@ -108,14 +46,6 @@ fn group<'error, M>(c: &'error mut Criterion<M>, group_name: &str) -> BenchmarkG
where
M: Measurement,
{
#[cfg(feature = "bench-extensive")]
{
let mut group = c.benchmark_group(group_name);
group.sample_size(10);
group
}
#[cfg(not(feature = "bench-extensive"))]
return c.benchmark_group(group_name);
}
@@ -128,33 +58,21 @@ fn bench_baseline(c: &mut Criterion) {
fn bench_odd_product(c: &mut Criterion) {
let group = group(c, "OddPorduct");
#[cfg(feature = "bench-extensive")]
let parameters = &[300000, 1200000, 12000000, 180000000, 720000000];
#[cfg(not(feature = "bench-extensive"))]
let parameters = &[10_000, 100_000];
let parameters = &[10_000, 100_000, 300000];
bench(group, parameters, parameters, Contract::odd_product);
}
fn bench_triangle_number(c: &mut Criterion) {
let group = group(c, "TriangleNumber");
#[cfg(feature = "bench-extensive")]
let parameters = &[360000, 1440000, 14400000, 216000000, 864000000];
#[cfg(not(feature = "bench-extensive"))]
let parameters = &[10_000, 100_000];
let parameters = &[10_000, 100_000, 360000];
bench(group, parameters, parameters, Contract::triangle_number);
}
fn bench_fibonacci_recurisve(c: &mut Criterion) {
let group = group(c, "FibonacciRecursive");
#[cfg(feature = "bench-extensive")]
let parameters = [24, 27, 31, 36, 39]
.iter()
.map(|p| U256::from(*p))
.collect::<Vec<_>>();
#[cfg(not(feature = "bench-extensive"))]
let parameters = [12, 16, 20]
let parameters = [12, 16, 20, 24]
.iter()
.map(|p| U256::from(*p))
.collect::<Vec<_>>();
@@ -164,12 +82,6 @@ fn bench_fibonacci_recurisve(c: &mut Criterion) {
fn bench_fibonacci_iterative(c: &mut Criterion) {
let group = group(c, "FibonacciIterative");
#[cfg(feature = "bench-extensive")]
let parameters = [256, 162500, 650000, 6500000, 100000000, 400000000]
.iter()
.map(|p| U256::from(*p))
.collect::<Vec<_>>();
#[cfg(not(feature = "bench-extensive"))]
let parameters = [64, 128, 256]
.iter()
.map(|p| U256::from(*p))
@@ -193,7 +105,9 @@ fn bench_sha1(c: &mut Criterion) {
let parameters = &[vec![0xff], vec![0xff; 64], vec![0xff; 512]];
let labels = parameters.iter().map(|p| p.len()).collect::<Vec<_>>();
bench(group, parameters, &labels, Contract::sha1);
bench(group, parameters, &labels, |input| {
Contract::sha1(input.into())
});
}
criterion_group!(