⚡️ Speed up function built_with_nvcodec by 16,398%

[codeflash-ai]

📄 16,398% (163.98x) speedup for built_with_nvcodec in src/spdl/io/utils/_build.py

⏱️ Runtime : 1.64 milliseconds → 9.95 microseconds (best of 568 runs)

📝 Explanation and details

The optimization introduces result caching to avoid expensive FFI (Foreign Function Interface) calls. The key change is adding a global variable _built_with_nvcodec that stores the result of the first call to _libspdl_cuda.built_with_nvcodec().

What was optimized:

• Added a global cache variable _built_with_nvcodec: bool | None = None
• Modified the function to check the cache first and return immediately if available
• Only calls the expensive FFI function _libspdl_cuda.built_with_nvcodec() once per program execution

Why this is faster:
The line profiler shows that _libspdl_cuda.built_with_nvcodec() takes ~5.12ms (98.8% of total time) in the original code. This is a costly FFI call that crosses the Python-C boundary. With caching, subsequent calls only perform a simple variable lookup (~14ns) instead of the expensive FFI call.

Performance characteristics:

• First call: Similar performance to original (still needs the FFI call)
• Subsequent calls: ~164x faster due to cache hits
• Multiple calls scenario: The test showing 10 consecutive calls demonstrates 19,731% speedup, highlighting the dramatic benefit when the function is called repeatedly

This optimization is particularly effective for applications that check NVCODEC availability multiple times during execution, which is common in media processing workflows where capability detection happens frequently.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import sys
import types

# imports
import pytest
from spdl.io.utils._build import built_with_nvcodec


# --- Function to test (self-contained definition for unit testing purposes) ---
class DummyLibSpdlCuda:
    """Dummy class to simulate _libspdl_cuda with a built_with_nvcodec method."""
    def __init__(self, should_raise=False, return_value=True):
        self.should_raise = should_raise
        self.return_value = return_value
from spdl.io.utils._build import built_with_nvcodec

# We'll patch _libspdl_cuda in the module namespace for testing
_libspdl_cuda = DummyLibSpdlCuda()
from spdl.io.utils._build import built_with_nvcodec

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

def test_nvcodec_returns_true(monkeypatch):
    """Basic: Should return True if built_with_nvcodec returns True."""
    monkeypatch.setattr(__import__(__name__), "_libspdl_cuda", DummyLibSpdlCuda(return_value=True))
    codeflash_output = built_with_nvcodec() # 52.4μs -> 360ns (14452% faster)

def test_nvcodec_returns_false(monkeypatch):
    """Basic: Should return False if built_with_nvcodec returns False."""
    monkeypatch.setattr(__import__(__name__), "_libspdl_cuda", DummyLibSpdlCuda(return_value=False))
    codeflash_output = built_with_nvcodec() # 53.5μs -> 352ns (15088% faster)

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

def test_nvcodec_raises_exception(monkeypatch):
    """Edge: Should return False if built_with_nvcodec raises any Exception."""
    monkeypatch.setattr(__import__(__name__), "_libspdl_cuda", DummyLibSpdlCuda(should_raise=True))
    codeflash_output = built_with_nvcodec() # 53.8μs -> 368ns (14513% faster)

def test_nvcodec_returns_non_bool(monkeypatch):
    """Edge: Should propagate non-bool values from built_with_nvcodec."""
    # If built_with_nvcodec returns a non-bool, built_with_nvcodec should return it as is
    monkeypatch.setattr(__import__(__name__), "_libspdl_cuda", DummyLibSpdlCuda(return_value="yes"))
    codeflash_output = built_with_nvcodec() # 52.1μs -> 351ns (14758% faster)

def test_nvcodec_returns_none(monkeypatch):
    """Edge: Should propagate None if built_with_nvcodec returns None."""
    monkeypatch.setattr(__import__(__name__), "_libspdl_cuda", DummyLibSpdlCuda(return_value=None))
    codeflash_output = built_with_nvcodec() # 54.0μs -> 344ns (15595% faster)

