[benchmarks] Add fibonacci benchmark (#17988)

* Add fibonacci benchmark

* Use same number for each benchmark

* Waive

* Run rustfmt

Author: calintat

crates/transaction-workloads-lib/prebuilt.mpb

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::{
-    move_workloads::{LoopType, PreBuiltPackagesImpl},
+    move_workloads::{FibonacciFunctionType, LoopType, PreBuiltPackagesImpl},
     token_workflow::TokenWorkflowKind,
     EntryPoints, MonotonicCounterType, OrderBookState,
 };
@@ -106,6 +106,11 @@ pub enum TransactionTypeArg {
     MonotonicCounterMultiple10,
     MonotonicCounterMultiple100,
     MonotonicCounterMultiple1000,
+
+    // Fibonacci tests
+    FibonacciRecursive20,
+    FibonacciTailRecursive20,
+    FibonacciIterative20,
 }
 
 impl TransactionTypeArg {
@@ -487,6 +492,24 @@ impl TransactionTypeArg {
                     counter_type: MonotonicCounterType::Multiple { count: 1000 },
                 })
             },
+            TransactionTypeArg::FibonacciRecursive20 => {
+                call_custom_module(EntryPoints::Fibonacci {
+                    n: 20,
+                    function_type: FibonacciFunctionType::Recursive,
+                })
+            },
+            TransactionTypeArg::FibonacciTailRecursive20 => {
+                call_custom_module(EntryPoints::Fibonacci {
+                    n: 20,
+                    function_type: FibonacciFunctionType::TailRecursive,
+                })
+            },
+            TransactionTypeArg::FibonacciIterative20 => {
+                call_custom_module(EntryPoints::Fibonacci {
+                    n: 20,
+                    function_type: FibonacciFunctionType::Iterative,
+                })
+            },
         }
     }
 

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

@@ -47,6 +47,13 @@ pub enum LoopType {
     BcsToBytes { len: u64 },
 }
 
