⚡️ Speed up method Algorithms.register by 57%

[codeflash-ai]

📄 57% (0.57x) speedup for Algorithms.register in src/titiler/core/titiler/core/algorithm/__init__.py

⏱️ Runtime : 444 microseconds → 283 microseconds (best of 250 runs)

📝 Explanation and details

The optimization replaces an inefficient loop-based duplicate checking approach with a single set intersection operation, delivering a 56% speedup.

Key optimization: Instead of iterating through each algorithm and checking name in self.data individually, the code now performs one set intersection: self.data.keys() & algorithms.keys(). This eliminates the O(n×m) complexity of repeated dictionary lookups in favor of O(n+m) set intersection.

Why it's faster: The original code performed up to 6,073 individual dictionary lookups (as shown in the profiler), with each name in self.data check taking ~236ns. The optimized version performs just one set operation that finds all overlaps at once, dramatically reducing the computational overhead.

Performance characteristics by test case:

• Large-scale operations: Show the most dramatic improvements (180%+ faster) because the optimization scales much better with input size
• Overwrite operations: Benefit significantly since they skip the overlap check entirely
• Small inputs: Show modest slowdowns (4-23%) due to the overhead of creating sets, but this is negligible in absolute terms (microseconds)
• Conflict detection: Much faster for large inputs where conflicts exist, as it finds overlaps in one operation rather than scanning linearly

Impact on workloads: This optimization is particularly valuable for applications that register many algorithms at once or work with large algorithm registries, which appears common given the comprehensive default algorithm set in the dependency code. The performance gain scales with registry size, making it increasingly beneficial as the system grows.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from copy import copy
from typing import Dict, Type

# function to test (copied from titiler/core/algorithm/__init__.py)
import attr
# imports
import pytest  # used for our unit tests
from titiler.core.algorithm.__init__ import Algorithms

# Minimal BaseAlgorithm and dummy subclasses for testing
class BaseAlgorithm:
    pass

class DummyAlgorithmA(BaseAlgorithm):
    pass

class DummyAlgorithmB(BaseAlgorithm):
    pass

class DummyAlgorithmC(BaseAlgorithm):
    pass
from titiler.core.algorithm.__init__ import Algorithms

# Default algorithms for our tests
default_algorithms: Dict[str, Type[BaseAlgorithm]] = {
    "algoA": DummyAlgorithmA,
    "algoB": DummyAlgorithmB,
}
algorithms = Algorithms(copy(default_algorithms))

# unit tests

# ---------------------------
# 1. Basic Test Cases
# ---------------------------

def test_register_single_new_algorithm():
    # Register a single new algorithm
    new_algo = {"algoC": DummyAlgorithmC}
    codeflash_output = algorithms.register(new_algo); result = codeflash_output # 2.01μs -> 2.45μs (17.9% slower)

def test_register_multiple_new_algorithms():
    # Register multiple new algorithms
    new_algos = {
        "algoC": DummyAlgorithmC,
        "algoD": DummyAlgorithmA,
    }
    codeflash_output = algorithms.register(new_algos); result = codeflash_output # 2.05μs -> 2.14μs (4.34% slower)

def test_register_no_new_algorithms_returns_copy():
    # Registering with empty dict should return a copy with same data
    codeflash_output = algorithms.register({}); result = codeflash_output # 1.62μs -> 1.88μs (13.6% slower)

def test_register_returns_new_instance():
    # Ensure that register returns a new Algorithms instance
    new_algo = {"algoC": DummyAlgorithmC}
    codeflash_output = algorithms.register(new_algo); result = codeflash_output # 1.87μs -> 1.88μs (0.903% slower)

# ---------------------------
# 2. Edge Test Cases
# ---------------------------

def test_register_existing_algorithm_without_overwrite_raises():
    # Try to register an algorithm with an existing name, without overwrite
    new_algo = {"algoA": DummyAlgorithmC}
    with pytest.raises(Exception) as excinfo:
        algorithms.register(new_algo) # 1.59μs -> 2.08μs (23.4% slower)

def test_register_existing_algorithm_with_overwrite_succeeds():
    # Register with an existing name, with overwrite=True
    new_algo = {"algoA": DummyAlgorithmC}
    codeflash_output = algorithms.register(new_algo, overwrite=True); result = codeflash_output # 2.18μs -> 1.86μs (17.0% faster)

