⚡️ Speed up function get_decorator_name_for_mode by 25% in PR #1518 (proper-async)

[codeflash-ai]

⚡️ This pull request contains optimizations for PR #1518

If you approve this dependent PR, these changes will be merged into the original PR branch proper-async.

This PR will be automatically closed if the original PR is merged.

---

📄 25% (0.25x) speedup for get_decorator_name_for_mode in codeflash/code_utils/instrument_existing_tests.py

⏱️ Runtime : 942 microseconds → 752 microseconds (best of 248 runs)

📝 Explanation and details

This optimization achieves a 25% runtime improvement (942μs → 752μs) by replacing sequential if statements with a dictionary lookup using .get() with a default value.

Key Performance Changes:

1. Dictionary Lookup vs Sequential Branching: The original code performs up to 2 enum equality comparisons before returning. The optimized version uses a pre-computed dictionary (_MODE_TO_DECORATOR) that provides O(1) constant-time lookup instead of O(n) sequential checks. This eliminates conditional branching overhead entirely.

2. Reduced CPU Instructions: Each enum comparison involves attribute access and equality checking. The dictionary approach consolidates this into a single hash table lookup with a default fallback, reducing the instruction count per function call.

3. Better for Hot Paths: Based on function_references, this function is called in test instrumentation workflows (test_async_run_and_parse_tests.py) where it's invoked multiple times per test run. The function decorates async functions during testing setup, making it part of the test execution infrastructure. Even though it's not in the tightest inner loop, the cumulative savings across multiple test runs add up.

Test Case Performance Profile:

• Best speedups (58-76% faster): Large-scale tests with 1000+ iterations (test_large_scale_mixed_inputs_1000_iterations, test_unknown_and_wrong_types_return_performance_decorator) show the most dramatic improvements, as the O(1) lookup advantage compounds over many calls.

• Moderate speedups (27-32% faster): Repeated calls with the same input (test_idempotence_on_repeated_calls_same_input, test_loop_1000_same_input_performance_and_consistency) benefit from consistent hash lookups.

• Minor regressions (0-28% slower): Single-call tests for BEHAVIOR mode show slight slowdowns because the original code checked BEHAVIOR first (early exit), while the dictionary approach has fixed overhead regardless of input. However, the overall win comes from amortized performance across all modes.

Trade-off: Individual BEHAVIOR lookups are slightly slower due to dictionary overhead, but the optimization wins on aggregate workload performance, which is what matters in the testing infrastructure context where the function is called with varied inputs across many test cases.

✅ Correctness verification report:

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

🌀 Click to see Generated Regression Tests

import pytest  # used for our unit tests
from codeflash.code_utils.instrument_existing_tests import \
    get_decorator_name_for_mode
from codeflash.models.models import TestingMode

def test_behavior_mode_returns_behavior_decorator():
    # Basic test: TestingMode.BEHAVIOR should map to the behavior decorator name
    codeflash_output = get_decorator_name_for_mode(TestingMode.BEHAVIOR); result = codeflash_output # 555ns -> 708ns (21.6% slower)

def test_concurrency_mode_returns_concurrency_decorator():
    # Basic test: TestingMode.CONCURRENCY should map to the concurrency decorator name
    codeflash_output = get_decorator_name_for_mode(TestingMode.CONCURRENCY); result = codeflash_output # 713ns -> 712ns (0.140% faster)

def test_performance_and_line_profile_return_performance_decorator():
    # Basic + edge: Both PERFORMANCE and LINE_PROFILE should fall back to the performance decorator
    codeflash_output = get_decorator_name_for_mode(TestingMode.PERFORMANCE); res_perf = codeflash_output # 719ns -> 749ns (4.01% slower)
    codeflash_output = get_decorator_name_for_mode(TestingMode.LINE_PROFILE); res_line = codeflash_output # 407ns -> 365ns (11.5% faster)

def test_unknown_and_wrong_types_return_performance_decorator():
    # Edge cases: inputs of wrong types or unexpected values should return the performance decorator
    # None, plain strings, ints, empty string, and arbitrary objects are included
    inputs = [None, "behavior", "CONCURRENCY", "", 0, 12345, object()]
    for item in inputs:
        # For each unexpected input, the function should not raise and should return the performance decorator
        codeflash_output = get_decorator_name_for_mode(item); result = codeflash_output # 3.00μs -> 1.70μs (76.0% faster)

