⚡️ Speed up method BCDataStream.write_int32 by 27%

[codeflash-ai]

📄 27% (0.27x) speedup for BCDataStream.write_int32 in electrum/transaction.py

⏱️ Runtime : 3.13 milliseconds → 2.47 milliseconds (best of 114 runs)

📝 Explanation and details

The optimization achieves a 26% speedup by inlining the _write_num method directly into write_int32, eliminating the function call overhead and redundant operations.

Key optimizations applied:

1. Function call elimination: The original code called self._write_num('<i', val) which added function call overhead. The optimized version directly implements the struct packing and buffer operations in write_int32.

2. Removed redundant assertion: The original _write_num included an assert isinstance(s, (bytes, bytearray)) check that's unnecessary since struct.pack() always returns bytes.

3. Direct buffer manipulation: Both versions use the same efficient buffer operations (bytearray(s) for initialization and inp.extend(s) for appending), but the optimized version accesses them directly without the indirection of a method call.

Performance impact analysis:

• The line profiler shows the original write_int32 spent 100% of its time just making the function call to _write_num
• The optimized version eliminates this overhead, with time distributed across the actual operations: struct packing (30.4%), buffer access (19.7%), conditional check (21%), and buffer operations (28.5%)
• All test cases show consistent 10-35% speedups across different scenarios

Workload benefits:
This optimization is particularly effective for:

• High-frequency serialization: Bitcoin transaction processing involves repeated int32 serialization for amounts, timestamps, and counters
• Bulk operations: The large-scale tests show 25-28% improvements when writing 1000+ values sequentially
• Memory-constrained scenarios: The optimization maintains the same efficient memory usage patterns while reducing CPU overhead

