perf(glsm): upload only the vertex range a client-array draw actually reads

Root cause of the F3/GUI FPS collapse (140+ -> 15 fps with the debug
overlay open, sluggish inventory/video-settings screens): 2f54db7 widened
captured client pointers to the whole underlying allocation to stay
correct when HBM-CE mutates the BufferBuilder limit after setting a
pointer. uploadClientArraysToVBO then re-uploaded that entire allocation
(>4MB observed, ~1.1ms per upload on PCIe) on EVERY draw issued while a
mod leaves client-state attribs enabled. Text/rect-heavy GUI frames issue
hundreds of draws, multiplying this into ~57ms/frame.

glDrawArrays (and the QUADS path through QuadConverter, whose shared EBO
references exactly [first, first+count)) knows the drawn vertex range, so
per-attrib uploads are now clamped to the bytes that range can read via
VertexAttribState.computeUploadLength; indexed draws with an unknown max
index keep the full-allocation upload. Escape hatch:
-Dactinium.glsmFullClientArrayUpload=true.

Also adds clientArray.stackSample caller attribution to the periodic GLSM
perf report to identify which mod drives large uploads.

Author: DHJComical

glsm/src/main/java/com/gtnewhorizons/angelica/glsm/GLStateManager.java

@@ -126,6 +126,8 @@ public class GLStateManager {
 
     public static final Logger LOGGER = LogManager.getLogger("GLSM");
     private static final boolean DEBUG_DRAW_LOGS = Boolean.getBoolean("actinium.glsm.verboseDrawLogs");
+    /** Escape hatch: -Dactinium.glsmFullClientArrayUpload=true restores whole-allocation uploads per draw. */
+    private static final boolean FULL_CLIENT_ARRAY_UPLOAD = Boolean.getBoolean("actinium.glsmFullClientArrayUpload");
 
     // Thread Checking - must be early in static init order so isMainThread() works for state initialization
     @Getter private static final Thread MainThread = Thread.currentThread();
@@ -434,6 +436,7 @@ public static void registerModifiedState(IStateStack<?> stack) {
     private static int clientArraysVBO = 0;
     private static int clientArraysVBOCapacity = 0;
     private static final int[] clientArraysVBOOffsets = new int[VertexAttribState.MAX_ATTRIBS];
+    private static final int[] clientArraysVBOUploadLengths = new int[VertexAttribState.MAX_ATTRIBS];
     private static int boundPixelUnpackBuffer;
     private static int boundPixelPackBuffer;
     private static final Int2IntOpenHashMap vaoEboMap = new Int2IntOpenHashMap();
@@ -2517,7 +2520,7 @@ public static void glDrawElementsInstanced(int mode, int count, int type, long i
     public static void glDrawArraysInstanced(int mode, int first, int count, int primcount) {
         prepareWideLineEmulation(mode);
         preDrawFFP();
-        prepareClientArrays();
+        prepareClientArrays(first, count);
         recordGpuCommand(GpuCommandType.DRAW_ARRAYS, mode, count);
         if (mode == GL11.GL_QUADS) {
             QuadConverter.drawQuadsAsTrianglesInstanced(first, count, primcount);
@@ -2548,30 +2551,42 @@ private static void preDrawFFP() {
     }
 
     private static void prepareClientArrays() {
+        prepareClientArrays(0, -1);
+    }
+
+    private static void prepareClientArrays(int first, int count) {
         final boolean perfDebugEnabled = GLSMPerfDebug.isEnabled();
         final long perfStart = perfDebugEnabled ? GLSMPerfDebug.begin(GLSMPerfDebug.Stage.GL_PREPARE_CLIENT_ARRAYS) : 0L;
         if (ShaderManager.getInstance().isEnabled() && VertexAttribState.hasAnyClientSideEnabledAttrib()) {
-            uploadClientArraysToVBO();
+            uploadClientArraysToVBO(first, count);
         }
         if (perfDebugEnabled) {
             GLSMPerfDebug.end(GLSMPerfDebug.Stage.GL_PREPARE_CLIENT_ARRAYS, perfStart);
         }
     }
 
     /**
-     * If any enabled vertex attribute uses a client-side pointer (no VBO), upload all such
-     * attribs into a shared stream VBO so the draw succeeds under core profile.
+     * If any enabled vertex attribute uses a client-side pointer (no VBO), upload such attribs
+     * into a shared stream VBO so the draw succeeds under core profile. When the draw's vertex
+     * range [first, first + count) is known (count >= 0), each attrib is narrowed to the bytes
+     * that range can actually read; the captured client pointer spans the whole underlying
+     * allocation, which can be megabytes larger than one draw needs. Indexed draws with an
+     * unknown maximum index pass count = -1 and keep the full-allocation upload.
      */
-    private static void uploadClientArraysToVBO() {
+    private static void uploadClientArraysToVBO(int first, int count) {
         final boolean perfDebugEnabled = GLSMPerfDebug.isEnabled();
         final long perfStart = perfDebugEnabled ? GLSMPerfDebug.begin(GLSMPerfDebug.Stage.GL_CLIENT_ARRAY_UPLOAD) : 0L;
+        final boolean fullUpload = FULL_CLIENT_ARRAY_UPLOAD || count < 0;
         int totalBytes = 0;
         for (int i = 0; i < VertexAttribState.MAX_ATTRIBS; i++) {
             clientArraysVBOOffsets[i] = -1;
             final VertexAttribState.Attrib a = VertexAttribState.get(i);
             if (!a.enabled || a.clientPointer == null) continue;
+            final int uploadLength = fullUpload ? a.clientPointer.remaining()
+                : VertexAttribState.computeUploadLength(a, first, count);
+            clientArraysVBOUploadLengths[i] = uploadLength;
             clientArraysVBOOffsets[i] = totalBytes;
-            totalBytes += a.clientPointer.remaining();
+            totalBytes += uploadLength;
         }
         if (totalBytes == 0) {
             if (perfDebugEnabled) {
@@ -2600,13 +2615,16 @@ private static void uploadClientArraysToVBO() {
         for (int i = 0; i < VertexAttribState.MAX_ATTRIBS; i++) {
             if (clientArraysVBOOffsets[i] < 0) continue;
             final VertexAttribState.Attrib a = VertexAttribState.get(i);
-            RENDER_BACKEND.bufferSubData(GL15.GL_ARRAY_BUFFER, clientArraysVBOOffsets[i], a.clientPointer.duplicate());
+            final ByteBuffer slice = a.clientPointer.duplicate();
+            slice.limit(slice.position() + clientArraysVBOUploadLengths[i]);
+            RENDER_BACKEND.bufferSubData(GL15.GL_ARRAY_BUFFER, clientArraysVBOOffsets[i], slice);
             RENDER_BACKEND.vertexAttribPointer(i, a.size, a.type, a.normalized, a.stride, (long) clientArraysVBOOffsets[i]);
         }
 
         glBindBuffer(GL15.GL_ARRAY_BUFFER, savedVBO);
         if (perfDebugEnabled) {
             GLSMPerfDebug.end(GLSMPerfDebug.Stage.GL_CLIENT_ARRAY_UPLOAD, perfStart);
+            GLSMPerfDebug.countClientArrayUpload(totalBytes);
         }
     }
 
@@ -2628,7 +2646,7 @@ public static void glDrawArrays(int mode, int first, int count) {
         }
         prepareWideLineEmulation(mode);
         preDrawFFP();
-        prepareClientArrays();
+        prepareClientArrays(first, count);
         if (DEBUG_DRAW_LOGS) {
             GLSMDebug.logDrawArrays("draw-arrays", mode, first, count);
         }

glsm/src/main/java/com/gtnewhorizons/angelica/glsm/debug/GLSMPerfDebug.java

@@ -12,6 +12,7 @@ public final class GLSMPerfDebug {
     private static final long REPORT_INTERVAL_NS = 1_000_000_000L;
     private static final int SAMPLE_MASK = 255;
     private static final int MAX_BUFFERBUILDER_SOURCE_LINES = 12;
+    private static final int MAX_CLIENT_ARRAY_STACK_LINES = 12;
     private static final String ENABLED_OVERRIDE = System.getProperty("actinium.glsmPerfDebug");
     private static volatile boolean enabled = resolveEnabled(ENABLED_OVERRIDE, false);
 
@@ -71,6 +72,7 @@ public enum Source {
     private static final int[] sourceCounts = new int[Source.values().length];
     private static final Map<String, Integer> bufferBuilderSourceCounts = new HashMap<>();
     private static final Map<String, Integer> bufferBuilderStackSamples = new HashMap<>();
+    private static final Map<String, Integer> clientArrayStackSamples = new HashMap<>();
     private static long fenceReclaimedBytes;
     private static int fenceReclaimedRegions;
     private static int fenceQueuePeak;
@@ -110,6 +112,7 @@ private static void resetStats() {
         Arrays.fill(sourceCounts, 0);
         bufferBuilderSourceCounts.clear();
         bufferBuilderStackSamples.clear();
+        clientArrayStackSamples.clear();
         fenceReclaimedBytes = 0L;
         fenceReclaimedRegions = 0;
         fenceQueuePeak = 0;
@@ -150,6 +153,20 @@ public static void countBufferBuilder(String source, int drawMode, int vertexCou
         }
     }
 
+    /**
+     * Attributes a client-array VBO upload to its draw-call origin. Sampled at the same cadence
+     * as the stage timer; the key carries the first non-glsm caller and a power-of-two bucket of
+     * the uploaded byte total, so the periodic report shows who drives large uploads.
+     */
+    public static void countClientArrayUpload(int totalBytes) {
+        if (!isEnabled()) return;
+        final int observed = observedCounts[Stage.GL_CLIENT_ARRAY_UPLOAD.ordinal()];
+        if ((observed & SAMPLE_MASK) == 0) {
+            final String stackKey = findClientArrayCaller() + "/bytes~" + bucketVertexCount(totalBytes);
+            clientArrayStackSamples.put(stackKey, clientArrayStackSamples.getOrDefault(stackKey, 0) + 1);
+        }
+    }
+
     public static void recordFenceReclaim(int bytes) {
         fenceReclaimedRegions++;
         fenceReclaimedBytes += bytes;
@@ -228,6 +245,7 @@ private static void report(long now) {
         }
         appendTopEntries(sb, "bufferbuilder.source", bufferBuilderSourceCounts, MAX_BUFFERBUILDER_SOURCE_LINES);
         appendTopEntries(sb, "bufferbuilder.stackSample", bufferBuilderStackSamples, MAX_BUFFERBUILDER_SOURCE_LINES);
+        appendTopEntries(sb, "clientArray.stackSample", clientArrayStackSamples, MAX_CLIENT_ARRAY_STACK_LINES);
         if (fenceReclaimedRegions != 0 || fenceQueuePeak != 0) {
             sb.append(" stream.fence[")
                 .append("reclaimedRegions=").append(fenceReclaimedRegions)
@@ -298,6 +316,28 @@ private static boolean isBufferBuilderBridge(String className, String methodName
             && (methodName.equals("draw") || methodName.startsWith("handler$"));
     }
 
+    /**
+     * Like {@link #findBufferBuilderCaller()} but additionally skips all glsm frames: the
+     * client-array upload is triggered from GLStateManager draw entry points, so the first
+     * interesting frame is the Minecraft/mod code that issued the draw.
+     */
+    private static String findClientArrayCaller() {
+        StackTraceElement[] stack = Thread.currentThread().getStackTrace();
+        for (StackTraceElement element : stack) {
+            String className = element.getClassName();
+            if (className.startsWith("com.gtnewhorizons.angelica.glsm.")
+                || className.startsWith("com.dhj.actinium.render.")
+                || className.startsWith("com.dhj.actinium.mixin.vintage.core.")
+                || className.startsWith("org.taumc.celeritas.impl.render.")
+                || className.startsWith("org.taumc.celeritas.mixin.core.")
+                || className.equals("java.lang.Thread")) {
+                continue;
+            }
+            return shortenClassName(className) + "#" + element.getMethodName();
+        }
+        return "unknown";
+    }
+
     private static String shortenClassName(String className) {
         int index = className.lastIndexOf('.');
         return index >= 0 ? className.substring(index + 1) : className;

glsm/src/main/java/com/gtnewhorizons/angelica/glsm/states/VertexAttribState.java

@@ -101,6 +101,25 @@ public static Attrib get(int index) {
         return current[index];
     }
 
+    /**
+     * Computes how many leading bytes of {@code a.clientPointer} a draw over vertices
+     * [first, first + count) can actually read. The captured pointer deliberately spans the
+     * whole underlying allocation (mods like HBM-CE mutate the Java limit after setting the
+     * pointer), so the Java limit is never consulted; only the draw's first/count may narrow
+     * the range. The last read byte of the final vertex is (first + count - 1) * stride +
+     * vertexSize - 1, which stays correct even for stride smaller than the vertex size.
+     * Negative strides read backwards from the pointer, so they fall back to the full
+     * captured range. The result is always clamped to the captured allocation.
+     */
+    public static int computeUploadLength(Attrib a, int first, int count) {
+        final int remaining = a.clientPointer.remaining();
+        if (count <= 0) return 0;
+        if (a.stride < 0) return remaining;
+        final int stride = a.stride > 0 ? a.stride : a.size * a.typeSizeBytes();
+        final long lastByteExclusive = (long) (first + count - 1) * stride + (long) a.size * a.typeSizeBytes();
+        return (int) Math.min(remaining, lastByteExclusive);
+    }
+
     /**
      * Captures the native pointer address without treating the Java buffer limit as its GL
      * allocation boundary. HBM reuses a BufferBuilder allocation and changes its limit between

src/test/java/com/gtnewhorizons/angelica/glsm/states/VertexAttribUploadLengthTest.java

@@ -0,0 +1,80 @@
+package com.gtnewhorizons.angelica.glsm.states;
+
+import org.junit.jupiter.api.Test;
+import org.lwjgl.opengl.GL11;
+
+import java.nio.ByteBuffer;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class VertexAttribUploadLengthTest {
+    private static VertexAttribState.Attrib attrib(int size, int type, int stride, int bufferBytes) {
+        final VertexAttribState.Attrib a = new VertexAttribState.Attrib();
+        a.size = size;
+        a.type = type;
+        a.stride = stride;
+        a.clientPointer = ByteBuffer.allocate(bufferBytes);
+        return a;
+    }
+
+    @Test
+    void tightlyPackedFloatPosition() {
+        // stride=0 means tightly packed: 3 floats = 12 bytes per vertex; [0, 100) reads 1200 bytes.
+        assertEquals(1200, VertexAttribState.computeUploadLength(attrib(3, GL11.GL_FLOAT, 0, 4096), 0, 100));
+    }
+
+    @Test
+    void explicitStrideCoversWholeVertices() {
+        // stride=32 with a 12-byte vertex: last vertex of [0, 100) ends at 99*32+12 = 3180.
+        assertEquals(3180, VertexAttribState.computeUploadLength(attrib(3, GL11.GL_FLOAT, 32, 8192), 0, 100));
+    }
+
+    @Test
+    void nonZeroFirstStillUploadsFromAllocationStart() {
+        // QUADS-as-triangles style range [16, 20): bytes up to (16+4-1)*12+12 = 240 are needed.
+        assertEquals(240, VertexAttribState.computeUploadLength(attrib(3, GL11.GL_FLOAT, 0, 4096), 16, 4));
+    }
+
+    @Test
+    void hugeAllocationShrinksToDrawRange() {
+        // The HBM-CE case: a 4.2MB reused allocation, a 4-vertex GUI draw reads only 48 bytes.
+        assertEquals(48, VertexAttribState.computeUploadLength(attrib(3, GL11.GL_FLOAT, 0, 4_200_768), 0, 4));
+    }
+
+    @Test
+    void clampedToCapturedAllocation() {
+        assertEquals(1024, VertexAttribState.computeUploadLength(attrib(3, GL11.GL_FLOAT, 0, 1024), 0, 10000));
+    }
+
+    @Test
+    void respectsBufferPosition() {
+        final VertexAttribState.Attrib a = attrib(3, GL11.GL_FLOAT, 0, 4096);
+        a.clientPointer.position(1024);
+        assertEquals(1200, VertexAttribState.computeUploadLength(a, 0, 100));
+        assertEquals(3072, VertexAttribState.computeUploadLength(a, 0, 1000));
+    }
+
+    @Test
+    void zeroCountUploadsNothing() {
+        assertEquals(0, VertexAttribState.computeUploadLength(attrib(3, GL11.GL_FLOAT, 0, 4096), 0, 0));
+    }
+
+    @Test
+    void byteAndShortTypes() {
+        // RGBA color as 4 unsigned bytes: 4 bytes per vertex.
+        assertEquals(400, VertexAttribState.computeUploadLength(attrib(4, GL11.GL_UNSIGNED_BYTE, 0, 4096), 0, 100));
+        // 2 shorts = 4-byte vertex, stride=8, range [2, 12): (2+10-1)*8+4 = 92.
+        assertEquals(92, VertexAttribState.computeUploadLength(attrib(2, GL11.GL_SHORT, 8, 4096), 2, 10));
+    }
+
+    @Test
+    void narrowStrideKeepsLastVertexCovered() {
+        // stride=8 < 12-byte vertex: the last vertex's tail must still be uploaded.
+        assertEquals(11 * 8 + 12, VertexAttribState.computeUploadLength(attrib(3, GL11.GL_FLOAT, 8, 4096), 0, 12));
+    }
+
+    @Test
+    void negativeStrideFallsBackToFullAllocation() {
+        assertEquals(4096, VertexAttribState.computeUploadLength(attrib(3, GL11.GL_FLOAT, -1, 4096), 0, 4));
+    }
+}