⚡️ Speed up method _BaseExpr.__floordiv__ by 5%

[codeflash-ai]

📄 5% (0.05x) speedup for _BaseExpr.__floordiv__ in aerospike_helpers/expressions/resources.py

⏱️ Runtime : 20.8 microseconds → 19.8 microseconds (best of 6 runs)

📝 Explanation and details

The optimized code achieves a 5% runtime improvement by eliminating an intermediate expression object creation in the __floordiv__ method.

What Changed:
The original implementation called __truediv__ (which creates a DIV expression object), stored it in div_expr, and then called __floor__() on that intermediate object. The optimized version directly chains _overload_op_va_args(right, _ExprOp.DIV)._overload_op_unary(_ExprOp.FLOOR), bypassing the temporary variable and method dispatch overhead.

Why This Is Faster:

1. Eliminates intermediate object storage: The original code created a local variable div_expr that held the result of __truediv__. This required Python to manage an additional name binding and reference in the local scope.

2. Removes extra method dispatch: By calling the internal helper methods directly instead of going through the public __truediv__ and __floor__ methods, the optimized version saves two method lookup and dispatch operations.

3. Reduces stack frame overhead: The chained call reduces the number of discrete operations Python must track in its execution stack.

Performance Characteristics:
The line profiler shows the optimized __floordiv__ takes 3.25ms total (11.7μs per call) versus 6.69ms (24.1μs per call) in the original—a 51% improvement in this method's execution time. Test results consistently show 3-7% speedups across various usage patterns:

• Simple two-expression floor division: 3.4% faster
• Varargs merging scenarios: 6.5-7.7% faster
• Large-scale operations (200+ operands): 6.8% faster

Impact:
This optimization is most beneficial when __floordiv__ is called frequently in expression building pipelines. Since Aerospike expression trees can be constructed with many chained operations, this micro-optimization compounds across multiple calls. The behavior remains identical—the same expression tree structure is produced, just more efficiently.

✅ Correctness verification report:

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

🌀 Click to see Generated Regression Tests

import pytest  # used for our unit tests
# Import the real classes and enums from the module where _BaseExpr is defined.
# We MUST import from the same module path shown in the function under test.
from aerospike_helpers.expressions.resources import _BaseExpr, _ExprOp

def test_basic_floordiv_between_two_exprs():
    # Create two real _BaseExpr instances (do NOT stub or fake them).
    a = _BaseExpr()
    b = _BaseExpr()

    # Call the instance method __floordiv__ on the left operand as required.
    codeflash_output = a.__floordiv__(b); res = codeflash_output # 4.28μs -> 4.13μs (3.41% faster)
    inner = res._children[0]

def test_floordiv_with_primitive_right_operand_includes_primitive_in_inner_children():
    # Left operand is a _BaseExpr; right operand is a plain integer.
    left = _BaseExpr()
    right_value = 5

    # Execute floordiv (which under the hood does truediv then floor).
    codeflash_output = left.__floordiv__(right_value); res = codeflash_output # 4.24μs -> 4.16μs (1.87% faster)

    # Inner child is the DIV expression.
    inner = res._children[0]

    # The DIV expression children must include the primitive right operand (5).
    # The structure of var-args DIV is: (left_expr, right_value, expr_end)
    # So we expect the primitive 5 to appear somewhere in the inner children tuple.
    found_primitive = any((child == right_value) for child in inner._children)

def test_varargs_merge_on_left_side_before_floordiv():
    # Create an initial division expression a / 1
    a = _BaseExpr()
    expr1 = a.__truediv__(1)  # produces a DIV expression with children (a, 1, expr_end)

    # Now perform floordiv with an additional operand 2:
    # This will call expr1.__truediv__(2) which should merge varargs (since expr1._op == DIV),
    # and then __floor__ to wrap with FLOOR.
    codeflash_output = expr1.__floordiv__(2); res = codeflash_output # 3.67μs -> 3.44μs (6.51% faster)

    # Inner operator is DIV and must contain a combined children list that includes 1 and 2.
    inner = res._children[0]

    # Ensure both previous operand (1) and new operand (2) are present in children.
    children_vals = tuple(child for child in inner._children)

    # The last child of the DIV expression must be the var-args end marker (a _BaseExpr with special op).
    end_marker = inner._children[-1]

def test_varargs_merge_on_both_sides_then_floordiv():
    # Build left and right DIV expressions separately: (a / 1) and (b / 2)
    a = _BaseExpr()
    b = _BaseExpr()
    left_div = a.__truediv__(1)
    right_div = b.__truediv__(2)

    # Now do left_div.__floordiv__(right_div)
    # This will cause _overload_op_va_args to merge left children and right children (both DIVs),
    # then wrap the combined DIV with FLOOR.
    codeflash_output = left_div.__floordiv__(right_div); res = codeflash_output # 3.86μs -> 3.58μs (7.71% faster)

    # Inner must be DIV with merged children from both sides
    inner = res._children[0]

    # Extract raw children values; they should contain a, 1, b, 2 (in that order before the end marker).
    # We check that both sides' concrete values appear in the merged child list.
    children = inner._children

    # Ensure single end marker at the end
    end_marker = children[-1]

