⚡️ Speed up method BCDataStream.read_uint64 by 10%

[codeflash-ai]

📄 10% (0.10x) speedup for BCDataStream.read_uint64 in electrum/transaction.py

⏱️ Runtime : 1.13 milliseconds → 1.03 milliseconds (best of 11 runs)

📝 Explanation and details

The optimized code achieves a 9% speedup through three key micro-optimizations that reduce function call overhead and attribute lookups in the hot path:

What specific optimizations were applied:

1. Inlined struct.calcsize('<Q'): The original code called struct.calcsize(format) on every invocation. Since read_uint64() always uses '<Q' format, the optimized version hardcodes size = 8 for this case, eliminating the function call overhead.

2. Reduced attribute lookups: The optimized version creates local variables cursor = self.read_cursor and inp = self.input to avoid repeated attribute access during the core unpacking operation.

3. Streamlined exception handling: The try/except block now only covers the struct.unpack_from call, while size calculation and variable assignments happen outside, reducing overhead in the exception-handling mechanism.

Why this leads to speedup:
In Python, function calls and attribute lookups have significant overhead. The struct.calcsize() call was happening on every read_uint64() invocation despite always returning 8. Local variable access is faster than attribute lookup, so caching self.read_cursor and self.input in locals provides measurable gains.

Performance characteristics based on test results:
The optimization shows consistent improvements across most test cases, with particularly strong gains (10-25% faster) for single value reads and large-scale sequential operations. The 1000-value sequential read test shows ~9.7% improvement, indicating the optimization scales well for bulk operations typical in Bitcoin transaction parsing.

Impact on workloads:
Since this is in electrum/transaction.py for Bitcoin transaction deserialization, this optimization will benefit any code that processes Bitcoin blocks or transactions, where read_uint64() is likely called frequently during parsing of binary transaction data.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 5179 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


# Define SerializationError for completeness
class SerializationError(Exception):
    pass

# unit tests

# 1. Basic Test Cases

def test_read_uint64_basic_zero():
    # Test reading zero
    stream = BCDataStream()
    stream.input = b'\x00\x00\x00\x00\x00\x00\x00\x00'
    codeflash_output = stream.read_uint64() # 2.31μs -> 2.32μs (0.344% slower)

def test_read_uint64_basic_one():
    # Test reading one
    stream = BCDataStream()
    stream.input = b'\x01\x00\x00\x00\x00\x00\x00\x00'
    codeflash_output = stream.read_uint64() # 1.50μs -> 1.33μs (13.2% faster)

def test_read_uint64_basic_max():
    # Test reading maximum uint64 value
    stream = BCDataStream()
    stream.input = b'\xff\xff\xff\xff\xff\xff\xff\xff'
    codeflash_output = stream.read_uint64() # 1.49μs -> 1.20μs (23.6% faster)

def test_read_uint64_basic_middle():
    # Test reading a middle value
    stream = BCDataStream()
    stream.input = b'\x78\x56\x34\x12\xef\xcd\xab\x90'  # 0x90abcdef12345678
    codeflash_output = stream.read_uint64() # 1.41μs -> 1.25μs (12.4% faster)

def test_read_uint64_basic_multiple_reads():
    # Test reading multiple uint64 values sequentially
    stream = BCDataStream()
    stream.input = (
        b'\x01\x00\x00\x00\x00\x00\x00\x00'
        b'\x02\x00\x00\x00\x00\x00\x00\x00'
    )
    codeflash_output = stream.read_uint64() # 1.36μs -> 1.20μs (13.5% faster)
    codeflash_output = stream.read_uint64() # 569ns -> 555ns (2.52% faster)

def test_read_uint64_basic_cursor_advance():
    # Test that read_cursor advances correctly
    stream = BCDataStream()
    stream.input = b'\x01\x00\x00\x00\x00\x00\x00\x00' + b'\x02\x00\x00\x00\x00\x00\x00\x00'
    codeflash_output = stream.read_uint64() # 1.23μs -> 1.12μs (9.17% faster)
    codeflash_output = stream.read_uint64() # 531ns -> 504ns (5.36% faster)

