⚡️ Speed up function bounce by 18%

[codeflash-ai]

📄 18% (0.18x) speedup for bounce in src/bokeh/driving.py

⏱️ Runtime : 21.9 microseconds → 18.6 microseconds (best of 250 runs)

📝 Explanation and details

The optimization applies a closure variable optimization to the inner function f within the bounce function. The key change is in the function definition:

What changed:

# Original
def f(i: int) -> int:

# Optimized  
def f(i: int, N=N, sequence=sequence) -> int:

Why this is faster:
In Python, variable lookups follow the LEGB rule (Local, Enclosing, Global, Built-in). The original code requires f to access N and sequence from the enclosing scope (closure variables) on every call. The optimized version captures these values as default arguments, making them local variables instead.

Local variable access is significantly faster than closure variable access because:

• Local variables are stored in a simple array and accessed by index
• Closure variables require following a pointer chain through cell objects
• This lookup overhead occurs every time f is called within the generator

Performance impact:
The line profiler shows the optimization reduces time spent in the _advance function's yield f(i) line from 9744ns to 7684ns per hit (21% improvement in the hottest line). The overall speedup of 17% demonstrates this micro-optimization's effectiveness when f is called repeatedly.

Test case analysis:
The optimization particularly benefits test cases that call the bounce driver many times (like test_bounce_many_steps with 1000 steps and test_bounce_performance_large_steps), where the cumulative effect of faster variable lookups becomes significant. Single-call tests see minimal benefit, but high-frequency usage scenarios get substantial performance gains.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	✅ 9 Passed
🌀 Generated Regression Tests	✅ 13 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
unit/bokeh/test_driving.py::test_bounce	834ns	752ns	10.9%✅

🌀 Generated Regression Tests and Runtime

from __future__ import annotations

from functools import partial
from typing import Any, Callable, Iterator, Sequence, TypeVar

# imports
import pytest  # used for our unit tests
from bokeh.driving import bounce

# unit tests

# Helper to extract values from the bounce driver
def get_bounce_values(driver, n):
    """Call the bounce driver n times and collect the output values."""
    result = []
    def collect(x):
        result.append(x)
    # Patch the driver to use our collecting function
    # The driver is a functools.partial(force, sequence=_advance(f))
    # So we replace the function argument
    original_func = driver.func
    original_args = driver.args
    original_keywords = driver.keywords.copy() if driver.keywords else {}
    # Replace 'f' with our collector
    driver_with_collect = partial(original_func, collect, **original_keywords)
    for _ in range(n):
        driver_with_collect()
    return result

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

from functools import partial
from typing import Any, Callable, Iterator, Sequence, TypeVar

# imports
import pytest  # used for our unit tests
from bokeh.driving import bounce

# unit tests

def bounce_sequence(seq, steps):
    """Helper to extract bounce sequence values for testing."""
    result = []
    values = []
    # bounce returns a driver function that calls f(next(sequence))
    # We'll capture the values by passing a list's append method as f
    codeflash_output = bounce(seq); driver = codeflash_output
    for _ in range(steps):
        driver(values.append)
    return values

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




def test_bounce_negative_numbers():
    # Sequence with negative numbers
    seq = [-1, -2, -3]
    expected = [-1, -2, -3, -3, -2, -1, -1, -2]
    output = bounce_sequence(seq, len(expected))

def test_bounce_with_zero():
    # Sequence containing zero
    seq = [0, 1, 2]
    expected = [0, 1, 2, 2, 1, 0, 0, 1]
    output = bounce_sequence(seq, len(expected))

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




def test_bounce_large_numbers():
    # Sequence with large integers
    seq = [1000000, 2000000]
    expected = [1000000, 2000000, 2000000, 1000000, 1000000, 2000000]
    output = bounce_sequence(seq, len(expected))



def test_bounce_many_steps():
    # Test with moderate length sequence and many steps
    seq = [0, 1, 2, 3, 4]
    steps = 1000
    output = bounce_sequence(seq, steps)
    # Check that the output is periodic with period 10
    period = seq + seq[::-1]
    for i in range(0, steps, 10):
        pass

def test_bounce_performance_large_steps():
    # This test checks that bounce can handle a large number of steps efficiently
    seq = [0, 1]
    steps = 1000
    output = bounce_sequence(seq, steps)
    # Should alternate in blocks of [0,1,1,0]
    expected = []
    for i in range(steps):
        div, mod = divmod(i, 2)
        if div % 2 == 0:
            expected.append(seq[mod])
        else:
            expected.append(seq[1-mod])


def test_bounce_large_sequence_reverse_check():
    # Check the reverse bounce for a large sequence
    seq = list(range(100))
    output = bounce_sequence(seq, 200)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

from bokeh.driving import bounce

def test_bounce():
    bounce(())

To edit these changes git checkout codeflash/optimize-bounce-mhwixv2q and push.