⚡️ Speed up method BCDataStream.write_uint16 by 12%

[codeflash-ai]

📄 12% (0.12x) speedup for BCDataStream.write_uint16 in electrum/transaction.py

⏱️ Runtime : 2.73 milliseconds → 2.44 milliseconds (best of 200 runs)

📝 Explanation and details

The optimization removes a redundant type assertion that was consuming ~22.5% of the execution time in the hot path _write_num method.

Key optimization: The line assert isinstance(s, (bytes, bytearray)) was eliminated because struct.pack() always returns bytes objects, making this runtime check unnecessary.

Performance impact: The line profiler shows the assertion alone took 2.07ms out of 9.23ms total (22.5% of execution time). Removing it reduces _write_num runtime from 9.23ms to 7.24ms - a 21.5% improvement in this method, contributing to the overall 11% speedup.

Why this works: Python's struct.pack() function has a guaranteed return type of bytes, so the assertion provides no functional value while adding computational overhead on every call. In performance-critical serialization code like Bitcoin transaction processing, eliminating such redundant checks is essential.

Test case benefits: The optimization shows consistent 10-16% improvements across all valid input test cases, with particularly strong gains (11-16%) for typical usage patterns like sequential writes and boolean values. Error cases show minimal impact since they fail early in struct.pack(), before reaching the removed assertion.

Workload impact: This optimization is especially valuable for Bitcoin transaction serialization where write_uint16 is called frequently to pack transaction data structures, making the cumulative effect of this micro-optimization significant in real-world usage.

✅ Correctness verification report:

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

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

def test_write_uint16_basic_zero():
    """Test writing the smallest uint16 value (0)"""
    stream = BCDataStream()
    stream.write_uint16(0) # 2.24μs -> 2.10μs (6.66% faster)

def test_write_uint16_basic_one():
    """Test writing value 1"""
    stream = BCDataStream()
    stream.write_uint16(1) # 1.50μs -> 1.25μs (19.5% faster)

def test_write_uint16_basic_typical():
    """Test writing a typical mid-range value"""
    stream = BCDataStream()
    stream.write_uint16(12345) # 1.38μs -> 1.20μs (15.2% faster)

def test_write_uint16_basic_max():
    """Test writing the largest uint16 value (65535)"""
    stream = BCDataStream()
    stream.write_uint16(65535) # 1.33μs -> 1.17μs (13.6% faster)

def test_write_uint16_multiple_writes():
    """Test writing multiple uint16 values in sequence"""
    stream = BCDataStream()
    stream.write_uint16(1) # 1.28μs -> 1.17μs (10.1% faster)
    stream.write_uint16(256) # 770ns -> 720ns (6.94% faster)
    stream.write_uint16(65535) # 377ns -> 341ns (10.6% faster)

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

def test_write_uint16_negative():
    """Test writing a negative value (should raise struct.error)"""
    stream = BCDataStream()
    with pytest.raises(struct.error):
        stream.write_uint16(-1) # 1.49μs -> 1.50μs (0.668% slower)

def test_write_uint16_too_large():
    """Test writing a value > 65535 (should raise struct.error)"""
    stream = BCDataStream()
    with pytest.raises(struct.error):
        stream.write_uint16(70000) # 1.35μs -> 1.37μs (1.39% slower)

def test_write_uint16_non_integer_float():
    """Test writing a float (should raise struct.error)"""
    stream = BCDataStream()
    with pytest.raises(struct.error):
        stream.write_uint16(3.14) # 1.23μs -> 1.32μs (6.99% slower)

def test_write_uint16_non_integer_str():
    """Test writing a string (should raise struct.error or TypeError)"""
    stream = BCDataStream()
    with pytest.raises((struct.error, TypeError)):
        stream.write_uint16("123") # 1.21μs -> 1.26μs (3.50% slower)