def test_return_type_and_format_is_string_and_matches_pattern():
    # Ensure the function always returns a str and follows the prefix/suffix pattern
    for mode in (TestingMode.BEHAVIOR, TestingMode.CONCURRENCY, TestingMode.PERFORMANCE, TestingMode.LINE_PROFILE):
        codeflash_output = get_decorator_name_for_mode(mode); out = codeflash_output # 1.65μs -> 1.72μs (4.06% slower)

def test_enum_value_constructor_equivalence():
    # Edge: constructing enum by value should behave identically to using the member directly
    # Create a BEHAVIOR member via value-based construction and verify mapping
    behavior_via_value = TestingMode("behavior")
    codeflash_output = get_decorator_name_for_mode(behavior_via_value) # 529ns -> 662ns (20.1% slower)

def test_idempotence_on_repeated_calls_same_input():
    # Basic stability test: repeated calls with the same input must return the same output
    input_mode = TestingMode.CONCURRENCY
    codeflash_output = get_decorator_name_for_mode(input_mode); first = codeflash_output # 694ns -> 670ns (3.58% faster)
    # Call the function repeatedly and ensure outputs are identical every time
    for _ in range(50):  # modest repetition to validate idempotence
        codeflash_output = get_decorator_name_for_mode(input_mode) # 14.2μs -> 11.1μs (27.9% faster)

def test_large_scale_mixed_inputs_1000_iterations():
    # Large-scale test: prepare a deterministic list of 1000 inputs mixing valid and invalid types
    base_inputs = [
        TestingMode.BEHAVIOR,
        TestingMode.CONCURRENCY,
        TestingMode.PERFORMANCE,
        TestingMode.LINE_PROFILE,
        None,
        "",
        "behavior",
        42,
        object(),
    ]
    # Repeat and trim to exactly 1000 entries to stress the function across many calls
    inputs = (base_inputs * 125)[:1000]  # 9 * 125 = 1125, sliced down to 1000 for determinism
    # Verify expected mapping logic over all 1000 deterministic inputs
    for item in inputs:
        expected = (
            "codeflash_behavior_async"
            if item == TestingMode.BEHAVIOR
            else "codeflash_concurrency_async"
            if item == TestingMode.CONCURRENCY
            else "codeflash_performance_async"
        )
        # Call the function and assert the result matches expected mapping
        codeflash_output = get_decorator_name_for_mode(item); result = codeflash_output # 308μs -> 194μs (58.8% faster)

def test_loop_1000_same_input_performance_and_consistency():
    # Large-scale performance-like test: invoke the function 1000 times with the same input
    # to ensure consistent output and reasonable execution across many iterations
    input_mode = TestingMode.PERFORMANCE
    for _ in range(1000):
        codeflash_output = get_decorator_name_for_mode(input_mode); out = codeflash_output # 287μs -> 217μs (32.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 enum import Enum

# imports
import pytest
from codeflash.code_utils.instrument_existing_tests import \
    get_decorator_name_for_mode
from codeflash.models.models import TestingMode

def test_behavior_mode_returns_correct_decorator():
    """Test that BEHAVIOR mode returns the correct decorator name."""
    codeflash_output = get_decorator_name_for_mode(TestingMode.BEHAVIOR); result = codeflash_output # 554ns -> 776ns (28.6% slower)

def test_concurrency_mode_returns_correct_decorator():
    """Test that CONCURRENCY mode returns the correct decorator name."""
    codeflash_output = get_decorator_name_for_mode(TestingMode.CONCURRENCY); result = codeflash_output # 719ns -> 756ns (4.89% slower)

def test_performance_mode_returns_correct_decorator():
    """Test that PERFORMANCE mode returns the correct decorator name."""
    codeflash_output = get_decorator_name_for_mode(TestingMode.PERFORMANCE); result = codeflash_output # 743ns -> 685ns (8.47% faster)

def test_line_profile_mode_returns_default_decorator():
    """Test that LINE_PROFILE mode (not explicitly handled) returns the default decorator."""
    codeflash_output = get_decorator_name_for_mode(TestingMode.LINE_PROFILE); result = codeflash_output # 726ns -> 722ns (0.554% faster)

