⚡️ Speed up function _completed_rung_key by 33%

[codeflash-ai]

📄 33% (0.33x) speedup for _completed_rung_key in optuna/pruners/_successive_halving.py

⏱️ Runtime : 723 microseconds → 545 microseconds (best of 233 runs)

📝 Explanation and details

The optimization replaces the .format() method with an f-string for string formatting, achieving a 32% speedup (723μs → 545μs).

What changed:

• "completed_rung_{}".format(rung) → f"completed_rung_{rung}"

Why it's faster:
F-strings are significantly more performant than .format() because they're evaluated at compile-time rather than runtime. The .format() method involves:

1. Method lookup and call overhead
2. Parsing the format string at runtime
3. Creating intermediate objects for formatting

F-strings bypass these steps by generating optimized bytecode that directly interpolates values, reducing the per-call overhead from 352.9ns to 248.6ns (30% improvement per call).

Performance characteristics:
The optimization shows consistent gains across all test scenarios:

• Basic cases: 17-48% faster for simple integers
• Edge cases: 31-77% faster for extreme values (min/max int, booleans)
• Large scale: 30-34% faster when called in loops (1000+ iterations)

Impact on workloads:
This function appears to be called frequently (3,441 hits in profiling), suggesting it's in a performance-critical path. Given that it's part of Optuna's successive halving pruner, it's likely called during hyperparameter optimization loops where every microsecond matters. The 32% improvement will compound significantly in optimization workflows that make thousands of pruning decisions.

The optimization is particularly effective for workloads involving many pruning evaluations, as demonstrated by the large-scale test cases showing consistent 30%+ improvements.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from __future__ import annotations

# imports
import pytest  # used for our unit tests
from optuna.pruners._successive_halving import _completed_rung_key

# unit tests

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

def test_completed_rung_key_basic_positive_integer():
    # Test with a typical positive integer
    codeflash_output = _completed_rung_key(1) # 676ns -> 454ns (48.9% faster)
    codeflash_output = _completed_rung_key(5) # 290ns -> 247ns (17.4% faster)
    codeflash_output = _completed_rung_key(42) # 244ns -> 207ns (17.9% faster)

def test_completed_rung_key_basic_zero():
    # Test with zero
    codeflash_output = _completed_rung_key(0) # 597ns -> 404ns (47.8% faster)

def test_completed_rung_key_basic_negative_integer():
    # Test with a typical negative integer
    codeflash_output = _completed_rung_key(-1) # 578ns -> 391ns (47.8% faster)
    codeflash_output = _completed_rung_key(-100) # 372ns -> 302ns (23.2% faster)

def test_completed_rung_key_basic_large_integer():
    # Test with a large positive integer
    codeflash_output = _completed_rung_key(999999) # 629ns -> 440ns (43.0% faster)

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

def test_completed_rung_key_edge_min_int():
    # Test with minimum integer value (simulate 32-bit signed int)
    min_int = -2**31
    codeflash_output = _completed_rung_key(min_int) # 718ns -> 546ns (31.5% faster)

def test_completed_rung_key_edge_max_int():
    # Test with maximum integer value (simulate 32-bit signed int)
    max_int = 2**31 - 1
    codeflash_output = _completed_rung_key(max_int) # 665ns -> 462ns (43.9% faster)

def test_completed_rung_key_edge_non_integer_types():
    # Test with float input (should coerce to string, but is not type safe)
    # The function expects int, but does not enforce type, so float will be accepted
    codeflash_output = _completed_rung_key(3.0)
    codeflash_output = _completed_rung_key(-7.5)
    # Test with string input (should raise TypeError)
    with pytest.raises(TypeError):
        _completed_rung_key("5")
    # Test with None (should raise TypeError)
    with pytest.raises(TypeError):
        _completed_rung_key(None)
    # Test with list input (should raise TypeError)
    with pytest.raises(TypeError):
        _completed_rung_key([1])

def test_completed_rung_key_edge_bool_values():
    # Test with boolean values (True/False are subclasses of int in Python)
    codeflash_output = _completed_rung_key(True) # 1.71μs -> 1.03μs (65.6% faster)
    codeflash_output = _completed_rung_key(False) # 391ns -> 280ns (39.6% faster)



def test_completed_rung_key_large_scale_many_integers():
    # Test with a large number of sequential integers
    for i in range(1000):
        codeflash_output = _completed_rung_key(i) # 203μs -> 154μs (31.7% faster)

def test_completed_rung_key_large_scale_negative_integers():
    # Test with a large number of negative integers
    for i in range(-1000, 0):
        codeflash_output = _completed_rung_key(i) # 206μs -> 155μs (32.3% faster)