def test_write_uint16_none():
    """Test writing None (should raise struct.error or TypeError)"""
    stream = BCDataStream()
    with pytest.raises((struct.error, TypeError)):
        stream.write_uint16(None) # 1.14μs -> 1.18μs (3.22% slower)

def test_write_uint16_bool_true():
    """Test writing True (should be interpreted as 1)"""
    stream = BCDataStream()
    stream.write_uint16(True) # 1.60μs -> 1.48μs (8.19% faster)

def test_write_uint16_bool_false():
    """Test writing False (should be interpreted as 0)"""
    stream = BCDataStream()
    stream.write_uint16(False) # 1.45μs -> 1.29μs (11.9% faster)

def test_write_uint16_input_already_initialized():
    """Test writing when input is already a bytearray with data"""
    stream = BCDataStream()
    stream.input = bytearray(b'\xAA\xBB')
    stream.write_uint16(42) # 1.39μs -> 1.25μs (11.1% faster)

def test_write_uint16_input_is_empty_bytearray():
    """Test writing when input is an empty bytearray"""
    stream = BCDataStream()
    stream.input = bytearray()
    stream.write_uint16(100) # 1.35μs -> 1.18μs (14.5% faster)

def test_write_uint16_return_value():
    """Test that write_uint16 returns None"""
    stream = BCDataStream()
    codeflash_output = stream.write_uint16(123); result = codeflash_output # 1.40μs -> 1.28μs (9.71% faster)

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

def test_write_uint16_large_batch():
    """Test writing a large batch of sequential uint16 values"""
    stream = BCDataStream()
    n = 1000  # Upper limit as per instructions
    for i in range(n):
        stream.write_uint16(i) # 333μs -> 297μs (12.3% faster)
    # Check a few spot values
    for idx in [0, 1, 500, 999]:
        val = idx
        expected_bytes = struct.pack('<H', val)
        offset = idx * 2

def test_write_uint16_large_random_values():
    """Test writing a large batch of random uint16 values"""
    import random
    stream = BCDataStream()
    n = 1000
    values = [random.randint(0, 65535) for _ in range(n)]
    for v in values:
        stream.write_uint16(v) # 340μs -> 302μs (12.6% faster)
    # Verify a few spot values
    for idx in [0, 10, 500, 999]:
        expected_bytes = struct.pack('<H', values[idx])
        offset = idx * 2

def test_write_uint16_performance():
    """Test that writing 1000 values does not take excessive time (basic scalability check)"""
    import time
    stream = BCDataStream()
    n = 1000
    start = time.time()
    for i in range(n):
        stream.write_uint16(i) # 333μs -> 296μs (12.2% faster)
    duration = time.time() - start
# 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  # used for our unit tests
from electrum.transaction import BCDataStream

# unit tests

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

def test_write_uint16_basic_zero():
    """Test writing the minimum uint16 value (0)."""
    ds = BCDataStream()
    ds.write_uint16(0) # 2.25μs -> 2.02μs (11.2% faster)

def test_write_uint16_basic_one():
    """Test writing the value 1."""
    ds = BCDataStream()
    ds.write_uint16(1) # 1.52μs -> 1.37μs (10.8% faster)

def test_write_uint16_basic_typical():
    """Test writing a typical value (0x1234)."""
    ds = BCDataStream()
    ds.write_uint16(0x1234) # 1.40μs -> 1.27μs (9.80% faster)

def test_write_uint16_basic_max():
    """Test writing the maximum uint16 value (65535)."""
    ds = BCDataStream()
    ds.write_uint16(65535) # 1.35μs -> 1.16μs (16.2% faster)

def test_write_uint16_multiple_writes():
    """Test writing multiple uint16 values sequentially."""
    ds = BCDataStream()
    ds.write_uint16(0x0001) # 1.26μs -> 1.20μs (5.00% faster)
    ds.write_uint16(0x1234) # 809ns -> 712ns (13.6% faster)
    ds.write_uint16(0xFFFF) # 362ns -> 346ns (4.62% faster)

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