def test_register_with_empty_name_key():
    # Register with an empty string as name
    new_algo = {"": DummyAlgorithmC}
    codeflash_output = algorithms.register(new_algo); result = codeflash_output # 1.80μs -> 2.16μs (16.6% slower)

def test_register_with_non_string_name():
    # Register with a non-string key (should allow, as per code)
    new_algo = {42: DummyAlgorithmC}
    codeflash_output = algorithms.register(new_algo); result = codeflash_output # 2.14μs -> 2.31μs (7.39% slower)

def test_register_with_none_as_algorithm_class():
    # Register with None as the value (should allow, as per code)
    new_algo = {"algoE": None}
    codeflash_output = algorithms.register(new_algo); result = codeflash_output # 1.81μs -> 2.04μs (11.3% slower)

def test_register_with_non_algorithm_class():
    # Register with a value that is not a subclass of BaseAlgorithm (should allow, as per code)
    class NotAnAlgorithm:
        pass
    new_algo = {"algoF": NotAnAlgorithm}
    codeflash_output = algorithms.register(new_algo); result = codeflash_output # 1.91μs -> 2.06μs (7.15% slower)

def test_register_with_duplicate_keys_in_input():
    # Python dicts can't have duplicate keys, but test overwriting in input dict itself
    new_algos = {"algoC": DummyAlgorithmA, "algoC": DummyAlgorithmB}
    codeflash_output = algorithms.register(new_algos); result = codeflash_output # 1.75μs -> 1.88μs (6.60% slower)

def test_register_with_algorithm_name_case_sensitivity():
    # Register with a name differing only by case
    new_algo = {"AlgoA": DummyAlgorithmC}
    codeflash_output = algorithms.register(new_algo); result = codeflash_output # 1.74μs -> 1.88μs (7.19% slower)

# ---------------------------
# 3. Large Scale Test Cases
# ---------------------------

def test_register_many_algorithms():
    # Register a large number of new algorithms
    large_algos = {f"algo_{i}": DummyAlgorithmA for i in range(1000)}
    codeflash_output = algorithms.register(large_algos); result = codeflash_output # 57.0μs -> 20.0μs (186% faster)
    for i in range(1000):
        pass

def test_register_many_existing_algorithms_with_overwrite():
    # Register 1000 algorithms with names already present, with overwrite=True
    base_data = {f"algo_{i}": DummyAlgorithmA for i in range(1000)}
    base_algorithms = Algorithms(base_data)
    new_algos = {f"algo_{i}": DummyAlgorithmB for i in range(1000)}
    codeflash_output = base_algorithms.register(new_algos, overwrite=True); result = codeflash_output # 70.7μs -> 25.1μs (181% faster)
    for i in range(1000):
        pass

def test_register_many_existing_algorithms_without_overwrite_raises():
    # Register 1000 algorithms with names already present, without overwrite
    base_data = {f"algo_{i}": DummyAlgorithmA for i in range(1000)}
    base_algorithms = Algorithms(base_data)
    new_algos = {f"algo_{i}": DummyAlgorithmB for i in range(1000)}
    with pytest.raises(Exception) as excinfo:
        base_algorithms.register(new_algos) # 1.69μs -> 35.2μs (95.2% slower)

def test_register_performance_large_scale():
    # Ensure register works efficiently with large input
    import time
    large_algos = {f"algo_{i}": DummyAlgorithmA for i in range(1000)}
    start = time.time()
    codeflash_output = algorithms.register(large_algos); result = codeflash_output # 56.5μs -> 20.0μs (183% faster)
    duration = time.time() - start

# ---------------------------
# 4. Determinism and Immutability
# ---------------------------

def test_register_does_not_mutate_original():
    # Ensure that register does not mutate the original Algorithms instance
    new_algo = {"algoC": DummyAlgorithmC}
    before = dict(algorithms.data)
    algorithms.register(new_algo) # 1.92μs -> 2.10μs (8.54% slower)
    after = dict(algorithms.data)

def test_register_is_deterministic():
    # Registering the same input twice should yield same result
    new_algo = {"algoC": DummyAlgorithmC}
    codeflash_output = algorithms.register(new_algo); result1 = codeflash_output # 1.81μs -> 2.03μs (11.1% slower)
    codeflash_output = algorithms.register(new_algo); result2 = codeflash_output # 720ns -> 791ns (8.98% slower)

# ---------------------------
# 5. Error Message Specificity
# ---------------------------

