[BlockSTM] Per-block Gas Limit

aptos-move/aptos-transaction-benchmarks/src/main.rs

@@ -16,6 +16,7 @@ fn main() {
 
     let mut measurements: Vec<Vec<(usize, usize)>> = Vec::new();
     let concurrency_level = num_cpus::get();
+    let maybe_gas_limit = None;
 
     for block_size in txns {
         for num_accounts in acts {
@@ -25,6 +26,7 @@ fn main() {
                 num_warmups,
                 num_runs,
                 concurrency_level,
+                maybe_gas_limit,
             );
             times.sort();
             measurements.push(times);

aptos-move/aptos-transaction-benchmarks/src/transactions.rs

@@ -101,6 +101,7 @@ where
         num_warmups: usize,
         num_runs: usize,
         concurrency_level: usize,
+        maybe_gas_limit: Option<u64>,
     ) -> Vec<(usize, usize)> {
         let mut ret = Vec::new();
 
@@ -110,7 +111,7 @@ where
 
             if i < num_warmups {
                 println!("WARMUP - ignore results");
-                state.execute_blockstm_benchmark(concurrency_level);
+                state.execute_blockstm_benchmark(concurrency_level, maybe_gas_limit);
             } else {
                 println!(
                     "RUN BlockSTM-only benchmark for: num_threads = {}, \
@@ -120,7 +121,7 @@ where
                     num_accounts,
                     num_txn,
                 );
-                ret.push(state.execute_blockstm_benchmark(concurrency_level));
+                ret.push(state.execute_blockstm_benchmark(concurrency_level, maybe_gas_limit));
             }
         }
 
@@ -220,7 +221,7 @@ impl TransactionBenchState {
     fn execute(self) {
         // The output is ignored here since we're just testing transaction performance, not trying
         // to assert correctness.
-        BlockAptosVM::execute_block(self.transactions, self.executor.get_state_view(), 1)
+        BlockAptosVM::execute_block(self.transactions, self.executor.get_state_view(), 1, None)
             .expect("VM should not fail to start");
     }
 
@@ -232,15 +233,21 @@ impl TransactionBenchState {
             self.transactions,
             self.executor.get_state_view(),
             num_cpus::get(),
+            None,
         )
         .expect("VM should not fail to start");
     }
 
-    fn execute_blockstm_benchmark(self, concurrency_level: usize) -> (usize, usize) {
+    fn execute_blockstm_benchmark(
+        self,
+        concurrency_level: usize,
+        maybe_gas_limit: Option<u64>,
+    ) -> (usize, usize) {
         BlockAptosVM::execute_block_benchmark(
             self.transactions,
             self.executor.get_state_view(),
             concurrency_level,
+            maybe_gas_limit,
         )
     }
 }

aptos-move/aptos-vm/src/aptos_vm.rs

@@ -1483,8 +1483,45 @@ impl VMExecutor for AptosVM {
         );
 
         let count = transactions.len();
-        let ret =
-            BlockAptosVM::execute_block(transactions, state_view, Self::get_concurrency_level());
+        let ret = BlockAptosVM::execute_block(
+            transactions,
+            state_view,
+            Self::get_concurrency_level(),
+            None,
+        );
+        if ret.is_ok() {
+            // Record the histogram count for transactions per block.
+            BLOCK_TRANSACTION_COUNT.observe(count as f64);
+        }
+        ret
+    }
+
+    fn execute_block_with_gas_limit(
+        transactions: Vec<Transaction>,
+        state_view: &(impl StateView + Sync),
+        maybe_gas_limit: Option<u64>,
+    ) -> std::result::Result<Vec<TransactionOutput>, VMStatus> {
+        fail_point!("move_adapter::execute_block", |_| {
+            Err(VMStatus::Error(
+                StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR,
+                None,
+            ))
+        });
+
+        let log_context = AdapterLogSchema::new(state_view.id(), 0);
+        info!(
+            log_context,
+            "Executing block, transaction count: {}",
+            transactions.len()
+        );
+
+        let count = transactions.len();
+        let ret = BlockAptosVM::execute_block(
+            transactions,
+            state_view,
+            Self::get_concurrency_level(),
+            maybe_gas_limit,
+        );
         if ret.is_ok() {
             // Record the histogram count for transactions per block.
             BLOCK_TRANSACTION_COUNT.observe(count as f64);

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

@@ -81,6 +81,11 @@ impl BlockExecutorTransactionOutput for AptosTransactionOutput {
             TransactionStatus::Retry,
         )))
     }
+
+    /// Return the amount of gas consumed by the transaction.
+    fn gas_used(&self) -> u64 {
+        self.0.txn_output().gas_used()
+    }
 }
 
 pub struct BlockAptosVM();