The optimization preserves all original behavior and error handling while providing significant performance gains for this hot-path serialization method.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 9096 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_int32_basic_positive(): """Test writing a basic positive int32 value.""" stream = BCDataStream() stream.write_int32(42) # 2.05μs -> 1.68μs (21.6% faster) def test_write_int32_basic_negative(): """Test writing a basic negative int32 value.""" stream = BCDataStream() stream.write_int32(-42) # 1.42μs -> 1.27μs (11.6% faster) def test_write_int32_basic_zero(): """Test writing zero.""" stream = BCDataStream() stream.write_int32(0) # 1.40μs -> 1.13μs (24.6% faster) def test_write_int32_multiple_calls(): """Test writing multiple int32 values in sequence.""" stream = BCDataStream() stream.write_int32(1) # 1.43μs -> 1.10μs (29.4% faster) stream.write_int32(2) # 779ns -> 697ns (11.8% faster) stream.write_int32(-3) # 476ns -> 397ns (19.9% faster) # struct.pack('<i', 1) == b'\x01\x00\x00\x00' # struct.pack('<i', 2) == b'\x02\x00\x00\x00' # struct.pack('<i', -3) == b'\xfd\xff\xff\xff' expected = bytearray(b'\x01\x00\x00\x00\x02\x00\x00\x00\xfd\xff\xff\xff') def test_write_int32_return_value(): """Test that write_int32 returns None.""" stream = BCDataStream() codeflash_output = stream.write_int32(123); ret = codeflash_output # 1.23μs -> 963ns (27.7% faster) # -------- Edge Test Cases -------- def test_write_int32_minimum_value(): """Test writing the minimum int32 value.""" stream = BCDataStream() min_val = -2**31 stream.write_int32(min_val) # 1.28μs -> 1.02μs (25.3% faster) def test_write_int32_maximum_value(): """Test writing the maximum int32 value.""" stream = BCDataStream() max_val = 2**31 - 1 stream.write_int32(max_val) # 1.35μs -> 995ns (35.3% faster) def test_write_int32_overflow_positive(): """Test that writing a value too large for int32 raises struct.error.""" stream = BCDataStream() with pytest.raises(struct.error): stream.write_int32(2**31) # 2.54μs -> 2.31μs (10.0% faster) def test_write_int32_overflow_negative(): """Test that writing a value too small for int32 raises struct.error.""" stream = BCDataStream() with pytest.raises(struct.error): stream.write_int32(-2**31 - 1) # 2.00μs -> 1.69μs (18.8% faster) @pytest.mark.parametrize("val", [  0, 1, -1, 123456, -123456, 2**31-1, -2**31 ]) def test_write_int32_idempotence(val): """Test that writing the same value twice results in two identical 4-byte sequences.""" stream = BCDataStream() stream.write_int32(val) # 9.70μs -> 7.56μs (28.3% faster) stream.write_int32(val) # 4.78μs -> 3.97μs (20.3% faster) packed = struct.pack('<i', val) def test_write_int32_non_integer_input(): """Test that non-integer input raises TypeError or struct.error.""" stream = BCDataStream() # float with pytest.raises(struct.error): stream.write_int32(3.14) # string with pytest.raises(TypeError): stream.write_int32("100") # None with pytest.raises(TypeError): stream.write_int32(None) # list with pytest.raises(TypeError): stream.write_int32([1,2,3]) def test_write_int32_mutates_input(): """Test that .input is a bytearray and is mutated, not replaced, after first write.""" stream = BCDataStream() stream.write_int32(1) # 2.52μs -> 2.03μs (24.3% faster) first_input = stream.input stream.write_int32(2) # 814ns -> 709ns (14.8% faster) # -------- Large Scale Test Cases -------- def test_write_int32_large_scale_sequential(): """Test writing a large number of sequential int32 values.""" stream = BCDataStream() N = 1000 for i in range(N): stream.write_int32(i) # 336μs -> 267μs (26.1% faster) # Check a few random positions for correctness for idx in [0, 1, 10, 100, 999]: start = idx * 4 expected = struct.pack('<i', idx) def test_write_int32_large_scale_negative(): """Test writing a large number of negative int32 values.""" stream = BCDataStream() N = 1000 for i in range(N): stream.write_int32(-i) # 338μs -> 267μs (26.5% faster) # Check a few random positions for correctness for idx in [0, 1, 10, 100, 999]: start = idx * 4 expected = struct.pack('<i', -idx) def test_write_int32_large_scale_pattern(): """Test writing a repeating pattern of int32 values.""" stream = BCDataStream() pattern = [0, 2**31-1, -2**31, -1, 123456789] N = 200 # 5*200 = 1000 writes for _ in range(N): for val in pattern: stream.write_int32(val) # Check the first 5 values for i, val in enumerate(pattern): start = i * 4 expected = struct.pack('<i', val) # Check the last 5 values for i, val in enumerate(pattern): start = (5*N - 5 + i) * 4 expected = struct.pack('<i', val) def test_write_int32_large_scale_memory_efficiency(): """Test that memory usage does not explode for large but reasonable input.""" import sys stream = BCDataStream() N = 1000 for i in range(N): stream.write_int32(i) # 337μs -> 265μs (27.3% faster) # The memory size should be reasonable (not much more than the data itself) mem_size = sys.getsizeof(stream.input) # 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 integers # imports import pytest # used for our unit tests from electrum.transaction import BCDataStream # unit tests # --- BASIC TEST CASES --- def test_write_int32_basic_positive(): """Test writing a simple positive int32 value.""" stream = BCDataStream() stream.write_int32(1) # 2.06μs -> 1.60μs (28.7% faster) def test_write_int32_basic_negative(): """Test writing a simple negative int32 value.""" stream = BCDataStream() stream.write_int32(-1) # 1.50μs -> 1.16μs (29.4% faster) def test_write_int32_basic_zero(): """Test writing zero.""" stream = BCDataStream() stream.write_int32(0) # 1.42μs -> 1.12μs (26.9% faster) def test_write_int32_basic_multiple_writes(): """Test writing multiple int32 values sequentially.""" stream = BCDataStream() stream.write_int32(1) # 1.37μs -> 1.04μs (32.0% faster) stream.write_int32(2) # 795ns -> 657ns (21.0% faster) # struct.pack('<i', 1) + struct.pack('<i', 2) expected = bytearray(struct.pack('<i', 1) + struct.pack('<i', 2)) # --- EDGE TEST CASES --- def test_write_int32_edge_max_int32(): """Test writing the maximum int32 value.""" stream = BCDataStream() max_int32 = 2**31 - 1 stream.write_int32(max_int32) # 1.32μs -> 988ns (33.8% faster) expected = bytearray(struct.pack('<i', max_int32)) def test_write_int32_edge_min_int32(): """Test writing the minimum int32 value.""" stream = BCDataStream() min_int32 = -2**31 stream.write_int32(min_int32) # 1.30μs -> 1.02μs (27.9% faster) expected = bytearray(struct.pack('<i', min_int32)) def test_write_int32_edge_overflow_positive(): """Test writing a value just above int32 range (should raise struct.error).""" stream = BCDataStream() with pytest.raises(struct.error): stream.write_int32(2**31) # 2.64μs -> 2.46μs (7.06% faster) def test_write_int32_edge_overflow_negative(): """Test writing a value just below int32 range (should raise struct.error).""" stream = BCDataStream() with pytest.raises(struct.error): stream.write_int32(-2**31 - 1) # 1.95μs -> 1.71μs (13.9% faster) def test_write_int32_edge_non_integer(): """Test writing a non-integer value (should raise struct.error).""" stream = BCDataStream() with pytest.raises(struct.error): stream.write_int32(1.5) # 1.30μs -> 1.13μs (15.0% faster) def test_write_int32_edge_string(): """Test writing a string (should raise struct.error).""" stream = BCDataStream() with pytest.raises(struct.error): stream.write_int32("123") # 1.25μs -> 1.04μs (19.9% faster) def test_write_int32_edge_none(): """Test writing None (should raise struct.error).""" stream = BCDataStream() with pytest.raises(struct.error): stream.write_int32(None) # 1.21μs -> 1.00μs (20.6% faster) def test_write_int32_edge_bool_true(): """Test writing True (should be treated as 1).""" stream = BCDataStream() stream.write_int32(True) # 1.69μs -> 1.31μs (28.8% faster) expected = bytearray(struct.pack('<i', 1)) def test_write_int32_edge_bool_false(): """Test writing False (should be treated as 0).""" stream = BCDataStream() stream.write_int32(False) # 1.41μs -> 1.10μs (28.3% faster) expected = bytearray(struct.pack('<i', 0)) def test_write_int32_edge_input_already_initialized(): """Test writing when input is already a bytearray.""" stream = BCDataStream() stream.input = bytearray(b'abc') stream.write_int32(42) # 1.38μs -> 1.11μs (24.3% faster) expected = bytearray(b'abc' + struct.pack('<i', 42)) def test_write_int32_edge_input_is_empty_bytearray(): """Test writing when input is an empty bytearray.""" stream = BCDataStream() stream.input = bytearray() stream.write_int32(99) # 1.33μs -> 957ns (38.9% faster) expected = bytearray(struct.pack('<i', 99)) # --- LARGE SCALE TEST CASES --- def test_write_int32_large_scale_many_writes(): """Test writing a large number of int32 values sequentially.""" stream = BCDataStream() values = list(range(1000)) # 0 to 999 for v in values: stream.write_int32(v) # 343μs -> 269μs (27.7% faster) # The expected result is the concatenation of all packed int32s expected = bytearray(b''.join([struct.pack('<i', v) for v in values])) def test_write_int32_large_scale_alternating_signs(): """Test writing alternating positive and negative int32 values.""" stream = BCDataStream() values = [i if i % 2 == 0 else -i for i in range(1000)] for v in values: stream.write_int32(v) # 345μs -> 273μs (26.4% faster) expected = bytearray(b''.join([struct.pack('<i', v) for v in values])) def test_write_int32_large_scale_max_min(): """Test writing max and min int32 values repeatedly.""" stream = BCDataStream() values = [2**31 - 1, -2**31] * 500 # 1000 elements for v in values: stream.write_int32(v) # 340μs -> 270μs (26.1% faster) expected = bytearray(b''.join([struct.pack('<i', v) for v in values])) def test_write_int32_large_scale_performance(): """Test that writing 1000 int32s does not take excessive time or memory.""" import time stream = BCDataStream() values = [i for i in range(1000)] start = time.time() for v in values: stream.write_int32(v) # 341μs -> 265μs (28.4% faster) duration = time.time() - start def test_write_int32_large_scale_multiple_streams(): """Test writing to multiple BCDataStream instances independently.""" streams = [BCDataStream() for _ in range(10)] for i, stream in enumerate(streams): for v in range(i * 100, (i + 1) * 100): stream.write_int32(v) expected = bytearray(b''.join([struct.pack('<i', v) for v in range(i * 100, (i + 1) * 100)])) # 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_int32-mhmi39uo and push.