⚡️ Speed up method BCDataStream.write_int64 by 17%

[codeflash-ai]

📄 17% (0.17x) speedup for BCDataStream.write_int64 in electrum/transaction.py

⏱️ Runtime : 1.92 milliseconds → 1.65 milliseconds (best of 227 runs)

📝 Explanation and details

The optimization achieves a 16% speedup by eliminating a function call overhead in the hot path. The key change is inlining the _write_num logic directly into write_int64 instead of delegating through a method call.

What changed:

• The original write_int64 called self._write_num('<q', val), adding function call overhead
• The optimized version directly implements the struct packing and buffer extension logic inline

Why this is faster:

• Eliminates function call overhead: Each call to write_int64 no longer requires setting up a new stack frame for _write_num
• Reduces attribute lookups: The profiler shows write_int64 was taking 20.6ms total time, with the function call consuming significant overhead
• Maintains efficient buffer operations: Still uses bytearray.extend() for optimal memory management

Performance impact by test case:

• Best gains on simple operations: Zero writes (16.5% faster), boolean conversions (19-28% faster), and error cases (up to 28.6% faster) benefit most from eliminating call overhead
• Consistent improvements in batch operations: Large-scale tests show 16-19% speedups, indicating the optimization scales well
• Minimal impact on complex scenarios: Even edge cases and error handling maintain 5-18% improvements

This optimization is particularly valuable because write_int64 appears to be a frequently called method in Bitcoin transaction serialization, where every microsecond saved in the hot path translates to meaningful performance gains during transaction processing.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import struct

# imports
import pytest
from electrum.transaction import BCDataStream

# unit tests

# 1. Basic Test Cases

def test_write_int64_basic_positive():
    """Test writing a basic positive int64 value."""
    ds = BCDataStream()
    ds.write_int64(123456789) # 1.41μs -> 1.30μs (8.56% faster)

def test_write_int64_basic_negative():
    """Test writing a basic negative int64 value."""
    ds = BCDataStream()
    ds.write_int64(-987654321) # 1.38μs -> 1.28μs (7.75% faster)

def test_write_int64_zero():
    """Test writing zero."""
    ds = BCDataStream()
    ds.write_int64(0) # 1.40μs -> 1.20μs (16.5% faster)

def test_write_int64_multiple_writes():
    """Test writing multiple int64 values in sequence."""
    ds = BCDataStream()
    ds.write_int64(1) # 1.37μs -> 1.23μs (11.4% faster)
    ds.write_int64(2) # 785ns -> 686ns (14.4% faster)
    ds.write_int64(3) # 447ns -> 377ns (18.6% faster)
    expected = struct.pack('<q', 1) + struct.pack('<q', 2) + struct.pack('<q', 3)

def test_write_int64_return_value():
    """Test that write_int64 returns None."""
    ds = BCDataStream()
    codeflash_output = ds.write_int64(42); ret = codeflash_output # 1.28μs -> 1.21μs (5.69% faster)

# 2. Edge Test Cases

def test_write_int64_maximum():
    """Test writing the maximum int64 value."""
    max_int64 = 2**63 - 1
    ds = BCDataStream()
    ds.write_int64(max_int64) # 1.46μs -> 1.35μs (8.38% faster)

def test_write_int64_minimum():
    """Test writing the minimum int64 value."""
    min_int64 = -2**63
    ds = BCDataStream()
    ds.write_int64(min_int64) # 1.52μs -> 1.32μs (15.2% faster)

def test_write_int64_overflow_positive():
    """Test writing a value that is too large for int64 (should raise struct.error)."""
    ds = BCDataStream()
    with pytest.raises(struct.error):
        ds.write_int64(2**63) # 2.09μs -> 1.90μs (9.73% faster)

def test_write_int64_overflow_negative():
    """Test writing a value that is too small for int64 (should raise struct.error)."""
    ds = BCDataStream()
    with pytest.raises(struct.error):
        ds.write_int64(-2**63 - 1) # 1.92μs -> 1.73μs (10.8% faster)