def test_completed_rung_key_large_scale_extreme_values():
    # Test with extremely large and small values
    values = [10**12, -10**12, 2**63-1, -2**63]
    for v in values:
        codeflash_output = _completed_rung_key(v) # 1.88μs -> 1.48μs (26.5% faster)

# ---------------------------
# Miscellaneous Test Cases
# ---------------------------

def test_completed_rung_key_edge_string_format():
    # Test that the output string format is always correct
    for i in [0, 1, -1, 123, -456, 999]:
        codeflash_output = _completed_rung_key(i); result = codeflash_output # 1.87μs -> 1.37μs (36.7% faster)

def test_completed_rung_key_edge_leading_zeros():
    # Test that leading zeros in input are not preserved (since int type)
    codeflash_output = _completed_rung_key(7) # 617ns -> 398ns (55.0% faster)
    # If input is 007, it's interpreted as 7
    codeflash_output = _completed_rung_key(int("007")) # 241ns -> 164ns (47.0% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from __future__ import annotations

# imports
import pytest  # used for our unit tests
from optuna.pruners._successive_halving import _completed_rung_key

# unit tests

# 1. Basic Test Cases

def test_completed_rung_key_with_zero():
    # Test with rung = 0 (common base case)
    codeflash_output = _completed_rung_key(0) # 782ns -> 450ns (73.8% faster)

def test_completed_rung_key_with_positive_integer():
    # Test with a typical positive integer
    codeflash_output = _completed_rung_key(5) # 646ns -> 398ns (62.3% faster)

def test_completed_rung_key_with_small_positive():
    # Test with another small positive number
    codeflash_output = _completed_rung_key(1) # 668ns -> 433ns (54.3% faster)

def test_completed_rung_key_with_large_positive():
    # Test with a larger positive number
    codeflash_output = _completed_rung_key(123) # 646ns -> 466ns (38.6% faster)

# 2. Edge Test Cases

def test_completed_rung_key_with_negative_integer():
    # Test with a negative integer (should still format as string)
    codeflash_output = _completed_rung_key(-1) # 616ns -> 452ns (36.3% faster)

def test_completed_rung_key_with_large_negative_integer():
    # Test with a large negative integer
    codeflash_output = _completed_rung_key(-999) # 692ns -> 479ns (44.5% faster)

def test_completed_rung_key_with_max_int():
    # Test with maximum 32-bit integer
    codeflash_output = _completed_rung_key(2**31 - 1) # 703ns -> 473ns (48.6% faster)

def test_completed_rung_key_with_min_int():
    # Test with minimum 32-bit integer
    codeflash_output = _completed_rung_key(-(2**31)) # 645ns -> 481ns (34.1% faster)




def test_completed_rung_key_with_bool_true():
    # Test with boolean True (should treat as 1)
    codeflash_output = _completed_rung_key(True) # 1.84μs -> 1.04μs (76.5% faster)

def test_completed_rung_key_with_bool_false():
    # Test with boolean False (should treat as 0)
    codeflash_output = _completed_rung_key(False) # 1.14μs -> 677ns (67.7% faster)

# 3. Large Scale Test Cases

def test_completed_rung_key_with_many_sequential_values():
    # Test with a range of values to ensure no off-by-one errors or performance issues
    for i in range(-100, 100):
        codeflash_output = _completed_rung_key(i) # 41.6μs -> 31.9μs (30.6% faster)

def test_completed_rung_key_with_large_positive_numbers():
    # Test with large numbers up to 999 (upper limit for large scale)
    for i in range(900, 1000):
        codeflash_output = _completed_rung_key(i) # 21.1μs -> 16.1μs (30.7% faster)

def test_completed_rung_key_with_large_negative_numbers():
    # Test with large negative numbers down to -999
    for i in range(-999, -900):
        codeflash_output = _completed_rung_key(i) # 21.0μs -> 16.0μs (31.4% faster)

def test_completed_rung_key_uniqueness_for_different_inputs():
    # Ensure that different inputs yield different outputs (injective property for ints)
    results = set()
    for i in range(-500, 500):
        codeflash_output = _completed_rung_key(i); key = codeflash_output # 208μs -> 156μs (33.8% faster)
        results.add(key)

def test_completed_rung_key_output_is_string():
    # Ensure output is always of type str
    for i in range(-10, 10):
        pass
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from optuna.pruners._successive_halving import _completed_rung_key

def test__completed_rung_key():
    _completed_rung_key(0)

🔎 Concolic Coverage Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
codeflash_concolic_bg1jh046/tmpsmlq4p6m/test_concolic_coverage.py::test__completed_rung_key	1.04μs	532ns	96.4%✅

To edit these changes git checkout codeflash/optimize-_completed_rung_key-mho9fiu5 and push.