⚡️ Speed up function _double by 23%

[codeflash-ai]

📄 23% (0.23x) speedup for _double in src/deepgram/extensions/telemetry/proto_encoder.py

⏱️ Runtime : 13.8 microseconds → 11.3 microseconds (best of 81 runs)

📝 Explanation and details

The optimization inlines the _varint function directly into _key, eliminating function call overhead. Since _key generates protobuf wire format keys using (field_number << 3) | wire_type, the resulting values are typically small (most field numbers are < 16, so keys are usually ≤ 0x7F).

Key changes:

• Replaced _varint((field_number << 3) | wire_type) with inlined varint encoding logic
• Added fast-path: if value <= 0x7F: return bytes((value,)) for single-byte encoding
• Eliminated function call overhead for the common case of small field numbers

Why it's faster:

• Function call elimination: Saves the overhead of calling _varint for every key generation
• Fast-path optimization: Most protobuf field numbers are small, so keys typically encode as single bytes, avoiding the while loop entirely
• Reduced stack operations: Direct byte manipulation instead of function parameter passing

The 22% speedup is particularly effective for test cases with small field numbers (like the annotated tests using field_number=1 and field_number=13), where the fast-path single-byte encoding provides maximum benefit. This optimization excels in typical protobuf usage patterns where field numbers stay low.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import struct  # used for binary packing/unpacking

# imports
import pytest  # used for our unit tests
from deepgram.extensions.telemetry.proto_encoder import _double

# unit tests

# --- Basic Test Cases ---











def test_double_edge_min_max_float():
    # Test with minimum and maximum float values
    import sys
    field_number = 13
    min_float = -sys.float_info.max
    max_float = sys.float_info.max
    codeflash_output = _double(field_number, min_float); result_min = codeflash_output
    codeflash_output = _double(field_number, max_float); result_max = codeflash_output
    expected_key = _key(field_number, 1)
    unpacked_min = struct.unpack("<d", result_min[len(expected_key):])[0]
    unpacked_max = struct.unpack("<d", result_max[len(expected_key):])[0]








#------------------------------------------------
import math
import struct

# imports
import pytest  # used for our unit tests
from deepgram.extensions.telemetry.proto_encoder import _double

# unit tests

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









def test_nan_double():
    # Test NaN value
    field_number = 1
    value = float('nan')
    codeflash_output = _double(field_number, value); result = codeflash_output # 4.00μs -> 3.00μs (33.4% faster)
    # struct.pack will produce a NaN bit pattern, but there are many NaN bit patterns.
    # Check that the unpacked value is NaN
    unpacked = struct.unpack("<d", result[-8:])[0]




def test_invalid_field_number_type():
    # Test with invalid field_number type (should raise TypeError)
    with pytest.raises(TypeError):
        _double("not_an_int", 1.0) # 2.01μs -> 1.98μs (1.82% faster)

def test_invalid_value_type():
    # Test with value that cannot be converted to float (should raise ValueError)
    with pytest.raises(ValueError):
        _double(1, "not_a_float") # 3.92μs -> 3.23μs (21.4% faster)







#------------------------------------------------
from deepgram.extensions.telemetry.proto_encoder import _double

def test__double():
    _double(0, 0.0)

🔎 Concolic Coverage Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
codeflash_concolic_7zeygj7s/tmpmx0pv4o_/test_concolic_coverage.py::test__double	3.89μs	3.05μs	27.5%✅

To edit these changes git checkout codeflash/optimize-_double-mh4j30jd and push.