def test_write_uint16_negative_value():
    """Test writing a negative value, which should raise struct.error."""
    ds = BCDataStream()
    with pytest.raises(struct.error):
        ds.write_uint16(-1) # 1.48μs -> 1.43μs (3.14% faster)

def test_write_uint16_value_too_large():
    """Test writing a value larger than uint16 (65536), should raise struct.error."""
    ds = BCDataStream()
    with pytest.raises(struct.error):
        ds.write_uint16(65536) # 1.34μs -> 1.36μs (1.10% slower)

def test_write_uint16_non_integer():
    """Test writing a non-integer value (float), should raise struct.error."""
    ds = BCDataStream()
    with pytest.raises(struct.error):
        ds.write_uint16(3.14) # 1.21μs -> 1.27μs (4.65% slower)

def test_write_uint16_string():
    """Test writing a string, should raise struct.error."""
    ds = BCDataStream()
    with pytest.raises(struct.error):
        ds.write_uint16("100") # 1.20μs -> 1.21μs (0.912% slower)

def test_write_uint16_bool_true():
    """Test writing boolean True, which is 1 as int."""
    ds = BCDataStream()
    ds.write_uint16(True) # 1.62μs -> 1.46μs (11.1% faster)

def test_write_uint16_bool_false():
    """Test writing boolean False, which is 0 as int."""
    ds = BCDataStream()
    ds.write_uint16(False) # 1.48μs -> 1.29μs (14.7% faster)

def test_write_uint16_none():
    """Test writing None, should raise struct.error."""
    ds = BCDataStream()
    with pytest.raises(struct.error):
        ds.write_uint16(None) # 1.24μs -> 1.27μs (2.43% slower)

def test_write_uint16_object():
    """Test writing an object, should raise struct.error."""
    ds = BCDataStream()
    with pytest.raises(struct.error):
        ds.write_uint16(object()) # 1.27μs -> 1.28μs (1.33% slower)

def test_write_uint16_input_preinitialized():
    """Test writing when input is already set to a bytearray."""
    ds = BCDataStream()
    ds.input = bytearray(b'\xaa\xbb')
    ds.write_uint16(0x1234) # 1.53μs -> 1.34μs (14.1% faster)

def test_write_uint16_input_preinitialized_empty():
    """Test writing when input is already set to an empty bytearray."""
    ds = BCDataStream()
    ds.input = bytearray()
    ds.write_uint16(0xABCD) # 1.36μs -> 1.18μs (15.7% faster)

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

def test_write_uint16_large_scale_sequential():
    """Test writing a large sequence of uint16 values (0..999)."""
    ds = BCDataStream()
    for i in range(1000):
        ds.write_uint16(i) # 335μs -> 299μs (11.9% faster)

def test_write_uint16_large_scale_pattern():
    """Test writing a repeating pattern of values."""
    ds = BCDataStream()
    values = [0, 0xFFFF, 0x1234, 0xABCD]
    for _ in range(250):  # 250 * 4 = 1000 values
        for v in values:
            ds.write_uint16(v)

def test_write_uint16_large_scale_max_values():
    """Test writing 1000 times the maximum value."""
    ds = BCDataStream()
    for _ in range(1000):
        ds.write_uint16(65535) # 336μs -> 300μs (11.9% faster)

def test_write_uint16_large_scale_interleaved():
    """Test writing values interleaved with manual input extension."""
    ds = BCDataStream()
    ds.input = bytearray(b'\x00\x00')
    for i in range(998):  # 998 * 2 + 2 = 2000 bytes
        ds.write_uint16(i) # 331μs -> 298μs (11.2% faster)

def test_write_uint16_large_scale_performance():
    """Test that writing 1000 uint16 values does not take excessive time or memory."""
    ds = BCDataStream()
    import time
    start = time.time()
    for i in range(1000):
        ds.write_uint16(i) # 334μs -> 301μs (11.2% faster)
    duration = time.time() - start
# 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_uint16-mhmhuw09 and push.