@@ -90,6 +95,7 @@ impl BlockAptosVM {
         transactions: Vec<Transaction>,
         state_view: &S,
         concurrency_level: usize,
+        maybe_gas_limit: Option<u64>,
     ) -> Result<Vec<TransactionOutput>, VMStatus> {
         let _timer = BLOCK_EXECUTOR_EXECUTE_BLOCK_SECONDS.start_timer();
         // Verify the signatures of all the transactions in parallel.
@@ -112,6 +118,7 @@ impl BlockAptosVM {
         BLOCK_EXECUTOR_CONCURRENCY.set(concurrency_level as i64);
         let executor = BlockExecutor::<PreprocessedTransaction, AptosExecutorTask<S>, S>::new(
             concurrency_level,
+            maybe_gas_limit,
         );
 
         let ret = executor
@@ -145,6 +152,7 @@ impl BlockAptosVM {
         transactions: Vec<Transaction>,
         state_view: &S,
         concurrency_level: usize,
+        maybe_gas_limit: Option<u64>,
     ) -> (usize, usize) {
         // Verify the signatures of all the transactions in parallel.
         // This is time consuming so don't wait and do the checking
@@ -173,6 +181,7 @@ impl BlockAptosVM {
         BLOCK_EXECUTOR_CONCURRENCY.set(concurrency_level as i64);
         let executor = BlockExecutor::<PreprocessedTransaction, AptosExecutorTask<S>, S>::new(
             concurrency_level,
+            maybe_gas_limit,
         );
         println!("Parallel execution starts...");
         let timer = Instant::now();
@@ -186,8 +195,10 @@ impl BlockAptosVM {
         flush_speculative_logs();
 
         // sequentially execute the block and check if the results match
-        let seq_executor =
-            BlockExecutor::<PreprocessedTransaction, AptosExecutorTask<S>, S>::new(1);
+        let seq_executor = BlockExecutor::<PreprocessedTransaction, AptosExecutorTask<S>, S>::new(
+            1,
+            maybe_gas_limit,
+        );
         println!("Sequential execution starts...");
         let seq_timer = Instant::now();
         let seq_ret =

aptos-move/aptos-vm/src/lib.rs

@@ -152,6 +152,14 @@ pub trait VMExecutor: Send + Sync {
         transactions: Vec<Transaction>,
         state_view: &(impl StateView + Sync),
     ) -> Result<Vec<TransactionOutput>, VMStatus>;
+
+    /// Executes a block of transactions with per_block_gas_limit
+    /// and returns output for each one of them.
+    fn execute_block_with_gas_limit(
+        transactions: Vec<Transaction>,
+        state_view: &(impl StateView + Sync),
+        maybe_gas_limit: Option<u64>,
+    ) -> Result<Vec<TransactionOutput>, VMStatus>;
 }
 
 /*

aptos-move/block-executor/src/counters.rs

@@ -24,6 +24,24 @@ pub static SPECULATIVE_ABORT_COUNT: Lazy<IntCounter> = Lazy::new(|| {
     .unwrap()
 });
 
+/// Count of times the BlockSTM is early halted due to exceeding the per-block gas limit.
+pub static PARALLEL_EXCEED_PER_BLOCK_GAS_LIMIT_COUNT: Lazy<IntCounter> = Lazy::new(|| {
+    register_int_counter!(
+        "aptos_execution_par_gas_limit_count",
+        "Count of times the BlockSTM is early halted due to exceeding the per-block gas limit"
+    )
+    .unwrap()
+});
+
+/// Count of times the sequential execution is early halted due to exceeding the per-block gas limit.
+pub static SEQUENTIAL_EXCEED_PER_BLOCK_GAS_LIMIT_COUNT: Lazy<IntCounter> = Lazy::new(|| {
+    register_int_counter!(
+        "aptos_execution_seq_gas_limit_count",
+        "Count of times the sequential execution is early halted due to exceeding the per-block gas limit"
+    )
+    .unwrap()
+});
+
 pub static PARALLEL_EXECUTION_SECONDS: Lazy<Histogram> = Lazy::new(|| {
     register_histogram!(
         // metric name
@@ -109,3 +127,21 @@ pub static DEPENDENCY_WAIT_SECONDS: Lazy<Histogram> = Lazy::new(|| {
     )
     .unwrap()
 });
+
+pub static PARALLEL_PER_BLOCK_GAS: Lazy<Histogram> = Lazy::new(|| {
+    register_histogram!(
+        "aptos_execution_par_per_block_gas",
+        "The per-block consumed gas in parallel execution (Block STM)",
+        exponential_buckets(/*start=*/ 1.0, /*factor=*/ 2.0, /*count=*/ 30).unwrap(),
+    )
+    .unwrap()
+});
+
+pub static SEQUENTIAL_PER_BLOCK_GAS: Lazy<Histogram> = Lazy::new(|| {
+    register_histogram!(
+        "aptos_execution_seq_per_block_gas",
+        "The per-block consumed gas in sequential execution",
+        exponential_buckets(/*start=*/ 1.0, /*factor=*/ 2.0, /*count=*/ 30).unwrap(),
+    )
+    .unwrap()
+});