def test_nvcodec_returns_int(monkeypatch):
    """Edge: Should propagate integer values."""
    monkeypatch.setattr(__import__(__name__), "_libspdl_cuda", DummyLibSpdlCuda(return_value=1))
    codeflash_output = built_with_nvcodec() # 55.2μs -> 348ns (15752% faster)

def test_nvcodec_returns_object(monkeypatch):
    """Edge: Should propagate object values."""
    obj = object()
    monkeypatch.setattr(__import__(__name__), "_libspdl_cuda", DummyLibSpdlCuda(return_value=obj))
    codeflash_output = built_with_nvcodec() # 54.4μs -> 340ns (15908% faster)

def test_nvcodec_returns_list(monkeypatch):
    """Edge: Should propagate list values."""
    monkeypatch.setattr(__import__(__name__), "_libspdl_cuda", DummyLibSpdlCuda(return_value=[True, False]))
    codeflash_output = built_with_nvcodec() # 54.0μs -> 343ns (15633% faster)

def test_nvcodec_returns_dict(monkeypatch):
    """Edge: Should propagate dict values."""
    monkeypatch.setattr(__import__(__name__), "_libspdl_cuda", DummyLibSpdlCuda(return_value={"nvcodec": True}))
    codeflash_output = built_with_nvcodec() # 54.5μs -> 337ns (16065% faster)

def test_nvcodec_returns_empty_string(monkeypatch):
    """Edge: Should propagate empty string values."""
    monkeypatch.setattr(__import__(__name__), "_libspdl_cuda", DummyLibSpdlCuda(return_value=""))
    codeflash_output = built_with_nvcodec() # 54.0μs -> 331ns (16217% faster)

def test_nvcodec_returns_empty_list(monkeypatch):
    """Edge: Should propagate empty list values."""
    monkeypatch.setattr(__import__(__name__), "_libspdl_cuda", DummyLibSpdlCuda(return_value=[]))
    codeflash_output = built_with_nvcodec() # 55.2μs -> 329ns (16690% faster)

def test_nvcodec_returns_empty_dict(monkeypatch):
    """Edge: Should propagate empty dict values."""
    monkeypatch.setattr(__import__(__name__), "_libspdl_cuda", DummyLibSpdlCuda(return_value={}))
    codeflash_output = built_with_nvcodec() # 54.2μs -> 351ns (15342% faster)

def test_nvcodec_returns_float(monkeypatch):
    """Edge: Should propagate float values."""
    monkeypatch.setattr(__import__(__name__), "_libspdl_cuda", DummyLibSpdlCuda(return_value=0.0))
    codeflash_output = built_with_nvcodec() # 53.5μs -> 311ns (17110% faster)

def test_nvcodec_returns_large_int(monkeypatch):
    """Edge: Should propagate large integer values."""
    monkeypatch.setattr(__import__(__name__), "_libspdl_cuda", DummyLibSpdlCuda(return_value=10**18))
    codeflash_output = built_with_nvcodec() # 54.0μs -> 350ns (15330% faster)

def test_nvcodec_returns_false_and_exception(monkeypatch):
    """Edge: Should return False if built_with_nvcodec raises Exception, even if return_value is False."""
    monkeypatch.setattr(__import__(__name__), "_libspdl_cuda", DummyLibSpdlCuda(should_raise=True, return_value=False))
    codeflash_output = built_with_nvcodec() # 54.5μs -> 349ns (15515% faster)

def test_nvcodec_returns_true_and_exception(monkeypatch):
    """Edge: Should return False if built_with_nvcodec raises Exception, even if return_value is True."""
    monkeypatch.setattr(__import__(__name__), "_libspdl_cuda", DummyLibSpdlCuda(should_raise=True, return_value=True))
    codeflash_output = built_with_nvcodec() # 55.7μs -> 328ns (16893% faster)

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