def test_register_error_message_specificity():
    # Register with an existing name, check error message
    new_algo = {"algoA": DummyAlgorithmC}
    with pytest.raises(Exception) as excinfo:
        algorithms.register(new_algo) # 1.57μs -> 2.00μs (21.7% slower)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

from copy import copy
from typing import Dict, Type

# function to test
import attr
# imports
import pytest
from titiler.core.algorithm.__init__ import Algorithms

# Dummy base class for algorithms
class BaseAlgorithm:
    pass

# Dummy algorithm implementations for testing
class DummyAlgorithmA(BaseAlgorithm):
    pass

class DummyAlgorithmB(BaseAlgorithm):
    pass

class DummyAlgorithmC(BaseAlgorithm):
    pass
from titiler.core.algorithm.__init__ import Algorithms

# Test data for initial algorithms
default_algorithms: Dict[str, Type[BaseAlgorithm]] = {
    "algoA": DummyAlgorithmA,
    "algoB": DummyAlgorithmB,
}

# Helper function to get a fresh Algorithms instance for each test
def get_algorithms():
    return Algorithms(copy(default_algorithms))

# ------------------- UNIT TESTS -------------------

# 1. Basic Test Cases

def test_register_new_algorithm():
    # Register a new algorithm not present in the initial set
    algos = get_algorithms()
    new_algos = {"algoC": DummyAlgorithmC}
    codeflash_output = algos.register(new_algos); result = codeflash_output # 1.44μs -> 1.58μs (8.69% slower)

def test_register_multiple_new_algorithms():
    # Register multiple new algorithms at once
    algos = get_algorithms()
    new_algos = {"algoC": DummyAlgorithmC, "algoD": DummyAlgorithmA}
    codeflash_output = algos.register(new_algos); result = codeflash_output # 1.55μs -> 1.58μs (2.15% slower)

def test_register_does_not_modify_original():
    # Ensure register returns a new instance, original is unchanged
    algos = get_algorithms()
    new_algos = {"algoC": DummyAlgorithmC}
    codeflash_output = algos.register(new_algos); result = codeflash_output # 1.40μs -> 1.52μs (8.08% slower)

def test_register_overwrite_true():
    # Register with overwrite=True should replace the algorithm
    algos = get_algorithms()
    new_algos = {"algoA": DummyAlgorithmC}
    codeflash_output = algos.register(new_algos, overwrite=True); result = codeflash_output # 1.71μs -> 1.26μs (35.4% faster)

def test_register_overwrite_false_raises():
    # Register with overwrite=False and duplicate name should raise
    algos = get_algorithms()
    new_algos = {"algoA": DummyAlgorithmC}
    with pytest.raises(Exception) as excinfo:
        algos.register(new_algos, overwrite=False) # 1.72μs -> 2.22μs (22.4% slower)

def test_register_no_algorithms():
    # Registering an empty dict should return an unchanged copy
    algos = get_algorithms()
    codeflash_output = algos.register({}); result = codeflash_output # 1.26μs -> 1.48μs (14.6% slower)

# 2. Edge Test Cases

def test_register_algorithm_with_empty_string_name():
    # Register with empty string as name
    algos = get_algorithms()
    new_algos = {"": DummyAlgorithmC}
    codeflash_output = algos.register(new_algos); result = codeflash_output # 1.46μs -> 1.63μs (10.0% slower)

def test_register_algorithm_with_non_str_key():
    # Register with non-string keys should work (since no type check)
    algos = get_algorithms()
    new_algos = {42: DummyAlgorithmC}
    codeflash_output = algos.register(new_algos); result = codeflash_output # 1.67μs -> 1.89μs (11.8% slower)

def test_register_algorithm_with_none_key():
    # Register with None as key
    algos = get_algorithms()
    new_algos = {None: DummyAlgorithmC}
    codeflash_output = algos.register(new_algos); result = codeflash_output # 1.57μs -> 1.73μs (9.22% slower)

def test_register_algorithm_with_none_value():
    # Register with None as value (should allow, no type check)
    algos = get_algorithms()
    new_algos = {"algoC": None}
    codeflash_output = algos.register(new_algos); result = codeflash_output # 1.43μs -> 1.58μs (9.58% slower)

def test_register_duplicate_keys_in_input():
    # Register dict with duplicate keys (Python dict can't have duplicates, so only last wins)
    algos = get_algorithms()
    new_algos = {"algoC": DummyAlgorithmA, "algoC": DummyAlgorithmB}
    codeflash_output = algos.register(new_algos); result = codeflash_output # 1.39μs -> 1.50μs (7.78% slower)

