starknet_os: os resources test - add sha512

Author: dorimedini-starkware

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

@@ -3,6 +3,7 @@
 mod OsResourcesTestContract {
     use box::BoxTrait;
     use core::sha256::{SHA256_INITIAL_STATE, sha256_state_handle_init};
+    use core::sha512::{SHA512_INITIAL_STATE, sha512_state_handle_init};
     use starknet::info::SyscallResultTrait;
     use starknet::secp256_trait::Secp256Trait;
     use starknet::secp256k1::{
@@ -16,7 +17,7 @@ mod OsResourcesTestContract {
     use starknet::syscalls::{
         call_contract_syscall, deploy_syscall, emit_event_syscall, get_execution_info_v3_syscall,
         keccak_syscall, library_call_syscall, replace_class_syscall, send_message_to_l1_syscall,
-        sha256_process_block_syscall,
+        sha256_process_block_syscall, sha512_process_block_syscall,
     };
     use starknet::{ClassHash, ContractAddress, get_block_hash_syscall, get_class_hash_at_syscall};
 
@@ -136,6 +137,11 @@ mod OsResourcesTestContract {
         let mut state = sha256_state_handle_init(BoxTrait::new(SHA256_INITIAL_STATE));
         let _ = sha256_process_block_syscall(state, input).unwrap_syscall();
 
+        // sha256.
+        let mut input = BoxTrait::new([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]);
+        let mut state = sha512_state_handle_init(BoxTrait::new(SHA512_INITIAL_STATE));
+        let _ = sha512_process_block_syscall(state, input).unwrap_syscall();
+
         // replace class syscall.
         replace_class_syscall(stable_class_hash).unwrap_syscall();
 

crates/starknet_os/src/test_utils.rs

@@ -18,6 +18,16 @@ pub mod validations;
 #[path = "resource_utils_test.rs"]
 mod resource_utils_test;
 
+fn scale_builtin_cells(resources: &ExecutionResources) -> ExecutionResources {
+    let mut scaled_resources = resources.clone();
+    scaled_resources.builtin_instance_counter = scaled_resources
+        .builtin_instance_counter
+        .iter()
+        .map(|(builtin, count)| (*builtin, count / BUILTIN_INSTANCE_SIZES.get(builtin).unwrap()))
+        .collect();
+    scaled_resources
+}
+
 // Resources consumed by the SHA-256 batch phase, separated into linear and constant factors.
 pub const SHA256_BATCH_SIZE: usize = 7;
 pub static SHA256_BATCH_RESOURCES_LINEAR_UNSCALED: LazyLock<ExecutionResources> =
@@ -29,15 +39,8 @@ pub static SHA256_BATCH_RESOURCES_LINEAR_UNSCALED: LazyLock<ExecutionResources>
             (BuiltinName::range_check, 448),
         ]),
     });
