perf: hot-path optimizations in ALP/Dict/Bitpacked codecs

- AlpCodec: precompute single factor (1 FP mult/elem vs 2), strength-reduce loop offset, Math.toIntExact for 2GB safety
- DictCodec: loop-unswitch codePType outside expand loop; three type-specific expandU8/U16/U32 with running outOff counter; Math.toIntExact
- BitpackedCodec: running blockByteOff counter; hoist per-row invariants (o, s, baseIdx, wordBase, hiBase, loMask, hiMask) above lane loop

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: dfa1

core/src/main/java/io/github/dfa1/vortex/encoding/AlpCodec.java

@@ -90,16 +90,17 @@ private Array decodeF64(DecodeContext ctx, EncodingProtos.ALPMetadata meta, int
         DType encodedDtype = new DType.Primitive(PType.I64, false);
         Array encoded = decodeChildAs(ctx, 0, encodedDtype, n);
 
-        double f10 = F10_F64[expF];
-        double if10 = IF10_F64[expE];
+        // Precompute single factor — avoids 2 FP mults per element in the hot loop.
+        double factor = F10_F64[expF] * IF10_F64[expE];
 
-        byte[] outBytes = new byte[(int) (n * 8)];
+        byte[] outBytes = new byte[Math.toIntExact(n * 8)];
         ByteBuffer out = ByteBuffer.wrap(outBytes).order(ByteOrder.LITTLE_ENDIAN);
         var srcLayout = ValueLayout.JAVA_LONG_UNALIGNED.withOrder(ByteOrder.LITTLE_ENDIAN);
         MemorySegment src = encoded.buffer(0);
-        for (long i = 0; i < n; i++) {
-            long   encVal = src.get(srcLayout, i * 8);
-            double dec    = (double) encVal * f10 * if10;
+        // Strength-reduce: running byte offset instead of i*8 per iteration.
+        for (long off = 0, end = n * 8; off < end; off += 8) {
+            long   encVal = src.get(srcLayout, off);
+            double dec    = (double) encVal * factor;
             out.putDouble(dec);
         }
 
@@ -143,16 +144,15 @@ private Array decodeF32(DecodeContext ctx, EncodingProtos.ALPMetadata meta, int
         DType encodedDtype = new DType.Primitive(PType.I32, false);
         Array encoded = decodeChildAs(ctx, 0, encodedDtype, n);
 
-        float f10  = F10_F32[expF];
-        float if10 = IF10_F32[expE];
+        float factor = F10_F32[expF] * IF10_F32[expE];
 
-        byte[] outBytes = new byte[(int) (n * 4)];
+        byte[] outBytes = new byte[Math.toIntExact(n * 4)];
         ByteBuffer out = ByteBuffer.wrap(outBytes).order(ByteOrder.LITTLE_ENDIAN);
         var srcLayout = ValueLayout.JAVA_INT_UNALIGNED.withOrder(ByteOrder.LITTLE_ENDIAN);
         MemorySegment src = encoded.buffer(0);
-        for (long i = 0; i < n; i++) {
-            int   encVal = src.get(srcLayout, i * 4);
-            float dec    = (float) encVal * f10 * if10;
+        for (long off = 0, end = n * 4; off < end; off += 4) {
+            int   encVal = src.get(srcLayout, off);
+            float dec    = (float) encVal * factor;
             out.putFloat(dec);
         }
 

core/src/main/java/io/github/dfa1/vortex/encoding/BitpackedCodec.java

@@ -184,9 +184,10 @@ private static long[] fastlanesUnpack(
         int  blockCount = (int) ((totalElems + 1023) / 1024);
         long bitMask    = bitWidth == 64 ? -1L : (1L << bitWidth) - 1L;
 
-        for (int block = 0; block < blockCount; block++) {
-            long blockByteOff    = (long) block * 128L * bitWidth;
-            int  blockLogicStart = block * 1024 - offset;
+        long blockByteOff    = 0L;
+        long blockByteStride = 128L * bitWidth;
+        for (int block = 0; block < blockCount; block++, blockByteOff += blockByteStride) {
+            int blockLogicStart = block * 1024 - offset;
 
             for (int row = 0; row < typeBits; row++) {
                 int currWord      = (row * bitWidth) / typeBits;
@@ -195,25 +196,30 @@ private static long[] fastlanesUnpack(
                 int remainingBits = (nextWord > currWord) ? ((row + 1) * bitWidth) % typeBits : 0;
                 int currentBits   = bitWidth - remainingBits;
 
+                // Hoist per-row invariants above the lane loop.
+                int  o        = row / 8;
+                int  s        = row % 8;
+                int  baseIdx  = blockLogicStart + FL_ORDER[o] * 16 + s * 128;
+                long wordBase = blockByteOff + (long) (LANES * currWord) * wordBytes;
+                long hiBase   = (remainingBits > 0)
+                    ? blockByteOff + (long) (LANES * nextWord) * wordBytes : 0L;
+                long loMask   = (remainingBits > 0) ? (1L << currentBits) - 1L : 0L;
+                long hiMask   = (remainingBits > 0) ? (1L << remainingBits) - 1L : 0L;
+
                 for (int lane = 0; lane < LANES; lane++) {
-                    int o = row / 8;
-                    int s = row % 8;
-                    int logicalIdx = blockLogicStart + FL_ORDER[o] * 16 + s * 128 + lane;
+                    int logicalIdx = baseIdx + lane;
 
                     if (logicalIdx < 0 || logicalIdx >= rowCount) {
                         continue;
                     }
 
-                    long wordOff = blockByteOff + (long) (LANES * currWord + lane) * wordBytes;
+                    long wordOff = wordBase + (long) lane * wordBytes;
                     long src     = readWordFromSeg(buf, wordOff, typeBits);
 
                     long value;
                     if (remainingBits > 0) {
-                        long loMask = (1L << currentBits) - 1L;
-                        long lo     = (src >>> shift) & loMask;
-                        long hiOff  = blockByteOff + (long) (LANES * nextWord + lane) * wordBytes;
-                        long hi     = readWordFromSeg(buf, hiOff, typeBits)
-                                      & ((1L << remainingBits) - 1L);
+                        long lo = (src >>> shift) & loMask;
+                        long hi = readWordFromSeg(buf, hiBase + (long) lane * wordBytes, typeBits) & hiMask;
                         value = lo | (hi << currentBits);
                     } else {
                         value = (src >>> shift) & bitMask;

core/src/main/java/io/github/dfa1/vortex/encoding/DictCodec.java

@@ -140,11 +140,15 @@ private Array decodeRustProto(DecodeContext ctx, byte[] metaBytes) {
         MemorySegment codesBuf  = codesArr.buffer(0);
         MemorySegment valuesBuf = valuesArr.buffer(0);
 
-        byte[] expanded = new byte[(int) (rowCount * elemSize)];
+        byte[] expanded = new byte[Math.toIntExact(rowCount * elemSize)];
         MemorySegment out = MemorySegment.ofArray(expanded);
-        for (long i = 0; i < rowCount; i++) {
-            long code = readCode(codesBuf, codePType, i);
-            MemorySegment.copy(valuesBuf, code * elemSize, out, i * elemSize, elemSize);
+        // Loop-unswitch: pull the codePType switch outside the hot loop so the JIT
+        // sees a tight, type-specific loop with predictable branches.
+        switch (codePType) {
+            case U8 -> expandU8(codesBuf, valuesBuf, out, rowCount, elemSize);
+            case U16 -> expandU16(codesBuf, valuesBuf, out, rowCount, elemSize);
+            case U32 -> expandU32(codesBuf, valuesBuf, out, rowCount, elemSize);
+            default  -> throw new IllegalStateException("unexpected code type: " + codePType);
         }
         return new Array(ctx.dtype(), rowCount, new MemorySegment[]{out}, new Array[0], ArrayStats.empty());
     }
@@ -209,6 +213,38 @@ private static void writeCode(ByteBuffer buf, PType codePType, int code) {
         }
     }
 
+    private static void expandU8(
+        MemorySegment codes, MemorySegment values, MemorySegment out,
+        long rowCount, int elemSize
+    ) {
+        for (long i = 0, outOff = 0; i < rowCount; i++, outOff += elemSize) {
+            long code = Byte.toUnsignedLong(codes.get(ValueLayout.JAVA_BYTE, i));
+            MemorySegment.copy(values, code * elemSize, out, outOff, elemSize);
+        }
+    }
+
+    private static void expandU16(
+        MemorySegment codes, MemorySegment values, MemorySegment out,
+        long rowCount, int elemSize
+    ) {
+        var layout = ValueLayout.JAVA_SHORT_UNALIGNED.withOrder(ByteOrder.LITTLE_ENDIAN);
+        for (long i = 0, outOff = 0; i < rowCount; i++, outOff += elemSize) {
+            long code = Short.toUnsignedLong(codes.get(layout, i * 2));
+            MemorySegment.copy(values, code * elemSize, out, outOff, elemSize);
+        }
+    }
+
+    private static void expandU32(
+        MemorySegment codes, MemorySegment values, MemorySegment out,
+        long rowCount, int elemSize
+    ) {
+        var layout = ValueLayout.JAVA_INT_UNALIGNED.withOrder(ByteOrder.LITTLE_ENDIAN);
+        for (long i = 0, outOff = 0; i < rowCount; i++, outOff += elemSize) {
+            long code = Integer.toUnsignedLong(codes.get(layout, i * 4));
+            MemorySegment.copy(values, code * elemSize, out, outOff, elemSize);
+        }
+    }
+
     private static long readCode(MemorySegment buf, PType codePType, long i) {
         return switch (codePType) {
             case U8  -> Byte.toUnsignedLong(buf.get(ValueLayout.JAVA_BYTE, i));