limit on size

Rust tests in series and other quality of life fixes

configure/main.ts

@@ -8,6 +8,7 @@ import {
     Commitment,
     Connection,
     LAMPORTS_PER_SOL,
+    PublicKey,
 } from "@solana/web3.js";
 import { getKeypairFromFile } from "./common_utils";
 import { deploy_programs } from "./deploy_programs";
@@ -277,6 +278,7 @@ async function configure(
             market.quote_mint,
         ])
         .flat();
+
     const userAccountsList = userData
         .map((user) => {
             const allOpenOrdersAccounts = user.open_orders
@@ -286,13 +288,24 @@ async function configure(
             return allOpenOrdersAccounts.concat(allTokenAccounts);
         })
         .flat();
+
     accounts = accounts.concat(marketAccountsList).concat(userAccountsList);
 
     console.log("Accounts created");
 
+    const known_accounts = await Promise.all(accounts.map(async (account) => {
+        // get accountInfo as jsonParsed to get Size
+        let accountInfo = await connection.getParsedAccountInfo(account);
+        return [account,
+            // @ts-ignore
+            accountInfo.value.space
+        ] as [PublicKey, number];
+    }));
+
+
     let outputFile: OutputFile = {
         programs: programOutputData,
-        known_accounts: accounts,
+        known_accounts,
         users: userData,
         mints,
         markets,

configure/output_file.ts

@@ -17,7 +17,7 @@ export interface ProgramOutputData {
 export interface OutputFile {
   users: User[];
   programs: ProgramOutputData[];
-  known_accounts: PublicKey[];
+  known_accounts: [PublicKey, number][];
   mints: PublicKey[];
   markets: Market[];
 }

src/config.rs

@@ -78,7 +78,7 @@ pub struct Market {
 #[derive(Serialize, Deserialize, Clone)]
 pub struct Config {
     pub programs: Vec<ProgramData>,
-    pub known_accounts: Vec<String>,
+    pub known_accounts: Vec<(String, u32)>,
     pub users: Vec<User>,
     pub mints: Vec<String>,
     pub markets: Vec<Market>,

src/solana_runtime/accounts_fetching.rs

@@ -19,8 +19,8 @@ const NB_OF_ACCOUNTS_FETCHED_PER_TASK: usize = 100;
 pub struct AccountsFetchingTests;
 
 impl AccountsFetchingTests {
-    pub fn create_random_address(count: usize) -> Vec<Pubkey> {
-        (0..count).map(|_| Keypair::new().pubkey()).collect()
+    pub fn create_random_address(count: usize) -> Vec<(Pubkey, u32)> {
+        (0..count).map(|_| (Keypair::new().pubkey(), 0)).collect()
     }
 }
 
@@ -30,19 +30,19 @@ impl TestingTask for AccountsFetchingTests {
         let accounts = config
             .known_accounts
             .iter()
-            .map(|x| Pubkey::from_str(x.as_str()).unwrap())
+            .map(|x| (Pubkey::from_str(&x.0).unwrap(), x.1))
             .collect::<Vec<_>>();
-        let unknown_accounts: Vec<Pubkey> =
-            AccountsFetchingTests::create_random_address(accounts.len());
+
+        let unknown_accounts = AccountsFetchingTests::create_random_address(accounts.len());
 
         let instant = GetAccountsBench {
             accounts_list: Arc::new([accounts, unknown_accounts].concat()),
         };
+
         let metric = Bencher::bench::<GetAccountsBench>(instant, args).await?;
         Ok(metric)
     }
 
-
     fn get_name(&self) -> String {
         "Accounts Fetching".to_string()
     }
@@ -50,7 +50,7 @@ impl TestingTask for AccountsFetchingTests {
 
 #[derive(Clone)]
 pub struct GetAccountsBench {
-    accounts_list: Arc<Vec<Pubkey>>,
+    accounts_list: Arc<Vec<(Pubkey, u32)>>,
 }
 
 #[async_trait::async_trait]
@@ -70,10 +70,25 @@ impl Benchmark for GetAccountsBench {
             let accounts = self
                 .accounts_list
                 .iter()
-                .copied()
                 .choose_multiple(&mut rng, number_of_fetched_accounts);
 
-            rpc_client.raw_get_multiple_accounts(accounts).await
+            // filter accounts whose account.1 value summing up to 10485760
+            let mut sum = 0;
+            let mut filtered_accounts = Vec::new();
+
+            for account in accounts.iter() {
+                let local_sum = sum + account.1;
+
+                // try maximise the number of accounts fetched
+                if local_sum <= 10485760 {
+                    sum = local_sum;
+                    filtered_accounts.push(account.0);
+                } 
+            }
+
+            rpc_client
+                .raw_get_multiple_accounts(filtered_accounts)
+                .await
         }
 
         Ok(())