def test_write_int64_non_integer():
    """Test writing a non-integer value (should raise struct.error or TypeError)."""
    ds = BCDataStream()
    with pytest.raises((struct.error, TypeError)):
        ds.write_int64(1.5) # 1.44μs -> 1.36μs (5.83% faster)
    with pytest.raises((struct.error, TypeError)):
        ds.write_int64("not an int") # 675ns -> 550ns (22.7% faster)

def test_write_int64_none_input():
    """Test writing None as input (should raise struct.error or TypeError)."""
    ds = BCDataStream()
    with pytest.raises((struct.error, TypeError)):
        ds.write_int64(None) # 1.35μs -> 1.05μs (28.6% faster)

def test_write_int64_bool_true():
    """Test writing True as input (should be treated as 1)."""
    ds = BCDataStream()
    ds.write_int64(True) # 1.74μs -> 1.46μs (19.0% faster)

def test_write_int64_bool_false():
    """Test writing False as input (should be treated as 0)."""
    ds = BCDataStream()
    ds.write_int64(False) # 1.57μs -> 1.37μs (14.3% faster)

def test_write_int64_preserves_existing_data():
    """Test that write_int64 appends to existing input, not overwriting."""
    ds = BCDataStream()
    ds.input = bytearray(b'abc')
    ds.write_int64(10) # 1.46μs -> 1.30μs (12.4% faster)

# 3. Large Scale Test Cases

def test_write_int64_large_batch():
    """Test writing a large number of int64 values in sequence."""
    ds = BCDataStream()
    N = 1000  # reasonable upper limit for test
    for i in range(N):
        ds.write_int64(i) # 358μs -> 308μs (16.2% faster)

def test_write_int64_large_negative_batch():
    """Test writing a large number of negative int64 values in sequence."""
    ds = BCDataStream()
    N = 1000
    for i in range(N):
        ds.write_int64(-i) # 359μs -> 310μs (16.0% faster)

def test_write_int64_large_alternating():
    """Test writing alternating min/max int64 values."""
    ds = BCDataStream()
    min_int64 = -2**63
    max_int64 = 2**63 - 1
    N = 500  # 500 min, 500 max = 1000 total
    for i in range(N):
        ds.write_int64(min_int64) # 186μs -> 163μs (13.9% faster)
        ds.write_int64(max_int64) # 184μs -> 160μs (14.4% faster)

def test_write_int64_large_preserves_initial_input():
    """Test that a large batch write preserves and appends to initial input."""
    ds = BCDataStream()
    ds.input = bytearray(b'initial')
    N = 100
    for i in range(N):
        ds.write_int64(i) # 39.6μs -> 34.1μs (16.2% 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

# imports
import pytest
from electrum.transaction import BCDataStream

# unit tests

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

def test_write_int64_zero():
    """Test writing zero."""
    stream = BCDataStream()
    stream.write_int64(0) # 1.88μs -> 1.78μs (5.45% faster)

def test_write_int64_positive():
    """Test writing a small positive integer."""
    stream = BCDataStream()
    stream.write_int64(123456789) # 1.46μs -> 1.47μs (0.544% slower)

def test_write_int64_negative():
    """Test writing a small negative integer."""
    stream = BCDataStream()
    stream.write_int64(-123456789) # 1.47μs -> 1.29μs (13.6% faster)

def test_write_int64_multiple_writes():
    """Test writing multiple int64 values in sequence."""
    stream = BCDataStream()
    stream.write_int64(1) # 1.41μs -> 1.30μs (8.70% faster)
    stream.write_int64(-1) # 916ns -> 815ns (12.4% faster)
    stream.write_int64(42) # 450ns -> 418ns (7.66% faster)
    expected = struct.pack('<q', 1) + struct.pack('<q', -1) + struct.pack('<q', 42)

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

