⚡️ Speed up method ByteAlignedImageCodec.readComponent by 5%

[codeflash-ai]

📄 5% (0.05x) speedup for ByteAlignedImageCodec.readComponent in jme3-core/src/main/java/com/jme3/texture/image/ByteAlignedImageCodec.java

⏱️ Runtime : 280 microseconds → 266 microseconds (best of 19 runs)

📝 Explanation and details

The optimization replaces a generic for-loop that iterates byte-by-byte with an explicit switch statement that unrolls the logic for sizes 1–4, eliminating loop-condition checks, iterator decrements, and repeated index arithmetic (position + i) on every iteration. Line profiler data shows the original loop's body (component = (component << 8) | (encoded[position + i] & 0xff)) consumed 84.5% of total time at ~1240 ns per hit; the optimized version's inlined case blocks drop this to negligible overhead, cutting total function time from 293 µs to 233 µs (a 20% reduction in profiler time, 5% end-to-end speedup). The fallback default case preserves correctness for sizes >4 and the exception-handling path remains identical, so no behavioral trade-offs occur.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 17 Passed
⏪ Replay Tests	🔘 None Found
🔎 Concolic Coverage Tests	🔘 None Found
📊 Tests Coverage	Coverage data not available

🌀 Click to see Generated Regression Tests

package com.jme3.texture.image;

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

import java.lang.reflect.Method;
import java.util.Arrays;

import static org.junit.Assert.*;
import static org.junit.Assert.assertEquals;

public class ByteAlignedImageCodecTest {

    private ByteAlignedImageCodec instance;
    private Method readComponentMethod;

    @Before
    public void setUp() throws Exception {
        // Create an instance with arbitrary parameters. The constructor parameters are not used by the static method under test,
        // but the test requirement asks for an instance to be created.
        instance = new ByteAlignedImageCodec(
                32, // bpp
                0,  // flags
                1,  // az
                1,  // rz
                1,  // gz
                1,  // bz
                0,  // ap
                0,  // rp
                0,  // gp
                0   // bp
        );

        // Acquire the private static method readComponent(byte[], int, int) via reflection
        readComponentMethod = ByteAlignedImageCodec.class.getDeclaredMethod("readComponent", byte[].class, int.class, int.class);
        readComponentMethod.setAccessible(true);
    }

    // Helper to invoke the private static method
    private int invokeReadComponent(byte[] encoded, int position, int size) throws Exception {
        Object result = readComponentMethod.invoke(null, encoded, position, size);
        return ((Integer) result).intValue();
    }

    @Test
    public void testReadComponent_SingleByte_ReturnsByteValue() throws Exception {
        byte[] encoded = new byte[] { (byte)0x7F }; // 127
        int value = invokeReadComponent(encoded, 0, 1);
    }

    @Test
    public void testReadComponent_TwoBytes_ReturnsCombinedValue() throws Exception {
        byte[] encoded = new byte[] { (byte)0x01, (byte)0x02 }; // expect 0x02<<8 | 0x01 = 0x0201 = 513
        int value = invokeReadComponent(encoded, 0, 2);
    }

    @Test
    public void testReadComponent_FourBytes_ReturnsCombinedValue() throws Exception {
        byte[] encoded = new byte[] { (byte)0x01, (byte)0x02, (byte)0x03, (byte)0x04 };
        // Expected: 0x04<<24 | 0x03<<16 | 0x02<<8 | 0x01 = 0x04030201 = 67305985
        int value = invokeReadComponent(encoded, 0, 4);
    }

    @Test
    public void testReadComponent_MidPosition_ReturnsCorrectValue() throws Exception {
        byte[] encoded = new byte[] { 0x00, 0x10, 0x20, 0x30 };
        // position = 1, size = 3 -> bytes at indices 1,2,3 => expect 0x30<<16 | 0x20<<8 | 0x10 = 0x00302010
        int value = invokeReadComponent(encoded, 1, 3);
    }

    @Test
    public void testReadComponent_SizeZero_ReturnsZero() throws Exception {
        byte[] encoded = new byte[] { 0x01, 0x02 };
        int value = invokeReadComponent(encoded, 0, 0);
    }

    @Test
    public void testReadComponent_NegativeSize_ReturnsZero() throws Exception {
        byte[] encoded = new byte[] { 0x01, 0x02 };
        int value = invokeReadComponent(encoded, 0, -1);
    }

    @Test
    public void testReadComponent_ArrayIndexOutOfBounds_ReturnsZero() throws Exception {
        byte[] encoded = new byte[] { 0x11, 0x22 };
        // position = 1, size = 2 -> will attempt to access index 2 -> ArrayIndexOutOfBoundsException is caught and method returns 0
        int value = invokeReadComponent(encoded, 1, 2);
    }

