Add vector-picture to benchmark tool, and show io/execution gas split (aptos-labs#10692)

Author: igor-aptos

aptos-move/move-examples/token_objects/ambassador/Move.toml

@@ -2,8 +2,9 @@
 name = 'ambassador'
 version = '1.0.0'
 
+# do not change to "_", concrete address needed for module-publish testing framework
 [addresses]
-ambassador = "_"
+ambassador = "0xCAFE"
 
 [dependencies]
 AptosFramework = { local = "../../../framework/aptos-framework" }

crates/transaction-generator-lib/src/args.rs

@@ -30,6 +30,7 @@ pub enum TransactionTypeArg {
     TokenV1FTMintAndStore,
     TokenV1FTMintAndTransfer,
     TokenV2AmbassadorMint,
+    VectorPicture30k,
 }
 
 impl TransactionTypeArg {
@@ -157,6 +158,11 @@ impl TransactionTypeArg {
                 num_modules: module_working_set_size,
                 use_account_pool: sender_use_account_pool,
             },
+            TransactionTypeArg::VectorPicture30k => TransactionType::CallCustomModules {
+                entry_point: EntryPoints::VectorPicture { length: 30 * 1024 },
+                num_modules: module_working_set_size,
+                use_account_pool: sender_use_account_pool,
+            },
         }
     }
 

crates/transaction-generator-lib/src/publishing/module_simple.rs

@@ -168,6 +168,13 @@ pub enum EntryPoints {
     TokenV1MintAndTransferFT,
 
     TokenV2AmbassadorMint,
+
+    InitializeVectorPicture {
+        length: u64,
+    },
+    VectorPicture {
+        length: u64,
+    },
 }
 
 impl EntryPoints {
@@ -201,6 +208,9 @@ impl EntryPoints {
             | EntryPoints::TokenV1MintAndStoreFT
             | EntryPoints::TokenV1MintAndTransferFT => "framework_usecases",
             EntryPoints::TokenV2AmbassadorMint => "ambassador_token",
+            EntryPoints::InitializeVectorPicture { .. } | EntryPoints::VectorPicture { .. } => {
+                "complex"
+            },
         }
     }
 
@@ -234,6 +244,9 @@ impl EntryPoints {
             | EntryPoints::TokenV1MintAndStoreFT
             | EntryPoints::TokenV1MintAndTransferFT => "token_v1",
             EntryPoints::TokenV2AmbassadorMint => "ambassador",
+            EntryPoints::InitializeVectorPicture { .. } | EntryPoints::VectorPicture { .. } => {
+                "vector_picture"
+            },
         }
     }
 
@@ -373,6 +386,22 @@ impl EntryPoints {
                     ],
                 )
             },
+            EntryPoints::InitializeVectorPicture { length } => {
+                get_payload(module_id, ident_str!("create").to_owned(), vec![
+                    bcs::to_bytes(&length).unwrap(), // length
+                ])
+            },
+            EntryPoints::VectorPicture { length } => {
+                let rng: &mut StdRng = rng.expect("Must provide RNG");
+                get_payload(module_id, ident_str!("update").to_owned(), vec![
+                    bcs::to_bytes(&other.expect("Must provide other")).unwrap(),
+                    bcs::to_bytes(&0u64).unwrap(), // palette_index
+                    bcs::to_bytes(&rng.gen_range(0u64, length)).unwrap(), // index
+                    bcs::to_bytes(&rng.gen_range(0u8, 255u8)).unwrap(), // color R
+                    bcs::to_bytes(&rng.gen_range(0u8, 255u8)).unwrap(), // color G
+                    bcs::to_bytes(&rng.gen_range(0u8, 255u8)).unwrap(), // color B
+                ])
+            },
         }
     }
 
@@ -386,6 +415,9 @@ impl EntryPoints {
             | EntryPoints::TokenV1MintAndTransferFT => {
                 Some(EntryPoints::TokenV1InitializeCollection)
             },
+            EntryPoints::VectorPicture { length } => {
+                Some(EntryPoints::InitializeVectorPicture { length: *length })
+            },
             _ => None,
         }
     }

