⚡️ Speed up method IndexBuffer.createIndexBuffer by 6%

[codeflash-ai]

📄 6% (0.06x) speedup for IndexBuffer.createIndexBuffer in jme3-core/src/main/java/com/jme3/scene/mesh/IndexBuffer.java

⏱️ Runtime : 421 microseconds → 395 microseconds (best of 109 runs)

📝 Explanation and details

The optimized code changes the threshold checks from vertexCount < 128 to vertexCount <= 256 and from vertexCount < 65536 to vertexCount <= 65536, exploiting the full unsigned range of byte (0–255) and short (0–65535) index types. This reduces unnecessary promotions to wider types: meshes with up to 256 vertices now use 1-byte indices instead of 2-byte shorts, and meshes with exactly 65536 vertices use 2-byte shorts instead of 4-byte ints, cutting memory overhead and improving cache locality. The change also removes a redundant Math.max(0, vertexCount - 1) call in the byte-buffer branch and normalizes the maxIndexValue calculation across branches. Runtime improved by 6% (421 µs → 395 µs) due to these tighter type selections and the elimination of the branch-dependent max operation.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 19 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.scene.mesh;

import org.junit.Test;
import org.junit.Before;
import static org.junit.Assert.*;

public class IndexBufferTest {

    private IndexBuffer defaultBuffer;

    @Before
    public void setUp() {
        // Create a typical small index buffer to be available for tests that may use it.
        // This also demonstrates creating an IndexBuffer instance via the factory.
        defaultBuffer = IndexBuffer.createIndexBuffer(10, 5);
    }

    @Test
    public void testCreateIndexBuffer_SmallVertexCount_ReturnsByteBuffer() {
        IndexBuffer buf = IndexBuffer.createIndexBuffer(10, 5);
        // Expect a byte-backed index buffer for vertexCount < 128
    }

    @Test
    public void testCreateIndexBuffer_MidVertexCount_ReturnsShortBuffer() {
        IndexBuffer buf = IndexBuffer.createIndexBuffer(1000, 10);
        // Expect a short-backed index buffer for 128 <= vertexCount < 65536
    }

    @Test
    public void testCreateIndexBuffer_LargeVertexCount_ReturnsIntBuffer() {
        IndexBuffer buf = IndexBuffer.createIndexBuffer(70000, 50);
        // Expect an int-backed index buffer for vertexCount >= 65536
    }

    @Test
    public void testCreateIndexBuffer_Boundary127_ReturnsByteBuffer() {
        IndexBuffer buf = IndexBuffer.createIndexBuffer(127, 1);
        // 127 is strictly less than 128 -> byte buffer
    }

    @Test
    public void testCreateIndexBuffer_Boundary128_ReturnsShortBuffer() {
        IndexBuffer buf = IndexBuffer.createIndexBuffer(128, 1);
        // 128 is not less than 128 -> falls into short buffer branch
    }

    @Test
    public void testCreateIndexBuffer_Boundary65535_ReturnsShortBuffer() {
        IndexBuffer buf = IndexBuffer.createIndexBuffer(65535, 2);
        // 65535 < 65536 -> short buffer
    }

    @Test
    public void testCreateIndexBuffer_Boundary65536_ReturnsIntBuffer() {
        IndexBuffer buf = IndexBuffer.createIndexBuffer(65536, 2);
        // 65536 is not less than 65536 -> int buffer
    }

    @Test
    public void testCreateIndexBuffer_NegativeVertexCount_HandledAsByteBuffer() {
        IndexBuffer buf = IndexBuffer.createIndexBuffer(-5, 3);
        // negative vertexCount is < 128, so it should produce a byte-backed buffer
    }

    @Test
    public void testCreateIndexBuffer_ZeroIndexCount_CreatesBuffer() {
        IndexBuffer buf = IndexBuffer.createIndexBuffer(10, 0);
        // Should still create a buffer (capacity 0 is allowed)
    }

    @Test(expected = IllegalArgumentException.class)
    public void testCreateIndexBuffer_NegativeIndexCount_ThrowsException() {
        // indexCount < 0 should cause the underlying buffer allocation to fail.
        // Expect IllegalArgumentException (common for negative allocation sizes).
        IndexBuffer.createIndexBuffer(10, -1);
    }

    @Test
    public void testCreateIndexBuffer_LargeIndexCount_PerformanceAndType() {
        // Large but reasonable index count to verify the method handles larger allocations
        // without excessive resource usage in a unit test environment.
        IndexBuffer buf = IndexBuffer.createIndexBuffer(70000, 200_000);
    }
}

package com.jme3.scene.mesh;

import org.junit.Test;
import org.junit.Before;
import static org.junit.Assert.*;

import java.lang.reflect.Field;
import java.nio.Buffer;

import com.jme3.scene.mesh.IndexBuffer;

/**
 * Unit tests for IndexBuffer.createIndexBuffer(...) behavior.
 *
 * These tests focus on:
 * - selecting the correct concrete Index*Buffer implementation
 * - verifying the underlying buffer capacity matches the requested indexCount
 * - boundary conditions around the selection thresholds
 * - error behavior for invalid indexCount values
 *
 * Note: reflection is used only to obtain the internally stored Buffer instance
 * from the concrete Index*Buffer returned by the factory so we can assert its capacity.
 */
