⚡️ Speed up method BCDataStream.write_uint32 by 6%

[codeflash-ai]

📄 6% (0.06x) speedup for BCDataStream.write_uint32 in electrum/transaction.py

⏱️ Runtime : 2.61 milliseconds → 2.46 milliseconds (best of 177 runs)

📝 Explanation and details

The optimization eliminates an intermediate variable assignment in the _write_num method by directly embedding struct.pack(format, num) calls within the conditional branches.

Key changes:

• Removed the s: bytes = struct.pack(format, num) assignment and the inp = self.input local variable
• Changed from self.input = bytearray(s) to self.input = bytearray(struct.pack(format, num))
• Changed from inp.extend(s) to self.input.extend(struct.pack(format, num))

Why this is faster:

1. Reduced variable assignments: Eliminates the overhead of creating and storing intermediate variables (s and inp)
2. Fewer attribute lookups: The original code performed self.input lookup twice (once for inp assignment, once for the None check), while the optimized version accesses it directly in each branch
3. Reduced stack frame size: Fewer local variables means less memory allocation and cleanup overhead per function call

Performance impact:
The line profiler shows the optimization reduces _write_num execution time by ~35% (7.66ms → 4.94ms), contributing to the overall 5% speedup. The improvement is most pronounced in the common path where self.input is not None (line shows 65.5% of total time vs 29.4% in original).

Test case analysis:
The optimization performs consistently well across all test scenarios, with improvements ranging from 2-16% in individual calls. It's particularly effective for batch operations (6-7% improvement on 1000-value writes) and benefits both initial writes and subsequent extends to existing buffers.

Since this appears to be Bitcoin transaction serialization code, this optimization would benefit any workload involving frequent binary data encoding, which is common in cryptocurrency applications.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 6607 Passed
⏪ Replay Tests	🔘 None Found
🔎 Concolic Coverage Tests	🔘 None Found
📊 Tests Coverage	100.0%

🌀 Generated Regression Tests and Runtime

import struct

# imports
import pytest  # used for our unit tests
from electrum.transaction import BCDataStream

# unit tests

# ---- Basic Test Cases ----

def test_write_uint32_basic_values():
    # Test writing a typical uint32 value
    ds = BCDataStream()
    ds.write_uint32(1) # 1.91μs -> 1.75μs (9.02% faster)
    ds2 = BCDataStream()
    ds2.write_uint32(123456789) # 668ns -> 583ns (14.6% faster)

def test_write_uint32_multiple_writes():
    # Test writing multiple uint32 values in sequence
    ds = BCDataStream()
    ds.write_uint32(1) # 1.34μs -> 1.35μs (0.445% slower)
    ds.write_uint32(2) # 934ns -> 862ns (8.35% faster)
    ds.write_uint32(3) # 462ns -> 462ns (0.000% faster)
    expected = struct.pack('<I', 1) + struct.pack('<I', 2) + struct.pack('<I', 3)

def test_write_uint32_return_value():
    # The function should return None
    ds = BCDataStream()
    codeflash_output = ds.write_uint32(42); ret = codeflash_output # 1.31μs -> 1.32μs (0.758% slower)

# ---- Edge Test Cases ----

def test_write_uint32_zero():
    # Test writing the minimum uint32 value (0)
    ds = BCDataStream()
    ds.write_uint32(0) # 1.38μs -> 1.32μs (4.63% faster)

def test_write_uint32_max():
    # Test writing the maximum uint32 value (2**32 - 1)
    ds = BCDataStream()
    ds.write_uint32(0xFFFFFFFF) # 1.44μs -> 1.32μs (9.41% faster)

def test_write_uint32_overflow():
    # Writing a value > 2**32-1 should raise struct.error
    ds = BCDataStream()
    with pytest.raises(struct.error):
        ds.write_uint32(0x100000000) # 2.79μs -> 2.86μs (2.38% slower)

def test_write_uint32_negative():
    # Writing a negative value should raise struct.error
    ds = BCDataStream()
    with pytest.raises(struct.error):
        ds.write_uint32(-1) # 2.03μs -> 2.00μs (1.30% faster)

def test_write_uint32_non_integer():
    # Writing a non-integer value should raise struct.error or TypeError
    ds = BCDataStream()
    with pytest.raises((struct.error, TypeError)):
        ds.write_uint32("not an int") # 1.65μs -> 1.69μs (2.78% slower)
    with pytest.raises((struct.error, TypeError)):
        ds.write_uint32(3.14) # 698ns -> 721ns (3.19% slower)
    with pytest.raises((struct.error, TypeError)):
        ds.write_uint32(None) # 702ns -> 736ns (4.62% slower)

def test_write_uint32_input_already_initialized():
    # If input is already a bytearray, it should extend, not overwrite
    ds = BCDataStream()
    ds.input = bytearray(b'\xAA\xBB')
    ds.write_uint32(5) # 1.70μs -> 1.62μs (4.87% faster)

def test_write_uint32_input_is_empty_bytearray():
    # If input is an empty bytearray, it should extend correctly
    ds = BCDataStream()
    ds.input = bytearray()
    ds.write_uint32(7) # 1.57μs -> 1.43μs (10.2% faster)