crates/transaction-generator-lib/src/publishing/raw_module_data.rs

@@ -19,7 +19,7 @@ use crate::{
     db_access::DbAccessUtil, pipeline::Pipeline, transaction_committer::TransactionCommitter,
     transaction_executor::TransactionExecutor, transaction_generator::TransactionGenerator,
 };
-use aptos_block_executor::counters as block_executor_counters;
+use aptos_block_executor::counters::{self as block_executor_counters, GasType};
 use aptos_block_partitioner::v2::counters::BLOCK_PARTITIONING_SECONDS;
 use aptos_config::config::{NodeConfig, PrunerConfig};
 use aptos_db::AptosDB;
@@ -191,7 +191,7 @@ pub fn run_benchmark<V>(
     );
 
     let mut start_time = Instant::now();
-    let start_gas_measurement = GasMesurement::start();
+    let start_gas_measurement = GasMeasuring::start();
 
     let start_partitioning_total = BLOCK_PARTITIONING_SECONDS.get_sample_sum();
     let start_execution_total = APTOS_EXECUTOR_EXECUTE_BLOCK_SECONDS.get_sample_sum();
@@ -248,7 +248,7 @@ pub fn run_benchmark<V>(
 
     let elapsed = start_time.elapsed().as_secs_f64();
     let delta_v = (db.reader.get_latest_version().unwrap() - version) as f64;
-    let (delta_gas, delta_gas_count) = start_gas_measurement.end();
+    let delta_gas = start_gas_measurement.end();
 
     let delta_vm_time = APTOS_EXECUTOR_VM_EXECUTE_BLOCK_SECONDS.get_sample_sum() - start_vm_time;
     info!(
@@ -266,10 +266,15 @@ pub fn run_benchmark<V>(
         }
     );
     info!("Overall TPS: {} txn/s", delta_v / elapsed);
-    info!("Overall GPS: {} gas/s", delta_gas / elapsed);
+    info!("Overall GPS: {} gas/s", delta_gas.gas / elapsed);
+    info!("Overall ioGPS: {} gas/s", delta_gas.io_gas / elapsed);
+    info!(
+        "Overall executionGPS: {} gas/s",
+        delta_gas.execution_gas / elapsed
+    );
     info!(
         "Overall GPT: {} gas/txn",
-        delta_gas / (delta_gas_count as f64).max(1.0)
+        delta_gas.gas / (delta_gas.gas_count as f64).max(1.0)
     );
 
     let time_in_partitioning =
@@ -494,46 +499,66 @@ fn add_accounts_impl<V>(
     );
 }
 