def test_register_with_large_string_key():
    # Register with a very large string as key
    algos = get_algorithms()
    large_key = "x" * 1000
    new_algos = {large_key: DummyAlgorithmC}
    codeflash_output = algos.register(new_algos); result = codeflash_output # 1.48μs -> 1.48μs (0.271% faster)

def test_register_with_non_algorithm_value():
    # Register with a value that is not a subclass of BaseAlgorithm
    algos = get_algorithms()
    new_algos = {"algoC": object}
    codeflash_output = algos.register(new_algos); result = codeflash_output # 1.39μs -> 1.49μs (6.58% slower)

def test_register_with_overwrite_and_multiple_conflicts():
    # Register multiple algorithms, some conflicts, with overwrite=True
    algos = get_algorithms()
    new_algos = {"algoA": DummyAlgorithmC, "algoB": DummyAlgorithmA, "algoC": DummyAlgorithmB}
    codeflash_output = algos.register(new_algos, overwrite=True); result = codeflash_output # 2.00μs -> 1.30μs (54.5% faster)

def test_register_with_overwrite_and_partial_conflict():
    # Register multiple algorithms, one conflict, with overwrite=True
    algos = get_algorithms()
    new_algos = {"algoA": DummyAlgorithmC, "algoC": DummyAlgorithmB}
    codeflash_output = algos.register(new_algos, overwrite=True); result = codeflash_output # 1.69μs -> 1.20μs (40.8% faster)

def test_register_with_overwrite_false_and_multiple_conflicts():
    # Register multiple algorithms, some conflicts, with overwrite=False
    algos = get_algorithms()
    new_algos = {"algoA": DummyAlgorithmC, "algoC": DummyAlgorithmB}
    with pytest.raises(Exception) as excinfo:
        algos.register(new_algos, overwrite=False) # 1.69μs -> 2.37μs (28.5% slower)

# 3. Large Scale Test Cases

def test_register_many_new_algorithms():
    # Register a large number of new algorithms
    algos = get_algorithms()
    new_algos = {f"algo_{i}": DummyAlgorithmA for i in range(1000)}
    codeflash_output = algos.register(new_algos); result = codeflash_output # 56.5μs -> 19.7μs (187% faster)
    for i in range(1000):
        pass

def test_register_many_conflicting_algorithms_with_overwrite():
    # Register a large number of conflicting algorithms and overwrite them
    algos = Algorithms({f"algo_{i}": DummyAlgorithmA for i in range(1000)})
    new_algos = {f"algo_{i}": DummyAlgorithmB for i in range(1000)}
    codeflash_output = algos.register(new_algos, overwrite=True); result = codeflash_output # 72.1μs -> 25.7μs (181% faster)
    for i in range(1000):
        pass

def test_register_many_conflicting_algorithms_without_overwrite():
    # Register a large number of conflicting algorithms without overwrite should raise
    algos = Algorithms({f"algo_{i}": DummyAlgorithmA for i in range(1000)})
    new_algos = {f"algo_{i}": DummyAlgorithmB for i in range(1000)}
    with pytest.raises(Exception) as excinfo:
        algos.register(new_algos, overwrite=False) # 1.75μs -> 36.2μs (95.2% slower)

def test_register_large_mixed_new_and_conflicting():
    # Register a mix of new and conflicting algorithms
    algos = Algorithms({f"algo_{i}": DummyAlgorithmA for i in range(500)})
    new_algos = {f"algo_{i}": DummyAlgorithmB for i in range(1000)}
    # Without overwrite, should raise for the first conflict
    with pytest.raises(Exception) as excinfo:
        algos.register(new_algos, overwrite=False) # 1.68μs -> 19.0μs (91.2% slower)
    # With overwrite, all should be present and conflicts resolved
    codeflash_output = algos.register(new_algos, overwrite=True); result = codeflash_output # 68.9μs -> 21.0μs (228% faster)
    for i in range(1000):
        pass

def test_register_large_empty_input():
    # Register with an empty dict on large Algorithms instance
    algos = Algorithms({f"algo_{i}": DummyAlgorithmA for i in range(1000)})
    codeflash_output = algos.register({}); result = codeflash_output # 3.43μs -> 4.18μs (18.0% slower)
# 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-Algorithms.register-mi8dpjdj and push.