⚡️ Speed up method BCDataStream.read_int16 by 36%

[codeflash-ai]

📄 36% (0.36x) speedup for BCDataStream.read_int16 in electrum/transaction.py

⏱️ Runtime : 1.61 milliseconds → 1.18 milliseconds (best of 12 runs)

📝 Explanation and details

The optimized code achieves a 36% speedup by eliminating function call overhead and replacing dynamic calculations with hardcoded constants.

Key optimizations applied:

1. Inlined function call: The original code delegated to _read_num('<h'), requiring a function call with parameter passing. The optimized version inlines this logic directly in read_int16(), eliminating the call overhead entirely.

2. Hardcoded size calculation: Instead of calling struct.calcsize('<h') every time (which always returns 2 for a signed 16-bit integer), the optimized version uses the literal 2. This removes a function call and string parsing overhead.

Performance impact analysis:

From the line profiler results, the original version spent significant time in the function call mechanism itself - the read_int16 method took 15.6ms total time just to call _read_num. The optimized version reduces this to 4.77ms by handling everything inline.

The struct.unpack_from operation time remains similar (1.77ms vs 1.88ms), but eliminating the struct.calcsize call saves substantial overhead, especially in the cursor increment operation (1.52ms vs 1.27ms).

Test case performance:

The optimization shows consistent 35-57% improvements across all test scenarios:

• Simple reads: 35-53% faster
• Sequential reads: 24-57% faster
• Large-scale operations (500-1000 items): 35-36% faster

This optimization is particularly effective for Bitcoin transaction parsing workloads where read_int16 is called frequently during deserialization of binary data streams, making the function call elimination and constant folding highly beneficial.

✅ Correctness verification report:

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


# Exception class used in BCDataStream
class SerializationError(Exception):
    pass

# ------------------------- UNIT TESTS -------------------------

# --- Basic Test Cases ---

def test_read_int16_positive_number():
    # Test reading a simple positive int16 value
    stream = BCDataStream()
    stream.input = b'\x01\x00'  # 1 in little-endian
    stream.read_cursor = 0
    codeflash_output = stream.read_int16() # 2.63μs -> 1.86μs (41.4% faster)

def test_read_int16_negative_number():
    # Test reading a simple negative int16 value
    stream = BCDataStream()
    stream.input = b'\xff\xff'  # -1 in little-endian
    stream.read_cursor = 0
    codeflash_output = stream.read_int16() # 1.89μs -> 1.31μs (43.5% faster)

def test_read_int16_zero():
    # Test reading zero
    stream = BCDataStream()
    stream.input = b'\x00\x00'
    stream.read_cursor = 0
    codeflash_output = stream.read_int16() # 1.65μs -> 1.18μs (39.6% faster)

def test_read_int16_multiple_reads():
    # Test reading multiple int16 values sequentially
    stream = BCDataStream()
    stream.input = b'\x01\x00\xff\xff\x00\x00'
    stream.read_cursor = 0
    codeflash_output = stream.read_int16() # 1.58μs -> 1.17μs (35.6% faster)
    codeflash_output = stream.read_int16() # 820ns -> 551ns (48.8% faster)
    codeflash_output = stream.read_int16() # 463ns -> 371ns (24.8% faster)

# --- Edge Test Cases ---

def test_read_int16_minimum_value():
    # Test reading minimum int16 value (-32768)
    stream = BCDataStream()
    stream.input = b'\x00\x80'  # -32768 in little-endian
    stream.read_cursor = 0
    codeflash_output = stream.read_int16() # 1.51μs -> 989ns (52.9% faster)

def test_read_int16_maximum_value():
    # Test reading maximum int16 value (32767)
    stream = BCDataStream()
    stream.input = b'\xff\x7f'  # 32767 in little-endian
    stream.read_cursor = 0
    codeflash_output = stream.read_int16() # 1.59μs -> 1.04μs (53.6% faster)

def test_read_int16_incomplete_data():
    # Test reading when not enough bytes are available
    stream = BCDataStream()
    stream.input = b'\x01'  # only 1 byte, but need 2
    stream.read_cursor = 0
    with pytest.raises(SerializationError):
        stream.read_int16()

def test_read_int16_empty_input():
    # Test reading from empty input
    stream = BCDataStream()
    stream.input = b''
    stream.read_cursor = 0
    with pytest.raises(SerializationError):
        stream.read_int16()

def test_read_int16_cursor_out_of_bounds():
    # Test reading when cursor is set past end of input
    stream = BCDataStream()
    stream.input = b'\x01\x00'
    stream.read_cursor = 2  # past end
    with pytest.raises(SerializationError):
        stream.read_int16()

def test_read_int16_none_input():
    # Test reading when input is None
    stream = BCDataStream()
    stream.input = None
    stream.read_cursor = 0
    with pytest.raises(SerializationError):
        stream.read_int16()

def test_read_int16_non_bytes_input():
    # Test reading when input is not bytes-like
    stream = BCDataStream()
    stream.input = "not bytes"  # string, not bytes
    stream.read_cursor = 0
    with pytest.raises(SerializationError):
        stream.read_int16()