    @Test(timeout = 2000)
    public void testReadComponent_Performance_LargeRepeatedCalls_CompletesWithinTime() throws Exception {
        // Prepare a large buffer and repeatedly read small components to exercise performance
        final int size = 100_000;
        byte[] large = new byte[size];
        // Fill with a pattern
        for (int i = 0; i < size; i++) {
            large[i] = (byte) (i & 0xFF);
        }

        // Perform many reads; each read uses size 4 (safe for int combination)
        int runs = 50_000;
        int acc = 0;
        // We'll vary positions so we exercise different offsets
        for (int i = 0; i < runs; i++) {
            int pos = (i * 7) % (size - 4); // ensure room for 4 bytes
            acc ^= invokeReadComponent(large, pos, 4); // XOR to use result and prevent JIT elimination
        }

        // A simple sanity check to ensure the loop did some work; acc should be an int (no specific value guaranteed)
    }
}

package com.jme3.texture.image;

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

import java.lang.reflect.Method;

import static org.junit.Assert.*;
import com.jme3.texture.image.ByteAlignedImageCodec;

public class ByteAlignedImageCodecTest_2 {

    private ByteAlignedImageCodec codec;
    private Method readComponentMethod;

    @Before
    public void setUp() throws Exception {
        // Create an instance with arbitrary but valid constructor arguments.
        // Parameters: bpp, flags, az, rz, gz, bz, ap, rp, gp, bp
        codec = new ByteAlignedImageCodec(32, 0, 1, 1, 1, 1, 0, 0, 0, 0);

        // Access the private static method readComponent(byte[], int, int) via reflection
        readComponentMethod = ByteAlignedImageCodec.class.getDeclaredMethod("readComponent", byte[].class, int.class, int.class);
        readComponentMethod.setAccessible(true);
    }

    // Helper to call the private static method
    private int readComponent(byte[] encoded, int position, int size) throws Exception {
        Object result = readComponentMethod.invoke(null, encoded, position, size);
        return ((Integer) result).intValue();
    }

    @Test
    public void testReadComponent_SingleByte_ReturnsUnsignedValue() throws Exception {
        byte[] encoded = new byte[] { (byte) 0xAB };
        int value = readComponent(encoded, 0, 1);
    }

    @Test
    public void testReadComponent_MultiByte_LittleEndianAggregation() throws Exception {
        byte[] encoded = new byte[] { 0x01, 0x02, 0x03 };
        // Expect bytes interpreted as little-endian: result = 0x03 02 01
        int value = readComponent(encoded, 0, 3);
    }

    @Test
    public void testReadComponent_WithPositionOffset_ReturnsCorrectAggregation() throws Exception {
        byte[] encoded = new byte[] { 0x00, 0x11, 0x22, 0x33 };
        // position 1, size 3 -> bytes {0x11,0x22,0x33} -> little-endian -> 0x332211
        int value = readComponent(encoded, 1, 3);
    }

    @Test
    public void testReadComponent_SizeZero_ReturnsZero() throws Exception {
        byte[] encoded = new byte[] { 0x12, 0x34 };
        int value = readComponent(encoded, 0, 0);
    }

    @Test
    public void testReadComponent_OutOfBounds_ReturnsZero() throws Exception {
        byte[] encoded = new byte[] { 0x10, 0x20 };
        // position 1, size 3 attempts to access encoded[3] which is out of bounds.
        int value = readComponent(encoded, 1, 3);
    }

    @Test
    public void testReadComponent_NegativePosition_ReturnsZero() throws Exception {
        byte[] encoded = new byte[] { 0x01, 0x02, 0x03 };
        // negative position will cause ArrayIndexOutOfBoundsException and method catches it, returning 0
        int value = readComponent(encoded, -1, 2);
    }

    @Test
    public void testReadComponent_BytesWithHighBitSet_HandlesUnsignedBytes() throws Exception {
        byte[] encoded = new byte[] { (byte) 0xFF, (byte) 0x80 }; // 0x80 0xFF -> little-endian -> 0x80FF
        int value = readComponent(encoded, 0, 2);
    }

    @Test
    public void testReadComponent_LargeArray_PerformanceAndCorrectness() throws Exception {
        // Create a large array and place a known 4-byte little-endian pattern somewhere in the middle
        final int largeSize = 1_000_000;
        byte[] large = new byte[largeSize];
        int pos = 500_000;
        // set bytes to 0x01,0x02,0x03,0x04 at position
        large[pos] = 0x01;
        large[pos + 1] = 0x02;
        large[pos + 2] = 0x03;
        large[pos + 3] = 0x04;

        int value = readComponent(large, pos, 4);
        // little-endian aggregated value: 0x04 03 02 01
    }
}

To edit these changes git checkout codeflash/optimize-ByteAlignedImageCodec.readComponent-mnbipxy4 and push.