def test_return_type_is_string():
    """Test that the function always returns a string."""
    codeflash_output = get_decorator_name_for_mode(TestingMode.BEHAVIOR); result = codeflash_output # 566ns -> 726ns (22.0% slower)

def test_return_value_is_non_empty():
    """Test that the function returns a non-empty string."""
    codeflash_output = get_decorator_name_for_mode(TestingMode.BEHAVIOR); result = codeflash_output # 557ns -> 702ns (20.7% slower)

def test_all_enum_members_handled():
    """Test that the function handles all TestingMode enum members and returns a string."""
    # Iterate through all enum members to ensure none raise an error
    for mode in TestingMode:
        codeflash_output = get_decorator_name_for_mode(mode); result = codeflash_output # 1.73μs -> 1.62μs (6.53% faster)

def test_behavior_mode_exact_string_match():
    """Test that BEHAVIOR mode returns the exact expected string with no whitespace."""
    codeflash_output = get_decorator_name_for_mode(TestingMode.BEHAVIOR); result = codeflash_output # 565ns -> 586ns (3.58% slower)

def test_concurrency_mode_exact_string_match():
    """Test that CONCURRENCY mode returns the exact expected string with no whitespace."""
    codeflash_output = get_decorator_name_for_mode(TestingMode.CONCURRENCY); result = codeflash_output # 719ns -> 729ns (1.37% slower)

def test_performance_mode_exact_string_match():
    """Test that PERFORMANCE mode returns the exact expected string with no whitespace."""
    codeflash_output = get_decorator_name_for_mode(TestingMode.PERFORMANCE); result = codeflash_output # 683ns -> 671ns (1.79% faster)

def test_return_contains_async_suffix():
    """Test that all returned decorator names contain 'async' suffix."""
    for mode in TestingMode:
        codeflash_output = get_decorator_name_for_mode(mode); result = codeflash_output # 1.66μs -> 1.64μs (1.28% faster)

def test_return_contains_codeflash_prefix():
    """Test that all returned decorator names contain 'codeflash' prefix."""
    for mode in TestingMode:
        codeflash_output = get_decorator_name_for_mode(mode); result = codeflash_output # 1.66μs -> 1.52μs (9.01% faster)

def test_decorator_name_format():
    """Test that decorator names follow the pattern codeflash_<mode>_async."""
    for mode in TestingMode:
        codeflash_output = get_decorator_name_for_mode(mode); result = codeflash_output # 1.66μs -> 1.55μs (6.70% faster)

def test_behavior_decorator_contains_behavior_keyword():
    """Test that BEHAVIOR mode returns a string containing 'behavior'."""
    codeflash_output = get_decorator_name_for_mode(TestingMode.BEHAVIOR); result = codeflash_output # 553ns -> 655ns (15.6% slower)

def test_concurrency_decorator_contains_concurrency_keyword():
    """Test that CONCURRENCY mode returns a string containing 'concurrency'."""
    codeflash_output = get_decorator_name_for_mode(TestingMode.CONCURRENCY); result = codeflash_output # 705ns -> 662ns (6.50% faster)

def test_performance_decorator_contains_performance_keyword():
    """Test that PERFORMANCE mode returns a string containing 'performance'."""
    codeflash_output = get_decorator_name_for_mode(TestingMode.PERFORMANCE); result = codeflash_output # 745ns -> 696ns (7.04% faster)

def test_return_value_consistency():
    """Test that calling the function multiple times with the same input returns the same result."""
    mode = TestingMode.BEHAVIOR
    codeflash_output = get_decorator_name_for_mode(mode); result1 = codeflash_output # 544ns -> 689ns (21.0% slower)
    codeflash_output = get_decorator_name_for_mode(mode); result2 = codeflash_output # 266ns -> 283ns (6.01% slower)
    codeflash_output = get_decorator_name_for_mode(mode); result3 = codeflash_output # 203ns -> 219ns (7.31% slower)

def test_line_profile_returns_performance_default():
    """Test that LINE_PROFILE mode (unhandled) returns the performance decorator as default."""
    codeflash_output = get_decorator_name_for_mode(TestingMode.LINE_PROFILE); result = codeflash_output # 741ns -> 721ns (2.77% faster)

