⚡️ Speed up function estimate_operation_cost by 121%

[codeflash-ai]

📄 121% (1.21x) speedup for estimate_operation_cost in pdd/sync_determine_operation.py

⏱️ Runtime : 1.21 milliseconds → 548 microseconds (best of 121 runs)

📝 Explanation and details

The optimization moves the cost_map dictionary from being created inside the function to a module-level constant _COST_MAP. This eliminates the need to recreate the dictionary on every function call.

Key changes:

• Dictionary moved from function scope to module scope as _COST_MAP
• Function body simplified to a single return statement using the pre-created dictionary

Why this leads to speedup:

• Eliminated dictionary creation overhead: The original code recreated a 13-entry dictionary on every call, requiring memory allocation and initialization of all key-value pairs
• Reduced per-call work: Function now only performs a single dictionary lookup instead of dictionary creation + lookup
• Better memory efficiency: Single dictionary instance shared across all calls instead of creating temporary dictionaries

Performance characteristics from test results:

• Consistent 100-200% speedup across all test cases, with individual calls going from ~300-900ns to ~150-400ns
• Particularly effective for high-frequency usage patterns (large scale tests show 113-120% improvements)
• Benefits scale linearly with call frequency - the more the function is called, the more overhead is saved
• All operation types (known, unknown, edge cases) benefit equally since the optimization affects the common dictionary creation path

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import sys

# imports
import pytest  # used for our unit tests
from pdd.sync_determine_operation import estimate_operation_cost

# unit tests

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

def test_basic_known_operations():
    # Test all known operations and their expected costs
    codeflash_output = estimate_operation_cost('auto-deps') # 1.11μs -> 475ns (135% faster)
    codeflash_output = estimate_operation_cost('generate') # 499ns -> 207ns (141% faster)
    codeflash_output = estimate_operation_cost('example') # 376ns -> 176ns (114% faster)
    codeflash_output = estimate_operation_cost('crash') # 355ns -> 153ns (132% faster)
    codeflash_output = estimate_operation_cost('verify') # 340ns -> 166ns (105% faster)
    codeflash_output = estimate_operation_cost('test') # 344ns -> 161ns (114% faster)
    codeflash_output = estimate_operation_cost('fix') # 372ns -> 153ns (143% faster)
    codeflash_output = estimate_operation_cost('update') # 343ns -> 158ns (117% faster)
    codeflash_output = estimate_operation_cost('analyze_conflict') # 337ns -> 145ns (132% faster)
    codeflash_output = estimate_operation_cost('nothing') # 337ns -> 152ns (122% faster)
    codeflash_output = estimate_operation_cost('all_synced') # 340ns -> 187ns (81.8% faster)
    codeflash_output = estimate_operation_cost('error') # 342ns -> 146ns (134% faster)
    codeflash_output = estimate_operation_cost('fail_and_request_manual_merge') # 336ns -> 150ns (124% faster)

def test_basic_default_language_argument():
    # Test that default language argument does not affect output
    codeflash_output = estimate_operation_cost('generate') # 875ns -> 367ns (138% faster)
    codeflash_output = estimate_operation_cost('generate', language='python') # 755ns -> 463ns (63.1% faster)
    codeflash_output = estimate_operation_cost('generate', language='java') # 462ns -> 205ns (125% faster)

def test_basic_unknown_operation_returns_zero():
    # Test that unknown operations return 0.0
    codeflash_output = estimate_operation_cost('foobar') # 872ns -> 360ns (142% faster)
    codeflash_output = estimate_operation_cost('') # 436ns -> 240ns (81.7% faster)
    codeflash_output = estimate_operation_cost('GENerate') # 443ns -> 171ns (159% faster)

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

def test_edge_case_sensitive_operations():
    # Test that operations are case sensitive
    codeflash_output = estimate_operation_cost('Generate') # 883ns -> 383ns (131% faster)
    codeflash_output = estimate_operation_cost('TEST') # 440ns -> 211ns (109% faster)
    codeflash_output = estimate_operation_cost('Test') # 416ns -> 181ns (130% faster)