# 2. Edge Test Cases

def test_read_uint64_edge_short_input():
    # Test reading from input that's too short
    stream = BCDataStream()
    stream.input = b'\x01\x02\x03'  # only 3 bytes
    with pytest.raises(SerializationError):
        stream.read_uint64()

def test_read_uint64_edge_exact_boundary():
    # Test reading at the exact end of the buffer
    stream = BCDataStream()
    stream.input = b'\x01\x00\x00\x00\x00\x00\x00\x00'
    stream.read_cursor = 0
    codeflash_output = stream.read_uint64()
    # Now cursor is at the end, another read should fail
    with pytest.raises(SerializationError):
        stream.read_uint64()

def test_read_uint64_edge_cursor_in_middle():
    # Test with cursor set in the middle of the buffer
    stream = BCDataStream()
    stream.input = b'\x00\x00\x00\x00\x00\x00\x00\x00' + b'\x01\x00\x00\x00\x00\x00\x00\x00'
    stream.read_cursor = 8
    codeflash_output = stream.read_uint64() # 2.34μs -> 2.28μs (2.81% faster)

def test_read_uint64_edge_non_bytearray_input():
    # Test with input as a bytearray instead of bytes
    stream = BCDataStream()
    stream.input = bytearray(b'\x01\x00\x00\x00\x00\x00\x00\x00')
    codeflash_output = stream.read_uint64() # 1.62μs -> 1.49μs (9.23% faster)

def test_read_uint64_edge_invalid_format():
    # Test with an invalid format string (should raise SerializationError)
    stream = BCDataStream()
    stream.input = b'\x01\x00\x00\x00\x00\x00\x00\x00'
    # Patch _read_num to use an invalid format
    def bad_read_num(fmt):
        return struct.unpack_from('invalid', stream.input, stream.read_cursor)
    stream._read_num = bad_read_num
    with pytest.raises(struct.error):
        stream.read_uint64() # 2.41μs -> 2.36μs (2.38% faster)

def test_read_uint64_edge_read_cursor_out_of_bounds():
    # Test with read_cursor set beyond the input length
    stream = BCDataStream()
    stream.input = b'\x01\x00\x00\x00\x00\x00\x00\x00'
    stream.read_cursor = 100  # way beyond input
    with pytest.raises(SerializationError):
        stream.read_uint64()

def test_read_uint64_edge_empty_input():
    # Test with empty input
    stream = BCDataStream()
    stream.input = b''
    with pytest.raises(SerializationError):
        stream.read_uint64()

def test_read_uint64_edge_none_input():
    # Test with input set to None
    stream = BCDataStream()
    stream.input = None
    with pytest.raises(SerializationError):
        stream.read_uint64()

def test_read_uint64_edge_partial_read():
    # Test reading one value, then attempting to read past end
    stream = BCDataStream()
    stream.input = b'\x01\x00\x00\x00\x00\x00\x00\x00'
    codeflash_output = stream.read_uint64()
    with pytest.raises(SerializationError):
        stream.read_uint64()

# 3. Large Scale Test Cases

def test_read_uint64_large_scale_many_values():
    # Test reading 1000 sequential uint64 values
    stream = BCDataStream()
    values = [i for i in range(1000)]
    # Pack all values as little-endian uint64
    stream.input = b''.join(struct.pack('<Q', v) for v in values)
    for expected in values:
        codeflash_output = stream.read_uint64() # 361μs -> 331μs (9.28% faster)

def test_read_uint64_large_scale_max_values():
    # Test reading 1000 maximum uint64 values
    stream = BCDataStream()
    maxval = 0xFFFFFFFFFFFFFFFF
    stream.input = b''.join(struct.pack('<Q', maxval) for _ in range(1000))
    for _ in range(1000):
        codeflash_output = stream.read_uint64() # 361μs -> 329μs (9.72% faster)

def test_read_uint64_large_scale_cursor_final_position():
    # After reading 1000 values, cursor should be at the end
    stream = BCDataStream()
    stream.input = b''.join(struct.pack('<Q', i) for i in range(1000))
    for _ in range(1000):
        stream.read_uint64()
    # Next read should fail
    with pytest.raises(SerializationError):
        stream.read_uint64()