def test_function_performance_with_many_calls():
    """Test that the function executes quickly even with 1000 repeated calls."""
    # This is a performance-oriented test to ensure no performance regression
    import time
    mode = TestingMode.BEHAVIOR
    
    start_time = time.time()
    for _ in range(1000):
        codeflash_output = get_decorator_name_for_mode(mode); result = codeflash_output # 197μs -> 213μs (7.57% slower)
    end_time = time.time()
    
    # Should complete 1000 calls in under 1 second
    elapsed = end_time - start_time

def test_all_enum_members_consistency_at_scale():
    """Test that the function returns consistent results for all enum members across 100 iterations."""
    expected_results = {
        TestingMode.BEHAVIOR: "codeflash_behavior_async",
        TestingMode.CONCURRENCY: "codeflash_concurrency_async",
        TestingMode.PERFORMANCE: "codeflash_performance_async",
        TestingMode.LINE_PROFILE: "codeflash_performance_async",
    }
    
    # Call 100 times for each mode and verify consistency
    for mode, expected in expected_results.items():
        for _ in range(100):
            codeflash_output = get_decorator_name_for_mode(mode); result = codeflash_output

def test_enum_member_iteration_comprehensive():
    """Test that the function handles all TestingMode enum members comprehensively."""
    # Get all enum members
    modes = list(TestingMode)
    
    # Process all modes
    results = {}
    for mode in modes:
        results[mode] = get_decorator_name_for_mode(mode) # 1.68μs -> 1.64μs (2.62% faster)

def test_decorator_name_latin_characters_only():
    """Test that decorator names contain only valid identifier characters."""
    for mode in TestingMode:
        codeflash_output = get_decorator_name_for_mode(mode); result = codeflash_output # 1.65μs -> 1.50μs (9.99% faster)

def test_behavior_mode_distinct_from_others():
    """Test that BEHAVIOR mode returns a uniquely distinct decorator name."""
    codeflash_output = get_decorator_name_for_mode(TestingMode.BEHAVIOR); behavior_result = codeflash_output # 516ns -> 616ns (16.2% slower)
    codeflash_output = get_decorator_name_for_mode(TestingMode.CONCURRENCY); concurrency_result = codeflash_output # 407ns -> 321ns (26.8% faster)
    codeflash_output = get_decorator_name_for_mode(TestingMode.PERFORMANCE); performance_result = codeflash_output # 334ns -> 277ns (20.6% faster)

def test_concurrent_mode_distinct_from_performance():
    """Test that CONCURRENCY mode returns a different decorator than PERFORMANCE mode."""
    codeflash_output = get_decorator_name_for_mode(TestingMode.CONCURRENCY); concurrency_result = codeflash_output # 699ns -> 624ns (12.0% faster)
    codeflash_output = get_decorator_name_for_mode(TestingMode.PERFORMANCE); performance_result = codeflash_output # 399ns -> 352ns (13.4% 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-pr1518-2026-02-18T09.55.26 and push.

[claude]

PR Review Summary

Prek Checks

✅ All prek checks pass (ruff check + ruff format). No fixes needed.

Mypy

✅ No new mypy errors introduced by this PR. All 13 errors in instrument_existing_tests.py are pre-existing.

Code Review

Scope: This PR optimizes get_decorator_name_for_mode by replacing sequential if statements with a module-level dictionary lookup using .get() with a default value. The change is functionally equivalent to the original.

No critical issues found. The optimization is straightforward and correct:

• _MODE_TO_DECORATOR dict maps BEHAVIOR → "codeflash_behavior_async", CONCURRENCY → "codeflash_concurrency_async"
• .get(mode, "codeflash_performance_async") correctly falls back for PERFORMANCE, LINE_PROFILE, and any other mode

CI Note: 3 integration tests (async-optimization, init-optimization, js-cjs-function-optimization) are failing, but these appear to be related to the base branch (proper-async) rather than this optimization commit.

Test Coverage

File	Stmts	Miss	Coverage
codeflash/code_utils/instrument_existing_tests.py	414	35	92%
codeflash/optimization/function_optimizer.py	1162	948	18%

• Changed lines coverage: The optimization modifies only get_decorator_name_for_mode (line 1675) and adds the _MODE_TO_DECORATOR dict (lines 21-24). Both are exercised by existing tests in test_instrument_async_tests.py.
• function_optimizer.py: 18% coverage is expected — this is a large orchestration file requiring full E2E integration tests to cover.
• No coverage regressions from this optimization.

---

Last updated: 2026-02-18T10:00:00Z