⚡️ Speed up function ioff by 67%

[codeflash-ai]

📄 67% (0.67x) speedup for ioff in lib/matplotlib/pyplot.py

⏱️ Runtime : 580 microseconds → 347 microseconds (best of 107 runs)

📝 Explanation and details

The optimized code achieves a 66% speedup by implementing conditional execution guards in the ion() and ioff() functions.

Key optimizations applied:

1. State-aware conditional execution: The optimized version caches the current interactive mode state (current_mode = isinteractive()) and only performs expensive operations when the state actually needs to change:

   • In ioff(): Only calls matplotlib.interactive(False) and uninstall_repl_displayhook() when currently interactive (if current_mode)
   • In ion(): Only calls matplotlib.interactive(True) and install_repl_displayhook() when currently non-interactive (if not current_mode)

2. Reduced function call overhead: When interactive mode is already in the desired state, the optimization avoids:

   • Calling matplotlib.interactive() (which involves dictionary lookups in rcParams)
   • Calling install_repl_displayhook() or uninstall_repl_displayhook() (which involve module imports and event registration)

Why this provides significant speedup:

• The test results show particularly strong gains for repeated calls (84.5-112% faster on subsequent calls) because once the mode is set, subsequent calls become nearly no-ops
• Even first-time calls see 60-76% improvements by eliminating unnecessary work when the state doesn't need to change
• The optimization is especially beneficial for code that frequently toggles interactive mode or calls these functions defensively

Impact on workloads:
This optimization particularly benefits scenarios where ion()/ioff() are called repeatedly in loops, initialization sequences, or defensive programming patterns where the current state is unknown. The preserved context manager behavior ensures backward compatibility while dramatically reducing overhead for common usage patterns.

✅ Correctness verification report:

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

⚙️ Existing Unit Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
test_pyplot.py::test_ioff	3.03μs	3.11μs	-2.48%⚠️
test_pyplot.py::test_ion	8.73μs	5.26μs	65.9%✅
test_pyplot.py::test_nested_ion_ioff	9.80μs	8.93μs	9.85%✅

🌀 Generated Regression Tests and Runtime

# --- Function to test (copied and minimally adapted) ---

# imports
from matplotlib.pyplot import ioff

# --- Minimal stubs for matplotlib internals for testing ---


# Simulate matplotlib.rcParams as a global dict
class RcParams(dict):
    pass


# Simulate matplotlib module and its interactive state
class MatplotlibStub:
    def __init__(self):
        self.rcParams = RcParams()
        self.rcParams["interactive"] = False

    def interactive(self, b):
        self.rcParams["interactive"] = b

    def is_interactive(self):
        return self.rcParams["interactive"]


# Patch sys.modules to insert a dummy matplotlib module and _pylab_helpers
matplotlib = MatplotlibStub()

# --- Unit tests ---

# --- Basic Test Cases ---


def test_ioff_disables_interactive_mode():
    """
    Basic: ioff() disables interactive mode.
    """
    matplotlib.interactive(True)  # Start with interactive ON
    ioff()  # 8.31μs -> 4.71μs (76.5% faster)


def test_ioff_idempotent():
    """
    Basic: ioff() is idempotent (calling multiple times keeps interactive mode off).
    """
    matplotlib.interactive(True)
    ioff()  # 8.51μs -> 4.53μs (87.6% faster)
    ioff()  # 3.38μs -> 1.59μs (112% faster)


def test_ioff_returns_context_manager():
    """
    Basic: ioff() returns an AbstractContextManager.
    """
    codeflash_output = ioff()
    cm = codeflash_output  # 7.52μs -> 4.58μs (64.4% faster)


def test_ioff_context_manager_restores_state():
    """
    Basic: Using ioff() as a context manager restores previous interactive state.
    """
    matplotlib.interactive(True)
    with ioff():
        pass


def test_ioff_context_manager_nested():
    """
    Basic: Nested ioff() context managers restore state correctly.
    """
    matplotlib.interactive(True)
    with ioff():
        with ioff():
            pass


# --- Edge Test Cases ---


def test_ioff_when_already_off():
    """
    Edge: ioff() when interactive mode is already off.
    """
    matplotlib.interactive(False)
    ioff()  # 7.35μs -> 4.56μs (61.3% faster)


