First draft of sol vs fe gas benchmarking

crates/fe/Cargo.toml

@@ -33,6 +33,8 @@ similar = "2"
 colored = "2"
 hex = "0.4"
 toml = "0.8.8"
+serde = { version = "1", features = ["derive"] }
+ethers-core = "2"
 glob.workspace = true
 crossbeam-channel.workspace = true
 scip = "0.6.1"

crates/fe/bench_fixtures/bitwise_u256.fe

@@ -0,0 +1,34 @@
+use std::abi::sol
+
+pub msg BenchMsg {
+    #[selector = sol("and_(uint256,uint256)")]
+    And { a: u256, b: u256 } -> u256,
+    #[selector = sol("or_(uint256,uint256)")]
+    Or { a: u256, b: u256 } -> u256,
+    #[selector = sol("xor_(uint256,uint256)")]
+    Xor { a: u256, b: u256 } -> u256,
+    #[selector = sol("shl_(uint256,uint256)")]
+    Shl { a: u256, b: u256 } -> u256,
+    #[selector = sol("shr_(uint256,uint256)")]
+    Shr { a: u256, b: u256 } -> u256,
+}
+
+pub contract Bench {
+    recv BenchMsg {
+        And { a, b } -> u256 {
+            a & b
+        }
+        Or { a, b } -> u256 {
+            a | b
+        }
+        Xor { a, b } -> u256 {
+            a ^ b
+        }
+        Shl { a, b } -> u256 {
+            a << b
+        }
+        Shr { a, b } -> u256 {
+            a >> b
+        }
+    }
+}

crates/fe/bench_fixtures/bitwise_u256.sol

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+contract Bench {
+    function and_(uint256 a, uint256 b) public pure returns (uint256) {
+        return a & b;
+    }
+
+    function or_(uint256 a, uint256 b) public pure returns (uint256) {
+        return a | b;
+    }
+
+    function xor_(uint256 a, uint256 b) public pure returns (uint256) {
+        return a ^ b;
+    }
+
+    function shl_(uint256 a, uint256 b) public pure returns (uint256) {
+        return a << b;
+    }
+
+    function shr_(uint256 a, uint256 b) public pure returns (uint256) {
+        return a >> b;
+    }
+}

crates/fe/bench_fixtures/bitwise_u256.toml

@@ -0,0 +1,21 @@
+contract = "Bench"
+
+[[calls]]
+function = "and_(uint256,uint256)"
+args = ["255", "170"]
+
+[[calls]]
+function = "or_(uint256,uint256)"
+args = ["255", "170"]
+
+[[calls]]
+function = "xor_(uint256,uint256)"
+args = ["255", "170"]
+
+[[calls]]
+function = "shl_(uint256,uint256)"
+args = ["1", "8"]
+
+[[calls]]
+function = "shr_(uint256,uint256)"
+args = ["256", "4"]

crates/fe/bench_fixtures/loops.fe

@@ -0,0 +1,71 @@
+use std::abi::sol
+
+pub msg BenchMsg {
+    #[selector = sol("counter(uint256)")]
+    Counter { n: u256 } -> u256,
+    #[selector = sol("sum(uint256)")]
+    Sum { n: u256 } -> u256,
+    #[selector = sol("xorLoop(uint256,uint256)")]
+    XorLoop { n: u256, seed: u256 } -> u256,
+    #[selector = sol("counterUnchecked(uint256)")]
+    CounterUnchecked { n: u256 } -> u256,
+    #[selector = sol("sumUnchecked(uint256)")]
+    SumUnchecked { n: u256 } -> u256,
+    #[selector = sol("xorLoopUnchecked(uint256,uint256)")]
+    XorLoopUnchecked { n: u256, seed: u256 } -> u256,
+}
+
+pub contract Bench {
+    recv BenchMsg {
+        Counter { n } -> u256 {
+            let mut i: u256 = 0
+            while i < n {
+                i = i + 1
+            }
+            i
+        }
+        Sum { n } -> u256 {
+            let mut total: u256 = 0
+            let mut i: u256 = 1
+            while i <= n {
+                total = total + i
+                i = i + 1
+            }
+            total
+        }
+        XorLoop { n, seed } -> u256 {
+            let mut acc: u256 = seed
+            let mut i: u256 = 0
+            while i < n {
+                acc = acc ^ (seed ^ i)
+                i = i + 1
+            }
+            acc
+        }
+        CounterUnchecked { n } -> u256 {
+            let mut i: u256 = 0
+            while i < n {
+                i = i + 1
+            }
+            i
+        }
+        SumUnchecked { n } -> u256 {
+            let mut total: u256 = 0
+            let mut i: u256 = 1
+            while i <= n {
+                total = total + i
+                i = i + 1
+            }
+            total
+        }
+        XorLoopUnchecked { n, seed } -> u256 {
+            let mut acc: u256 = seed
+            let mut i: u256 = 0
+            while i < n {
+                acc = acc ^ (seed ^ i)
+                i = i + 1
+            }
+            acc
+        }
+    }
+}

crates/fe/bench_fixtures/loops.sol