# ---- Large Scale Test Cases ----

def test_write_uint32_large_batch():
    # Test writing a large batch of uint32s (up to 1000 values)
    ds = BCDataStream()
    values = list(range(1000))
    for v in values:
        ds.write_uint32(v) # 392μs -> 374μs (4.82% faster)
    expected = b''.join([struct.pack('<I', v) for v in values])

def test_write_uint32_large_random_values():
    # Test writing 1000 random uint32 values
    import random
    ds = BCDataStream()
    random.seed(0)
    values = [random.randint(0, 0xFFFFFFFF) for _ in range(1000)]
    for v in values:
        ds.write_uint32(v) # 395μs -> 375μs (5.38% faster)
    expected = b''.join([struct.pack('<I', v) for v in values])

def test_write_uint32_performance():
    # This test is not a strict performance benchmark, but ensures that writing 1000 values completes quickly
    import time
    ds = BCDataStream()
    start = time.time()
    for i in range(1000):
        ds.write_uint32(i) # 389μs -> 367μs (5.83% faster)
    elapsed = time.time() - start

# ---- Additional Edge and Robustness Cases ----

def test_write_uint32_input_is_none_after_multiple_writes():
    # After first write, input should not be None
    ds = BCDataStream()
    ds.write_uint32(1) # 2.21μs -> 2.12μs (4.14% faster)

def test_write_uint32_input_type_is_bytearray():
    # After write, input should always be a bytearray
    ds = BCDataStream()
    ds.write_uint32(1) # 1.52μs -> 1.41μs (7.74% faster)
    ds.write_uint32(2) # 878ns -> 824ns (6.55% faster)

def test_write_uint32_mutation_safety():
    # Ensure that extending input does not mutate previous objects
    ds = BCDataStream()
    ds.write_uint32(1) # 1.39μs -> 1.37μs (0.873% faster)
    before = ds.input[:]
    ds.write_uint32(2) # 836ns -> 798ns (4.76% faster)

def test_write_uint32_struct_format():
    # Ensure that the struct format is little-endian and 4 bytes
    ds = BCDataStream()
    ds.write_uint32(0x01020304) # 1.35μs -> 1.32μs (2.43% faster)

def test_write_uint32_multiple_streams_independent():
    # Ensure that multiple BCDataStream objects maintain independent input
    ds1 = BCDataStream()
    ds2 = BCDataStream()
    ds1.write_uint32(1) # 1.43μs -> 1.23μs (16.9% faster)
    ds2.write_uint32(2) # 611ns -> 580ns (5.34% faster)
    ds1.write_uint32(3) # 752ns -> 778ns (3.34% slower)
    ds2.write_uint32(4) # 455ns -> 442ns (2.94% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
import struct  # used for packing/unpacking binary data

# imports
import pytest  # used for our unit tests
from electrum.transaction import BCDataStream

# unit tests

# --- Basic Test Cases ---
def test_write_uint32_basic_zero():
    """Test writing the smallest uint32 value (0)"""
    stream = BCDataStream()
    stream.write_uint32(0) # 1.43μs -> 1.32μs (8.55% faster)

def test_write_uint32_basic_small():
    """Test writing a small uint32 value"""
    stream = BCDataStream()
    stream.write_uint32(42) # 1.37μs -> 1.19μs (15.2% faster)

def test_write_uint32_basic_typical():
    """Test writing a typical uint32 value"""
    stream = BCDataStream()
    stream.write_uint32(123456789) # 1.44μs -> 1.29μs (12.0% faster)

def test_write_uint32_basic_multiple():
    """Test writing multiple uint32 values in sequence"""
    stream = BCDataStream()
    stream.write_uint32(1) # 1.43μs -> 1.33μs (7.43% faster)
    stream.write_uint32(2) # 926ns -> 941ns (1.59% slower)
    stream.write_uint32(3) # 477ns -> 452ns (5.53% faster)
    expected = struct.pack('<I', 1) + struct.pack('<I', 2) + struct.pack('<I', 3)

# --- Edge Test Cases ---
def test_write_uint32_edge_max():
    """Test writing the largest uint32 value (2**32 - 1)"""
    stream = BCDataStream()
    stream.write_uint32(0xFFFFFFFF) # 1.49μs -> 1.33μs (11.9% faster)

def test_write_uint32_edge_near_max():
    """Test writing a value just below the max (2**32 - 2)"""
    stream = BCDataStream()
    stream.write_uint32(0xFFFFFFFE) # 1.39μs -> 1.33μs (4.36% faster)

def test_write_uint32_edge_min():
    """Test writing the minimum uint32 value (0) again for coverage"""
    stream = BCDataStream()
    stream.write_uint32(0) # 1.44μs -> 1.32μs (9.17% faster)

def test_write_uint32_edge_negative():
    """Test writing a negative value (should raise struct.error)"""
    stream = BCDataStream()
    with pytest.raises(struct.error):
        stream.write_uint32(-1) # 2.00μs -> 2.03μs (1.68% slower)