def test_read_int16_cursor_at_last_byte():
    # Test reading when cursor is at the last byte (should fail)
    stream = BCDataStream()
    stream.input = b'\x01\x00'
    stream.read_cursor = 1
    with pytest.raises(SerializationError):
        stream.read_int16()

def test_read_int16_cursor_negative():
    # Test reading when cursor is negative (should fail)
    stream = BCDataStream()
    stream.input = b'\x01\x00'
    stream.read_cursor = -1
    with pytest.raises(SerializationError):
        stream.read_int16()

# --- Large Scale Test Cases ---

def test_read_int16_large_sequence():
    # Test reading a large sequence of int16 values
    N = 500
    # Create N int16 values: 0, 1, 2, ..., N-1
    values = list(range(N))
    # Pack them into bytes
    stream = BCDataStream()
    stream.input = b''.join(struct.pack('<h', v) for v in values)
    stream.read_cursor = 0
    # Read back and check all values
    for expected in values:
        codeflash_output = stream.read_int16() # 219μs -> 159μs (37.1% faster)

def test_read_int16_large_negative_sequence():
    # Test reading a large sequence of negative int16 values
    N = 500
    values = list(range(-N, 0))
    stream = BCDataStream()
    stream.input = b''.join(struct.pack('<h', v) for v in values)
    stream.read_cursor = 0
    for expected in values:
        codeflash_output = stream.read_int16() # 222μs -> 164μs (35.2% faster)

def test_read_int16_large_mixed_sequence():
    # Test reading a large mixed sequence of positive and negative int16 values
    N = 500
    values = [i if i % 2 == 0 else -i for i in range(N)]
    stream = BCDataStream()
    stream.input = b''.join(struct.pack('<h', v) for v in values)
    stream.read_cursor = 0
    for expected in values:
        codeflash_output = stream.read_int16() # 226μs -> 166μs (35.9% faster)

def test_read_int16_large_scale_performance():
    # Test that reading 1000 int16 values works and is reasonably fast
    N = 1000
    values = [32767 if i % 2 == 0 else -32768 for i in range(N)]
    stream = BCDataStream()
    stream.input = b''.join(struct.pack('<h', v) for v in values)
    stream.read_cursor = 0
    for expected in values:
        codeflash_output = stream.read_int16() # 449μs -> 330μs (35.8% faster)

# --- Additional Edge Cases ---

def test_read_int16_cursor_exact_end():
    # Test reading at the exact end (should fail)
    stream = BCDataStream()
    stream.input = b'\x01\x00'
    stream.read_cursor = 2
    with pytest.raises(SerializationError):
        stream.read_int16()

def test_read_int16_cursor_far_out_of_bounds():
    # Test reading with cursor way past end
    stream = BCDataStream()
    stream.input = b'\x01\x00'
    stream.read_cursor = 100
    with pytest.raises(SerializationError):
        stream.read_int16()

def test_read_int16_cursor_just_enough_bytes():
    # Test reading when there are just enough bytes left
    stream = BCDataStream()
    stream.input = b'\x01\x00\x02\x00'
    stream.read_cursor = 2
    codeflash_output = stream.read_int16() # 2.63μs -> 1.74μs (51.6% faster)

def test_read_int16_after_large_scale_reads():
    # Test reading after large scale reads, should fail if no bytes left
    N = 100
    stream = BCDataStream()
    stream.input = b''.join(struct.pack('<h', i) for i in range(N))
    stream.read_cursor = N * 2
    with pytest.raises(SerializationError):
        stream.read_int16()
# 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_int16_positive_value():
    # Test reading a simple positive int16 value (e.g., 0x1234 = 4660)
    stream = BCDataStream()
    stream.input = b'\x34\x12'  # little-endian encoding of 0x1234
    stream.read_cursor = 0
    codeflash_output = stream.read_int16() # 2.65μs -> 1.76μs (50.9% faster)

def test_read_int16_negative_value():
    # Test reading a negative int16 value (e.g., -2)
    stream = BCDataStream()
    stream.input = struct.pack('<h', -2)
    stream.read_cursor = 0
    codeflash_output = stream.read_int16() # 1.71μs -> 1.20μs (42.6% faster)

def test_read_int16_zero():
    # Test reading zero
    stream = BCDataStream()
    stream.input = b'\x00\x00'
    stream.read_cursor = 0
    codeflash_output = stream.read_int16() # 1.71μs -> 1.24μs (38.1% faster)

def test_read_int16_multiple_reads():
    # Test reading two values in sequence
    stream = BCDataStream()
    stream.input = struct.pack('<hh', 1, -1)
    stream.read_cursor = 0
    codeflash_output = stream.read_int16() # 1.54μs -> 1.13μs (36.2% faster)
    codeflash_output = stream.read_int16() # 800ns -> 509ns (57.2% faster)

# ----------- EDGE TEST CASES -----------