public class IndexBufferTest_2 {

    // Provide a sample instance created in @Before as requested.
    // This instance is used only for having a readily available IndexBuffer.
    private IndexBuffer instance;

    @Before
    public void setUp() {
        // Typical small example: vertexCount < 128 -> should produce a byte-based index buffer
        instance = IndexBuffer.createIndexBuffer(10, 3);
    }

    // Helper to find the first Buffer-typed field in the concrete Index*Buffer using reflection.
    private Buffer findUnderlyingBuffer(IndexBuffer ib) {
        Field[] fields = ib.getClass().getDeclaredFields();
        for (Field f : fields) {
            if (Buffer.class.isAssignableFrom(f.getType())) {
                f.setAccessible(true);
                try {
                    Object val = f.get(ib);
                    if (val instanceof Buffer) {
                        return (Buffer) val;
                    }
                } catch (IllegalAccessException e) {
                    // fall through and continue searching other fields
                }
            }
        }
        // If not found on declared fields, search superclass fields (defensive)
        Class<?> cls = ib.getClass().getSuperclass();
        while (cls != null) {
            Field[] supFields = cls.getDeclaredFields();
            for (Field f : supFields) {
                if (Buffer.class.isAssignableFrom(f.getType())) {
                    f.setAccessible(true);
                    try {
                        Object val = f.get(ib);
                        if (val instanceof Buffer) {
                            return (Buffer) val;
                        }
                    } catch (IllegalAccessException e) {
                        // continue search
                    }
                }
            }
            cls = cls.getSuperclass();
        }
        fail("No Buffer field found in instance of " + ib.getClass().getName());
        return null; // unreachable, but required by compiler
    }

    @Test
    public void testCreateIndexBuffer_TypicalSmallVertexCount_ReturnsIndexByteBuffer() {
        // The instance created in setUp uses vertexCount=10 (<128) -> expects IndexByteBuffer
    }

    @Test
    public void testCreateIndexBuffer_VerifyCapacityForZeroIndexCount() {
        // indexCount = 0 should create a buffer with capacity 0
        IndexBuffer ib = IndexBuffer.createIndexBuffer(5, 0); // small vertexCount -> byte buffer
        Buffer buf = findUnderlyingBuffer(ib);
    }

    @Test
    public void testCreateIndexBuffer_Boundary127_ReturnsByteBuffer() {
        // vertexCount = 127 -> still in first branch (<128)
        IndexBuffer ib = IndexBuffer.createIndexBuffer(127, 7);
    }

    @Test
    public void testCreateIndexBuffer_Boundary128_ReturnsShortBuffer() {
        // vertexCount = 128 -> first branch false, second branch true (<65536)
        IndexBuffer ib = IndexBuffer.createIndexBuffer(128, 9);
    }

    @Test
    public void testCreateIndexBuffer_Boundary65535_ReturnsShortBuffer() {
        // vertexCount = 65535 -> still short
        IndexBuffer ib = IndexBuffer.createIndexBuffer(65535, 11);
    }

    @Test
    public void testCreateIndexBuffer_Boundary65536_ReturnsIntBuffer() {
        // vertexCount = 65536 -> should use IntBuffer (third branch)
        IndexBuffer ib = IndexBuffer.createIndexBuffer(65536, 13);
    }

    @Test
    public void testCreateIndexBuffer_NegativeVertexCount_TreatedAsSmall_ReturnsByteBuffer() {
        // A negative vertexCount will satisfy the first condition (vertexCount < 128)
        IndexBuffer ib = IndexBuffer.createIndexBuffer(-5, 4);
        // underlying buffer capacity should match indexCount
        Buffer buf = findUnderlyingBuffer(ib);
    }

    @Test(expected = IllegalArgumentException.class)
    public void testCreateIndexBuffer_NegativeIndexCount_ThrowsIllegalArgumentException() {
        // Negative indexCount should cause the underlying Buffer allocation to fail.
        // The BufferUtils allocator is expected to throw IllegalArgumentException for negative capacity.
        IndexBuffer.createIndexBuffer(10, -1);
    }

    @Test
    public void testCreateIndexBuffer_LargeVertexCount_ProducesIntBufferWithCorrectCapacity() {
        // Large vertexCount (> 65536) should produce an IndexIntBuffer
        int vertexCount = 70000;
        int indexCount = 10000;
        IndexBuffer ib = IndexBuffer.createIndexBuffer(vertexCount, indexCount);

        Buffer buf = findUnderlyingBuffer(ib);
    }

    @Test
    public void testSetUpInstance_IsUsableAndByteBufferBacked() {
        // verify the instance created in setUp is byte-backed and buffer capacity as requested (3)
        Buffer buf = findUnderlyingBuffer(instance);
    }
}

To edit these changes git checkout codeflash/optimize-IndexBuffer.createIndexBuffer-mnblrltk and push.