⚡️ Speed up method BitExp.lscan by 65%

[codeflash-ai]

📄 65% (0.65x) speedup for BitExp.lscan in client/src/com/aerospike/client/exp/BitExp.java

⏱️ Runtime : 728 microseconds → 443 microseconds (best of 169 runs)

📝 Explanation and details

Inlining the Pack.pack call into the return site (and collapsing addRead into a private static helper) eliminated an unnecessary local byte[] reference and reduced call/bytecode overhead, cutting end-to-end time from 728 µs to 443 µs (≈64% speedup). This change reduces a store/load of a temporary, shortens the call chain so the JVM can more effectively inline and optimize the allocation/usage of the packed bytes, and lowers register/stack traffic on the hot path. The improvement is most visible in the large-scale creation test (≈47.7% faster), confirming the benefit on repeated invocation workloads. Trade-offs are minimal: behavior and public API are unchanged while code locality increased slightly, making this a low-risk, high-impact micro-optimization.

✅ Correctness verification report:

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

🌀 Click to see Generated Regression Tests

package com.aerospike.client.exp;

import org.junit.Test;
import org.junit.Before;

import static org.junit.Assert.*;

import java.util.Arrays;

import com.aerospike.client.exp.BitExp;
import com.aerospike.client.exp.Exp;
// Performance comparison:
// BitExpTest.testLscan_TypicalInputs_ReturnsModuleWithExpectedModuleAndReturnType#1: 0.002ms -> 0.002ms (-0.5% faster)
// BitExpTest.testLscan_NullBitOffset_ThrowsNullPointerException#2: 0.048ms -> 0.042ms (12.5% faster)
// BitExpTest.testLscan_NullBitOffset_ThrowsNullPointerException#3: 0.042ms -> 0.038ms (9.7% faster)
// BitExpTest.testLscan_TypicalInputs_ReturnsModule#1: 0.000ms -> 0.000ms (15.9% faster)
// BitExpTest.testLscan_ZeroBitSize_ReturnsModule#8: 0.000ms -> 0.000ms (0.0% faster)
// BitExpTest.testLscan_NullBin_AllowsNullBin#6: 0.000ms -> 0.000ms (0.0% faster)
// BitExpTest.testLscan_NullBitSize_ThrowsNullPointerException#4: 0.033ms -> 0.031ms (7.3% faster)
// BitExpTest.testLscan_NegativeOffset_ReturnsModule#2: 0.001ms -> 0.001ms (5.2% faster)
// BitExpTest.testLscan_NullValue_ThrowsNullPointerException#5: 0.031ms -> 0.029ms (3.9% faster)
// BitExpTest.testLscan_PackedBytes_MatchPackOutput#7: 0.001ms -> 0.000ms (38.8% faster)
// BitExpTest.testLscan_LargeInputs_NoThrow#9: 0.570ms -> 0.298ms (47.7% faster)

/**
 * Unit tests for BitExp.lscan
 *
 * Note:
 * - These tests assume the presence of Exp.val(...) and Exp.blobBin(...) factory methods
 *   as commonly provided by the Aerospike Java client Exp API.
 * - BitExp only contains static methods, but a BitExp instance is created in setUp()
 *   to satisfy the requirement of the exercise.
 */
public class BitExpTest {
    private BitExp instance;

    @Before
    public void setUp() {
        // BitExp has only static methods, but create an instance per instruction.
        instance = new BitExp();
    }

    @Test
    public void testLscan_TypicalInputs_ReturnsModuleWithExpectedModuleAndReturnType() {
        // Arrange
        Exp bitOffset = Exp.val(24);
        Exp bitSize = Exp.val(8);
        Exp value = Exp.val(true);
        Exp bin = Exp.blobBin("a");

        // Act
        Exp result = BitExp.lscan(bitOffset, bitSize, value, bin);

        // Assert basic non-null and type
        assertNotNull("lscan should not return null", result);
        assertTrue("Result should be an instance of Exp.Module", result instanceof Exp.Module);

        // Assert that the module stores the same bin reference that was passed in.
        Exp.Module module = (Exp.Module) result;
        assertSame("Module.bin should reference the provided bin expression", bin, module.bin);

        // Assert that the module id is the BitExp module (1) and return type is INT.
        // These fields are populated by BitExp.addRead(...). This verifies that lscan
        // used addRead with Exp.Type.INT.
        assertEquals("Module id should be 1 (BitExp module)", 1, module.module);
        assertEquals("Return type code should be Exp.Type.INT.code", Exp.Type.INT.code, module.retType);
    }