@@ -0,0 +1,64 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+contract Bench {
+    function counter(uint256 n) public pure returns (uint256) {
+        uint256 i = 0;
+        while (i < n) {
+            i = i + 1;
+        }
+        return i;
+    }
+
+    function sum(uint256 n) public pure returns (uint256) {
+        uint256 total = 0;
+        uint256 i = 1;
+        while (i <= n) {
+            total = total + i;
+            i = i + 1;
+        }
+        return total;
+    }
+
+    function xorLoop(uint256 n, uint256 seed) public pure returns (uint256) {
+        uint256 acc = seed;
+        uint256 i = 0;
+        while (i < n) {
+            acc = acc ^ (seed ^ i);
+            i = i + 1;
+        }
+        return acc;
+    }
+
+    function counterUnchecked(uint256 n) public pure returns (uint256) {
+        uint256 i = 0;
+        while (i < n) {
+            unchecked { i = i + 1; }
+        }
+        return i;
+    }
+
+    function sumUnchecked(uint256 n) public pure returns (uint256) {
+        uint256 total = 0;
+        uint256 i = 1;
+        while (i <= n) {
+            unchecked {
+                total = total + i;
+                i = i + 1;
+            }
+        }
+        return total;
+    }
+
+    function xorLoopUnchecked(uint256 n, uint256 seed) public pure returns (uint256) {
+        uint256 acc = seed;
+        uint256 i = 0;
+        while (i < n) {
+            unchecked {
+                acc = acc ^ (seed ^ i);
+                i = i + 1;
+            }
+        }
+        return acc;
+    }
+}

crates/fe/bench_fixtures/loops.toml

@@ -0,0 +1,25 @@
+contract = "Bench"
+
+[[calls]]
+function = "counter(uint256)"
+args = ["100"]
+
+[[calls]]
+function = "sum(uint256)"
+args = ["100"]
+
+[[calls]]
+function = "xorLoop(uint256,uint256)"
+args = ["100", "42"]
+
+[[calls]]
+function = "counterUnchecked(uint256)"
+args = ["100"]
+
+[[calls]]
+function = "sumUnchecked(uint256)"
+args = ["100"]
+
+[[calls]]
+function = "xorLoopUnchecked(uint256,uint256)"
+args = ["100", "42"]

crates/fe/bench_fixtures/math_u256.fe

@@ -0,0 +1,34 @@
+use std::abi::sol
+
+pub msg BenchMsg {
+    #[selector = sol("add(uint256,uint256)")]
+    Add { a: u256, b: u256 } -> u256,
+    #[selector = sol("sub(uint256,uint256)")]
+    Sub { a: u256, b: u256 } -> u256,
+    #[selector = sol("mul(uint256,uint256)")]
+    Mul { a: u256, b: u256 } -> u256,
+    #[selector = sol("div(uint256,uint256)")]
+    Div { a: u256, b: u256 } -> u256,
+    #[selector = sol("mod_(uint256,uint256)")]
+    Mod { a: u256, b: u256 } -> u256,
+}
+
+pub contract Bench {
+    recv BenchMsg {
+        Add { a, b } -> u256 {
+            a + b
+        }
+        Sub { a, b } -> u256 {
+            a - b
+        }
+        Mul { a, b } -> u256 {
+            a * b
+        }
+        Div { a, b } -> u256 {
+            a / b
+        }
+        Mod { a, b } -> u256 {
+            a % b
+        }
+    }
+}

crates/fe/bench_fixtures/math_u256.sol

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+contract Bench {
+    function add(uint256 a, uint256 b) public pure returns (uint256) {
+        return a + b;
+    }
+
+    function sub(uint256 a, uint256 b) public pure returns (uint256) {
+        return a - b;
+    }
+
+    function mul(uint256 a, uint256 b) public pure returns (uint256) {
+        return a * b;
+    }
+
+    function div(uint256 a, uint256 b) public pure returns (uint256) {
+        return a / b;
+    }
+
+    function mod_(uint256 a, uint256 b) public pure returns (uint256) {
+        return a % b;
+    }
+}

crates/fe/bench_fixtures/math_u256.toml

@@ -0,0 +1,21 @@
+contract = "Bench"
+
+[[calls]]
+function = "add(uint256,uint256)"
+args = ["100", "200"]
+
+[[calls]]
+function = "sub(uint256,uint256)"
+args = ["300", "100"]
+
+[[calls]]
+function = "mul(uint256,uint256)"
+args = ["50", "4"]
+
+[[calls]]
+function = "div(uint256,uint256)"
+args = ["1000", "7"]
+
+[[calls]]
+function = "mod_(uint256,uint256)"
+args = ["1000", "7"]

crates/fe/bench_fixtures/storage_simple.fe

@@ -0,0 +1,28 @@
+use std::abi::sol
+use std::evm::StorageMap
+
+pub msg BenchMsg {
+    #[selector = sol("store(uint256,uint256)")]
+    Store { key: u256, value: u256 },
+    #[selector = sol("load(uint256)")]
+    Load { key: u256 } -> u256,
+    #[selector = sol("storeAndLoad(uint256,uint256)")]
+    StoreAndLoad { key: u256, value: u256 } -> u256,
+}
+
+pub contract Bench {
+    mut data: StorageMap<u256, u256, 0>,
+
+    recv BenchMsg {
+        Store { key, value } uses (mut data) {
+            data.set(key, value)
+        }
+        Load { key } -> u256 uses (data) {
+            data.get(key)
+        }
+        StoreAndLoad { key, value } -> u256 uses (mut data) {
+            data.set(key, value)
+            data.get(key)
+        }
+    }
+}