def test_nvcodec_large_list(monkeypatch):
    """Large Scale: Should propagate large list values."""
    large_list = [True] * 999
    monkeypatch.setattr(__import__(__name__), "_libspdl_cuda", DummyLibSpdlCuda(return_value=large_list))
    codeflash_output = built_with_nvcodec(); result = codeflash_output # 55.1μs -> 335ns (16359% faster)

def test_nvcodec_large_dict(monkeypatch):
    """Large Scale: Should propagate large dict values."""
    large_dict = {str(i): i for i in range(999)}
    monkeypatch.setattr(__import__(__name__), "_libspdl_cuda", DummyLibSpdlCuda(return_value=large_dict))
    codeflash_output = built_with_nvcodec(); result = codeflash_output # 59.5μs -> 356ns (16607% faster)
    for i in range(999):
        pass

def test_nvcodec_large_string(monkeypatch):
    """Large Scale: Should propagate large string values."""
    large_string = "x" * 999
    monkeypatch.setattr(__import__(__name__), "_libspdl_cuda", DummyLibSpdlCuda(return_value=large_string))
    codeflash_output = built_with_nvcodec(); result = codeflash_output # 57.1μs -> 330ns (17207% faster)


def test_nvcodec_performance(monkeypatch):
    """Large Scale: Should not be slow for large data (performance check)."""
    import time
    large_data = [True] * 999
    monkeypatch.setattr(__import__(__name__), "_libspdl_cuda", DummyLibSpdlCuda(return_value=large_data))
    start = time.time()
    codeflash_output = built_with_nvcodec(); result = codeflash_output # 76.1μs -> 470ns (16088% faster)
    duration = time.time() - start

# -------------------
# MISCELLANEOUS/ROBUSTNESS
# -------------------

def test_nvcodec_multiple_calls(monkeypatch):
    """Robustness: Should return consistent results across multiple calls."""
    monkeypatch.setattr(__import__(__name__), "_libspdl_cuda", DummyLibSpdlCuda(return_value=True))
    for _ in range(10):
        codeflash_output = built_with_nvcodec() # 317μs -> 1.60μs (19731% faster)

def test_nvcodec_changing_return(monkeypatch):
    """Robustness: Should reflect changes in _libspdl_cuda.built_with_nvcodec return value."""
    monkeypatch.setattr(__import__(__name__), "_libspdl_cuda", DummyLibSpdlCuda(return_value=True))
    codeflash_output = built_with_nvcodec() # 51.0μs -> 358ns (14149% faster)
    monkeypatch.setattr(__import__(__name__), "_libspdl_cuda", DummyLibSpdlCuda(return_value=False))
    codeflash_output = built_with_nvcodec() # 32.1μs -> 165ns (19350% faster)

def test_nvcodec_changing_exception(monkeypatch):
    """Robustness: Should reflect changes in _libspdl_cuda.built_with_nvcodec behavior."""
    monkeypatch.setattr(__import__(__name__), "_libspdl_cuda", DummyLibSpdlCuda(should_raise=True))
    codeflash_output = built_with_nvcodec() # 48.6μs -> 346ns (13941% faster)
    monkeypatch.setattr(__import__(__name__), "_libspdl_cuda", DummyLibSpdlCuda(return_value=True))
    codeflash_output = built_with_nvcodec() # 32.6μs -> 164ns (19779% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from spdl.io.utils._build import built_with_nvcodec

def test_built_with_nvcodec():
    built_with_nvcodec()

🔎 Concolic Coverage Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
codeflash_concolic_xpyvdxks/tmpk9gbptv4/test_concolic_coverage.py::test_built_with_nvcodec	47.5μs	336ns	14028%✅

To edit these changes git checkout codeflash/optimize-built_with_nvcodec-mgqp8anp and push.