def test_write_uint32_edge_overflow():
    """Test writing a value above uint32 max (should raise struct.error)"""
    stream = BCDataStream()
    with pytest.raises(struct.error):
        stream.write_uint32(0x100000000) # 2.74μs -> 2.82μs (2.87% slower)

def test_write_uint32_edge_non_integer():
    """Test writing a non-integer value (should raise struct.error)"""
    stream = BCDataStream()
    with pytest.raises(struct.error):
        stream.write_uint32(3.14) # 1.64μs -> 1.66μs (0.906% slower)

def test_write_uint32_edge_string_input():
    """Test writing a string value (should raise struct.error)"""
    stream = BCDataStream()
    with pytest.raises(struct.error):
        stream.write_uint32("123") # 1.48μs -> 1.53μs (3.34% slower)

def test_write_uint32_edge_none_input():
    """Test writing None (should raise struct.error)"""
    stream = BCDataStream()
    with pytest.raises(struct.error):
        stream.write_uint32(None) # 1.42μs -> 1.60μs (11.1% slower)

def test_write_uint32_edge_bool_true():
    """Test writing True (should be treated as 1)"""
    stream = BCDataStream()
    stream.write_uint32(True) # 1.79μs -> 1.72μs (4.25% faster)

def test_write_uint32_edge_bool_false():
    """Test writing False (should be treated as 0)"""
    stream = BCDataStream()
    stream.write_uint32(False) # 1.57μs -> 1.52μs (3.36% faster)

def test_write_uint32_edge_existing_input():
    """Test writing when input is already set"""
    stream = BCDataStream()
    stream.input = bytearray(b"abcd")
    stream.write_uint32(0x11223344) # 1.59μs -> 1.55μs (2.84% faster)
    expected = b"abcd" + struct.pack('<I', 0x11223344)

# --- Large Scale Test Cases ---
def test_write_uint32_large_scale_1000():
    """Test writing 1000 sequential uint32 values"""
    stream = BCDataStream()
    for i in range(1000):
        stream.write_uint32(i) # 383μs -> 359μs (6.83% faster)

def test_write_uint32_large_scale_pattern():
    """Test writing a repeated pattern of uint32 values"""
    stream = BCDataStream()
    pattern = [0xDEADBEEF, 0xFEEDFACE, 0xCAFEBABE]
    for i in range(333):  # 333 * 3 = 999 values
        for val in pattern:
            stream.write_uint32(val)
    # Check a random position in the stream
    idx = 100 * 3  # 100th pattern start

def test_write_uint32_large_scale_extend_existing():
    """Test writing a large number of values with pre-existing input"""
    stream = BCDataStream()
    stream.input = bytearray(b"start")
    for i in range(500):
        stream.write_uint32(i) # 195μs -> 182μs (7.01% faster)

def test_write_uint32_large_scale_all_max():
    """Test writing 1000 times the max uint32 value"""
    stream = BCDataStream()
    for _ in range(1000):
        stream.write_uint32(0xFFFFFFFF) # 388μs -> 364μs (6.72% faster)
    # All bytes should be the same as struct.pack('<I', 0xFFFFFFFF)
    expected = struct.pack('<I', 0xFFFFFFFF) * 1000

# --- Determinism and Robustness ---
def test_write_uint32_deterministic_output():
    """Test that writing the same sequence produces the same output every time"""
    stream1 = BCDataStream()
    stream2 = BCDataStream()
    values = [0, 1, 123, 0xFFFFFFFF, 42]
    for v in values:
        stream1.write_uint32(v) # 4.43μs -> 4.21μs (5.25% faster)
        stream2.write_uint32(v) # 2.27μs -> 2.17μs (4.71% faster)

def test_write_uint32_no_return():
    """Test that write_uint32 returns None (side effect only)"""
    stream = BCDataStream()
    codeflash_output = stream.write_uint32(123); result = codeflash_output # 1.37μs -> 1.33μs (2.85% faster)

def test_write_uint32_input_type():
    """Test that input is a bytearray after writing"""
    stream = BCDataStream()
    stream.write_uint32(1) # 1.42μs -> 1.25μs (13.2% faster)

def test_write_uint32_input_is_not_replaced():
    """Test that input is not replaced when already set"""
    stream = BCDataStream()
    stream.input = bytearray(b"abc")
    before = stream.input
    stream.write_uint32(5) # 1.44μs -> 1.34μs (6.91% faster)

# --- Miscellaneous ---
def test_write_uint32_struct_packing_consistency():
    """Test that struct.pack and BCDataStream produce identical results for a range of values"""
    stream = BCDataStream()
    for v in [0, 1, 255, 256, 65535, 65536, 2**31, 2**32 - 1]:
        stream.write_uint32(v) # 5.01μs -> 4.77μs (4.92% faster)
    expected = b''.join([struct.pack('<I', v) for v in [0, 1, 255, 256, 65535, 65536, 2**31, 2**32 - 1]])
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

To edit these changes git checkout codeflash/optimize-BCDataStream.write_uint32-mholkas9 and push.