def test_read_uint64_large_scale_partial_last_value():
    # Test with last value truncated
    stream = BCDataStream()
    values = [i for i in range(999)]
    stream.input = b''.join(struct.pack('<Q', v) for v in values) + b'\x01\x02'
    for expected in values:
        codeflash_output = stream.read_uint64()
    # Now only 2 bytes left, should fail
    with pytest.raises(SerializationError):
        stream.read_uint64()
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

import struct

# imports
import pytest
from electrum.transaction import BCDataStream


# function to test
class SerializationError(Exception):
    pass

# unit tests

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

def test_read_uint64_zero():
    # Test reading 0 from bytes
    stream = BCDataStream()
    stream.input = b'\x00\x00\x00\x00\x00\x00\x00\x00'
    stream.read_cursor = 0
    codeflash_output = stream.read_uint64() # 2.30μs -> 2.27μs (1.41% faster)

def test_read_uint64_one():
    # Test reading 1 from bytes
    stream = BCDataStream()
    stream.input = b'\x01\x00\x00\x00\x00\x00\x00\x00'
    stream.read_cursor = 0
    codeflash_output = stream.read_uint64() # 1.69μs -> 1.34μs (25.8% faster)

def test_read_uint64_max():
    # Test reading maximum uint64 value
    stream = BCDataStream()
    stream.input = b'\xff\xff\xff\xff\xff\xff\xff\xff'
    stream.read_cursor = 0
    codeflash_output = stream.read_uint64() # 1.40μs -> 1.27μs (10.7% faster)

def test_read_uint64_arbitrary():
    # Test reading an arbitrary uint64 value
    value = 0x0123456789ABCDEF
    stream = BCDataStream()
    stream.input = value.to_bytes(8, 'little')
    stream.read_cursor = 0
    codeflash_output = stream.read_uint64() # 1.42μs -> 1.26μs (12.5% faster)

def test_read_uint64_cursor_advance():
    # Test that the read_cursor is advanced by 8 after reading
    stream = BCDataStream()
    stream.input = b'\x01\x00\x00\x00\x00\x00\x00\x00' + b'\x02\x00\x00\x00\x00\x00\x00\x00'
    stream.read_cursor = 0
    codeflash_output = stream.read_uint64(); first = codeflash_output # 1.39μs -> 1.19μs (17.3% faster)
    codeflash_output = stream.read_uint64(); second = codeflash_output # 548ns -> 566ns (3.18% slower)

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

def test_read_uint64_insufficient_bytes():
    # Test reading when there are not enough bytes (should raise SerializationError)
    stream = BCDataStream()
    stream.input = b'\x01\x02\x03'  # only 3 bytes
    stream.read_cursor = 0
    with pytest.raises(SerializationError):
        stream.read_uint64()

def test_read_uint64_exact_end_of_stream():
    # Test reading at the exact end of stream (should succeed)
    stream = BCDataStream()
    stream.input = b'\xAA\xBB\xCC\xDD\xEE\xFF\x11\x22'
    stream.read_cursor = 0
    codeflash_output = stream.read_uint64()
    # Now at end, further read should fail
    with pytest.raises(SerializationError):
        stream.read_uint64()

def test_read_uint64_nonzero_cursor():
    # Test reading with a nonzero read_cursor
    stream = BCDataStream()
    stream.input = b'\x00\x00\x00\x00' + b'\x01\x02\x03\x04\x05\x06\x07\x08' + b'\xFF'
    stream.read_cursor = 4
    codeflash_output = stream.read_uint64() # 2.40μs -> 2.29μs (5.03% faster)

def test_read_uint64_cursor_beyond_input():
    # Test reading with read_cursor beyond input (should raise SerializationError)
    stream = BCDataStream()
    stream.input = b'\x00\x00\x00\x00\x00\x00\x00\x00'
    stream.read_cursor = 10  # beyond input
    with pytest.raises(SerializationError):
        stream.read_uint64()