+#[derive(Debug, Clone)]
+pub enum FibonacciFunctionType {
+    Recursive,
+    TailRecursive,
+    Iterative,
+}
+
 /// Monotonically increasing counter test variants
 #[derive(Debug, Copy, Clone)]
 pub enum MonotonicCounterType {
@@ -127,6 +134,11 @@ pub enum EntryPoints {
         loop_count: Option<u64>,
         loop_type: LoopType,
     },
+    /// Compute the n-th fibonacci number using the given function type.
+    Fibonacci {
+        n: u64,
+        function_type: FibonacciFunctionType,
+    },
     // next 2 functions, second arg must be existing account address with data
     // Sets `Resource` to the max from two addresses
     Maximize,
@@ -314,6 +326,7 @@ impl EntryPointTrait for EntryPoints {
             | EntryPoints::Double
             | EntryPoints::Half
             | EntryPoints::Loop { .. }
+            | EntryPoints::Fibonacci { .. }
             | EntryPoints::GetFromConst { .. }
             | EntryPoints::SetId
             | EntryPoints::SetName
@@ -384,6 +397,7 @@ impl EntryPointTrait for EntryPoints {
             | EntryPoints::Double
             | EntryPoints::Half
             | EntryPoints::Loop { .. }
+            | EntryPoints::Fibonacci { .. }
             | EntryPoints::GetFromConst { .. }
             | EntryPoints::SetId
             | EntryPoints::SetName
@@ -501,6 +515,16 @@ impl EntryPointTrait for EntryPoints {
                 };
                 get_payload(module_id, ident_str!(method).to_owned(), args)
             },
+            EntryPoints::Fibonacci { n, function_type } => {
+                let method = match function_type {
+                    FibonacciFunctionType::Recursive => "fibonacci_recursive",
+                    FibonacciFunctionType::TailRecursive => "fibonacci_tail_recursive",
+                    FibonacciFunctionType::Iterative => "fibonacci_iterative",
+                };
+                get_payload(module_id, ident_str!(method).to_owned(), vec![
+                    bcs::to_bytes(&n).unwrap(),
+                ])
+            },
             EntryPoints::GetFromConst { const_idx } => get_from_random_const(
                 module_id,
                 const_idx.unwrap_or_else(
@@ -995,6 +1019,7 @@ impl EntryPointTrait for EntryPoints {
             | EntryPoints::Double
             | EntryPoints::Half
             | EntryPoints::Loop { .. }
+            | EntryPoints::Fibonacci { .. }
             | EntryPoints::GetFromConst { .. }
             | EntryPoints::SetId
             | EntryPoints::SetName

crates/transaction-workloads-lib/src/move_workloads.rs

@@ -1076,4 +1076,28 @@ mod tests {
             NativeParallelUncoordinatedBlockExecutor<NativeNoStorageRawTransactionExecutor>,
         >(Some(TransactionTypeArg::NoOp), false);
     }
+
+    #[test]
+    fn test_fibonacci_recursive() {
+        test_generic_benchmark::<AptosVMBlockExecutor>(
+            Some(TransactionTypeArg::FibonacciRecursive20),
+            true,
+        );
+    }
+
+    #[test]
+    fn test_fibonacci_tail_recursive() {
+        test_generic_benchmark::<AptosVMBlockExecutor>(
+            Some(TransactionTypeArg::FibonacciTailRecursive20),
+            true,
+        );
+    }
+
+    #[test]
+    fn test_fibonacci_iterative() {
+        test_generic_benchmark::<AptosVMBlockExecutor>(
+            Some(TransactionTypeArg::FibonacciIterative20),
+            true,
+        );
+    }
 }

execution/executor-benchmark/src/lib.rs

@@ -101,6 +101,56 @@ module 0xABCD::simple {
         }
     }
 
+    public entry fun fibonacci_recursive(_s: &signer, n: u64) {
+        fib_rec(n);
+    }
+
+    public entry fun fibonacci_tail_recursive(_s: &signer, n: u64) {
+        fib_tail_rec(n, 0, 1);
+    }
+
+    public entry fun fibonacci_iterative(_s: &signer, n: u64) {
+        fib_iter(n);
+    }
+
+    /// Computes the n-th fibonacci number using a simple recursive algorithm.
+    fun fib_rec(n: u64): u64 {
+        if (n <= 1) {
+            n
+        } else {
+            fib_rec(n - 1) + fib_rec(n - 2)
+        }
+    }
+
+    /// Computes the n-th fibonacci number using a tail-recursive algorithm.
+    fun fib_tail_rec(n: u64, a: u64, b: u64): u64 {
+        if (n == 0) {
+            a
+        } else {
+            fib_tail_rec(n - 1, b, a + b)
+        }
+    }
+
+    /// Computes the n-th fibonacci number using an iterative algorithm.
+    fun fib_iter(n: u64): u64 {
+        if (n <= 1) {
+            return n;
+        };
+
+        let a = 0;
+        let b = 1;
+
+        let i = 2;
+        while (i <= n) {
+            let temp = a + b;
+            a = b;
+            b = temp;
+            i += 1;
+        };
+
+        b
+    }
+
     // Counter
     // This is a constant to change to check versioning of the module published.
     // In a simple way this can be used as a verion info, and incremented by 1

testsuite/benchmark-workloads/packages/simple/sources/Simple.move

@@ -275,6 +275,10 @@ class RunGroupConfig:
     RunGroupConfig(key=RunGroupKey("order-book-balanced-size-skewed80-pct50-markets"), included_in=Flow.ORDER_BOOK | Flow.CONTINUOUS, waived=True),
     RunGroupConfig(key=RunGroupKey("monotonic-counter-single"), included_in=Flow.CONTINUOUS, waived=True),
 
+    RunGroupConfig(key=RunGroupKey("fibonacci-recursive20"), included_in=Flow.CONTINUOUS, waived=True),
+    RunGroupConfig(key=RunGroupKey("fibonacci-tail-recursive20"), included_in=Flow.CONTINUOUS, waived=True),
+    RunGroupConfig(key=RunGroupKey("fibonacci-iterative20"), included_in=Flow.CONTINUOUS, waived=True),
+
     RunGroupConfig(expected_tps=50000, key=RunGroupKey("coin_transfer_connected_components", executor_type="sharded"), key_extra=RunGroupKeyExtra(sharding_traffic_flags="--connected-tx-grps 5000", transaction_type_override=""), included_in=Flow.REPRESENTATIVE, waived=True),
     RunGroupConfig(expected_tps=50000, key=RunGroupKey("coin_transfer_hotspot", executor_type="sharded"), key_extra=RunGroupKeyExtra(sharding_traffic_flags="--hotspot-probability 0.8", transaction_type_override=""), included_in=Flow.REPRESENTATIVE, waived=True),
 

testsuite/single_node_performance.py

@@ -53,3 +53,6 @@ no_commit_apt-fa-transfer	1	VM	5	0.756	1.016	35479.7
 no_commit_apt-fa-transfer	1	NativeVM	5	0.799	1.013	60489.6
 no_commit_apt-fa-transfer	1	AptosVMSpeculative	5	0.680	1.014	10473.4
 no_commit_apt-fa-transfer	1	NativeSpeculative	5	0.702	1.011	102011.3
+fibonacci-recursive-20	1	VM	9	0.989	1.017	3339.3
+fibonacci-tail-recursive-20	1	VM	9	0.989	1.017	3339.3
+fibonacci-iterative-20	1	VM	9	0.989	1.017	3339.3