def test_ioff_context_manager_when_already_off():
    """
    Edge: Using ioff() as context manager when already off.
    """
    matplotlib.interactive(False)
    with ioff():
        pass


def test_ioff_context_manager_with_exception():
    """
    Edge: ioff() as context manager should restore state even if exception is raised.
    """
    matplotlib.interactive(True)
    try:
        with ioff():
            raise RuntimeError("Test exception")
    except RuntimeError:
        pass


def test_ioff_context_manager_many_nesting():
    """
    Large Scale: Test ioff() as context manager with many nested levels.
    """
    matplotlib.interactive(True)
    depth = 100  # Reasonable upper bound for test
    ctxs = []
    try:
        for _ in range(depth):
            codeflash_output = ioff()
            ctx = codeflash_output
            ctx.__enter__()
            ctxs.append(ctx)
    finally:
        while ctxs:
            ctx = ctxs.pop()
            ctx.__exit__(None, None, None)

# imports
from matplotlib.pyplot import ioff

# --- Function under test (simplified, self-contained for testing) ---


class DummyRcParams(dict):
    """A dummy rcParams dict for testing interactive state."""

    pass


class DummyMatplotlib:
    """A dummy matplotlib module with interactive state."""

    def __init__(self):
        self.rcParams = DummyRcParams()
        self.rcParams["interactive"] = False

    def interactive(self, b):
        self.rcParams["interactive"] = b

    def is_interactive(self):
        return self.rcParams["interactive"]


# Instantiate dummy global matplotlib object for test isolation
matplotlib = DummyMatplotlib()

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


def test_ioff_sets_interactive_false():
    """ioff() sets interactive mode to False."""
    matplotlib.interactive(True)
    ioff()  # 7.64μs -> 4.48μs (70.5% faster)


def test_ioff_when_already_false():
    """ioff() called when already False should remain False."""
    matplotlib.interactive(False)
    ioff()  # 7.64μs -> 4.64μs (64.5% faster)


def test_ioff_returns_context_manager():
    """ioff() returns an AbstractContextManager."""
    codeflash_output = ioff()
    cm = codeflash_output  # 7.60μs -> 4.52μs (68.2% faster)


def test_ioff_context_manager_restores_state():
    """ioff() used as context manager restores previous interactive state."""
    matplotlib.interactive(True)
    with ioff():
        pass


def test_ioff_context_manager_nested():
    """Nested ioff() context managers restore interactive state correctly."""
    matplotlib.interactive(True)
    with ioff():
        with ioff():
            pass


def test_ioff_multiple_calls_idempotent():
    """Multiple calls to ioff() keep interactive mode False."""
    matplotlib.interactive(True)
    ioff()  # 8.55μs -> 5.17μs (65.4% faster)
    ioff()  # 3.14μs -> 1.70μs (84.5% faster)


def test_ioff_context_manager_exception():
    """ioff context manager restores state even if exception is raised."""
    matplotlib.interactive(True)
    try:
        with ioff():
            raise RuntimeError("Test exception")
    except RuntimeError:
        pass


def test_ioff_many_nested_contexts():
    """Test ioff with many nested context managers (scalability)."""
    matplotlib.interactive(True)
    stack = []
    # Open 100 ioff contexts
    for _ in range(100):
        codeflash_output = ioff()
        cm = codeflash_output  # 235μs -> 140μs (67.8% faster)
        stack.append(cm.__enter__())
    # Close all contexts
    while stack:
        cm = stack.pop()
        cm.__exit__(None, None, None)


def test_ioff_context_manager_leak():
    """Test that ioff context manager does not leak state after many uses."""
    matplotlib.interactive(True)
    for _ in range(200):
        with ioff():
            pass


def test_ioff_context_manager_is_reentrant():
    """Test that ioff context manager can be re-entered."""
    matplotlib.interactive(True)
    codeflash_output = ioff()
    cm = codeflash_output  # 8.58μs -> 5.16μs (66.3% faster)
    with cm:
        pass
    with cm:
        pass


def test_ioff_context_manager_type():
    """Test that ioff returns a context manager of the correct base type."""
    codeflash_output = ioff()
    cm = codeflash_output  # 7.33μs -> 4.58μs (60.0% faster)


def test_ioff_docstring_present():
    """Test that ioff has a docstring."""


# 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-ioff-mjaa2dkh and push.