def test_edge_whitespace_in_operations():
    # Test operations with leading/trailing whitespace
    codeflash_output = estimate_operation_cost(' generate') # 855ns -> 354ns (142% faster)
    codeflash_output = estimate_operation_cost('generate ') # 435ns -> 180ns (142% faster)
    codeflash_output = estimate_operation_cost('  test  ') # 373ns -> 155ns (141% faster)

def test_edge_non_string_operation():
    # Test non-string types as operation argument
    codeflash_output = estimate_operation_cost(None)
    codeflash_output = estimate_operation_cost(123)
    codeflash_output = estimate_operation_cost(['generate'])
    codeflash_output = estimate_operation_cost({'operation': 'generate'})

def test_edge_language_argument_variety():
    # Test various language arguments, should not affect cost
    codeflash_output = estimate_operation_cost('fix', language='python') # 1.58μs -> 938ns (69.0% faster)
    codeflash_output = estimate_operation_cost('fix', language='java') # 602ns -> 303ns (98.7% faster)
    codeflash_output = estimate_operation_cost('fix', language='') # 435ns -> 203ns (114% faster)
    codeflash_output = estimate_operation_cost('fix', language=None) # 400ns -> 180ns (122% faster)

def test_edge_empty_operation_string():
    # Test empty string as operation
    codeflash_output = estimate_operation_cost('') # 989ns -> 448ns (121% faster)

def test_edge_operation_with_special_characters():
    # Test operation with special characters
    codeflash_output = estimate_operation_cost('generate!') # 903ns -> 370ns (144% faster)
    codeflash_output = estimate_operation_cost('test@123') # 444ns -> 211ns (110% faster)
    codeflash_output = estimate_operation_cost('fix#') # 421ns -> 152ns (177% faster)

def test_edge_operation_is_boolean():
    # Test boolean as operation argument
    codeflash_output = estimate_operation_cost(True) # 932ns -> 425ns (119% faster)
    codeflash_output = estimate_operation_cost(False) # 474ns -> 226ns (110% faster)

def test_edge_operation_is_float():
    # Test float as operation argument
    codeflash_output = estimate_operation_cost(0.1) # 1.04μs -> 609ns (70.4% faster)
    codeflash_output = estimate_operation_cost(1.0) # 479ns -> 241ns (98.8% faster)

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

def test_large_scale_multiple_known_operations():
    # Test a large number of known operations in a loop
    known_ops = [
        'auto-deps', 'generate', 'example', 'crash', 'verify', 'test',
        'fix', 'update', 'analyze_conflict', 'nothing', 'all_synced', 'error',
        'fail_and_request_manual_merge'
    ]
    expected_costs = [0.10, 0.50, 0.30, 0.40, 0.35, 0.60, 0.45, 0.25, 0.20, 0.0, 0.0, 0.0, 0.0]
    for i in range(len(known_ops)):
        codeflash_output = estimate_operation_cost(known_ops[i]) # 5.15μs -> 2.37μs (118% faster)

def test_large_scale_unknown_operations():
    # Test a large number of unknown operations
    for i in range(100):
        op = f"unknown_op_{i}"
        codeflash_output = estimate_operation_cost(op) # 37.9μs -> 17.6μs (116% faster)

def test_large_scale_mixed_operations():
    # Test a mix of known and unknown operations
    known_ops = [
        'auto-deps', 'generate', 'example', 'crash', 'verify', 'test',
        'fix', 'update', 'analyze_conflict', 'nothing', 'all_synced', 'error',
        'fail_and_request_manual_merge'
    ]
    for i in range(100):
        if i % 2 == 0:
            # Known operation
            op = known_ops[i % len(known_ops)]
            codeflash_output = estimate_operation_cost(op); expected = codeflash_output
        else:
            # Unknown operation
            op = f"unknown_{i}"
            codeflash_output = estimate_operation_cost(op)

def test_large_scale_all_zero_operations():
    # Test all operations that should return zero cost
    zero_ops = ['nothing', 'all_synced', 'error', 'fail_and_request_manual_merge']
    for _ in range(250):
        for op in zero_ops:
            codeflash_output = estimate_operation_cost(op)