-struct GasMesurement {
-    start_gas: f64,
-    start_gas_count: u64,
+struct GasMeasurement {
+    pub gas: f64,
+
+    pub io_gas: f64,
+    pub execution_gas: f64,
+
+    pub gas_count: u64,
 }
 
-impl GasMesurement {
-    pub fn sequential_gas_counter() -> Histogram {
-        block_executor_counters::TXN_GAS.with_label_values(&[
-            block_executor_counters::Mode::SEQUENTIAL,
-            block_executor_counters::GasType::NON_STORAGE_GAS,
-        ])
+impl GasMeasurement {
+    pub fn sequential_gas_counter(gas_type: &str) -> Histogram {
+        block_executor_counters::TXN_GAS
+            .with_label_values(&[block_executor_counters::Mode::SEQUENTIAL, gas_type])
     }
 
-    pub fn parallel_gas_counter() -> Histogram {
-        block_executor_counters::TXN_GAS.with_label_values(&[
-            block_executor_counters::Mode::PARALLEL,
-            block_executor_counters::GasType::NON_STORAGE_GAS,
-        ])
+    pub fn parallel_gas_counter(gas_type: &str) -> Histogram {
+        block_executor_counters::TXN_GAS
+            .with_label_values(&[block_executor_counters::Mode::PARALLEL, gas_type])
     }
 
-    pub fn start() -> Self {
-        let start_gas = Self::sequential_gas_counter().get_sample_sum()
-            + Self::parallel_gas_counter().get_sample_sum();
-        let start_gas_count = Self::sequential_gas_counter().get_sample_count()
-            + Self::parallel_gas_counter().get_sample_count();
+    pub fn now() -> GasMeasurement {
+        let gas = Self::sequential_gas_counter(GasType::NON_STORAGE_GAS).get_sample_sum()
+            + Self::parallel_gas_counter(GasType::NON_STORAGE_GAS).get_sample_sum();
+        let io_gas = Self::sequential_gas_counter(GasType::IO_GAS).get_sample_sum()
+            + Self::parallel_gas_counter(GasType::IO_GAS).get_sample_sum();
+        let execution_gas = Self::sequential_gas_counter(GasType::EXECUTION_GAS).get_sample_sum()
+            + Self::parallel_gas_counter(GasType::EXECUTION_GAS).get_sample_sum();
+
+        let gas_count = Self::sequential_gas_counter(GasType::NON_STORAGE_GAS).get_sample_count()
+            + Self::parallel_gas_counter(GasType::NON_STORAGE_GAS).get_sample_count();
+
+        Self {
+            gas,
+            io_gas,
+            execution_gas,
+            gas_count,
+        }
+    }
+}
+
+struct GasMeasuring {
+    start: GasMeasurement,
+}
 
+impl GasMeasuring {
+    pub fn start() -> Self {
         Self {
-            start_gas,
-            start_gas_count,
+            start: GasMeasurement::now(),
         }
     }
 
-    pub fn end(self) -> (f64, u64) {
-        let delta_gas = (Self::sequential_gas_counter().get_sample_sum()
-            + Self::parallel_gas_counter().get_sample_sum())
-            - self.start_gas;
-        let delta_gas_count = (Self::sequential_gas_counter().get_sample_count()
-            + Self::parallel_gas_counter().get_sample_count())
-            - self.start_gas_count;
-        (delta_gas, delta_gas_count)
+    pub fn end(self) -> GasMeasurement {
+        let end = GasMeasurement::now();
+
+        GasMeasurement {
+            gas: end.gas - self.start.gas,
+            io_gas: end.io_gas - self.start.io_gas,
+            execution_gas: end.execution_gas - self.start.execution_gas,
+            gas_count: end.gas_count - self.start.gas_count,
+        }
     }
 }
 

execution/executor-benchmark/src/lib.rs

@@ -3,7 +3,7 @@
 
 use crate::{
     block_preparation::BlockPreparationStage, ledger_update_stage::LedgerUpdateStage,
-    metrics::NUM_TXNS, GasMesurement, TransactionCommitter, TransactionExecutor,
+    metrics::NUM_TXNS, GasMeasuring, TransactionCommitter, TransactionExecutor,
 };
 use aptos_block_partitioner::v2::config::PartitionerV2Config;
 use aptos_crypto::HashValue;
@@ -143,7 +143,7 @@ where
                 start_execution_rx.map(|rx| rx.recv());
                 let start_time = Instant::now();
                 let mut executed = 0;
-                let start_gas_measurement = GasMesurement::start();
+                let start_gas_measurement = GasMeasuring::start();
                 while let Ok(msg) = executable_block_receiver.recv() {
                     let ExecuteBlockMessage {
                         current_block_start_time,
@@ -160,7 +160,7 @@ where
                     info!("Finished executing block");
                 }
 
-                let (delta_gas, delta_gas_count) = start_gas_measurement.end();
+                let delta_gas = start_gas_measurement.end();
 
                 let elapsed = start_time.elapsed().as_secs_f64();
                 info!(
@@ -171,12 +171,22 @@ where
                 );
                 info!(
                     "Overall execution GPS: {} gas/s (over {} txns)",
-                    delta_gas / elapsed,
+                    delta_gas.gas / elapsed,
+                    executed
+                );
+                info!(
+                    "Overall execution ioGPS: {} gas/s (over {} txns)",
+                    delta_gas.io_gas / elapsed,
+                    executed
+                );
+                info!(
+                    "Overall execution executionGPS: {} gas/s (over {} txns)",
+                    delta_gas.execution_gas / elapsed,
                     executed
                 );
                 info!(
                     "Overall execution GPT: {} gas/txn (over {} txns)",
-                    delta_gas / (delta_gas_count as f64).max(1.0),
+                    delta_gas.gas / (delta_gas.gas_count as f64).max(1.0),
                     executed
                 );
 

execution/executor-benchmark/src/pipeline.rs

@@ -0,0 +1,7 @@
+[package]
+name = 'complex'
+version = '1.0.0'
+
+[dependencies]
+AptosFramework = { local = "../../../../../aptos-move/framework/aptos-framework" }
+

testsuite/module-publish/src/packages/complex/Move.toml

@@ -0,0 +1,98 @@
+// Copyright Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+module 0xABCD::vector_picture {
+    use std::error;
+    use std::signer;
+    use std::vector;
+    use aptos_std::object::{Self, Object};
+
+    /// The caller tried to mutate an item outside the bounds of the vector.
+    const E_INDEX_OUT_OF_BOUNDS: u64 = 1;
+
+    /// The caller tried to create palette for non-initialized account.
+    const E_ALL_PALETTES_NOT_INIT: u64 = 2;
+
+    struct AllPalettes has key {
+        all: vector<address>,
+    }
+
+    #[resource_group_member(group = aptos_framework::object::ObjectGroup)]
+    struct Palette has key {
+        vec: vector<Color>,
+    }
+
+    struct Color has copy, drop, store {
+        r: u8,
+        g: u8,
+        b: u8,
+    }
+
+    fun init_module(publisher: &signer) {
+        move_to<AllPalettes>(
+            publisher,
+            AllPalettes {
+                all: vector::empty(),
+            },
+        );
+    }
+
+    /// Create a new Palette
+    public entry fun create(
+        caller: &signer,
+        // Length of the vector to create.
+        length: u64,
+    ) acquires AllPalettes {
+        let caller_addr = signer::address_of(caller);
+
+        // Just a dummy color.
+        let color = Color {
+            r: 124,
+            g: 213,
+            b: 37,
+        };
+
+        // Build vec and palette.
+        let vec = vector::empty();
+        let i = 0;
+        while (i < length) {
+            vector::push_back(&mut vec, color);
+            i = i + 1;
+        };
+        let palette = Palette { vec };
+
+        // Create the object we'll store the Palette in.
+        let constructor_ref = object::create_object(caller_addr);
+
+        // Move the Palette resource into the object.
+        let object_signer = object::generate_signer(&constructor_ref);
+        move_to(&object_signer, palette);
+
+        assert!(exists<AllPalettes>(caller_addr), error::invalid_argument(E_ALL_PALETTES_NOT_INIT));
+
+        let all_palettes = borrow_global_mut<AllPalettes>(caller_addr);
+        vector::push_back(&mut all_palettes.all, object::address_from_constructor_ref(&constructor_ref));
+    }
+
+    /// Update an element in the vector.
+    public entry fun update(
+        palette_addr: address,
+        palette_index: u64,
+        index: u64,
+        r: u8,
+        g: u8,
+        b: u8,
+    ) acquires Palette, AllPalettes {
+        let all_palettes = borrow_global<AllPalettes>(palette_addr);
+        let palette_addr = vector::borrow(&all_palettes.all, palette_index);
+
+        let palette_ = borrow_global_mut<Palette>(*palette_addr);
+
+        // Confirm the index is not out of bounds.
+        assert!(index < vector::length(&palette_.vec), error::invalid_argument(E_INDEX_OUT_OF_BOUNDS));
+
+        // Write the pixel.
+        let color = Color { r, g, b };
+        *vector::borrow_mut(&mut palette_.vec, index) = color;
+    }
+}