-pub static SHA256_BATCH_RESOURCES_LINEAR: LazyLock<ExecutionResources> = LazyLock::new(|| {
-    let mut resources = SHA256_BATCH_RESOURCES_LINEAR_UNSCALED.clone();
-    resources.builtin_instance_counter = resources
-        .builtin_instance_counter
-        .iter()
-        .map(|(builtin, count)| (*builtin, count / BUILTIN_INSTANCE_SIZES.get(builtin).unwrap()))
-        .collect();
-    resources
-});
+pub static SHA256_BATCH_RESOURCES_LINEAR: LazyLock<ExecutionResources> =
+    LazyLock::new(|| scale_builtin_cells(&*SHA256_BATCH_RESOURCES_LINEAR_UNSCALED));
 pub static SHA256_BATCH_RESOURCES_CONSTANT: LazyLock<ExecutionResources> =
     LazyLock::new(|| ExecutionResources {
         n_steps: 49,
@@ -50,21 +53,17 @@ pub static SHA256_BATCH_RESOURCES_CONSTANT: LazyLock<ExecutionResources> =
 
 // Resources consumed by the SHA-512 batch phase, separated into linear and constant factors.
 pub const SHA512_BATCH_SIZE: usize = 3;
-pub static SHA512_BATCH_RESOURCES_LINEAR: LazyLock<ExecutionResources> =
+pub static SHA512_BATCH_RESOURCES_LINEAR_UNSCALED: LazyLock<ExecutionResources> =
     LazyLock::new(|| ExecutionResources {
         n_steps: 13710,
         n_memory_holes: 0,
         builtin_instance_counter: BTreeMap::from([
-            (
-                BuiltinName::bitwise,
-                9960 / BUILTIN_INSTANCE_SIZES.get(&BuiltinName::bitwise).unwrap(),
-            ),
-            (
-                BuiltinName::range_check,
-                192 / BUILTIN_INSTANCE_SIZES.get(&BuiltinName::range_check).unwrap(),
-            ),
+            (BuiltinName::bitwise, 9960),
+            (BuiltinName::range_check, 192),
         ]),
     });
+pub static SHA512_BATCH_RESOURCES_LINEAR: LazyLock<ExecutionResources> =
+    LazyLock::new(|| scale_builtin_cells(&*SHA512_BATCH_RESOURCES_LINEAR_UNSCALED));
 pub static SHA512_BATCH_RESOURCES_CONSTANT: LazyLock<ExecutionResources> =
     LazyLock::new(|| ExecutionResources {
         n_steps: 49,

crates/starknet_os_flow_tests/src/os_resources_test.rs

@@ -28,7 +28,12 @@ use starknet_api::transaction::{L2ToL1Payload, MessageToL1};
 use starknet_api::versioned_constants_logic::VersionedConstantsTrait;
 use starknet_api::{calldata, declare_tx_args, invoke_tx_args};
 use starknet_os::hint_processor::os_logger::ResourceFinalizer;
-use starknet_os::test_utils::{SHA256_BATCH_RESOURCES_LINEAR_UNSCALED, SHA256_BATCH_SIZE};
+use starknet_os::test_utils::{
+    SHA256_BATCH_RESOURCES_LINEAR_UNSCALED,
+    SHA256_BATCH_SIZE,
+    SHA512_BATCH_RESOURCES_LINEAR_UNSCALED,
+    SHA512_BATCH_SIZE,
+};
 use starknet_types_core::felt::Felt;
 use strum::IntoEnumIterator;
 
@@ -49,7 +54,7 @@ use crate::test_manager::{
 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; 13] = [
+const UNMEASURABLE_SYSCALLS: [Selector; 12] = [
     Selector::DelegateCall,
     Selector::DelegateL1Handler,
     Selector::GetBlockNumber,
@@ -59,7 +64,6 @@ const UNMEASURABLE_SYSCALLS: [Selector; 13] = [
     Selector::GetSequencerAddress,
     Selector::GetTxInfo,
     Selector::GetTxSignature,
-    Selector::Sha512ProcessBlock,
     Selector::LibraryCallL1Handler,
     Selector::StorageRead,
     Selector::StorageWrite,
@@ -87,7 +91,8 @@ static SYSCALLS_WITH_LINEAR_FACTOR: LazyLock<HashMap<Selector, usize>> = LazyLoc
 /// Syscalls that are implemented using virtual builtins. Such syscalls have their "heavy lifting"
 /// executed after the execute_syscalls part of the OS, so the consumed resources are not captured
 /// by the OsLogger.
-const SYSCALLS_WITH_VIRTUAL_BUILTINS: [Selector; 1] = [Selector::Sha256ProcessBlock];
+const SYSCALLS_WITH_VIRTUAL_BUILTINS: [Selector; 2] =
+    [Selector::Sha256ProcessBlock, Selector::Sha512ProcessBlock];
 
 /// Expected syscalls in the fee transfer call. Should be removed from the list of syscalls during
 /// measurement iteration - only the syscalls called during __execute__ should be measured.
@@ -117,6 +122,9 @@ fn update_resources_for_virtual_builtin_syscall(
         Selector::Sha256ProcessBlock => (&measured_base
             + &SHA256_BATCH_RESOURCES_LINEAR_UNSCALED.div_ceil(SHA256_BATCH_SIZE))
             .filter_unused_builtins(),
+        Selector::Sha512ProcessBlock => (&measured_base
+            + &SHA512_BATCH_RESOURCES_LINEAR_UNSCALED.div_ceil(SHA512_BATCH_SIZE))
+            .filter_unused_builtins(),
         _ => panic!("Resource update not implemented for virtual builtin syscall: {selector:?}."),
     }
 }