Add builtin usage stats. (#419)

* Change builtin types to counters.

* Increment builtin counters.

* Add `BuiltinStats` structure.

* Fix stuff.

* Fix stuff.

* Fix stuff.

* Fix stuff.

* Fix benches.

programs/benches/factorial_2M.c

@@ -1,35 +1,32 @@
-#include <stddef.h>
+#include <assert.h>
 #include <stdint.h>
 
 
 typedef struct factorial_return_values
 {
+    uint64_t range_check_counter;
     unsigned __int128 remaining_gas;
     struct {
         uint8_t discriminant;
-        union {
-            uint64_t ok[4];
-            struct {
-                void* ptr;
-                uint32_t len;
-                uint32_t cap;
-            } err;
-        };
+        struct {
+            void* ptr;
+            uint32_t len;
+            uint32_t cap;
+        } err;
     } result;
 } factorial_return_values_t;
 
 
-static void run_bench(factorial_return_values_t*, void*, uint64_t)
+static void run_bench(factorial_return_values_t*, uint64_t)
 __attribute__((weakref("_mlir_ciface_factorial_2M::factorial_2M::main(f1)")));
 
 
 int main()
 {
     factorial_return_values_t return_values;
 
-    run_bench(&return_values, NULL, 0);
+    run_bench(&return_values, 0);
+    assert(return_values.result.discriminant == 0);
 
-    // discriminant 0 == Result::Ok
-    // return value 0 == ok in hyperfine
-    return return_values.result.discriminant;
+    return 0;
 }

programs/benches/factorial_2M.cairo

@@ -6,9 +6,14 @@ fn factorial(value: felt252, n: felt252) -> felt252 {
     }
 }
 
-fn main() -> felt252 {
+fn main() {
     // Make sure that factorial(10) == 3628800
     let y: felt252 = factorial(1, 10);
     assert(3628800 == y, 'failed test');
-    factorial(1, 2000000)
+
+    let result = factorial(1, 2000000);
+    assert(
+        result == 0x4d6e41de886ac83938da3456ccf1481182687989ead34d9d35236f0864575a0,
+        'invalid result'
+    );
 }

programs/benches/fib_2M.c

@@ -1,36 +1,32 @@
-#include <dlfcn.h>
-#include <stddef.h>
+#include <assert.h>
 #include <stdint.h>
 
 
 typedef struct fib_return_values
 {
+    uint64_t range_check_counter;
     unsigned __int128 remaining_gas;
     struct {
         uint8_t discriminant;
-        union {
-            uint64_t ok[4];
-            struct {
-                void *ptr;
-                uint32_t len;
-                uint32_t cap;
-            } err;
-        };
+        struct {
+            void *ptr;
+            uint32_t len;
+            uint32_t cap;
+        } err;
     } result;
 } fib_return_values_t;
 
 
-static void run_bench(fib_return_values_t *, void *, uint64_t)
+static void run_bench(fib_return_values_t *, uint64_t)
     __attribute__((weakref("_mlir_ciface_fib_2M::fib_2M::main(f1)")));
 
 
 int main()
 {
     fib_return_values_t return_values;
 
-    run_bench(&return_values, NULL, 0);
+    run_bench(&return_values, 0);
+    assert(return_values.result.discriminant == 0);
 
-    // discriminant 0 == Result::Ok
-    // return value 0 == ok in hyperfine
-    return return_values.result.discriminant;
+    return 0;
 }

programs/benches/fib_2M.cairo

@@ -5,8 +5,13 @@ fn fib(a: felt252, b: felt252, n: felt252) -> felt252 {
     }
 }
 
-fn main() -> felt252 {
+fn main() {
     let y: felt252 = fib(0, 1, 10);
     assert(55 == y, 'failed test'); // check fib is correct
-    fib(0, 1, 2000000) // 2m
+
+    let result = fib(0, 1, 2000000);
+    assert(
+        result == 0x79495858064f7881b9eff3a923642b2990b5a4342da5470eb2251df58d9acfb,
+        'invalid result'
+    );
 }

programs/benches/logistic_map.c

@@ -1,33 +1,32 @@
-#include <stddef.h>
+#include <assert.h>
 #include <stdint.h>
 
 
 typedef struct map_return_values
 {
+    uint64_t range_check_counter;
     unsigned __int128 remaining_gas;
     struct {
         uint8_t discriminant;
-        union {
-            uint64_t ok[4];
-            struct {
-                void *ptr;
-                uint32_t len;
-                uint32_t cap;
-            } err;
-        };
+        struct {
+            void *ptr;
+            uint32_t len;
+            uint32_t cap;
+        } err;
     } result;
 } map_return_values_t;
 
 
-static void run_bench(map_return_values_t *, void *, uint64_t)
+static void run_bench(map_return_values_t *, uint64_t)
     __attribute__((weakref("_mlir_ciface_logistic_map::logistic_map::main(f2)")));
 
 
 int main()
 {
     map_return_values_t return_values;
 
-    run_bench(&return_values, NULL, 0);
+    run_bench(&return_values, 0);
+    assert(return_values.result.discriminant == 0);
 
     return 0;
 }

programs/benches/logistic_map.cairo

@@ -6,19 +6,24 @@ fn iterate_map(r: felt252, x: felt252) -> felt252 {
     r * x * -x
 }
 
-fn main() -> felt252 {
+fn main() {
     // Initial value.
     let mut x = 1234567890123456789012345678901234567890;
 
     // Iterate the map.
     let mut i = 15000;
-    loop {
+    let result = loop {
         x = iterate_map(4, x);
 
         if i == 0 {
             break x;
         }
 
         i = i - 1;
-    }
+    };
+
+    assert(
+        result == 0x12d35a3ae9fe7c56f194b12b34d567a844432acd2b7da993a158c15447a424d,
+        'invalid result'
+    );
 }

src/execution_result.rs

@@ -4,11 +4,22 @@ use crate::{
 };
 use starknet_types_core::felt::Felt;
 
+#[derive(Clone, Debug, Default, Eq, PartialEq)]
+pub struct BuiltinStats {
+    pub bitwise: usize,
+    pub ec_op: usize,
+    pub range_check: usize,
+    pub pedersen: usize,
+    pub poseidon: usize,
+    pub segment_arena: usize,
+}
+
 /// The result of the JIT execution.
-#[derive(Debug, Clone, Eq, PartialEq)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub struct ExecutionResult {
     pub remaining_gas: Option<u128>,
     pub return_value: JitValue,
+    pub builtin_stats: BuiltinStats,
 }
 
 /// Starknet contract execution result.