1, add benchmark for testing vm2 transaction execution

2, cache the vm2 config from shengguo lu
3, add batch operations for the transaction interface

chain/src/chain.rs

@@ -1254,9 +1254,9 @@ impl ChainReader for BlockChain {
 
     fn get_transaction_info(&self, txn_hash: HashValue) -> Result<Option<StcRichTransactionInfo>> {
         let (storage, _storage2) = &self.storage;
-        let txn_info_ids = storage.get_rich_transaction_info_ids_by_txn_hash(txn_hash)?;
+        let txn_info_ids = storage.get_transaction_info_ids_by_txn_hash(txn_hash)?;
         for txn_info_id in txn_info_ids {
-            let txn_info = storage.get_transaction_info_by_rich_info_id(txn_info_id)?;
+            let txn_info = storage.get_transaction_info(txn_info_id)?;
             if let Some(txn_info) = txn_info {
                 if self.exist_block(txn_info.block_id())? {
                     return Ok(Some(txn_info));
@@ -1266,6 +1266,17 @@ impl ChainReader for BlockChain {
         Ok(None)
     }
 
+    fn get_transaction_info_by_global_index(
+        &self,
+        transaction_global_index: u64,
+    ) -> Result<Option<StcRichTransactionInfo>> {
+        let (storage, _storage2) = &self.storage;
+        match self.txn_accumulator.get_leaf(transaction_global_index)? {
+            None => Ok(None),
+            Some(hash) => storage.get_transaction_info(hash),
+        }
+    }
+
     fn chain_state_reader(&self) -> &dyn ChainStateReader {
         &self.statedb.0
     }
@@ -1416,8 +1427,7 @@ impl ChainReader for BlockChain {
             .txn_accumulator
             .get_leaves(start_index, reverse, max_size)?;
         let mut infos = vec![];
-        let txn_infos =
-            storage.get_transaction_infos_by_info_ids(hashes.clone(), chain_header.id())?;
+        let txn_infos = storage.get_transaction_infos(hashes.clone())?;
         for (i, info) in txn_infos.into_iter().enumerate() {
             match info {
                 Some(info) => infos.push(info),
@@ -1496,45 +1506,20 @@ impl ChainReader for BlockChain {
                 )
             })?;
 
-        let get_transaction_info_in_this_chain =
-            |id: HashValue| -> Result<Option<StcRichTransactionInfo>> {
-                // vm1's TransactionInfo's id and StcRichTransactionInfo's id are same,
-                // vm2's TransactionInfo's id and StcRichTransactionInfo's id are different
-                // we are not sure whether the id is from vm1 or vm2, so we need to check both.
-                let mut rich_ids = storage.get_rich_ids_by_info_id(id).unwrap_or(vec![]);
-                rich_ids.push(id);
-                let rich_infos = storage.get_transaction_infos_by_rich_ids(rich_ids)?;
-                for rich_info in rich_infos {
-                    if rich_info.is_none() {
-                        continue;
-                    }
-                    let rich_info = rich_info.unwrap();
-                    if self.check_exist_block(rich_info.block_id(), rich_info.block_number)? {
-                        return Ok(Some(rich_info));
-                    }
-                }
-                Ok(None)
-            };
-
-        let proof_rich_transaction_info =
-            get_transaction_info_in_this_chain(proof_transaction_info_id)?.ok_or_else(|| {
+        let proof_rich_transaction_info = storage
+            .get_transaction_info(proof_transaction_info_id)?
+            .ok_or_else(|| {
                 format_err!(
-                    "failed to get proof txn info by hash:{}, block id:{}",
-                    proof_transaction_info_id,
-                    block_id
+                    "failed to get proof txn info by hash:{}",
+                    proof_transaction_info_id
                 )
             })?;
 
         let proof_transaction_info = proof_rich_transaction_info.transaction_info;
 
-        let input_rich_transaction_info = get_transaction_info_in_this_chain(transaction_info_id)?
-            .ok_or_else(|| {
-                format_err!(
-                    "failed to get txn info by hash:{}, block id:{}",
-                    transaction_info_id,
-                    block_id
-                )
-            })?;
+        let input_rich_transaction_info = storage
+            .get_transaction_info(transaction_info_id)?
+            .ok_or_else(|| format_err!("failed to get txn info by hash:{}", transaction_info_id))?;
 
         let final_raw_transaction = storage
             .get_transaction(proof_transaction_info.transaction_hash())?
@@ -1551,14 +1536,9 @@ impl ChainReader for BlockChain {
             .ok_or_else(|| format_err!("Cannot get state root hash"))?;
         let final_access_path = final_raw_transaction.access_path();
 
-        let transaction_info = get_transaction_info_in_this_chain(transaction_info_id)?
-            .ok_or_else(|| {
-                format_err!(
-                    "failed to get txn info by hash:{}, block id:{}",
-                    transaction_info_id,
-                    block_id
-                )
-            })?;
+        let transaction_info = storage
+            .get_transaction_info(transaction_info_id)?
+            .ok_or_else(|| format_err!("failed to get txn info by hash:{}", transaction_info_id))?;
 
         let event_proof = match input_rich_transaction_info.transaction_info {
             StcTransactionInfo::V1(_) => {
@@ -1840,15 +1820,13 @@ impl BlockChain {
                     continue;
                 }
 
-                let txn_info = storage
-                    .get_transaction_info_by_info_id(*id, block_id)?
-                    .ok_or_else(|| {
-                        anyhow::anyhow!(format!(
-                            "cannot find txn info with txn_info_id {} on main chain(head: {})",
-                            id,
-                            chain_header.id()
-                        ))
-                    })?;
+                let txn_info = storage.get_transaction_info(*id)?.ok_or_else(|| {
+                    anyhow::anyhow!(format!(
+                        "cannot find txn info with txn_info_id {} on main chain(head: {})",
+                        id,
+                        chain_header.id()
+                    ))
+                })?;
 
                 let filtered_event_with_info =
                     filtered_events.map(|(idx, evt)| StcContractEventInfo {
@@ -2218,6 +2196,13 @@ impl BlockChain {
                     format_err!("Can not find block info for parent {:?}", selected_parent)
                 })?;
 
+        // let multi_state = self.storage.0.get_vm_multi_state(selected_parent)?;
+
+        // let statedb = self.statedb.0.fork_at(multi_state.state_root1());
+        // let statedb2 = self.statedb.1.fork_at(multi_state.state_root2());
+
+        // Get epoch from forked statedb (read from VM2's statedb)
+
         // Execute VM1 transactions
         let executed_data = if !transactions.is_empty() {
             starcoin_executor::block_execute(

cmd/tx-factory/src/main.rs

@@ -269,4 +269,4 @@ fn main() {
 
     handle.join().unwrap();
     info!("txfactory: stop now");
-}
+}

cmd/tx-factory/src/mocker.rs

@@ -132,7 +132,7 @@ impl TxnMocker {
             .generate_mock_txn2(self.next_sequence_number, expiration_timestamp)?;
         info!("prepare to sign txn, sender: {}", raw_txn.sender());
 
-        self.unlock_account2()?;
+        self.unlock_account()?;
 
         let user_txn = match self.client.account_sign_txn2(raw_txn) {
             Err(e) => {
@@ -585,8 +585,8 @@ impl TxnMocker {
         }
 
         if !addr_vec.is_empty() {
-            self.recheck_sequence_number2()?;
-            self.unlock_account2()?;
+            self.recheck_sequence_number()?;
+            self.unlock_account()?;
             let txn = self.generator.generate_account_txn2(
                 self.next_sequence_number,
                 self.account_address2,

cmd/tx-factory/src/pressure_vm2.rs

@@ -37,7 +37,7 @@ pub fn start_vm2_pressure_test(
                     if let Err(e) = success {
                         error!("fail to run stress test, err: {:?}", &e);
                         // if txn is rejected, recheck sequence number, and start over
-                        if let Err(e) = tx_mocker.recheck_sequence_number2() {
+                        if let Err(e) = tx_mocker.recheck_sequence_number() {
                             error!("fail to start over, err: {:?}", e);
                         }
                     }
@@ -46,7 +46,7 @@ pub fn start_vm2_pressure_test(
                     if let Err(e) = success {
                         error!("fail to generate/submit mock txn, err: {:?}", &e);
                         // if txn is rejected, recheck sequence number, and start over
-                        if let Err(e) = tx_mocker.recheck_sequence_number2() {
+                        if let Err(e) = tx_mocker.recheck_sequence_number() {
                             error!("fail to start over, err: {:?}", e);
                         }
                     }

commons/parallel-executor/src/executor.rs

@@ -11,6 +11,7 @@ use crate::{
 use num_cpus;
 use once_cell::sync::Lazy;
 use starcoin_infallible::Mutex;
+use starcoin_logger::prelude::error;
 use starcoin_mvhashmap::MVHashMap;
 use std::{collections::HashSet, hash::Hash, marker::PhantomData, sync::Arc, thread::spawn};
 
@@ -285,6 +286,60 @@ where
         }
     }
 
+    fn execute_block_meta_data_txn(
+        &self,
+        executor_arguments: &E::Argument,
+        block: &[T],
+        last_input_output: &TxnLastInputOutput<
+            <T as Transaction>::Key,
+            <E as ExecutorTask>::Output,
+            <E as ExecutorTask>::Error,
+        >,
+        versioned_data_cache: &MVHashMap<<T as Transaction>::Key, <T as Transaction>::Value>,
+        scheduler: &Scheduler,
+    ) {
+        if block.is_empty() || !block[0].is_block_meta_data() {
+            return;
+        }
+
+        let executor = E::init(*executor_arguments);
+        match scheduler.next_task() {
+            SchedulerTask::ExecutionTask(version, None, guard) => {
+                let (idx_to_execute, incarnation) = version;
+                assert!(idx_to_execute == 0 && incarnation == 0);
+                self.execute(
+                    version,
+                    guard,
+                    block,
+                    last_input_output,
+                    versioned_data_cache,
+                    scheduler,
+                    &executor,
+                );
+            }
+            _ => {
+                unreachable!()
+            }
+        };
+
+        match scheduler.next_task() {
+            SchedulerTask::ValidationTask(version, guard) => {
+                let (idx_to_execute, incarnation) = version;
+                assert!(idx_to_execute == 0 && incarnation == 0);
+                self.validate(
+                    version,
+                    guard,
+                    last_input_output,
+                    versioned_data_cache,
+                    scheduler,
+                );
+            }
+            _ => {
+                error!("second task from scheduler should be validation of block metadata txn, maybe execute block meta txn failed?");
+            }
+        };
+    }
+
     pub fn execute_transactions_parallel(
         &self,
         executor_initial_arguments: E::Argument,
@@ -299,6 +354,16 @@ where
         let last_input_output = TxnLastInputOutput::new(num_txns);
         let scheduler = Scheduler::new(num_txns);
 
+        // BlockMetadata is always the first txn of block that modifies fundamental info of block
+        // other txns depends on this execution result, execute it first to avoid unnecessary contention
+        self.execute_block_meta_data_txn(
+            &executor_initial_arguments,
+            &signature_verified_block,
+            &last_input_output,
+            &versioned_data_cache,
+            &scheduler,
+        );
+
         RAYON_EXEC_POOL.scope(|s| {
             for _ in 0..self.concurrency_level {
                 s.spawn(|_| {

commons/parallel-executor/src/task.rs

@@ -22,6 +22,12 @@ pub enum ExecutionStatus<T, E> {
 pub trait Transaction: Sync + Send + 'static {
     type Key: PartialOrd + Send + Sync + Clone + Hash + Eq;
     type Value: Send + Sync;
+
+    /// Returns true if this transaction is block metadata.
+    /// Default false to preserve backward compatibility for existing implementors.
+    fn is_block_meta_data(&self) -> bool {
+        false
+    }
 }
 
 /// Inference result of a transaction.

kube/manifest/starcoin-halley.yaml

@@ -23,7 +23,7 @@ spec:
         starcoin/node-pool: seed-pool
       containers:
       - name: starcoin
-        image: starcoin/starcoin:sha-718e01a
+        image: starcoin/starcoin:sha-6a5e4e8
         imagePullPolicy: Always
         command:
           - bash

rpc/client/src/remote_state_reader2/mod.rs

@@ -10,13 +10,9 @@ use starcoin_vm2_crypto::HashValue;
 use starcoin_vm2_state_api::{
     AccountStateSetIterator, ChainStateReader, StateWithProof, StateWithTableItemProof,
 };
-use starcoin_vm2_types::{
-    account_address::AccountAddress as AccountAddress2,
-    account_config::{stc_struct_tag, CoinStoreResource},
-    view::StrView,
-};
 use starcoin_vm2_types::{
     account_address::AccountAddress,
+    account_config::BalanceResource,
     account_state::AccountState,
     state_set::{AccountStateSet, ChainStateSet},
 };
@@ -64,33 +60,16 @@ impl<'a> RemoteStateReader<'a> {
         Self { client, state_root }
     }
 
-    pub fn get_balance2(&self, address: AccountAddress2) -> Result<Option<u128>> {
-        let stc = stc_struct_tag();
-        let resources = self.client.state_list_resource2(
-            address,
-            false,
-            Some(self.state_root),
-            0,
-            usize::MAX,
-            Some(vec![StrView::from(stc.clone())]),
-            None,
-        )?;
-        for (key, resource) in resources.resources {
-            if key.0 != stc {
-                continue;
-            }
-            if let Some(_token_code) = CoinStoreResource::token_code(&key.0) {
-                let balance = resource
-                    .decode::<CoinStoreResource>()
-                    .ok()
-                    .map(|balance| balance.coin() as u128);
-                return Ok(balance);
-            } else {
-                return Ok(None);
-            }
-        }
-
-        Ok(None)
+    pub fn get_balance2(&self, address: AccountAddress) -> Result<Option<u128>> {
+        let state_key = StateKey::resource_typed::<BalanceResource>(&address)?;
+        self.client
+            .state_get_with_proof2(state_key)?
+            .state
+            .map_or(Ok(None), |state| {
+                Ok(Some(
+                    bcs_ext::from_bytes::<BalanceResource>(state.0.as_slice())?.token(),
+                ))
+            })
     }
 }
 

sync/Cargo.toml

@@ -77,10 +77,6 @@ starcoin-account-service = { workspace = true }
 starcoin-vm2-account-service = { workspace = true }
 starcoin-vm2-statedb = { workspace = true }
 starcoin-vm2-vm-runtime = { workspace = true }
-starcoin-rpc-client = { workspace = true }
-chrono = { workspace = true }
-plotters = "0.3"
-tempfile = { workspace = true }
 
 [package]
 authors = { workspace = true }