Parallel tests (aptos-labs#9107)

Author: gelash

Cargo.lock

@@ -130,15 +130,8 @@ impl BlockExecutorTransactionOutput for AptosTransactionOutput {
         );
     }
 
-    /// Return the amount of gas consumed by the transaction.
-    fn gas_used(&self) -> u64 {
-        self.committed_output
-            .get()
-            .map_or(0, |output| output.gas_used())
-    }
-
-    // Return the fee statement of the transaction.
-    // Should never be called after vm_output is consumed.
+    /// Return the fee statement of the transaction.
+    /// Should never be called after vm_output is consumed.
     fn fee_statement(&self) -> FeeStatement {
         self.vm_output
             .lock()

aptos-move/aptos-vm/src/block_executor/mod.rs

@@ -24,6 +24,7 @@ aptos-types = { workspace = true }
 aptos-vm-logging = { workspace = true }
 arc-swap = { workspace = true }
 bcs = { workspace = true }
+claims = { workspace = true }
 criterion = { workspace = true, optional = true }
 crossbeam = { workspace = true }
 dashmap = { workspace = true }
@@ -36,8 +37,8 @@ proptest-derive = { workspace = true, optional = true }
 rayon = { workspace = true }
 
 [dev-dependencies]
-claims = { workspace = true }
 criterion = { workspace = true }
+itertools = { workspace = true }
 proptest = { workspace = true }
 proptest-derive = { workspace = true }
 rand = { workspace = true }

aptos-move/block-executor/Cargo.toml

@@ -1,8 +1,9 @@
 // Copyright © Aptos Foundation
+// Parts of the project are originally copyright © Meta Platforms, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
 // Run this bencher via `cargo bench --features fuzzing`.
-use aptos_parallel_executor::proptest_types::bencher::Bencher;
+use aptos_block_executor::proptest_types::bencher::Bencher;
 use criterion::{criterion_group, criterion_main, Criterion};
 use proptest::prelude::*;
 

aptos-move/block-executor/benches/scheduler_benches.rs

@@ -5,6 +5,7 @@ use aptos_metrics_core::{
     exponential_buckets, register_histogram, register_histogram_vec, register_int_counter,
     register_int_counter_vec, Histogram, HistogramVec, IntCounter, IntCounterVec,
 };
+use aptos_types::fee_statement::FeeStatement;
 use once_cell::sync::Lazy;
 
 pub struct GasType;
@@ -26,28 +27,28 @@ impl Mode {
 }
 
 /// Record the block gas during parallel execution.
-pub fn observe_parallel_execution_block_gas(cost: u64, gas_type: &'static str) {
+fn observe_parallel_execution_block_gas(cost: u64, gas_type: &'static str) {
     BLOCK_GAS
         .with_label_values(&[Mode::PARALLEL, gas_type])
         .observe(cost as f64);
 }
 
 /// Record the txn gas during parallel execution.
-pub fn observe_parallel_execution_txn_gas(cost: u64, gas_type: &'static str) {
+fn observe_parallel_execution_txn_gas(cost: u64, gas_type: &'static str) {
     TXN_GAS
         .with_label_values(&[Mode::PARALLEL, gas_type])
         .observe(cost as f64);
 }
 
 /// Record the block gas during sequential execution.
-pub fn observe_sequential_execution_block_gas(cost: u64, gas_type: &'static str) {
+fn observe_sequential_execution_block_gas(cost: u64, gas_type: &'static str) {
     BLOCK_GAS
         .with_label_values(&[Mode::SEQUENTIAL, gas_type])
         .observe(cost as f64);
 }
 
 /// Record the txn gas during sequential execution.
-pub fn observe_sequential_execution_txn_gas(cost: u64, gas_type: &'static str) {
+fn observe_sequential_execution_txn_gas(cost: u64, gas_type: &'static str) {
     TXN_GAS
         .with_label_values(&[Mode::SEQUENTIAL, gas_type])
         .observe(cost as f64);
@@ -194,3 +195,95 @@ pub static BLOCK_COMMITTED_TXNS: Lazy<HistogramVec> = Lazy::new(|| {
     )
     .unwrap()
 });
+
+pub(crate) fn update_parallel_block_gas_counters(
+    accumulated_fee_statement: &FeeStatement,
+    num_committed: usize,
+) {
+    observe_parallel_execution_block_gas(accumulated_fee_statement.gas_used(), GasType::TOTAL_GAS);
+    observe_parallel_execution_block_gas(
+        accumulated_fee_statement.execution_gas_used(),
+        GasType::EXECUTION_GAS,
+    );
+    observe_parallel_execution_block_gas(accumulated_fee_statement.io_gas_used(), GasType::IO_GAS);
+    observe_parallel_execution_block_gas(
+        accumulated_fee_statement.storage_gas_used(),
+        GasType::STORAGE_GAS,
+    );
+    observe_parallel_execution_block_gas(
+        accumulated_fee_statement.execution_gas_used() + accumulated_fee_statement.io_gas_used(),
+        GasType::NON_STORAGE_GAS,
+    );
+    observe_parallel_execution_block_gas(
+        accumulated_fee_statement.storage_fee_used(),
+        GasType::STORAGE_FEE,
+    );
+    BLOCK_COMMITTED_TXNS
+        .with_label_values(&[Mode::PARALLEL])
+        .observe(num_committed as f64);
+}
+
+pub(crate) fn update_parallel_txn_gas_counters(txn_fee_statements: &Vec<FeeStatement>) {
+    for fee_statement in txn_fee_statements {
+        observe_parallel_execution_txn_gas(fee_statement.gas_used(), GasType::TOTAL_GAS);
+        observe_parallel_execution_txn_gas(
+            fee_statement.execution_gas_used(),
+            GasType::EXECUTION_GAS,
+        );
+        observe_parallel_execution_txn_gas(fee_statement.io_gas_used(), GasType::IO_GAS);
+        observe_parallel_execution_txn_gas(fee_statement.storage_gas_used(), GasType::STORAGE_GAS);
+        observe_parallel_execution_txn_gas(
+            fee_statement.execution_gas_used() + fee_statement.io_gas_used(),
+            GasType::NON_STORAGE_GAS,
+        );
+        observe_parallel_execution_txn_gas(fee_statement.storage_fee_used(), GasType::STORAGE_FEE);
+    }
+}
+
+pub(crate) fn update_sequential_block_gas_counters(
+    accumulated_fee_statement: &FeeStatement,
+    num_committed: usize,
+) {
+    observe_sequential_execution_block_gas(
+        accumulated_fee_statement.gas_used(),
+        GasType::TOTAL_GAS,
+    );
+    observe_sequential_execution_block_gas(
+        accumulated_fee_statement.execution_gas_used(),
+        GasType::EXECUTION_GAS,
+    );
+    observe_sequential_execution_block_gas(
+        accumulated_fee_statement.io_gas_used(),
+        GasType::IO_GAS,
+    );
+    observe_sequential_execution_block_gas(
+        accumulated_fee_statement.storage_gas_used(),
+        GasType::STORAGE_GAS,
+    );
+    observe_sequential_execution_block_gas(
+        accumulated_fee_statement.execution_gas_used() + accumulated_fee_statement.io_gas_used(),
+        GasType::NON_STORAGE_GAS,
+    );
+    observe_sequential_execution_block_gas(
+        accumulated_fee_statement.storage_fee_used(),
+        GasType::STORAGE_FEE,
+    );
+    BLOCK_COMMITTED_TXNS
+        .with_label_values(&[Mode::PARALLEL])
+        .observe(num_committed as f64);
+}
+
+pub(crate) fn update_sequential_txn_gas_counters(fee_statement: &FeeStatement) {
+    observe_sequential_execution_txn_gas(fee_statement.gas_used(), GasType::TOTAL_GAS);
+    observe_sequential_execution_txn_gas(
+        fee_statement.execution_gas_used(),
+        GasType::EXECUTION_GAS,
+    );
+    observe_sequential_execution_txn_gas(fee_statement.io_gas_used(), GasType::IO_GAS);
+    observe_sequential_execution_txn_gas(fee_statement.storage_gas_used(), GasType::STORAGE_GAS);
+    observe_sequential_execution_txn_gas(
+        fee_statement.execution_gas_used() + fee_statement.io_gas_used(),
+        GasType::NON_STORAGE_GAS,
+    );
+    observe_sequential_execution_txn_gas(fee_statement.storage_fee_used(), GasType::STORAGE_FEE);
+}