def test_large_scale_floordiv_with_many_operands_performance_and_structure():
    # Build a large DIV varargs expression by repeated truediv calls.
    # Keep the loop under 1000 iterations per instructions; use 200 to exercise scale.
    operands = 200
    base = _BaseExpr()
    # Iteratively extend the DIV expression: each __truediv__ merges into the same DIV expression
    for i in range(operands):
        base = base.__truediv__(i)

    # At this point, base is a DIV expression with children: (original_base, 0, 1, ..., operands-1, expr_end)
    # Now perform floordiv with one more operand to exercise merging + floor wrapping.
    extra_operand = 999
    codeflash_output = base.__floordiv__(extra_operand); res = codeflash_output # 4.80μs -> 4.50μs (6.76% faster)

    # Validate inner operator is DIV
    inner = res._children[0]

    # The combined number of DIV children should be:
    # 1 original base + operands (0..operands-1) + extra_operand + 1 expr_end
    expected_children_count = 1 + operands + 1 + 1  # 1 (original base) + operands + extra_operand slot + expr_end
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

import pytest
from aerospike_helpers.expressions.resources import (
    _BaseExpr, _create_operator_expression, _ExprOp)

def test_floordiv_basic_two_expressions():
    """Test basic floor division between two _BaseExpr objects."""
    # Create two simple expressions
    left = _BaseExpr()
    left._op = _ExprOp.ADD
    left._children = (5, 2)
    
    right = _BaseExpr()
    right._op = _ExprOp.ADD
    right._children = (2, 0)
    
    # Perform floor division
    result = left // right

def test_floordiv_expression_with_numeric():
    """Test floor division between expression and numeric value."""
    # Create an expression
    expr = _BaseExpr()
    expr._op = _ExprOp.ADD
    expr._children = (10, 3)
    
    # Floor divide by numeric value
    result = expr // 2

def test_floordiv_numeric_with_expression():
    """Test floor division between numeric value and expression (reverse)."""
    # Create an expression
    expr = _BaseExpr()
    expr._op = _ExprOp.MUL
    expr._children = (3, 4)
    
    # Numeric floor divide by expression (should trigger __rfloordiv__ if available)
    # This tests that the expression can be used as divisor
    result = expr // 3

def test_floordiv_preserves_structure():
    """Test that floor division preserves expression structure."""
    left = _BaseExpr()
    left._op = _ExprOp.DIV
    left._children = (20, 4)
    
    right = _BaseExpr()
    right._op = _ExprOp.ADD
    right._children = (1, 1)
    
    result = left // right

def test_floordiv_creates_floor_operation():
    """Test that __floordiv__ specifically creates a FLOOR operation."""
    expr1 = _BaseExpr()
    expr1._op = _ExprOp.ADD
    expr1._children = (100,)
    
    expr2 = _BaseExpr()
    expr2._op = _ExprOp.MUL
    expr2._children = (5,)
    
    result = expr1 // expr2

def test_floordiv_with_zero_value():
    """Test floor division with zero as divisor (edge case)."""
    expr = _BaseExpr()
    expr._op = _ExprOp.ADD
    expr._children = (50,)
    
    # Floor divide by zero - should not raise in expression construction
    # (runtime error would occur in actual evaluation)
    result = expr // 0

def test_floordiv_with_negative_values():
    """Test floor division with negative numeric values."""
    expr = _BaseExpr()
    expr._op = _ExprOp.SUB
    expr._children = (10, 20)
    
    result = expr // -3

def test_floordiv_with_float_divisor():
    """Test floor division with float divisor."""
    expr = _BaseExpr()
    expr._op = _ExprOp.DIV
    expr._children = (100, 3)
    
    result = expr // 2.5