def test_large_scale_performance():
    # Test performance with a large list of random operations
    # (This is not a strict performance test, but checks scalability)
    ops = ['auto-deps', 'generate', 'example', 'crash', 'verify', 'test',
           'fix', 'update', 'analyze_conflict', 'nothing', 'all_synced', 'error',
           'fail_and_request_manual_merge', 'unknown', '', None, 123, True, 'GENerate']
    for i in range(500):
        op = ops[i % len(ops)]
        # All known ops should return expected cost, unknowns should return 0.0
        if op in [
            'auto-deps', 'generate', 'example', 'crash', 'verify', 'test',
            'fix', 'update', 'analyze_conflict', 'nothing', 'all_synced', 'error',
            'fail_and_request_manual_merge'
        ]:
            codeflash_output = estimate_operation_cost(op); expected = codeflash_output
        else:
            codeflash_output = estimate_operation_cost(op)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
import sys

# imports
import pytest  # used for our unit tests
from pdd.sync_determine_operation import estimate_operation_cost

# unit tests

# ----------- BASIC TEST CASES -----------

def test_basic_known_operations():
    # Test all known operations with their expected costs
    codeflash_output = estimate_operation_cost('auto-deps') # 1.05μs -> 394ns (167% faster)
    codeflash_output = estimate_operation_cost('generate') # 467ns -> 223ns (109% faster)
    codeflash_output = estimate_operation_cost('example') # 367ns -> 175ns (110% faster)
    codeflash_output = estimate_operation_cost('crash') # 339ns -> 148ns (129% faster)
    codeflash_output = estimate_operation_cost('verify') # 343ns -> 162ns (112% faster)
    codeflash_output = estimate_operation_cost('test') # 334ns -> 151ns (121% faster)
    codeflash_output = estimate_operation_cost('fix') # 354ns -> 164ns (116% faster)
    codeflash_output = estimate_operation_cost('update') # 348ns -> 152ns (129% faster)
    codeflash_output = estimate_operation_cost('analyze_conflict') # 337ns -> 147ns (129% faster)

def test_basic_zero_cost_operations():
    # Test operations that should return zero cost
    codeflash_output = estimate_operation_cost('nothing') # 849ns -> 308ns (176% faster)
    codeflash_output = estimate_operation_cost('all_synced') # 466ns -> 244ns (91.0% faster)
    codeflash_output = estimate_operation_cost('error') # 374ns -> 150ns (149% faster)
    codeflash_output = estimate_operation_cost('fail_and_request_manual_merge') # 348ns -> 161ns (116% faster)

def test_basic_default_language_parameter():
    # Test that the 'language' parameter does not affect the result
    codeflash_output = estimate_operation_cost('generate', language="python") # 1.16μs -> 635ns (82.2% faster)
    codeflash_output = estimate_operation_cost('generate', language="javascript") # 577ns -> 312ns (84.9% faster)
    codeflash_output = estimate_operation_cost('generate', language="") # 414ns -> 197ns (110% faster)

# ----------- EDGE TEST CASES -----------

def test_unknown_operation_returns_zero():
    # Test for an unknown operation string
    codeflash_output = estimate_operation_cost('unknown_operation') # 895ns -> 412ns (117% faster)

def test_empty_string_operation():
    # Test with empty string as operation
    codeflash_output = estimate_operation_cost('') # 805ns -> 389ns (107% faster)

def test_none_operation():
    # Test with None as operation (should not crash, should return 0.0)
    codeflash_output = estimate_operation_cost(None) # 952ns -> 390ns (144% faster)

def test_operation_case_sensitivity():
    # Test that the function is case-sensitive
    codeflash_output = estimate_operation_cost('Generate') # 888ns -> 400ns (122% faster)
    codeflash_output = estimate_operation_cost('AUTO-DEPS') # 548ns -> 262ns (109% faster)
    codeflash_output = estimate_operation_cost('generate') # 417ns -> 179ns (133% faster)