def test_read_uint64_cursor_at_last_valid_byte():
    # Test reading with cursor at last valid byte (should raise SerializationError)
    stream = BCDataStream()
    stream.input = b'\x00\x00\x00\x00\x00\x00\x00\x00'
    stream.read_cursor = 1  # only 7 bytes left, not enough for uint64
    with pytest.raises(SerializationError):
        stream.read_uint64()

def test_read_uint64_uninitialized_input():
    # Test reading when input is None (should raise SerializationError)
    stream = BCDataStream()
    stream.input = None
    stream.read_cursor = 0
    with pytest.raises(SerializationError):
        stream.read_uint64()

def test_read_uint64_empty_input():
    # Test reading when input is empty bytes (should raise SerializationError)
    stream = BCDataStream()
    stream.input = b''
    stream.read_cursor = 0
    with pytest.raises(SerializationError):
        stream.read_uint64()

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

def test_read_uint64_multiple_integers():
    # Test reading many uint64 values in sequence
    values = [i for i in range(100)]
    stream = BCDataStream()
    stream.input = b''.join(v.to_bytes(8, 'little') for v in values)
    stream.read_cursor = 0
    for expected in values:
        codeflash_output = stream.read_uint64()
    # Further read should fail
    with pytest.raises(SerializationError):
        stream.read_uint64()

def test_read_uint64_large_value_near_max():
    # Test reading a value close to uint64 max
    value = 0xFFFFFFFFFFFFFFFE
    stream = BCDataStream()
    stream.input = value.to_bytes(8, 'little')
    stream.read_cursor = 0
    codeflash_output = stream.read_uint64() # 2.39μs -> 2.29μs (4.28% faster)

def test_read_uint64_performance_reasonable():
    # Test performance and correctness for 1000 sequential reads
    values = [0xFFFFFFFFFFFFFFFF - i for i in range(1000)]
    stream = BCDataStream()
    stream.input = b''.join(v.to_bytes(8, 'little') for v in values)
    stream.read_cursor = 0
    for expected in values:
        codeflash_output = stream.read_uint64() # 367μs -> 334μs (9.70% faster)

def test_read_uint64_with_garbage_after():
    # Test that reading works and leaves cursor at correct position with extra data after
    stream = BCDataStream()
    stream.input = b'\x01\x02\x03\x04\x05\x06\x07\x08' + b'garbage'
    stream.read_cursor = 0
    codeflash_output = stream.read_uint64() # 1.93μs -> 1.72μs (11.8% faster)

# ---------------------------
# Additional Edge Cases
# ---------------------------

def test_read_uint64_input_as_bytearray():
    # Test reading when input is a bytearray instead of bytes
    value = 0xDEADBEEFDEADBEEF
    stream = BCDataStream()
    stream.input = bytearray(value.to_bytes(8, 'little'))
    stream.read_cursor = 0
    codeflash_output = stream.read_uint64() # 1.49μs -> 1.22μs (22.3% faster)

def test_read_uint64_multiple_reads_with_offset():
    # Test reading multiple uint64s with cursor offset
    stream = BCDataStream()
    stream.input = b'\x00'*4 + b'\x11\x22\x33\x44\x55\x66\x77\x88' + b'\x99\xAA\xBB\xCC\xDD\xEE\xFF\x00'
    stream.read_cursor = 4
    codeflash_output = stream.read_uint64() # 1.35μs -> 1.15μs (17.5% faster)
    codeflash_output = stream.read_uint64() # 551ns -> 561ns (1.78% slower)

def test_read_uint64_struct_error_bubbling():
    # Test that struct.error is wrapped as SerializationError
    stream = BCDataStream()
    stream.input = b'\x00\x01'
    stream.read_cursor = 0
    with pytest.raises(SerializationError) as excinfo:
        stream.read_uint64()
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

from electrum.transaction import BCDataStream
import pytest

def test_BCDataStream_read_uint64():
    with pytest.raises(SerializationError, match="a\\ bytes\\-like\\ object\\ is\\ required,\\ not\\ 'NoneType'"):
        BCDataStream.read_uint64(BCDataStream())

To edit these changes git checkout codeflash/optimize-BCDataStream.read_uint64-mhxpta7k and push.