def test_floordiv_chained_operations():
    """Test chaining multiple floor divisions."""
    expr1 = _BaseExpr()
    expr1._op = _ExprOp.ADD
    expr1._children = (1000,)
    
    expr2 = _BaseExpr()
    expr2._op = _ExprOp.MUL
    expr2._children = (2,)
    
    # Chain floor divisions
    result = (expr1 // expr2) // 5

def test_floordiv_with_string_in_children():
    """Test floor division expression with string in children (edge case)."""
    expr = _BaseExpr()
    expr._op = _ExprOp.ADD
    expr._children = ("value", 10)
    
    result = expr // 2

def test_floordiv_with_bytes_in_children():
    """Test floor division expression with bytes in children (edge case)."""
    expr = _BaseExpr()
    expr._op = _ExprOp.ADD
    expr._children = (b"data", 5)
    
    result = expr // 1

def test_floordiv_empty_children():
    """Test floor division with expression having empty children."""
    expr = _BaseExpr()
    expr._op = _ExprOp.ADD
    expr._children = ()
    
    result = expr // 3

def test_floordiv_both_expressions_same_op():
    """Test floor division when both operands have same operation type."""
    expr1 = _BaseExpr()
    expr1._op = _ExprOp.ADD
    expr1._children = (10, 5)
    
    expr2 = _BaseExpr()
    expr2._op = _ExprOp.ADD
    expr2._children = (2, 1)
    
    result = expr1 // expr2

def test_floordiv_with_one_as_divisor():
    """Test floor division with 1 as divisor (identity operation)."""
    expr = _BaseExpr()
    expr._op = _ExprOp.DIV
    expr._children = (100, 2)
    
    result = expr // 1

def test_floordiv_with_negative_one_as_divisor():
    """Test floor division with -1 as divisor."""
    expr = _BaseExpr()
    expr._op = _ExprOp.MUL
    expr._children = (50,)
    
    result = expr // -1

def test_floordiv_large_numeric_values():
    """Test floor division with very large numeric values."""
    expr = _BaseExpr()
    expr._op = _ExprOp.ADD
    expr._children = (999999999999,)
    
    result = expr // 1000000000

def test_floordiv_very_small_divisor():
    """Test floor division with very small divisor."""
    expr = _BaseExpr()
    expr._op = _ExprOp.DIV
    expr._children = (100,)
    
    result = expr // 0.0001

def test_floordiv_many_sequential_operations():
    """Test floor division performance with many sequential operations."""
    expr = _BaseExpr()
    expr._op = _ExprOp.ADD
    expr._children = (10000,)
    
    # Perform many floor divisions in sequence
    result = expr
    for i in range(1, 100):
        divisor = _BaseExpr()
        divisor._op = _ExprOp.MUL
        divisor._children = (i,)
        result = result // divisor

def test_floordiv_complex_expression_tree():
    """Test floor division with complex nested expression tree."""
    # Build a complex left operand
    left_base = _BaseExpr()
    left_base._op = _ExprOp.ADD
    left_base._children = (100,)
    
    left = _BaseExpr()
    left._op = _ExprOp.MUL
    left._children = (left_base, 5)
    
    # Build a complex right operand
    right_base = _BaseExpr()
    right_base._op = _ExprOp.SUB
    right_base._children = (10,)
    
    right = _BaseExpr()
    right._op = _ExprOp.DIV
    right._children = (right_base, 2)
    
    result = left // right

def test_floordiv_with_many_children():
    """Test floor division on expression with many children."""
    expr = _BaseExpr()
    expr._op = _ExprOp.ADD
    # Create tuple with many children
    expr._children = tuple(range(1, 100))
    
    divisor = _BaseExpr()
    divisor._op = _ExprOp.MUL
    divisor._children = (2, 3)
    
    result = expr // divisor

def test_floordiv_deeply_nested_expressions():
    """Test floor division with deeply nested expression hierarchy."""
    # Create deeply nested structure
    current = _BaseExpr()
    current._op = _ExprOp.ADD
    current._children = (5,)
    
    for depth in range(50):
        new_expr = _BaseExpr()
        new_expr._op = _ExprOp.MUL if depth % 2 == 0 else _ExprOp.DIV
        new_expr._children = (current,)
        current = new_expr
    
    divisor = _BaseExpr()
    divisor._op = _ExprOp.ADD
    divisor._children = (2,)
    
    result = current // divisor

def test_floordiv_batch_operations():
    """Test floor division performance with batch of operations."""
    expressions = []
    for i in range(100):
        expr = _BaseExpr()
        expr._op = _ExprOp.ADD
        expr._children = (i + 1,)
        expressions.append(expr)
    
    # Apply floor division to all expressions
    divisor = _BaseExpr()
    divisor._op = _ExprOp.MUL
    divisor._children = (3,)
    
    results = [expr // divisor for expr in expressions]

def test_floordiv_alternating_operations():
    """Test floor division alternating with other operations."""
    expr = _BaseExpr()
    expr._op = _ExprOp.ADD
    expr._children = (1000,)
    
    divisor = _BaseExpr()
    divisor._op = _ExprOp.MUL
    divisor._children = (2,)
    
    # Alternate floor division with other operations
    for i in range(50):
        expr = expr // divisor
        if i % 2 == 0:
            expr = expr + 1  # Mix with addition

def test_floordiv_scalar_vs_expression_consistency():
    """Test that floor division behaves consistently with scalars and expressions."""
    expr1 = _BaseExpr()
    expr1._op = _ExprOp.ADD
    expr1._children = (100,)
    
    # Test with scalar
    result_scalar = expr1 // 5
    
    # Test with expression
    expr2 = _BaseExpr()
    expr2._op = _ExprOp.MUL
    expr2._children = (5,)
    
    result_expr = expr1 // expr2
# 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-_BaseExpr.__floordiv__-ml0hdmk8 and push.