def test_operation_with_whitespace():
    # Test operation with leading/trailing whitespace
    codeflash_output = estimate_operation_cost(' generate ') # 935ns -> 321ns (191% faster)
    codeflash_output = estimate_operation_cost('auto-deps ') # 535ns -> 246ns (117% faster)
    codeflash_output = estimate_operation_cost(' auto-deps') # 371ns -> 157ns (136% faster)

def test_operation_with_similar_names():
    # Test operation names that are similar but not exact
    codeflash_output = estimate_operation_cost('test1') # 889ns -> 297ns (199% faster)
    codeflash_output = estimate_operation_cost('tests') # 541ns -> 220ns (146% faster)
    codeflash_output = estimate_operation_cost('testing') # 408ns -> 202ns (102% faster)

def test_language_parameter_irrelevant():
    # Test that changing language does not affect cost
    codeflash_output = estimate_operation_cost('fix', language='python') # 1.12μs -> 634ns (76.0% faster)
    codeflash_output = estimate_operation_cost('fix', language='java') # 631ns -> 279ns (126% faster)
    codeflash_output = estimate_operation_cost('fix', language='c++') # 426ns -> 189ns (125% faster)

def test_non_string_operation():
    # Test with non-string types for operation
    codeflash_output = estimate_operation_cost(123)
    codeflash_output = estimate_operation_cost(0.5)
    codeflash_output = estimate_operation_cost(['test'])

# ----------- LARGE SCALE TEST CASES -----------

def test_large_scale_known_operations():
    # Test a large list of known operations to check performance and correctness
    known_ops = [
        'auto-deps', 'generate', 'example', 'crash', 'verify', 'test', 'fix',
        'update', 'analyze_conflict', 'nothing', 'all_synced', 'error', 'fail_and_request_manual_merge'
    ]
    for op in known_ops * 50:  # 13 * 50 = 650 calls
        # Should never raise and should always return the correct value
        codeflash_output = estimate_operation_cost(op); expected = codeflash_output # 221μs -> 100μs (120% faster)
        # Check that the value matches the cost_map
        cost_map = {
            'auto-deps': 0.10,
            'generate': 0.50,
            'example': 0.30,
            'crash': 0.40,
            'verify': 0.35,
            'test': 0.60,
            'fix': 0.45,
            'update': 0.25,
            'analyze_conflict': 0.20,
            'nothing': 0.0,
            'all_synced': 0.0,
            'error': 0.0,
            'fail_and_request_manual_merge': 0.0
        }

def test_large_scale_unknown_operations():
    # Test a large list of unknown operations to check they all return 0.0
    unknown_ops = [f"unknown_{i}" for i in range(700)]
    for op in unknown_ops:
        codeflash_output = estimate_operation_cost(op) # 255μs -> 119μs (113% faster)

def test_large_scale_mixed_operations():
    # Test a mix of known and unknown operations in a large batch
    known_ops = [
        'auto-deps', 'generate', 'example', 'crash', 'verify', 'test', 'fix',
        'update', 'analyze_conflict', 'nothing', 'all_synced', 'error', 'fail_and_request_manual_merge'
    ]
    mixed_ops = []
    for i in range(500):
        # Alternate known and unknown
        if i % 2 == 0:
            mixed_ops.append(known_ops[i % len(known_ops)])
        else:
            mixed_ops.append(f"unknown_{i}")
    for op in mixed_ops:
        if op in known_ops:
            pass
        else:
            codeflash_output = estimate_operation_cost(op)

def test_large_scale_non_string_operations():
    # Test a large batch of non-string operations
    non_string_ops = [None, 123, 0.5, [], {}, True, False, object()] * 80  # 8 * 80 = 640
    for op in non_string_ops:
        codeflash_output = estimate_operation_cost(op)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from pdd.sync_determine_operation import estimate_operation_cost

def test_estimate_operation_cost():
    estimate_operation_cost('fix', language='')

🔎 Concolic Coverage Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
codeflash_concolic_diinpk0o/tmp9b8xptno/test_concolic_coverage.py::test_estimate_operation_cost	1.64μs	895ns	83.5%✅

To edit these changes git checkout codeflash/optimize-estimate_operation_cost-mgmzumxa and push.