starknet_os: os resources test - measure linear factor, add deploy

Author: dorimedini-starkware

crates/apollo_starknet_os_program/src/cairo/starkware/starknet/core/os/constants.cairo

@@ -108,7 +108,7 @@ const SYSCALL_BASE_GAS_COST = 10000;
 
 // Syscall gas costs.
 const CALL_CONTRACT_GAS_COST = 91360;
-const DEPLOY_GAS_COST = 147120;
+const DEPLOY_GAS_COST = 151970;
 const DEPLOY_CALLDATA_FACTOR_GAS_COST = 4850;
 const GET_BLOCK_HASH_GAS_COST = 10840;
 const GET_CLASS_HASH_AT_GAS_COST = 10000;

crates/apollo_starknet_os_program/src/program_hash.json

@@ -1,5 +1,5 @@
 {
-  "os": "0x7b762f60dc1f9ecb199322522749de4e926c1eee33454764ae8974744ef0c5a",
+  "os": "0x765f8dfbd1ba21a2381a20e92688112bb3633377c11448a2167a230d0b339f0",
   "virtual_os": "0x28619dbc9767792fb536aaba7a2d55f70faadf808c95ec66b956d33fdee1bc0",
   "aggregator": "0x700786d51b3854af43d8e12180380bda3029be6c1767e007858de6ca2edac40",
   "aggregator_with_prefix": "0xe08d300e3f5996e43d6d7cc5a20068e0e58cf1309089f2348317ac580f6c1f"

crates/blockifier/resources/blockifier_versioned_constants_0_14_4.json

@@ -247,11 +247,11 @@
             },
             "Deploy": {
                 "constant": {
-                    "n_steps": 1173,
+                    "n_steps": 1181,
                     "n_memory_holes": 0,
                     "builtin_instance_counter": {
                         "range_check_builtin": 21,
-                        "pedersen_builtin": 7
+                        "pedersen_builtin": 8
                     }
                 },
                 "calldata_factor": {

crates/blockifier/resources/versioned_constants_diff_regression/0.14.3_0.14.4.txt

@@ -1,3 +1,5 @@
 + /os_constants/allowed_virtual_os_program_hashes/2: "0x28619dbc9767792fb536aaba7a2d55f70faadf808c95ec66b956d33fdee1bc0"
 ~ /os_resources/execute_syscalls/CallContract/n_steps: 901
+~ /os_resources/execute_syscalls/Deploy/constant/builtin_instance_counter/pedersen_builtin: 8
+~ /os_resources/execute_syscalls/Deploy/constant/n_steps: 1183
 ~ /os_resources/execute_syscalls/LibraryCall/n_steps: 874

crates/blockifier_test_utils/resources/feature_contracts/cairo1/os_resources_test_contract.cairo

@@ -2,7 +2,7 @@
 #[starknet::contract(account)]
 mod OsResourcesTestContract {
     use starknet::info::SyscallResultTrait;
-    use starknet::syscalls::{call_contract_syscall, library_call_syscall};
+    use starknet::syscalls::{call_contract_syscall, deploy_syscall, library_call_syscall};
     use starknet::{ClassHash, ContractAddress};
 
     const STABLE_EXTERNAL_ENTRY_POINT_SELECTOR: felt252 = selector!("external");
@@ -40,5 +40,13 @@ mod OsResourcesTestContract {
             stable_class_hash, STABLE_EXTERNAL_ENTRY_POINT_SELECTOR, array![0].span(),
         )
             .unwrap_syscall();
+
+        // deploy syscall. The resources this syscall consumes can vary depending on the deployed
+        // contract address, in a non-trivial way (see `normalize_address` in the cairo0 core). For
+        // this reason we deploy from zero, and choose a specific salt.
+        // base (no calldata):
+        deploy_syscall(stable_class_hash, 3, array![0].span(), true).unwrap_syscall();
+        // linear factor (calldata len = 1):
+        deploy_syscall(stable_class_hash, 3, array![1, 0].span(), true).unwrap_syscall();
     }
 }

crates/starknet_os_flow_tests/src/os_resources_test.rs

@@ -2,6 +2,8 @@ use std::collections::HashSet;
 
 use blockifier::blockifier_versioned_constants::{
     RawVersionedConstants,
+    ResourcesParams,
+    VariableCallDataFactor,
     VariableResourceParams,
     VersionedConstants,
 };
@@ -36,10 +38,9 @@ use crate::test_manager::{TestBuilder, TestBuilderConfig, FUNDED_ACCOUNT_ADDRESS
 use crate::tests::NON_TRIVIAL_RESOURCE_BOUNDS;
 
 // TODO(Dori): Delete this, or at least reduce it to a minimal set of unmeasurable syscalls.
-const UNMEASURABLE_SYSCALLS: [Selector; 34] = [
+const UNMEASURABLE_SYSCALLS: [Selector; 33] = [
     Selector::DelegateCall,
     Selector::DelegateL1Handler,
-    Selector::Deploy,
     Selector::EmitEvent,
     Selector::GetBlockHash,
     Selector::GetBlockNumber,
@@ -73,6 +74,8 @@ const UNMEASURABLE_SYSCALLS: [Selector; 34] = [
     Selector::StorageWrite,
 ];
 
+const SYSCALLS_WITH_LINEAR_FACTOR: [Selector; 2] = [Selector::Deploy, Selector::MetaTxV0];
+
 /// Measure the OS overhead for each syscall, and compare the results with the latest VC.
 ///
 /// This test relies on the [starknet_os::hint_processor::os_logger::OsLogger] to capture the
@@ -199,41 +202,66 @@ async fn test_os_resources_regression() {
     // Measure each syscall overhead. If the syscall incurs an inner call, subtract the inner call
     // overhead.
     let mut inner_calls_iter = inner_calls.into_iter();
-    let mut visited_syscalls = HashSet::new();
-    let measurements: IndexMap<Selector, ExecutionResources> = syscall_traces
+    let mut syscalls_iter = syscall_traces
         .iter()
-        .filter_map(|syscall_trace| {
-            let selector = syscall_trace.get_selector();
-            if UNMEASURABLE_SYSCALLS.contains(&selector) {
-                return None;
-            }
+        .filter(|syscall_trace| !UNMEASURABLE_SYSCALLS.contains(&syscall_trace.get_selector()));
+    let mut measurements: IndexMap<Selector, VariableResourceParams> = IndexMap::new();
+    let mut fetch_inner_resources = |selector: Selector| -> ExecutionResources {
+        if selector.is_calling_syscall() {
+            // TODO(Dori): Take opcodes (like blake) into account.
+            inner_calls_iter.next().unwrap().resources.vm_resources
+        } else {
+            ExecutionResources::default()
+        }
+    };
+    while let Some(syscall_trace) = syscalls_iter.next() {
+        let selector = syscall_trace.get_selector();
 
-            // Ensure we don't visit the same syscall twice.
-            assert!(
-                !visited_syscalls.contains(&selector),
-                "Syscall {selector:?} was visited twice."
-            );
-            visited_syscalls.insert(selector);
+        // Ensure we don't visit the same syscall more than once.
+        assert!(
+            measurements.get(&selector).is_none(),
+            "Syscall {selector:?} was visited again, unexpectedly."
+        );
 
-            // If this syscall incurs an inner call, it should be the next inner call in the
-            // iterator.
-            let inner_overhead = if selector.is_calling_syscall() {
-                // TODO(Dori): Take opcodes (like blake) into account.
-                inner_calls_iter.next().unwrap().resources.vm_resources
-            } else {
-                ExecutionResources::default()
-            };
+        // If this syscall incurs an inner call, it should be the next inner call in the
+        // iterator.
+        let inner_overhead = fetch_inner_resources(selector);
+        // The resources measured here are one of two types: constant, or base cost of a syscall
+        // with a linear factor.
+        let resources =
+            (syscall_trace.get_resources().unwrap() - &inner_overhead).filter_unused_builtins();
 
-            Some((
+        // If this if a syscall with a linear factor, the next syscall should be the linear cost.
+        // Otherwise, this syscall has a constant cost.
+        let syscall_cost = if SYSCALLS_WITH_LINEAR_FACTOR.contains(&selector) {
+            let next_syscall_trace = syscalls_iter.next().unwrap();
+            assert_eq!(
                 selector,
-                (syscall_trace.get_resources().unwrap() - &inner_overhead).filter_unused_builtins(),
-            ))
-        })
-        .collect();
+                next_syscall_trace.get_selector(),
+                "Expected next syscall to be the same as the current syscall {selector:?}, but \
+                 got {:?}.",
+                next_syscall_trace.get_selector()
+            );
+            let next_inner_overhead = fetch_inner_resources(selector);
+            let next_resources = (next_syscall_trace.get_resources().unwrap()
+                - &next_inner_overhead)
+                .filter_unused_builtins();
+            let linear_factor_resources = (&next_resources - &resources).filter_unused_builtins();
+            VariableResourceParams::WithFactor(ResourcesParams {
+                constant: resources,
+                // Syscalls with a linear factor have an unscaled linear factor cost.
+                calldata_factor: VariableCallDataFactor::Unscaled(linear_factor_resources),
+            })
+        } else {
+            VariableResourceParams::Constant(resources)
+        };
+
+        measurements.insert(selector, syscall_cost);
+    }
 
     // Make sure we covered all syscalls we expect to.
     assert_eq!(
-        visited_syscalls,
+        HashSet::from_iter(measurements.keys().cloned()),
         Selector::iter()
             .collect::<HashSet<_>>()
             .difference(&UNMEASURABLE_SYSCALLS.iter().cloned().collect::<HashSet<_>>())
@@ -246,10 +274,7 @@ async fn test_os_resources_regression() {
     let mut raw_vc: RawVersionedConstants =
         serde_json::from_str(VersionedConstants::json_str(&version).unwrap()).unwrap();
     for (syscall, resources) in measurements {
-        raw_vc
-            .os_resources
-            .execute_syscalls
-            .insert(syscall, VariableResourceParams::Constant(resources));
+        raw_vc.os_resources.execute_syscalls.insert(syscall, resources);
     }
     expect_file![VersionedConstants::json_path(&version).unwrap()]
         .assert_eq(&raw_vc.to_string_pretty());