Updated Split concept to allow more efficient Byte reads. (#8555)

Author: orizi

corelib/src/byte_array.cairo

@@ -125,50 +125,6 @@ pub(crate) impl U128IntoBytes31 of Into<u128, bytes31> {
     }
 }
 
-/// Splits a `bytes31` into two `bytes31`s at the given index (LSB's index is 0).
-/// The input `bytes31` and the output `bytes31`s are represented using `felt252`s to improve
-/// performance.
-///
-/// Note: this function assumes that:
-/// 1. `word` is validly convertible to a `bytes31` which has no more than `len` bytes of data.
-/// 2. `index <= len`.
-/// 3. `len <= BYTES_IN_BYTES31`.
-/// If these assumptions are not met, it can corrupt the `bytes31`. Thus, this should be a
-/// private function. We could add masking/assertions but it would be more expensive.
-pub(crate) fn split_bytes31(word: felt252, len: usize, index: usize) -> (felt252, felt252) {
-    if index == 0 {
-        return (0, word);
-    }
-    if index == len {
-        return (word, 0);
-    }
-
-    let u256 { low, high } = word.into();
-
-    if index == BYTES_IN_U128 {
-        return (low.into(), high.into());
-    }
-
-    if len <= BYTES_IN_U128 {
-        let result = split_u128(low, index);
-        return (result.low.into(), result.high.into());
-    }
-
-    // len > BYTES_IN_U128
-    if index < BYTES_IN_U128 {
-        let low_result = split_u128(low, index);
-        let right = high.into() * one_shift_left_bytes_u128(BYTES_IN_U128 - index).into()
-            + low_result.high.into();
-        return (low_result.low.into(), right);
-    }
-
-    // len > BYTES_IN_U128 && index > BYTES_IN_U128
-
-    let high_result = split_u128(high, index - BYTES_IN_U128);
-    let left = high_result.low.into() * POW_2_128 + low.into();
-    return (left, high_result.high.into());
-}
-
 /// Returns `1 << (8 * n_bytes)` as `u128`, where `n_bytes` must be < `BYTES_IN_U128`.
 ///
 /// Panics if `n_bytes >= BYTES_IN_U128`.

corelib/src/bytes_31.cairo

@@ -1,4 +1,5 @@
-use crate::bytes_31::{bytes31_const, split_bytes31};
+use crate::byte_array::split_bytes31_for_testing as split_bytes31;
+use crate::bytes_31::bytes31_const;
 
 const POW_2_248: felt252 = 0x100000000000000000000000000000000000000000000000000000000000000;
 
@@ -137,32 +138,32 @@ fn test_u128_into_bytes31() {
 
 #[test]
 fn test_split_bytes31() {
-    let (left, right) = split_bytes31(0x1122, 2, 1);
+    let (left, right) = split_bytes31(0x1122, 1);
     assert(left == 0x22, 'bad split (2, 1) left');
     assert(right == 0x11, 'bad split (2, 1) right');
 
     let x = 0x112233445566778899aabbccddeeff00112233;
-    let (left, right) = split_bytes31(x, 19, 0);
+    let (left, right) = split_bytes31(x, 0);
     assert(left == 0, 'bad split (19, 0) left');
     assert(right == 0x112233445566778899aabbccddeeff00112233, 'bad split (19, 0) right');
 
-    let (left, right) = split_bytes31(x, 19, 1);
+    let (left, right) = split_bytes31(x, 1);
     assert(left == 0x33, 'bad split (19, 1) left');
     assert(right == 0x112233445566778899aabbccddeeff001122, 'bad split (19, 1) right');
 
-    let (left, right) = split_bytes31(x, 19, 15);
+    let (left, right) = split_bytes31(x, 15);
     assert(left == 0x5566778899aabbccddeeff00112233, 'bad split (19, 15) left');
     assert(right == 0x11223344, 'bad split (19, 15) right');
 
-    let (left, right) = split_bytes31(x, 19, 16);
+    let (left, right) = split_bytes31(x, 16);
     assert(left == 0x445566778899aabbccddeeff00112233, 'bad split (19, 16) left');
     assert(right == 0x112233, 'bad split (19, 16) right');
 
-    let (left, right) = split_bytes31(x, 19, 18);
+    let (left, right) = split_bytes31(x, 18);
     assert(left == 0x2233445566778899aabbccddeeff00112233, 'bad split (19, 18) left');
     assert(right == 0x11, 'bad split (19, 18) right');
 
-    let (left, right) = split_bytes31(x, 19, 19);
+    let (left, right) = split_bytes31(x, 19);
     assert(left == 0x112233445566778899aabbccddeeff00112233, 'bad split (19, 19) left');
     assert(right == 0, 'bad split (19, 19) right');
 }

corelib/src/test/bytes31_test.cairo

@@ -112,7 +112,7 @@ fn test_validate_gas_cost() {
     assert!(
         call_building_gas_usage == 3930
             && serialization_gas_usage == 27670
-            && entry_point_gas_usage == 100930,
+            && entry_point_gas_usage == 104530,
         "Unexpected gas_usage:
      call_building: `{call_building_gas_usage}`.
      serialization: `{serialization_gas_usage}`.