    @Test(expected = NullPointerException.class)
    public void testLscan_NullBitOffset_ThrowsNullPointerException() {
        // Passing a null bitOffset should result in an exception when packing the expression.
        // We expect a NullPointerException (Pack.pack or the expression handling will throw).
        Exp bitOffset = null;
        Exp bitSize = Exp.val(8);
        Exp value = Exp.val(true);
        Exp bin = Exp.blobBin("a");

        BitExp.lscan(bitOffset, bitSize, value, bin);
    }

    @Test
    public void testLscan_ValueTrueVsFalse_ProducesDifferentPackedBytes() {
        // Arrange common parts
        Exp bitOffset = Exp.val(0);
        Exp bitSize = Exp.val(16);
        Exp bin = Exp.blobBin("testBin");

        // Act
        Exp.Module resTrue = (Exp.Module) BitExp.lscan(bitOffset, bitSize, Exp.val(true), bin);
        Exp.Module resFalse = (Exp.Module) BitExp.lscan(bitOffset, bitSize, Exp.val(false), bin);

        // Assert the packed bytes differ when the boolean value differs.
        // This verifies that the value argument influences the packed representation.
        assertNotNull("Packed bytes for true should not be null", resTrue.bytes);
        assertNotNull("Packed bytes for false should not be null", resFalse.bytes);
        assertFalse("Packed byte arrays should differ for true vs false",
                Arrays.equals(resTrue.bytes, resFalse.bytes));
    }

    @Test
    public void testLscan_BoundaryBitSizesAndOffsets_NoExceptionAndConsistentReturnType() {
        // Test a few boundary-like values to ensure packing/creation does not throw
        Exp[] offsets = new Exp[] {
            Exp.val(0),
            Exp.val(-1),
            Exp.val(Integer.MIN_VALUE),
            Exp.val(Integer.MAX_VALUE)
        };

        Exp[] sizes = new Exp[] {
            Exp.val(0),
            Exp.val(1),
            Exp.val(Integer.MAX_VALUE)
        };

        Exp bin = Exp.blobBin("boundaryBin");

        for (Exp off : offsets) {
            for (Exp size : sizes) {
                Exp.Module module = (Exp.Module) BitExp.lscan(off, size, Exp.val(false), bin);
                assertNotNull("Module should not be null for offset " + off + " and size " + size, module);
                assertEquals("Return type should be INT for all boundary cases", Exp.Type.INT.code, module.retType);
            }
        }
    }

    @Test
    public void testLscan_LargeScale_InvocationPerformance() {
        // This is a lightweight performance/scale check: build many lscan expressions
        // to ensure creation is reasonably fast and does not blow up memory or throw.
        final int iterations = 2000;
        Exp bin = Exp.blobBin("perfBin");

        long start = System.nanoTime();
        for (int i = 0; i < iterations; i++) {
            // Use varying offsets and sizes to emulate varied inputs.
            Exp off = Exp.val(i);
            Exp size = Exp.val((i % 64) + 1);
            Exp.Module m = (Exp.Module) BitExp.lscan(off, size, Exp.val((i % 2) == 0), bin);
            // Simple sanity assertion inside loop to ensure objects are valid.
            assertNotNull("Module must not be null in iteration " + i, m);
        }
        long elapsedMs = (System.nanoTime() - start) / 1_000_000L;

        // Allow generous threshold; primarily ensure it completes quickly in normal environments.
        // This assertion guards against egregious regressions in the expression builder.
        assertTrue("Creating " + iterations + " lscan expressions should be reasonably fast, took " + elapsedMs + "ms",
                elapsedMs < 5000);
    }
}

To edit these changes git checkout codeflash/optimize-BitExp.lscan-mmcjcfpa and push.