starknet_os: define sha256 batch resources constants

Author: dorimedini-starkware

crates/starknet_os/src/resource_utils_test.rs

@@ -0,0 +1,116 @@
+use std::collections::HashMap;
+
+use apollo_starknet_os_program::OS_PROGRAM_BYTES;
+use cairo_vm::types::builtin_name::BuiltinName;
+use cairo_vm::types::layout_name::LayoutName;
+use cairo_vm::types::relocatable::MaybeRelocatable;
+use cairo_vm::vm::runners::cairo_runner::ExecutionResources;
+use rand::rngs::StdRng;
+use rand::{RngExt, SeedableRng};
+use starknet_types_core::felt::Felt;
+
+use crate::test_utils::cairo_runner::{
+    initialize_cairo_runner,
+    run_cairo_0_entrypoint,
+    EndpointArg,
+    EntryPointRunnerConfig,
+    ImplicitArg,
+    ValueArg,
+};
+use crate::test_utils::{SHA256_BATCH_RESOURCES_CONSTANT, SHA256_BATCH_RESOURCES_LINEAR};
+
+/// SHA-256 block compression: takes 8 u32 state words and 16 u32 message words, returns the
+/// new 8 u32 state. Wraps `sha2::compress256` (message words are big-endian per the SHA-256 spec).
+fn sha_256_update_state(state: &[u32; 8], message: &[u32; 16]) -> [u32; 8] {
+    let block = sha2::digest::generic_array::GenericArray::from_exact_iter(
+        message.iter().flat_map(|word| word.to_be_bytes()),
+    )
+    .expect("message is exactly 64 bytes");
+    let mut new_state = *state;
+    sha2::compress256(&mut new_state, &[block]);
+    new_state
+}
+
+fn run_finalize_sha256(number_of_blocks: usize) -> ExecutionResources {
+    // Build the SHA-256 instance array. Each instance is 32 felts:
+    // [message (16) | initial_state (8) | output_state (8)].
+    let mut rng = StdRng::seed_from_u64(42);
+    let mut input: Vec<u32> = Vec::new();
+    for _ in 0..number_of_blocks {
+        let message: [u32; 16] = rng.random();
+        let state: [u32; 8] = rng.random();
+        input.extend_from_slice(&message);
+        input.extend_from_slice(&state);
+        let output_state = sha_256_update_state(&state, &message);
+        input.extend_from_slice(&output_state);
+    }
+
+    let runner_config = EntryPointRunnerConfig {
+        layout: LayoutName::starknet,
+        add_main_prefix_to_entrypoint: false,
+        ..Default::default()
+    };
+    let implicit_args = [
+        ImplicitArg::Builtin(BuiltinName::range_check),
+        ImplicitArg::Builtin(BuiltinName::bitwise),
+    ];
+    let (mut cairo_runner, program, entrypoint) = initialize_cairo_runner(
+        &runner_config,
+        OS_PROGRAM_BYTES,
+        "starkware.cairo.common.cairo_sha256.sha256_utils.finalize_sha256",
+        &implicit_args,
+        HashMap::new(),
+    )
+    .unwrap();
+
+    let sha256_start = cairo_runner
+        .vm
+        .gen_arg(
+            &input.iter().map(|&word| MaybeRelocatable::Int(Felt::from(word))).collect::<Vec<_>>(),
+        )
+        .unwrap()
+        .get_relocatable()
+        .unwrap();
+    let sha256_end = (sha256_start + input.len()).unwrap();
+
+    let explicit_args = [
+        EndpointArg::Value(ValueArg::Single(MaybeRelocatable::RelocatableValue(sha256_start))),
+        EndpointArg::Value(ValueArg::Single(MaybeRelocatable::RelocatableValue(sha256_end))),
+    ];
+    run_cairo_0_entrypoint(
+        entrypoint,
+        &explicit_args,
+        &implicit_args,
+        None,
+        &mut cairo_runner,
+        &program,
+        &runner_config,
+        &[],
+    )
+    .unwrap();
+
+    cairo_runner.get_execution_resources().unwrap()
+}
+
+/// Tests that the `finalize_sha256` Cairo function from the OS program consumes the expected
+/// resources.
+#[test]
+fn test_finalize_sha256() {
+    // Sha256 batching resources has a factor that is linear in the number of rounds, and a constant
+    // factor. Sample the execution at two points to compute both factors.
+    let blocks_in_round = 7_usize;
+    let number_of_blocks_1 = 8_usize;
+    let number_of_rounds_1 = (number_of_blocks_1 - 1) / blocks_in_round + 1;
+    let number_of_blocks_2 = number_of_blocks_1 + blocks_in_round;
+    let number_of_rounds_2 = (number_of_blocks_2 - 1) / blocks_in_round + 1;
+    let resources_1 = run_finalize_sha256(number_of_blocks_1);
+    let resources_2 = run_finalize_sha256(number_of_blocks_2);
+
+    assert_eq!(number_of_rounds_2 - number_of_rounds_1, 1);
+    let linear_factor = (&resources_2 - &resources_1).filter_unused_builtins();
+    let constant_factor =
+        (&resources_1 - &(&linear_factor * number_of_rounds_1)).filter_unused_builtins();
+
+    assert_eq!(linear_factor, *SHA256_BATCH_RESOURCES_LINEAR);
+    assert_eq!(constant_factor, *SHA256_BATCH_RESOURCES_CONSTANT);
+}

crates/starknet_os/src/test_utils.rs

@@ -1,7 +1,45 @@
+use std::collections::BTreeMap;
+use std::sync::LazyLock;
+
+use cairo_vm::types::builtin_name::BuiltinName;
+use cairo_vm::vm::runners::cairo_runner::ExecutionResources;
+
+use crate::hint_processor::constants::BUILTIN_INSTANCE_SIZES;
+
 pub mod cairo_dict;
 pub mod cairo_runner;
 pub mod coverage;
 pub mod errors;
 #[cfg(test)]
 pub mod utils;
 pub mod validations;
+
+#[cfg(test)]
+#[path = "resource_utils_test.rs"]
+mod resource_utils_test;
+
+// Resources consumed by the SHA-256 batch phase, separated into linear and constant factors.
+pub static SHA256_BATCH_RESOURCES_LINEAR: LazyLock<ExecutionResources> =
+    LazyLock::new(|| ExecutionResources {
+        n_steps: 11822,
+        n_memory_holes: 0,
+        builtin_instance_counter: BTreeMap::from([
+            (
+                BuiltinName::bitwise,
+                7800 / BUILTIN_INSTANCE_SIZES.get(&BuiltinName::bitwise).unwrap(),
+            ),
+            (
+                BuiltinName::range_check,
+                448 / BUILTIN_INSTANCE_SIZES.get(&BuiltinName::range_check).unwrap(),
+            ),
+        ]),
+    });
+pub static SHA256_BATCH_RESOURCES_CONSTANT: LazyLock<ExecutionResources> =
+    LazyLock::new(|| ExecutionResources {
+        n_steps: 49,
+        n_memory_holes: 0,
+        builtin_instance_counter: BTreeMap::from([(
+            BuiltinName::range_check,
+            3 / BUILTIN_INSTANCE_SIZES.get(&BuiltinName::range_check).unwrap(),
+        )]),
+    });