update benchmark tests

Author: tejasbadadare

target_chains/ethereum/contracts/forge-test/GasBenchmark.t.sol

@@ -19,11 +19,12 @@ contract GasBenchmark is Test, WormholeTestUtils, PythTestUtils {
     // It is possible to have more signers but the median seems to be 13.
     uint8 constant NUM_GUARDIAN_SIGNERS = 13;
 
-    // We use 5 prices to form a batch of 5 prices, close to our mainnet transactions.
-    uint8 constant NUM_PRICES = 5;
+    // Our mainnet transactions use 5 prices to form a batch of 5 prices,
+    // but Pulse allows parsing up to 10 requests in a single requests, so we set up 10 prices.
+    uint8 constant NUM_PRICES = 10;
 
-    // We will have less than 512 price for a foreseeable future.
-    uint8 constant MERKLE_TREE_DEPTH = 9;
+    // We will have less than 2^11=2048 price for a foreseeable future.
+    uint8 constant MERKLE_TREE_DEPTH = 11;
 
     IWormhole public wormhole;
     IPyth public pyth;
@@ -265,10 +266,8 @@ contract GasBenchmark is Test, WormholeTestUtils, PythTestUtils {
             100
         );
     }
-
-    function testBenchmarkParsePriceFeedUpdates1() public {
-        uint numIds = 1;
-
+    // Helper function to run price feed update benchmark with a specified number of feeds
+    function _runParsePriceFeedUpdatesBenchmark(uint256 numIds) internal {
         bytes32[] memory ids = new bytes32[](numIds);
         for (uint i = 0; i < numIds; i++) {
             ids[i] = priceIds[i];
@@ -281,64 +280,44 @@ contract GasBenchmark is Test, WormholeTestUtils, PythTestUtils {
         );
     }
 
-    function testBenchmarkParsePriceFeedUpdates2() public {
-        uint numIds = 2;
+    function testBenchmarkParsePriceFeedUpdates1() public {
+        _runParsePriceFeedUpdatesBenchmark(1);
+    }
 
-        bytes32[] memory ids = new bytes32[](numIds);
-        for (uint i = 0; i < numIds; i++) {
-            ids[i] = priceIds[i];
-        }
-        pyth.parsePriceFeedUpdates{value: freshPricesUpdateFee[numIds - 1]}(
-            freshPricesUpdateData[numIds - 1],
-            ids,
-            0,
-            50
-        );
+    function testBenchmarkParsePriceFeedUpdates2() public {
+        _runParsePriceFeedUpdatesBenchmark(2);
     }
 
     function testBenchmarkParsePriceFeedUpdates3() public {
-        uint numIds = 3;
-
-        bytes32[] memory ids = new bytes32[](numIds);
-        for (uint i = 0; i < numIds; i++) {
-            ids[i] = priceIds[i];
-        }
-        pyth.parsePriceFeedUpdates{value: freshPricesUpdateFee[numIds - 1]}(
-            freshPricesUpdateData[numIds - 1],
-            ids,
-            0,
-            50
-        );
+        _runParsePriceFeedUpdatesBenchmark(3);
     }
 
     function testBenchmarkParsePriceFeedUpdates4() public {
-        uint numIds = 4;
-
-        bytes32[] memory ids = new bytes32[](numIds);
-        for (uint i = 0; i < numIds; i++) {
-            ids[i] = priceIds[i];
-        }
-        pyth.parsePriceFeedUpdates{value: freshPricesUpdateFee[numIds - 1]}(
-            freshPricesUpdateData[numIds - 1],
-            ids,
-            0,
-            50
-        );
+        _runParsePriceFeedUpdatesBenchmark(4);
     }
 
     function testBenchmarkParsePriceFeedUpdates5() public {
-        uint numIds = 5;
+        _runParsePriceFeedUpdatesBenchmark(5);
+    }
 
-        bytes32[] memory ids = new bytes32[](numIds);
-        for (uint i = 0; i < numIds; i++) {
-            ids[i] = priceIds[i];
-        }
-        pyth.parsePriceFeedUpdates{value: freshPricesUpdateFee[numIds - 1]}(
-            freshPricesUpdateData[numIds - 1],
-            ids,
-            0,
-            50
-        );
+    function testBenchmarkParsePriceFeedUpdates6() public {
+        _runParsePriceFeedUpdatesBenchmark(6);
+    }
+
+    function testBenchmarkParsePriceFeedUpdates7() public {
+        _runParsePriceFeedUpdatesBenchmark(7);
+    }
+
+    function testBenchmarkParsePriceFeedUpdates8() public {
+        _runParsePriceFeedUpdatesBenchmark(8);
+    }
+
+    function testBenchmarkParsePriceFeedUpdates9() public {
+        _runParsePriceFeedUpdatesBenchmark(9);
+    }
+
+    function testBenchmarkParsePriceFeedUpdates10() public {
+        _runParsePriceFeedUpdatesBenchmark(10);
     }
 
     function testBenchmarkParsePriceFeedUpdatesForAllPriceFeedsShuffledSubsetPriceIds()

target_chains/ethereum/contracts/forge-test/PulseGasBenchmark.t.sol

@@ -98,23 +98,23 @@ contract PulseGasBenchmark is Test, PulseTestUtils {
         );
     }
 
-    function testFlow_01_Feed() public {
+    function testBasicFlowWith01Feeds() public {
         _runBenchmarkWithFeeds(1);
     }
 
-    function testFlow_02_Feeds() public {
+    function testBasicFlowWith02Feeds() public {
         _runBenchmarkWithFeeds(2);
     }
 
-    function testFlow_04_Feeds() public {
+    function testBasicFlowWith04Feeds() public {
         _runBenchmarkWithFeeds(4);
     }
 
-    function testFlow_08_Feeds() public {
+    function testBasicFlowWith08Feeds() public {
         _runBenchmarkWithFeeds(8);
     }
 
-    function testFlow_10_Feeds() public {
+    function testBasicFlowWith10Feeds() public {
         _runBenchmarkWithFeeds(10);
     }
 
@@ -124,7 +124,9 @@ contract PulseGasBenchmark is Test, PulseTestUtils {
     // The last fulfillment will be the most expensive since it needs
     // to linearly scan through all the fulfilled requests in storage
     // in order to update _state.lastUnfulfilledReq
-    // NOTE: Run test with -vv to see extra gas logs.
+    //
+    // NOTE: Run test with `forge test --gas-report --match-test testMultipleRequestsOutOfOrderFulfillment`
+    // and observe the `max` value for `executeCallback` to see the cost of the most expensive request.
     function testMultipleRequestsOutOfOrderFulfillment() public {
         uint64 timestamp = SafeCast.toUint64(block.timestamp);
         bytes32[] memory priceIds = createPriceIds(2);
@@ -181,9 +183,76 @@ contract PulseGasBenchmark is Test, PulseTestUtils {
         uint endGas = gasleft();
 
         // Log gas usage for the last callback which would be the most expensive
-        // in the original implementation
-        console.log("Gas used for last callback (seq 1):", midGas - endGas);
-        console.log("Gas used for all other callbacks:", startGas - midGas);
+        // in the original implementation (need to run test with -vv)
+        console.log(
+            "Gas used for last callback (seq 1): %s",
+            vm.toString(midGas - endGas)
+        );
+        console.log(
+            "Gas used for all other callbacks: %s",
+            vm.toString(startGas - midGas)
+        );
+    }
+
+    // Helper function to run the overflow mapping benchmark with a specified number of feeds
+    function _runOverflowBenchmarkWithFeeds(uint256 numFeeds) internal {
+        uint64 timestamp = SafeCast.toUint64(block.timestamp);
+        bytes32[] memory priceIds = createPriceIds(numFeeds);
+        uint32 callbackGasLimit = 100000;
+        uint128 totalFee = pulse.getFee(
+            defaultProvider,
+            callbackGasLimit,
+            priceIds
+        );
+
+        // Create NUM_REQUESTS requests to fill up the main array
+        // The constant is defined in PulseState.sol as 32
+        uint64[] memory sequenceNumbers = new uint64[](32);
+        vm.deal(address(consumer), 50 ether);
+
+        // Use the same timestamp for all requests to avoid "Too far in future" error
+        for (uint i = 0; i < 32; i++) {
+            vm.prank(address(consumer));
+            sequenceNumbers[i] = pulse.requestPriceUpdatesWithCallback{
+                value: totalFee
+            }(defaultProvider, timestamp, priceIds, callbackGasLimit);
+        }
+
+        // Create one more request that will go to the overflow mapping
+        // (This could potentially happen earlier if a shortKey collides,
+        // but this guarantees it.)
+        vm.prank(address(consumer));
+        pulse.requestPriceUpdatesWithCallback{value: totalFee}(
+            defaultProvider,
+            timestamp,
+            priceIds,
+            callbackGasLimit
+        );
+    }
+
+    // These tests benchmark the gas usage when a new request overflows the fixed-size
+    // request array and gets stored in the overflow mapping.
+    //
+    // NOTE: Run test with `forge test --gas-report --match-test testOverflowMappingGasUsageWithXXFeeds`
+    // and observe the `max` value for `executeCallback` to see the cost of the overflowing request.
+    function testOverflowMappingGasUsageWith01Feeds() public {
+        _runOverflowBenchmarkWithFeeds(1);
+    }
+
+    function testOverflowMappingGasUsageWith02Feeds() public {
+        _runOverflowBenchmarkWithFeeds(2);
+    }
+
+    function testOverflowMappingGasUsageWith04Feeds() public {
+        _runOverflowBenchmarkWithFeeds(4);
+    }
+
+    function testOverflowMappingGasUsageWith08Feeds() public {
+        _runOverflowBenchmarkWithFeeds(8);
+    }
+
+    function testOverflowMappingGasUsageWith10Feeds() public {
+        _runOverflowBenchmarkWithFeeds(10);
     }
 }