def test_write_int64_max_value():
    """Test writing the maximum 64-bit signed integer."""
    max_val = 2**63 - 1
    stream = BCDataStream()
    stream.write_int64(max_val) # 1.44μs -> 1.33μs (8.28% faster)

def test_write_int64_min_value():
    """Test writing the minimum 64-bit signed integer."""
    min_val = -2**63
    stream = BCDataStream()
    stream.write_int64(min_val) # 1.62μs -> 1.43μs (13.5% faster)

def test_write_int64_just_outside_range_positive():
    """Test writing a value just outside the positive 64-bit range (should raise error)."""
    stream = BCDataStream()
    with pytest.raises(struct.error):
        stream.write_int64(2**63) # 2.10μs -> 1.92μs (9.36% faster)

def test_write_int64_just_outside_range_negative():
    """Test writing a value just outside the negative 64-bit range (should raise error)."""
    stream = BCDataStream()
    with pytest.raises(struct.error):
        stream.write_int64(-2**63 - 1) # 1.90μs -> 1.61μs (18.0% faster)

def test_write_int64_non_integer_float():
    """Test writing a float value (should raise error)."""
    stream = BCDataStream()
    with pytest.raises(struct.error):
        stream.write_int64(1.5) # 1.51μs -> 1.29μs (17.1% faster)

def test_write_int64_non_integer_str():
    """Test writing a string value (should raise error)."""
    stream = BCDataStream()
    with pytest.raises(struct.error):
        stream.write_int64("100") # 1.39μs -> 1.18μs (17.8% faster)

def test_write_int64_none():
    """Test writing None (should raise error)."""
    stream = BCDataStream()
    with pytest.raises(struct.error):
        stream.write_int64(None) # 1.39μs -> 1.17μs (19.5% faster)

def test_write_int64_mutable_input_extend():
    """Test that .input is extended, not replaced, for multiple writes."""
    stream = BCDataStream()
    stream.write_int64(5) # 1.72μs -> 1.55μs (10.8% faster)
    first = stream.input[:]
    stream.write_int64(6) # 888ns -> 825ns (7.64% faster)

def test_write_int64_input_is_bytearray():
    """Test that .input remains a bytearray after writes."""
    stream = BCDataStream()
    stream.write_int64(7) # 1.46μs -> 1.33μs (10.0% faster)
    stream.write_int64(8) # 735ns -> 646ns (13.8% faster)

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

def test_write_int64_many_writes():
    """Test writing a large number of int64 values in sequence."""
    stream = BCDataStream()
    count = 1000
    values = list(range(count))
    for v in values:
        stream.write_int64(v) # 366μs -> 310μs (18.2% faster)
    # Spot-check a few values
    for i in [0, 1, 10, 100, 999]:
        expected = struct.pack('<q', values[i])
        actual = stream.input[i*8:(i+1)*8]

def test_write_int64_large_negative_and_positive_mix():
    """Test writing a mix of large negative and positive int64 values."""
    stream = BCDataStream()
    vals = [2**63-1, -2**63, 0, -1, 1, 2**32, -2**32]
    for v in vals:
        stream.write_int64(v) # 5.61μs -> 4.99μs (12.6% faster)
    expected = b''.join([struct.pack('<q', v) for v in vals])

def test_write_int64_performance_reasonable():
    """Test that writing 1000 int64s is reasonably fast (not a strict perf test, but ensures no O(n^2))."""
    import time
    stream = BCDataStream()
    values = list(range(1000))
    start = time.time()
    for v in values:
        stream.write_int64(v) # 365μs -> 306μs (19.3% faster)
    end = time.time()

def test_write_int64_sequential_input_growth():
    """Test that input grows as expected with each write."""
    stream = BCDataStream()
    for i in range(10):
        stream.write_int64(i) # 6.33μs -> 5.49μs (15.5% faster)
# 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_int64-mholurw8 and push.