def test_read_int16_minimum_value():
    # Test reading the minimum int16 value (-32768)
    stream = BCDataStream()
    stream.input = struct.pack('<h', -32768)
    stream.read_cursor = 0
    codeflash_output = stream.read_int16() # 1.53μs -> 1.05μs (46.2% faster)

def test_read_int16_maximum_value():
    # Test reading the maximum int16 value (32767)
    stream = BCDataStream()
    stream.input = struct.pack('<h', 32767)
    stream.read_cursor = 0
    codeflash_output = stream.read_int16() # 1.50μs -> 1.02μs (47.5% faster)

def test_read_int16_cursor_not_at_start():
    # Test reading with cursor offset (should skip first value)
    stream = BCDataStream()
    stream.input = struct.pack('<hh', 123, 456)
    stream.read_cursor = 2  # skip first int16
    codeflash_output = stream.read_int16() # 1.48μs -> 1.02μs (44.9% faster)

def test_read_int16_insufficient_bytes():
    # Test reading when there are not enough bytes left (should raise SerializationError)
    stream = BCDataStream()
    stream.input = b'\x01'  # only 1 byte, need 2
    stream.read_cursor = 0
    with pytest.raises(SerializationError):
        stream.read_int16()

def test_read_int16_exact_end_of_input():
    # Test reading exactly at the end of the input (should succeed)
    stream = BCDataStream()
    stream.input = struct.pack('<h', 999)
    stream.read_cursor = 0
    codeflash_output = stream.read_int16()
    # Now cursor is at the end, further read should fail
    with pytest.raises(SerializationError):
        stream.read_int16()

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

def test_read_int16_cursor_beyond_input():
    # Test reading with cursor already beyond input (should raise SerializationError)
    stream = BCDataStream()
    stream.input = struct.pack('<h', 5)
    stream.read_cursor = 10  # beyond input length
    with pytest.raises(SerializationError):
        stream.read_int16()

# ----------- LARGE SCALE TEST CASES -----------

def test_read_int16_large_batch():
    # Test reading a large batch of int16 values
    NUM_VALUES = 500  # keep under 1000 as per instructions
    values = [i - 250 for i in range(NUM_VALUES)]  # range includes negatives and positives
    stream = BCDataStream()
    stream.input = struct.pack('<' + 'h'*NUM_VALUES, *values)
    stream.read_cursor = 0
    for expected in values:
        codeflash_output = stream.read_int16()
    # After all reads, further read should fail
    with pytest.raises(SerializationError):
        stream.read_int16()

def test_read_int16_performance_large():
    # Test that reading a large number of int16s is efficient and correct
    NUM_VALUES = 999  # just below 1000
    values = [32767 if i % 2 == 0 else -32768 for i in range(NUM_VALUES)]
    stream = BCDataStream()
    stream.input = struct.pack('<' + 'h'*NUM_VALUES, *values)
    stream.read_cursor = 0
    for i, expected in enumerate(values):
        codeflash_output = stream.read_int16() # 445μs -> 327μs (36.3% faster)

def test_read_int16_partial_large_batch():
    # Test reading part of a large batch, then stopping
    NUM_VALUES = 100
    values = [i for i in range(NUM_VALUES)]
    stream = BCDataStream()
    stream.input = struct.pack('<' + 'h'*NUM_VALUES, *values)
    stream.read_cursor = 0
    # Read only first 10
    for i in range(10):
        codeflash_output = stream.read_int16() # 6.26μs -> 4.28μs (46.3% faster)

# ----------- ADDITIONAL EDGE CASES -----------

def test_read_int16_non_byte_input():
    # Test with input as a bytearray instead of bytes
    stream = BCDataStream()
    stream.input = bytearray(struct.pack('<h', 12345))
    stream.read_cursor = 0
    codeflash_output = stream.read_int16() # 1.68μs -> 1.19μs (41.3% faster)

def test_read_int16_cursor_at_end():
    # Test reading with cursor exactly at end (should fail)
    stream = BCDataStream()
    stream.input = struct.pack('<h', 1)
    stream.read_cursor = 2
    with pytest.raises(SerializationError):
        stream.read_int16()

def test_read_int16_multiple_types_of_input():
    # Test with various types of input (bytes, bytearray)
    for val in [0, -1, 32767, -32768]:
        for typ in [bytes, bytearray]:
            stream = BCDataStream()
            stream.input = typ(struct.pack('<h', val))
            stream.read_cursor = 0
            codeflash_output = stream.read_int16()

def test_read_int16_after_error():
    # After a failed read, the cursor should not have advanced
    stream = BCDataStream()
    stream.input = b'\x01'  # only 1 byte
    stream.read_cursor = 0
    try:
        stream.read_int16()
    except SerializationError:
        pass
# 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_int16():
    with pytest.raises(SerializationError, match="a\\ bytes\\-like\\ object\\ is\\ required,\\ not\\ 'NoneType'"):
        BCDataStream.read_int16(BCDataStream())

To edit these changes git checkout codeflash/optimize-BCDataStream.read_int16-mhokk9bu and push.