blockifier: refactor estimation blake constants (starkware-libs#8107)

Author: avivg-starkware

crates/blockifier/src/execution/execution_utils.rs

@@ -368,54 +368,67 @@ pub fn poseidon_hash_many_cost(data_length: usize) -> ExecutionResources {
     }
 }
 
-mod blake_cost {
-    // U-32 counts
+// Constants that define how felts are encoded into u32s for BLAKE hashing.
+mod blake_encoding {
+    /// Number of u32s in a Blake input message.
     pub const N_U32S_MESSAGE: usize = 16;
+
+    /// Number of u32s a felt is encoded into.
     pub const N_U32S_BIG_FELT: usize = 8;
     pub const N_U32S_SMALL_FELT: usize = 2;
+}
 
-    // Steps counts
+// Constants used for estimating the cost of BLAKE hashing inside Starknet OS.
+// These values are based on empirical measurement by running
+// `encode_felt252_data_and_calc_blake_hash` on various combinations of big and small felts.
+mod blake_estimation {
+    // Per-felt step cost (measured).
     pub const STEPS_BIG_FELT: usize = 45;
     pub const STEPS_SMALL_FELT: usize = 15;
 
-    // One-time segment setup cost (full vs partial)
+    // One-time overhead.
+    // Overhead when input fills a full Blake message (16 u32s).
     pub const BASE_STEPS_FULL_MSG: usize = 217;
+    // Overhead when input results in a partial message (remainder < 16 u32s).
     pub const BASE_STEPS_PARTIAL_MSG: usize = 195;
+    // Extra steps per 2-u32 remainder in partial messages.
     pub const STEPS_PER_2_U32_REMINDER: usize = 3;
 
-    // TODO(AvivG): This is a placeholder, add the actual gas cost for the BLAKE opcode
+    // BLAKE opcode gas cost in Stwo.
+    // TODO(AvivG): Replace with actual cost when known.
     pub const BLAKE_OPCODE_GAS: usize = 0;
 }
 
 /// Calculates the total number of u32s required to encode the given number of big and small felts.
 /// Big felts encode to 8 u32s each, small felts encode to 2 u32s each.
 fn total_u32s_from_felts(n_big_felts: usize, n_small_felts: usize) -> usize {
     let big_u32s = n_big_felts
-        .checked_mul(blake_cost::N_U32S_BIG_FELT)
+        .checked_mul(blake_encoding::N_U32S_BIG_FELT)
         .expect("Overflow computing big felts u32s");
     let small_u32s = n_small_felts
-        .checked_mul(blake_cost::N_U32S_SMALL_FELT)
+        .checked_mul(blake_encoding::N_U32S_SMALL_FELT)
         .expect("Overflow computing small felts u32s");
     big_u32s.checked_add(small_u32s).expect("Overflow computing total u32s")
 }
 
 fn base_steps_for_blake_hash(n_u32s: usize) -> usize {
-    let rem_u32s = n_u32s % blake_cost::N_U32S_MESSAGE;
+    let rem_u32s = n_u32s % blake_encoding::N_U32S_MESSAGE;
     if rem_u32s == 0 {
-        blake_cost::BASE_STEPS_FULL_MSG
+        blake_estimation::BASE_STEPS_FULL_MSG
     } else {
         // This computation is based on running blake2s with different inputs.
         // Note: all inputs expand to an even number of u32s --> `rem_u32s` is always even.
-        blake_cost::BASE_STEPS_PARTIAL_MSG + (rem_u32s / 2) * blake_cost::STEPS_PER_2_U32_REMINDER
+        blake_estimation::BASE_STEPS_PARTIAL_MSG
+            + (rem_u32s / 2) * blake_estimation::STEPS_PER_2_U32_REMINDER
     }
 }
 
 fn felts_steps(n_big_felts: usize, n_small_felts: usize) -> usize {
     let big_steps = n_big_felts
-        .checked_mul(blake_cost::STEPS_BIG_FELT)
+        .checked_mul(blake_estimation::STEPS_BIG_FELT)
         .expect("Overflow computing big felt steps");
     let small_steps = n_small_felts
-        .checked_mul(blake_cost::STEPS_SMALL_FELT)
+        .checked_mul(blake_estimation::STEPS_SMALL_FELT)
         .expect("Overflow computing small felt steps");
     big_steps.checked_add(small_steps).expect("Overflow computing total felt steps")
 }
@@ -436,7 +449,7 @@ fn compute_blake_hash_steps(n_big_felts: usize, n_small_felts: usize) -> usize {
 fn count_blake_opcode(n_big_felts: usize, n_small_felts: usize) -> usize {
     // Count the total number of u32s to be hashed.
     let total_u32s = total_u32s_from_felts(n_big_felts, n_small_felts);
-    total_u32s.div_ceil(blake_cost::N_U32S_MESSAGE)
+    total_u32s.div_ceil(blake_encoding::N_U32S_MESSAGE)
 }
 
 /// Estimates the VM resources for `encode_felt252_data_and_calc_blake_hash` in the Starknet OS.
@@ -464,7 +477,7 @@ where
 
     let blake_op_count = count_blake_opcode(n_big_felts, n_small_felts);
     let blake_op_gas = blake_op_count
-        .checked_mul(blake_cost::BLAKE_OPCODE_GAS)
+        .checked_mul(blake_estimation::BLAKE_OPCODE_GAS)
         .map(u64_from_usize)
         .map(GasAmount)
         .expect("Overflow computing Blake opcode gas.");

crates/blockifier/src/execution/execution_utils_test.rs

@@ -5,11 +5,8 @@ use starknet_types_core::felt::Felt;
 
 use crate::blockifier_versioned_constants::VersionedConstants;
 use crate::bouncer::vm_resources_to_sierra_gas;
-use crate::execution::execution_utils::blake_cost::{
-    BASE_STEPS_FULL_MSG,
-    N_U32S_BIG_FELT,
-    N_U32S_SMALL_FELT,
-};
+use crate::execution::execution_utils::blake_encoding::{N_U32S_BIG_FELT, N_U32S_SMALL_FELT};
+use crate::execution::execution_utils::blake_estimation::BASE_STEPS_FULL_MSG;
 use crate::execution::execution_utils::{
     compute_blake_hash_steps,
     cost_of_encode_felt252_data_and_calc_blake_hash,
@@ -57,7 +54,8 @@ fn test_zero_inputs() {
 // TODO(AvivG): Add tests for:
 // - `compute_blake_hash_steps` simple cases (felts input).
 // - `count_blake_opcode` simple cases (felts input).
-// - `cost_of_encode_felt252_data_and_calc_blake_hash` simple cases (felts input).
+// - `cost_of_encode_felt252_data_and_calc_blake_hash` simple cases (felts input) (including partial
+//   remainder).
 // - `cost_of_encode_felt252_data_and_calc_blake_hash` compare against actual execution resources
 //   from running a Cairo entry point (computing blake).
 // - base steps costs - compare against actual execution resources by running on an empty input.