From c1109a7f0a868eaf31dc5a57b17eea91750c2379 Mon Sep 17 00:00:00 2001
From: Prateek Gaur <prateek.gaur@snowflake.com>
Date: Sat, 3 Oct 2026 03:11:38 +0000
Subject: [PATCH 01/27] Fold frame bias into bit unpacking

A frame-of-reference decoder adds the frame to every value right after
unpacking it. Doing that in a second pass reads and writes the whole
output again, so the scalar and SIMD unpackers now take an optional bias
and add it before each store. With no bias the existing paths are
unchanged, including the plain memcpy used when the bit width equals the
output width. The tests run the biased form across widths, offsets,
epilogues and every dispatched instruction set.
---
 cpp/src/arrow/util/bpacking.cc                |  32 +
 .../arrow/util/bpacking_dispatch_internal.h   | 602 ++++++++++--------
 cpp/src/arrow/util/bpacking_internal.h        |  25 +
 cpp/src/arrow/util/bpacking_scalar.cc         |  15 +
 cpp/src/arrow/util/bpacking_scalar_internal.h |  16 +
 cpp/src/arrow/util/bpacking_simd_128.cc       |  18 +
 cpp/src/arrow/util/bpacking_simd_128_alt.cc   |  17 +
 cpp/src/arrow/util/bpacking_simd_256.cc       |  18 +
 cpp/src/arrow/util/bpacking_simd_avx512.cc    |  15 +
 cpp/src/arrow/util/bpacking_simd_internal.h   |  72 +++
 .../util/bpacking_simd_kernel_internal.h      |  94 ++-
 cpp/src/arrow/util/bpacking_test.cc           | 157 +++++
 12 files changed, 790 insertions(+), 291 deletions(-)

diff --git a/cpp/src/arrow/util/bpacking.cc b/cpp/src/arrow/util/bpacking.cc
index 1bf81df4f28f..4a2ec0f9c059 100644
--- a/cpp/src/arrow/util/bpacking.cc
+++ b/cpp/src/arrow/util/bpacking.cc
@@ -43,6 +43,23 @@ struct UnpackDynamicFunction {
   }
 };
 
+template <typename Uint>
+struct UnpackBiasDynamicFunction {
+  using FunctionType = decltype(&bpacking::unpack_bias_scalar<Uint>);
+
+  static constexpr auto targets() {
+    return std::array{
+        ARROW_DISPATCH_TARGET_NONE(&bpacking::unpack_bias_scalar<Uint>)    //
+        ARROW_DISPATCH_TARGET_NEON(&bpacking::unpack_bias_neon<Uint>)      //
+        ARROW_DISPATCH_TARGET_SVE128(&bpacking::unpack_bias_sve128<Uint>)  //
+        ARROW_DISPATCH_TARGET_SVE256(&bpacking::unpack_bias_sve256<Uint>)  //
+        ARROW_DISPATCH_TARGET_SSE4_2(&bpacking::unpack_bias_sse4_2<Uint>)  //
+        ARROW_DISPATCH_TARGET_AVX2(&bpacking::unpack_bias_avx2<Uint>)      //
+        ARROW_DISPATCH_TARGET_AVX512(&bpacking::unpack_bias_avx512<Uint>)  //
+    };
+  }
+};
+
 }  // namespace
 
 template <typename Uint>
@@ -57,4 +74,19 @@ template void unpack<uint16_t>(const uint8_t*, uint16_t*, const UnpackOptions&);
 template void unpack<uint32_t>(const uint8_t*, uint32_t*, const UnpackOptions&);
 template void unpack<uint64_t>(const uint8_t*, uint64_t*, const UnpackOptions&);
 
+template <typename Uint>
+void unpack_bias(const uint8_t* in, Uint* out, const UnpackOptions& opts, Uint bias) {
+  static const DynamicDispatch<UnpackBiasDynamicFunction<Uint>> dispatch;
+  return dispatch(in, out, opts, bias);
+}
+
+template void unpack_bias<uint8_t>(const uint8_t*, uint8_t*, const UnpackOptions&,
+                                   uint8_t);
+template void unpack_bias<uint16_t>(const uint8_t*, uint16_t*, const UnpackOptions&,
+                                    uint16_t);
+template void unpack_bias<uint32_t>(const uint8_t*, uint32_t*, const UnpackOptions&,
+                                    uint32_t);
+template void unpack_bias<uint64_t>(const uint8_t*, uint64_t*, const UnpackOptions&,
+                                    uint64_t);
+
 }  // namespace arrow::internal
diff --git a/cpp/src/arrow/util/bpacking_dispatch_internal.h b/cpp/src/arrow/util/bpacking_dispatch_internal.h
index 6ea6adee1800..e89ccc9e8083 100644
--- a/cpp/src/arrow/util/bpacking_dispatch_internal.h
+++ b/cpp/src/arrow/util/bpacking_dispatch_internal.h
@@ -31,23 +31,52 @@
 namespace arrow::internal::bpacking {
 
 /// Unpack a zero bit packed array.
-template <typename Uint>
-ARROW_FORCE_INLINE void unpack_null(const uint8_t* in, Uint* out, int batch_size) {
-  std::memset(out, 0, batch_size * sizeof(Uint));
+template <bool kHasBias = false, typename Uint>
+ARROW_FORCE_INLINE void unpack_null(const uint8_t* in, Uint* out, int batch_size,
+                                    Uint bias = Uint{}) {
+  if constexpr (kHasBias) {
+    // Every unpacked value is zero, so every output value is the bias.
+    std::fill(out, out + batch_size, bias);
+  } else {
+    std::memset(out, 0, batch_size * sizeof(Uint));
+  }
 }
 
 /// Unpack a packed array where packed and unpacked values have exactly the same number of
 /// bits.
-template <typename Uint>
-ARROW_FORCE_INLINE void unpack_full(const uint8_t* in, Uint* out, int batch_size) {
+template <bool kHasBias = false, typename Uint>
+ARROW_FORCE_INLINE void unpack_full(const uint8_t* in, Uint* out, int batch_size,
+                                    Uint bias = Uint{}) {
   if constexpr (ARROW_LITTLE_ENDIAN == 1) {
-    std::memcpy(out, in, batch_size * sizeof(Uint));
+    if constexpr (kHasBias) {
+      // Two details let this loop approach memcpy speed:
+      //   1. A constant-size memcpy for the load, not SafeLoadAs: SafeLoadAs
+      //      builds an AlignedStorage per element and the vectorizer refuses it,
+      //      while a fixed-size memcpy is just an unaligned load.
+      //   2. A restrict qualifier: `in` is a uint8_t*, so it may alias
+      //      anything, including `out`. Without restating that they are
+      //      distinct the compiler has to assume overlap and emits a scalar
+      //      loop.
+      const uint8_t* ARROW_RESTRICT src = in;
+      Uint* ARROW_RESTRICT dst = out;
+      for (int k = 0; k < batch_size; k += 1) {
+        Uint val;
+        std::memcpy(&val, src + (k * sizeof(Uint)), sizeof(Uint));
+        dst[k] = static_cast<Uint>(val + bias);
+      }
+    } else {
+      std::memcpy(out, in, batch_size * sizeof(Uint));
+    }
   } else {
     using bit_util::FromLittleEndian;
     using util::SafeLoadAs;
 
     for (int k = 0; k < batch_size; k += 1) {
-      out[k] = FromLittleEndian(SafeLoadAs<Uint>(in + (k * sizeof(Uint))));
+      Uint val = FromLittleEndian(SafeLoadAs<Uint>(in + (k * sizeof(Uint))));
+      if constexpr (kHasBias) {
+        val = static_cast<Uint>(val + bias);
+      }
+      out[k] = val;
     }
   }
 }
@@ -96,9 +125,9 @@ using SpreadBufferUint = std::conditional_t<
 /// This function works for all input batch sizes but is not the fastest.
 /// In prolog mode, instead of unpacking all required element, the function will
 /// stop if it finds a byte aligned value start.
-template <int kPackedBitWidth, bool kIsProlog, typename Uint>
+template <int kPackedBitWidth, bool kIsProlog, bool kHasBias = false, typename Uint>
 ARROW_FORCE_INLINE int unpack_exact(const uint8_t* in, const uint8_t* in_end, Uint* out,
-                                    int batch_size, int bit_offset) {
+                                    int batch_size, int bit_offset, Uint bias = Uint{}) {
   static_assert(kPackedBitWidth > 0);
 
   // For the epilog we adapt the max spread since better alignment give shorter spreads
@@ -168,6 +197,9 @@ ARROW_FORCE_INLINE int unpack_exact(const uint8_t* in, const uint8_t* in_end, Ui
       }
     }
 
+    if constexpr (kHasBias) {
+      val = static_cast<Uint>(val + bias);
+    }
     *out = val;
     out++;
     start_bit += kPackedBitWidth;
@@ -190,12 +222,12 @@ ARROW_FORCE_INLINE int unpack_exact(const uint8_t* in, const uint8_t* in_end, Ui
 ///                       This is used to safely overread.
 ///                       Negative value to deduce from batch_size.
 template <int kPackedBitWidth, template <typename, int> typename Unpacker,
-          typename UnpackedUInt>
+          bool kHasBias = false, typename UnpackedUInt>
 void unpack_width(const uint8_t* in, UnpackedUInt* out, int batch_size, int bit_offset,
-                  int max_read_bytes) {
+                  int max_read_bytes, UnpackedUInt bias = UnpackedUInt{}) {
   if constexpr (kPackedBitWidth == 0) {
     // Easy case to handle, simply setting memory to zero.
-    return unpack_null(in, out, batch_size);
+    return unpack_null<kHasBias>(in, out, batch_size, bias);
   } else {
     // Number of bytes to read according to batch_size.
     const int bytes_batch = static_cast<int>(
@@ -206,8 +238,8 @@ void unpack_width(const uint8_t* in, UnpackedUInt* out, int batch_size, int bit_
     const uint8_t* in_end = in + (max_read_bytes >= 0 ? max_read_bytes : bytes_batch);
 
     // In case of misalignment, we need to run the prolog until aligned.
-    int extracted =
-        unpack_exact<kPackedBitWidth, true>(in, in_end, out, batch_size, bit_offset);
+    int extracted = unpack_exact<kPackedBitWidth, true, kHasBias>(
+        in, in_end, out, batch_size, bit_offset, bias);
     // We either extracted everything or found a alignment
     const int start_bit = extracted * kPackedBitWidth + bit_offset;
     ARROW_DCHECK((extracted == batch_size) || ((start_bit) % 8 == 0));
@@ -218,7 +250,7 @@ void unpack_width(const uint8_t* in, UnpackedUInt* out, int batch_size, int bit_
 
     if constexpr (kPackedBitWidth == 8 * sizeof(UnpackedUInt)) {
       // Only memcpy / static_cast
-      return unpack_full(in, out, batch_size);
+      return unpack_full<kHasBias>(in, out, batch_size, bias);
     } else {
       using UnpackerForWidth = Unpacker<UnpackedUInt, kPackedBitWidth>;
       // Number of values extracted by one iteration of the kernel
@@ -229,9 +261,29 @@ void unpack_width(const uint8_t* in, UnpackedUInt* out, int batch_size, int bit_
 
       if constexpr (kValuesUnpacked > 0) {
         const uint8_t* in_last = in_end - kBytesRead;
+        // Whether this unpacker family folds the bias into its own stores. The
+        // xsimd kernels do; the generated scalar and AVX-512 families do not, so
+        // they get a second pass over the values the kernel just wrote. That
+        // pass is over kValuesUnpacked elements still in L1, not over the whole
+        // Some generated kernels do not accept a bias. Apply it in a fallback
+        // pass for correctness on those targets.
+        constexpr bool kUnpackerTakesBias =
+            requires(const uint8_t* i, UnpackedUInt* o, UnpackedUInt b) {
+              UnpackerForWidth::unpack(i, o, b);
+            };  // NOLINT(readability/braces)
+
         // Running the optimized kernel for batch extraction
         while ((batch_size >= kValuesUnpacked) && (in <= in_last)) {
-          in = UnpackerForWidth::unpack(in, out);
+          if constexpr (kHasBias && kUnpackerTakesBias) {
+            in = UnpackerForWidth::unpack(in, out, bias);
+          } else {
+            in = UnpackerForWidth::unpack(in, out);
+            if constexpr (kHasBias) {
+              for (int k = 0; k < kValuesUnpacked; ++k) {
+                out[k] = static_cast<UnpackedUInt>(out[k] + bias);
+              }
+            }
+          }
           out += kValuesUnpacked;
           batch_size -= kValuesUnpacked;
         }
@@ -245,406 +297,412 @@ void unpack_width(const uint8_t* in, UnpackedUInt* out, int batch_size, int bit_
       // Running the epilog for the remaining values that don't fit in a kernel
       ARROW_DCHECK_GE(batch_size, 0);
       ARROW_COMPILER_ASSUME(batch_size >= 0);
-      unpack_exact<kPackedBitWidth, false>(in, in_end, out, batch_size,
-                                           /* bit_offset= */ 0);
+      unpack_exact<kPackedBitWidth, false, kHasBias>(in, in_end, out, batch_size,
+                                                     /* bit_offset= */ 0, bias);
     }
   }
 }
 
-template <template <typename, int> typename Unpacker, typename UnpackedUint>
-static void unpack_jump(const uint8_t* in, UnpackedUint* out, const UnpackOptions& opt) {
+template <template <typename, int> typename Unpacker, bool kHasBias = false,
+          typename UnpackedUint>
+static void unpack_jump(const uint8_t* in, UnpackedUint* out, const UnpackOptions& opt,
+                        UnpackedUint bias = UnpackedUint{}) {
+  // A bias on a bool output would have to saturate rather than add, which is not
+  // what any caller means by it.
+  static_assert(!(kHasBias && std::is_same_v<UnpackedUint, bool>),
+                "unpack with a bias is not defined for bool output");
   if constexpr (std::is_same_v<UnpackedUint, bool>) {
     switch (opt.bit_width) {
       case 0:
-        return unpack_width<0, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<0, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 1:
-        return unpack_width<1, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<1, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
     }
   } else if constexpr (sizeof(UnpackedUint) == 1) {
     switch (opt.bit_width) {
       case 0:
-        return unpack_width<0, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<0, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 1:
-        return unpack_width<1, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<1, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 2:
-        return unpack_width<2, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<2, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 3:
-        return unpack_width<3, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<3, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 4:
-        return unpack_width<4, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<4, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 5:
-        return unpack_width<5, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<5, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 6:
-        return unpack_width<6, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<6, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 7:
-        return unpack_width<7, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<7, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 8:
-        return unpack_width<8, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<8, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
     }
   } else if constexpr (sizeof(UnpackedUint) == 2) {
     switch (opt.bit_width) {
       case 0:
-        return unpack_width<0, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<0, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 1:
-        return unpack_width<1, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<1, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 2:
-        return unpack_width<2, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<2, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 3:
-        return unpack_width<3, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<3, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 4:
-        return unpack_width<4, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<4, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 5:
-        return unpack_width<5, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<5, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 6:
-        return unpack_width<6, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<6, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 7:
-        return unpack_width<7, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<7, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 8:
-        return unpack_width<8, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<8, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 9:
-        return unpack_width<9, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<9, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 10:
-        return unpack_width<10, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<10, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 11:
-        return unpack_width<11, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<11, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 12:
-        return unpack_width<12, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<12, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 13:
-        return unpack_width<13, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<13, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 14:
-        return unpack_width<14, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<14, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 15:
-        return unpack_width<15, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<15, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 16:
-        return unpack_width<16, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<16, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
     }
   } else if constexpr (sizeof(UnpackedUint) == 4) {
     switch (opt.bit_width) {
       case 0:
-        return unpack_width<0, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<0, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 1:
-        return unpack_width<1, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<1, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 2:
-        return unpack_width<2, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<2, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 3:
-        return unpack_width<3, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<3, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 4:
-        return unpack_width<4, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<4, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 5:
-        return unpack_width<5, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<5, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 6:
-        return unpack_width<6, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<6, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 7:
-        return unpack_width<7, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<7, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 8:
-        return unpack_width<8, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<8, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 9:
-        return unpack_width<9, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<9, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 10:
-        return unpack_width<10, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<10, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 11:
-        return unpack_width<11, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<11, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 12:
-        return unpack_width<12, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<12, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 13:
-        return unpack_width<13, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<13, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 14:
-        return unpack_width<14, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<14, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 15:
-        return unpack_width<15, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<15, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 16:
-        return unpack_width<16, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<16, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 17:
-        return unpack_width<17, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<17, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 18:
-        return unpack_width<18, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<18, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 19:
-        return unpack_width<19, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<19, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 20:
-        return unpack_width<20, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<20, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 21:
-        return unpack_width<21, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<21, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 22:
-        return unpack_width<22, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<22, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 23:
-        return unpack_width<23, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<23, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 24:
-        return unpack_width<24, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<24, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 25:
-        return unpack_width<25, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<25, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 26:
-        return unpack_width<26, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<26, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 27:
-        return unpack_width<27, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<27, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 28:
-        return unpack_width<28, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<28, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 29:
-        return unpack_width<29, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<29, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 30:
-        return unpack_width<30, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<30, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 31:
-        return unpack_width<31, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<31, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 32:
-        return unpack_width<32, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<32, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
     }
   } else if constexpr (sizeof(UnpackedUint) == 8) {
     switch (opt.bit_width) {
       case 0:
-        return unpack_width<0, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<0, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 1:
-        return unpack_width<1, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<1, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 2:
-        return unpack_width<2, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<2, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 3:
-        return unpack_width<3, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<3, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 4:
-        return unpack_width<4, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<4, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 5:
-        return unpack_width<5, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<5, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 6:
-        return unpack_width<6, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<6, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 7:
-        return unpack_width<7, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<7, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 8:
-        return unpack_width<8, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<8, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 9:
-        return unpack_width<9, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                         opt.max_read_bytes);
+        return unpack_width<9, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 10:
-        return unpack_width<10, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<10, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 11:
-        return unpack_width<11, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<11, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 12:
-        return unpack_width<12, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<12, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 13:
-        return unpack_width<13, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<13, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 14:
-        return unpack_width<14, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<14, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 15:
-        return unpack_width<15, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<15, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 16:
-        return unpack_width<16, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<16, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 17:
-        return unpack_width<17, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<17, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 18:
-        return unpack_width<18, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<18, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 19:
-        return unpack_width<19, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<19, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 20:
-        return unpack_width<20, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<20, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 21:
-        return unpack_width<21, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<21, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 22:
-        return unpack_width<22, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<22, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 23:
-        return unpack_width<23, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<23, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 24:
-        return unpack_width<24, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<24, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 25:
-        return unpack_width<25, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<25, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 26:
-        return unpack_width<26, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<26, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 27:
-        return unpack_width<27, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<27, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 28:
-        return unpack_width<28, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<28, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 29:
-        return unpack_width<29, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<29, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 30:
-        return unpack_width<30, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<30, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 31:
-        return unpack_width<31, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<31, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 32:
-        return unpack_width<32, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<32, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 33:
-        return unpack_width<33, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<33, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 34:
-        return unpack_width<34, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<34, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 35:
-        return unpack_width<35, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<35, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 36:
-        return unpack_width<36, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<36, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 37:
-        return unpack_width<37, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<37, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 38:
-        return unpack_width<38, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<38, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 39:
-        return unpack_width<39, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<39, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 40:
-        return unpack_width<40, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<40, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 41:
-        return unpack_width<41, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<41, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 42:
-        return unpack_width<42, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<42, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 43:
-        return unpack_width<43, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<43, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 44:
-        return unpack_width<44, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<44, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 45:
-        return unpack_width<45, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<45, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 46:
-        return unpack_width<46, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<46, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 47:
-        return unpack_width<47, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<47, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 48:
-        return unpack_width<48, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<48, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 49:
-        return unpack_width<49, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<49, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 50:
-        return unpack_width<50, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<50, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 51:
-        return unpack_width<51, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<51, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 52:
-        return unpack_width<52, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<52, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 53:
-        return unpack_width<53, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<53, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 54:
-        return unpack_width<54, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<54, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 55:
-        return unpack_width<55, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<55, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 56:
-        return unpack_width<56, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<56, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 57:
-        return unpack_width<57, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<57, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 58:
-        return unpack_width<58, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<58, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 59:
-        return unpack_width<59, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<59, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 60:
-        return unpack_width<60, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<60, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 61:
-        return unpack_width<61, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<61, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 62:
-        return unpack_width<62, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<62, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 63:
-        return unpack_width<63, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<63, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
       case 64:
-        return unpack_width<64, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
-                                          opt.max_read_bytes);
+        return unpack_width<64, Unpacker, kHasBias>(
+            in, out, opt.batch_size, opt.bit_offset, opt.max_read_bytes, bias);
     }
   }
   ARROW_DCHECK(false) << "Unsupported num_bits " << opt.bit_width;
diff --git a/cpp/src/arrow/util/bpacking_internal.h b/cpp/src/arrow/util/bpacking_internal.h
index 329a1ae959b5..dbdad2082c6b 100644
--- a/cpp/src/arrow/util/bpacking_internal.h
+++ b/cpp/src/arrow/util/bpacking_internal.h
@@ -48,4 +48,29 @@ extern template ARROW_TEMPLATE_EXPORT void unpack<uint32_t>(  //
 extern template ARROW_TEMPLATE_EXPORT void unpack<uint64_t>(  //
     const uint8_t* in, uint64_t* out, const UnpackOptions& opts);
 
+/// \brief Unpack, adding `bias` to every value.
+///
+/// Equivalent to `unpack()` followed by a loop adding `bias`, but the addition
+/// happens inside the unpacker before its store, so the output is traversed
+/// once instead of twice. Frame-of-reference decoders are the motivating
+/// caller: the separate add pass costs as much as the unpack it follows.
+///
+/// `bias + value` is computed in `Uint`, so it wraps rather than saturating.
+/// Not defined for `bool` output, where an add has no meaning.
+template <typename Uint>
+ARROW_EXPORT void unpack_bias(const uint8_t* in, Uint* out, const UnpackOptions& opts,
+                              Uint bias);
+
+extern template ARROW_TEMPLATE_EXPORT void unpack_bias<uint8_t>(  //
+    const uint8_t* in, uint8_t* out, const UnpackOptions& opts, uint8_t bias);
+
+extern template ARROW_TEMPLATE_EXPORT void unpack_bias<uint16_t>(  //
+    const uint8_t* in, uint16_t* out, const UnpackOptions& opts, uint16_t bias);
+
+extern template ARROW_TEMPLATE_EXPORT void unpack_bias<uint32_t>(  //
+    const uint8_t* in, uint32_t* out, const UnpackOptions& opts, uint32_t bias);
+
+extern template ARROW_TEMPLATE_EXPORT void unpack_bias<uint64_t>(  //
+    const uint8_t* in, uint64_t* out, const UnpackOptions& opts, uint64_t bias);
+
 }  // namespace arrow::internal
diff --git a/cpp/src/arrow/util/bpacking_scalar.cc b/cpp/src/arrow/util/bpacking_scalar.cc
index 5226ad55cd3e..be3c9ded3462 100644
--- a/cpp/src/arrow/util/bpacking_scalar.cc
+++ b/cpp/src/arrow/util/bpacking_scalar.cc
@@ -33,4 +33,19 @@ template void unpack_scalar<uint16_t>(const uint8_t*, uint16_t*, const UnpackOpt
 template void unpack_scalar<uint32_t>(const uint8_t*, uint32_t*, const UnpackOptions&);
 template void unpack_scalar<uint64_t>(const uint8_t*, uint64_t*, const UnpackOptions&);
 
+template <typename Uint>
+void unpack_bias_scalar(const uint8_t* in, Uint* out, const UnpackOptions& opts,
+                        Uint bias) {
+  return unpack_jump<ScalarUnpackerForWidth, /*kHasBias=*/true>(in, out, opts, bias);
+}
+
+template void unpack_bias_scalar<uint8_t>(const uint8_t*, uint8_t*, const UnpackOptions&,
+                                          uint8_t);
+template void unpack_bias_scalar<uint16_t>(const uint8_t*, uint16_t*,
+                                           const UnpackOptions&, uint16_t);
+template void unpack_bias_scalar<uint32_t>(const uint8_t*, uint32_t*,
+                                           const UnpackOptions&, uint32_t);
+template void unpack_bias_scalar<uint64_t>(const uint8_t*, uint64_t*,
+                                           const UnpackOptions&, uint64_t);
+
 }  // namespace arrow::internal::bpacking
diff --git a/cpp/src/arrow/util/bpacking_scalar_internal.h b/cpp/src/arrow/util/bpacking_scalar_internal.h
index 2f62174f5f3f..c6a52a82e3b7 100644
--- a/cpp/src/arrow/util/bpacking_scalar_internal.h
+++ b/cpp/src/arrow/util/bpacking_scalar_internal.h
@@ -42,4 +42,20 @@ extern template ARROW_TEMPLATE_EXPORT void unpack_scalar<uint32_t>(
 extern template ARROW_TEMPLATE_EXPORT void unpack_scalar<uint64_t>(
     const uint8_t* in, uint64_t* out, const UnpackOptions& opts);
 
+template <typename Uint>
+ARROW_EXPORT void unpack_bias_scalar(const uint8_t* in, Uint* out,
+                                     const UnpackOptions& opts, Uint bias);
+
+extern template ARROW_TEMPLATE_EXPORT void unpack_bias_scalar<uint8_t>(
+    const uint8_t* in, uint8_t* out, const UnpackOptions& opts, uint8_t bias);
+
+extern template ARROW_TEMPLATE_EXPORT void unpack_bias_scalar<uint16_t>(
+    const uint8_t* in, uint16_t* out, const UnpackOptions& opts, uint16_t bias);
+
+extern template ARROW_TEMPLATE_EXPORT void unpack_bias_scalar<uint32_t>(
+    const uint8_t* in, uint32_t* out, const UnpackOptions& opts, uint32_t bias);
+
+extern template ARROW_TEMPLATE_EXPORT void unpack_bias_scalar<uint64_t>(
+    const uint8_t* in, uint64_t* out, const UnpackOptions& opts, uint64_t bias);
+
 }  // namespace arrow::internal::bpacking
diff --git a/cpp/src/arrow/util/bpacking_simd_128.cc b/cpp/src/arrow/util/bpacking_simd_128.cc
index 1bc756b2aa7d..ee90d22a37f5 100644
--- a/cpp/src/arrow/util/bpacking_simd_128.cc
+++ b/cpp/src/arrow/util/bpacking_simd_128.cc
@@ -17,9 +17,11 @@
 
 #if defined(ARROW_HAVE_NEON)
 #  define UNPACK_PLATFORM unpack_neon
+#  define UNPACK_BIAS_PLATFORM unpack_bias_neon
 #  define KERNEL_PLATFORM KernelNeon
 #elif defined(ARROW_HAVE_SSE4_2)
 #  define UNPACK_PLATFORM unpack_sse4_2
+#  define UNPACK_BIAS_PLATFORM unpack_bias_sse4_2
 #  define KERNEL_PLATFORM KernelSse42
 #endif
 
@@ -45,7 +47,23 @@ template void UNPACK_PLATFORM<uint16_t>(const uint8_t*, uint16_t*, const UnpackO
 template void UNPACK_PLATFORM<uint32_t>(const uint8_t*, uint32_t*, const UnpackOptions&);
 template void UNPACK_PLATFORM<uint64_t>(const uint8_t*, uint64_t*, const UnpackOptions&);
 
+template <typename Uint>
+void UNPACK_BIAS_PLATFORM(const uint8_t* in, Uint* out, const UnpackOptions& opts,
+                          Uint bias) {
+  return unpack_jump<KERNEL_PLATFORM, /*kHasBias=*/true>(in, out, opts, bias);
+}
+
+template void UNPACK_BIAS_PLATFORM<uint8_t>(const uint8_t*, uint8_t*,
+                                            const UnpackOptions&, uint8_t);
+template void UNPACK_BIAS_PLATFORM<uint16_t>(const uint8_t*, uint16_t*,
+                                             const UnpackOptions&, uint16_t);
+template void UNPACK_BIAS_PLATFORM<uint32_t>(const uint8_t*, uint32_t*,
+                                             const UnpackOptions&, uint32_t);
+template void UNPACK_BIAS_PLATFORM<uint64_t>(const uint8_t*, uint64_t*,
+                                             const UnpackOptions&, uint64_t);
+
 }  // namespace arrow::internal::bpacking
 
 #  undef UNPACK_PLATFORM
+#  undef UNPACK_BIAS_PLATFORM
 #endif  // UNPACK_PLATFORM
diff --git a/cpp/src/arrow/util/bpacking_simd_128_alt.cc b/cpp/src/arrow/util/bpacking_simd_128_alt.cc
index bd4799d3cd31..9ffaec4899b5 100644
--- a/cpp/src/arrow/util/bpacking_simd_128_alt.cc
+++ b/cpp/src/arrow/util/bpacking_simd_128_alt.cc
@@ -17,6 +17,7 @@
 
 #if defined(ARROW_HAVE_RUNTIME_SVE128)
 #  define UNPACK_PLATFORM unpack_sve128
+#  define UNPACK_BIAS_PLATFORM unpack_bias_sve128
 #  define KERNEL_PLATFORM KernelSve128
 #endif
 
@@ -46,6 +47,22 @@ template void UNPACK_PLATFORM<uint16_t>(const uint8_t*, uint16_t*, const UnpackO
 template void UNPACK_PLATFORM<uint32_t>(const uint8_t*, uint32_t*, const UnpackOptions&);
 template void UNPACK_PLATFORM<uint64_t>(const uint8_t*, uint64_t*, const UnpackOptions&);
 
+template <typename Uint>
+void UNPACK_BIAS_PLATFORM(const uint8_t* in, Uint* out, const UnpackOptions& opts,
+                          Uint bias) {
+  return unpack_jump<KERNEL_PLATFORM, /*kHasBias=*/true>(in, out, opts, bias);
+}
+
+template void UNPACK_BIAS_PLATFORM<uint8_t>(const uint8_t*, uint8_t*,
+                                            const UnpackOptions&, uint8_t);
+template void UNPACK_BIAS_PLATFORM<uint16_t>(const uint8_t*, uint16_t*,
+                                             const UnpackOptions&, uint16_t);
+template void UNPACK_BIAS_PLATFORM<uint32_t>(const uint8_t*, uint32_t*,
+                                             const UnpackOptions&, uint32_t);
+template void UNPACK_BIAS_PLATFORM<uint64_t>(const uint8_t*, uint64_t*,
+                                             const UnpackOptions&, uint64_t);
+
 }  // namespace arrow::internal::bpacking
 
 #undef UNPACK_PLATFORM
+#undef UNPACK_BIAS_PLATFORM
diff --git a/cpp/src/arrow/util/bpacking_simd_256.cc b/cpp/src/arrow/util/bpacking_simd_256.cc
index 8c5ce4dc7d06..98f7d210fb94 100644
--- a/cpp/src/arrow/util/bpacking_simd_256.cc
+++ b/cpp/src/arrow/util/bpacking_simd_256.cc
@@ -17,9 +17,11 @@
 
 #if defined(ARROW_HAVE_SVE256) || defined(ARROW_HAVE_RUNTIME_SVE256)
 #  define UNPACK_PLATFORM unpack_sve256
+#  define UNPACK_BIAS_PLATFORM unpack_bias_sve256
 #  define KERNEL_PLATFORM KernelSve256
 #elif defined(ARROW_HAVE_RUNTIME_AVX2)
 #  define UNPACK_PLATFORM unpack_avx2
+#  define UNPACK_BIAS_PLATFORM unpack_bias_avx2
 #  define KERNEL_PLATFORM KernelAvx2
 #endif
 
@@ -48,6 +50,22 @@ template void UNPACK_PLATFORM<uint16_t>(const uint8_t*, uint16_t*, const UnpackO
 template void UNPACK_PLATFORM<uint32_t>(const uint8_t*, uint32_t*, const UnpackOptions&);
 template void UNPACK_PLATFORM<uint64_t>(const uint8_t*, uint64_t*, const UnpackOptions&);
 
+template <typename Uint>
+void UNPACK_BIAS_PLATFORM(const uint8_t* in, Uint* out, const UnpackOptions& opts,
+                          Uint bias) {
+  return unpack_jump<KERNEL_PLATFORM, /*kHasBias=*/true>(in, out, opts, bias);
+}
+
+template void UNPACK_BIAS_PLATFORM<uint8_t>(const uint8_t*, uint8_t*,
+                                            const UnpackOptions&, uint8_t);
+template void UNPACK_BIAS_PLATFORM<uint16_t>(const uint8_t*, uint16_t*,
+                                             const UnpackOptions&, uint16_t);
+template void UNPACK_BIAS_PLATFORM<uint32_t>(const uint8_t*, uint32_t*,
+                                             const UnpackOptions&, uint32_t);
+template void UNPACK_BIAS_PLATFORM<uint64_t>(const uint8_t*, uint64_t*,
+                                             const UnpackOptions&, uint64_t);
+
 }  // namespace arrow::internal::bpacking
 
 #undef UNPACK_PLATFORM
+#undef UNPACK_BIAS_PLATFORM
diff --git a/cpp/src/arrow/util/bpacking_simd_avx512.cc b/cpp/src/arrow/util/bpacking_simd_avx512.cc
index bef7aebe175e..408ee5f3df19 100644
--- a/cpp/src/arrow/util/bpacking_simd_avx512.cc
+++ b/cpp/src/arrow/util/bpacking_simd_avx512.cc
@@ -33,4 +33,19 @@ template void unpack_avx512<uint16_t>(const uint8_t*, uint16_t*, const UnpackOpt
 template void unpack_avx512<uint32_t>(const uint8_t*, uint32_t*, const UnpackOptions&);
 template void unpack_avx512<uint64_t>(const uint8_t*, uint64_t*, const UnpackOptions&);
 
+template <typename Uint>
+void unpack_bias_avx512(const uint8_t* in, Uint* out, const UnpackOptions& opts,
+                        Uint bias) {
+  return unpack_jump<Simd512UnpackerForWidth, /*kHasBias=*/true>(in, out, opts, bias);
+}
+
+template void unpack_bias_avx512<uint8_t>(const uint8_t*, uint8_t*, const UnpackOptions&,
+                                          uint8_t);
+template void unpack_bias_avx512<uint16_t>(const uint8_t*, uint16_t*,
+                                           const UnpackOptions&, uint16_t);
+template void unpack_bias_avx512<uint32_t>(const uint8_t*, uint32_t*,
+                                           const UnpackOptions&, uint32_t);
+template void unpack_bias_avx512<uint64_t>(const uint8_t*, uint64_t*,
+                                           const UnpackOptions&, uint64_t);
+
 }  // namespace arrow::internal::bpacking
diff --git a/cpp/src/arrow/util/bpacking_simd_internal.h b/cpp/src/arrow/util/bpacking_simd_internal.h
index d5a81baaec09..3fbdaa8a237a 100644
--- a/cpp/src/arrow/util/bpacking_simd_internal.h
+++ b/cpp/src/arrow/util/bpacking_simd_internal.h
@@ -26,8 +26,10 @@ namespace arrow::internal::bpacking {
 
 #if defined(ARROW_HAVE_NEON)
 #  define UNPACK_ARCH128 unpack_neon
+#  define UNPACK_BIAS_ARCH128 unpack_bias_neon
 #elif defined(ARROW_HAVE_SSE4_2)
 #  define UNPACK_ARCH128 unpack_sse4_2
+#  define UNPACK_BIAS_ARCH128 unpack_bias_sse4_2
 #endif
 
 #if defined(UNPACK_ARCH128)
@@ -50,11 +52,29 @@ extern template ARROW_TEMPLATE_EXPORT void UNPACK_ARCH128<uint32_t>(
 extern template ARROW_TEMPLATE_EXPORT void UNPACK_ARCH128<uint64_t>(
     const uint8_t* in, uint64_t* out, const UnpackOptions& opts);
 
+template <typename Uint>
+ARROW_EXPORT void UNPACK_BIAS_ARCH128(const uint8_t* in, Uint* out,
+                                      const UnpackOptions& opts, Uint bias);
+
+extern template ARROW_TEMPLATE_EXPORT void UNPACK_BIAS_ARCH128<uint8_t>(
+    const uint8_t* in, uint8_t* out, const UnpackOptions& opts, uint8_t bias);
+
+extern template ARROW_TEMPLATE_EXPORT void UNPACK_BIAS_ARCH128<uint16_t>(
+    const uint8_t* in, uint16_t* out, const UnpackOptions& opts, uint16_t bias);
+
+extern template ARROW_TEMPLATE_EXPORT void UNPACK_BIAS_ARCH128<uint32_t>(
+    const uint8_t* in, uint32_t* out, const UnpackOptions& opts, uint32_t bias);
+
+extern template ARROW_TEMPLATE_EXPORT void UNPACK_BIAS_ARCH128<uint64_t>(
+    const uint8_t* in, uint64_t* out, const UnpackOptions& opts, uint64_t bias);
+
 #endif  // UNPACK_ARCH128
 #undef UNPACK_ARCH128
+#undef UNPACK_BIAS_ARCH128
 
 #if defined(ARROW_HAVE_RUNTIME_SVE128)
 #  define UNPACK_ARCH128_ALT unpack_sve128
+#  define UNPACK_BIAS_ARCH128_ALT unpack_bias_sve128
 #endif
 
 #if defined(UNPACK_ARCH128_ALT)
@@ -78,13 +98,32 @@ extern template ARROW_TEMPLATE_EXPORT void UNPACK_ARCH128_ALT<uint32_t>(
 extern template ARROW_TEMPLATE_EXPORT void UNPACK_ARCH128_ALT<uint64_t>(
     const uint8_t* in, uint64_t* out, const UnpackOptions& opts);
 
+template <typename Uint>
+ARROW_EXPORT void UNPACK_BIAS_ARCH128_ALT(const uint8_t* in, Uint* out,
+                                          const UnpackOptions& opts, Uint bias);
+
+extern template ARROW_TEMPLATE_EXPORT void UNPACK_BIAS_ARCH128_ALT<uint8_t>(
+    const uint8_t* in, uint8_t* out, const UnpackOptions& opts, uint8_t bias);
+
+extern template ARROW_TEMPLATE_EXPORT void UNPACK_BIAS_ARCH128_ALT<uint16_t>(
+    const uint8_t* in, uint16_t* out, const UnpackOptions& opts, uint16_t bias);
+
+extern template ARROW_TEMPLATE_EXPORT void UNPACK_BIAS_ARCH128_ALT<uint32_t>(
+    const uint8_t* in, uint32_t* out, const UnpackOptions& opts, uint32_t bias);
+
+extern template ARROW_TEMPLATE_EXPORT void UNPACK_BIAS_ARCH128_ALT<uint64_t>(
+    const uint8_t* in, uint64_t* out, const UnpackOptions& opts, uint64_t bias);
+
 #endif  // UNPACK_ARCH128_ALT
 #undef UNPACK_ARCH128_ALT
+#undef UNPACK_BIAS_ARCH128_ALT
 
 #if defined(ARROW_HAVE_SVE256) || defined(ARROW_HAVE_RUNTIME_SVE256)
 #  define UNPACK_ARCH256 unpack_sve256
+#  define UNPACK_BIAS_ARCH256 unpack_bias_sve256
 #elif defined(UNPACK_ARCH256) || defined(ARROW_HAVE_RUNTIME_AVX2)
 #  define UNPACK_ARCH256 unpack_avx2
+#  define UNPACK_BIAS_ARCH256 unpack_bias_avx2
 #endif
 
 #if defined(UNPACK_ARCH256)
@@ -107,8 +146,25 @@ extern template ARROW_TEMPLATE_EXPORT void UNPACK_ARCH256<uint32_t>(
 extern template ARROW_TEMPLATE_EXPORT void UNPACK_ARCH256<uint64_t>(
     const uint8_t* in, uint64_t* out, const UnpackOptions& opts);
 
+template <typename Uint>
+ARROW_EXPORT void UNPACK_BIAS_ARCH256(const uint8_t* in, Uint* out,
+                                      const UnpackOptions& opts, Uint bias);
+
+extern template ARROW_TEMPLATE_EXPORT void UNPACK_BIAS_ARCH256<uint8_t>(
+    const uint8_t* in, uint8_t* out, const UnpackOptions& opts, uint8_t bias);
+
+extern template ARROW_TEMPLATE_EXPORT void UNPACK_BIAS_ARCH256<uint16_t>(
+    const uint8_t* in, uint16_t* out, const UnpackOptions& opts, uint16_t bias);
+
+extern template ARROW_TEMPLATE_EXPORT void UNPACK_BIAS_ARCH256<uint32_t>(
+    const uint8_t* in, uint32_t* out, const UnpackOptions& opts, uint32_t bias);
+
+extern template ARROW_TEMPLATE_EXPORT void UNPACK_BIAS_ARCH256<uint64_t>(
+    const uint8_t* in, uint64_t* out, const UnpackOptions& opts, uint64_t bias);
+
 #endif  // UNPACK_ARCH256
 #undef UNPACK_ARCH256
+#undef UNPACK_BIAS_ARCH256
 
 #if defined(ARROW_HAVE_AVX512) || defined(ARROW_HAVE_RUNTIME_AVX512)
 
@@ -130,6 +186,22 @@ extern template ARROW_TEMPLATE_EXPORT void unpack_avx512<uint32_t>(
 extern template ARROW_TEMPLATE_EXPORT void unpack_avx512<uint64_t>(
     const uint8_t* in, uint64_t* out, const UnpackOptions& opts);
 
+template <typename Uint>
+ARROW_EXPORT void unpack_bias_avx512(const uint8_t* in, Uint* out,
+                                     const UnpackOptions& opts, Uint bias);
+
+extern template ARROW_TEMPLATE_EXPORT void unpack_bias_avx512<uint8_t>(
+    const uint8_t* in, uint8_t* out, const UnpackOptions& opts, uint8_t bias);
+
+extern template ARROW_TEMPLATE_EXPORT void unpack_bias_avx512<uint16_t>(
+    const uint8_t* in, uint16_t* out, const UnpackOptions& opts, uint16_t bias);
+
+extern template ARROW_TEMPLATE_EXPORT void unpack_bias_avx512<uint32_t>(
+    const uint8_t* in, uint32_t* out, const UnpackOptions& opts, uint32_t bias);
+
+extern template ARROW_TEMPLATE_EXPORT void unpack_bias_avx512<uint64_t>(
+    const uint8_t* in, uint64_t* out, const UnpackOptions& opts, uint64_t bias);
+
 #endif
 
 }  // namespace arrow::internal::bpacking
diff --git a/cpp/src/arrow/util/bpacking_simd_kernel_internal.h b/cpp/src/arrow/util/bpacking_simd_kernel_internal.h
index 83a969cca643..33cddfe0ef79 100644
--- a/cpp/src/arrow/util/bpacking_simd_kernel_internal.h
+++ b/cpp/src/arrow/util/bpacking_simd_kernel_internal.h
@@ -645,9 +645,10 @@ struct MediumKernel {
   static constexpr int kValuesUnpacked = kPlan.unpacked_per_kernel();
   static constexpr int kBytesRead = kPlan.total_bytes_read();
 
-  template <int kReadIdx, int kSwizzleIdx, int kShiftIdx>
+  template <bool kHasBias, int kReadIdx, int kSwizzleIdx, int kShiftIdx>
   ARROW_FORCE_INLINE static void unpack_one_shift_impl(const simd_batch& words,
-                                                       unpacked_type* out) {
+                                                       unpacked_type* out,
+                                                       const simd_batch& bias) {
     constexpr auto kRightShiftsArr =
         kPlan.shifts.at(kReadIdx).at(kSwizzleIdx).at(kShiftIdx);
     constexpr auto kRightShifts = array_to_batch_constant<kRightShiftsArr, arch_type>();
@@ -662,44 +663,62 @@ struct MediumKernel {
     const auto shifted = right_shift_by_excess(words, kRightShifts);
     const auto vals = shifted & kMask;
     if constexpr (std::is_same_v<unpacked_type, bool>) {
+      static_assert(!kHasBias, "no bias on bool output");
       const xsimd::batch_bool<uint_type, arch_type> bools = vals != 0;
       bools.store_unaligned(out + kOutOffset);
+    } else if constexpr (kHasBias) {
+      // The bias is added before the store, so the output needs no second
+      // pass to add it.
+      (vals + bias).store_unaligned(out + kOutOffset);
     } else {
       vals.store_unaligned(out + kOutOffset);
     }
   }
 
-  template <int kReadIdx, int kSwizzleIdx, int... kShiftIds>
+  template <bool kHasBias, int kReadIdx, int kSwizzleIdx, int... kShiftIds>
   ARROW_FORCE_INLINE static void unpack_one_swizzle_impl(
-      const simd_bytes& bytes, unpacked_type* out,
+      const simd_bytes& bytes, unpacked_type* out, const simd_batch& bias,
       std::integer_sequence<int, kShiftIds...>) {
     constexpr auto kSwizzlesArr = kPlan.swizzles.at(kReadIdx).at(kSwizzleIdx);
     constexpr auto kSwizzles = array_to_batch_constant<kSwizzlesArr, arch_type>();
 
     const auto swizzled = xsimd::swizzle(bytes, kSwizzles);
     const auto words = xsimd::bitwise_cast<uint_type>(swizzled);
-    (unpack_one_shift_impl<kReadIdx, kSwizzleIdx, kShiftIds>(words, out), ...);
+    (unpack_one_shift_impl<kHasBias, kReadIdx, kSwizzleIdx, kShiftIds>(words, out, bias),
+     ...);
   }
 
-  template <int kReadIdx, int... kSwizzleIds>
+  template <bool kHasBias, int kReadIdx, int... kSwizzleIds>
   ARROW_FORCE_INLINE static void unpack_one_read_impl(
-      const uint8_t* in, unpacked_type* out, std::integer_sequence<int, kSwizzleIds...>) {
+      const uint8_t* in, unpacked_type* out, const simd_batch& bias,
+      std::integer_sequence<int, kSwizzleIds...>) {
     using ShiftSeq = std::make_integer_sequence<int, kPlanSize.shifts_per_swizzle()>;
     const auto bytes =
         safe_load_bytes<kPlan.bytes_per_read(), arch_type>(in + kPlan.reads.at(kReadIdx));
-    (unpack_one_swizzle_impl<kReadIdx, kSwizzleIds>(bytes, out, ShiftSeq{}), ...);
+    (unpack_one_swizzle_impl<kHasBias, kReadIdx, kSwizzleIds>(bytes, out, bias,
+                                                              ShiftSeq{}),
+     ...);
   }
 
-  template <int... kReadIds>
+  template <bool kHasBias, int... kReadIds>
   ARROW_FORCE_INLINE static void unpack_all_impl(
-      const uint8_t* in, unpacked_type* out, std::integer_sequence<int, kReadIds...>) {
+      const uint8_t* in, unpacked_type* out, const simd_batch& bias,
+      std::integer_sequence<int, kReadIds...>) {
     using SwizzleSeq = std::make_integer_sequence<int, kPlanSize.swizzles_per_read()>;
-    (unpack_one_read_impl<kReadIds>(in, out, SwizzleSeq{}), ...);
+    (unpack_one_read_impl<kHasBias, kReadIds>(in, out, bias, SwizzleSeq{}), ...);
   }
 
   ARROW_FORCE_INLINE static const uint8_t* unpack(const uint8_t* in, unpacked_type* out) {
     using ReadSeq = std::make_integer_sequence<int, kPlanSize.reads_per_kernel()>;
-    unpack_all_impl(in, out, ReadSeq{});
+    unpack_all_impl<false>(in, out, simd_batch{}, ReadSeq{});
+    return in + (kPlan.unpacked_per_kernel() * kShape.packed_bit_size()) / 8;
+  }
+
+  /// Same, with `bias` added to every value before it is stored.
+  ARROW_FORCE_INLINE static const uint8_t* unpack(const uint8_t* in, unpacked_type* out,
+                                                  unpacked_type bias) {
+    using ReadSeq = std::make_integer_sequence<int, kPlanSize.reads_per_kernel()>;
+    unpack_all_impl<true>(in, out, simd_batch(static_cast<uint_type>(bias)), ReadSeq{});
     return in + (kPlan.unpacked_per_kernel() * kShape.packed_bit_size()) / 8;
   }
 };
@@ -934,9 +953,10 @@ struct LargeKernel {
   static constexpr int kValuesUnpacked = kPlanSize.unpacked_per_kernel();
   static constexpr int kBytesRead = kPlan.total_bytes_read();
 
-  template <int kReadIdx>
+  template <bool kHasBias, int kReadIdx>
   ARROW_FORCE_INLINE static void unpack_one_read_impl(const uint8_t* in,
-                                                      unpacked_type* out) {
+                                                      unpacked_type* out,
+                                                      const simd_batch& bias) {
     constexpr auto kLowSwizzles =
         array_to_batch_constant<kPlan.low_swizzles.at(kReadIdx), arch_type>();
     constexpr auto kLowRShifts =
@@ -967,18 +987,34 @@ struct LargeKernel {
     // We can have a single mask and apply it after OR because the shifts will ensure that
     // there are zeros where the high/low values are incomplete.
     const auto vals = (low_shifted | high_shifted) & kPlan.mask;
-    xsimd::store_unaligned(out + kReadIdx * kShape.unpacked_per_simd(), vals);
+    if constexpr (kHasBias) {
+      // As in MediumKernel: fold the bias into this store rather than sweeping
+      // the output again afterwards.
+      xsimd::store_unaligned(out + kReadIdx * kShape.unpacked_per_simd(), vals + bias);
+    } else {
+      xsimd::store_unaligned(out + kReadIdx * kShape.unpacked_per_simd(), vals);
+    }
   }
 
-  template <int... kReadIds>
+  template <bool kHasBias, int... kReadIds>
   ARROW_FORCE_INLINE static void unpack_all_impl(
-      const uint8_t* in, unpacked_type* out, std::integer_sequence<int, kReadIds...>) {
-    (unpack_one_read_impl<kReadIds>(in, out), ...);
+      const uint8_t* in, unpacked_type* out, const simd_batch& bias,
+      std::integer_sequence<int, kReadIds...>) {
+    (unpack_one_read_impl<kHasBias, kReadIds>(in, out, bias), ...);
   }
 
   ARROW_FORCE_INLINE static const uint8_t* unpack(const uint8_t* in, unpacked_type* out) {
     using ReadSeq = std::make_integer_sequence<int, kPlanSize.reads_per_kernel()>;
-    unpack_all_impl(in, out, ReadSeq{});
+    unpack_all_impl<false>(in, out, simd_batch{}, ReadSeq{});
+    return in + (kPlan.kPlanSize.unpacked_per_kernel() * kShape.packed_bit_size()) / 8;
+  }
+
+  /// Same, with `bias` added to every value before it is stored.
+  ARROW_FORCE_INLINE static const uint8_t* unpack(const uint8_t* in, unpacked_type* out,
+                                                  unpacked_type bias) {
+    using ReadSeq = std::make_integer_sequence<int, kPlanSize.reads_per_kernel()>;
+    unpack_all_impl<true>(
+        in, out, simd_batch(static_cast<typename Traits::uint_type>(bias)), ReadSeq{});
     return in + (kPlan.kPlanSize.unpacked_per_kernel() * kShape.packed_bit_size()) / 8;
   }
 };
@@ -1016,6 +1052,26 @@ struct CastingKernel : WorkingKernel {
     }
     return in;
   }
+
+  /// Same, with `bias` added to every value.
+  ///
+  /// The add goes in the cast loop, not in the working kernel's stores. The
+  /// working kernel can be *narrower* than `unpacked_type` (uint32 working /
+  /// uint64 unpacked on SSE4.2), and adding there would compute the bias modulo
+  /// the working width before widening -- wrong for any bias that does not fit.
+  /// Adding after the widening is correct for both directions, and the cast loop
+  /// was going to run anyway.
+  ARROW_FORCE_INLINE static const uint8_t* unpack(const uint8_t* in, unpacked_type* out,
+                                                  unpacked_type bias) {
+    using working_type = typename WorkingKernel::unpacked_type;
+
+    working_type buffer[kValuesUnpacked] = {};
+    in = WorkingKernel::unpack(in, buffer);
+    for (int k = 0; k < kValuesUnpacked; ++k) {
+      out[k] = static_cast<unpacked_type>(static_cast<unpacked_type>(buffer[k]) + bias);
+    }
+    return in;
+  }
 };
 
 /*******************************
diff --git a/cpp/src/arrow/util/bpacking_test.cc b/cpp/src/arrow/util/bpacking_test.cc
index d4d588228e7e..87e4570f4de8 100644
--- a/cpp/src/arrow/util/bpacking_test.cc
+++ b/cpp/src/arrow/util/bpacking_test.cc
@@ -321,4 +321,161 @@ TYPED_TEST(TestUnpack, UnpackSve256) {
 
 TYPED_TEST(TestUnpack, Unpack) { this->TestAll(&unpack<TypeParam>); }
 
+// ----------------------------------------------------------------------
+// unpack_bias
+
+template <typename Uint>
+using UnpackBiasFunc = void (*)(const uint8_t*, Uint*, const UnpackOptions&, Uint);
+
+template <typename Uint>
+class TestUnpackBias : public ::testing::Test {
+ protected:
+  /// `unpack_bias` must agree with `unpack` followed by an add, elementwise.
+  ///
+  /// This is a differential test against the plain unpacker on the same target,
+  /// which TestUnpack already covers, so it needs no second reference
+  /// implementation -- and it catches the failure mode that matters most here: a
+  /// kernel that folds the bias into some of its stores but not all of them.
+  void TestOne(UnpackBiasFunc<Uint> unpack_bias, UnpackFunc<Uint> unpack,
+               const UnpackOptions& opts, Uint bias) {
+    SCOPED_TRACE(::testing::Message() << "Testing bias=" << static_cast<uint64_t>(bias));
+
+    const auto original =
+        GenerateRandomValuesForPacking<Uint>(opts.batch_size, opts.bit_width);
+    const auto packed =
+        PackValues(original, opts.batch_size, opts.bit_width, opts.bit_offset);
+
+    std::vector<Uint> expected(opts.batch_size);
+    unpack(packed.data(), expected.data(), opts);
+    for (auto& v : expected) {
+      v = static_cast<Uint>(v + bias);
+    }
+
+    // Prefilled with a value the unpacker should never leave behind, so a store
+    // the kernel skips shows up as a mismatch rather than a lucky zero.
+    std::vector<Uint> actual(opts.batch_size, static_cast<Uint>(~Uint{0}));
+    unpack_bias(packed.data(), actual.data(), opts, bias);
+
+    ASSERT_EQ(expected, actual);
+  }
+
+  void TestAll(UnpackBiasFunc<Uint> unpack_bias, UnpackFunc<Uint> unpack) {
+    constexpr int kMaxBitWidth = 8 * sizeof(Uint);
+
+    // 0 must reproduce plain unpack. The top two force the add to wrap, which is
+    // the documented behaviour (the add is modular in Uint) and is what
+    // frame-of-reference callers rely on when they reinterpret the result as
+    // signed.
+    const std::vector<Uint> kBiases = {Uint{0}, Uint{1}, static_cast<Uint>(~Uint{0}),
+                                       static_cast<Uint>(Uint{1} << (kMaxBitWidth - 1))};
+
+    for (int num_values_base : {64, 128, 2048}) {
+      SCOPED_TRACE(::testing::Message() << "Testing num_values=" << num_values_base);
+
+      for (int bit_width = 0; bit_width <= kMaxBitWidth; ++bit_width) {
+        SCOPED_TRACE(::testing::Message() << "Testing bit_width=" << bit_width);
+
+        // Every misalignment, to reach the prolog with a bias.
+        for (int bit_offset = 0; bit_offset < 8; ++bit_offset) {
+          SCOPED_TRACE(::testing::Message() << "Testing bit_offset=" << bit_offset);
+          const UnpackOptions opts{
+              .batch_size = num_values_base,
+              .bit_width = bit_width,
+              .bit_offset = bit_offset,
+              .max_read_bytes = -1,  // No over-reading in testing (strict ASAN)
+          };
+          for (Uint bias : kBiases) {
+            TestOne(unpack_bias, unpack, opts, bias);
+            if (testing::Test::HasFailure()) return;
+          }
+        }
+
+        // Every epilog size, to reach the tail with a bias.
+        for (int epilogue_size = 0; epilogue_size <= kMaxBitWidth; ++epilogue_size) {
+          SCOPED_TRACE(::testing::Message() << "Testing epilog_size=" << epilogue_size);
+          const UnpackOptions opts{
+              .batch_size = num_values_base + epilogue_size,
+              .bit_width = bit_width,
+              .bit_offset = 0,
+              .max_read_bytes = -1,  // No over-reading in testing (strict ASAN)
+          };
+          for (Uint bias : kBiases) {
+            TestOne(unpack_bias, unpack, opts, bias);
+            if (testing::Test::HasFailure()) return;
+          }
+        }
+      }
+    }
+  }
+};
+
+// No bool: an add has no meaning on a bool output and unpack_bias is not
+// instantiated for it.
+using UnpackBiasTypes = ::testing::Types<uint8_t, uint16_t, uint32_t, uint64_t>;
+
+TYPED_TEST_SUITE(TestUnpackBias, UnpackBiasTypes, UnpackTypeNames);
+
+TYPED_TEST(TestUnpackBias, UnpackBiasScalar) {
+  this->TestAll(&bpacking::unpack_bias_scalar<TypeParam>,
+                &bpacking::unpack_scalar<TypeParam>);
+}
+
+#if defined(ARROW_HAVE_SSE4_2)
+TYPED_TEST(TestUnpackBias, UnpackBiasSse4_2) {
+  this->TestAll(&bpacking::unpack_bias_sse4_2<TypeParam>,
+                &bpacking::unpack_sse4_2<TypeParam>);
+}
+#endif
+
+#if defined(ARROW_HAVE_RUNTIME_AVX2)
+TYPED_TEST(TestUnpackBias, UnpackBiasAvx2) {
+  if (!CpuInfo::GetInstance()->IsSupported(CpuInfo::AVX2)) {
+    GTEST_SKIP() << "Test requires AVX2";
+  }
+  this->TestAll(&bpacking::unpack_bias_avx2<TypeParam>,
+                &bpacking::unpack_avx2<TypeParam>);
+}
+#endif
+
+#if defined(ARROW_HAVE_RUNTIME_AVX512)
+TYPED_TEST(TestUnpackBias, UnpackBiasAvx512) {
+  if (!CpuInfo::GetInstance()->IsSupported(CpuInfo::AVX512)) {
+    GTEST_SKIP() << "Test requires AVX512";
+  }
+  this->TestAll(&bpacking::unpack_bias_avx512<TypeParam>,
+                &bpacking::unpack_avx512<TypeParam>);
+}
+#endif
+
+#if defined(ARROW_HAVE_NEON)
+TYPED_TEST(TestUnpackBias, UnpackBiasNeon) {
+  this->TestAll(&bpacking::unpack_bias_neon<TypeParam>,
+                &bpacking::unpack_neon<TypeParam>);
+}
+#endif
+
+#if defined(ARROW_HAVE_RUNTIME_SVE128)
+TYPED_TEST(TestUnpackBias, UnpackBiasSve128) {
+  if (!CpuInfo::GetInstance()->IsSupported(CpuInfo::SVE128)) {
+    GTEST_SKIP() << "Test requires SVE128";
+  }
+  this->TestAll(&bpacking::unpack_bias_sve128<TypeParam>,
+                &bpacking::unpack_sve128<TypeParam>);
+}
+#endif
+
+#if defined(ARROW_HAVE_RUNTIME_SVE256)
+TYPED_TEST(TestUnpackBias, UnpackBiasSve256) {
+  if (!CpuInfo::GetInstance()->IsSupported(CpuInfo::SVE256)) {
+    GTEST_SKIP() << "Test requires SVE256";
+  }
+  this->TestAll(&bpacking::unpack_bias_sve256<TypeParam>,
+                &bpacking::unpack_sve256<TypeParam>);
+}
+#endif
+
+TYPED_TEST(TestUnpackBias, UnpackBias) {
+  this->TestAll(&unpack_bias<TypeParam>, &unpack<TypeParam>);
+}
+
 }  // namespace arrow::internal

From 7770ac47216d559323c9060c0f131c13cfbe3da3 Mon Sep 17 00:00:00 2001
From: Prateek Gaur <prateek.gaur@snowflake.com>
Date: Sat, 3 Oct 2026 03:11:46 +0000
Subject: [PATCH 02/27] Add the PFOR codec and page format

PFOR packs each vector of 1024 values at a width chosen for most of them
and stores the rest as patched exceptions. This adds frame and width
selection, the exception section, an endian-independent page layout, and
decoding that checks every length against the page before reading it.
int32 and int64 are supported. The codec builds under both CMake and
Meson, with unit tests and a microbenchmark.
---
 cpp/src/arrow/CMakeLists.txt                  |   2 +
 cpp/src/arrow/meson.build                     |   2 +
 cpp/src/arrow/util/CMakeLists.txt             |   4 +
 cpp/src/arrow/util/meson.build                |   1 +
 cpp/src/arrow/util/pfor/pfor.cc               | 396 +++++++++
 cpp/src/arrow/util/pfor/pfor_benchmark.cc     | 312 +++++++
 .../arrow/util/pfor/pfor_constants_internal.h | 103 +++
 cpp/src/arrow/util/pfor/pfor_internal.h       | 237 ++++++
 cpp/src/arrow/util/pfor/pfor_test.cc          | 773 ++++++++++++++++++
 cpp/src/arrow/util/pfor/pfor_wrapper.cc       | 416 ++++++++++
 .../arrow/util/pfor/pfor_wrapper_internal.h   | 156 ++++
 11 files changed, 2402 insertions(+)
 create mode 100644 cpp/src/arrow/util/pfor/pfor.cc
 create mode 100644 cpp/src/arrow/util/pfor/pfor_benchmark.cc
 create mode 100644 cpp/src/arrow/util/pfor/pfor_constants_internal.h
 create mode 100644 cpp/src/arrow/util/pfor/pfor_internal.h
 create mode 100644 cpp/src/arrow/util/pfor/pfor_test.cc
 create mode 100644 cpp/src/arrow/util/pfor/pfor_wrapper.cc
 create mode 100644 cpp/src/arrow/util/pfor/pfor_wrapper_internal.h

diff --git a/cpp/src/arrow/CMakeLists.txt b/cpp/src/arrow/CMakeLists.txt
index 8750598f6c3b..0a239e893258 100644
--- a/cpp/src/arrow/CMakeLists.txt
+++ b/cpp/src/arrow/CMakeLists.txt
@@ -566,6 +566,8 @@ set(ARROW_UTIL_SRCS
     util/math_internal.cc
     util/memory.cc
     util/mutex.cc
+    util/pfor/pfor.cc
+    util/pfor/pfor_wrapper.cc
     util/ree_util.cc
     util/secure_string.cc
     util/string.cc
diff --git a/cpp/src/arrow/meson.build b/cpp/src/arrow/meson.build
index 831bc1218083..ebba2cd22fbb 100644
--- a/cpp/src/arrow/meson.build
+++ b/cpp/src/arrow/meson.build
@@ -204,6 +204,8 @@ arrow_util_srcs = [
     'util/math_internal.cc',
     'util/memory.cc',
     'util/mutex.cc',
+    'util/pfor/pfor.cc',
+    'util/pfor/pfor_wrapper.cc',
     'util/ree_util.cc',
     'util/secure_string.cc',
     'util/string.cc',
diff --git a/cpp/src/arrow/util/CMakeLists.txt b/cpp/src/arrow/util/CMakeLists.txt
index 628e9a4d1c7e..9be9dbfa7188 100644
--- a/cpp/src/arrow/util/CMakeLists.txt
+++ b/cpp/src/arrow/util/CMakeLists.txt
@@ -118,6 +118,10 @@ add_arrow_test(threading-utility-test
                test_common.cc
                thread_pool_test.cc)
 
+add_arrow_test(pfor-test SOURCES pfor/pfor_test.cc)
+
+add_arrow_benchmark(pfor/pfor_benchmark)
+
 add_arrow_benchmark(bit_block_counter_benchmark)
 add_arrow_benchmark(bit_util_benchmark)
 add_arrow_benchmark(bitmap_reader_benchmark)
diff --git a/cpp/src/arrow/util/meson.build b/cpp/src/arrow/util/meson.build
index c39e09c2d030..41f306d3c7d2 100644
--- a/cpp/src/arrow/util/meson.build
+++ b/cpp/src/arrow/util/meson.build
@@ -269,6 +269,7 @@ util_tests = {
         ],
     },
     'arrow-crc32-test': {'sources': ['crc32_test.cc']},
+    'arrow-pfor-test': {'sources': ['pfor/pfor_test.cc']},
 }
 
 foreach key, val : util_tests
diff --git a/cpp/src/arrow/util/pfor/pfor.cc b/cpp/src/arrow/util/pfor/pfor.cc
new file mode 100644
index 000000000000..708515f3e48b
--- /dev/null
+++ b/cpp/src/arrow/util/pfor/pfor.cc
@@ -0,0 +1,396 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+// Core PFOR (Patched Frame of Reference) compression implementation
+//
+// Implementation notes:
+//   - Vector size: 1024
+//   - Max exceptions: PforConstants::ExceptionCountType
+//   - Exception values: original integers (not FOR offsets)
+//   - Bit packing: Arrow's BitWriter/unpack
+
+#include "arrow/util/pfor/pfor_internal.h"
+
+#include <algorithm>
+#include <array>
+#include <cstring>
+#include <limits>
+#include <span>
+
+#include "arrow/util/bit_stream_utils_internal.h"
+#include "arrow/util/bit_util.h"
+#include "arrow/util/bpacking_internal.h"
+#include "arrow/util/endian.h"
+#include "arrow/util/logging.h"
+#include "arrow/util/macros.h"
+#include "arrow/util/ubsan.h"
+
+namespace arrow {
+namespace util {
+namespace pfor {
+
+namespace {
+
+// The PFOR wire format is little-endian, so every multi-byte field converts on the
+// way in and out. The bit-packed deltas need no conversion of their own:
+// bit_util::BitWriter writes them little-endian and arrow::internal::unpack reads
+// them back the same way, so those bytes are copied verbatim.
+//
+// On a little-endian host both helpers below are a plain memcpy.
+template <typename T>
+void StoreLittleEndianArray(const T* values, int64_t num_values, uint8_t* output) {
+  if constexpr (ARROW_LITTLE_ENDIAN == 1) {
+    std::memcpy(output, values, static_cast<size_t>(num_values) * sizeof(T));
+  } else {
+    for (int64_t i = 0; i < num_values; ++i) {
+      util::SafeStore(output + i * sizeof(T), bit_util::ToLittleEndian(values[i]));
+    }
+  }
+}
+
+}  // namespace
+
+// ----------------------------------------------------------------------
+// FindOptimalBitWidth: histogram-based cost model
+
+template <typename T>
+BitWidthResult PforCompression<T>::FindOptimalBitWidth(const UnsignedT* deltas,
+                                                       int32_t num_elements) {
+  constexpr uint8_t max_bits = PforTypeTraits<T>::kMaxBitWidth;
+  constexpr int32_t position_bits =
+      static_cast<int32_t>(sizeof(PforConstants::PositionType)) * 8;
+  constexpr int32_t value_bits = sizeof(T) * 8;
+
+  // Build histogram: histogram[b] = count of deltas requiring exactly b bits.
+  // Use 4 independent accumulators so the read-modify-write doesn't serialize
+  // on repeated bins and the four load->clz->bump chains overlap (this loop is
+  // ~half of encode time; a single histogram array runs scalar and stalls).
+  std::array<int32_t, 65> h0{}, h1{}, h2{}, h3{};
+  int32_t i = 0;
+  for (; i + 4 <= num_elements; i += 4) {
+    ++h0[PforTypeTraits<T>::BitsRequired(deltas[i])];
+    ++h1[PforTypeTraits<T>::BitsRequired(deltas[i + 1])];
+    ++h2[PforTypeTraits<T>::BitsRequired(deltas[i + 2])];
+    ++h3[PforTypeTraits<T>::BitsRequired(deltas[i + 3])];
+  }
+  for (; i < num_elements; ++i) ++h0[PforTypeTraits<T>::BitsRequired(deltas[i])];
+  std::array<int32_t, 65> histogram{};
+  for (int b = 0; b <= 64; ++b) histogram[b] = h0[b] + h1[b] + h2[b] + h3[b];
+
+  // Evaluate each candidate bit width
+  int64_t best_cost = std::numeric_limits<int64_t>::max();
+  uint8_t best_bit_width = max_bits;
+  PforConstants::ExceptionCountType best_num_exceptions = 0;
+
+  int64_t exceptions_above = num_elements;
+
+  for (uint8_t b = 0; b <= max_bits; ++b) {
+    exceptions_above -= histogram[b];
+
+    // A vector holds at most kMaxVectorSize elements, so that is also the most
+    // exceptions one can name. Skipping the wider counts keeps the cast below
+    // exact; the full-width candidate has none at all, so a best is always
+    // found.
+    if (exceptions_above > PforConstants::kMaxVectorSize) {
+      continue;
+    }
+
+    int64_t packing_cost = static_cast<int64_t>(num_elements) * b;
+    int64_t exception_cost = exceptions_above * (position_bits + value_bits);
+    int64_t total_cost = packing_cost + exception_cost;
+
+    if (total_cost < best_cost) {
+      best_cost = total_cost;
+      best_bit_width = b;
+      best_num_exceptions =
+          static_cast<PforConstants::ExceptionCountType>(exceptions_above);
+    }
+  }
+
+  return {best_bit_width, best_num_exceptions};
+}
+
+// ----------------------------------------------------------------------
+// EncodeVector
+
+template <typename T>
+PforEncodedVector<T> PforCompression<T>::EncodeVector(const T* values,
+                                                      int32_t num_elements) {
+  ARROW_DCHECK(num_elements > 0);
+
+  // Step 1: Find min (frame of reference)
+  T min_val = values[0];
+  for (int32_t i = 1; i < num_elements; ++i) {
+    if (values[i] < min_val) min_val = values[i];
+  }
+
+  // Step 2: Compute unsigned deltas. Use a stack scratch for the common
+  // (<=vector-size) case to avoid a per-vector heap alloc + zero-init.
+  const auto unsigned_min = static_cast<UnsignedT>(min_val);
+  constexpr int32_t kFull = static_cast<int32_t>(PforConstants::kPforVectorSize);
+  UnsignedT stack_deltas[kFull];
+  std::vector<UnsignedT> heap_deltas;
+  UnsignedT* deltas = stack_deltas;
+  if (num_elements > kFull) {
+    heap_deltas.resize(num_elements);
+    deltas = heap_deltas.data();
+  }
+  for (int32_t i = 0; i < num_elements; ++i) {
+    deltas[i] = static_cast<UnsignedT>(values[i]) - unsigned_min;
+  }
+
+  // Step 3: Find optimal bit width
+  auto [bit_width, num_exceptions] = FindOptimalBitWidth(deltas, num_elements);
+
+  // Step 4: Collect exceptions and replace with placeholder (0)
+  PforEncodedVector<T> result;
+  result.set_info(PforVectorInfo<T>(min_val, bit_width, num_exceptions));
+
+  if (num_exceptions > 0) {
+    result.mutable_exception_positions().reserve(num_exceptions);
+    result.mutable_exception_values().reserve(num_exceptions);
+
+    UnsignedT mask = (bit_width >= PforTypeTraits<T>::kMaxBitWidth)
+                         ? static_cast<UnsignedT>(-1)
+                         : (static_cast<UnsignedT>(1) << bit_width) - 1;
+
+    for (int32_t i = 0; i < num_elements; ++i) {
+      if (deltas[i] > mask) {
+        result.mutable_exception_positions().push_back(
+            static_cast<PforConstants::PositionType>(i));
+        result.mutable_exception_values().push_back(values[i]);
+        deltas[i] = 0;
+      }
+    }
+  }
+
+  // Step 5: Bit-pack the deltas
+  if (bit_width > 0) {
+    int64_t packed_size =
+        bit_util::BytesForBits(static_cast<int64_t>(num_elements) * bit_width);
+    result.mutable_packed_values().resize(static_cast<size_t>(packed_size), 0);
+
+    bit_util::BitWriter writer(result.mutable_packed_values().data(),
+                               static_cast<int>(packed_size));
+    for (int32_t i = 0; i < num_elements; ++i) {
+      writer.PutValue(static_cast<uint64_t>(deltas[i]), bit_width);
+    }
+    writer.Flush();
+  }
+
+  return result;
+}
+
+// ----------------------------------------------------------------------
+// DecodeVector
+
+template <typename T>
+Result<int64_t> PforCompression<T>::DecodeVector(std::span<const uint8_t> data,
+                                                 int32_t num_elements, T* values) {
+  // Step 1: Read vector info
+  ARROW_ASSIGN_OR_RAISE(auto info, PforVectorInfo<T>::Load(data));
+  const uint8_t* read_ptr = data.data() + PforVectorInfo<T>::kStoredSize;
+
+  // `values` holds num_elements slots, and everything below is sized by fields
+  // that came off the wire, so check them against it before reading or writing.
+  if (info.num_exceptions() > num_elements) {
+    return Status::Invalid("PFOR vector has ", info.num_exceptions(),
+                           " exceptions but only ", num_elements, " elements");
+  }
+  const int64_t packed_bytes =
+      bit_util::BytesForBits(static_cast<int64_t>(num_elements) * info.bit_width());
+  const int64_t exception_bytes =
+      info.num_exceptions() *
+      (static_cast<int64_t>(sizeof(PforConstants::PositionType)) + sizeof(T));
+  if (PforVectorInfo<T>::kStoredSize + packed_bytes + exception_bytes >
+      static_cast<int64_t>(data.size())) {
+    return Status::Invalid(
+        "PFOR vector needs ",
+        PforVectorInfo<T>::kStoredSize + packed_bytes + exception_bytes,
+        " bytes but only ", data.size(), " remain");
+  }
+
+  // Step 2: Handle constant data (bit_width == 0, no exceptions)
+  if (info.bit_width() == 0 && info.num_exceptions() == 0) {
+    std::fill(values, values + num_elements, info.frame_of_reference());
+    return PforVectorInfo<T>::kStoredSize;
+  }
+
+  // Step 3: Unpack bit-packed deltas and add FOR
+  if (info.bit_width() > 0) {
+    const auto unsigned_for = static_cast<UnsignedT>(info.frame_of_reference());
+
+    // The vector kernels load a fixed-size window per step. Use the remaining
+    // page bytes as the read bound so a kernel can process the final step when
+    // its load extends beyond this vector's packed payload.
+    //
+    // `data` runs from this vector to the end of the page, so every byte after
+    // this vector's header is inside the caller's buffer and ours to read.
+    const auto readable_bytes = static_cast<int>(std::min<int64_t>(
+        static_cast<int64_t>(data.size()) - PforVectorInfo<T>::kStoredSize,
+        std::numeric_limits<int>::max()));
+
+    if (unsigned_for == 0) {
+      // FOR is zero: there is no bias to add, so unpack straight into the
+      // output. T and UnsignedT are the same width, so the unsigned bits the
+      // unpacker writes are the signed values — no scratch buffer and no
+      // second (add-FOR) pass. This is the common case (any column whose
+      // minimum is 0) and decodes at the raw unpack speed. Exceptions are
+      // still patched below in Step 4.
+      arrow::internal::unpack(
+          read_ptr, reinterpret_cast<UnsignedT*>(values),
+          arrow::internal::UnpackOptions{static_cast<int>(num_elements), info.bit_width(),
+                                         /*bit_offset=*/0, readable_bytes});
+    } else {
+      // Fold the non-zero frame into the unpacker's store to avoid a second
+      // traversal of the output.
+      //
+      // The add is modular in UnsignedT, so the bits the unpacker stores are the
+      // signed values, exactly as in the FOR==0 case above — no cast pass, no
+      // scratch, and no aliasing question. Exceptions are patched in Step 4.
+      arrow::internal::unpack_bias(
+          read_ptr, reinterpret_cast<UnsignedT*>(values),
+          arrow::internal::UnpackOptions{static_cast<int>(num_elements), info.bit_width(),
+                                         /*bit_offset=*/0, readable_bytes},
+          unsigned_for);
+    }
+
+    read_ptr += packed_bytes;
+  } else {
+    // bit_width == 0 but has exceptions - fill with FOR
+    std::fill(values, values + num_elements, info.frame_of_reference());
+  }
+
+  // Step 4: Patch exceptions (stored as original values at their positions).
+  const PforConstants::ExceptionCountType num_exceptions = info.num_exceptions();
+  if (num_exceptions > 0) {
+    const uint8_t* positions_ptr = read_ptr;
+    read_ptr += num_exceptions * sizeof(PforConstants::PositionType);
+
+    const uint8_t* values_ptr = read_ptr;
+    read_ptr += num_exceptions * sizeof(T);
+
+    // Every position indexes `values`, so one past the end is an out-of-bounds
+    // write. Take the maximum first: a reduction still vectorizes, where a
+    // bounds check with an early return inside the patch loop would not.
+    PforConstants::PositionType max_position = 0;
+    for (PforConstants::ExceptionCountType i = 0; i < num_exceptions; ++i) {
+      max_position = std::max(
+          max_position,
+          bit_util::FromLittleEndian(util::SafeLoadAs<PforConstants::PositionType>(
+              positions_ptr + i * sizeof(PforConstants::PositionType))));
+    }
+    if (max_position >= num_elements) {
+      return Status::Invalid("PFOR exception position ", max_position,
+                             " is outside a vector of ", num_elements, " elements");
+    }
+
+    for (PforConstants::ExceptionCountType i = 0; i < num_exceptions; ++i) {
+      PforConstants::PositionType pos =
+          bit_util::FromLittleEndian(util::SafeLoadAs<PforConstants::PositionType>(
+              positions_ptr + i * sizeof(PforConstants::PositionType)));
+      T value =
+          bit_util::FromLittleEndian(util::SafeLoadAs<T>(values_ptr + i * sizeof(T)));
+      values[static_cast<size_t>(pos)] = value;
+    }
+  }
+
+  return static_cast<int64_t>(read_ptr - data.data());
+}
+
+// ----------------------------------------------------------------------
+// Serialization helpers
+
+template <typename T>
+int64_t PforCompression<T>::SerializedVectorSize(const PforEncodedVector<T>& vec,
+                                                 int32_t num_elements) {
+  int64_t size = PforVectorInfo<T>::kStoredSize;
+  if (vec.info().bit_width() > 0) {
+    size += bit_util::BytesForBits(static_cast<int64_t>(num_elements) *
+                                   vec.info().bit_width());
+  }
+  size += vec.info().num_exceptions() *
+          static_cast<int64_t>(sizeof(PforConstants::PositionType));
+  size += vec.info().num_exceptions() * static_cast<int64_t>(sizeof(T));
+  return size;
+}
+
+template <typename T>
+Result<int64_t> PforCompression<T>::SerializeVector(const PforEncodedVector<T>& vec,
+                                                    int32_t num_elements,
+                                                    std::span<uint8_t> dest) {
+  const int64_t needed = SerializedVectorSize(vec, num_elements);
+  if (static_cast<int64_t>(dest.size()) < needed) {
+    return Status::Invalid("PFOR vector needs ", needed, " bytes to serialize but only ",
+                           dest.size(), " remain");
+  }
+
+  // `needed` is computed from bit_width and num_exceptions, while the copies
+  // below take their lengths from the sections themselves, so a vector whose
+  // info disagrees with its sections would write past `needed` bytes.
+  const int64_t expected_packed_bytes =
+      vec.info().bit_width() > 0
+          ? bit_util::BytesForBits(static_cast<int64_t>(num_elements) *
+                                   vec.info().bit_width())
+          : 0;
+  if (static_cast<int64_t>(vec.packed_values().size()) != expected_packed_bytes) {
+    return Status::Invalid("PFOR vector has ", vec.packed_values().size(),
+                           " packed bytes but bit_width ",
+                           static_cast<int>(vec.info().bit_width()), " over ",
+                           num_elements, " elements needs ", expected_packed_bytes);
+  }
+  if (vec.exception_positions().size() != vec.info().num_exceptions() ||
+      vec.exception_values().size() != vec.info().num_exceptions()) {
+    return Status::Invalid("PFOR vector claims ", vec.info().num_exceptions(),
+                           " exceptions but carries ", vec.exception_positions().size(),
+                           " positions and ", vec.exception_values().size(), " values");
+  }
+
+  uint8_t* write_ptr = dest.data();
+
+  // Write vector info
+  vec.info().Store(std::span<uint8_t>(write_ptr, PforVectorInfo<T>::kStoredSize));
+  write_ptr += PforVectorInfo<T>::kStoredSize;
+
+  // Write packed values
+  if (vec.info().bit_width() > 0) {
+    std::memcpy(write_ptr, vec.packed_values().data(), vec.packed_values().size());
+    write_ptr += vec.packed_values().size();
+  }
+
+  // Write exception positions
+  if (vec.info().num_exceptions() > 0) {
+    StoreLittleEndianArray(vec.exception_positions().data(), vec.info().num_exceptions(),
+                           write_ptr);
+    write_ptr += vec.info().num_exceptions() * sizeof(PforConstants::PositionType);
+
+    // Write exception values (original integers)
+    StoreLittleEndianArray(vec.exception_values().data(), vec.info().num_exceptions(),
+                           write_ptr);
+    write_ptr += vec.info().num_exceptions() * sizeof(T);
+  }
+
+  return static_cast<int64_t>(write_ptr - dest.data());
+}
+
+// Explicit template instantiations
+template class PforCompression<int32_t>;
+template class PforCompression<int64_t>;
+
+}  // namespace pfor
+}  // namespace util
+}  // namespace arrow
diff --git a/cpp/src/arrow/util/pfor/pfor_benchmark.cc b/cpp/src/arrow/util/pfor/pfor_benchmark.cc
new file mode 100644
index 000000000000..127965e0210d
--- /dev/null
+++ b/cpp/src/arrow/util/pfor/pfor_benchmark.cc
@@ -0,0 +1,312 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+// PFOR encoding/decoding benchmarks.
+//
+// Data distributions cover the key archetypes that exercise PFOR's cost model
+// differently:
+//   - Constant: bit_width=0, best case
+//   - Sequential: small range, ideal FOR
+//   - SmallRange: clustered random, good FOR compression
+//   - HighBaseSmallRange: high absolute values, small delta range (timestamps)
+//   - WithOutliers: tests exception handling path
+//   - Random: worst case, full bit-width
+//   - TPC-DS DateSk/StoreSk/ItemSk/Quantity: realistic surrogate key distributions
+
+#include <algorithm>
+#include <cmath>
+#include <cstdint>
+#include <cstring>
+#include <limits>
+#include <numeric>
+#include <random>
+#include <vector>
+
+#include "benchmark/benchmark.h"
+
+#include "arrow/util/logging.h"
+#include "arrow/util/pfor/pfor_internal.h"
+#include "arrow/util/pfor/pfor_wrapper_internal.h"
+
+namespace arrow::util::pfor {
+namespace {
+
+// ----------------------------------------------------------------------
+// Data Generators
+
+using Int32Gen = std::vector<int32_t> (*)(int64_t);
+using Int64Gen = std::vector<int64_t> (*)(int64_t);
+
+template <typename T>
+std::vector<T> GenConstant(int64_t n) {
+  return std::vector<T>(n, static_cast<T>(42));
+}
+
+template <typename T>
+std::vector<T> GenSequential(int64_t n) {
+  std::vector<T> v(n);
+  std::iota(v.begin(), v.end(), static_cast<T>(0));
+  return v;
+}
+
+template <typename T>
+std::vector<T> GenSmallRange(int64_t n) {
+  std::vector<T> v(n);
+  std::mt19937_64 rng(12345);
+  std::uniform_int_distribution<T> dist(100000, 200000);
+  for (auto& x : v) x = dist(rng);
+  return v;
+}
+
+template <typename T>
+std::vector<T> GenHighBaseSmallRange(int64_t n) {
+  std::vector<T> v(n);
+  const T kBase = static_cast<T>(1704067200);
+  std::mt19937_64 rng(12345);
+  std::uniform_int_distribution<T> dist(0, 1000);
+  for (auto& x : v) x = kBase + dist(rng);
+  return v;
+}
+
+template <typename T>
+std::vector<T> GenWithOutliers(int64_t n) {
+  std::vector<T> v(n);
+  std::mt19937_64 rng(42);
+  std::uniform_int_distribution<T> small_dist(1000, 1255);
+  for (auto& x : v) x = small_dist(rng);
+  std::uniform_int_distribution<int64_t> pos_dist(0, n - 1);
+  int num_outliers = std::max(static_cast<int64_t>(1), n / 100);
+  for (int i = 0; i < num_outliers; ++i) {
+    v[pos_dist(rng)] = static_cast<T>(std::numeric_limits<T>::max() / 2 + i);
+  }
+  return v;
+}
+
+template <typename T>
+std::vector<T> GenRandom(int64_t n) {
+  std::vector<T> v(n);
+  std::mt19937_64 rng(99);
+  std::uniform_int_distribution<T> dist(std::numeric_limits<T>::min(),
+                                        std::numeric_limits<T>::max());
+  for (auto& x : v) x = dist(rng);
+  return v;
+}
+
+template <typename T>
+std::vector<T> GenTpcdsSoldDateSk(int64_t n) {
+  std::vector<T> v(n);
+  const T kBase = 2450815;
+  std::mt19937_64 rng(12345);
+  std::uniform_int_distribution<T> dist(0, 1820);
+  for (auto& x : v) x = kBase + dist(rng);
+  return v;
+}
+
+template <typename T>
+std::vector<T> GenTpcdsStoreSk(int64_t n) {
+  std::vector<T> v(n);
+  std::mt19937_64 rng(12345);
+  std::uniform_int_distribution<T> dist(1, 1000);
+  for (auto& x : v) x = dist(rng);
+  return v;
+}
+
+template <typename T>
+std::vector<T> GenTpcdsItemSk(int64_t n) {
+  std::vector<T> v(n);
+  const T kMax = 100000;
+  std::mt19937_64 rng(12345);
+  std::exponential_distribution<double> exp_dist(0.00005);
+  for (auto& x : v) {
+    T val = static_cast<T>(exp_dist(rng));
+    x = std::min(static_cast<T>(val + 1), kMax);
+  }
+  return v;
+}
+
+template <typename T>
+std::vector<T> GenTpcdsQuantity(int64_t n) {
+  std::vector<T> v(n);
+  std::mt19937_64 rng(12345);
+  std::uniform_int_distribution<T> small_dist(1, 10);
+  std::uniform_int_distribution<T> large_dist(11, 100);
+  std::uniform_int_distribution<int> chance(0, 99);
+  for (auto& x : v) {
+    x = (chance(rng) < 90) ? small_dist(rng) : large_dist(rng);
+  }
+  return v;
+}
+
+// ----------------------------------------------------------------------
+// Benchmark Core
+
+template <typename T>
+void BM_PforEncodeImpl(benchmark::State& state, std::vector<T> (*generator)(int64_t)) {
+  const int64_t num_values = state.range(0);
+  auto values = generator(num_values);
+
+  int64_t max_size =
+      PforWrapper<T>::GetMaxCompressedSize(static_cast<int32_t>(num_values)).ValueOrDie();
+  std::vector<uint8_t> compressed(max_size);
+
+  for (auto _ : state) {
+    int64_t comp_size = max_size;
+    ARROW_CHECK_OK(
+        PforWrapper<T>::Encode(values.data(), num_values, compressed.data(), &comp_size));
+    benchmark::DoNotOptimize(comp_size);
+    benchmark::ClobberMemory();
+  }
+
+  state.SetBytesProcessed(state.iterations() * num_values *
+                          static_cast<int64_t>(sizeof(T)));
+  state.SetItemsProcessed(state.iterations() * num_values);
+
+  // Report compression ratio
+  int64_t comp_size = max_size;
+  ARROW_CHECK_OK(
+      PforWrapper<T>::Encode(values.data(), num_values, compressed.data(), &comp_size));
+  state.counters["CompRatio%"] =
+      benchmark::Counter(100.0 * static_cast<double>(comp_size) /
+                         static_cast<double>(num_values * sizeof(T)));
+}
+
+template <typename T>
+void BM_PforDecodeImpl(benchmark::State& state, std::vector<T> (*generator)(int64_t)) {
+  const int64_t num_values = state.range(0);
+  auto values = generator(num_values);
+
+  int64_t max_size =
+      PforWrapper<T>::GetMaxCompressedSize(static_cast<int32_t>(num_values)).ValueOrDie();
+  std::vector<uint8_t> compressed(max_size);
+  int64_t comp_size = max_size;
+  ARROW_CHECK_OK(
+      PforWrapper<T>::Encode(values.data(), num_values, compressed.data(), &comp_size));
+
+  std::vector<T> decoded(num_values);
+
+  for (auto _ : state) {
+    ARROW_CHECK_OK(
+        PforWrapper<T>::Decode(compressed.data(), comp_size, num_values, decoded.data()));
+    benchmark::ClobberMemory();
+  }
+
+  state.SetBytesProcessed(state.iterations() * num_values *
+                          static_cast<int64_t>(sizeof(T)));
+  state.SetItemsProcessed(state.iterations() * num_values);
+}
+
+// ----------------------------------------------------------------------
+// Non-template wrappers to avoid comma-in-macro issues with BENCHMARK_CAPTURE
+
+void BM_PforEncodeInt32(benchmark::State& state, Int32Gen gen) {
+  BM_PforEncodeImpl<int32_t>(state, gen);
+}
+void BM_PforDecodeInt32(benchmark::State& state, Int32Gen gen) {
+  BM_PforDecodeImpl<int32_t>(state, gen);
+}
+void BM_PforEncodeInt64(benchmark::State& state, Int64Gen gen) {
+  BM_PforEncodeImpl<int64_t>(state, gen);
+}
+void BM_PforDecodeInt64(benchmark::State& state, Int64Gen gen) {
+  BM_PforDecodeImpl<int64_t>(state, gen);
+}
+
+// ----------------------------------------------------------------------
+// Benchmark sizes: 1K, 10K, 100K, 1M
+
+static void CustomArgs(benchmark::internal::Benchmark* b) {
+  for (int64_t n : {1024, 10240, 102400, 1048576}) {
+    b->Arg(n);
+  }
+}
+
+// ----------------------------------------------------------------------
+// INT32 Encode
+
+BENCHMARK_CAPTURE(BM_PforEncodeInt32, Constant, &GenConstant<int32_t>)->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt32, Sequential, &GenSequential<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt32, SmallRange, &GenSmallRange<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt32, HighBaseSmallRange, &GenHighBaseSmallRange<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt32, WithOutliers, &GenWithOutliers<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt32, Random, &GenRandom<int32_t>)->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt32, TpcdsSoldDateSk, &GenTpcdsSoldDateSk<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt32, TpcdsStoreSk, &GenTpcdsStoreSk<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt32, TpcdsItemSk, &GenTpcdsItemSk<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt32, TpcdsQuantity, &GenTpcdsQuantity<int32_t>)
+    ->Apply(CustomArgs);
+
+// INT32 Decode
+
+BENCHMARK_CAPTURE(BM_PforDecodeInt32, Constant, &GenConstant<int32_t>)->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt32, Sequential, &GenSequential<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt32, SmallRange, &GenSmallRange<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt32, HighBaseSmallRange, &GenHighBaseSmallRange<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt32, WithOutliers, &GenWithOutliers<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt32, Random, &GenRandom<int32_t>)->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt32, TpcdsSoldDateSk, &GenTpcdsSoldDateSk<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt32, TpcdsStoreSk, &GenTpcdsStoreSk<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt32, TpcdsItemSk, &GenTpcdsItemSk<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt32, TpcdsQuantity, &GenTpcdsQuantity<int32_t>)
+    ->Apply(CustomArgs);
+
+// ----------------------------------------------------------------------
+// INT64 Encode
+
+BENCHMARK_CAPTURE(BM_PforEncodeInt64, Constant, &GenConstant<int64_t>)->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt64, Sequential, &GenSequential<int64_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt64, SmallRange, &GenSmallRange<int64_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt64, HighBaseSmallRange, &GenHighBaseSmallRange<int64_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt64, WithOutliers, &GenWithOutliers<int64_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt64, Random, &GenRandom<int64_t>)->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt64, TpcdsSoldDateSk, &GenTpcdsSoldDateSk<int64_t>)
+    ->Apply(CustomArgs);
+
+// INT64 Decode
+
+BENCHMARK_CAPTURE(BM_PforDecodeInt64, Constant, &GenConstant<int64_t>)->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt64, Sequential, &GenSequential<int64_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt64, SmallRange, &GenSmallRange<int64_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt64, HighBaseSmallRange, &GenHighBaseSmallRange<int64_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt64, WithOutliers, &GenWithOutliers<int64_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt64, Random, &GenRandom<int64_t>)->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt64, TpcdsSoldDateSk, &GenTpcdsSoldDateSk<int64_t>)
+    ->Apply(CustomArgs);
+
+}  // namespace
+}  // namespace arrow::util::pfor
diff --git a/cpp/src/arrow/util/pfor/pfor_constants_internal.h b/cpp/src/arrow/util/pfor/pfor_constants_internal.h
new file mode 100644
index 000000000000..863ffa5a7343
--- /dev/null
+++ b/cpp/src/arrow/util/pfor/pfor_constants_internal.h
@@ -0,0 +1,103 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+// Constants for PFOR (Patched Frame of Reference) compression
+
+#pragma once
+
+#include <bit>
+#include <cstdint>
+#include <type_traits>
+
+namespace arrow {
+namespace util {
+namespace pfor {
+
+/// \brief Constants used throughout PFOR compression
+class PforConstants {
+ public:
+  /// Number of elements compressed together as a unit.
+  static constexpr int64_t kPforVectorSize = 1024;
+
+  /// log2(kPforVectorSize)
+  static constexpr uint8_t kDefaultLogVectorSize = 10;
+
+  /// Minimum allowed log vector size
+  static constexpr uint8_t kMinLogVectorSize = 3;
+
+  /// Maximum allowed log vector size
+  static constexpr uint8_t kMaxLogVectorSize = 15;
+
+  /// Type used to store vector data offsets (supports pages up to 4GB)
+  using OffsetType = uint32_t;
+
+  /// Type used to store exception positions within a compressed vector.
+  using PositionType = uint16_t;
+
+  /// Type used to store the number of exceptions in a compressed vector.
+  ///
+  /// Unsigned: a vector holds up to 2^kMaxLogVectorSize elements and every one
+  /// of them can be an exception, so a count of 32768 has to be representable.
+  using ExceptionCountType = uint16_t;
+
+  /// Largest vector the format allows, in elements.
+  static constexpr int32_t kMaxVectorSize = 1 << kMaxLogVectorSize;
+
+  /// Page header size in bytes: packing_mode, log_vector_size and
+  /// value_byte_width one byte each, then num_elements. Derived from the field
+  /// types rather than written out, so that widening a field cannot leave the
+  /// constant behind; StoreHeader and LoadHeader are the two readers of it.
+  static constexpr int64_t kHeaderSize =
+      sizeof(uint8_t) + sizeof(uint8_t) + sizeof(uint8_t) + sizeof(int32_t);
+
+  /// Packing mode: FOR + bit-packing (currently the only mode).
+  static constexpr uint8_t kPackingModeForBitPack = 0;
+};
+
+/// \brief Type traits for PFOR integer types
+template <typename T>
+struct PforTypeTraits {};
+
+template <>
+struct PforTypeTraits<int32_t> {
+  using UnsignedType = uint32_t;
+  static constexpr uint8_t kMaxBitWidth = 32;
+  /// PforVectorInfo size: frame of reference, bit-width byte, exception count.
+  static constexpr int64_t kVectorInfoSize =
+      sizeof(int32_t) + sizeof(uint8_t) + sizeof(PforConstants::ExceptionCountType);
+
+  static uint8_t BitsRequired(uint32_t value) {
+    return static_cast<uint8_t>(std::bit_width(value));
+  }
+};
+
+template <>
+struct PforTypeTraits<int64_t> {
+  using UnsignedType = uint64_t;
+  static constexpr uint8_t kMaxBitWidth = 64;
+  /// PforVectorInfo size: frame of reference, bit-width byte, exception count.
+  static constexpr int64_t kVectorInfoSize =
+      sizeof(int64_t) + sizeof(uint8_t) + sizeof(PforConstants::ExceptionCountType);
+
+  static uint8_t BitsRequired(uint64_t value) {
+    return static_cast<uint8_t>(std::bit_width(value));
+  }
+};
+
+}  // namespace pfor
+}  // namespace util
+}  // namespace arrow
diff --git a/cpp/src/arrow/util/pfor/pfor_internal.h b/cpp/src/arrow/util/pfor/pfor_internal.h
new file mode 100644
index 000000000000..e766f144813f
--- /dev/null
+++ b/cpp/src/arrow/util/pfor/pfor_internal.h
@@ -0,0 +1,237 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+// Core PFOR (Patched Frame of Reference) compression algorithm
+//
+// PFOR compresses integer columns by:
+//   1. Subtracting the minimum value (Frame of Reference)
+//   2. Choosing an optimal bit width via a cost model
+//   3. Bit-packing the deltas at the chosen width
+//   4. Storing outlier values (exceptions) separately
+
+#pragma once
+
+#include <cstdint>
+#include <cstring>
+#include <span>
+#include <vector>
+
+#include "arrow/result.h"
+#include "arrow/status.h"
+#include "arrow/util/endian.h"
+#include "arrow/util/pfor/pfor_constants_internal.h"
+#include "arrow/util/ubsan.h"
+
+namespace arrow {
+namespace util {
+namespace pfor {
+
+// ----------------------------------------------------------------------
+// Per-vector metadata
+
+/// \brief PFOR vector metadata stored at the start of each compressed vector.
+///
+/// For INT32 (7 bytes): [frame_of_reference(4B)] [bit_width(1B)] [num_exceptions(2B)]
+/// For INT64 (11 bytes): [frame_of_reference(8B)] [bit_width(1B)] [num_exceptions(2B)]
+///
+/// num_exceptions is unsigned: a vector holds up to kMaxVectorSize elements,
+/// so the count has to reach 32768, which a signed 16-bit field cannot hold.
+/// Its wire type is PforConstants::ExceptionCountType.
+///
+/// The bit_width byte stores the actual bit width in bits 0..6; bit 7 is
+/// reserved (always written as 0 and ignored on load), leaving room for a
+/// future flag without changing the layout of existing buffers.
+///
+/// Seven bits, not six: the range is 0..64 inclusive, and 64 does not fit in
+/// six. A 6-bit mask stored an INT64 vector whose deltas need the full 64 bits
+/// as width 0, and since such a vector has no exceptions either, Load reported
+/// a constant vector and the decoder filled the output with the frame of
+/// reference -- silently, with no error and no size mismatch.
+template <typename T>
+class PforVectorInfo {
+ public:
+  static constexpr uint8_t kBitWidthMask = 0x7F;
+
+  PforVectorInfo() = default;
+  PforVectorInfo(T frame_of_reference, uint8_t bit_width,
+                 PforConstants::ExceptionCountType num_exceptions)
+      : frame_of_reference_(frame_of_reference),
+        bit_width_(bit_width),
+        num_exceptions_(num_exceptions) {}
+
+  T frame_of_reference() const { return frame_of_reference_; }
+  uint8_t bit_width() const { return bit_width_; }
+  PforConstants::ExceptionCountType num_exceptions() const { return num_exceptions_; }
+
+  void set_frame_of_reference(T frame_of_reference) {
+    frame_of_reference_ = frame_of_reference;
+  }
+  void set_bit_width(uint8_t bit_width) { bit_width_ = bit_width; }
+  void set_num_exceptions(PforConstants::ExceptionCountType num_exceptions) {
+    num_exceptions_ = num_exceptions;
+  }
+
+  /// \brief Store this info to a byte buffer (little-endian)
+  void Store(std::span<uint8_t> dest) const {
+    uint8_t* ptr = dest.data();
+    util::SafeStore(ptr, bit_util::ToLittleEndian(frame_of_reference_));
+    // bits 0..6 = bit width; bit 7 reserved (0).
+    ptr[sizeof(T)] = static_cast<uint8_t>(bit_width_ & kBitWidthMask);
+    util::SafeStore(ptr + sizeof(T) + 1, bit_util::ToLittleEndian(num_exceptions_));
+  }
+
+  /// \brief Load this info from a byte buffer (little-endian)
+  static Result<PforVectorInfo> Load(std::span<const uint8_t> src) {
+    if (src.size() < static_cast<size_t>(kStoredSize)) {
+      return Status::Invalid("PFOR vector info buffer too small: ", src.size(), " < ",
+                             kStoredSize);
+    }
+    PforVectorInfo info;
+    const uint8_t* ptr = src.data();
+    info.frame_of_reference_ = bit_util::FromLittleEndian(util::SafeLoadAs<T>(ptr));
+    // Mask off the reserved high bit (7).
+    info.bit_width_ = static_cast<uint8_t>(ptr[sizeof(T)] & kBitWidthMask);
+    info.num_exceptions_ = bit_util::FromLittleEndian(
+        util::SafeLoadAs<PforConstants::ExceptionCountType>(ptr + sizeof(T) + 1));
+    if (info.bit_width_ > PforTypeTraits<T>::kMaxBitWidth) {
+      return Status::Invalid("PFOR bit_width out of range: ",
+                             static_cast<int>(info.bit_width_));
+    }
+    if (info.num_exceptions_ > PforConstants::kMaxVectorSize) {
+      return Status::Invalid("PFOR num_exceptions exceeds the maximum vector size: ",
+                             info.num_exceptions_);
+    }
+    return info;
+  }
+
+  /// \brief Serialized size in bytes
+  static constexpr int64_t kStoredSize = PforTypeTraits<T>::kVectorInfoSize;
+
+ private:
+  T frame_of_reference_ = 0;
+  uint8_t bit_width_ = 0;
+  PforConstants::ExceptionCountType num_exceptions_ = 0;
+
+  static_assert(kStoredSize == sizeof(frame_of_reference_) + sizeof(bit_width_) +
+                                   sizeof(num_exceptions_),
+                "kStoredSize must match the fields Store writes and Load reads");
+};
+
+// ----------------------------------------------------------------------
+// Encoded vector representation
+
+/// \brief A PFOR-encoded vector with all its data sections
+template <typename T>
+class PforEncodedVector {
+ public:
+  PforEncodedVector() = default;
+
+  const PforVectorInfo<T>& info() const { return info_; }
+  PforVectorInfo<T>& mutable_info() { return info_; }
+  void set_info(const PforVectorInfo<T>& info) { info_ = info; }
+
+  const std::vector<uint8_t>& packed_values() const { return packed_values_; }
+  std::vector<uint8_t>& mutable_packed_values() { return packed_values_; }
+  void set_packed_values(std::vector<uint8_t> v) { packed_values_ = std::move(v); }
+
+  const std::vector<PforConstants::PositionType>& exception_positions() const {
+    return exception_positions_;
+  }
+  std::vector<PforConstants::PositionType>& mutable_exception_positions() {
+    return exception_positions_;
+  }
+  void set_exception_positions(std::vector<PforConstants::PositionType> v) {
+    exception_positions_ = std::move(v);
+  }
+
+  const std::vector<T>& exception_values() const { return exception_values_; }
+  std::vector<T>& mutable_exception_values() { return exception_values_; }
+  void set_exception_values(std::vector<T> v) { exception_values_ = std::move(v); }
+
+ private:
+  PforVectorInfo<T> info_;
+  std::vector<uint8_t> packed_values_;
+  std::vector<PforConstants::PositionType> exception_positions_;
+  std::vector<T> exception_values_;
+};
+
+// ----------------------------------------------------------------------
+// Cost model result
+
+/// \brief Result of the optimal bit width search
+struct BitWidthResult {
+  uint8_t bit_width = 0;
+  PforConstants::ExceptionCountType num_exceptions = 0;
+};
+
+// ----------------------------------------------------------------------
+// Core compression/decompression
+
+/// \brief PFOR compression and decompression algorithms
+///
+/// \tparam T the integer type (int32_t or int64_t)
+template <typename T>
+class PforCompression {
+ public:
+  using UnsignedT = typename PforTypeTraits<T>::UnsignedType;
+
+  /// \brief Find the optimal bit width using the cost model
+  ///
+  /// Evaluates every candidate bit width and selects the one that
+  /// minimizes total encoded size (packing cost + exception cost).
+  ///
+  /// \param[in] deltas unsigned deltas after FOR subtraction
+  /// \param[in] num_elements number of elements
+  /// \return the optimal bit width and exception count
+  static BitWidthResult FindOptimalBitWidth(const UnsignedT* deltas,
+                                            int32_t num_elements);
+
+  /// \brief Encode a single vector of integers
+  ///
+  /// \param[in] values input integer values
+  /// \param[in] num_elements number of elements (up to vector_size)
+  /// \pre num_elements > 0; the frame of reference is values[0] reduced over the
+  ///      rest, so there is no answer for an empty vector
+  /// \return the encoded vector with all sections
+  static PforEncodedVector<T> EncodeVector(const T* values, int32_t num_elements);
+
+  /// \brief Decode a single vector from compressed data
+  ///
+  /// \param[in] data span over the compressed vector data
+  /// \param[in] num_elements number of elements in this vector
+  /// \param[out] values output buffer for num_elements decoded integers
+  /// \return number of bytes consumed from data, or error
+  static Result<int64_t> DecodeVector(std::span<const uint8_t> data, int32_t num_elements,
+                                      T* values);
+
+  /// \brief Calculate the serialized size of an encoded vector
+  static int64_t SerializedVectorSize(const PforEncodedVector<T>& vec,
+                                      int32_t num_elements);
+
+  /// \brief Serialize an encoded vector to a byte buffer
+  ///
+  /// \param[in] vec the encoded vector
+  /// \param[in] num_elements number of elements
+  /// \param[out] dest output buffer, at least SerializedVectorSize() bytes
+  /// \return number of bytes written, or an error if `dest` is too small
+  static Result<int64_t> SerializeVector(const PforEncodedVector<T>& vec,
+                                         int32_t num_elements, std::span<uint8_t> dest);
+};
+
+}  // namespace pfor
+}  // namespace util
+}  // namespace arrow
diff --git a/cpp/src/arrow/util/pfor/pfor_test.cc b/cpp/src/arrow/util/pfor/pfor_test.cc
new file mode 100644
index 000000000000..c63be0d5e201
--- /dev/null
+++ b/cpp/src/arrow/util/pfor/pfor_test.cc
@@ -0,0 +1,773 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include <gtest/gtest.h>
+
+#include <algorithm>
+#include <cstdint>
+#include <limits>
+#include <numeric>
+#include <random>
+#include <span>
+#include <string>
+#include <vector>
+
+#include "arrow/testing/gtest_util.h"
+#include "arrow/util/logging.h"
+#include "arrow/util/pfor/pfor_internal.h"
+#include "arrow/util/pfor/pfor_wrapper_internal.h"
+
+namespace arrow::util::pfor {
+
+// ----------------------------------------------------------------------
+// Test fixture
+//
+// PFOR is instantiated for int32_t and int64_t, and the two differ in the
+// widths of the frame of reference, the packed deltas and the exception values,
+// so nearly every test here belongs to both. The helpers hide the width
+// arithmetic; tests that poke at particular byte offsets derive them from
+// sizeof(T) and kStoredSize rather than writing them out.
+
+template <typename T>
+class PforTest : public ::testing::Test {
+ protected:
+  using UnsignedT = typename PforTypeTraits<T>::UnsignedType;
+
+  /// Encode, serialize and decode a single vector, checking that it round-trips.
+  ///
+  /// \param[out] encoded_out the encoded form, for tests that assert on its
+  ///             metadata; may be null
+  void RoundTripVector(const std::vector<T>& values,
+                       PforEncodedVector<T>* encoded_out = nullptr) {
+    const auto num_elements = static_cast<int32_t>(values.size());
+    auto encoded = PforCompression<T>::EncodeVector(values.data(), num_elements);
+
+    const int64_t needed =
+        PforCompression<T>::SerializedVectorSize(encoded, num_elements);
+    std::vector<uint8_t> buffer(needed);
+    ASSERT_OK_AND_ASSIGN(const int64_t written, PforCompression<T>::SerializeVector(
+                                                    encoded, num_elements, buffer));
+    ASSERT_EQ(needed, written);
+
+    std::vector<T> decoded(values.size());
+    ASSERT_OK(PforCompression<T>::DecodeVector(buffer, num_elements, decoded.data()));
+    ASSERT_EQ(values, decoded);
+
+    if (encoded_out != nullptr) {
+      *encoded_out = std::move(encoded);
+    }
+  }
+
+  /// Encode and decode a whole page, checking that it round-trips and stays
+  /// inside the bound the encoder allocates from.
+  ///
+  /// \param[out] comp_size_out the compressed size, for tests that assert on
+  ///             the compression ratio; may be null
+  void RoundTripPage(const std::vector<T>& values, int64_t* comp_size_out = nullptr) {
+    const auto num_values = static_cast<int32_t>(values.size());
+    ASSERT_OK_AND_ASSIGN(const int64_t max_size,
+                         PforWrapper<T>::GetMaxCompressedSize(num_values));
+    std::vector<uint8_t> compressed(max_size);
+    int64_t comp_size = max_size;
+    ASSERT_OK(
+        PforWrapper<T>::Encode(values.data(), num_values, compressed.data(), &comp_size));
+    ASSERT_GT(comp_size, 0);
+    ASSERT_LE(comp_size, max_size);
+
+    std::vector<T> decoded(values.size());
+    ASSERT_OK(
+        PforWrapper<T>::Decode(compressed.data(), comp_size, num_values, decoded.data()));
+    ASSERT_EQ(values, decoded);
+
+    if (comp_size_out != nullptr) {
+      *comp_size_out = comp_size;
+    }
+  }
+
+  /// Encode `values` and return the compressed bytes, sized exactly.
+  static std::vector<uint8_t> EncodePage(const std::vector<T>& values) {
+    const auto num_values = static_cast<int32_t>(values.size());
+    int64_t comp_size = PforWrapper<T>::GetMaxCompressedSize(num_values).ValueOrDie();
+    std::vector<uint8_t> compressed(comp_size);
+    ARROW_CHECK_OK(
+        PforWrapper<T>::Encode(values.data(), num_values, compressed.data(), &comp_size));
+    compressed.resize(comp_size);
+    return compressed;
+  }
+
+  /// Offset of the first vector in a single-vector page: header, then the
+  /// one-entry offset array.
+  static constexpr int64_t kFirstVectorOffset =
+      PforConstants::kHeaderSize +
+      static_cast<int64_t>(sizeof(PforConstants::OffsetType));
+
+  /// Offsets of the PforVectorInfo fields, relative to the start of a vector.
+  static constexpr int64_t kBitWidthOffset = static_cast<int64_t>(sizeof(T));
+  static constexpr int64_t kNumExceptionsOffset = kBitWidthOffset + 1;
+
+  static std::vector<T> RandomValues(int32_t num_values, T min, T max, uint32_t seed) {
+    std::vector<T> values(num_values);
+    std::mt19937 rng(seed);
+    std::uniform_int_distribution<T> dist(min, max);
+    for (auto& v : values) v = dist(rng);
+    return values;
+  }
+};
+
+using PforTypes = ::testing::Types<int32_t, int64_t>;
+TYPED_TEST_SUITE(PforTest, PforTypes);
+
+namespace {
+
+void StoreLE32(uint8_t* dest, uint32_t value) {
+  for (int i = 0; i < 4; ++i) {
+    dest[i] = static_cast<uint8_t>(value >> (8 * i));
+  }
+}
+
+}  // namespace
+
+// ----------------------------------------------------------------------
+// Constants Tests
+
+TEST(PforConstantsTest, VectorSizeIsPowerOfTwo) {
+  EXPECT_EQ(PforConstants::kPforVectorSize, 1024);
+  EXPECT_EQ(1 << PforConstants::kDefaultLogVectorSize, PforConstants::kPforVectorSize);
+}
+
+TEST(PforConstantsTest, VectorInfoSizes) {
+  EXPECT_EQ(PforTypeTraits<int32_t>::kVectorInfoSize, 7);
+  EXPECT_EQ(PforTypeTraits<int64_t>::kVectorInfoSize, 11);
+}
+
+// ----------------------------------------------------------------------
+// BitsRequired Tests
+
+TYPED_TEST(PforTest, BitsRequired) {
+  using T = TypeParam;
+  using UnsignedT = typename PforTypeTraits<T>::UnsignedType;
+
+  EXPECT_EQ(PforTypeTraits<T>::BitsRequired(0), 0);
+  EXPECT_EQ(PforTypeTraits<T>::BitsRequired(1), 1);
+  EXPECT_EQ(PforTypeTraits<T>::BitsRequired(2), 2);
+  EXPECT_EQ(PforTypeTraits<T>::BitsRequired(3), 2);
+  EXPECT_EQ(PforTypeTraits<T>::BitsRequired(255), 8);
+  EXPECT_EQ(PforTypeTraits<T>::BitsRequired(256), 9);
+  EXPECT_EQ(PforTypeTraits<T>::BitsRequired(std::numeric_limits<UnsignedT>::max()),
+            PforTypeTraits<T>::kMaxBitWidth);
+}
+
+// ----------------------------------------------------------------------
+// VectorInfo Serialization Tests
+
+TYPED_TEST(PforTest, VectorInfoRoundTrip) {
+  using T = TypeParam;
+  PforVectorInfo<T> info;
+  info.set_frame_of_reference(-42);
+  info.set_bit_width(17);
+  info.set_num_exceptions(300);
+
+  std::vector<uint8_t> buf(PforVectorInfo<T>::kStoredSize);
+  info.Store(buf);
+  ASSERT_OK_AND_ASSIGN(auto loaded, PforVectorInfo<T>::Load(buf));
+
+  EXPECT_EQ(loaded.frame_of_reference(), -42);
+  EXPECT_EQ(loaded.bit_width(), 17);
+  EXPECT_EQ(loaded.num_exceptions(), 300);
+}
+
+// The extremes of every field at once: the widest frame of reference the type
+// can hold and the full bit width. A six-bit width field could not store 64,
+// and reported such a vector as constant.
+TYPED_TEST(PforTest, VectorInfoRoundTripAtFieldExtremes) {
+  using T = TypeParam;
+  constexpr T kFrameOfReference = std::numeric_limits<T>::min();
+  PforVectorInfo<T> info(kFrameOfReference, PforTypeTraits<T>::kMaxBitWidth, 30000);
+
+  std::vector<uint8_t> buf(PforVectorInfo<T>::kStoredSize);
+  info.Store(buf);
+  ASSERT_OK_AND_ASSIGN(auto loaded, PforVectorInfo<T>::Load(buf));
+
+  EXPECT_EQ(loaded.frame_of_reference(), kFrameOfReference);
+  EXPECT_EQ(loaded.bit_width(), PforTypeTraits<T>::kMaxBitWidth);
+  EXPECT_EQ(loaded.num_exceptions(), 30000);
+}
+
+// Every element of a maximum-size vector can be an exception, so the count has
+// to reach kMaxVectorSize. A signed 16-bit field stopped one short of that.
+TYPED_TEST(PforTest, VectorInfoNumExceptionsAtMaxVectorSize) {
+  using T = TypeParam;
+  PforVectorInfo<T> info;
+  info.set_bit_width(3);
+  info.set_num_exceptions(PforConstants::kMaxVectorSize);
+
+  std::vector<uint8_t> buf(PforVectorInfo<T>::kStoredSize);
+  info.Store(buf);
+  ASSERT_OK_AND_ASSIGN(auto loaded, PforVectorInfo<T>::Load(buf));
+
+  EXPECT_EQ(loaded.num_exceptions(), PforConstants::kMaxVectorSize);
+}
+
+TYPED_TEST(PforTest, VectorInfoRejectsNumExceptionsAboveMaxVectorSize) {
+  using T = TypeParam;
+  // [FOR] [bit_width 1B] [num_exceptions 2B], with a count no vector can have.
+  std::vector<uint8_t> buf(PforVectorInfo<T>::kStoredSize, 0);
+  buf[TestFixture::kBitWidthOffset] = 3;
+  buf[TestFixture::kNumExceptionsOffset] = 0xFF;
+  buf[TestFixture::kNumExceptionsOffset + 1] = 0xFF;
+  ASSERT_RAISES(Invalid, PforVectorInfo<T>::Load(buf));
+}
+
+TYPED_TEST(PforTest, VectorInfoRejectsUndersizedBuffer) {
+  using T = TypeParam;
+  std::vector<uint8_t> buf(PforVectorInfo<T>::kStoredSize - 1, 0);
+  ASSERT_RAISES(Invalid, PforVectorInfo<T>::Load(buf));
+}
+
+// ----------------------------------------------------------------------
+// Cost Model Tests
+
+TYPED_TEST(PforTest, CostModelAllIdentical) {
+  using T = TypeParam;
+  using UnsignedT = typename PforTypeTraits<T>::UnsignedType;
+  // All deltas are 0 => bit_width should be 0, no exceptions
+  std::vector<UnsignedT> deltas(100, 0);
+  auto result = PforCompression<T>::FindOptimalBitWidth(deltas.data(), 100);
+  EXPECT_EQ(result.bit_width, 0);
+  EXPECT_EQ(result.num_exceptions, 0);
+}
+
+TYPED_TEST(PforTest, CostModelSingleOutlier) {
+  using T = TypeParam;
+  using UnsignedT = typename PforTypeTraits<T>::UnsignedType;
+  // 99 values fit in 3 bits, 1 outlier needs 16 bits
+  std::vector<UnsignedT> deltas(100, 5);  // all fit in 3 bits
+  deltas[50] = 50000;                     // outlier: 16 bits
+  auto result = PforCompression<T>::FindOptimalBitWidth(deltas.data(), 100);
+  // An exception costs a 16-bit position plus a full-width value, so at
+  // bit_width=3 the vector costs 100*3 + 1*(16 + 8*sizeof(T)) bits, against
+  // 100*16 at bit_width=16. Patching the one outlier wins for both widths of T.
+  EXPECT_EQ(result.bit_width, 3);
+  EXPECT_EQ(result.num_exceptions, 1);
+}
+
+TYPED_TEST(PforTest, CostModelNoOutliers) {
+  using T = TypeParam;
+  using UnsignedT = typename PforTypeTraits<T>::UnsignedType;
+  // All values fit in 8 bits
+  std::vector<UnsignedT> deltas(100);
+  for (int32_t i = 0; i < 100; ++i) deltas[i] = i * 2;
+  auto result = PforCompression<T>::FindOptimalBitWidth(deltas.data(), 100);
+  EXPECT_EQ(result.num_exceptions, 0);
+  EXPECT_LE(result.bit_width, 8);
+}
+
+// ----------------------------------------------------------------------
+// Vector Encode/Decode Round-Trip Tests
+
+TYPED_TEST(PforTest, VectorSimpleSequence) {
+  using T = TypeParam;
+  std::vector<T> values(64);
+  std::iota(values.begin(), values.end(), 100);
+
+  PforEncodedVector<T> encoded;
+  this->RoundTripVector(values, &encoded);
+  EXPECT_EQ(encoded.info().frame_of_reference(), 100);
+  EXPECT_EQ(encoded.info().num_exceptions(), 0);
+}
+
+TYPED_TEST(PforTest, VectorWithOutlier) {
+  using T = TypeParam;
+  std::vector<T> values = {100, 102, 101, 103, 100, 99, 50000, 104};
+
+  PforEncodedVector<T> encoded;
+  this->RoundTripVector(values, &encoded);
+  EXPECT_EQ(encoded.info().frame_of_reference(), 99);
+  EXPECT_GT(encoded.info().num_exceptions(), 0);
+}
+
+TYPED_TEST(PforTest, VectorAllIdentical) {
+  using T = TypeParam;
+  std::vector<T> values(100, 42);
+
+  PforEncodedVector<T> encoded;
+  this->RoundTripVector(values, &encoded);
+  EXPECT_EQ(encoded.info().bit_width(), 0);
+  EXPECT_EQ(encoded.info().num_exceptions(), 0);
+}
+
+TYPED_TEST(PforTest, VectorNegativeValues) {
+  using T = TypeParam;
+  std::vector<T> values = {-100, -50, -200, -1, -150};
+
+  PforEncodedVector<T> encoded;
+  this->RoundTripVector(values, &encoded);
+  EXPECT_EQ(encoded.info().frame_of_reference(), -200);
+}
+
+// The frame of reference is subtracted in the unsigned domain, so a vector
+// spanning the whole range of T has a delta that only wraps to the right answer.
+TYPED_TEST(PforTest, VectorMinMaxEdge) {
+  using T = TypeParam;
+  std::vector<T> values = {std::numeric_limits<T>::min(), std::numeric_limits<T>::max(),
+                           0, -1, 1};
+  this->RoundTripVector(values);
+}
+
+TYPED_TEST(PforTest, VectorSingleElement) {
+  using T = TypeParam;
+  this->RoundTripVector(std::vector<T>{42});
+}
+
+// ----------------------------------------------------------------------
+// Page-Level Wrapper Tests
+
+TYPED_TEST(PforTest, PageSmall) { this->RoundTripPage({10, 20, 30, 40, 50}); }
+
+TYPED_TEST(PforTest, PageExactOneVector) {
+  using T = TypeParam;
+  std::vector<T> values(PforConstants::kPforVectorSize);
+  std::iota(values.begin(), values.end(), 0);
+  this->RoundTripPage(values);
+}
+
+TYPED_TEST(PforTest, PageMultipleVectors) {
+  // 2.5 vectors worth of data
+  this->RoundTripPage(TestFixture::RandomValues(2560, 0, 1000, /*seed=*/42));
+}
+
+TYPED_TEST(PforTest, PageWithOutliers) {
+  using T = TypeParam;
+  std::vector<T> values(1024, 100);
+  values[0] = -999999;
+  values[100] = 888888;
+  values[500] = 777777;
+  values[1023] = -123456;
+  this->RoundTripPage(values);
+}
+
+TYPED_TEST(PforTest, PagePartialTrailingVector) {
+  using T = TypeParam;
+  auto values = TestFixture::RandomValues(3000, 0, 100000, /*seed=*/123);
+  values[0] = std::numeric_limits<T>::max() / 2;
+  values[1500] = std::numeric_limits<T>::min() / 2;
+  this->RoundTripPage(values);
+}
+
+TYPED_TEST(PforTest, PageSingleElement) {
+  using T = TypeParam;
+  this->RoundTripPage(std::vector<T>{42});
+}
+
+TYPED_TEST(PforTest, PageAllZeros) {
+  using T = TypeParam;
+  std::vector<T> values(1024, 0);
+  int64_t comp_size = 0;
+  this->RoundTripPage(values, &comp_size);
+  // bit_width is 0, so the page is header, offset array and vector info only.
+  EXPECT_LT(comp_size, 100);
+}
+
+TYPED_TEST(PforTest, PageLargeRandom) {
+  using T = TypeParam;
+  this->RoundTripPage(TestFixture::RandomValues(10000, std::numeric_limits<T>::min(),
+                                                std::numeric_limits<T>::max(),
+                                                /*seed=*/99));
+}
+
+// Covers the FOR==0 fast path (bit_width > 0 with frame_of_reference == 0):
+// decode unpacks straight into the output, skipping the scratch buffer and the
+// add-FOR pass. Forces min == 0, a range that needs bit_width > 0, outliers to
+// exercise the exception patch on that path, and multiple vectors.
+TYPED_TEST(PforTest, PageZeroMinWithExceptions) {
+  auto values = TestFixture::RandomValues(3000, 0, 500, /*seed=*/2024);
+  values[0] = 0;            // force min == 0 -> FOR == 0
+  values[100] = 1'000'000;  // outliers -> exceptions on the FOR==0 path
+  values[1500] = 999'999;
+  values[2999] = 500'000;
+  this->RoundTripPage(values);
+}
+
+// ----------------------------------------------------------------------
+// Encode Argument Validation
+
+TYPED_TEST(PforTest, EncodeZeroValuesWritesABareHeader) {
+  using T = TypeParam;
+  // An all-null page holds no values, and the reader still has to be able to load
+  // a header from it, so zero values encodes to the header and nothing else. The
+  // pointer is null because the buffer the values would come from is empty.
+  std::vector<uint8_t> compressed(64);
+  int64_t comp_size = 64;
+  ASSERT_OK(PforWrapper<T>::Encode(nullptr, 0, compressed.data(), &comp_size));
+  ASSERT_EQ(PforConstants::kHeaderSize, comp_size);
+
+  ASSERT_OK_AND_ASSIGN(const int32_t count,
+                       PforWrapper<T>::DecodeElementCount(compressed.data(), comp_size));
+  ASSERT_EQ(0, count);
+  ASSERT_OK(PforWrapper<T>::Decode(compressed.data(), comp_size, 0, nullptr));
+}
+
+TYPED_TEST(PforTest, EncodeRejectsNegativeCount) {
+  using T = TypeParam;
+  std::vector<T> values = {1, 2, 3};
+  std::vector<uint8_t> compressed(64);
+  int64_t comp_size = 64;
+  ASSERT_RAISES(Invalid,
+                PforWrapper<T>::Encode(values.data(), -1, compressed.data(), &comp_size));
+}
+
+TYPED_TEST(PforTest, EncodeRejectsNullInputWithValuesToEncode) {
+  using T = TypeParam;
+  std::vector<uint8_t> compressed(64);
+  int64_t comp_size = 64;
+  ASSERT_RAISES(Invalid,
+                PforWrapper<T>::Encode(nullptr, 3, compressed.data(), &comp_size));
+}
+
+TYPED_TEST(PforTest, EncodeRejectsUnrepresentableVectorSize) {
+  using T = TypeParam;
+  std::vector<T> values = {1, 2, 3};
+  std::vector<uint8_t> compressed(64);
+
+  // Not a power of two.
+  int64_t comp_size = 64;
+  ASSERT_RAISES(Invalid, PforWrapper<T>::Encode(values.data(), 3, 1000, compressed.data(),
+                                                &comp_size));
+
+  // A power of two, but the header's log_vector_size field cannot describe it.
+  comp_size = 64;
+  ASSERT_RAISES(
+      Invalid, PforWrapper<T>::Encode(values.data(), 3, PforConstants::kMaxVectorSize * 2,
+                                      compressed.data(), &comp_size));
+}
+
+// ----------------------------------------------------------------------
+// Compression Ratio Test
+
+TYPED_TEST(PforTest, ClusteredDataCompresses) {
+  using T = TypeParam;
+  // Data clustered around 1000 with one outlier
+  auto values = TestFixture::RandomValues(1024, 1000, 1255, /*seed=*/42);
+  values[500] = 999999;
+
+  int64_t comp_size = 0;
+  this->RoundTripPage(values, &comp_size);
+
+  const size_t plain_size = 1024 * sizeof(T);
+  EXPECT_LT(comp_size, static_cast<int64_t>(plain_size / 2));
+}
+
+// ----------------------------------------------------------------------
+// Corrupt Page Tests
+//
+// A PFOR page can come from anywhere, so Decode has to reject a header that
+// disagrees with the buffer it arrived in rather than trusting it and reading
+// or writing out of bounds.
+
+namespace {
+
+// A tight cluster plus one far outlier, so the cost model packs narrow and
+// patches the outlier. The outlier is 31 bits out rather than 16: an exception
+// costs a position plus a full-width value, so a 16-bit outlier is cheaper to
+// pack than to patch once the values are 64 bits wide, and the tests below need
+// a vector that has an exception section.
+template <typename T>
+std::vector<T> ClusterWithOutlier() {
+  return {10, 20, 30, 40, 2'000'000'000};
+}
+
+}  // namespace
+
+TYPED_TEST(PforTest, DecodeElementCountReadsThePageHeader) {
+  using T = TypeParam;
+  std::vector<T> values(2048);
+  std::iota(values.begin(), values.end(), 0);
+  auto compressed = TestFixture::EncodePage(values);
+
+  ASSERT_OK_AND_ASSIGN(const int32_t count, PforWrapper<T>::DecodeElementCount(
+                                                compressed.data(), compressed.size()));
+  EXPECT_EQ(count, static_cast<int32_t>(values.size()));
+}
+
+TYPED_TEST(PforTest, DecodeElementCountRejectsMalformedInput) {
+  using T = TypeParam;
+  const std::vector<T> values = {10, 20, 30, 40, 50};
+  auto compressed = TestFixture::EncodePage(values);
+
+  ASSERT_RAISES(Invalid, PforWrapper<T>::DecodeElementCount(
+                             compressed.data(), PforConstants::kHeaderSize - 1));
+  ASSERT_RAISES(Invalid, PforWrapper<T>::DecodeElementCount(nullptr, compressed.size()));
+  ASSERT_RAISES(Invalid, PforWrapper<T>::DecodeElementCount(compressed.data(), -1));
+}
+
+TYPED_TEST(PforTest, CorruptBufferTooSmallForHeader) {
+  using T = TypeParam;
+  const std::vector<T> values = {10, 20, 30, 40, 50};
+  auto compressed = TestFixture::EncodePage(values);
+
+  std::vector<T> decoded(values.size());
+  ASSERT_RAISES(Invalid,
+                PforWrapper<T>::Decode(compressed.data(), PforConstants::kHeaderSize - 1,
+                                       5, decoded.data()));
+}
+
+TYPED_TEST(PforTest, CorruptElementCountExceedsOutputCapacity) {
+  using T = TypeParam;
+  const std::vector<T> values = {10, 20, 30, 40, 50};
+  auto compressed = TestFixture::EncodePage(values);
+
+  // num_elements lives at header byte 3.
+  StoreLE32(compressed.data() + 3, 6);
+
+  std::vector<T> decoded(values.size());
+  ASSERT_RAISES(Invalid, PforWrapper<T>::Decode(compressed.data(), compressed.size(), 5,
+                                                decoded.data()));
+}
+
+TYPED_TEST(PforTest, CorruptElementCountBelowOutputCapacity) {
+  using T = TypeParam;
+  const std::vector<T> values = {10, 20, 30, 40, 50};
+  auto compressed = TestFixture::EncodePage(values);
+
+  // A count short of the caller's capacity would fill part of the output and
+  // leave the rest holding whatever it held before.
+  StoreLE32(compressed.data() + 3, 4);
+
+  std::vector<T> decoded(values.size());
+  ASSERT_RAISES(Invalid, PforWrapper<T>::Decode(compressed.data(), compressed.size(), 5,
+                                                decoded.data()));
+}
+
+TYPED_TEST(PforTest, CorruptOffsetArrayTruncated) {
+  using T = TypeParam;
+  // Four vectors, so the offset array is 16 bytes; hand Decode a buffer with
+  // room for only two of them.
+  std::vector<T> values(4096);
+  std::iota(values.begin(), values.end(), 0);
+  auto compressed = TestFixture::EncodePage(values);
+
+  std::vector<T> decoded(values.size());
+  ASSERT_RAISES(Invalid,
+                PforWrapper<T>::Decode(compressed.data(), PforConstants::kHeaderSize + 8,
+                                       4096, decoded.data()));
+}
+
+TYPED_TEST(PforTest, CorruptVectorOffsetPastEndOfBuffer) {
+  using T = TypeParam;
+  std::vector<T> values(2048);
+  std::iota(values.begin(), values.end(), 0);
+  auto compressed = TestFixture::EncodePage(values);
+
+  // Point the second vector past the end of the buffer.
+  StoreLE32(compressed.data() + TestFixture::kFirstVectorOffset,
+            static_cast<uint32_t>(compressed.size()));
+
+  std::vector<T> decoded(values.size());
+  ASSERT_RAISES(Invalid, PforWrapper<T>::Decode(compressed.data(), compressed.size(),
+                                                2048, decoded.data()));
+}
+
+TYPED_TEST(PforTest, CorruptFirstVectorOffsetSkipsTheOffsetArray) {
+  using T = TypeParam;
+  const std::vector<T> values = {10, 20, 30, 40, 50};
+  auto compressed = TestFixture::EncodePage(values);
+
+  // One vector, so its data starts right after the four byte offset array.
+  StoreLE32(compressed.data() + PforConstants::kHeaderSize, 5);
+
+  std::vector<T> decoded(values.size());
+  ASSERT_RAISES(Invalid, PforWrapper<T>::Decode(compressed.data(), compressed.size(), 5,
+                                                decoded.data()));
+}
+
+TYPED_TEST(PforTest, CorruptVectorOffsetsRunBackwards) {
+  using T = TypeParam;
+  std::vector<T> values(2048);
+  std::iota(values.begin(), values.end(), 0);
+  auto compressed = TestFixture::EncodePage(values);
+
+  // Point the second vector at the first one's data. Both offsets are inside the
+  // buffer, so only reading them as a chain catches it.
+  StoreLE32(compressed.data() + TestFixture::kFirstVectorOffset,
+            static_cast<uint32_t>(2 * sizeof(PforConstants::OffsetType)));
+
+  std::vector<T> decoded(values.size());
+  ASSERT_RAISES(Invalid, PforWrapper<T>::Decode(compressed.data(), compressed.size(),
+                                                2048, decoded.data()));
+}
+
+TYPED_TEST(PforTest, CorruptExceptionPositionPastEndOfVector) {
+  using T = TypeParam;
+  const std::vector<T> values = ClusterWithOutlier<T>();
+  auto compressed = TestFixture::EncodePage(values);
+
+  // Locate the stored exception position: the vector info, then the packed
+  // deltas at whatever width the cost model chose.
+  const int64_t vector_start = TestFixture::kFirstVectorOffset;
+  ASSERT_GT(compressed[vector_start + TestFixture::kNumExceptionsOffset], 0)
+      << "the cost model packed this vector without exceptions, so there is no "
+         "exception position to corrupt";
+  const uint8_t bit_width = compressed[vector_start + TestFixture::kBitWidthOffset];
+  const int64_t packed_bytes = (5 * bit_width + 7) / 8;
+  const int64_t position_offset =
+      vector_start + PforVectorInfo<T>::kStoredSize + packed_bytes;
+
+  // Point the exception at index 100 of a five-element vector.
+  compressed[position_offset] = 100;
+  compressed[position_offset + 1] = 0;
+
+  std::vector<T> decoded(5);
+  ASSERT_RAISES(Invalid, PforWrapper<T>::Decode(compressed.data(), compressed.size(), 5,
+                                                decoded.data()));
+}
+
+TYPED_TEST(PforTest, CorruptExceptionCountExceedsVectorLength) {
+  using T = TypeParam;
+  const std::vector<T> values = ClusterWithOutlier<T>();
+  auto compressed = TestFixture::EncodePage(values);
+
+  const int64_t vector_start = TestFixture::kFirstVectorOffset;
+  compressed[vector_start + TestFixture::kNumExceptionsOffset] = 6;
+  compressed[vector_start + TestFixture::kNumExceptionsOffset + 1] = 0;
+
+  std::vector<T> decoded(5);
+  ASSERT_RAISES(Invalid, PforWrapper<T>::Decode(compressed.data(), compressed.size(), 5,
+                                                decoded.data()));
+}
+
+TYPED_TEST(PforTest, CorruptExceptionDataTruncated) {
+  using T = TypeParam;
+  const std::vector<T> values = ClusterWithOutlier<T>();
+  auto compressed = TestFixture::EncodePage(values);
+
+  // Drop the trailing exception value, leaving its position behind.
+  ASSERT_GT(
+      compressed[TestFixture::kFirstVectorOffset + TestFixture::kNumExceptionsOffset], 0);
+  std::vector<T> decoded(5);
+  ASSERT_RAISES(
+      Invalid, PforWrapper<T>::Decode(compressed.data(),
+                                      static_cast<int64_t>(compressed.size() - sizeof(T)),
+                                      5, decoded.data()));
+}
+
+// ----------------------------------------------------------------------
+// Output sizing
+
+TYPED_TEST(PforTest, MaxCompressedSizeRejectsInvalidArguments) {
+  using T = TypeParam;
+  ASSERT_RAISES(Invalid, PforWrapper<T>::GetMaxCompressedSize(-1));
+  // A zero vector_size would divide by zero on the way to the answer.
+  for (const int32_t vector_size : {0, 3, 1000, PforConstants::kMaxVectorSize * 2}) {
+    SCOPED_TRACE("vector_size=" + std::to_string(vector_size));
+    ASSERT_RAISES(Invalid, PforWrapper<T>::GetMaxCompressedSize(1024, vector_size));
+    std::vector<T> values(16, 0);
+    int64_t comp_size = 1 << 20;
+    std::vector<uint8_t> compressed(comp_size);
+    ASSERT_RAISES(Invalid, PforWrapper<T>::Encode(values.data(), 16, vector_size,
+                                                  compressed.data(), &comp_size));
+  }
+}
+
+TYPED_TEST(PforTest, EncodeRejectsUndersizedOutputBuffer) {
+  using T = TypeParam;
+  std::vector<T> values(1024);
+  std::iota(values.begin(), values.end(), 0);
+  ASSERT_OK_AND_ASSIGN(const int64_t max_size,
+                       PforWrapper<T>::GetMaxCompressedSize(1024));
+
+  std::vector<uint8_t> compressed(max_size);
+  int64_t comp_size = max_size - 1;
+  ASSERT_RAISES(Invalid, PforWrapper<T>::Encode(values.data(), 1024, compressed.data(),
+                                                &comp_size));
+}
+
+TYPED_TEST(PforTest, SerializeVectorRejectsUndersizedDestination) {
+  using T = TypeParam;
+  std::vector<T> values(64);
+  std::iota(values.begin(), values.end(), 0);
+  const auto encoded = PforCompression<T>::EncodeVector(values.data(), 64);
+  const int64_t needed = PforCompression<T>::SerializedVectorSize(encoded, 64);
+
+  std::vector<uint8_t> buffer(needed);
+  ASSERT_OK_AND_ASSIGN(const int64_t written,
+                       PforCompression<T>::SerializeVector(encoded, 64, buffer));
+  ASSERT_EQ(needed, written);
+  ASSERT_RAISES(Invalid, PforCompression<T>::SerializeVector(
+                             encoded, 64, std::span<uint8_t>(buffer).subspan(1)));
+}
+
+// SerializedVectorSize is derived from the vector info, while the copy that
+// follows it takes its lengths from the sections, so a vector whose info and
+// sections disagree has to be refused rather than written past the size the
+// caller reserved.
+TYPED_TEST(PforTest, SerializeVectorRejectsInfoInconsistentWithSections) {
+  using T = TypeParam;
+  std::vector<T> values(64);
+  std::iota(values.begin(), values.end(), 0);
+  const auto encoded = PforCompression<T>::EncodeVector(values.data(), 64);
+  std::vector<uint8_t> buffer(PforCompression<T>::SerializedVectorSize(encoded, 64) + 64);
+
+  {
+    // A bit width that does not account for the packed bytes present.
+    auto corrupted = encoded;
+    corrupted.mutable_info().set_bit_width(
+        static_cast<uint8_t>(encoded.info().bit_width() + 1));
+    ASSERT_RAISES(Invalid, PforCompression<T>::SerializeVector(corrupted, 64, buffer));
+  }
+  {
+    // An exception count with no exception sections behind it.
+    auto corrupted = encoded;
+    corrupted.mutable_info().set_num_exceptions(1);
+    ASSERT_RAISES(Invalid, PforCompression<T>::SerializeVector(corrupted, 64, buffer));
+  }
+}
+
+// GetMaxCompressedSize is what the encoder allocates, and it is derived from the
+// cost model rather than from a worst case that assumes every value is an
+// exception, so inputs that push the model in different directions all have to
+// land inside it.
+TYPED_TEST(PforTest, MaxCompressedSizeBoundHoldsForAdversarialInputs) {
+  using T = TypeParam;
+  constexpr int32_t kNumValues = 3000;
+  std::mt19937 rng(7);
+  std::uniform_int_distribution<T> full_range(std::numeric_limits<T>::min(),
+                                              std::numeric_limits<T>::max());
+
+  std::vector<std::vector<T>> inputs;
+  // Incompressible: every delta needs the full width, so the model picks it.
+  inputs.emplace_back(kNumValues);
+  for (auto& v : inputs.back()) v = full_range(rng);
+  // A narrow cluster with a scatter of far-away values, which is the case that
+  // trades bit width against exception count.
+  inputs.emplace_back(kNumValues, 1000);
+  for (int32_t i = 0; i < kNumValues; i += 3) {
+    inputs.back()[i] = full_range(rng);
+  }
+  // Alternating extremes, so the frame of reference cannot help.
+  inputs.emplace_back(kNumValues);
+  for (int32_t i = 0; i < kNumValues; ++i) {
+    inputs.back()[i] =
+        (i % 2 == 0) ? std::numeric_limits<T>::min() : std::numeric_limits<T>::max();
+  }
+
+  for (size_t i = 0; i < inputs.size(); ++i) {
+    SCOPED_TRACE("input " + std::to_string(i));
+    this->RoundTripPage(inputs[i]);
+  }
+}
+
+}  // namespace arrow::util::pfor
diff --git a/cpp/src/arrow/util/pfor/pfor_wrapper.cc b/cpp/src/arrow/util/pfor/pfor_wrapper.cc
new file mode 100644
index 000000000000..0dd3e1c04f39
--- /dev/null
+++ b/cpp/src/arrow/util/pfor/pfor_wrapper.cc
@@ -0,0 +1,416 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+// PFOR page-level wrapper implementation
+//
+// Page layout:
+//   [Header 7B] [Offset Array: numVectors * 4B] [Vector 0] [Vector 1] ...
+//
+// Each vector:
+//   [PforVectorInfo] [PackedValues] [ExceptionPositions] [ExceptionValues]
+
+#include "arrow/util/pfor/pfor_wrapper_internal.h"
+
+#include <algorithm>
+#include <bit>
+#include <cstring>
+#include <span>
+#include <vector>
+
+#include "arrow/util/bit_util.h"
+#include "arrow/util/endian.h"
+#include "arrow/util/logging.h"
+#include "arrow/util/ubsan.h"
+
+namespace arrow {
+namespace util {
+namespace pfor {
+
+namespace {
+
+/// Width of one entry in the per-page offset array.
+constexpr int64_t kOffsetSize = sizeof(PforConstants::OffsetType);
+
+/// \brief Accept only the vector sizes the page header can describe
+///
+/// A size outside this range would encode a page that Decode then rejects, so
+/// refuse it up front.
+Status ValidateVectorSize(int32_t vector_size) {
+  if (!std::has_single_bit(static_cast<uint32_t>(vector_size)) ||
+      vector_size < (1 << PforConstants::kMinLogVectorSize) ||
+      vector_size > PforConstants::kMaxVectorSize) {
+    return Status::Invalid("PFOR vector_size must be a power of two in [",
+                           1 << PforConstants::kMinLogVectorSize, ", ",
+                           PforConstants::kMaxVectorSize, "]: ", vector_size);
+  }
+  return Status::OK();
+}
+
+/// \brief Check the offset array before any of it steers a read
+///
+/// The offsets are byte counts from the start of the offset array, and the
+/// vectors they point at were written back to back in order, so a well-formed
+/// page has the first offset landing just past the array and the rest strictly
+/// increasing. Checking the chain as a whole, before decoding any of it, keeps a
+/// page whose offsets overlap or run backwards from decoding part-way and
+/// emitting values built out of the wrong bytes.
+Status ValidateOffsets(const uint8_t* offset_array_start, int32_t num_vectors,
+                       int64_t offset_array_size, int64_t payload_size) {
+  int64_t previous = -1;
+  for (int32_t v = 0; v < num_vectors; ++v) {
+    const int64_t offset =
+        bit_util::FromLittleEndian(util::SafeLoadAs<PforConstants::OffsetType>(
+            offset_array_start + v * kOffsetSize));
+    if (v == 0) {
+      if (offset != offset_array_size) {
+        return Status::Invalid("PFOR first vector offset ", offset,
+                               " does not follow the ", offset_array_size,
+                               " byte offset array");
+      }
+    } else if (offset <= previous) {
+      return Status::Invalid("PFOR vector ", v, " offset ", offset,
+                             " does not follow offset ", previous,
+                             " of the vector before it");
+    }
+    if (offset >= payload_size) {
+      return Status::Invalid("PFOR vector ", v, " offset ", offset,
+                             " is past the end of the ", payload_size, " byte payload");
+    }
+    previous = offset;
+  }
+  return Status::OK();
+}
+
+}  // namespace
+
+// ----------------------------------------------------------------------
+// Header serialization
+
+template <typename T>
+void PforWrapper<T>::StoreHeader(std::span<uint8_t> dest, const PforHeader& header) {
+  static_assert(PforConstants::kHeaderSize == sizeof(PforHeader::packing_mode) +
+                                                  sizeof(PforHeader::log_vector_size) +
+                                                  sizeof(PforHeader::value_byte_width) +
+                                                  sizeof(PforHeader::num_elements),
+                "kHeaderSize must match the fields StoreHeader and LoadHeader move");
+  uint8_t* ptr = dest.data();
+  util::SafeStore(ptr + 0, header.packing_mode);
+  util::SafeStore(ptr + 1, header.log_vector_size);
+  util::SafeStore(ptr + 2, header.value_byte_width);
+  util::SafeStore(ptr + 3, bit_util::ToLittleEndian(header.num_elements));
+}
+
+template <typename T>
+Result<typename PforWrapper<T>::PforHeader> PforWrapper<T>::LoadHeader(
+    std::span<const uint8_t> src) {
+  if (src.size() < static_cast<size_t>(PforConstants::kHeaderSize)) {
+    return Status::Invalid("PFOR compressed buffer too small for header: ", src.size(),
+                           " < ", PforConstants::kHeaderSize);
+  }
+  PforHeader header;
+  const uint8_t* ptr = src.data();
+  header.packing_mode = util::SafeLoadAs<uint8_t>(ptr + 0);
+  header.log_vector_size = util::SafeLoadAs<uint8_t>(ptr + 1);
+  header.value_byte_width = util::SafeLoadAs<uint8_t>(ptr + 2);
+  header.num_elements = bit_util::FromLittleEndian(util::SafeLoadAs<int32_t>(ptr + 3));
+
+  if (header.packing_mode != PforConstants::kPackingModeForBitPack) {
+    return Status::Invalid("PFOR unsupported packing mode: ",
+                           static_cast<int>(header.packing_mode));
+  }
+  if (header.value_byte_width != sizeof(T)) {
+    return Status::Invalid(
+        "PFOR value_byte_width mismatch: ", static_cast<int>(header.value_byte_width),
+        " vs expected ", sizeof(T));
+  }
+  if (header.log_vector_size < PforConstants::kMinLogVectorSize ||
+      header.log_vector_size > PforConstants::kMaxLogVectorSize) {
+    return Status::Invalid("PFOR invalid log_vector_size: ",
+                           static_cast<int>(header.log_vector_size));
+  }
+  if (header.num_elements < 0) {
+    return Status::Invalid("PFOR invalid num_elements: ", header.num_elements);
+  }
+  return header;
+}
+
+// ----------------------------------------------------------------------
+// Encode
+
+template <typename T>
+Status PforWrapper<T>::Encode(const T* values, int32_t num_values, int32_t vector_size,
+                              uint8_t* comp, int64_t* comp_size) {
+  if (num_values < 0) {
+    return Status::Invalid("PFOR num_values must be non-negative: ", num_values);
+  }
+  // An all-null page holds no values and is still written, and a reader loads the
+  // header before it knows how many values a page has, so zero values encodes to a
+  // bare header rather than to nothing at all. The buffer it comes from is empty in
+  // that case, and an empty container is entitled to a null data pointer.
+  if (values == nullptr && num_values > 0) {
+    return Status::Invalid("PFOR input pointer is null");
+  }
+  if (comp == nullptr) {
+    return Status::Invalid("PFOR output pointer is null");
+  }
+  if (comp_size == nullptr) {
+    return Status::Invalid("PFOR output size pointer is null");
+  }
+  RETURN_NOT_OK(ValidateVectorSize(vector_size));
+
+  // Everything below writes into `comp` without re-checking, including the
+  // header and the offset array, so confirm once that the caller gave us the
+  // buffer the API asks for.
+  ARROW_ASSIGN_OR_RAISE(const int64_t max_size,
+                        GetMaxCompressedSize(num_values, vector_size));
+  if (*comp_size < max_size) {
+    return Status::Invalid("PFOR output buffer of ", *comp_size,
+                           " bytes is smaller than the ", max_size, " bytes ", num_values,
+                           " values may need");
+  }
+
+  const int32_t num_vectors =
+      static_cast<int32_t>(bit_util::CeilDiv(num_values, vector_size));
+
+  // ValidateVectorSize has already established that vector_size is a power of
+  // two, so its trailing-zero count is log2 of it.
+  const auto log_vector_size =
+      static_cast<uint8_t>(std::countr_zero(static_cast<uint32_t>(vector_size)));
+
+  uint8_t* dest = comp;
+
+  // Step 1: Write header
+  PforHeader header;
+  header.packing_mode = PforConstants::kPackingModeForBitPack;
+  header.log_vector_size = log_vector_size;
+  header.value_byte_width = sizeof(T);
+  header.num_elements = num_values;
+  StoreHeader(std::span<uint8_t>(dest, PforConstants::kHeaderSize), header);
+  uint8_t* write_ptr = dest + PforConstants::kHeaderSize;
+
+  // Step 2: Reserve space for offset array
+  uint8_t* offset_array_start = write_ptr;
+  write_ptr += num_vectors * kOffsetSize;
+
+  // Step 3: Encode each vector and build offset array
+  const uint8_t* data_start = offset_array_start;
+
+  for (int32_t v = 0; v < num_vectors; ++v) {
+    // Record offset (from start of offset array)
+    const auto offset = static_cast<PforConstants::OffsetType>(write_ptr - data_start);
+    util::SafeStore(offset_array_start + v * kOffsetSize,
+                    bit_util::ToLittleEndian(offset));
+
+    // Determine elements in this vector
+    int32_t start_idx = v * vector_size;
+    int32_t elements_in_vector = std::min(vector_size, num_values - start_idx);
+
+    auto encoded =
+        PforCompression<T>::EncodeVector(values + start_idx, elements_in_vector);
+
+    // Serialize to output
+    ARROW_ASSIGN_OR_RAISE(
+        const int64_t bytes_written,
+        PforCompression<T>::SerializeVector(
+            encoded, elements_in_vector,
+            std::span<uint8_t>(write_ptr, dest + *comp_size - write_ptr)));
+    write_ptr += bytes_written;
+  }
+
+  *comp_size = static_cast<int64_t>(write_ptr - dest);
+  return Status::OK();
+}
+
+template <typename T>
+Status PforWrapper<T>::Encode(const T* values, int32_t num_values, uint8_t* comp,
+                              int64_t* comp_size) {
+  return Encode(values, num_values, kVectorSize, comp, comp_size);
+}
+
+// ----------------------------------------------------------------------
+// Decode
+
+template <typename T>
+Status PforWrapper<T>::Decode(const uint8_t* comp, int64_t comp_size, int32_t num_values,
+                              T* values) {
+  if (num_values < 0) {
+    return Status::Invalid("PFOR num_values must be non-negative: ", num_values);
+  }
+  if (comp == nullptr) {
+    return Status::Invalid("PFOR compressed data pointer is null");
+  }
+  // Every bound below is expressed against `comp_size`, and it also becomes the
+  // size of a std::span, where a negative value would convert to a huge size_t
+  // and read past the end of the buffer.
+  if (comp_size < PforConstants::kHeaderSize) {
+    return Status::Invalid("PFOR compressed buffer too small for header: ", comp_size,
+                           " < ", PforConstants::kHeaderSize);
+  }
+
+  const uint8_t* src = comp;
+
+  // Step 1: Read header
+  ARROW_ASSIGN_OR_RAISE(PforHeader header,
+                        LoadHeader(std::span<const uint8_t>(src, comp_size)));
+
+  // The loop below sizes its work from the header's count while `values` is only
+  // as large as `num_values`, so a header claiming more would write past the end
+  // of the output and one claiming fewer would fill part of it and still return
+  // OK, leaving the rest whatever it held before. Require the two to agree.
+  if (header.num_elements != num_values) {
+    return Status::Invalid("PFOR header element count ", header.num_elements,
+                           " does not match the expected value count ", num_values);
+  }
+
+  const int32_t vector_size = 1 << header.log_vector_size;
+  const int32_t num_vectors =
+      static_cast<int32_t>(bit_util::CeilDiv(header.num_elements, vector_size));
+
+  // Step 2: Read and check the offset array
+  const uint8_t* offset_array_start = src + PforConstants::kHeaderSize;
+  const int64_t offset_array_size = num_vectors * kOffsetSize;
+  if (PforConstants::kHeaderSize + offset_array_size > comp_size) {
+    return Status::Invalid("PFOR offset array for ", num_vectors,
+                           " vectors does not fit in ", comp_size, " bytes");
+  }
+  const int64_t payload_size = comp_size - PforConstants::kHeaderSize;
+  ARROW_RETURN_NOT_OK(
+      ValidateOffsets(offset_array_start, num_vectors, offset_array_size, payload_size));
+
+  // Step 3: Decode each vector
+  for (int32_t v = 0; v < num_vectors; ++v) {
+    const auto offset =
+        bit_util::FromLittleEndian(util::SafeLoadAs<PforConstants::OffsetType>(
+            offset_array_start + v * kOffsetSize));
+    const uint8_t* vector_data = offset_array_start + offset;
+
+    int32_t start_idx = v * vector_size;
+    int32_t elements_in_vector = std::min(vector_size, header.num_elements - start_idx);
+
+    ARROW_RETURN_NOT_OK(PforCompression<T>::DecodeVector(
+        std::span<const uint8_t>(vector_data, src + comp_size - vector_data),
+        elements_in_vector, values + start_idx));
+  }
+
+  return Status::OK();
+}
+
+// ----------------------------------------------------------------------
+// DecodeElementCount
+
+template <typename T>
+Result<int32_t> PforWrapper<T>::DecodeElementCount(const uint8_t* comp,
+                                                   int64_t comp_size) {
+  if (comp == nullptr) {
+    return Status::Invalid("PFOR compressed data pointer is null");
+  }
+  if (comp_size < 0) {
+    return Status::Invalid("PFOR compressed size must be non-negative: ", comp_size);
+  }
+  ARROW_ASSIGN_OR_RAISE(const PforHeader header,
+                        LoadHeader(std::span<const uint8_t>(comp, comp_size)));
+  return header.num_elements;
+}
+
+// ----------------------------------------------------------------------
+// VectorReader
+
+template <typename T>
+Result<typename PforWrapper<T>::VectorReader> PforWrapper<T>::VectorReader::Open(
+    std::span<const uint8_t> input) {
+  ARROW_ASSIGN_OR_RAISE(const PforHeader header, PforWrapper<T>::LoadHeader(input));
+
+  VectorReader reader;
+  reader.input_ = input;
+  reader.num_elements_ = header.num_elements;
+  reader.vector_size_ = 1 << header.log_vector_size;
+  reader.num_vectors_ =
+      static_cast<int32_t>(bit_util::CeilDiv(reader.num_elements_, reader.vector_size_));
+  reader.offset_array_start_ = input.data() + PforConstants::kHeaderSize;
+  const int64_t offset_array_size =
+      static_cast<int64_t>(reader.num_vectors_) * kOffsetSize;
+  if (PforConstants::kHeaderSize + offset_array_size >
+      static_cast<int64_t>(input.size())) {
+    return Status::Invalid("PFOR offset array for ", reader.num_vectors_,
+                           " vectors does not fit in ", input.size(), " bytes");
+  }
+  reader.payload_size_ = static_cast<int64_t>(input.size()) - PforConstants::kHeaderSize;
+  RETURN_NOT_OK(ValidateOffsets(reader.offset_array_start_, reader.num_vectors_,
+                                offset_array_size, reader.payload_size_));
+  return reader;
+}
+
+template <typename T>
+Result<int32_t> PforWrapper<T>::VectorReader::VectorLength(int32_t vector_index) const {
+  if (vector_index < 0 || vector_index >= num_vectors_) {
+    return Status::Invalid("PFOR vector index ", vector_index, " is outside [0, ",
+                           num_vectors_, ")");
+  }
+  return std::min(vector_size_, num_elements_ - vector_index * vector_size_);
+}
+
+template <typename T>
+Status PforWrapper<T>::VectorReader::DecodeVector(int32_t vector_index,
+                                                  std::span<T> output) const {
+  ARROW_ASSIGN_OR_RAISE(const int32_t vector_length, VectorLength(vector_index));
+  if (output.size() < static_cast<size_t>(vector_length)) {
+    return Status::Invalid("PFOR vector output has ", output.size(), " slots but needs ",
+                           vector_length);
+  }
+  const auto offset =
+      bit_util::FromLittleEndian(util::SafeLoadAs<PforConstants::OffsetType>(
+          offset_array_start_ + vector_index * kOffsetSize));
+  const uint8_t* vector_data = offset_array_start_ + offset;
+  return PforCompression<T>::DecodeVector(
+             std::span<const uint8_t>(vector_data,
+                                      input_.data() + input_.size() - vector_data),
+             vector_length, output.data())
+      .status();
+}
+
+// ----------------------------------------------------------------------
+// GetMaxCompressedSize
+
+template <typename T>
+Result<int64_t> PforWrapper<T>::GetMaxCompressedSize(int32_t num_values,
+                                                     int32_t vector_size) {
+  if (num_values < 0) {
+    return Status::Invalid("PFOR num_values must be non-negative: ", num_values);
+  }
+  RETURN_NOT_OK(ValidateVectorSize(vector_size));
+
+  const int64_t num_vectors = bit_util::CeilDiv(num_values, vector_size);
+
+  // A vector never serializes to more than its values occupy unpacked.
+  // FindOptimalBitWidth minimises `num_elements * bit_width + num_exceptions *
+  // (16 + 8 * sizeof(T))` bits, and the full-width candidate scores
+  // `num_elements * 8 * sizeof(T)` bits with no exceptions at all, so whatever
+  // width it does pick costs no more than that. Bit packing rounds the packed
+  // section up to a whole byte, hence the trailing byte.
+  const int64_t max_vector_size =
+      PforVectorInfo<T>::kStoredSize + vector_size * static_cast<int64_t>(sizeof(T)) + 1;
+
+  return PforConstants::kHeaderSize + num_vectors * (kOffsetSize + max_vector_size);
+}
+
+// Explicit template instantiations
+template class PforWrapper<int32_t>;
+template class PforWrapper<int64_t>;
+
+}  // namespace pfor
+}  // namespace util
+}  // namespace arrow
diff --git a/cpp/src/arrow/util/pfor/pfor_wrapper_internal.h b/cpp/src/arrow/util/pfor/pfor_wrapper_internal.h
new file mode 100644
index 000000000000..b438df1c7f35
--- /dev/null
+++ b/cpp/src/arrow/util/pfor/pfor_wrapper_internal.h
@@ -0,0 +1,156 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+// High-level wrapper interface for PFOR compression
+//
+// Handles page-level serialization: header, offset array, and vectors.
+
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <span>
+
+#include "arrow/result.h"
+#include "arrow/status.h"
+#include "arrow/util/pfor/pfor_internal.h"
+
+namespace arrow {
+namespace util {
+namespace pfor {
+
+/// \class PforWrapper
+/// \brief High-level interface for PFOR page-level compression
+///
+/// Manages this page layout (offsets are relative to the offset array):
+///
+///   +---------------------------------------------------------------+
+///   | PFOR header (7 bytes)                                         |
+///   | Offset 0 | Offset 1 | ... | Offset n-1      (4 bytes each)    |
+///   | Vector 0 | Vector 1 | ... | Vector n-1                         |
+///   +---------------------------------------------------------------+
+///
+/// Header fields:
+///
+///   +--------+--------------------+---------------------+
+///   | Offset | Field              | Size                |
+///   +--------+--------------------+---------------------+
+///   |      0 | packing_mode       | 1 byte (uint8)      |
+///   |      1 | log_vector_size    | 1 byte (uint8)      |
+///   |      2 | value_byte_width   | 1 byte (uint8)      |
+///   |      3 | num_elements       | 4 bytes (int32)     |
+///   +--------+--------------------+---------------------+
+///
+/// \tparam T the integer type (int32_t or int64_t)
+template <typename T>
+class PforWrapper {
+ public:
+  /// A validated view of one encoded page.  It keeps no decoded values and can
+  /// therefore serve arbitrary vectors without materializing the whole page.
+  class VectorReader {
+   public:
+    static Result<VectorReader> Open(std::span<const uint8_t> input);
+
+    int32_t num_elements() const { return num_elements_; }
+    int32_t vector_size() const { return vector_size_; }
+    int32_t num_vectors() const { return num_vectors_; }
+
+    Result<int32_t> VectorLength(int32_t vector_index) const;
+    Status DecodeVector(int32_t vector_index, std::span<T> output) const;
+
+   private:
+    std::span<const uint8_t> input_;
+    const uint8_t* offset_array_start_ = nullptr;
+    int64_t payload_size_ = 0;
+    int32_t num_elements_ = 0;
+    int32_t vector_size_ = 0;
+    int32_t num_vectors_ = 0;
+  };
+
+  /// \brief Encode integer values into a PFOR-compressed page
+  ///
+  /// \param[in] values pointer to input integers
+  /// \param[in] num_values total number of values; zero writes a bare header,
+  ///            which is what an all-null page encodes to
+  /// \param[in] vector_size number of elements per vector (must be a power of 2,
+  ///            in [2^kMinLogVectorSize, 2^kMaxLogVectorSize])
+  /// \param[out] comp pointer to output buffer, at least
+  ///             GetMaxCompressedSize(num_values, vector_size) bytes
+  /// \param[in,out] comp_size input: available buffer size, which must be at
+  ///                least GetMaxCompressedSize(num_values, vector_size);
+  ///                output: bytes written
+  /// \return Status::OK on success, or an error if the arguments are invalid
+  static Status Encode(const T* values, int32_t num_values, int32_t vector_size,
+                       uint8_t* comp, int64_t* comp_size);
+
+  /// Convenience overload with default vector_size = kPforVectorSize
+  static Status Encode(const T* values, int32_t num_values, uint8_t* comp,
+                       int64_t* comp_size);
+
+  /// \brief Decode a PFOR-compressed page
+  ///
+  /// \param[in] comp pointer to compressed data
+  /// \param[in] comp_size size of compressed data
+  /// \param[in] num_values number of values the page holds, which must equal the
+  ///            count in its header; DecodeElementCount reads that count. Zero is
+  ///            valid: an all-null page is a bare header.
+  /// \param[out] values pointer to output buffer, sized for num_values
+  /// \return Status::OK on success, or an error if the data is malformed
+  static Status Decode(const uint8_t* comp, int64_t comp_size, int32_t num_values,
+                       T* values);
+
+  /// \brief Read the value count a page declares in its own header
+  ///
+  /// The parquet page header counts nulls, which a PFOR page does not store, so
+  /// a caller holding a page needs this to learn how many values are in it.
+  ///
+  /// \param[in] comp pointer to compressed data
+  /// \param[in] comp_size size of compressed data
+  /// \return the number of values the page holds, or an error if the header is
+  ///         malformed
+  static Result<int32_t> DecodeElementCount(const uint8_t* comp, int64_t comp_size);
+
+  /// \brief Get the maximum compressed size for a given number of values
+  ///
+  /// \param[in] num_values number of integer values
+  /// \param[in] vector_size number of elements per vector (must be a power of 2,
+  ///            in [2^kMinLogVectorSize, 2^kMaxLogVectorSize])
+  /// \return maximum possible compressed page size in bytes, or an error if the
+  ///         arguments are invalid
+  static Result<int64_t> GetMaxCompressedSize(
+      int32_t num_values,
+      int32_t vector_size = static_cast<int32_t>(PforConstants::kPforVectorSize));
+
+ private:
+  /// \brief Page header structure (7 bytes)
+  struct PforHeader {
+    uint8_t packing_mode;      // 0 = FOR + bit-packing
+    uint8_t log_vector_size;   // log2(vector_size)
+    uint8_t value_byte_width;  // sizeof(T): 4 or 8
+    int32_t num_elements;      // total element count
+  };
+
+  static constexpr int32_t kVectorSize =
+      static_cast<int32_t>(PforConstants::kPforVectorSize);
+
+  static void StoreHeader(std::span<uint8_t> dest, const PforHeader& header);
+  static Result<PforHeader> LoadHeader(std::span<const uint8_t> src);
+};
+
+}  // namespace pfor
+}  // namespace util
+}  // namespace arrow

From f24b14070ae15bfbdec3d5ac249276187254eeb5 Mon Sep 17 00:00:00 2001
From: Prateek Gaur <prateek.gaur@snowflake.com>
Date: Sat, 3 Oct 2026 03:11:56 +0000
Subject: [PATCH 03/27] Integrate PFOR with Parquet integer columns

Registers PFOR for INT32 and INT64 and wires it into the encoder and
decoder factories. Reads work for dense and nullable columns,, and the
decoder can also return one vector at a time.
---
 cpp/src/parquet/CMakeLists.txt   |   2 +
 cpp/src/parquet/column_reader.cc |   3 +-
 cpp/src/parquet/decoder.cc       | 193 ++++++++++++++++++++++++++++++-
 cpp/src/parquet/encoder.cc       | 110 ++++++++++++++++++
 cpp/src/parquet/meson.build      |   1 +
 cpp/src/parquet/types.cc         |   2 +
 cpp/src/parquet/types.h          |   3 +-
 7 files changed, 310 insertions(+), 4 deletions(-)

diff --git a/cpp/src/parquet/CMakeLists.txt b/cpp/src/parquet/CMakeLists.txt
index f8a42b5b96bf..b97df02726cb 100644
--- a/cpp/src/parquet/CMakeLists.txt
+++ b/cpp/src/parquet/CMakeLists.txt
@@ -407,6 +407,7 @@ add_parquet_test(chunker-test SOURCES chunker_internal_test.cc)
 
 add_parquet_test(arrow-reader-writer-test
                  SOURCES
+                 arrow/arrow_encoding_test.cc
                  arrow/arrow_reader_writer_test.cc
                  arrow/arrow_statistics_test.cc
                  arrow/variant_test.cc)
@@ -452,5 +453,6 @@ add_parquet_benchmark(level_conversion_benchmark)
 add_parquet_benchmark(metadata_benchmark)
 add_parquet_benchmark(page_index_benchmark SOURCES page_index_benchmark.cc
                       benchmark_util.cc)
+add_parquet_benchmark(pfor_comparison_benchmark)
 add_parquet_benchmark(arrow/reader_writer_benchmark PREFIX "parquet-arrow")
 add_parquet_benchmark(arrow/size_stats_benchmark PREFIX "parquet-arrow")
diff --git a/cpp/src/parquet/column_reader.cc b/cpp/src/parquet/column_reader.cc
index 162a72bd1576..b2d5c18630c8 100644
--- a/cpp/src/parquet/column_reader.cc
+++ b/cpp/src/parquet/column_reader.cc
@@ -971,7 +971,8 @@ class ColumnReaderImplBase {
         case Encoding::RLE:
         case Encoding::DELTA_BINARY_PACKED:
         case Encoding::DELTA_BYTE_ARRAY:
-        case Encoding::DELTA_LENGTH_BYTE_ARRAY: {
+        case Encoding::DELTA_LENGTH_BYTE_ARRAY:
+        case Encoding::PFOR: {
           auto decoder = MakeTypedDecoder<DType>(encoding, descr_, pool_);
           current_decoder_.SetDecoder(decoder.get());
           decoders_[static_cast<int>(encoding)] = std::move(decoder);
diff --git a/cpp/src/parquet/decoder.cc b/cpp/src/parquet/decoder.cc
index c4d3fe5a8a5a..1a4e8c93af49 100644
--- a/cpp/src/parquet/decoder.cc
+++ b/cpp/src/parquet/decoder.cc
@@ -24,6 +24,8 @@
 #include <cstring>
 #include <limits>
 #include <memory>
+#include <optional>
+#include <span>
 #include <string>
 #include <string_view>
 #include <type_traits>
@@ -44,6 +46,7 @@
 #include "arrow/util/checked_cast.h"
 #include "arrow/util/int_util_overflow.h"
 #include "arrow/util/logging_internal.h"
+#include "arrow/util/pfor/pfor_wrapper_internal.h"
 #include "arrow/util/rle_encoding_internal.h"
 #include "arrow/util/spaced_internal.h"
 #include "arrow/util/ubsan.h"
@@ -2372,6 +2375,183 @@ class ByteStreamSplitDecoder<FLBAType> : public ByteStreamSplitDecoderBase<FLBAT
   }
 };
 
+// ----------------------------------------------------------------------
+// PFOR Decoder
+
+template <typename DType>
+class PforDecoder : public TypedDecoderImpl<DType> {
+ public:
+  using Base = TypedDecoderImpl<DType>;
+  using T = typename DType::c_type;
+  using VectorReader = typename ::arrow::util::pfor::PforWrapper<T>::VectorReader;
+
+  explicit PforDecoder(const ColumnDescriptor* descr,
+                       MemoryPool* pool = ::arrow::default_memory_pool())
+      : Base(descr, Encoding::PFOR), cached_vector_(AllocateBuffer(pool, 0)) {}
+
+  void SetData(int num_values, const uint8_t* data, int len) override {
+    if (num_values < 0 || len < 0) {
+      throw ParquetException("PFOR SetData: num_values=" + std::to_string(num_values) +
+                             " len=" + std::to_string(len));
+    }
+    Base::SetData(num_values, data, len);
+    if (num_values > 0 && len == 0) {
+      throw ParquetException("PFOR SetData: num_values=" + std::to_string(num_values) +
+                             " but len=" + std::to_string(len));
+    }
+    // A decoder is cached per encoding and reused across the data pages of a
+    // column chunk, so every piece of state describing the previous page has to
+    // be dropped along with the page itself.
+    cached_vector_index_ = -1;
+    // `num_values` is the page's level count, which includes nulls, while a PFOR
+    // page stores only the non-null values. Its own header is the authority on
+    // how many, so take the count from there.
+    if (len > 0) {
+      PARQUET_ASSIGN_OR_THROW(
+          reader_, VectorReader::Open({this->data_, static_cast<size_t>(this->len_)}));
+      const int32_t encoded_values = reader_->num_elements();
+      if (encoded_values > num_values) {
+        throw ParquetException("PFOR page declares " + std::to_string(encoded_values) +
+                               " values but the page header allows at most " +
+                               std::to_string(num_values));
+      }
+      this->num_values_ = encoded_values;
+    } else {
+      reader_.reset();
+      this->num_values_ = 0;
+    }
+    levels_remaining_ = num_values;
+  }
+
+  int Decode(T* buffer, int max_values) override {
+    if (ARROW_PREDICT_FALSE(max_values < 0)) {
+      throw ParquetException("PFOR Decode: max_values must be non-negative");
+    }
+    max_values = std::min(max_values, this->num_values_);
+    if (max_values == 0) return 0;
+    DecodeInternal(buffer, max_values);
+    this->num_values_ -= max_values;
+    levels_remaining_ -= max_values;
+    CheckPageConsumed();
+    return max_values;
+  }
+
+  int DecodeSpaced(T* buffer, int num_values, int null_count, const uint8_t* valid_bits,
+                   int64_t valid_bits_offset) override {
+    const int decoded =
+        Base::DecodeSpaced(buffer, num_values, null_count, valid_bits, valid_bits_offset);
+    levels_remaining_ -= null_count;
+    CheckPageConsumed();
+    return decoded;
+  }
+
+  // `num_values` counts output slots; only the non-null ones are backed by
+  // encoded values, so decode that many and spread them over the valid runs.
+  int DecodeArrow(int num_values, int null_count, const uint8_t* valid_bits,
+                  int64_t valid_bits_offset,
+                  typename EncodingTraits<DType>::Accumulator* builder) override {
+    const int values_to_decode = num_values - null_count;
+    if (ARROW_PREDICT_FALSE(this->num_values_ < values_to_decode)) {
+      ParquetException::EofException(
+          "PFOR DecodeArrow: not enough values available. "
+          "Available: " +
+          std::to_string(this->num_values_) +
+          ", requested: " + std::to_string(values_to_decode));
+    }
+
+    PARQUET_THROW_NOT_OK(builder->Reserve(num_values));
+
+    // 1. Land the values in the builder's storage packed to the right, so step 2
+    //    can expand them in place into their final positions. An all-null run
+    //    asks for no values, and a page carrying none has nothing to decode.
+    if (values_to_decode > 0) {
+      T* decode_out = builder->GetMutableValue(builder->length() + null_count);
+      DecodeInternal(decode_out, values_to_decode);
+    }
+
+    // 2. Expand the values into their final positions.
+    if (null_count == 0) {
+      builder->UnsafeAdvance(num_values);
+    } else {
+      ::arrow::util::internal::SpacedExpandLeftward(
+          reinterpret_cast<uint8_t*>(builder->GetMutableValue(builder->length())),
+          static_cast<int>(sizeof(T)), num_values, null_count, valid_bits,
+          valid_bits_offset);
+      builder->UnsafeAdvance(num_values, valid_bits, valid_bits_offset);
+    }
+    this->num_values_ -= values_to_decode;
+    levels_remaining_ -= num_values;
+    CheckPageConsumed();
+    return values_to_decode;
+  }
+
+  int DecodeArrow(int num_values, int null_count, const uint8_t* valid_bits,
+                  int64_t valid_bits_offset,
+                  typename EncodingTraits<DType>::DictAccumulator* out) override {
+    const int values_decoded = num_values - null_count;
+    std::vector<T> values(values_decoded);
+    if (Decode(values.data(), values_decoded) != values_decoded) {
+      ParquetException::EofException();
+    }
+    levels_remaining_ -= null_count;
+    CheckPageConsumed();
+
+    const T* data = values.data();
+    PARQUET_THROW_NOT_OK(out->Reserve(num_values));
+    VisitNullBitmapInline(
+        valid_bits, valid_bits_offset, num_values, null_count,
+        [&]() { PARQUET_THROW_NOT_OK(out->Append(*data++)); },
+        [&]() { PARQUET_THROW_NOT_OK(out->AppendNull()); });
+    return values_decoded;
+  }
+
+ private:
+  void CheckPageConsumed() const {
+    ARROW_DCHECK_GE(levels_remaining_, 0) << "PFOR decoder consumed too many levels";
+    if (ARROW_PREDICT_FALSE(levels_remaining_ <= 0 && this->num_values_ > 0)) {
+      throw ParquetException("PFOR page has " + std::to_string(this->num_values_) +
+                             " unconsumed values after all levels were read");
+    }
+  }
+
+  void DecodeInternal(T* output, int count) {
+    const int32_t vector_size = reader_->vector_size();
+    int32_t processed = reader_->num_elements() - this->num_values_;
+    for (int32_t remaining = count; remaining > 0;) {
+      const int32_t vector_index = processed / vector_size;
+      const int32_t position = processed % vector_size;
+      PARQUET_ASSIGN_OR_THROW(const int32_t vector_length,
+                              reader_->VectorLength(vector_index));
+      const int32_t take = std::min(remaining, vector_length - position);
+      if (position == 0 && take == vector_length) {
+        PARQUET_THROW_NOT_OK(reader_->DecodeVector(
+            vector_index, {output, static_cast<size_t>(vector_length)}));
+      } else {
+        if (cached_vector_index_ != vector_index) {
+          PARQUET_THROW_NOT_OK(
+              cached_vector_->Resize(static_cast<int64_t>(vector_length) * sizeof(T),
+                                     /*shrink_to_fit=*/false));
+          PARQUET_THROW_NOT_OK(
+              reader_->DecodeVector(vector_index, {cached_vector_->mutable_data_as<T>(),
+                                                   static_cast<size_t>(vector_length)}));
+          cached_vector_index_ = vector_index;
+        }
+        std::memcpy(output, cached_vector_->data_as<T>() + position,
+                    static_cast<size_t>(take) * sizeof(T));
+      }
+      output += take;
+      processed += take;
+      remaining -= take;
+    }
+  }
+
+  std::optional<VectorReader> reader_;
+  // One vector of pool-backed scratch, reused when a batch begins or ends inside it.
+  std::shared_ptr<ResizableBuffer> cached_vector_;
+  int32_t cached_vector_index_ = -1;
+  int64_t levels_remaining_ = 0;
+};
+
 }  // namespace
 
 // ----------------------------------------------------------------------
@@ -2448,6 +2628,15 @@ std::unique_ptr<Decoder> MakeDecoder(Type::type type_num, Encoding::type encodin
       return std::make_unique<RleBooleanDecoder>(descr);
     }
     throw ParquetException("RLE encoding only supports BOOLEAN");
+  } else if (encoding == Encoding::PFOR) {
+    switch (type_num) {
+      case Type::INT32:
+        return std::make_unique<PforDecoder<Int32Type>>(descr, pool);
+      case Type::INT64:
+        return std::make_unique<PforDecoder<Int64Type>>(descr, pool);
+      default:
+        throw ParquetException("PFOR decoder only supports INT32 and INT64");
+    }
   } else {
     ParquetException::NYI("Selected encoding is not supported");
   }
@@ -2491,8 +2680,8 @@ std::vector<Encoding::type> SupportedEncodings(Type::type physical_type) {
       return {Encoding::PLAIN, Encoding::RLE};
     case Type::INT32:
     case Type::INT64:
-      return {Encoding::PLAIN, Encoding::DELTA_BINARY_PACKED,
-              Encoding::BYTE_STREAM_SPLIT};
+      return {Encoding::PLAIN, Encoding::DELTA_BINARY_PACKED, Encoding::BYTE_STREAM_SPLIT,
+              Encoding::PFOR};
     case Type::INT96:
       return {Encoding::PLAIN};
     case Type::FLOAT:
diff --git a/cpp/src/parquet/encoder.cc b/cpp/src/parquet/encoder.cc
index 3e469df277b8..ce675a2dfb4c 100644
--- a/cpp/src/parquet/encoder.cc
+++ b/cpp/src/parquet/encoder.cc
@@ -40,6 +40,7 @@
 #include "arrow/util/hashing.h"
 #include "arrow/util/int_util_overflow.h"
 #include "arrow/util/logging_internal.h"
+#include "arrow/util/pfor/pfor_wrapper_internal.h"
 #include "arrow/util/rle_encoding_internal.h"
 #include "arrow/util/spaced_internal.h"
 #include "arrow/util/ubsan.h"
@@ -1763,6 +1764,106 @@ std::shared_ptr<Buffer> RleBooleanEncoder::FlushValues() {
 
 }  // namespace
 
+// ----------------------------------------------------------------------
+// PFOR Encoder
+
+// TODO: support incremental encoding. Today `Put` only appends raw input
+// to `values_`, and `FlushValues` runs the entire PFOR pipeline on the
+// whole buffer in one shot. A future revision should encode complete
+// vectors as `Put` calls fill them, holding only a partial-vector tail
+// across calls, so the encoder can produce output progressively and use
+// bounded memory. This is deferred to a follow-up change; the decoder
+// carries the matching TODO.
+//
+// TODO: fall back to PLAIN when PFOR is not paying for itself. This encoder
+// always emits a PFOR page, and the cost model's worst case is the full width
+// with no exceptions, so a column whose deltas never narrow (random values, or
+// a low null sentinel that becomes the frame of reference and can never be an
+// exception) encodes to its plain size plus the page header, the offset array
+// and one PforVectorInfo per vector.
+//
+// The decision belongs in ColumnWriterImpl, not here: `encoding_` is const, so
+// this encoder cannot relabel its own page, and the choice depends on the page
+// compressor, which this layer knows nothing about. The mechanism already
+// exists -- mirror `FallbackToPlainEncoding()` in column_writer.cc, which swaps
+// `current_encoder_` for a PLAIN encoder and updates `encoding_`. Parquet
+// records the encoding per page, so mixing PLAIN and PFOR pages in one column
+// chunk needs no format change.
+//
+// What is missing on this side is a way for the writer to know the ratio
+// before paying for the encode. FindOptimalBitWidth already computes the cost
+// of a vector in bits, so a sampled estimate over the first few vectors would
+// answer the question without encoding the page twice.
+template <typename DType>
+class PforEncoder : public EncoderImpl, virtual public TypedEncoder<DType> {
+ public:
+  using T = typename DType::c_type;
+  using TypedEncoder<DType>::Put;
+
+  explicit PforEncoder(const ColumnDescriptor* descr, MemoryPool* pool)
+      : EncoderImpl(descr, Encoding::PFOR, pool), pool_(pool) {}
+
+  std::shared_ptr<Buffer> FlushValues() override {
+    // An all-null optional page adds no values and is still written, so an empty
+    // buffer has to encode to a header-only page rather than to zero bytes, which
+    // the reader would reject for having no header to load.
+    const int32_t num_values = static_cast<int32_t>(values_.size());
+    PARQUET_ASSIGN_OR_THROW(
+        int64_t max_size,
+        ::arrow::util::pfor::PforWrapper<T>::GetMaxCompressedSize(num_values));
+    PARQUET_ASSIGN_OR_THROW(auto buffer,
+                            ::arrow::AllocateResizableBuffer(max_size, pool_));
+
+    int64_t comp_size = max_size;
+    PARQUET_THROW_NOT_OK(::arrow::util::pfor::PforWrapper<T>::Encode(
+        values_.data(), num_values, buffer->mutable_data(), &comp_size));
+
+    PARQUET_THROW_NOT_OK(buffer->Resize(comp_size));
+    values_.clear();
+    return buffer;
+  }
+
+  int64_t EstimatedDataEncodedSize() override {
+    return static_cast<int64_t>(values_.size() * sizeof(T));
+  }
+
+  void Put(const ::arrow::Array& values) override {
+    const auto& data = *values.data();
+    if (data.length > std::numeric_limits<int32_t>::max()) {
+      throw ParquetException("Array cannot be longer than ",
+                             std::numeric_limits<int32_t>::max());
+    }
+    if (values.null_count() == 0) {
+      Put(data.template GetValues<T>(1), static_cast<int>(data.length));
+    } else {
+      PutSpaced(data.template GetValues<T>(1), static_cast<int>(data.length),
+                data.GetValues<uint8_t>(0, 0), data.offset);
+    }
+  }
+
+  void Put(const T* buffer, int num_values) override {
+    values_.insert(values_.end(), buffer, buffer + num_values);
+  }
+
+  void PutSpaced(const T* src, int num_values, const uint8_t* valid_bits,
+                 int64_t valid_bits_offset) override {
+    if (valid_bits != NULLPTR) {
+      PARQUET_ASSIGN_OR_THROW(auto buffer,
+                              ::arrow::AllocateBuffer(num_values * sizeof(T), pool_));
+      T* dest = reinterpret_cast<T*>(buffer->mutable_data());
+      int num_valid = ::arrow::util::internal::SpacedCompress<T>(
+          src, num_values, valid_bits, valid_bits_offset, dest);
+      Put(dest, num_valid);
+    } else {
+      Put(src, num_values);
+    }
+  }
+
+ private:
+  MemoryPool* pool_;
+  std::vector<T> values_;
+};
+
 // ----------------------------------------------------------------------
 // Factory function
 
@@ -1862,6 +1963,15 @@ std::unique_ptr<Encoder> MakeEncoder(Type::type type_num, Encoding::type encodin
         throw ParquetException(
             "DELTA_BYTE_ARRAY only supports BYTE_ARRAY and FIXED_LEN_BYTE_ARRAY");
     }
+  } else if (encoding == Encoding::PFOR) {
+    switch (type_num) {
+      case Type::INT32:
+        return std::make_unique<PforEncoder<Int32Type>>(descr, pool);
+      case Type::INT64:
+        return std::make_unique<PforEncoder<Int64Type>>(descr, pool);
+      default:
+        throw ParquetException("PFOR encoder only supports INT32 and INT64");
+    }
   } else {
     ParquetException::NYI("Selected encoding is not supported");
   }
diff --git a/cpp/src/parquet/meson.build b/cpp/src/parquet/meson.build
index 9069ccb5fd1a..1200427fe2f7 100644
--- a/cpp/src/parquet/meson.build
+++ b/cpp/src/parquet/meson.build
@@ -226,6 +226,7 @@ parquet_tests = {
     'chunker-test': {'sources': files('chunker_internal_test.cc')},
     'arrow-reader-writer-test': {
         'sources': files(
+            'arrow/arrow_encoding_test.cc',
             'arrow/arrow_reader_writer_test.cc',
             'arrow/arrow_statistics_test.cc',
             'arrow/variant_test.cc',
diff --git a/cpp/src/parquet/types.cc b/cpp/src/parquet/types.cc
index 9d7604faec30..1567d2b559e2 100644
--- a/cpp/src/parquet/types.cc
+++ b/cpp/src/parquet/types.cc
@@ -270,6 +270,8 @@ std::string EncodingToString(Encoding::type t) {
       return "RLE_DICTIONARY";
     case Encoding::BYTE_STREAM_SPLIT:
       return "BYTE_STREAM_SPLIT";
+    case Encoding::PFOR:
+      return "PFOR";
     default:
       return "UNKNOWN";
   }
diff --git a/cpp/src/parquet/types.h b/cpp/src/parquet/types.h
index 687353aa9bcb..acfedb45d795 100644
--- a/cpp/src/parquet/types.h
+++ b/cpp/src/parquet/types.h
@@ -539,8 +539,9 @@ struct Encoding {
     DELTA_BYTE_ARRAY = 7,
     RLE_DICTIONARY = 8,
     BYTE_STREAM_SPLIT = 9,
+    PFOR = 11,
     // Should always be last element (except UNKNOWN)
-    UNDEFINED = 10,
+    UNDEFINED = 12,
     UNKNOWN = 999
   };
 };

From de763837ab2005887c430a63f15d31539b8f257b Mon Sep 17 00:00:00 2001
From: Prateek Gaur <prateek.gaur@snowflake.com>
Date: Sat, 3 Oct 2026 03:12:04 +0000
Subject: [PATCH 04/27] Test and benchmark Parquet PFOR integration

The tests write and read whole files, including nulls, batched reads,
malformed pages and the factory paths. The benchmark compares PFOR with
the existing integer encodings on synthetic columns modeled on common
analytic data. It skips any compression codec the build does not include
rather than aborting.
---
 .gitignore                                   |    3 +
 cpp/src/parquet/arrow/arrow_encoding_test.cc |  392 +++++++
 cpp/src/parquet/column_writer_test.cc        |   52 +
 cpp/src/parquet/encoding_test.cc             |  238 ++++
 cpp/src/parquet/pfor_comparison_benchmark.cc | 1019 ++++++++++++++++++
 5 files changed, 1704 insertions(+)
 create mode 100644 cpp/src/parquet/arrow/arrow_encoding_test.cc
 create mode 100644 cpp/src/parquet/pfor_comparison_benchmark.cc

diff --git a/.gitignore b/.gitignore
index 83458ab2057b..dc53bf2c0d82 100644
--- a/.gitignore
+++ b/.gitignore
@@ -94,3 +94,6 @@ rat.txt
 
 # for ODBC DLL
 *.rc
+
+# Local out-of-tree benchmark build dir
+cpp/build-bench/
diff --git a/cpp/src/parquet/arrow/arrow_encoding_test.cc b/cpp/src/parquet/arrow/arrow_encoding_test.cc
new file mode 100644
index 000000000000..1adec93341ea
--- /dev/null
+++ b/cpp/src/parquet/arrow/arrow_encoding_test.cc
@@ -0,0 +1,392 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+// End-to-end tests for the column encodings, driven through the Arrow reader
+// and writer rather than through the encoder classes directly.
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+#include <cstdint>
+#include <limits>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "arrow/chunked_array.h"
+#include "arrow/io/memory.h"
+#include "arrow/table.h"
+#include "arrow/testing/builder.h"
+#include "arrow/testing/gtest_util.h"
+#include "arrow/testing/random.h"
+#include "arrow/type.h"
+#include "arrow/util/config.h"
+
+#include "parquet/arrow/reader.h"
+#include "parquet/arrow/writer.h"
+#include "parquet/file_reader.h"
+#include "parquet/metadata.h"
+#include "parquet/platform.h"
+#include "parquet/properties.h"
+#include "parquet/test_util.h"
+#include "parquet/types.h"
+
+using arrow::ChunkedArray;
+using arrow::Table;
+using arrow::io::BufferReader;
+
+namespace parquet {
+namespace arrow {
+namespace {
+
+// Write `table` with `writer_properties` and read it straight back, handing back
+// the file's bytes as well so a caller can check what the writer chose.
+void DoRoundtrip(const std::shared_ptr<Table>& table, int64_t row_group_size,
+                 std::shared_ptr<Table>* out,
+                 const std::shared_ptr<WriterProperties>& writer_properties,
+                 std::shared_ptr<Buffer>* out_file = nullptr) {
+  auto sink = CreateOutputStream();
+  ASSERT_OK_NO_THROW(WriteTable(*table, ::arrow::default_memory_pool(), sink,
+                                row_group_size, writer_properties));
+  ASSERT_OK_AND_ASSIGN(auto buffer, sink->Finish());
+  if (out_file != nullptr) {
+    *out_file = buffer;
+  }
+
+  std::unique_ptr<FileReader> reader;
+  FileReaderBuilder builder;
+  ASSERT_OK_NO_THROW(builder.Open(std::make_shared<BufferReader>(buffer)));
+  ASSERT_OK(builder.Build(&reader));
+  ASSERT_OK_AND_ASSIGN(*out, reader->ReadTable());
+}
+
+// Fail unless every column chunk of `file` was written with `encoding`. Without
+// this a round trip still passes when the writer quietly chose something else,
+// and the test would be checking the default encoding instead.
+void AssertAllColumnsUse(const std::shared_ptr<Buffer>& file, Encoding::type encoding) {
+  auto metadata =
+      ParquetFileReader::Open(std::make_shared<BufferReader>(file))->metadata();
+  ASSERT_GT(metadata->num_row_groups(), 0);
+  for (int rg = 0; rg < metadata->num_row_groups(); ++rg) {
+    auto row_group = metadata->RowGroup(rg);
+    for (int col = 0; col < row_group->num_columns(); ++col) {
+      EXPECT_THAT(row_group->ColumnChunk(col)->encodings(), ::testing::Contains(encoding))
+          << "row group " << rg << " column " << col << " does not use "
+          << EncodingToString(encoding);
+    }
+  }
+}
+
+// ----------------------------------------------------------------------
+// PFOR encoding file-level integration tests
+
+class ParquetPforEncodingTest : public ::testing::Test {
+ public:
+  void TestPforRoundTrip(const std::shared_ptr<Table>& table,
+                         int64_t row_group_size = -1) {
+    auto writer_props = WriterProperties::Builder()
+                            .disable_dictionary()
+                            ->encoding(Encoding::PFOR)
+                            ->build();
+
+    std::shared_ptr<Table> result;
+    std::shared_ptr<Buffer> file;
+    DoRoundtrip(table, row_group_size < 0 ? table->num_rows() : row_group_size, &result,
+                writer_props, &file);
+
+    ASSERT_NO_FATAL_FAILURE(AssertAllColumnsUse(file, Encoding::PFOR));
+    ASSERT_NO_FATAL_FAILURE(::arrow::AssertTablesEqual(*table, *result));
+  }
+
+  void TestPforWithCompression(const std::shared_ptr<Table>& table,
+                               Compression::type compression) {
+    auto writer_props = WriterProperties::Builder()
+                            .disable_dictionary()
+                            ->encoding(Encoding::PFOR)
+                            ->compression(compression)
+                            ->build();
+
+    std::shared_ptr<Table> result;
+    std::shared_ptr<Buffer> file;
+    DoRoundtrip(table, table->num_rows(), &result, writer_props, &file);
+
+    ASSERT_NO_FATAL_FAILURE(AssertAllColumnsUse(file, Encoding::PFOR));
+    ASSERT_NO_FATAL_FAILURE(::arrow::AssertTablesEqual(*table, *result));
+  }
+
+  // A table of one column named "values" holding `values`.
+  template <typename ArrowType, typename C>
+  static std::shared_ptr<Table> TableOf(const std::shared_ptr<::arrow::DataType>& type,
+                                        const C& values) {
+    std::shared_ptr<::arrow::Array> array;
+    ::arrow::ArrayFromVector<ArrowType>(values, &array);
+    return Table::Make(::arrow::schema({::arrow::field("values", type)}),
+                       {std::make_shared<ChunkedArray>(array)});
+  }
+};
+
+TEST_F(ParquetPforEncodingTest, SimpleInt32Table) {
+  auto schema = ::arrow::schema({::arrow::field("values", ::arrow::int32())});
+  auto table = ::arrow::TableFromJSON(
+      schema, {R"([[1], [2], [3], [4], [5], [6], [7], [8], [9], [10]])"});
+  TestPforRoundTrip(table);
+}
+
+TEST_F(ParquetPforEncodingTest, SimpleInt64Table) {
+  auto schema = ::arrow::schema({::arrow::field("values", ::arrow::int64())});
+  auto table = ::arrow::TableFromJSON(
+      schema, {R"([[-100], [0], [100], [200], [300], [400], [500], [600], [700]])"});
+  TestPforRoundTrip(table);
+}
+
+TEST_F(ParquetPforEncodingTest, MixedTypesWithInt32Int64) {
+  auto schema = ::arrow::schema({::arrow::field("id", ::arrow::int32()),
+                                 ::arrow::field("count", ::arrow::int64()),
+                                 ::arrow::field("ratio", ::arrow::float64()),
+                                 ::arrow::field("name", ::arrow::utf8())});
+  auto table = ::arrow::TableFromJSON(schema, {R"([[1, 1000, 1.5, "a"],
+                                          [2, 1001, 2.5, "b"],
+                                          [3, 1002, 3.5, "c"],
+                                          [4, 1003, 4.5, "d"],
+                                          [5, 1004, 5.5, "e"]])"});
+  // PFOR takes only the two integer columns; the rest keep their defaults.
+  auto writer_props = WriterProperties::Builder()
+                          .disable_dictionary()
+                          ->encoding("id", Encoding::PFOR)
+                          ->encoding("count", Encoding::PFOR)
+                          ->build();
+
+  std::shared_ptr<Table> result;
+  std::shared_ptr<Buffer> file;
+  DoRoundtrip(table, table->num_rows(), &result, writer_props, &file);
+
+  auto metadata =
+      ParquetFileReader::Open(std::make_shared<BufferReader>(file))->metadata();
+  ASSERT_THAT(metadata->RowGroup(0)->ColumnChunk(0)->encodings(),
+              ::testing::Contains(Encoding::PFOR));
+  ASSERT_THAT(metadata->RowGroup(0)->ColumnChunk(1)->encodings(),
+              ::testing::Contains(Encoding::PFOR));
+  ASSERT_NO_FATAL_FAILURE(::arrow::AssertTablesEqual(*table, *result));
+}
+
+TEST_F(ParquetPforEncodingTest, LargeInt32Dataset) {
+  ::arrow::random::RandomArrayGenerator rag(42);
+  auto array = rag.Int32(10000, -1000000, 1000000);
+
+  auto schema = ::arrow::schema({::arrow::field("values", ::arrow::int32())});
+  auto table = Table::Make(schema, {std::make_shared<ChunkedArray>(array)});
+
+  TestPforRoundTrip(table);
+}
+
+TEST_F(ParquetPforEncodingTest, LargeInt64Dataset) {
+  ::arrow::random::RandomArrayGenerator rag(42);
+  auto array = rag.Int64(10000, -1000000000LL, 1000000000LL);
+
+  auto schema = ::arrow::schema({::arrow::field("values", ::arrow::int64())});
+  auto table = Table::Make(schema, {std::make_shared<ChunkedArray>(array)});
+
+  TestPforRoundTrip(table);
+}
+
+// The distribution PFOR is built for: a tight cluster sitting a long way from
+// zero, so the frame of reference carries the magnitude and the bit-packed
+// payload carries only the spread.
+TEST_F(ParquetPforEncodingTest, ClusteredValuesFarFromZero) {
+  std::vector<int64_t> values(4000);
+  for (size_t i = 0; i < values.size(); ++i) {
+    values[i] = 1'000'000'000'000LL + static_cast<int64_t>(i % 37);
+  }
+  TestPforRoundTrip(TableOf<::arrow::Int64Type>(::arrow::int64(), values));
+}
+
+// One vector of a constant, which encodes at bit width 0 and so has an empty
+// bit-packed payload.
+TEST_F(ParquetPforEncodingTest, ConstantColumn) {
+  std::vector<int32_t> values(2048, -7);
+  TestPforRoundTrip(TableOf<::arrow::Int32Type>(::arrow::int32(), values));
+}
+
+// A cluster with a few values far above it, which is what the exception path
+// exists to hold.
+TEST_F(ParquetPforEncodingTest, ClusterWithOutliers) {
+  std::vector<int32_t> values(3000);
+  for (size_t i = 0; i < values.size(); ++i) {
+    values[i] = 500 + static_cast<int32_t>(i % 11);
+    if (i % 97 == 0) {
+      values[i] = 1'000'000 + static_cast<int32_t>(i);
+    }
+  }
+  TestPforRoundTrip(TableOf<::arrow::Int32Type>(::arrow::int32(), values));
+}
+
+// The extremes of each type in one vector, where the span between the smallest
+// and largest value does not fit in the type and the encoder has to fall back
+// to storing full-width values.
+TEST_F(ParquetPforEncodingTest, Int32AtTypeBounds) {
+  std::vector<int32_t> values = {std::numeric_limits<int32_t>::lowest(),
+                                 std::numeric_limits<int32_t>::max(),
+                                 0,
+                                 -1,
+                                 1,
+                                 std::numeric_limits<int32_t>::lowest() + 1,
+                                 std::numeric_limits<int32_t>::max() - 1};
+  TestPforRoundTrip(TableOf<::arrow::Int32Type>(::arrow::int32(), values));
+}
+
+TEST_F(ParquetPforEncodingTest, Int64AtTypeBounds) {
+  std::vector<int64_t> values = {std::numeric_limits<int64_t>::lowest(),
+                                 std::numeric_limits<int64_t>::max(),
+                                 0,
+                                 -1,
+                                 1,
+                                 std::numeric_limits<int64_t>::lowest() + 1,
+                                 std::numeric_limits<int64_t>::max() - 1};
+  TestPforRoundTrip(TableOf<::arrow::Int64Type>(::arrow::int64(), values));
+}
+
+TEST_F(ParquetPforEncodingTest, Int32WithNulls) {
+  auto schema = ::arrow::schema({::arrow::field("values", ::arrow::int32())});
+  auto table = ::arrow::TableFromJSON(
+      schema, {R"([[1], [null], [3], [null], [5], [6], [null], [8]])"});
+  TestPforRoundTrip(table);
+}
+
+// A PFOR page holds no nulls, so an all-null page carries no values at all and
+// has to survive the round trip as a header with an empty payload.
+TEST_F(ParquetPforEncodingTest, AllNullColumn) {
+  auto schema = ::arrow::schema({::arrow::field("values", ::arrow::int64())});
+  auto table = ::arrow::TableFromJSON(
+      schema, {R"([[null], [null], [null], [null], [null], [null]])"});
+  TestPforRoundTrip(table);
+}
+
+// Nulls ahead of the first value, which makes the level count and the value
+// count differ from the very first batch a reader sees.
+TEST_F(ParquetPforEncodingTest, LeadingNulls) {
+  auto schema = ::arrow::schema({::arrow::field("values", ::arrow::int32())});
+  auto table = ::arrow::TableFromJSON(
+      schema, {R"([[null], [null], [null], [7], [8], [9], [null], [11]])"});
+  TestPforRoundTrip(table);
+}
+
+TEST_F(ParquetPforEncodingTest, MultipleRowGroups) {
+  ::arrow::random::RandomArrayGenerator rag(123);
+  auto array = rag.Int64(5000, -100, 100);
+
+  auto schema = ::arrow::schema({::arrow::field("values", ::arrow::int64())});
+  auto table = Table::Make(schema, {std::make_shared<ChunkedArray>(array)});
+
+  TestPforRoundTrip(table, /*row_group_size=*/1000);
+}
+
+// Row groups that do not divide the vector size, so most pages end on a partial
+// vector.
+TEST_F(ParquetPforEncodingTest, RowGroupsEndOnPartialVectors) {
+  ::arrow::random::RandomArrayGenerator rag(7);
+  auto array = rag.Int32(5000, -50000, 50000);
+
+  auto schema = ::arrow::schema({::arrow::field("values", ::arrow::int32())});
+  auto table = Table::Make(schema, {std::make_shared<ChunkedArray>(array)});
+
+  TestPforRoundTrip(table, /*row_group_size=*/1500);
+}
+
+#ifdef ARROW_WITH_ZSTD
+TEST_F(ParquetPforEncodingTest, PforWithZstdCompression) {
+  ::arrow::random::RandomArrayGenerator rag(42);
+  auto array = rag.Int64(5000, -1000, 1000);
+
+  auto schema = ::arrow::schema({::arrow::field("values", ::arrow::int64())});
+  auto table = Table::Make(schema, {std::make_shared<ChunkedArray>(array)});
+
+  TestPforWithCompression(table, Compression::ZSTD);
+}
+#endif
+
+#ifdef ARROW_WITH_SNAPPY
+TEST_F(ParquetPforEncodingTest, PforWithSnappyCompression) {
+  ::arrow::random::RandomArrayGenerator rag(42);
+  auto array = rag.Int32(5000, -1000, 1000);
+
+  auto schema = ::arrow::schema({::arrow::field("values", ::arrow::int32())});
+  auto table = Table::Make(schema, {std::make_shared<ChunkedArray>(array)});
+
+  TestPforWithCompression(table, Compression::SNAPPY);
+}
+#endif
+
+TEST_F(ParquetPforEncodingTest, VerifyPforEncodingUsed) {
+  std::vector<int64_t> values(1000);
+  for (size_t i = 0; i < values.size(); ++i) {
+    values[i] = 5'000'000 + static_cast<int64_t>(i);
+  }
+  auto table = TableOf<::arrow::Int64Type>(::arrow::int64(), values);
+
+  auto writer_props =
+      WriterProperties::Builder().disable_dictionary()->encoding(Encoding::PFOR)->build();
+
+  auto sink = CreateOutputStream();
+  ASSERT_OK(WriteTable(*table, ::arrow::default_memory_pool(), sink, table->num_rows(),
+                       writer_props));
+  ASSERT_OK_AND_ASSIGN(auto buffer, sink->Finish());
+
+  auto reader = ParquetFileReader::Open(std::make_shared<BufferReader>(buffer));
+  auto metadata = reader->metadata();
+
+  ASSERT_EQ(metadata->num_row_groups(), 1);
+  auto row_group = metadata->RowGroup(0);
+  ASSERT_EQ(row_group->num_columns(), 1);
+
+  auto encodings = row_group->ColumnChunk(0)->encodings();
+  EXPECT_THAT(encodings, ::testing::Contains(Encoding::PFOR))
+      << "PFOR encoding not found in column encodings";
+}
+
+// A reader that asks for fewer values than the page holds is served the rest on
+// later calls, so batches smaller than a page must reassemble exactly.
+TEST_F(ParquetPforEncodingTest, ReadInSmallBatches) {
+  ::arrow::random::RandomArrayGenerator rag(99);
+  auto array = rag.Int32(4096, -30000, 30000);
+
+  auto schema = ::arrow::schema({::arrow::field("values", ::arrow::int32())});
+  auto table = Table::Make(schema, {std::make_shared<ChunkedArray>(array)});
+
+  auto writer_props =
+      WriterProperties::Builder().disable_dictionary()->encoding(Encoding::PFOR)->build();
+
+  auto sink = CreateOutputStream();
+  ASSERT_OK(WriteTable(*table, ::arrow::default_memory_pool(), sink, table->num_rows(),
+                       writer_props));
+  ASSERT_OK_AND_ASSIGN(auto buffer, sink->Finish());
+
+  std::unique_ptr<FileReader> reader;
+  FileReaderBuilder builder;
+  ASSERT_OK_NO_THROW(builder.Open(std::make_shared<BufferReader>(buffer)));
+  ASSERT_OK(builder.properties(default_arrow_reader_properties())->Build(&reader));
+  reader->set_batch_size(97);
+
+  ASSERT_OK_AND_ASSIGN(auto batch_reader, reader->GetRecordBatchReader());
+  ASSERT_OK_AND_ASSIGN(auto result, batch_reader->ToTable());
+
+  ASSERT_NO_FATAL_FAILURE(
+      ::arrow::AssertTablesEqual(*table, *result, /*same_chunk_layout=*/false));
+}
+
+}  // namespace
+}  // namespace arrow
+}  // namespace parquet
diff --git a/cpp/src/parquet/column_writer_test.cc b/cpp/src/parquet/column_writer_test.cc
index 69ec07c1b78f..d4b183305da4 100644
--- a/cpp/src/parquet/column_writer_test.cc
+++ b/cpp/src/parquet/column_writer_test.cc
@@ -178,6 +178,40 @@ class TestPrimitiveWriter : public PrimitiveTypedTest<TestType> {
     ASSERT_NO_FATAL_FAILURE(this->ReadAndCompare(compression, num_rows, enable_checksum));
   }
 
+  // Round-trip an optional PFOR column through a DataPageV2 page. Optional pages
+  // carry definition levels, and when every value is null the encoder is flushed
+  // with no values at all.
+  void TestPforOptionalDataPageV2(int num_nulls) {
+    ASSERT_LE(num_nulls, SMALL_SIZE);
+    this->SetUpSchema(Repetition::OPTIONAL);
+    this->descr_ = this->schema_.Column(0);
+    this->GenerateData(SMALL_SIZE);
+
+    // The nulls come first, so the values the writer consumes are the leading
+    // SMALL_SIZE - num_nulls entries of `values_`.
+    std::vector<int16_t> definition_levels(SMALL_SIZE, 1);
+    for (int i = 0; i < num_nulls; ++i) {
+      definition_levels[i] = 0;
+    }
+
+    ColumnProperties column_properties;
+    column_properties.set_encoding(Encoding::PFOR);
+    auto writer =
+        this->BuildWriter(SMALL_SIZE, column_properties, ParquetVersion::PARQUET_2_LATEST,
+                          ParquetDataPageVersion::V2);
+    writer->WriteBatch(SMALL_SIZE, definition_levels.data(), nullptr, this->values_ptr_);
+    writer->Close();
+
+    ASSERT_EQ(SMALL_SIZE, this->metadata_num_values());
+
+    this->ReadColumn();
+    const int64_t num_expected = SMALL_SIZE - num_nulls;
+    ASSERT_EQ(num_expected, this->values_read_);
+    this->values_out_.resize(num_expected);
+    this->values_.resize(num_expected);
+    ASSERT_EQ(this->values_, this->values_out_);
+  }
+
   void TestRequiredWithCodecOptions(Encoding::type encoding,
                                     Compression::type compression, bool enable_dictionary,
                                     bool enable_statistics, int64_t num_rows = SMALL_SIZE,
@@ -2475,5 +2509,23 @@ TYPED_TEST(TestBloomFilterWriter, Basic) {
   }
 }
 
+// PFOR on an optional column with DataPageV2 pages
+TEST_F(TestValuesWriterInt32Type, PforOptionalDataPageV2) {
+  this->TestPforOptionalDataPageV2(/*num_nulls=*/3);
+}
+
+TEST_F(TestValuesWriterInt64Type, PforOptionalDataPageV2) {
+  this->TestPforOptionalDataPageV2(/*num_nulls=*/3);
+}
+
+// An all-null page holds no values, so its PFOR payload is a bare header
+TEST_F(TestValuesWriterInt32Type, PforAllNullDataPageV2) {
+  this->TestPforOptionalDataPageV2(/*num_nulls=*/SMALL_SIZE);
+}
+
+TEST_F(TestValuesWriterInt64Type, PforAllNullDataPageV2) {
+  this->TestPforOptionalDataPageV2(/*num_nulls=*/SMALL_SIZE);
+}
+
 }  // namespace test
 }  // namespace parquet
diff --git a/cpp/src/parquet/encoding_test.cc b/cpp/src/parquet/encoding_test.cc
index 831829e4a210..c9315f56c378 100644
--- a/cpp/src/parquet/encoding_test.cc
+++ b/cpp/src/parquet/encoding_test.cc
@@ -22,6 +22,7 @@
 #include <cstring>
 #include <functional>
 #include <limits>
+#include <numeric>
 #include <span>
 #include <utility>
 #include <vector>
@@ -1044,6 +1045,71 @@ class EncodingAdHocTyped : public ::testing::Test {
     ::arrow::AssertArraysEqual(*values, *result);
   }
 
+  void Pfor(int seed) {
+    if (!std::is_same<ParquetType, Int32Type>::value &&
+        !std::is_same<ParquetType, Int64Type>::value) {
+      return;
+    }
+    auto values = GetValues(seed);
+    auto encoder =
+        MakeTypedEncoder<ParquetType>(Encoding::PFOR,
+                                      /*use_dictionary=*/false, column_descr());
+    auto decoder = MakeTypedDecoder<ParquetType>(Encoding::PFOR, column_descr());
+
+    ASSERT_NO_THROW(encoder->Put(*values));
+    auto buf = encoder->FlushValues();
+
+    int num_values = static_cast<int>(values->length() - values->null_count());
+    decoder->SetData(num_values, buf->data(), static_cast<int>(buf->size()));
+
+    BuilderType acc(arrow_type(), ::arrow::default_memory_pool());
+    ASSERT_EQ(num_values,
+              decoder->DecodeArrow(static_cast<int>(values->length()),
+                                   static_cast<int>(values->null_count()),
+                                   values->null_bitmap_data(), values->offset(), &acc));
+
+    std::shared_ptr<::arrow::Array> result;
+    ASSERT_OK(acc.Finish(&result));
+    ASSERT_OK(result->ValidateFull());
+    ASSERT_EQ(size_, result->length());
+    ::arrow::AssertArraysEqual(*values, *result, /*verbose=*/true);
+  }
+
+  void PforDict(int seed) {
+    if constexpr (!std::is_same_v<ParquetType, Int32Type> &&
+                  !std::is_same_v<ParquetType, Int64Type>) {
+      return;
+    } else {
+      auto values = GetValues(seed);
+      auto encoder =
+          MakeTypedEncoder<ParquetType>(Encoding::PFOR,
+                                        /*use_dictionary=*/false, column_descr());
+      auto decoder = MakeTypedDecoder<ParquetType>(Encoding::PFOR, column_descr());
+
+      ASSERT_NO_THROW(encoder->Put(*values));
+      auto buf = encoder->FlushValues();
+
+      int num_values = static_cast<int>(values->length() - values->null_count());
+      decoder->SetData(num_values, buf->data(), static_cast<int>(buf->size()));
+
+      DictBuilderType acc(arrow_type(), ::arrow::default_memory_pool());
+      ASSERT_EQ(num_values,
+                decoder->DecodeArrow(static_cast<int>(values->length()),
+                                     static_cast<int>(values->null_count()),
+                                     values->null_bitmap_data(), values->offset(), &acc));
+
+      std::shared_ptr<::arrow::Array> result;
+      ASSERT_OK(acc.Finish(&result));
+      ASSERT_OK(result->ValidateFull());
+      ASSERT_EQ(size_, result->length());
+
+      // The accumulator produced a DictionaryArray; compare it densely.
+      ASSERT_OK_AND_ASSIGN(auto dense_datum,
+                           ::arrow::compute::Cast(::arrow::Datum(result), arrow_type()));
+      ::arrow::AssertArraysEqual(*values, *dense_datum.make_array(), /*verbose=*/true);
+    }
+  }
+
   void Dict(int seed) {
     if (std::is_same<ParquetType, BooleanType>::value) {
       return;
@@ -1228,6 +1294,27 @@ TYPED_TEST(EncodingAdHocTyped, DeltaBitPackArrowDirectPut) {
   }
 }
 
+TYPED_TEST(EncodingAdHocTyped, PforArrowDirectPut) {
+  for (auto seed : {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}) {
+    this->Pfor(seed);
+  }
+  // Same, but without nulls (this could trigger different code paths)
+  this->null_probability_ = 0.0;
+  for (auto seed : {0, 1, 2, 3, 4}) {
+    this->Pfor(seed);
+  }
+}
+
+TYPED_TEST(EncodingAdHocTyped, PforArrowDirectPutDictBuilder) {
+  for (auto seed : {0, 1, 2, 3, 4}) {
+    this->PforDict(seed);
+  }
+  this->null_probability_ = 0.0;
+  for (auto seed : {0, 1, 2, 3, 4}) {
+    this->PforDict(seed);
+  }
+}
+
 TYPED_TEST(EncodingAdHocTyped, DictArrowDirectPut) { this->Dict(0); }
 
 TYPED_TEST(EncodingAdHocTyped, DictArrowDirectPutIndices) { this->DictPutIndices(); }
@@ -2034,6 +2121,157 @@ TYPED_TEST(TestDeltaBitPackEncoding, ZeroDeltaBitWidth) {
   this->CheckRoundtripWithValues(int_values);
 }
 
+// ----------------------------------------------------------------------
+// PFOR encode/decode tests.
+
+template <typename Type>
+class TestPforEncoding : public TestEncodingBase<Type> {
+ public:
+  using c_type = typename Type::c_type;
+  static constexpr int TYPE = Type::type_num;
+
+  void CheckDecoding(int read_batch_size) {
+    auto decoder = MakeTypedDecoder<Type>(Encoding::PFOR, descr_.get());
+    decoder->SetData(num_values_, encode_buffer_->data(),
+                     static_cast<int>(encode_buffer_->size()));
+
+    std::vector<c_type> decoded(num_values_);
+    int values_decoded = 0;
+    while (values_decoded < num_values_) {
+      const int decoded_now =
+          decoder->Decode(decoded.data() + values_decoded, read_batch_size);
+      ASSERT_GT(decoded_now, 0);
+      values_decoded += decoded_now;
+    }
+    ASSERT_EQ(num_values_, values_decoded);
+    ASSERT_NO_FATAL_FAILURE(VerifyResults<c_type>(decoded.data(), draws_, num_values_));
+  }
+
+  void CheckRoundtrip() override {
+    auto encoder = MakeTypedEncoder<Type>(Encoding::PFOR,
+                                          /*use_dictionary=*/false, descr_.get());
+    encoder->Put(draws_, num_values_);
+    encode_buffer_ = encoder->FlushValues();
+
+    // A reader asks for whatever its batch size is, so the page has to come out
+    // the same whether it is drained in one call or in many.
+    for (const int read_batch_size : {1, 11, num_values_}) {
+      if (read_batch_size > 0) {
+        ASSERT_NO_FATAL_FAILURE(CheckDecoding(read_batch_size));
+      }
+    }
+  }
+
+ protected:
+  USING_BASE_MEMBERS();
+};
+
+using TestPforEncodingTypes = ::testing::Types<Int32Type, Int64Type>;
+TYPED_TEST_SUITE(TestPforEncoding, TestPforEncodingTypes);
+
+TYPED_TEST(TestPforEncoding, BasicRoundTrip) {
+  // The default vector size is 1024, so cover an empty page, a single value, a
+  // partial vector, an exact multiple, and a partial trailing vector.
+  ASSERT_NO_FATAL_FAILURE(this->Execute(0, 0));
+  ASSERT_NO_FATAL_FAILURE(this->Execute(1, 1));
+  ASSERT_NO_FATAL_FAILURE(this->Execute(100, 1));
+  ASSERT_NO_FATAL_FAILURE(this->Execute(1024, 4));
+  ASSERT_NO_FATAL_FAILURE(this->Execute(1025, 3));
+}
+
+TYPED_TEST(TestPforEncoding, DecoderReusedAcrossPages) {
+  using c_type = typename TypeParam::c_type;
+  auto encoder =
+      MakeTypedEncoder<TypeParam>(Encoding::PFOR,
+                                  /*use_dictionary=*/false, this->descr_.get());
+  auto decoder = MakeTypedDecoder<TypeParam>(Encoding::PFOR, this->descr_.get());
+
+  // A column chunk reuses one decoder for all of its data pages, with only
+  // SetData between them. The second page is the longer one, so a decoder that
+  // kept the first page's values would also read past the end of them.
+  const std::vector<std::vector<c_type>> pages = {
+      {10, 11, 12, 13}, {900, 901, 902, 903, 904, 905, 906, 907}};
+
+  for (const auto& page : pages) {
+    const int page_values = static_cast<int>(page.size());
+    encoder->Put(page.data(), page_values);
+    auto buffer = encoder->FlushValues();
+    decoder->SetData(page_values, buffer->data(), static_cast<int>(buffer->size()));
+
+    std::vector<c_type> decoded(page.size());
+    ASSERT_EQ(page_values, decoder->Decode(decoded.data(), page_values));
+    ASSERT_EQ(page, decoded);
+  }
+}
+
+TYPED_TEST(TestPforEncoding, AllNullPage) {
+  constexpr int kNumValues = 40;
+  auto encoder =
+      MakeTypedEncoder<TypeParam>(Encoding::PFOR,
+                                  /*use_dictionary=*/false, this->descr_.get());
+  auto buffer = encoder->FlushValues();
+
+  // A reader hands the decoder the page's level count, which counts the nulls, so
+  // the page and its bare header have to survive being handed the full count.
+  auto decoder = MakeTypedDecoder<TypeParam>(Encoding::PFOR, this->descr_.get());
+  decoder->SetData(kNumValues, buffer->data(), static_cast<int>(buffer->size()));
+
+  // All slots are null, so the page carries no encoded values at all.
+  std::vector<uint8_t> valid_bits(bit_util::BytesForBits(kNumValues), 0);
+  typename EncodingTraits<TypeParam>::Accumulator acc;
+  ASSERT_EQ(0, decoder->DecodeArrow(kNumValues, /*null_count=*/kNumValues,
+                                    valid_bits.data(), /*valid_bits_offset=*/0, &acc));
+
+  std::shared_ptr<::arrow::Array> result;
+  ASSERT_OK(acc.Finish(&result));
+  ASSERT_OK(result->ValidateFull());
+  ASSERT_EQ(kNumValues, result->length());
+  ASSERT_EQ(kNumValues, result->null_count());
+}
+
+TYPED_TEST(TestPforEncoding, RejectsPageWithUnreadValues) {
+  using c_type = typename TypeParam::c_type;
+  constexpr int kNumValues = 200;
+  constexpr int kNullCount = 30;
+
+  std::vector<c_type> values(kNumValues);
+  std::iota(values.begin(), values.end(), static_cast<c_type>(0));
+  auto encoder =
+      MakeTypedEncoder<TypeParam>(Encoding::PFOR,
+                                  /*use_dictionary=*/false, this->descr_.get());
+  encoder->Put(values.data(), kNumValues);
+  auto encoded = encoder->FlushValues();
+
+  std::vector<uint8_t> valid_bits(bit_util::BytesForBits(kNumValues), 0);
+  for (int i = 0; i < kNumValues - kNullCount; ++i) {
+    bit_util::SetBit(valid_bits.data(), i);
+  }
+  std::vector<c_type> output(kNumValues);
+  auto decoder = MakeTypedDecoder<TypeParam>(Encoding::PFOR, this->descr_.get());
+  decoder->SetData(kNumValues, encoded->data(), static_cast<int>(encoded->size()));
+  ASSERT_THROW(decoder->DecodeSpaced(output.data(), kNumValues, kNullCount,
+                                     valid_bits.data(), /*valid_bits_offset=*/0),
+               ParquetException);
+}
+
+TYPED_TEST(TestPforEncoding, RejectsNegativeArguments) {
+  using c_type = typename TypeParam::c_type;
+  auto decoder = MakeTypedDecoder<TypeParam>(Encoding::PFOR, this->descr_.get());
+  uint8_t byte = 0;
+  ASSERT_THROW(decoder->SetData(-1, &byte, 1), ParquetException);
+  ASSERT_THROW(decoder->SetData(0, &byte, -1), ParquetException);
+
+  auto encoder =
+      MakeTypedEncoder<TypeParam>(Encoding::PFOR,
+                                  /*use_dictionary=*/false, this->descr_.get());
+  const c_type value = 7;
+  encoder->Put(&value, 1);
+  auto encoded = encoder->FlushValues();
+  decoder->SetData(1, encoded->data(), static_cast<int>(encoded->size()));
+  c_type output{};
+  ASSERT_THROW(decoder->Decode(&output, -1), ParquetException);
+}
+
 // ----------------------------------------------------------------------
 // Rle for Boolean encode/decode tests.
 
diff --git a/cpp/src/parquet/pfor_comparison_benchmark.cc b/cpp/src/parquet/pfor_comparison_benchmark.cc
new file mode 100644
index 000000000000..f44216b8812a
--- /dev/null
+++ b/cpp/src/parquet/pfor_comparison_benchmark.cc
@@ -0,0 +1,1019 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+// Comparison benchmark: PFOR vs DeltaBitPack vs ZSTD vs RleBitPackHybrid
+//                       vs ByteStreamSplit+ZSTD vs ByteStreamSplit+LZ4
+//
+// All throughput is reported as uncompressed_size / time (MB/s).
+// Data generators mimic ClickBench and TPC-DS column distributions.
+
+#include <algorithm>
+#include <bit>
+#include <cmath>
+#include <cstdint>
+#include <cstring>
+#include <memory>
+#include <numeric>
+#include <random>
+#include <string>
+#include <type_traits>
+#include <vector>
+
+#include "benchmark/benchmark.h"
+
+#include "arrow/util/compression.h"
+#include "arrow/util/logging.h"
+#include "arrow/util/pfor/pfor_wrapper_internal.h"
+#include "arrow/util/rle_encoding_internal.h"
+
+#include "parquet/encoding.h"
+#include "parquet/platform.h"
+#include "parquet/schema.h"
+#include "parquet/types.h"
+
+using ::arrow::Compression;
+using ::arrow::util::Codec;
+
+namespace parquet {
+namespace {
+
+// ----------------------------------------------------------------------
+// Data generators: ClickBench-like columns
+
+// Generator pointer type, parameterized on the column value type.
+template <typename T>
+using GenT = std::vector<T> (*)(int64_t);
+using Gen32 = GenT<int32_t>;
+using Gen64 = GenT<int64_t>;
+
+// Map the C++ value type to its Parquet physical type + descriptor type.
+template <typename T>
+struct PqTraits;
+template <>
+struct PqTraits<int32_t> {
+  using PType = Int32Type;
+  static constexpr Type::type kPhysicalType = Type::INT32;
+};
+template <>
+struct PqTraits<int64_t> {
+  using PType = Int64Type;
+  static constexpr Type::type kPhysicalType = Type::INT64;
+};
+
+std::vector<int32_t> GenClientIP(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(101);
+  std::uniform_int_distribution<uint32_t> dist(0x0A000000, 0xDFFFFFFF);
+  for (auto& x : v) x = static_cast<int32_t>(dist(rng));
+  return v;
+}
+
+std::vector<int32_t> GenUrlRegionID(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(102);
+  // Zipf-like over ~1000 values
+  std::uniform_real_distribution<double> uni(0.0, 1.0);
+  for (auto& x : v) {
+    double u = uni(rng);
+    x = static_cast<int32_t>(std::pow(u, 2.0) * 1000) + 1;
+  }
+  return v;
+}
+
+std::vector<int32_t> GenCounterID(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(103);
+  std::uniform_int_distribution<int32_t> jitter(0, 3);
+  int32_t counter = 100000;
+  for (auto& x : v) {
+    counter += 1 + jitter(rng);
+    x = counter;
+  }
+  return v;
+}
+
+std::vector<int32_t> GenEventDate(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(104);
+  const int32_t dates[] = {19691, 19692, 19693, 19694, 19695};
+  std::uniform_int_distribution<int> idx(0, 4);
+  for (auto& x : v) x = dates[idx(rng)];
+  return v;
+}
+
+std::vector<int32_t> GenEventTime(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(105);
+  const int32_t base = 1704067200;  // 2024-01-01
+  std::uniform_int_distribution<int32_t> offset(0, 86399);
+  for (auto& x : v) x = base + offset(rng);
+  return v;
+}
+
+std::vector<int32_t> GenGoodEvent(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(106);
+  std::uniform_int_distribution<int> dist(0, 99);
+  for (auto& x : v) x = (dist(rng) < 95) ? 1 : 0;
+  return v;
+}
+
+std::vector<int32_t> GenHID(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(107);
+  std::uniform_int_distribution<int32_t> dist(std::numeric_limits<int32_t>::min(),
+                                              std::numeric_limits<int32_t>::max());
+  for (auto& x : v) x = dist(rng);
+  return v;
+}
+
+std::vector<int32_t> GenHitColor(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(108);
+  const int32_t colors[] = {1, 2, 3, 4, 5};
+  std::uniform_int_distribution<int> idx(0, 4);
+  for (auto& x : v) x = colors[idx(rng)];
+  return v;
+}
+
+std::vector<int32_t> GenIPNetworkID(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(109);
+  std::uniform_int_distribution<int32_t> dist(1, 10000);
+  for (auto& x : v) x = dist(rng);
+  return v;
+}
+
+std::vector<int32_t> GenJavaEnable(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(110);
+  std::uniform_int_distribution<int> dist(0, 99);
+  for (auto& x : v) x = (dist(rng) < 85) ? 1 : 0;
+  return v;
+}
+
+std::vector<int32_t> GenOS(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(111);
+  std::uniform_int_distribution<int32_t> dist(1, 20);
+  for (auto& x : v) x = dist(rng);
+  return v;
+}
+
+std::vector<int32_t> GenResolution(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(112);
+  const int32_t resolutions[] = {360,  480,  600,  720,  768,  800,  900,
+                                 1024, 1050, 1080, 1200, 1440, 1600, 2160};
+  std::uniform_int_distribution<int> idx(0, 13);
+  for (auto& x : v) x = resolutions[idx(rng)];
+  return v;
+}
+
+std::vector<int32_t> GenTrafficSourceID(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(113);
+  std::uniform_int_distribution<int32_t> dist(0, 10);
+  for (auto& x : v) x = dist(rng);
+  return v;
+}
+
+std::vector<int32_t> GenUserAgent(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(114);
+  // Zipf-like over ~100 user agents
+  std::uniform_real_distribution<double> uni(0.0, 1.0);
+  for (auto& x : v) {
+    double u = uni(rng);
+    x = static_cast<int32_t>(std::pow(u, 1.5) * 100) + 1;
+  }
+  return v;
+}
+
+// ----------------------------------------------------------------------
+// Data generators: the four most queried TPC-DS store_sales columns
+
+std::vector<int32_t> GenTpcdsSoldDateSk(int64_t n) {
+  std::vector<int32_t> v(n);
+  const int32_t kBase = 2450815;
+  std::mt19937 rng(201);
+  std::uniform_int_distribution<int32_t> dist(0, 1820);
+  for (auto& x : v) x = kBase + dist(rng);
+  return v;
+}
+
+std::vector<int32_t> GenTpcdsStoreSk(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(202);
+  std::uniform_int_distribution<int32_t> dist(1, 1000);
+  for (auto& x : v) x = dist(rng);
+  return v;
+}
+
+std::vector<int32_t> GenTpcdsItemSk(int64_t n) {
+  std::vector<int32_t> v(n);
+  const int32_t kMax = 100000;
+  std::mt19937 rng(203);
+  std::exponential_distribution<double> exp_dist(0.00005);
+  for (auto& x : v) {
+    int32_t val = static_cast<int32_t>(exp_dist(rng));
+    x = std::min(val + 1, kMax);
+  }
+  return v;
+}
+
+std::vector<int32_t> GenTpcdsQuantity(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(204);
+  std::uniform_int_distribution<int32_t> small_dist(1, 10);
+  std::uniform_int_distribution<int32_t> large_dist(11, 100);
+  std::uniform_int_distribution<int> chance(0, 99);
+  for (auto& x : v) {
+    x = (chance(rng) < 90) ? small_dist(rng) : large_dist(rng);
+  }
+  return v;
+}
+
+// --- TPC-H (lineitem) top-queried numeric columns (Q1/Q3/Q5/Q6) ------------
+// l_quantity: integer [1, 50], uniform. Small range, min 1.
+std::vector<int32_t> GenTpchLQuantity(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(301);
+  std::uniform_int_distribution<int32_t> dist(1, 50);
+  for (auto& x : v) x = dist(rng);
+  return v;
+}
+
+// l_extendedprice (cents): l_quantity * p_retailprice. p_retailprice spans
+// ~$900.00..$2099.00, so cents in [90000, 10495000]. Wide range, nonzero min.
+std::vector<int32_t> GenTpchLExtendedPrice(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(302);
+  std::uniform_int_distribution<int32_t> qty(1, 50);
+  std::uniform_int_distribution<int32_t> retail_cents(90000, 209900);
+  for (auto& x : v) x = qty(rng) * retail_cents(rng);
+  return v;
+}
+
+// l_discount (x100): integer [0, 10] i.e. 0.00..0.10. Includes 0 (0%
+// discount is a real value), so this one starts at 0.
+std::vector<int32_t> GenTpchLDiscount(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(303);
+  std::uniform_int_distribution<int32_t> dist(0, 10);
+  for (auto& x : v) x = dist(rng);
+  return v;
+}
+
+// l_shipdate (days since 1970-01-01): 1992-01-01..1998-12 span. Base 8036,
+// range ~7 years. Large nonzero min -> exercises frame-of-reference.
+std::vector<int32_t> GenTpchLShipDate(int64_t n) {
+  std::vector<int32_t> v(n);
+  const int32_t kBase = 8036;  // days since epoch for 1992-01-01
+  std::mt19937 rng(304);
+  std::uniform_int_distribution<int32_t> dist(0, 2557);
+  for (auto& x : v) x = kBase + dist(rng);
+  return v;
+}
+
+// --- TPC-DS (store_sales / date_dim) further top-queried numeric columns ---
+// ss_customer_sk: surrogate key, uniform [1, 2,000,000]. Big range, min 1.
+std::vector<int32_t> GenTpcdsCustomerSk(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(311);
+  std::uniform_int_distribution<int32_t> dist(1, 2000000);
+  for (auto& x : v) x = dist(rng);
+  return v;
+}
+
+// ss_ext_sales_price (cents): skewed price, exponential mean ~$50, floored at
+// $1.00 (a sale has a nonzero price), capped at $20,000. Long tail -> patches.
+std::vector<int32_t> GenTpcdsExtSalesPrice(int64_t n) {
+  std::vector<int32_t> v(n);
+  const int32_t kMin = 100, kMax = 2000000;
+  std::mt19937 rng(312);
+  std::exponential_distribution<double> exp_dist(1.0 / 5000.0);
+  for (auto& x : v) {
+    int32_t val = kMin + static_cast<int32_t>(exp_dist(rng));
+    x = std::min(val, kMax);
+  }
+  return v;
+}
+
+// ss_net_profit (cents): usually a small profit, sometimes a loss -> negative
+// values, so the frame of reference is negative (not zero).
+std::vector<int32_t> GenTpcdsNetProfit(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(313);
+  std::uniform_int_distribution<int32_t> dist(-10000, 300000);
+  for (auto& x : v) x = dist(rng);
+  return v;
+}
+
+// d_year: queried date_dim year range [1998, 2003]. Low cardinality, min 1998.
+std::vector<int32_t> GenTpcdsDYear(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(314);
+  std::uniform_int_distribution<int32_t> dist(1998, 2003);
+  for (auto& x : v) x = dist(rng);
+  return v;
+}
+
+// --- NYC yellow-taxi trip numeric columns ----------------------------------
+// pickup timestamp (unix seconds): 2015-01, base 1,420,070,400 + ~31 days.
+// Very large min -> frame-of-reference is essential.
+std::vector<int32_t> GenTaxiPickupUnixTime(int64_t n) {
+  std::vector<int32_t> v(n);
+  const int32_t kBase = 1420070400;  // 2015-01-01 UTC
+  std::mt19937 rng(321);
+  std::uniform_int_distribution<int32_t> dist(0, 2678400);  // ~31 days
+  for (auto& x : v) x = kBase + dist(rng);
+  return v;
+}
+
+// trip_distance (x100 miles): exponential mean ~1.8 mi, floored at 0.10 mi
+// (no zero-distance trips), capped at 100 mi. Long tail -> patches.
+std::vector<int32_t> GenTaxiTripDistanceX100(int64_t n) {
+  std::vector<int32_t> v(n);
+  const int32_t kMin = 10, kMax = 10000;
+  std::mt19937 rng(322);
+  std::exponential_distribution<double> exp_dist(1.0 / 180.0);
+  for (auto& x : v) {
+    int32_t val = kMin + static_cast<int32_t>(exp_dist(rng));
+    x = std::min(val, kMax);
+  }
+  return v;
+}
+
+// fare_amount (cents): $2.50 base + exponential mean ~$10, capped at $150.
+// Nonzero floor at the base fare, skewed with a long tail.
+std::vector<int32_t> GenTaxiFareCents(int64_t n) {
+  std::vector<int32_t> v(n);
+  const int32_t kBase = 250, kMax = 15000;
+  std::mt19937 rng(323);
+  std::exponential_distribution<double> exp_dist(1.0 / 1000.0);
+  for (auto& x : v) {
+    int32_t val = kBase + static_cast<int32_t>(exp_dist(rng));
+    x = std::min(val, kMax);
+  }
+  return v;
+}
+
+// ----------------------------------------------------------------------
+// Data generators: int64 columns whose values exceed the int32 range. Covers the common
+// 64-bit analytic cases: nanosecond timestamps, large surrogate keys, scaled-decimal
+// money, monotone IDs, and wide counters.
+
+// Nanosecond epoch timestamp (Parquet TIMESTAMP(NANOS)): 2024-01-01 base plus
+// up to ~1 day of jitter. Min ~1.70e18 -> very large frame of reference; raw
+// values need ~61 bits.
+std::vector<int64_t> GenTsNanos(int64_t n) {
+  std::vector<int64_t> v(n);
+  const int64_t kBase = 1704067200000000000LL;  // 2024-01-01T00:00:00Z in ns
+  std::mt19937_64 rng(401);
+  std::uniform_int_distribution<int64_t> off(0, 86399999999999LL);  // ~1 day
+  for (auto& x : v) x = kBase + off(rng);
+  return v;
+}
+
+// BIGINT surrogate / order key, uniform over [1, 10 billion] (exceeds 2^32).
+std::vector<int64_t> GenOrderKey(int64_t n) {
+  std::vector<int64_t> v(n);
+  std::mt19937_64 rng(402);
+  std::uniform_int_distribution<int64_t> dist(1, 10000000000LL);
+  for (auto& x : v) x = dist(rng);
+  return v;
+}
+
+// Money as int64 scaled decimal (micro-units): $0.01 .. ~$100k, skewed, with a
+// nonzero floor at one cent.
+std::vector<int64_t> GenPriceMicros(int64_t n) {
+  std::vector<int64_t> v(n);
+  const int64_t kMin = 10000, kMax = 100000000000LL;  // $0.01 .. $100,000
+  std::mt19937_64 rng(403);
+  std::exponential_distribution<double> exp_dist(1.0 / 5000000.0);  // mean ~$5
+  for (auto& x : v) {
+    int64_t val = kMin + static_cast<int64_t>(exp_dist(rng));
+    x = std::min(val, kMax);
+  }
+  return v;
+}
+
+// Snowflake-style monotone ID: large base + jittered per-row increments.
+// Monotone -> ideal for DELTA_BINARY_PACKED; huge min -> ideal for PFOR's FOR.
+std::vector<int64_t> GenSnowflakeId(int64_t n) {
+  std::vector<int64_t> v(n);
+  std::mt19937_64 rng(404);
+  std::uniform_int_distribution<int64_t> step(1, 4096);
+  int64_t id = 1500000000000000000LL;
+  for (auto& x : v) {
+    id += step(rng);
+    x = id;
+  }
+  return v;
+}
+
+// Wide cumulative byte counts, uniform [1024, 5 trillion] (wide 64-bit range).
+std::vector<int64_t> GenByteCount(int64_t n) {
+  std::vector<int64_t> v(n);
+  std::mt19937_64 rng(405);
+  std::uniform_int_distribution<int64_t> dist(1024, 5000000000000LL);
+  for (auto& x : v) x = dist(rng);
+  return v;
+}
+
+// ----------------------------------------------------------------------
+// Helpers
+
+template <typename T>
+static int32_t ComputeBitWidth(const std::vector<T>& values) {
+  using U = std::make_unsigned_t<T>;
+  U max_val = 0;
+  for (T v : values) {
+    max_val = std::max(max_val, static_cast<U>(v));
+  }
+  if (max_val == 0) return 1;
+  if constexpr (sizeof(T) == 8) {
+    return static_cast<int32_t>(std::bit_width(static_cast<uint64_t>(max_val)));
+  } else {
+    return static_cast<int32_t>(std::bit_width(static_cast<uint32_t>(max_val)));
+  }
+}
+
+template <typename T>
+static std::shared_ptr<ColumnDescriptor> MakeDescriptor() {
+  auto node = schema::PrimitiveNode::Make("col", Repetition::REQUIRED,
+                                          PqTraits<T>::kPhysicalType);
+  return std::make_shared<ColumnDescriptor>(node, /*max_def_level=*/0,
+                                            /*max_rep_level=*/0);
+}
+
+// ----------------------------------------------------------------------
+// PFOR Encode/Decode
+
+template <typename T>
+static void PforEncodeImpl(benchmark::State& state, GenT<T> gen) {
+  const int64_t num_values = state.range(0);
+  auto values = gen(num_values);
+  const int64_t uncompressed_size = num_values * sizeof(T);
+
+  int64_t max_size = ::arrow::util::pfor::PforWrapper<T>::GetMaxCompressedSize(
+                         static_cast<int32_t>(num_values))
+                         .ValueOrDie();
+  std::vector<uint8_t> compressed(max_size);
+
+  // Compute comp_size once for the counter
+  int64_t comp_size = max_size;
+  ARROW_CHECK_OK(::arrow::util::pfor::PforWrapper<T>::Encode(
+      values.data(), static_cast<int32_t>(num_values), compressed.data(), &comp_size));
+
+  for (auto _ : state) {
+    int64_t sz = max_size;
+    ARROW_CHECK_OK(::arrow::util::pfor::PforWrapper<T>::Encode(
+        values.data(), static_cast<int32_t>(num_values), compressed.data(), &sz));
+    benchmark::DoNotOptimize(sz);
+    benchmark::ClobberMemory();
+  }
+
+  state.SetBytesProcessed(state.iterations() * uncompressed_size);
+  state.SetItemsProcessed(state.iterations() * num_values);
+  state.counters["compression_ratio"] =
+      static_cast<double>(uncompressed_size) / static_cast<double>(comp_size);
+}
+static void BM_PforEncode(benchmark::State& state, Gen32 gen) {
+  PforEncodeImpl<int32_t>(state, gen);
+}
+static void BM_Pfor64Encode(benchmark::State& state, Gen64 gen) {
+  PforEncodeImpl<int64_t>(state, gen);
+}
+
+template <typename T>
+static void PforDecodeImpl(benchmark::State& state, GenT<T> gen) {
+  const int64_t num_values = state.range(0);
+  auto values = gen(num_values);
+  const int64_t uncompressed_size = num_values * sizeof(T);
+
+  int64_t max_size = ::arrow::util::pfor::PforWrapper<T>::GetMaxCompressedSize(
+                         static_cast<int32_t>(num_values))
+                         .ValueOrDie();
+  std::vector<uint8_t> compressed(max_size);
+  int64_t comp_size = max_size;
+  ARROW_CHECK_OK(::arrow::util::pfor::PforWrapper<T>::Encode(
+      values.data(), static_cast<int32_t>(num_values), compressed.data(), &comp_size));
+
+  std::vector<T> decoded(num_values);
+  for (auto _ : state) {
+    auto status = ::arrow::util::pfor::PforWrapper<T>::Decode(
+        compressed.data(), comp_size, static_cast<int32_t>(num_values), decoded.data());
+    ARROW_CHECK_OK(status);
+    benchmark::ClobberMemory();
+  }
+
+  state.SetBytesProcessed(state.iterations() * uncompressed_size);
+  state.SetItemsProcessed(state.iterations() * num_values);
+  state.counters["compression_ratio"] =
+      static_cast<double>(uncompressed_size) / static_cast<double>(comp_size);
+}
+static void BM_PforDecode(benchmark::State& state, Gen32 gen) {
+  PforDecodeImpl<int32_t>(state, gen);
+}
+static void BM_Pfor64Decode(benchmark::State& state, Gen64 gen) {
+  PforDecodeImpl<int64_t>(state, gen);
+}
+
+// ----------------------------------------------------------------------
+// DeltaBitPack Encode/Decode
+
+template <typename T>
+static void DeltaBitPackEncodeImpl(benchmark::State& state, GenT<T> gen) {
+  using PType = typename PqTraits<T>::PType;
+  const int64_t num_values = state.range(0);
+  auto values = gen(num_values);
+  const int64_t uncompressed_size = num_values * sizeof(T);
+
+  auto encoder = MakeTypedEncoder<PType>(Encoding::DELTA_BINARY_PACKED);
+
+  // Compute comp_size once for the counter
+  encoder->Put(values.data(), static_cast<int>(num_values));
+  auto pre_buf = encoder->FlushValues();
+  int64_t comp_size = pre_buf->size();
+
+  for (auto _ : state) {
+    encoder->Put(values.data(), static_cast<int>(num_values));
+    auto buf = encoder->FlushValues();
+    benchmark::DoNotOptimize(buf);
+  }
+
+  state.SetBytesProcessed(state.iterations() * uncompressed_size);
+  state.SetItemsProcessed(state.iterations() * num_values);
+  state.counters["compression_ratio"] =
+      static_cast<double>(uncompressed_size) / static_cast<double>(comp_size);
+}
+static void BM_DeltaBitPackEncode(benchmark::State& state, Gen32 gen) {
+  DeltaBitPackEncodeImpl<int32_t>(state, gen);
+}
+static void BM_DeltaBitPack64Encode(benchmark::State& state, Gen64 gen) {
+  DeltaBitPackEncodeImpl<int64_t>(state, gen);
+}
+
+template <typename T>
+static void DeltaBitPackDecodeImpl(benchmark::State& state, GenT<T> gen) {
+  using PType = typename PqTraits<T>::PType;
+  const int64_t num_values = state.range(0);
+  auto values = gen(num_values);
+  const int64_t uncompressed_size = num_values * sizeof(T);
+
+  auto encoder = MakeTypedEncoder<PType>(Encoding::DELTA_BINARY_PACKED);
+  encoder->Put(values.data(), static_cast<int>(num_values));
+  auto buf = encoder->FlushValues();
+  int64_t comp_size = buf->size();
+
+  std::vector<T> decoded(num_values);
+  auto decoder = MakeTypedDecoder<PType>(Encoding::DELTA_BINARY_PACKED);
+
+  for (auto _ : state) {
+    decoder->SetData(static_cast<int>(num_values), buf->data(),
+                     static_cast<int>(buf->size()));
+    decoder->Decode(decoded.data(), static_cast<int>(num_values));
+    benchmark::ClobberMemory();
+  }
+
+  state.SetBytesProcessed(state.iterations() * uncompressed_size);
+  state.SetItemsProcessed(state.iterations() * num_values);
+  state.counters["compression_ratio"] =
+      static_cast<double>(uncompressed_size) / static_cast<double>(comp_size);
+}
+static void BM_DeltaBitPackDecode(benchmark::State& state, Gen32 gen) {
+  DeltaBitPackDecodeImpl<int32_t>(state, gen);
+}
+static void BM_DeltaBitPack64Decode(benchmark::State& state, Gen64 gen) {
+  DeltaBitPackDecodeImpl<int64_t>(state, gen);
+}
+
+// ----------------------------------------------------------------------
+// Plain + ZSTD Encode/Decode
+
+// Codec::Create returns NotImplemented for a codec the build did not enable, and
+// dereferencing that Result aborts the process -- one unbuilt dependency would take
+// down every other benchmark registered in this binary. Report it as a skip instead.
+static std::unique_ptr<Codec> CodecOrSkip(benchmark::State& state,
+                                          Compression::type codec_type) {
+  auto maybe_codec = Codec::Create(codec_type);
+  if (!maybe_codec.ok()) {
+    state.SkipWithError(maybe_codec.status().ToString().c_str());
+    return nullptr;
+  }
+  return std::move(maybe_codec).ValueUnsafe();
+}
+
+template <typename T>
+static void PlainCodecEncodeImpl(benchmark::State& state, GenT<T> gen,
+                                 Compression::type codec_type) {
+  const int64_t num_values = state.range(0);
+  auto values = gen(num_values);
+  const int64_t uncompressed_size = num_values * sizeof(T);
+  const uint8_t* raw = reinterpret_cast<const uint8_t*>(values.data());
+
+  auto codec = CodecOrSkip(state, codec_type);
+  if (codec == nullptr) return;
+  int64_t max_comp = codec->MaxCompressedLen(uncompressed_size, raw);
+  std::vector<uint8_t> compressed(max_comp);
+
+  // Compute comp_size once for the counter
+  int64_t comp_size =
+      *codec->Compress(uncompressed_size, raw, max_comp, compressed.data());
+
+  for (auto _ : state) {
+    auto sz = *codec->Compress(uncompressed_size, raw, max_comp, compressed.data());
+    benchmark::DoNotOptimize(sz);
+  }
+
+  state.SetBytesProcessed(state.iterations() * uncompressed_size);
+  state.SetItemsProcessed(state.iterations() * num_values);
+  state.counters["compression_ratio"] =
+      static_cast<double>(uncompressed_size) / static_cast<double>(comp_size);
+}
+
+template <typename T>
+static void PlainCodecDecodeImpl(benchmark::State& state, GenT<T> gen,
+                                 Compression::type codec_type) {
+  const int64_t num_values = state.range(0);
+  auto values = gen(num_values);
+  const int64_t uncompressed_size = num_values * sizeof(T);
+  const uint8_t* raw = reinterpret_cast<const uint8_t*>(values.data());
+
+  auto codec = CodecOrSkip(state, codec_type);
+  if (codec == nullptr) return;
+  int64_t max_comp = codec->MaxCompressedLen(uncompressed_size, raw);
+  std::vector<uint8_t> compressed(max_comp);
+  int64_t comp_size =
+      *codec->Compress(uncompressed_size, raw, max_comp, compressed.data());
+
+  std::vector<uint8_t> decompressed(uncompressed_size);
+  for (auto _ : state) {
+    auto result = codec->Decompress(comp_size, compressed.data(), uncompressed_size,
+                                    decompressed.data());
+    ARROW_CHECK_OK(result.status());
+    benchmark::ClobberMemory();
+  }
+
+  state.SetBytesProcessed(state.iterations() * uncompressed_size);
+  state.SetItemsProcessed(state.iterations() * num_values);
+  state.counters["compression_ratio"] =
+      static_cast<double>(uncompressed_size) / static_cast<double>(comp_size);
+}
+static void BM_PlainZstdEncode(benchmark::State& state, Gen32 gen) {
+  PlainCodecEncodeImpl<int32_t>(state, gen, Compression::ZSTD);
+}
+static void BM_PlainZstd64Encode(benchmark::State& state, Gen64 gen) {
+  PlainCodecEncodeImpl<int64_t>(state, gen, Compression::ZSTD);
+}
+static void BM_PlainZstdDecode(benchmark::State& state, Gen32 gen) {
+  PlainCodecDecodeImpl<int32_t>(state, gen, Compression::ZSTD);
+}
+static void BM_PlainZstd64Decode(benchmark::State& state, Gen64 gen) {
+  PlainCodecDecodeImpl<int64_t>(state, gen, Compression::ZSTD);
+}
+
+// ----------------------------------------------------------------------
+// Plain + LZ4 Encode/Decode
+
+static void BM_PlainLz4Encode(benchmark::State& state, Gen32 gen) {
+  PlainCodecEncodeImpl<int32_t>(state, gen, Compression::LZ4_FRAME);
+}
+static void BM_PlainLz464Encode(benchmark::State& state, Gen64 gen) {
+  PlainCodecEncodeImpl<int64_t>(state, gen, Compression::LZ4_FRAME);
+}
+static void BM_PlainLz4Decode(benchmark::State& state, Gen32 gen) {
+  PlainCodecDecodeImpl<int32_t>(state, gen, Compression::LZ4_FRAME);
+}
+static void BM_PlainLz464Decode(benchmark::State& state, Gen64 gen) {
+  PlainCodecDecodeImpl<int64_t>(state, gen, Compression::LZ4_FRAME);
+}
+
+// ----------------------------------------------------------------------
+// RleBitPackHybrid Encode/Decode
+
+template <typename T>
+static void RleBitPackEncodeImpl(benchmark::State& state, GenT<T> gen) {
+  using U = std::make_unsigned_t<T>;
+  const int64_t num_values = state.range(0);
+  auto values = gen(num_values);
+  const int64_t uncompressed_size = num_values * sizeof(T);
+
+  int32_t bit_width = ComputeBitWidth<T>(values);
+  int64_t max_buf =
+      ::arrow::util::RleBitPackedEncoder::MaxBufferSize(bit_width, num_values) +
+      ::arrow::util::RleBitPackedEncoder::MinBufferSize(bit_width);
+  std::vector<uint8_t> buffer(max_buf);
+
+  // Compute comp_size once for the counter
+  int64_t comp_size;
+  {
+    ::arrow::util::RleBitPackedEncoder enc(buffer.data(), static_cast<int>(max_buf),
+                                           bit_width);
+    for (int64_t i = 0; i < num_values; ++i) {
+      enc.Put(static_cast<uint64_t>(static_cast<U>(values[i])));
+    }
+    comp_size = enc.Flush();
+  }
+
+  for (auto _ : state) {
+    ::arrow::util::RleBitPackedEncoder encoder(buffer.data(), static_cast<int>(max_buf),
+                                               bit_width);
+    for (int64_t i = 0; i < num_values; ++i) {
+      encoder.Put(static_cast<uint64_t>(static_cast<U>(values[i])));
+    }
+    auto sz = encoder.Flush();
+    benchmark::DoNotOptimize(sz);
+  }
+
+  state.SetBytesProcessed(state.iterations() * uncompressed_size);
+  state.SetItemsProcessed(state.iterations() * num_values);
+  state.counters["compression_ratio"] =
+      static_cast<double>(uncompressed_size) / static_cast<double>(comp_size);
+}
+static void BM_RleBitPackEncode(benchmark::State& state, Gen32 gen) {
+  RleBitPackEncodeImpl<int32_t>(state, gen);
+}
+static void BM_RleBitPack64Encode(benchmark::State& state, Gen64 gen) {
+  RleBitPackEncodeImpl<int64_t>(state, gen);
+}
+
+template <typename T>
+static void RleBitPackDecodeImpl(benchmark::State& state, GenT<T> gen) {
+  using U = std::make_unsigned_t<T>;
+  const int64_t num_values = state.range(0);
+  auto values = gen(num_values);
+  const int64_t uncompressed_size = num_values * sizeof(T);
+
+  int32_t bit_width = ComputeBitWidth<T>(values);
+  int64_t max_buf =
+      ::arrow::util::RleBitPackedEncoder::MaxBufferSize(bit_width, num_values) +
+      ::arrow::util::RleBitPackedEncoder::MinBufferSize(bit_width);
+  std::vector<uint8_t> buffer(max_buf);
+
+  ::arrow::util::RleBitPackedEncoder encoder(buffer.data(), static_cast<int>(max_buf),
+                                             bit_width);
+  for (int64_t i = 0; i < num_values; ++i) {
+    encoder.Put(static_cast<uint64_t>(static_cast<U>(values[i])));
+  }
+  int comp_size = encoder.Flush();
+
+  std::vector<T> decoded(num_values);
+  for (auto _ : state) {
+    ::arrow::util::RleBitPackedParser parser(buffer.data(), comp_size, bit_width);
+    int64_t out_idx = 0;
+    struct Handler {
+      T* output;
+      int64_t* idx;
+      int64_t max_values;
+      int32_t bw;
+      ::arrow::util::RleBitPackedParser::ControlFlow OnRleRun(::arrow::util::RleRun run) {
+        ::arrow::util::RleRunDecoder<T> dec(run, bw);
+        auto want = static_cast<int32_t>(
+            std::min(static_cast<int64_t>(run.values_count()), max_values - *idx));
+        auto count = dec.GetBatch(output + *idx, want, bw);
+        *idx += count;
+        return *idx >= max_values
+                   ? ::arrow::util::RleBitPackedParser::ControlFlow::Break
+                   : ::arrow::util::RleBitPackedParser::ControlFlow::Continue;
+      }
+      ::arrow::util::RleBitPackedParser::ControlFlow OnBitPackedRun(
+          ::arrow::util::BitPackedRun run) {
+        ::arrow::util::BitPackedRunDecoder<T> dec(run, bw);
+        auto want = static_cast<int32_t>(
+            std::min(static_cast<int64_t>(dec.remaining()), max_values - *idx));
+        auto count = dec.GetBatch(output + *idx, want, bw);
+        *idx += count;
+        return *idx >= max_values
+                   ? ::arrow::util::RleBitPackedParser::ControlFlow::Break
+                   : ::arrow::util::RleBitPackedParser::ControlFlow::Continue;
+      }
+    };
+    Handler handler{decoded.data(), &out_idx, num_values, bit_width};
+    parser.Parse(handler);
+    benchmark::ClobberMemory();
+  }
+
+  state.SetBytesProcessed(state.iterations() * uncompressed_size);
+  state.SetItemsProcessed(state.iterations() * num_values);
+  state.counters["compression_ratio"] =
+      static_cast<double>(uncompressed_size) / static_cast<double>(comp_size);
+}
+static void BM_RleBitPackDecode(benchmark::State& state, Gen32 gen) {
+  RleBitPackDecodeImpl<int32_t>(state, gen);
+}
+static void BM_RleBitPack64Decode(benchmark::State& state, Gen64 gen) {
+  RleBitPackDecodeImpl<int64_t>(state, gen);
+}
+
+// ----------------------------------------------------------------------
+// ByteStreamSplit + Codec (ZSTD or LZ4)
+
+template <typename T>
+static void BssCodecEncodeImpl(benchmark::State& state, GenT<T> gen,
+                               Compression::type codec_type) {
+  using PType = typename PqTraits<T>::PType;
+  const int64_t num_values = state.range(0);
+  auto values = gen(num_values);
+  const int64_t uncompressed_size = num_values * sizeof(T);
+
+  auto descr = MakeDescriptor<T>();
+  auto encoder = MakeTypedEncoder<PType>(Encoding::BYTE_STREAM_SPLIT,
+                                         /*use_dictionary=*/false, descr.get());
+  auto codec = CodecOrSkip(state, codec_type);
+  if (codec == nullptr) return;
+
+  encoder->Put(values.data(), static_cast<int>(num_values));
+  auto encoded_buf = encoder->FlushValues();
+  int64_t encoded_size = encoded_buf->size();
+
+  int64_t max_comp = codec->MaxCompressedLen(encoded_size, encoded_buf->data());
+  std::vector<uint8_t> compressed(max_comp);
+
+  // Compute comp_size once for the counter
+  int64_t comp_size =
+      *codec->Compress(encoded_size, encoded_buf->data(), max_comp, compressed.data());
+
+  for (auto _ : state) {
+    encoder->Put(values.data(), static_cast<int>(num_values));
+    auto buf = encoder->FlushValues();
+    auto sz = *codec->Compress(buf->size(), buf->data(), max_comp, compressed.data());
+    benchmark::DoNotOptimize(sz);
+  }
+
+  state.SetBytesProcessed(state.iterations() * uncompressed_size);
+  state.SetItemsProcessed(state.iterations() * num_values);
+  state.counters["compression_ratio"] =
+      static_cast<double>(uncompressed_size) / static_cast<double>(comp_size);
+}
+
+template <typename T>
+static void BssCodecDecodeImpl(benchmark::State& state, GenT<T> gen,
+                               Compression::type codec_type) {
+  using PType = typename PqTraits<T>::PType;
+  const int64_t num_values = state.range(0);
+  auto values = gen(num_values);
+  const int64_t uncompressed_size = num_values * sizeof(T);
+
+  auto descr = MakeDescriptor<T>();
+  auto encoder = MakeTypedEncoder<PType>(Encoding::BYTE_STREAM_SPLIT,
+                                         /*use_dictionary=*/false, descr.get());
+  auto codec = CodecOrSkip(state, codec_type);
+  if (codec == nullptr) return;
+
+  encoder->Put(values.data(), static_cast<int>(num_values));
+  auto encoded_buf = encoder->FlushValues();
+  int64_t encoded_size = encoded_buf->size();
+
+  int64_t max_comp = codec->MaxCompressedLen(encoded_size, encoded_buf->data());
+  std::vector<uint8_t> compressed(max_comp);
+  int64_t comp_size =
+      *codec->Compress(encoded_size, encoded_buf->data(), max_comp, compressed.data());
+
+  std::vector<uint8_t> decompressed(encoded_size);
+  std::vector<T> decoded(num_values);
+  auto decoder = MakeTypedDecoder<PType>(Encoding::BYTE_STREAM_SPLIT, descr.get());
+
+  for (auto _ : state) {
+    auto result = codec->Decompress(comp_size, compressed.data(), encoded_size,
+                                    decompressed.data());
+    ARROW_CHECK_OK(result.status());
+    decoder->SetData(static_cast<int>(num_values), decompressed.data(),
+                     static_cast<int>(encoded_size));
+    decoder->Decode(decoded.data(), static_cast<int>(num_values));
+    benchmark::ClobberMemory();
+  }
+
+  state.SetBytesProcessed(state.iterations() * uncompressed_size);
+  state.SetItemsProcessed(state.iterations() * num_values);
+  state.counters["compression_ratio"] =
+      static_cast<double>(uncompressed_size) / static_cast<double>(comp_size);
+}
+
+// Wrappers for BSS+ZSTD
+static void BM_BssZstdEncode(benchmark::State& state, Gen32 gen) {
+  BssCodecEncodeImpl<int32_t>(state, gen, Compression::ZSTD);
+}
+static void BM_BssZstd64Encode(benchmark::State& state, Gen64 gen) {
+  BssCodecEncodeImpl<int64_t>(state, gen, Compression::ZSTD);
+}
+static void BM_BssZstdDecode(benchmark::State& state, Gen32 gen) {
+  BssCodecDecodeImpl<int32_t>(state, gen, Compression::ZSTD);
+}
+static void BM_BssZstd64Decode(benchmark::State& state, Gen64 gen) {
+  BssCodecDecodeImpl<int64_t>(state, gen, Compression::ZSTD);
+}
+
+// Wrappers for BSS+LZ4
+static void BM_BssLz4Encode(benchmark::State& state, Gen32 gen) {
+  BssCodecEncodeImpl<int32_t>(state, gen, Compression::LZ4_FRAME);
+}
+static void BM_BssLz464Encode(benchmark::State& state, Gen64 gen) {
+  BssCodecEncodeImpl<int64_t>(state, gen, Compression::LZ4_FRAME);
+}
+static void BM_BssLz4Decode(benchmark::State& state, Gen32 gen) {
+  BssCodecDecodeImpl<int32_t>(state, gen, Compression::LZ4_FRAME);
+}
+static void BM_BssLz464Decode(benchmark::State& state, Gen64 gen) {
+  BssCodecDecodeImpl<int64_t>(state, gen, Compression::LZ4_FRAME);
+}
+
+// ----------------------------------------------------------------------
+// Benchmark Registration
+
+static void CustomArgs(benchmark::internal::Benchmark* b) { b->Arg(102400); }
+
+// Macro to register all algorithms for a given dataset
+#define REGISTER_DATASET(Name, GenFunc)                                        \
+  BENCHMARK_CAPTURE(BM_PforEncode, Name, &GenFunc)->Apply(CustomArgs);         \
+  BENCHMARK_CAPTURE(BM_PforDecode, Name, &GenFunc)->Apply(CustomArgs);         \
+  BENCHMARK_CAPTURE(BM_DeltaBitPackEncode, Name, &GenFunc)->Apply(CustomArgs); \
+  BENCHMARK_CAPTURE(BM_DeltaBitPackDecode, Name, &GenFunc)->Apply(CustomArgs); \
+  BENCHMARK_CAPTURE(BM_PlainZstdEncode, Name, &GenFunc)->Apply(CustomArgs);    \
+  BENCHMARK_CAPTURE(BM_PlainZstdDecode, Name, &GenFunc)->Apply(CustomArgs);    \
+  BENCHMARK_CAPTURE(BM_PlainLz4Encode, Name, &GenFunc)->Apply(CustomArgs);     \
+  BENCHMARK_CAPTURE(BM_PlainLz4Decode, Name, &GenFunc)->Apply(CustomArgs);     \
+  BENCHMARK_CAPTURE(BM_RleBitPackEncode, Name, &GenFunc)->Apply(CustomArgs);   \
+  BENCHMARK_CAPTURE(BM_RleBitPackDecode, Name, &GenFunc)->Apply(CustomArgs);   \
+  BENCHMARK_CAPTURE(BM_BssZstdEncode, Name, &GenFunc)->Apply(CustomArgs);      \
+  BENCHMARK_CAPTURE(BM_BssZstdDecode, Name, &GenFunc)->Apply(CustomArgs);      \
+  BENCHMARK_CAPTURE(BM_BssLz4Encode, Name, &GenFunc)->Apply(CustomArgs);       \
+  BENCHMARK_CAPTURE(BM_BssLz4Decode, Name, &GenFunc)->Apply(CustomArgs);
+
+// Same as REGISTER_DATASET but for int64 (BIGINT) columns; benchmark names get
+// the "64" codec suffix (e.g. BM_Pfor64Encode) to distinguish them.
+#define REGISTER_DATASET64(Name, GenFunc)                                        \
+  BENCHMARK_CAPTURE(BM_Pfor64Encode, Name, &GenFunc)->Apply(CustomArgs);         \
+  BENCHMARK_CAPTURE(BM_Pfor64Decode, Name, &GenFunc)->Apply(CustomArgs);         \
+  BENCHMARK_CAPTURE(BM_DeltaBitPack64Encode, Name, &GenFunc)->Apply(CustomArgs); \
+  BENCHMARK_CAPTURE(BM_DeltaBitPack64Decode, Name, &GenFunc)->Apply(CustomArgs); \
+  BENCHMARK_CAPTURE(BM_PlainZstd64Encode, Name, &GenFunc)->Apply(CustomArgs);    \
+  BENCHMARK_CAPTURE(BM_PlainZstd64Decode, Name, &GenFunc)->Apply(CustomArgs);    \
+  BENCHMARK_CAPTURE(BM_PlainLz464Encode, Name, &GenFunc)->Apply(CustomArgs);     \
+  BENCHMARK_CAPTURE(BM_PlainLz464Decode, Name, &GenFunc)->Apply(CustomArgs);     \
+  BENCHMARK_CAPTURE(BM_RleBitPack64Encode, Name, &GenFunc)->Apply(CustomArgs);   \
+  BENCHMARK_CAPTURE(BM_RleBitPack64Decode, Name, &GenFunc)->Apply(CustomArgs);   \
+  BENCHMARK_CAPTURE(BM_BssZstd64Encode, Name, &GenFunc)->Apply(CustomArgs);      \
+  BENCHMARK_CAPTURE(BM_BssZstd64Decode, Name, &GenFunc)->Apply(CustomArgs);      \
+  BENCHMARK_CAPTURE(BM_BssLz464Encode, Name, &GenFunc)->Apply(CustomArgs);       \
+  BENCHMARK_CAPTURE(BM_BssLz464Decode, Name, &GenFunc)->Apply(CustomArgs);
+
+// ClickBench datasets
+REGISTER_DATASET(ClientIP, GenClientIP)
+REGISTER_DATASET(UrlRegionID, GenUrlRegionID)
+REGISTER_DATASET(CounterID, GenCounterID)
+REGISTER_DATASET(EventDate, GenEventDate)
+REGISTER_DATASET(EventTime, GenEventTime)
+REGISTER_DATASET(GoodEvent, GenGoodEvent)
+REGISTER_DATASET(HID, GenHID)
+REGISTER_DATASET(HitColor, GenHitColor)
+REGISTER_DATASET(IPNetworkID, GenIPNetworkID)
+REGISTER_DATASET(JavaEnable, GenJavaEnable)
+REGISTER_DATASET(OS, GenOS)
+REGISTER_DATASET(Resolution, GenResolution)
+REGISTER_DATASET(TrafficSourceID, GenTrafficSourceID)
+REGISTER_DATASET(UserAgent, GenUserAgent)
+
+// TPC-DS datasets
+REGISTER_DATASET(TpcdsSoldDateSk, GenTpcdsSoldDateSk)
+REGISTER_DATASET(TpcdsStoreSk, GenTpcdsStoreSk)
+REGISTER_DATASET(TpcdsItemSk, GenTpcdsItemSk)
+REGISTER_DATASET(TpcdsQuantity, GenTpcdsQuantity)
+REGISTER_DATASET(TpcdsCustomerSk, GenTpcdsCustomerSk)
+REGISTER_DATASET(TpcdsExtSalesPrice, GenTpcdsExtSalesPrice)
+REGISTER_DATASET(TpcdsNetProfit, GenTpcdsNetProfit)
+REGISTER_DATASET(TpcdsDYear, GenTpcdsDYear)
+// TPC-H datasets
+REGISTER_DATASET(TpchLQuantity, GenTpchLQuantity)
+REGISTER_DATASET(TpchLExtendedPrice, GenTpchLExtendedPrice)
+REGISTER_DATASET(TpchLDiscount, GenTpchLDiscount)
+REGISTER_DATASET(TpchLShipDate, GenTpchLShipDate)
+// NYC taxi datasets
+REGISTER_DATASET(TaxiPickupUnixTime, GenTaxiPickupUnixTime)
+REGISTER_DATASET(TaxiTripDistanceX100, GenTaxiTripDistanceX100)
+REGISTER_DATASET(TaxiFareCents, GenTaxiFareCents)
+// int64 / BIGINT datasets (8-byte signed values)
+REGISTER_DATASET64(TsNanos, GenTsNanos)
+REGISTER_DATASET64(OrderKey, GenOrderKey)
+REGISTER_DATASET64(PriceMicros, GenPriceMicros)
+REGISTER_DATASET64(SnowflakeId, GenSnowflakeId)
+REGISTER_DATASET64(ByteCount, GenByteCount)
+
+}  // namespace
+}  // namespace parquet

From 706d5491976390cd6cd280b7f6586beb50d63bab Mon Sep 17 00:00:00 2001
From: Prateek Gaur <prateek.gaur@snowflake.com>
Date: Sat, 3 Oct 2026 20:48:15 +0000
Subject: [PATCH 05/27] Export PFOR templates from the Arrow library

The PFOR templates are instantiated in libarrow and used from libparquet
and its tests. Without export markers this only links on ELF platforms,
where symbols are visible by default.
---
 cpp/src/arrow/util/pfor/pfor_internal.h         | 3 ++-
 cpp/src/arrow/util/pfor/pfor_wrapper_internal.h | 3 ++-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/cpp/src/arrow/util/pfor/pfor_internal.h b/cpp/src/arrow/util/pfor/pfor_internal.h
index e766f144813f..b8c9ae63a45a 100644
--- a/cpp/src/arrow/util/pfor/pfor_internal.h
+++ b/cpp/src/arrow/util/pfor/pfor_internal.h
@@ -35,6 +35,7 @@
 #include "arrow/util/endian.h"
 #include "arrow/util/pfor/pfor_constants_internal.h"
 #include "arrow/util/ubsan.h"
+#include "arrow/util/visibility.h"
 
 namespace arrow {
 namespace util {
@@ -185,7 +186,7 @@ struct BitWidthResult {
 ///
 /// \tparam T the integer type (int32_t or int64_t)
 template <typename T>
-class PforCompression {
+class ARROW_EXPORT PforCompression {
  public:
   using UnsignedT = typename PforTypeTraits<T>::UnsignedType;
 
diff --git a/cpp/src/arrow/util/pfor/pfor_wrapper_internal.h b/cpp/src/arrow/util/pfor/pfor_wrapper_internal.h
index b438df1c7f35..02a422e3b62e 100644
--- a/cpp/src/arrow/util/pfor/pfor_wrapper_internal.h
+++ b/cpp/src/arrow/util/pfor/pfor_wrapper_internal.h
@@ -28,6 +28,7 @@
 #include "arrow/result.h"
 #include "arrow/status.h"
 #include "arrow/util/pfor/pfor_internal.h"
+#include "arrow/util/visibility.h"
 
 namespace arrow {
 namespace util {
@@ -57,7 +58,7 @@ namespace pfor {
 ///
 /// \tparam T the integer type (int32_t or int64_t)
 template <typename T>
-class PforWrapper {
+class ARROW_EXPORT PforWrapper {
  public:
   /// A validated view of one encoded page.  It keeps no decoded values and can
   /// therefore serve arbitrary vectors without materializing the whole page.

From fe3d6cabe796df4f063d4536e30fdaa638460e81 Mon Sep 17 00:00:00 2001
From: Prateek Gaur <prateek.gaur@snowflake.com>
Date: Sat, 3 Oct 2026 20:48:15 +0000
Subject: [PATCH 06/27] Document PFOR encoding selection

Lists the supported integer types and the Preview status. Writers never
pick PFOR on their own; a column has to ask for it.
---
 docs/source/cpp/parquet.rst | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/docs/source/cpp/parquet.rst b/docs/source/cpp/parquet.rst
index 1aace68626c9..a6ef43f2c24e 100644
--- a/docs/source/cpp/parquet.rst
+++ b/docs/source/cpp/parquet.rst
@@ -407,6 +407,8 @@ Encodings
 +--------------------------+----------+----------+---------+
 | DELTA_LENGTH_BYTE_ARRAY  | ✓        | ✓        |         |
 +--------------------------+----------+----------+---------+
+| PFOR                     | ✓        | ✓        | \(3)    |
++--------------------------+----------+----------+---------+
 
 * \(1) Only supported for encoding definition and repetition levels,
   and boolean values.
@@ -414,6 +416,10 @@ Encodings
 * \(2) On the write path, RLE_DICTIONARY is only enabled if Parquet format version
   2.4 or greater is selected in :func:`WriterProperties::version`.
 
+* \(3) Only supported for INT32 and INT64 values. PFOR is a Preview feature in
+  the Parquet format, so other readers may not support it. It is never selected
+  automatically: a column uses PFOR only where ``encoding()`` names it.
+
 Types
 -----
 

From c07a099428397491817e048711cc78a4e73d1dfd Mon Sep 17 00:00:00 2001
From: Prateek Gaur <prateek.gaur@snowflake.com>
Date: Tue, 1 Sep 2026 18:11:44 +0000
Subject: [PATCH 07/27] Add PFOR delta planning and searchable frames

Some columns pack far better as differences between neighbors than as
raw values, so the planner now costs both per vector and keeps the
cheaper one. The frame no longer has to be the minimum either. A
histogram pass finds a window that leaves outliers on both sides as
exceptions, and the frame then moves down to the smallest value the
window covers. If the search does not beat the minimum-frame plan, that
plan is kept.
---
 cpp/src/arrow/util/pfor/pfor.cc              | 204 ++++----
 cpp/src/arrow/util/pfor/pfor_benchmark.cc    | 244 ++++++++++
 cpp/src/arrow/util/pfor/pfor_internal.h      |  64 ++-
 cpp/src/arrow/util/pfor/pfor_plan_internal.h | 481 +++++++++++++++++++
 cpp/src/arrow/util/pfor/pfor_test.cc         | 293 ++++++++++-
 cpp/src/arrow/util/pfor/pfor_wrapper.cc      |  15 +-
 6 files changed, 1177 insertions(+), 124 deletions(-)
 create mode 100644 cpp/src/arrow/util/pfor/pfor_plan_internal.h

diff --git a/cpp/src/arrow/util/pfor/pfor.cc b/cpp/src/arrow/util/pfor/pfor.cc
index 708515f3e48b..f66eb3106575 100644
--- a/cpp/src/arrow/util/pfor/pfor.cc
+++ b/cpp/src/arrow/util/pfor/pfor.cc
@@ -65,63 +65,15 @@ void StoreLittleEndianArray(const T* values, int64_t num_values, uint8_t* output
 }  // namespace
 
 // ----------------------------------------------------------------------
-// FindOptimalBitWidth: histogram-based cost model
+// FindOptimalBitWidth
 
 template <typename T>
 BitWidthResult PforCompression<T>::FindOptimalBitWidth(const UnsignedT* deltas,
                                                        int32_t num_elements) {
-  constexpr uint8_t max_bits = PforTypeTraits<T>::kMaxBitWidth;
-  constexpr int32_t position_bits =
-      static_cast<int32_t>(sizeof(PforConstants::PositionType)) * 8;
-  constexpr int32_t value_bits = sizeof(T) * 8;
-
-  // Build histogram: histogram[b] = count of deltas requiring exactly b bits.
-  // Use 4 independent accumulators so the read-modify-write doesn't serialize
-  // on repeated bins and the four load->clz->bump chains overlap (this loop is
-  // ~half of encode time; a single histogram array runs scalar and stalls).
-  std::array<int32_t, 65> h0{}, h1{}, h2{}, h3{};
-  int32_t i = 0;
-  for (; i + 4 <= num_elements; i += 4) {
-    ++h0[PforTypeTraits<T>::BitsRequired(deltas[i])];
-    ++h1[PforTypeTraits<T>::BitsRequired(deltas[i + 1])];
-    ++h2[PforTypeTraits<T>::BitsRequired(deltas[i + 2])];
-    ++h3[PforTypeTraits<T>::BitsRequired(deltas[i + 3])];
-  }
-  for (; i < num_elements; ++i) ++h0[PforTypeTraits<T>::BitsRequired(deltas[i])];
   std::array<int32_t, 65> histogram{};
-  for (int b = 0; b <= 64; ++b) histogram[b] = h0[b] + h1[b] + h2[b] + h3[b];
-
-  // Evaluate each candidate bit width
-  int64_t best_cost = std::numeric_limits<int64_t>::max();
-  uint8_t best_bit_width = max_bits;
-  PforConstants::ExceptionCountType best_num_exceptions = 0;
-
-  int64_t exceptions_above = num_elements;
-
-  for (uint8_t b = 0; b <= max_bits; ++b) {
-    exceptions_above -= histogram[b];
-
-    // A vector holds at most kMaxVectorSize elements, so that is also the most
-    // exceptions one can name. Skipping the wider counts keeps the cast below
-    // exact; the full-width candidate has none at all, so a best is always
-    // found.
-    if (exceptions_above > PforConstants::kMaxVectorSize) {
-      continue;
-    }
-
-    int64_t packing_cost = static_cast<int64_t>(num_elements) * b;
-    int64_t exception_cost = exceptions_above * (position_bits + value_bits);
-    int64_t total_cost = packing_cost + exception_cost;
-
-    if (total_cost < best_cost) {
-      best_cost = total_cost;
-      best_bit_width = b;
-      best_num_exceptions =
-          static_cast<PforConstants::ExceptionCountType>(exceptions_above);
-    }
-  }
-
-  return {best_bit_width, best_num_exceptions};
+  BuildOffsetHistogram<T>(deltas, num_elements, &histogram);
+  int64_t cost_bits = 0;
+  return BestWidthFromHistogram<T>(histogram, num_elements, &cost_bits);
 }
 
 // ----------------------------------------------------------------------
@@ -132,53 +84,68 @@ PforEncodedVector<T> PforCompression<T>::EncodeVector(const T* values,
                                                       int32_t num_elements) {
   ARROW_DCHECK(num_elements > 0);
 
-  // Step 1: Find min (frame of reference)
-  T min_val = values[0];
-  for (int32_t i = 1; i < num_elements; ++i) {
-    if (values[i] < min_val) min_val = values[i];
-  }
-
-  // Step 2: Compute unsigned deltas. Use a stack scratch for the common
-  // (<=vector-size) case to avoid a per-vector heap alloc + zero-init.
-  const auto unsigned_min = static_cast<UnsignedT>(min_val);
+  // One scratch buffer serves both stages. ChooseVectorPlan fills it with the
+  // differences, and if the plan takes them it is also the source the offsets
+  // are computed from -- read at index i, written at index i, so the offsets
+  // can go back into the same storage. A stack buffer for the common
+  // (<=vector-size) case avoids a per-vector heap alloc and zero-init.
   constexpr int32_t kFull = static_cast<int32_t>(PforConstants::kPforVectorSize);
-  UnsignedT stack_deltas[kFull];
-  std::vector<UnsignedT> heap_deltas;
-  UnsignedT* deltas = stack_deltas;
+  T stack_scratch[kFull];
+  std::vector<T> heap_scratch;
+  T* scratch = stack_scratch;
   if (num_elements > kFull) {
-    heap_deltas.resize(num_elements);
-    deltas = heap_deltas.data();
-  }
-  for (int32_t i = 0; i < num_elements; ++i) {
-    deltas[i] = static_cast<UnsignedT>(values[i]) - unsigned_min;
+    heap_scratch.resize(num_elements);
+    scratch = heap_scratch.data();
   }
 
-  // Step 3: Find optimal bit width
-  auto [bit_width, num_exceptions] = FindOptimalBitWidth(deltas, num_elements);
+  const PforVectorPlan<T> plan = ChooseVectorPlan<T>(values, num_elements, scratch);
+  const T* source = plan.delta ? scratch : values;
 
-  // Step 4: Collect exceptions and replace with placeholder (0)
   PforEncodedVector<T> result;
-  result.set_info(PforVectorInfo<T>(min_val, bit_width, num_exceptions));
-
-  if (num_exceptions > 0) {
-    result.mutable_exception_positions().reserve(num_exceptions);
-    result.mutable_exception_values().reserve(num_exceptions);
-
-    UnsignedT mask = (bit_width >= PforTypeTraits<T>::kMaxBitWidth)
-                         ? static_cast<UnsignedT>(-1)
-                         : (static_cast<UnsignedT>(1) << bit_width) - 1;
+  result.set_info(PforVectorInfo<T>(plan.frame_of_reference, plan.bit_width,
+                                    plan.num_exceptions, plan.delta));
+  result.set_start_value(plan.start_value);
+
+  // Step 1: reduce by the frame, collecting whatever will not fit.
+  //
+  // The comparison is against the packed mask in the unsigned domain, which is
+  // what lets the frame sit above the minimum: a source value below the frame
+  // wraps to a huge offset, fails the same test as one above the window, and is
+  // patched from the exception list like any other. No second test, no sign.
+  auto* offsets = reinterpret_cast<UnsignedT*>(scratch);
+  const auto unsigned_frame = static_cast<UnsignedT>(plan.frame_of_reference);
+  const uint8_t bit_width = plan.bit_width;
+
+  if (plan.num_exceptions > 0) {
+    result.mutable_exception_positions().reserve(plan.num_exceptions);
+    result.mutable_exception_values().reserve(plan.num_exceptions);
+
+    const UnsignedT mask = (bit_width >= PforTypeTraits<T>::kMaxBitWidth)
+                               ? static_cast<UnsignedT>(-1)
+                               : (static_cast<UnsignedT>(1) << bit_width) - 1;
 
     for (int32_t i = 0; i < num_elements; ++i) {
-      if (deltas[i] > mask) {
+      const T value = source[i];
+      UnsignedT offset = static_cast<UnsignedT>(value) - unsigned_frame;
+      if (offset > mask) {
         result.mutable_exception_positions().push_back(
             static_cast<PforConstants::PositionType>(i));
-        result.mutable_exception_values().push_back(values[i]);
-        deltas[i] = 0;
+        // The exception carries whatever the packed stream carries: a value in
+        // a plain vector, a difference in a delta vector. The decoder patches
+        // it in before the running sum, so a patched difference is summed like
+        // any other.
+        result.mutable_exception_values().push_back(value);
+        offset = 0;
       }
+      offsets[i] = offset;
+    }
+  } else {
+    for (int32_t i = 0; i < num_elements; ++i) {
+      offsets[i] = static_cast<UnsignedT>(source[i]) - unsigned_frame;
     }
   }
 
-  // Step 5: Bit-pack the deltas
+  // Step 2: bit-pack the offsets
   if (bit_width > 0) {
     int64_t packed_size =
         bit_util::BytesForBits(static_cast<int64_t>(num_elements) * bit_width);
@@ -187,7 +154,7 @@ PforEncodedVector<T> PforCompression<T>::EncodeVector(const T* values,
     bit_util::BitWriter writer(result.mutable_packed_values().data(),
                                static_cast<int>(packed_size));
     for (int32_t i = 0; i < num_elements; ++i) {
-      writer.PutValue(static_cast<uint64_t>(deltas[i]), bit_width);
+      writer.PutValue(static_cast<uint64_t>(offsets[i]), bit_width);
     }
     writer.Flush();
   }
@@ -203,8 +170,21 @@ Result<int64_t> PforCompression<T>::DecodeVector(std::span<const uint8_t> data,
                                                  int32_t num_elements, T* values) {
   // Step 1: Read vector info
   ARROW_ASSIGN_OR_RAISE(auto info, PforVectorInfo<T>::Load(data));
+  const int64_t info_bytes = info.stored_bytes();
+  if (info_bytes > static_cast<int64_t>(data.size())) {
+    return Status::Invalid("PFOR delta vector needs ", info_bytes,
+                           " bytes of metadata but only ", data.size(), " remain");
+  }
   const uint8_t* read_ptr = data.data() + PforVectorInfo<T>::kStoredSize;
 
+  // A delta vector stores its own first value, which is what lets it decode
+  // without the vector before it -- the property the whole mode exists for.
+  T start_value = 0;
+  if (info.is_delta()) {
+    start_value = util::SafeLoadAs<T>(read_ptr);
+    read_ptr += sizeof(T);
+  }
+
   // `values` holds num_elements slots, and everything below is sized by fields
   // that came off the wire, so check them against it before reading or writing.
   if (info.num_exceptions() > num_elements) {
@@ -216,18 +196,29 @@ Result<int64_t> PforCompression<T>::DecodeVector(std::span<const uint8_t> data,
   const int64_t exception_bytes =
       info.num_exceptions() *
       (static_cast<int64_t>(sizeof(PforConstants::PositionType)) + sizeof(T));
-  if (PforVectorInfo<T>::kStoredSize + packed_bytes + exception_bytes >
-      static_cast<int64_t>(data.size())) {
-    return Status::Invalid(
-        "PFOR vector needs ",
-        PforVectorInfo<T>::kStoredSize + packed_bytes + exception_bytes,
-        " bytes but only ", data.size(), " remain");
+  if (info_bytes + packed_bytes + exception_bytes > static_cast<int64_t>(data.size())) {
+    return Status::Invalid("PFOR vector needs ",
+                           info_bytes + packed_bytes + exception_bytes,
+                           " bytes but only ", data.size(), " remain");
   }
 
   // Step 2: Handle constant data (bit_width == 0, no exceptions)
   if (info.bit_width() == 0 && info.num_exceptions() == 0) {
-    std::fill(values, values + num_elements, info.frame_of_reference());
-    return PforVectorInfo<T>::kStoredSize;
+    if (info.is_delta()) {
+      // Every difference is the frame, so the values step by it from the start
+      // value. Slot 0 always holds a difference of zero (see ComputeDeltas), so
+      // a frame other than zero cannot occur here, but the running sum below
+      // reconstructs the sequence either way rather than assuming it.
+      const auto step = static_cast<UnsignedT>(info.frame_of_reference());
+      auto acc = static_cast<UnsignedT>(start_value);
+      for (int32_t i = 0; i < num_elements; ++i) {
+        if (i > 0) acc += step;
+        std::memcpy(&values[i], &acc, sizeof(T));
+      }
+    } else {
+      std::fill(values, values + num_elements, info.frame_of_reference());
+    }
+    return info_bytes;
   }
 
   // Step 3: Unpack bit-packed deltas and add FOR
@@ -309,6 +300,23 @@ Result<int64_t> PforCompression<T>::DecodeVector(std::span<const uint8_t> data,
     }
   }
 
+  // Step 5: In a delta vector, everything above produced differences. Sum them.
+  //
+  // This has to come after the patch: an exception in a delta vector is a
+  // difference too, and summing before patching would carry the placeholder
+  // zero into every value that follows.
+  //
+  // The sum runs in the unsigned type. Signed overflow is undefined, and a
+  // column that spans the type's range will overflow -- the encoder took the
+  // differences the same way, so the bits round-trip exactly.
+  if (info.is_delta()) {
+    auto acc = static_cast<UnsignedT>(start_value);
+    for (int32_t i = 0; i < num_elements; ++i) {
+      acc += static_cast<UnsignedT>(values[i]);
+      std::memcpy(&values[i], &acc, sizeof(T));
+    }
+  }
+
   return static_cast<int64_t>(read_ptr - data.data());
 }
 
@@ -318,7 +326,7 @@ Result<int64_t> PforCompression<T>::DecodeVector(std::span<const uint8_t> data,
 template <typename T>
 int64_t PforCompression<T>::SerializedVectorSize(const PforEncodedVector<T>& vec,
                                                  int32_t num_elements) {
-  int64_t size = PforVectorInfo<T>::kStoredSize;
+  int64_t size = vec.info().stored_bytes();
   if (vec.info().bit_width() > 0) {
     size += bit_util::BytesForBits(static_cast<int64_t>(num_elements) *
                                    vec.info().bit_width());
@@ -366,6 +374,12 @@ Result<int64_t> PforCompression<T>::SerializeVector(const PforEncodedVector<T>&
   vec.info().Store(std::span<uint8_t>(write_ptr, PforVectorInfo<T>::kStoredSize));
   write_ptr += PforVectorInfo<T>::kStoredSize;
 
+  // Write the start value of a delta vector
+  if (vec.info().is_delta()) {
+    util::SafeStore(write_ptr, vec.start_value());
+    write_ptr += sizeof(T);
+  }
+
   // Write packed values
   if (vec.info().bit_width() > 0) {
     std::memcpy(write_ptr, vec.packed_values().data(), vec.packed_values().size());
diff --git a/cpp/src/arrow/util/pfor/pfor_benchmark.cc b/cpp/src/arrow/util/pfor/pfor_benchmark.cc
index 127965e0210d..ae878dab2036 100644
--- a/cpp/src/arrow/util/pfor/pfor_benchmark.cc
+++ b/cpp/src/arrow/util/pfor/pfor_benchmark.cc
@@ -26,6 +26,17 @@
 //   - WithOutliers: tests exception handling path
 //   - Random: worst case, full bit-width
 //   - TPC-DS DateSk/StoreSk/ItemSk/Quantity: realistic surrogate key distributions
+//
+// A second group covers columns with structure between neighbouring values, or
+// with a cluster the minimum is not part of. These are what separate a plan
+// that differences the values from one that packs them, and a frame of
+// reference placed by a search from one pinned to the minimum:
+//   - TrendJitter/EventMillis: timestamps, regular and bursty
+//   - Sawtooth: a climb cut by a halving, the case for patching both sides
+//   - MeasurementSeries/RandomWalk: bounded rate of change, no trend
+//   - SortedKeys/IdsWithGaps: monotonic, with and without jumps
+//   - SensorDropouts/LowSentinel: a low sentinel below the cluster
+//   - Bimodal: two clusters, so no one window covers the vector
 
 #include <algorithm>
 #include <cmath>
@@ -151,6 +162,163 @@ std::vector<T> GenTpcdsQuantity(int64_t n) {
   return v;
 }
 
+// ----------------------------------------------------------------------
+// Distributions with structure between neighbouring values, or with a
+// cluster the minimum is not part of. The generators above are all either
+// unordered or perfectly regular, so none of them separates a plan that
+// differences from one that does not, and none of them puts the frame of
+// reference anywhere but the minimum.
+
+/// A timestamp column with a fixed sampling interval and jitter: the
+/// differences cluster tightly around the interval, the values do not.
+template <typename T>
+std::vector<T> GenTrendJitter(int64_t n) {
+  std::vector<T> v(n);
+  std::mt19937_64 rng(7);
+  std::normal_distribution<double> jitter(0.0, 40.0);
+  double t = 1704067200.0;
+  for (auto& x : v) {
+    t += 3.0;
+    x = static_cast<T>(t + jitter(rng));
+  }
+  return v;
+}
+
+/// A TCP congestion window: a linear climb cut by a sharp halving. Almost
+/// every difference is the same small number and a few are large and
+/// negative, which is the shape a two-sided frame plus patching handles at
+/// close to no cost and a one-sided one cannot.
+template <typename T>
+std::vector<T> GenSawtooth(int64_t n) {
+  std::vector<T> v(n);
+  T cur = 1000;
+  for (int64_t i = 0; i < n; ++i) {
+    if (i % 200 == 199) {
+      cur /= 2;
+    } else {
+      cur += 12;
+    }
+    v[i] = cur;
+  }
+  return v;
+}
+
+/// A continuous quantity sampled over time, so the rate of change is bounded
+/// but the level wanders: differencing wins, though not by much.
+template <typename T>
+std::vector<T> GenMeasurement(int64_t n) {
+  std::vector<T> v(n);
+  std::mt19937_64 rng(11);
+  std::normal_distribution<double> noise(0.0, 1.0);
+  double level = 0.0;
+  double rate = 0.0;
+  for (int64_t i = 0; i < n; ++i) {
+    rate = 0.95 * rate + noise(rng);
+    level += rate;
+    v[i] = static_cast<T>(4000.0 * level / 50.0) + static_cast<T>(500000);
+  }
+  return v;
+}
+
+/// A sorted surrogate key column, which is what a clustered index or a
+/// sorted-by-key file produces.
+template <typename T>
+std::vector<T> GenSortedKeys(int64_t n) {
+  auto v = GenTpcdsItemSk<T>(n);
+  std::sort(v.begin(), v.end());
+  return v;
+}
+
+/// A measurement series punctuated by a low sentinel standing in for "no
+/// reading". The sentinel sits far below the cluster, so a frame pinned to
+/// the minimum has to widen to reach it and no value can ever be patched.
+template <typename T>
+std::vector<T> GenSensorDropouts(int64_t n) {
+  auto v = GenMeasurement<T>(n);
+  std::mt19937_64 rng(3);
+  std::uniform_int_distribution<int64_t> pos(0, n - 1);
+  for (int64_t i = 0; i < std::max<int64_t>(1, n / 200); ++i) {
+    v[pos(rng)] = static_cast<T>(-999999);
+  }
+  return v;
+}
+
+/// Monotonic ids with occasional large jumps, as a sequence shared between
+/// writers or restarted produces.
+template <typename T>
+std::vector<T> GenIdsWithGaps(int64_t n) {
+  std::vector<T> v(n);
+  std::mt19937_64 rng(5);
+  std::uniform_int_distribution<int> step(1, 6);
+  std::uniform_int_distribution<int> jump(0, 199);
+  T cur = 1000000;
+  for (auto& x : v) {
+    cur += static_cast<T>(step(rng));
+    if (jump(rng) == 0) cur += 100000;
+    x = cur;
+  }
+  return v;
+}
+
+/// Prices on a random walk: small signed steps around a high base, and no
+/// trend for the differences to line up on.
+template <typename T>
+std::vector<T> GenRandomWalk(int64_t n) {
+  std::vector<T> v(n);
+  std::mt19937_64 rng(13);
+  std::uniform_int_distribution<int> step(-25, 25);
+  T cur = 1500000;
+  for (auto& x : v) {
+    cur += static_cast<T>(step(rng));
+    x = cur;
+  }
+  return v;
+}
+
+/// Event arrival times in milliseconds since the epoch, bursty, so the gaps
+/// are skewed rather than clustered.
+template <typename T>
+std::vector<T> GenEventMillis(int64_t n) {
+  std::vector<T> v(n);
+  std::mt19937_64 rng(17);
+  std::exponential_distribution<double> gap(0.4);
+  double t = 1704067200.0;
+  for (auto& x : v) {
+    t += gap(rng);
+    x = static_cast<T>(t);
+  }
+  return v;
+}
+
+/// A tight unordered cluster with a low "missing" sentinel: the frame cannot
+/// sit at the minimum and differencing has nothing to exploit either, so
+/// this is the column that has to come out no worse than before.
+template <typename T>
+std::vector<T> GenLowSentinel(int64_t n) {
+  auto v = GenSmallRange<T>(n);
+  std::mt19937_64 rng(23);
+  std::uniform_int_distribution<int64_t> pos(0, n - 1);
+  for (int64_t i = 0; i < std::max<int64_t>(1, n / 200); ++i) {
+    v[pos(rng)] = static_cast<T>(-1000);
+  }
+  return v;
+}
+
+/// Two interleaved clusters far apart, so no single window covers the vector
+/// and the cheaper cluster is worth framing on its own.
+template <typename T>
+std::vector<T> GenBimodal(int64_t n) {
+  std::vector<T> v(n);
+  std::mt19937_64 rng(19);
+  std::uniform_int_distribution<T> lo(1000, 1100);
+  std::uniform_int_distribution<T> hi(900000, 900100);
+  std::uniform_int_distribution<int> pick(0, 9);
+  for (auto& x : v) {
+    x = pick(rng) < 8 ? lo(rng) : hi(rng);
+  }
+  return v;
+}
+
 // ----------------------------------------------------------------------
 // Benchmark Core
 
@@ -256,6 +424,25 @@ BENCHMARK_CAPTURE(BM_PforEncodeInt32, TpcdsItemSk, &GenTpcdsItemSk<int32_t>)
 BENCHMARK_CAPTURE(BM_PforEncodeInt32, TpcdsQuantity, &GenTpcdsQuantity<int32_t>)
     ->Apply(CustomArgs);
 
+BENCHMARK_CAPTURE(BM_PforEncodeInt32, TrendJitter, &GenTrendJitter<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt32, Sawtooth, &GenSawtooth<int32_t>)->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt32, MeasurementSeries, &GenMeasurement<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt32, SortedKeys, &GenSortedKeys<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt32, SensorDropouts, &GenSensorDropouts<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt32, IdsWithGaps, &GenIdsWithGaps<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt32, RandomWalk, &GenRandomWalk<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt32, EventMillis, &GenEventMillis<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt32, LowSentinel, &GenLowSentinel<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt32, Bimodal, &GenBimodal<int32_t>)->Apply(CustomArgs);
+
 // INT32 Decode
 
 BENCHMARK_CAPTURE(BM_PforDecodeInt32, Constant, &GenConstant<int32_t>)->Apply(CustomArgs);
@@ -277,6 +464,25 @@ BENCHMARK_CAPTURE(BM_PforDecodeInt32, TpcdsItemSk, &GenTpcdsItemSk<int32_t>)
 BENCHMARK_CAPTURE(BM_PforDecodeInt32, TpcdsQuantity, &GenTpcdsQuantity<int32_t>)
     ->Apply(CustomArgs);
 
+BENCHMARK_CAPTURE(BM_PforDecodeInt32, TrendJitter, &GenTrendJitter<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt32, Sawtooth, &GenSawtooth<int32_t>)->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt32, MeasurementSeries, &GenMeasurement<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt32, SortedKeys, &GenSortedKeys<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt32, SensorDropouts, &GenSensorDropouts<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt32, IdsWithGaps, &GenIdsWithGaps<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt32, RandomWalk, &GenRandomWalk<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt32, EventMillis, &GenEventMillis<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt32, LowSentinel, &GenLowSentinel<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt32, Bimodal, &GenBimodal<int32_t>)->Apply(CustomArgs);
+
 // ----------------------------------------------------------------------
 // INT64 Encode
 
@@ -293,6 +499,25 @@ BENCHMARK_CAPTURE(BM_PforEncodeInt64, Random, &GenRandom<int64_t>)->Apply(Custom
 BENCHMARK_CAPTURE(BM_PforEncodeInt64, TpcdsSoldDateSk, &GenTpcdsSoldDateSk<int64_t>)
     ->Apply(CustomArgs);
 
+BENCHMARK_CAPTURE(BM_PforEncodeInt64, TrendJitter, &GenTrendJitter<int64_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt64, Sawtooth, &GenSawtooth<int64_t>)->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt64, MeasurementSeries, &GenMeasurement<int64_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt64, SortedKeys, &GenSortedKeys<int64_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt64, SensorDropouts, &GenSensorDropouts<int64_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt64, IdsWithGaps, &GenIdsWithGaps<int64_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt64, RandomWalk, &GenRandomWalk<int64_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt64, EventMillis, &GenEventMillis<int64_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt64, LowSentinel, &GenLowSentinel<int64_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt64, Bimodal, &GenBimodal<int64_t>)->Apply(CustomArgs);
+
 // INT64 Decode
 
 BENCHMARK_CAPTURE(BM_PforDecodeInt64, Constant, &GenConstant<int64_t>)->Apply(CustomArgs);
@@ -308,5 +533,24 @@ BENCHMARK_CAPTURE(BM_PforDecodeInt64, Random, &GenRandom<int64_t>)->Apply(Custom
 BENCHMARK_CAPTURE(BM_PforDecodeInt64, TpcdsSoldDateSk, &GenTpcdsSoldDateSk<int64_t>)
     ->Apply(CustomArgs);
 
+BENCHMARK_CAPTURE(BM_PforDecodeInt64, TrendJitter, &GenTrendJitter<int64_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt64, Sawtooth, &GenSawtooth<int64_t>)->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt64, MeasurementSeries, &GenMeasurement<int64_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt64, SortedKeys, &GenSortedKeys<int64_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt64, SensorDropouts, &GenSensorDropouts<int64_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt64, IdsWithGaps, &GenIdsWithGaps<int64_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt64, RandomWalk, &GenRandomWalk<int64_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt64, EventMillis, &GenEventMillis<int64_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt64, LowSentinel, &GenLowSentinel<int64_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt64, Bimodal, &GenBimodal<int64_t>)->Apply(CustomArgs);
+
 }  // namespace
 }  // namespace arrow::util::pfor
diff --git a/cpp/src/arrow/util/pfor/pfor_internal.h b/cpp/src/arrow/util/pfor/pfor_internal.h
index b8c9ae63a45a..af7dd9168a80 100644
--- a/cpp/src/arrow/util/pfor/pfor_internal.h
+++ b/cpp/src/arrow/util/pfor/pfor_internal.h
@@ -34,6 +34,7 @@
 #include "arrow/status.h"
 #include "arrow/util/endian.h"
 #include "arrow/util/pfor/pfor_constants_internal.h"
+#include "arrow/util/pfor/pfor_plan_internal.h"
 #include "arrow/util/ubsan.h"
 #include "arrow/util/visibility.h"
 
@@ -53,9 +54,15 @@ namespace pfor {
 /// so the count has to reach 32768, which a signed 16-bit field cannot hold.
 /// Its wire type is PforConstants::ExceptionCountType.
 ///
-/// The bit_width byte stores the actual bit width in bits 0..6; bit 7 is
-/// reserved (always written as 0 and ignored on load), leaving room for a
-/// future flag without changing the layout of existing buffers.
+/// The bit_width byte stores the actual bit width in bits 0..6 and the delta
+/// flag in bit 7. A vector with the flag set packs the backward differences of
+/// its values rather than the values, and carries one extra full-width field
+/// after this info block -- the vector's first value -- so that it still
+/// decodes without reading the vector before it.
+///
+/// The flag is deliberately a bit of its own rather than another code in a
+/// mode field: differencing is orthogonal to how the payload is laid out, so
+/// the two have to be able to combine.
 ///
 /// Seven bits, not six: the range is 0..64 inclusive, and 64 does not fit in
 /// six. A 6-bit mask stored an INT64 vector whose deltas need the full 64 bits
@@ -66,17 +73,20 @@ template <typename T>
 class PforVectorInfo {
  public:
   static constexpr uint8_t kBitWidthMask = 0x7F;
+  static constexpr uint8_t kDeltaFlag = 0x80;
 
   PforVectorInfo() = default;
   PforVectorInfo(T frame_of_reference, uint8_t bit_width,
-                 PforConstants::ExceptionCountType num_exceptions)
+                 PforConstants::ExceptionCountType num_exceptions, bool is_delta = false)
       : frame_of_reference_(frame_of_reference),
         bit_width_(bit_width),
-        num_exceptions_(num_exceptions) {}
+        num_exceptions_(num_exceptions),
+        is_delta_(is_delta) {}
 
   T frame_of_reference() const { return frame_of_reference_; }
   uint8_t bit_width() const { return bit_width_; }
   PforConstants::ExceptionCountType num_exceptions() const { return num_exceptions_; }
+  bool is_delta() const { return is_delta_; }
 
   void set_frame_of_reference(T frame_of_reference) {
     frame_of_reference_ = frame_of_reference;
@@ -85,13 +95,25 @@ class PforVectorInfo {
   void set_num_exceptions(PforConstants::ExceptionCountType num_exceptions) {
     num_exceptions_ = num_exceptions;
   }
+  void set_is_delta(bool is_delta) { is_delta_ = is_delta; }
+
+  /// \brief Bytes this info occupies on the wire, start value included.
+  ///
+  /// Not a constant: the start value is only present on a delta vector. Paying
+  /// for it unconditionally would be free at a 1024-value vector and ruinous at
+  /// the smallest one the format allows (kMinLogVectorSize is 3, where eight
+  /// bytes across eight values is a byte per value).
+  int64_t stored_bytes() const {
+    return kStoredSize + (is_delta_ ? static_cast<int64_t>(sizeof(T)) : 0);
+  }
 
   /// \brief Store this info to a byte buffer (little-endian)
   void Store(std::span<uint8_t> dest) const {
     uint8_t* ptr = dest.data();
     util::SafeStore(ptr, bit_util::ToLittleEndian(frame_of_reference_));
-    // bits 0..6 = bit width; bit 7 reserved (0).
-    ptr[sizeof(T)] = static_cast<uint8_t>(bit_width_ & kBitWidthMask);
+    // bits 0..6 = bit width; bit 7 = delta flag.
+    ptr[sizeof(T)] =
+        static_cast<uint8_t>((bit_width_ & kBitWidthMask) | (is_delta_ ? kDeltaFlag : 0));
     util::SafeStore(ptr + sizeof(T) + 1, bit_util::ToLittleEndian(num_exceptions_));
   }
 
@@ -104,8 +126,9 @@ class PforVectorInfo {
     PforVectorInfo info;
     const uint8_t* ptr = src.data();
     info.frame_of_reference_ = bit_util::FromLittleEndian(util::SafeLoadAs<T>(ptr));
-    // Mask off the reserved high bit (7).
-    info.bit_width_ = static_cast<uint8_t>(ptr[sizeof(T)] & kBitWidthMask);
+    const uint8_t packed_bit_width = ptr[sizeof(T)];
+    info.bit_width_ = static_cast<uint8_t>(packed_bit_width & kBitWidthMask);
+    info.is_delta_ = (packed_bit_width & kDeltaFlag) != 0;
     info.num_exceptions_ = bit_util::FromLittleEndian(
         util::SafeLoadAs<PforConstants::ExceptionCountType>(ptr + sizeof(T) + 1));
     if (info.bit_width_ > PforTypeTraits<T>::kMaxBitWidth) {
@@ -126,7 +149,10 @@ class PforVectorInfo {
   T frame_of_reference_ = 0;
   uint8_t bit_width_ = 0;
   PforConstants::ExceptionCountType num_exceptions_ = 0;
+  bool is_delta_ = false;
 
+  // is_delta_ rides in a spare bit of the bit-width byte, so it adds nothing to
+  // the stored size.
   static_assert(kStoredSize == sizeof(frame_of_reference_) + sizeof(bit_width_) +
                                    sizeof(num_exceptions_),
                 "kStoredSize must match the fields Store writes and Load reads");
@@ -163,22 +189,18 @@ class PforEncodedVector {
   std::vector<T>& mutable_exception_values() { return exception_values_; }
   void set_exception_values(std::vector<T> v) { exception_values_ = std::move(v); }
 
+  /// \brief First value of the vector; stored only when info().is_delta().
+  T start_value() const { return start_value_; }
+  void set_start_value(T start_value) { start_value_ = start_value; }
+
  private:
   PforVectorInfo<T> info_;
+  T start_value_ = 0;
   std::vector<uint8_t> packed_values_;
   std::vector<PforConstants::PositionType> exception_positions_;
   std::vector<T> exception_values_;
 };
 
-// ----------------------------------------------------------------------
-// Cost model result
-
-/// \brief Result of the optimal bit width search
-struct BitWidthResult {
-  uint8_t bit_width = 0;
-  PforConstants::ExceptionCountType num_exceptions = 0;
-};
-
 // ----------------------------------------------------------------------
 // Core compression/decompression
 
@@ -203,10 +225,12 @@ class ARROW_EXPORT PforCompression {
 
   /// \brief Encode a single vector of integers
   ///
+  /// The cost model decides per vector whether to difference the values first
+  /// and where to put the frame of reference; see ChooseVectorPlan.
+  ///
   /// \param[in] values input integer values
   /// \param[in] num_elements number of elements (up to vector_size)
-  /// \pre num_elements > 0; the frame of reference is values[0] reduced over the
-  ///      rest, so there is no answer for an empty vector
+  /// \pre num_elements > 0; there is no frame of reference for an empty vector
   /// \return the encoded vector with all sections
   static PforEncodedVector<T> EncodeVector(const T* values, int32_t num_elements);
 
diff --git a/cpp/src/arrow/util/pfor/pfor_plan_internal.h b/cpp/src/arrow/util/pfor/pfor_plan_internal.h
new file mode 100644
index 000000000000..c7a0d34e5c0d
--- /dev/null
+++ b/cpp/src/arrow/util/pfor/pfor_plan_internal.h
@@ -0,0 +1,481 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+// PFOR encoder decision logic: what to do with one vector.
+//
+// The encoder chooses three things per vector, and this header holds the
+// search over all three:
+//
+//   1. whether to difference the values first (the delta mode),
+//   2. the frame of reference, which is not required to be the minimum,
+//   3. the bit width, from the existing histogram cost model.
+//
+// Kept apart from pfor.h, and free of every Arrow dependency, so the same
+// decision code can be linked into a standalone size study without building
+// the library. Nothing here touches bytes on the wire; pfor.cc does that.
+
+#pragma once
+
+#include <array>
+#include <bit>
+#include <cstdint>
+#include <cstring>
+#include <limits>
+
+#include "arrow/util/pfor/pfor_constants_internal.h"
+
+namespace arrow {
+namespace util {
+namespace pfor {
+
+/// \brief Result of the optimal bit width search
+struct BitWidthResult {
+  uint8_t bit_width = 0;
+  PforConstants::ExceptionCountType num_exceptions = 0;
+};
+
+/// \brief Bits an exception costs: its position plus a full-width value.
+template <typename T>
+constexpr int64_t ExceptionBits() {
+  return static_cast<int64_t>(sizeof(PforConstants::PositionType)) * 8 +
+         static_cast<int64_t>(sizeof(T)) * 8;
+}
+
+// ----------------------------------------------------------------------
+// Bit width search
+
+/// \brief Histogram of the bit widths needed by `values` reduced by `frame`.
+///
+/// out[b] counts the offsets that need exactly b bits. The subtraction is
+/// modular in the unsigned type, so a value below the frame wraps to a huge
+/// offset and lands in the top bin -- which is what makes a frame above the
+/// minimum work at all: below-frame values are counted as exceptions here and
+/// then patched on the way out, with no separate sign or direction to track.
+template <typename T>
+void BuildOffsetHistogram(const T* values, int32_t num_elements, T frame,
+                          std::array<int32_t, 65>* out) {
+  using UnsignedT = typename PforTypeTraits<T>::UnsignedType;
+  const auto unsigned_frame = static_cast<UnsignedT>(frame);
+
+  // Four independent accumulators so repeated bins do not serialize the
+  // read-modify-write and the load->clz->bump chains overlap. This loop is
+  // ~half of encode time; a single array runs scalar and stalls.
+  std::array<int32_t, 65> h0{}, h1{}, h2{}, h3{};
+  int32_t i = 0;
+  for (; i + 4 <= num_elements; i += 4) {
+    ++h0[PforTypeTraits<T>::BitsRequired(static_cast<UnsignedT>(values[i]) -
+                                         unsigned_frame)];
+    ++h1[PforTypeTraits<T>::BitsRequired(static_cast<UnsignedT>(values[i + 1]) -
+                                         unsigned_frame)];
+    ++h2[PforTypeTraits<T>::BitsRequired(static_cast<UnsignedT>(values[i + 2]) -
+                                         unsigned_frame)];
+    ++h3[PforTypeTraits<T>::BitsRequired(static_cast<UnsignedT>(values[i + 3]) -
+                                         unsigned_frame)];
+  }
+  for (; i < num_elements; ++i) {
+    ++h0[PforTypeTraits<T>::BitsRequired(static_cast<UnsignedT>(values[i]) -
+                                         unsigned_frame)];
+  }
+  for (int b = 0; b <= 64; ++b) (*out)[b] = h0[b] + h1[b] + h2[b] + h3[b];
+}
+
+/// \brief Pick the width that minimises packed bits plus exception bits.
+///
+/// \param[in] histogram output of BuildOffsetHistogram
+/// \param[in] num_elements number of elements the histogram covers
+/// \param[out] cost_bits total cost of the winning width
+template <typename T>
+BitWidthResult BestWidthFromHistogram(const std::array<int32_t, 65>& histogram,
+                                      int32_t num_elements, int64_t* cost_bits) {
+  constexpr uint8_t max_bits = PforTypeTraits<T>::kMaxBitWidth;
+
+  int64_t best_cost = std::numeric_limits<int64_t>::max();
+  uint8_t best_bit_width = max_bits;
+  PforConstants::ExceptionCountType best_num_exceptions = 0;
+
+  int64_t exceptions_above = num_elements;
+  for (uint8_t b = 0; b <= max_bits; ++b) {
+    exceptions_above -= histogram[b];
+
+    // A vector holds at most kMaxVectorSize elements, so that is also the most
+    // exceptions one can name. Skipping the wider counts keeps the cast below
+    // exact; the full-width candidate has none at all, so a best is always
+    // found.
+    if (exceptions_above > PforConstants::kMaxVectorSize) continue;
+
+    const int64_t total_cost =
+        static_cast<int64_t>(num_elements) * b + exceptions_above * ExceptionBits<T>();
+    if (total_cost < best_cost) {
+      best_cost = total_cost;
+      best_bit_width = b;
+      best_num_exceptions =
+          static_cast<PforConstants::ExceptionCountType>(exceptions_above);
+    }
+  }
+
+  *cost_bits = best_cost;
+  return {best_bit_width, best_num_exceptions};
+}
+
+/// Bucket count used by the frame search, as a shift and as a count. 256 keeps
+/// the scan in ChooseFrameAndWidth at roughly two passes' worth of work over a
+/// 1024-value vector.
+constexpr int32_t kFrameSearchBits = 8;
+constexpr int32_t kFrameSearchBuckets = 1 << kFrameSearchBits;
+
+/// \brief One walk producing both histograms the frame search needs.
+///
+/// The bit-width histogram costs the frame it is given; the bucket counts cost
+/// every other frame. Gather both in one pass because they use the same offset.
+///
+/// Bucketing is by shift rather than division: `1 << shift` values per bucket
+/// keeps the count at or below kFrameSearchBuckets without a per-element divide.
+template <typename T>
+void BuildFrameSearchHistograms(const T* values, int32_t num_elements, T frame,
+                                int32_t shift, std::array<int32_t, 65>* width_hist,
+                                std::array<int32_t, kFrameSearchBuckets + 1>* buckets) {
+  using UnsignedT = typename PforTypeTraits<T>::UnsignedType;
+  const auto unsigned_frame = static_cast<UnsignedT>(frame);
+
+  // Four accumulators, as in BuildOffsetHistogram: a column whose offsets share
+  // a width -- which is most of them -- sends every element to one bin, and a
+  // single accumulator turns that into a serial read-modify-write chain.
+  std::array<std::array<int32_t, 65>, 4> h{};
+  for (int32_t i = 0; i < num_elements; ++i) {
+    const UnsignedT offset = static_cast<UnsignedT>(values[i]) - unsigned_frame;
+    ++h[i & 3][PforTypeTraits<T>::BitsRequired(offset)];
+    ++(*buckets)[static_cast<size_t>(offset >> shift)];
+  }
+  for (int b = 0; b <= 64; ++b) {
+    (*width_hist)[b] = h[0][b] + h[1][b] + h[2][b] + h[3][b];
+  }
+}
+
+/// \brief Histogram over offsets that were already reduced by their frame.
+template <typename T>
+void BuildOffsetHistogram(const typename PforTypeTraits<T>::UnsignedType* offsets,
+                          int32_t num_elements, std::array<int32_t, 65>* out) {
+  // A pointer to the unsigned counterpart of T may be read as a pointer to T,
+  // and BitsRequired only looks at the bits, so a frame of zero over the same
+  // storage gives exactly the histogram of the offsets.
+  BuildOffsetHistogram<T>(reinterpret_cast<const T*>(offsets), num_elements,
+                          static_cast<T>(0), out);
+}
+
+// ----------------------------------------------------------------------
+// Frame search
+
+/// \brief The extremes of a run of values.
+template <typename T>
+struct MinMax {
+  T min = 0;
+  T max = 0;
+};
+
+/// \brief A frame of reference together with the width that suits it.
+template <typename T>
+struct FrameChoice {
+  T frame_of_reference = 0;
+  uint8_t bit_width = 0;
+  PforConstants::ExceptionCountType num_exceptions = 0;
+  int64_t cost_bits = std::numeric_limits<int64_t>::max();
+};
+
+/// \brief Choose a frame of reference and a bit width together.
+///
+/// The frame PFOR has always used is the minimum, which makes every exception
+/// an overshoot: one value far below the cluster drags the whole packed window
+/// down with it and nothing can patch it back. Treating the frame as a free
+/// parameter instead -- any lower bound, not the lowest -- lets the window sit
+/// where the values are and patch on both sides.
+///
+/// Storage is unaffected: the frame field already holds a full-width T, and the
+/// decoder only ever adds it. The whole cost is this search.
+///
+/// The search is approximate by design. An exact answer needs the values
+/// sorted; instead the range is bucketed with a shift, and for each candidate
+/// width a window is slid over the bucket counts. Only whole buckets count as
+/// covered, so the exception estimate is an upper bound -- never optimistic.
+/// The minimum-frame answer is always among the candidates, and it alone is
+/// costed from a real histogram, so the approximate search cannot produce a
+/// higher estimated cost.
+template <typename T>
+FrameChoice<T> ChooseFrameAndWidth(const T* values, int32_t num_elements,
+                                   MinMax<T> bounds) {
+  using UnsignedT = typename PforTypeTraits<T>::UnsignedType;
+  constexpr uint8_t max_bits = PforTypeTraits<T>::kMaxBitWidth;
+
+  const T min_val = bounds.min;
+  const T max_val = bounds.max;
+
+  // A constant vector is already at the floor, and min/max has just proved it
+  // constant, so it needs no histogram to find that out. Worth the special case
+  // for its own sake: a run of equal values sends every element to one
+  // histogram bin, where the read-modify-write serializes and the pass runs at
+  // a fraction of its usual rate.
+  const auto range = static_cast<UnsignedT>(max_val) - static_cast<UnsignedT>(min_val);
+  if (range == 0) {
+    FrameChoice<T> constant_choice;
+    constant_choice.frame_of_reference = min_val;
+    constant_choice.cost_bits = 0;
+    return constant_choice;
+  }
+
+  const auto range_bits = PforTypeTraits<T>::BitsRequired(range);
+  const int32_t shift = range_bits > kFrameSearchBits ? range_bits - kFrameSearchBits : 0;
+
+  // One walk serves both halves of the search: the bit-width histogram costs
+  // the minimum as a frame, the bucket counts cost every other frame.
+  std::array<int32_t, 65> histogram{};
+  std::array<int32_t, kFrameSearchBuckets + 1> counts{};
+  BuildFrameSearchHistograms<T>(values, num_elements, min_val, shift, &histogram,
+                                &counts);
+
+  // Candidate 0: the minimum, i.e. what PFOR has always done. Costed
+  // unconditionally, and from a real histogram, so the search cannot regress
+  // against it.
+  FrameChoice<T> best;
+  best.frame_of_reference = min_val;
+  int64_t cost_bits = 0;
+  BitWidthResult r = BestWidthFromHistogram<T>(histogram, num_elements, &cost_bits);
+  best.bit_width = r.bit_width;
+  best.num_exceptions = r.num_exceptions;
+  best.cost_bits = cost_bits;
+
+  // Already at width 0, with a handful of patches carrying the rest. Nothing a
+  // frame can do about it. Note this is not the same as having no exceptions:
+  // the whole point of a frame above the minimum is to trade a narrower width
+  // for a few patches, so an exception-free choice is where the search starts,
+  // not a reason to skip it. The sawtooth is the example -- its differences pack
+  // at width 12 with no exceptions, or at width 0 with five; only the latter is
+  // beneficial.
+  if (best.bit_width == 0) return best;
+
+  const int32_t num_buckets = static_cast<int32_t>(range >> shift) + 1;
+  std::array<int32_t, kFrameSearchBuckets + 2> prefix{};
+  for (int32_t b = 0; b < num_buckets; ++b) prefix[b + 1] = prefix[b] + counts[b];
+
+  // Slide a 2^w-wide window over the buckets and keep the position that costs
+  // least. Widths below the bucket size cannot be resolved at this granularity,
+  // and once one window spans every bucket there are no exceptions left to
+  // remove, so the loop covers only the ~kFrameSearchBits widths in between --
+  // fixed work, and none of it touching the data again.
+  //
+  // What comes out of this is a frame, not a width. Only whole buckets count as
+  // covered, so `w` here is an upper bound on the width the frame needs, and
+  // the exception count an upper bound too. The exact pass below is what turns
+  // the frame into a plan.
+  //
+  // Seeded with the incumbent's cost, so a window only registers if it beats
+  // the minimum as a frame. Everything after this loop -- the walk that lowers
+  // the frame onto a real value, and the exact pass that turns it into a width
+  // -- is then skipped entirely on a column the frame cannot help, which is
+  // most of them. Seeding it costs the conservative direction: the scan
+  // over-counts exceptions, so it can decline a frame whose exact cost would
+  // have won, but it cannot accept one that loses.
+  int32_t best_start = -1;
+  int32_t best_end = 0;
+  int64_t scan_cost = best.cost_bits;
+  for (int32_t w = shift; w <= max_bits; ++w) {
+    const int64_t whole_buckets = static_cast<int64_t>(1) << (w - shift);
+    if (whole_buckets <= 0) break;
+    const int32_t k =
+        static_cast<int32_t>(whole_buckets < num_buckets ? whole_buckets : num_buckets);
+    for (int32_t s = 0; s < num_buckets; ++s) {
+      const int32_t end = s + k < num_buckets ? s + k : num_buckets;
+      const int64_t exceptions = num_elements - (prefix[end] - prefix[s]);
+      if (exceptions > PforConstants::kMaxVectorSize) continue;
+      const int64_t cost =
+          static_cast<int64_t>(num_elements) * w + exceptions * ExceptionBits<T>();
+      if (cost < scan_cost) {
+        scan_cost = cost;
+        best_start = s;
+        best_end = end;
+      }
+    }
+    if (k >= num_buckets) break;  // one window already spans the data
+  }
+
+  if (best_start < 0) return best;
+
+  // Lower the frame from the boundary of the winning window onto the smallest
+  // value the window covers. Bucket boundaries stand 2^shift apart, which on
+  // a wide column is thousands, and a cluster sitting just above one would
+  // otherwise pay those bits for nothing.
+  //
+  // A walk of its own, rather than per-bucket minima kept by the pass above:
+  // tracking them there costs every vector a compare and a store per element,
+  // including the vectors where the scan finds nothing and the minima are
+  // discarded. Over the distributions in pfor_benchmark.cc that cost about 30%
+  // of encode throughput to improve one of them. Here only a vector the search has
+  // already won pays, and it pays one traversal.
+  const auto window_lo = static_cast<UnsignedT>(best_start) << shift;
+  // A window reaching the last bucket has no upper edge to test against: the
+  // edge would be num_buckets << shift, which is one past the representable
+  // range whenever the offsets span the whole type.
+  const bool bounded_above = best_end < num_buckets;
+  const UnsignedT window_hi =
+      bounded_above ? (static_cast<UnsignedT>(best_end) << shift) : UnsignedT{0};
+
+  const auto unsigned_min = static_cast<UnsignedT>(min_val);
+  UnsignedT frame_offset = 0;
+  bool covers_anything = false;
+  for (int32_t i = 0; i < num_elements; ++i) {
+    const UnsignedT offset = static_cast<UnsignedT>(values[i]) - unsigned_min;
+    if (offset < window_lo || (bounded_above && offset >= window_hi)) continue;
+    if (!covers_anything || offset < frame_offset) {
+      frame_offset = offset;
+      covers_anything = true;
+    }
+  }
+  if (!covers_anything) return best;
+
+  const auto scan_frame = static_cast<T>(unsigned_min + frame_offset);
+  if (scan_frame == min_val) return best;
+
+  // Cost the winning frame exactly. This pass is where the width and the
+  // exception count are decided. The scan works at bucket granularity and
+  // therefore cannot see a window narrower than one bucket. Such windows can be
+  // optimal: the sawtooth's differences span 12 bits, so its buckets are 16
+  // wide, and no scan over them can resolve the 0-bit window that its five
+  // patches leave behind.
+  BuildOffsetHistogram<T>(values, num_elements, scan_frame, &histogram);
+  int64_t exact_cost = 0;
+  r = BestWidthFromHistogram<T>(histogram, num_elements, &exact_cost);
+  if (exact_cost < best.cost_bits) {
+    best.frame_of_reference = scan_frame;
+    best.bit_width = r.bit_width;
+    best.num_exceptions = r.num_exceptions;
+    best.cost_bits = exact_cost;
+  }
+  return best;
+}
+
+/// \brief Overload for callers that have not already seen the values.
+template <typename T>
+FrameChoice<T> ChooseFrameAndWidth(const T* values, int32_t num_elements) {
+  MinMax<T> bounds{values[0], values[0]};
+  for (int32_t i = 1; i < num_elements; ++i) {
+    if (values[i] < bounds.min) bounds.min = values[i];
+    if (values[i] > bounds.max) bounds.max = values[i];
+  }
+  return ChooseFrameAndWidth<T>(values, num_elements, bounds);
+}
+
+// ----------------------------------------------------------------------
+// Whole-vector plan
+
+/// \brief Everything the encoder decided about one vector.
+template <typename T>
+struct PforVectorPlan {
+  /// Difference the values before framing and packing them.
+  bool delta = false;
+  /// Subtracted from every element before packing; added back on decode.
+  T frame_of_reference = 0;
+  /// First value of the vector, stored only when `delta` is set. It is what
+  /// makes a delta vector decodable on its own, without the vector before it.
+  T start_value = 0;
+  uint8_t bit_width = 0;
+  PforConstants::ExceptionCountType num_exceptions = 0;
+  /// Packed bits, exception bits, and the start value if there is one. Excludes
+  /// the fixed per-vector info, which every plan pays equally.
+  int64_t cost_bits = 0;
+};
+
+/// \brief Fill `deltas` with the backward differences of `values`.
+///
+/// deltas[0] is 0: the first value travels in the plan's start_value, and
+/// giving slot 0 a real delta would mean either a shorter packed run or a
+/// value that is not a difference sitting in the width histogram. Zero costs
+/// bit_width bits and distorts nothing.
+///
+/// Subtraction is done unsigned and copied across, because signed overflow is
+/// undefined and a column that spans the type's range will overflow.
+/// The bounds of the differences come back with them: this walk has just seen
+/// every one, and the search needs them before it can do anything else.
+template <typename T>
+void ComputeDeltas(const T* values, int32_t num_elements, T* deltas, MinMax<T>* bounds) {
+  using UnsignedT = typename PforTypeTraits<T>::UnsignedType;
+  deltas[0] = 0;
+  *bounds = MinMax<T>{0, 0};
+  for (int32_t i = 1; i < num_elements; ++i) {
+    const UnsignedT d =
+        static_cast<UnsignedT>(values[i]) - static_cast<UnsignedT>(values[i - 1]);
+    T signed_delta;
+    std::memcpy(&signed_delta, &d, sizeof(T));
+    deltas[i] = signed_delta;
+    if (signed_delta < bounds->min) bounds->min = signed_delta;
+    if (signed_delta > bounds->max) bounds->max = signed_delta;
+  }
+}
+
+/// \brief Decide how to encode one vector.
+///
+/// \param[in] values the vector
+/// \param[in] num_elements element count, > 0
+/// \param[out] delta_scratch scratch for num_elements differences; on return it
+///             holds the differences if the plan chose the delta mode, and is
+///             clobbered either way
+///
+/// Both transforms are costed with the same model and the cheaper one wins, so
+/// the mode is a per-vector decision. It has to be: differencing loses 6-19% on
+/// every unclustered draw, and a column is rarely all one shape.
+template <typename T>
+PforVectorPlan<T> ChooseVectorPlan(const T* values, int32_t num_elements,
+                                   T* delta_scratch) {
+  const FrameChoice<T> raw = ChooseFrameAndWidth<T>(values, num_elements);
+
+  PforVectorPlan<T> plan;
+  plan.delta = false;
+  plan.frame_of_reference = raw.frame_of_reference;
+  plan.bit_width = raw.bit_width;
+  plan.num_exceptions = raw.num_exceptions;
+  plan.cost_bits = raw.cost_bits;
+
+  // One element has no difference to take, and a vector already packing at
+  // width 0 cannot be improved on.
+  if (num_elements < 2 || raw.bit_width == 0) return plan;
+
+  MinMax<T> delta_bounds;
+  ComputeDeltas<T>(values, num_elements, delta_scratch, &delta_bounds);
+
+  // Both candidates get the full search. A cheaper gate on the spread of the
+  // differences was tried first and had to go: the sawtooth is a tight cluster
+  // of small positive differences with a handful of large negative ones, so its
+  // span is as wide as the raw span while its cost is a fraction of it. Any
+  // gate that reads a span rather than a distribution throws away the one shape
+  // the mode is here for.
+  const FrameChoice<T> delta =
+      ChooseFrameAndWidth<T>(delta_scratch, num_elements, delta_bounds);
+
+  // A delta vector carries its own first value, so it starts one full-width
+  // value behind.
+  const int64_t delta_cost = delta.cost_bits + static_cast<int64_t>(sizeof(T)) * 8;
+  if (delta_cost < plan.cost_bits) {
+    plan.delta = true;
+    plan.frame_of_reference = delta.frame_of_reference;
+    plan.start_value = values[0];
+    plan.bit_width = delta.bit_width;
+    plan.num_exceptions = delta.num_exceptions;
+    plan.cost_bits = delta_cost;
+  }
+  return plan;
+}
+
+}  // namespace pfor
+}  // namespace util
+}  // namespace arrow
diff --git a/cpp/src/arrow/util/pfor/pfor_test.cc b/cpp/src/arrow/util/pfor/pfor_test.cc
index c63be0d5e201..e7331aa1a6ae 100644
--- a/cpp/src/arrow/util/pfor/pfor_test.cc
+++ b/cpp/src/arrow/util/pfor/pfor_test.cc
@@ -19,6 +19,7 @@
 
 #include <algorithm>
 #include <cstdint>
+#include <cstring>
 #include <limits>
 #include <numeric>
 #include <random>
@@ -279,6 +280,9 @@ TYPED_TEST(PforTest, CostModelNoOutliers) {
 // ----------------------------------------------------------------------
 // Vector Encode/Decode Round-Trip Tests
 
+// An ascending run is what the delta mode is for, so this no longer measures
+// the frame of reference: the packed stream holds the differences, all of them
+// 1, and the frame belongs to those. The first value travels separately.
 TYPED_TEST(PforTest, VectorSimpleSequence) {
   using T = TypeParam;
   std::vector<T> values(64);
@@ -286,7 +290,22 @@ TYPED_TEST(PforTest, VectorSimpleSequence) {
 
   PforEncodedVector<T> encoded;
   this->RoundTripVector(values, &encoded);
-  EXPECT_EQ(encoded.info().frame_of_reference(), 100);
+  EXPECT_TRUE(encoded.info().is_delta());
+  EXPECT_EQ(encoded.start_value(), 100);
+}
+
+// The same shape with the differences made unpredictable, which is what leaves
+// the values themselves as the cheaper thing to pack. Here the frame is the
+// minimum and nothing is patched, as it was before there was a delta mode.
+TYPED_TEST(PforTest, VectorSimpleSequenceWithoutDelta) {
+  using T = TypeParam;
+  std::vector<T> values = this->RandomValues(64, 100, 163, 11);
+
+  PforEncodedVector<T> encoded;
+  this->RoundTripVector(values, &encoded);
+  EXPECT_FALSE(encoded.info().is_delta());
+  EXPECT_EQ(encoded.info().frame_of_reference(),
+            *std::min_element(values.begin(), values.end()));
   EXPECT_EQ(encoded.info().num_exceptions(), 0);
 }
 
@@ -729,9 +748,13 @@ TYPED_TEST(PforTest, SerializeVectorRejectsInfoInconsistentWithSections) {
     ASSERT_RAISES(Invalid, PforCompression<T>::SerializeVector(corrupted, 64, buffer));
   }
   {
-    // An exception count with no exception sections behind it.
+    // An exception count with nothing behind it. Taken relative to the real
+    // count, which need not be zero: the frame search buys a narrower width
+    // with patches, so even a plain ascending run can arrive with one.
     auto corrupted = encoded;
-    corrupted.mutable_info().set_num_exceptions(1);
+    corrupted.mutable_info().set_num_exceptions(
+        static_cast<PforConstants::ExceptionCountType>(encoded.info().num_exceptions() +
+                                                       1));
     ASSERT_RAISES(Invalid, PforCompression<T>::SerializeVector(corrupted, 64, buffer));
   }
 }
@@ -770,4 +793,268 @@ TYPED_TEST(PforTest, MaxCompressedSizeBoundHoldsForAdversarialInputs) {
   }
 }
 
+// ======================================================================
+// Delta Mode and Frame Search Tests
+
+// The mode has to survive every width, not just the ones a plausible column
+// produces, so this drives it through all of them: a cumulative sum whose
+// differences are exactly w bits wide leaves the encoder no cheaper option than
+// differencing, since the values themselves span 1024 times as much.
+TYPED_TEST(PforTest, DeltaRoundTripsAtEveryBitWidth) {
+  using T = TypeParam;
+  using UnsignedT = typename PforTypeTraits<T>::UnsignedType;
+  constexpr int32_t kNumValues = 1024;
+
+  for (uint8_t width = 0; width <= PforTypeTraits<T>::kMaxBitWidth; ++width) {
+    SCOPED_TRACE("delta width " + std::to_string(width));
+    // Differences that need exactly `width` bits, and whose top bit is set so
+    // the width cannot be mistaken for a narrower one.
+    const UnsignedT step =
+        width == 0 ? UnsignedT{0} : static_cast<UnsignedT>(UnsignedT{1} << (width - 1));
+
+    std::vector<T> values(kNumValues);
+    auto acc = static_cast<UnsignedT>(0);
+    for (int32_t i = 0; i < kNumValues; ++i) {
+      std::memcpy(&values[i], &acc, sizeof(T));
+      acc += step;
+    }
+    this->RoundTripVector(values);
+  }
+}
+
+// The negative control for the sweep above. If the encoder stopped choosing the
+// delta mode -- a cost-model change, a gate that reads the wrong thing -- every
+// round-trip test would still pass while testing nothing, so assert here that
+// the path is reached at all, and that it is not reached for data it would only
+// make bigger.
+TYPED_TEST(PforTest, DeltaIsChosenForRunsAndDeclinedForNoise) {
+  using T = TypeParam;
+  constexpr int32_t kNumValues = 1024;
+
+  std::vector<T> ascending(kNumValues);
+  std::iota(ascending.begin(), ascending.end(), static_cast<T>(1'000'000));
+  PforEncodedVector<T> encoded;
+  this->RoundTripVector(ascending, &encoded);
+  EXPECT_TRUE(encoded.info().is_delta());
+
+  // Independent draws from a narrow band: the values fit in 10 bits, while
+  // their differences take 11 and swing both ways.
+  const std::vector<T> noise = this->RandomValues(kNumValues, 0, 1000, 42);
+  this->RoundTripVector(noise, &encoded);
+  EXPECT_FALSE(encoded.info().is_delta());
+}
+
+// The property the mode exists for: a delta vector carries its own first value,
+// so it decodes without the vector before it. Decoding vector 1 of a page
+// straight out of the middle is what a reader doing block-level random access
+// would do, and it has to produce that vector's values and no others.
+TYPED_TEST(PforTest, DeltaVectorDecodesWithoutThePrecedingVector) {
+  using T = TypeParam;
+  constexpr int32_t kVectorSize = static_cast<int32_t>(PforConstants::kPforVectorSize);
+  constexpr int32_t kNumValues = 3 * kVectorSize;
+
+  std::vector<T> values(kNumValues);
+  std::iota(values.begin(), values.end(), static_cast<T>(500));
+  const std::vector<uint8_t> page = this->EncodePage(values);
+
+  // The offset array follows the header, one entry per vector, each counted
+  // from the start of the array itself.
+  const uint8_t* offsets = page.data() + PforConstants::kHeaderSize;
+  const auto second = util::SafeLoadAs<PforConstants::OffsetType>(
+      offsets + sizeof(PforConstants::OffsetType));
+  const uint8_t* vector = offsets + second;
+
+  std::vector<T> decoded(kVectorSize);
+  ASSERT_OK(PforCompression<T>::DecodeVector(
+      std::span<const uint8_t>(vector, page.data() + page.size() - vector), kVectorSize,
+      decoded.data()));
+  EXPECT_EQ(
+      std::vector<T>(values.begin() + kVectorSize, values.begin() + 2 * kVectorSize),
+      decoded);
+}
+
+// Two-sided patching. A tight cluster with one value far below it is the case
+// the old frame could not handle: at the minimum, the packed window has to span
+// the whole gap and every value in the cluster pays for it. The frame belongs
+// above the low value, which then becomes an exception like any other.
+TYPED_TEST(PforTest, FrameSitsAboveTheMinimumToPatchALowOutlier) {
+  using T = TypeParam;
+  constexpr int32_t kNumValues = 1024;
+
+  std::vector<T> values = this->RandomValues(kNumValues, 1'000'000, 1'000'063, 5);
+  values[500] = 0;  // one value four orders of magnitude below the cluster
+
+  PforEncodedVector<T> encoded;
+  this->RoundTripVector(values, &encoded);
+  EXPECT_GT(encoded.info().frame_of_reference(),
+            *std::min_element(values.begin(), values.end()));
+  EXPECT_GE(encoded.info().num_exceptions(), 1);
+  // Six bits covers the cluster; spanning the gap would take twenty. The bound
+  // is loose because the search picks the frame from bucketed counts and then
+  // lowers it to the smallest value it covers, which lands on the cluster
+  // minimum only when the cluster falls inside one bucket.
+  EXPECT_LE(encoded.info().bit_width(), 8);
+}
+
+// The two features together, on the shape that motivated them: a counter that
+// climbs steadily and resets, whose differences are a run of small positive
+// values with a handful of large negative ones. The differences want a frame
+// above their minimum, and the drops want patching -- neither alone is enough,
+// and this is where both of the encoder's bugs showed up during development.
+TYPED_TEST(PforTest, SawtoothPacksAtNearlyNoCost) {
+  using T = TypeParam;
+  constexpr int32_t kNumValues = 8192;
+
+  std::vector<T> values(kNumValues);
+  T level = 0;
+  for (int32_t i = 0; i < kNumValues; ++i) {
+    values[i] = level;
+    level = (i % 200 == 199) ? 0 : static_cast<T>(level + 12);
+  }
+
+  int64_t comp_size = 0;
+  this->RoundTripPage(values, &comp_size);
+  // The differences pack at width 0 with one patch per reset. Anything that
+  // falls back to a width wide enough to hold the climb costs at least 12 bits
+  // a value, so a bound of one is far from the boundary.
+  const double bits_per_value = 8.0 * comp_size / kNumValues;
+  EXPECT_LT(bits_per_value, 1.0) << "compressed to " << bits_per_value << " bits/value";
+}
+
+// An exception in a delta vector is itself a difference, so the decoder has to
+// patch before it sums. Summing first would carry the placeholder zero into
+// every value after the patch, which round-trips as a plausible-looking
+// sequence rather than an obvious corruption.
+TYPED_TEST(PforTest, DeltaExceptionsArePatchedBeforeTheSum) {
+  using T = TypeParam;
+  constexpr int32_t kNumValues = 1024;
+
+  // A steady climb with occasional jumps far larger than the packed width can
+  // hold, so the jumps become exceptions and everything after one depends on
+  // the patch having landed.
+  std::vector<T> values(kNumValues);
+  T level = 1000;
+  for (int32_t i = 0; i < kNumValues; ++i) {
+    values[i] = level;
+    level = static_cast<T>(level + ((i % 137 == 100) ? 1'000'000 : 3));
+  }
+
+  PforEncodedVector<T> encoded;
+  this->RoundTripVector(values, &encoded);
+  EXPECT_TRUE(encoded.info().is_delta());
+  EXPECT_GE(encoded.info().num_exceptions(), 1);
+}
+
+// The delta flag shares its byte with the bit width, and the width goes up to
+// 64, which needs all seven of the bits left over. A vector whose differences
+// span the type is the case that would catch the two fields overlapping.
+TYPED_TEST(PforTest, DeltaAtFullWidthRoundTrips) {
+  using T = TypeParam;
+  constexpr int32_t kNumValues = 1024;
+  std::mt19937_64 rng(3);
+
+  // Values whose differences are full-width, built by accumulating full-width
+  // steps, so the sequence wraps the type as it goes.
+  std::vector<T> values(kNumValues);
+  auto acc = static_cast<typename PforTypeTraits<T>::UnsignedType>(0);
+  for (int32_t i = 0; i < kNumValues; ++i) {
+    std::memcpy(&values[i], &acc, sizeof(T));
+    acc += static_cast<typename PforTypeTraits<T>::UnsignedType>(rng());
+  }
+  this->RoundTripVector(values);
+}
+
+// The same overlap, tested at the metadata directly rather than through data
+// that happens to produce it, at every width the type allows.
+TYPED_TEST(PforTest, VectorInfoKeepsTheDeltaFlagOutOfTheWidth) {
+  using T = TypeParam;
+  std::vector<uint8_t> buffer(PforVectorInfo<T>::kStoredSize);
+
+  for (uint8_t width = 0; width <= PforTypeTraits<T>::kMaxBitWidth; ++width) {
+    for (bool is_delta : {false, true}) {
+      SCOPED_TRACE("width " + std::to_string(width) + " delta " +
+                   std::to_string(is_delta));
+      const PforVectorInfo<T> info(static_cast<T>(-7), width, 123, is_delta);
+      info.Store(buffer);
+      ASSERT_OK_AND_ASSIGN(const auto loaded, PforVectorInfo<T>::Load(buffer));
+      EXPECT_EQ(loaded.bit_width(), width);
+      EXPECT_EQ(loaded.is_delta(), is_delta);
+      EXPECT_EQ(loaded.frame_of_reference(), static_cast<T>(-7));
+      EXPECT_EQ(loaded.num_exceptions(), 123);
+      EXPECT_EQ(loaded.stored_bytes(),
+                PforVectorInfo<T>::kStoredSize +
+                    (is_delta ? static_cast<int64_t>(sizeof(T)) : 0));
+    }
+  }
+}
+
+// Differencing is done in the unsigned domain because signed overflow is
+// undefined, and a column spanning the type's range will overflow. The bits
+// have to round-trip anyway.
+TYPED_TEST(PforTest, DeltaRoundTripsAcrossTheTypeExtremes) {
+  using T = TypeParam;
+  const T lo = std::numeric_limits<T>::min();
+  const T hi = std::numeric_limits<T>::max();
+
+  std::vector<std::vector<T>> inputs = {
+      {lo, hi, lo, hi, lo, hi, lo, hi},
+      {lo, static_cast<T>(lo + 1), static_cast<T>(lo + 2), hi, static_cast<T>(hi - 1)},
+      {hi, static_cast<T>(hi - 1), static_cast<T>(hi - 2), lo, static_cast<T>(lo + 1)},
+  };
+  // A ramp from the bottom of the type that runs off the top of it.
+  inputs.emplace_back(1024);
+  auto acc = static_cast<typename PforTypeTraits<T>::UnsignedType>(lo);
+  for (auto& v : inputs.back()) {
+    std::memcpy(&v, &acc, sizeof(T));
+    acc += static_cast<typename PforTypeTraits<T>::UnsignedType>(hi / 100);
+  }
+
+  for (size_t i = 0; i < inputs.size(); ++i) {
+    SCOPED_TRACE("input " + std::to_string(i));
+    this->RoundTripVector(inputs[i]);
+  }
+}
+
+// Small vectors are where the start value is expensive: the format allows eight
+// values to a vector, and eight bytes across eight of them is a byte each. The
+// cost model has to account for it rather than differencing whenever the
+// differences happen to be narrower.
+TYPED_TEST(PforTest, StartValueIsPaidForAtEveryVectorSize) {
+  using T = TypeParam;
+  for (int32_t log_size = PforConstants::kMinLogVectorSize;
+       log_size <= PforConstants::kMaxLogVectorSize; ++log_size) {
+    const int32_t vector_size = 1 << log_size;
+    SCOPED_TRACE("vector size " + std::to_string(vector_size));
+
+    std::vector<T> values(static_cast<size_t>(vector_size) * 3);
+    std::iota(values.begin(), values.end(), static_cast<T>(77));
+
+    const auto num_values = static_cast<int32_t>(values.size());
+    ASSERT_OK_AND_ASSIGN(const int64_t max_size,
+                         PforWrapper<T>::GetMaxCompressedSize(num_values, vector_size));
+    std::vector<uint8_t> compressed(max_size);
+    int64_t comp_size = max_size;
+    ASSERT_OK(PforWrapper<T>::Encode(values.data(), num_values, vector_size,
+                                     compressed.data(), &comp_size));
+    ASSERT_LE(comp_size, max_size);
+
+    std::vector<T> decoded(values.size());
+    ASSERT_OK(
+        PforWrapper<T>::Decode(compressed.data(), comp_size, num_values, decoded.data()));
+    EXPECT_EQ(values, decoded);
+  }
+}
+
+// A one-element vector has no difference to take, and a two-element one has
+// exactly one. Both are inside the range the format allows for a trailing
+// partial vector.
+TYPED_TEST(PforTest, DeltaHandlesVectorsTooShortToDifference) {
+  using T = TypeParam;
+  this->RoundTripVector(std::vector<T>{42});
+  this->RoundTripVector(std::vector<T>{42, 43});
+  this->RoundTripVector(std::vector<T>{std::numeric_limits<T>::max()});
+  this->RoundTripVector(
+      std::vector<T>{std::numeric_limits<T>::max(), std::numeric_limits<T>::min()});
+}
+
 }  // namespace arrow::util::pfor
diff --git a/cpp/src/arrow/util/pfor/pfor_wrapper.cc b/cpp/src/arrow/util/pfor/pfor_wrapper.cc
index 0dd3e1c04f39..0e1fadc5a650 100644
--- a/cpp/src/arrow/util/pfor/pfor_wrapper.cc
+++ b/cpp/src/arrow/util/pfor/pfor_wrapper.cc
@@ -395,14 +395,17 @@ Result<int64_t> PforWrapper<T>::GetMaxCompressedSize(int32_t num_values,
 
   const int64_t num_vectors = bit_util::CeilDiv(num_values, vector_size);
 
-  // A vector never serializes to more than its values occupy unpacked.
-  // FindOptimalBitWidth minimises `num_elements * bit_width + num_exceptions *
-  // (16 + 8 * sizeof(T))` bits, and the full-width candidate scores
+  // A vector never serializes to more than its values occupy unpacked. The cost
+  // model minimises `num_elements * bit_width + num_exceptions * (16 +
+  // 8 * sizeof(T))` bits, and the full-width candidate scores
   // `num_elements * 8 * sizeof(T)` bits with no exceptions at all, so whatever
   // width it does pick costs no more than that. Bit packing rounds the packed
-  // section up to a whole byte, hence the trailing byte.
-  const int64_t max_vector_size =
-      PforVectorInfo<T>::kStoredSize + vector_size * static_cast<int64_t>(sizeof(T)) + 1;
+  // section up to a whole byte, hence the trailing byte. The delta mode adds
+  // one full-width start value, and the model only chooses it when doing so
+  // still comes out cheaper, but the bound has to hold for either outcome.
+  const int64_t max_vector_size = PforVectorInfo<T>::kStoredSize +
+                                  static_cast<int64_t>(sizeof(T)) +
+                                  vector_size * static_cast<int64_t>(sizeof(T)) + 1;
 
   return PforConstants::kHeaderSize + num_vectors * (kOffsetSize + max_vector_size);
 }

From 33feeffc9dc1934b6787cecdb0d327aa5576b96c Mon Sep 17 00:00:00 2001
From: Prateek Gaur <prateek.gaur@snowflake.com>
Date: Tue, 1 Sep 2026 20:17:32 +0000
Subject: [PATCH 08/27] Benchmark PFOR delta mode on correlated columns

The existing benchmark columns are either unordered or perfectly
regular, and neither tells raw packing apart from delta packing. Adds
timestamp, sawtooth, bounded-rate, monotonic and clustered columns at
both integer widths, some of which also need a frame above the minimum.
---
 cpp/src/parquet/pfor_comparison_benchmark.cc | 215 ++++++++++++++++++-
 1 file changed, 214 insertions(+), 1 deletion(-)

diff --git a/cpp/src/parquet/pfor_comparison_benchmark.cc b/cpp/src/parquet/pfor_comparison_benchmark.cc
index f44216b8812a..30223418d0f7 100644
--- a/cpp/src/parquet/pfor_comparison_benchmark.cc
+++ b/cpp/src/parquet/pfor_comparison_benchmark.cc
@@ -19,7 +19,10 @@
 //                       vs ByteStreamSplit+ZSTD vs ByteStreamSplit+LZ4
 //
 // All throughput is reported as uncompressed_size / time (MB/s).
-// Data generators mimic ClickBench and TPC-DS column distributions.
+// Data generators mimic ClickBench and TPC-DS column distributions. A second
+// group covers columns with structure between neighbouring values, or with a
+// cluster the minimum is not part of; those are the ones on which PFOR's delta
+// mode and DELTA_BINARY_PACKED make different choices.
 
 #include <algorithm>
 #include <bit>
@@ -436,6 +439,199 @@ std::vector<int64_t> GenByteCount(int64_t n) {
   return v;
 }
 
+// ----------------------------------------------------------------------
+// Data generators: structure between neighboring values
+
+// The generators above are all either unordered or perfectly regular, so none
+// of them separates an encoding that differences neighbouring values from one
+// that packs them, and none of them puts a frame of reference anywhere but the
+// minimum. These do. They are the columns on which PFOR's delta mode and
+// DELTA_BINARY_PACKED make different choices, so they are what this file needs
+// in order to compare the two.
+//
+// Unlike the generators above, these are templates rather than a pair of
+// per-width functions: it keeps the int32 and int64 arms of every REGISTER
+// below on provably the same distribution, which two hand-written copies would
+// not. They live in their own namespace because two of them build on base
+// distributions whose names are already taken in this file by columns drawn
+// from different seeds -- keeping them separate is what makes these figures
+// comparable with pfor_benchmark.cc, which uses the same shapes.
+namespace delta_shapes {
+
+template <typename T>
+std::vector<T> GenSmallRange(int64_t n) {
+  std::vector<T> v(n);
+  std::mt19937_64 rng(12345);
+  std::uniform_int_distribution<T> dist(100000, 200000);
+  for (auto& x : v) x = dist(rng);
+  return v;
+}
+
+template <typename T>
+std::vector<T> GenTpcdsItemSk(int64_t n) {
+  std::vector<T> v(n);
+  const T kMax = 100000;
+  std::mt19937_64 rng(12345);
+  std::exponential_distribution<double> exp_dist(0.00005);
+  for (auto& x : v) {
+    T val = static_cast<T>(exp_dist(rng));
+    x = std::min(static_cast<T>(val + 1), kMax);
+  }
+  return v;
+}
+
+/// A timestamp column with a fixed sampling interval and jitter: the
+/// differences cluster tightly around the interval, the values do not.
+template <typename T>
+std::vector<T> GenTrendJitter(int64_t n) {
+  std::vector<T> v(n);
+  std::mt19937_64 rng(7);
+  std::normal_distribution<double> jitter(0.0, 40.0);
+  double t = 1704067200.0;
+  for (auto& x : v) {
+    t += 3.0;
+    x = static_cast<T>(t + jitter(rng));
+  }
+  return v;
+}
+
+/// A TCP congestion window: a linear climb cut by a sharp halving. Almost
+/// every difference is the same small number and a few are large and
+/// negative, which is the shape a two-sided frame plus patching handles at
+/// close to no cost and a one-sided one cannot.
+template <typename T>
+std::vector<T> GenSawtooth(int64_t n) {
+  std::vector<T> v(n);
+  T cur = 1000;
+  for (int64_t i = 0; i < n; ++i) {
+    if (i % 200 == 199) {
+      cur /= 2;
+    } else {
+      cur += 12;
+    }
+    v[i] = cur;
+  }
+  return v;
+}
+
+/// A continuous quantity sampled over time, so the rate of change is bounded
+/// but the level wanders: differencing wins, though not by much.
+template <typename T>
+std::vector<T> GenMeasurement(int64_t n) {
+  std::vector<T> v(n);
+  std::mt19937_64 rng(11);
+  std::normal_distribution<double> noise(0.0, 1.0);
+  double level = 0.0;
+  double rate = 0.0;
+  for (int64_t i = 0; i < n; ++i) {
+    rate = 0.95 * rate + noise(rng);
+    level += rate;
+    v[i] = static_cast<T>(4000.0 * level / 50.0) + static_cast<T>(500000);
+  }
+  return v;
+}
+
+/// A sorted surrogate key column, which is what a clustered index or a
+/// sorted-by-key file produces.
+template <typename T>
+std::vector<T> GenSortedKeys(int64_t n) {
+  auto v = GenTpcdsItemSk<T>(n);
+  std::sort(v.begin(), v.end());
+  return v;
+}
+
+/// A measurement series punctuated by a low sentinel standing in for "no
+/// reading". The sentinel sits far below the cluster, so a frame pinned to
+/// the minimum has to widen to reach it and no value can ever be patched.
+template <typename T>
+std::vector<T> GenSensorDropouts(int64_t n) {
+  auto v = GenMeasurement<T>(n);
+  std::mt19937_64 rng(3);
+  std::uniform_int_distribution<int64_t> pos(0, n - 1);
+  for (int64_t i = 0; i < std::max<int64_t>(1, n / 200); ++i) {
+    v[pos(rng)] = static_cast<T>(-999999);
+  }
+  return v;
+}
+
+/// Monotonic ids with occasional large jumps, as a sequence shared between
+/// writers or restarted produces.
+template <typename T>
+std::vector<T> GenIdsWithGaps(int64_t n) {
+  std::vector<T> v(n);
+  std::mt19937_64 rng(5);
+  std::uniform_int_distribution<int> step(1, 6);
+  std::uniform_int_distribution<int> jump(0, 199);
+  T cur = 1000000;
+  for (auto& x : v) {
+    cur += static_cast<T>(step(rng));
+    if (jump(rng) == 0) cur += 100000;
+    x = cur;
+  }
+  return v;
+}
+
+/// Prices on a random walk: small signed steps around a high base, and no
+/// trend for the differences to line up on.
+template <typename T>
+std::vector<T> GenRandomWalk(int64_t n) {
+  std::vector<T> v(n);
+  std::mt19937_64 rng(13);
+  std::uniform_int_distribution<int> step(-25, 25);
+  T cur = 1500000;
+  for (auto& x : v) {
+    cur += static_cast<T>(step(rng));
+    x = cur;
+  }
+  return v;
+}
+
+/// Event arrival times in milliseconds since the epoch, bursty, so the gaps
+/// are skewed rather than clustered.
+template <typename T>
+std::vector<T> GenEventMillis(int64_t n) {
+  std::vector<T> v(n);
+  std::mt19937_64 rng(17);
+  std::exponential_distribution<double> gap(0.4);
+  double t = 1704067200.0;
+  for (auto& x : v) {
+    t += gap(rng);
+    x = static_cast<T>(t);
+  }
+  return v;
+}
+
+/// A tight unordered cluster with a low "missing" sentinel: the frame cannot
+/// sit at the minimum and differencing has nothing to exploit either, so
+/// this is the column that has to come out no worse than before.
+template <typename T>
+std::vector<T> GenLowSentinel(int64_t n) {
+  auto v = GenSmallRange<T>(n);
+  std::mt19937_64 rng(23);
+  std::uniform_int_distribution<int64_t> pos(0, n - 1);
+  for (int64_t i = 0; i < std::max<int64_t>(1, n / 200); ++i) {
+    v[pos(rng)] = static_cast<T>(-1000);
+  }
+  return v;
+}
+
+/// Two interleaved clusters far apart, so no single window covers the vector
+/// and the cheaper cluster is worth framing on its own.
+template <typename T>
+std::vector<T> GenBimodal(int64_t n) {
+  std::vector<T> v(n);
+  std::mt19937_64 rng(19);
+  std::uniform_int_distribution<T> lo(1000, 1100);
+  std::uniform_int_distribution<T> hi(900000, 900100);
+  std::uniform_int_distribution<int> pick(0, 9);
+  for (auto& x : v) {
+    x = pick(rng) < 8 ? lo(rng) : hi(rng);
+  }
+  return v;
+}
+
+}  // namespace delta_shapes
+
 // ----------------------------------------------------------------------
 // Helpers
 
@@ -1015,5 +1211,22 @@ REGISTER_DATASET64(PriceMicros, GenPriceMicros)
 REGISTER_DATASET64(SnowflakeId, GenSnowflakeId)
 REGISTER_DATASET64(ByteCount, GenByteCount)
 
+// Columns with structure between neighbouring values (see delta_shapes above),
+// registered at both widths from the same distribution.
+#define REGISTER_DELTA_SHAPE(Name, GenFunc) \
+  REGISTER_DATASET(Name, GenFunc<int32_t>)  \
+  REGISTER_DATASET64(Name, GenFunc<int64_t>)
+
+REGISTER_DELTA_SHAPE(TrendJitter, delta_shapes::GenTrendJitter)
+REGISTER_DELTA_SHAPE(Sawtooth, delta_shapes::GenSawtooth)
+REGISTER_DELTA_SHAPE(MeasurementSeries, delta_shapes::GenMeasurement)
+REGISTER_DELTA_SHAPE(SortedKeys, delta_shapes::GenSortedKeys)
+REGISTER_DELTA_SHAPE(SensorDropouts, delta_shapes::GenSensorDropouts)
+REGISTER_DELTA_SHAPE(IdsWithGaps, delta_shapes::GenIdsWithGaps)
+REGISTER_DELTA_SHAPE(RandomWalk, delta_shapes::GenRandomWalk)
+REGISTER_DELTA_SHAPE(EventMillis, delta_shapes::GenEventMillis)
+REGISTER_DELTA_SHAPE(LowSentinel, delta_shapes::GenLowSentinel)
+REGISTER_DELTA_SHAPE(Bimodal, delta_shapes::GenBimodal)
+
 }  // namespace
 }  // namespace parquet

From 4c02050638c259cc5d544ef7b6e8cac225434e99 Mon Sep 17 00:00:00 2001
From: Prateek Gaur <prateek.gaur@snowflake.com>
Date: Thu, 3 Sep 2026 02:00:54 +0000
Subject: [PATCH 09/27] Reject unprofitable PFOR delta plans early

The delta frame search costs as much as the raw one and is wasted on
uncorrelated data. A strided sample of the differences now gives an
estimate first, and if that estimate cannot beat the raw plan, the full
search does not run.
---
 cpp/src/arrow/util/pfor/pfor_plan_internal.h |  93 +++++++++--
 cpp/src/arrow/util/pfor/pfor_test.cc         | 155 +++++++++++++++++++
 2 files changed, 239 insertions(+), 9 deletions(-)

diff --git a/cpp/src/arrow/util/pfor/pfor_plan_internal.h b/cpp/src/arrow/util/pfor/pfor_plan_internal.h
index c7a0d34e5c0d..a8022336842c 100644
--- a/cpp/src/arrow/util/pfor/pfor_plan_internal.h
+++ b/cpp/src/arrow/util/pfor/pfor_plan_internal.h
@@ -30,6 +30,7 @@
 
 #pragma once
 
+#include <algorithm>
 #include <array>
 #include <bit>
 #include <cstdint>
@@ -396,6 +397,20 @@ struct PforVectorPlan {
   int64_t cost_bits = 0;
 };
 
+/// \brief Map a signed value onto an unsigned one of the same magnitude.
+///
+/// Negative values interleave with positive ones instead of wrapping to the top
+/// of the range, so a small negative difference needs few bits rather than all
+/// of them. Used only by the estimate below; nothing on the wire is zigzagged.
+template <typename T>
+typename PforTypeTraits<T>::UnsignedType ZigZag(T value) {
+  using UnsignedT = typename PforTypeTraits<T>::UnsignedType;
+  constexpr int kBits = static_cast<int>(sizeof(T)) * 8;
+  const auto u = static_cast<UnsignedT>(value);
+  const UnsignedT sign_mask = UnsignedT{0} - (u >> (kBits - 1));
+  return static_cast<UnsignedT>((u << 1) ^ sign_mask);
+}
+
 /// \brief Fill `deltas` with the backward differences of `values`.
 ///
 /// deltas[0] is 0: the first value travels in the plan's start_value, and
@@ -423,6 +438,59 @@ void ComputeDeltas(const T* values, int32_t num_elements, T* deltas, MinMax<T>*
   }
 }
 
+/// \brief Estimate what packing the differences of `values` would cost, in bits.
+///
+/// The full decision needs the differences written out and searched, which is
+/// most of what encoding a vector costs. This reaches an answer good enough to
+/// decline the mode from a strided sample, without writing anything.
+///
+/// The sample is of widths, not of a span. A gate on the span of the
+/// differences was tried first and had to go: the sawtooth is a tight cluster
+/// of small positive differences with a handful of large negative ones, so its
+/// span is as wide as its raw span while its cost is a fraction of it. Feeding
+/// widths to the same cost model the search uses keeps that shape, because the
+/// model can trade a wide bin against a patch.
+///
+/// Zigzagging is what lets a histogram stand in for a frame search that has not
+/// run. Differences in [-k, k] zigzag into [0, 2k], and a frame at -k maps them
+/// onto the same [0, 2k], so for a range that straddles zero evenly the
+/// estimated width is the width the search would find. Where the range leans
+/// one way the estimate runs a bit or two wide.
+template <typename T>
+int64_t EstimateDeltaCostBits(const T* values, int32_t num_elements) {
+  using UnsignedT = typename PforTypeTraits<T>::UnsignedType;
+  // Enough of a sample to place a distribution across the width bins, and few
+  // enough that the pass is a fraction of the one it is deciding against.
+  constexpr int32_t kSampleTarget = 128;
+  const int32_t stride = std::max(1, num_elements / kSampleTarget);
+
+  // Four accumulators, as in the histogram passes above: most columns send
+  // nearly every difference to one bin, and one array would serialize on it.
+  std::array<std::array<int32_t, 65>, 4> h{};
+  int32_t sampled = 0;
+  for (int32_t i = stride; i < num_elements; i += stride) {
+    const UnsignedT d =
+        static_cast<UnsignedT>(values[i]) - static_cast<UnsignedT>(values[i - 1]);
+    T signed_delta;
+    std::memcpy(&signed_delta, &d, sizeof(T));
+    ++h[sampled & 3][PforTypeTraits<T>::BitsRequired(ZigZag<T>(signed_delta))];
+    ++sampled;
+  }
+  if (sampled == 0) return 0;
+
+  std::array<int32_t, 65> histogram{};
+  for (int b = 0; b <= 64; ++b) {
+    histogram[b] = h[0][b] + h[1][b] + h[2][b] + h[3][b];
+  }
+  int64_t sample_cost = 0;
+  BestWidthFromHistogram<T>(histogram, sampled, &sample_cost);
+
+  // Scale to the whole vector. Both terms of the model are per-element -- a
+  // width costs its bits every element, an exception costs its slot every time
+  // it occurs -- so the sample cost scales with the count.
+  return sample_cost * num_elements / sampled;
+}
+
 /// \brief Decide how to encode one vector.
 ///
 /// \param[in] values the vector
@@ -450,21 +518,28 @@ PforVectorPlan<T> ChooseVectorPlan(const T* values, int32_t num_elements,
   // width 0 cannot be improved on.
   if (num_elements < 2 || raw.bit_width == 0) return plan;
 
+  // A delta vector carries its own first value, so it starts one full-width
+  // value behind whatever its differences pack to.
+  const int64_t start_value_bits = static_cast<int64_t>(sizeof(T)) * 8;
+
+  // Estimate the mode before paying for it, and drop it here if the estimate
+  // cannot reach the incumbent. What is skipped is the whole of the rest of the
+  // mode: the pass that writes the differences out, and the frame search over
+  // them. The estimate is deliberately loose, so it declines only where the two
+  // modes are more than a sampling error apart -- which is where the choice
+  // matters least.
+  if (EstimateDeltaCostBits<T>(values, num_elements) + start_value_bits >=
+      plan.cost_bits) {
+    return plan;
+  }
+
   MinMax<T> delta_bounds;
   ComputeDeltas<T>(values, num_elements, delta_scratch, &delta_bounds);
 
-  // Both candidates get the full search. A cheaper gate on the spread of the
-  // differences was tried first and had to go: the sawtooth is a tight cluster
-  // of small positive differences with a handful of large negative ones, so its
-  // span is as wide as the raw span while its cost is a fraction of it. Any
-  // gate that reads a span rather than a distribution throws away the one shape
-  // the mode is here for.
   const FrameChoice<T> delta =
       ChooseFrameAndWidth<T>(delta_scratch, num_elements, delta_bounds);
 
-  // A delta vector carries its own first value, so it starts one full-width
-  // value behind.
-  const int64_t delta_cost = delta.cost_bits + static_cast<int64_t>(sizeof(T)) * 8;
+  const int64_t delta_cost = delta.cost_bits + start_value_bits;
   if (delta_cost < plan.cost_bits) {
     plan.delta = true;
     plan.frame_of_reference = delta.frame_of_reference;
diff --git a/cpp/src/arrow/util/pfor/pfor_test.cc b/cpp/src/arrow/util/pfor/pfor_test.cc
index e7331aa1a6ae..c6f63e565dcc 100644
--- a/cpp/src/arrow/util/pfor/pfor_test.cc
+++ b/cpp/src/arrow/util/pfor/pfor_test.cc
@@ -1057,4 +1057,159 @@ TYPED_TEST(PforTest, DeltaHandlesVectorsTooShortToDifference) {
       std::vector<T>{std::numeric_limits<T>::max(), std::numeric_limits<T>::min()});
 }
 
+namespace {
+
+/// A named column shape, for the gate test below.
+template <typename T>
+struct NamedColumn {
+  std::string name;
+  std::vector<T> values;
+};
+
+/// The distributions in pfor_benchmark.cc, plus the extremes, as one battery.
+/// Anything that changes the encoder's mind about differencing has to be seen
+/// on one of these or it is not being tested.
+template <typename T>
+std::vector<NamedColumn<T>> DeltaDecisionColumns() {
+  constexpr int32_t kN = static_cast<int32_t>(PforConstants::kPforVectorSize);
+  using UnsignedT = typename PforTypeTraits<T>::UnsignedType;
+  std::vector<NamedColumn<T>> columns;
+  auto add = [&columns](std::string name, std::vector<T> values) {
+    columns.push_back({std::move(name), std::move(values)});
+  };
+  auto make = [](auto fn) {
+    std::vector<T> v(kN);
+    for (int32_t i = 0; i < kN; ++i) v[i] = fn(i);
+    return v;
+  };
+
+  add("constant", std::vector<T>(kN, static_cast<T>(-7)));
+  add("ascending", make([](int32_t i) { return static_cast<T>(1'000'000 + i); }));
+  add("descending", make([](int32_t i) { return static_cast<T>(1'000'000 - i); }));
+  add("monotonic_with_gaps", make([](int32_t i) {
+        return static_cast<T>(500'000 + i * 3 + (i % 64 == 0 ? 4096 : 0));
+      }));
+  add("timestamps",
+      make([](int32_t i) { return static_cast<T>(1'700'000'000 + i * 17 + (i % 7)); }));
+  // A ramp that resets: small positive differences with a handful of large
+  // negative ones. The shape the two-sided frame exists for.
+  add("sawtooth",
+      make([](int32_t i) { return static_cast<T>((i % 200) * 13 + 100'000); }));
+  add("cluster_far_from_zero",
+      make([](int32_t i) { return static_cast<T>(1'000'000 + (i % 37)); }));
+  add("two_clusters", make([](int32_t i) {
+        return static_cast<T>(i % 2 == 0 ? 100 + (i % 8) : 900'000 + (i % 8));
+      }));
+  add("cluster_with_outliers", make([](int32_t i) {
+        return static_cast<T>(i % 97 == 0 ? 1'000'000 + i : 500 + (i % 11));
+      }));
+  add("type_extremes", make([](int32_t i) {
+        return i % 2 == 0 ? std::numeric_limits<T>::lowest() + static_cast<T>(i)
+                          : std::numeric_limits<T>::max() - static_cast<T>(i);
+      }));
+  // A random walk, and independent draws at several spreads. The walk is where
+  // differencing pays; the draws are where it must be declined.
+  for (uint32_t seed : {1u, 7u, 42u, 1234u}) {
+    std::mt19937 rng(seed);
+    std::uniform_int_distribution<int32_t> step(-40, 40);
+    auto walk = static_cast<UnsignedT>(0);
+    std::vector<T> values(kN);
+    for (int32_t i = 0; i < kN; ++i) {
+      walk += static_cast<UnsignedT>(static_cast<T>(step(rng)));
+      std::memcpy(&values[i], &walk, sizeof(T));
+    }
+    add("random_walk_" + std::to_string(seed), std::move(values));
+  }
+  for (T spread : {static_cast<T>(1), static_cast<T>(1000), static_cast<T>(1'000'000)}) {
+    for (uint32_t seed : {3u, 99u}) {
+      std::vector<T> values(kN);
+      std::mt19937 rng(seed);
+      std::uniform_int_distribution<T> dist(static_cast<T>(0), spread);
+      for (auto& v : values) v = dist(rng);
+      add("noise_" + std::to_string(static_cast<int64_t>(spread)) + "_" +
+              std::to_string(seed),
+          std::move(values));
+    }
+  }
+  return columns;
+}
+
+/// What ChooseVectorPlan would decide with no gate in front of the delta
+/// search: cost both modes properly and keep the cheaper.
+template <typename T>
+PforVectorPlan<T> ChooseVectorPlanUngated(const T* values, int32_t num_elements,
+                                          T* delta_scratch) {
+  const FrameChoice<T> raw = ChooseFrameAndWidth<T>(values, num_elements);
+  PforVectorPlan<T> plan;
+  plan.frame_of_reference = raw.frame_of_reference;
+  plan.bit_width = raw.bit_width;
+  plan.num_exceptions = raw.num_exceptions;
+  plan.cost_bits = raw.cost_bits;
+  if (num_elements < 2 || raw.bit_width == 0) return plan;
+
+  MinMax<T> delta_bounds;
+  ComputeDeltas<T>(values, num_elements, delta_scratch, &delta_bounds);
+  const FrameChoice<T> delta =
+      ChooseFrameAndWidth<T>(delta_scratch, num_elements, delta_bounds);
+  const int64_t delta_cost = delta.cost_bits + static_cast<int64_t>(sizeof(T)) * 8;
+  if (delta_cost < plan.cost_bits) {
+    plan.delta = true;
+    plan.frame_of_reference = delta.frame_of_reference;
+    plan.start_value = values[0];
+    plan.bit_width = delta.bit_width;
+    plan.num_exceptions = delta.num_exceptions;
+    plan.cost_bits = delta_cost;
+  }
+  return plan;
+}
+
+}  // namespace
+
+// The gate in front of the delta search is an estimate, so it can in principle
+// decline a vector the search would have won. Pin that it does not, on every
+// shape the encoder is meant to handle: same mode, same width, same cost as the
+// ungated chooser. A change that makes the estimate too pessimistic shows up
+// here as a lost delta rather than as a silent ratio regression.
+TYPED_TEST(PforTest, DeltaGateAgreesWithTheUngatedChooser) {
+  using T = TypeParam;
+  int delta_chosen = 0;
+  for (const auto& column : DeltaDecisionColumns<T>()) {
+    SCOPED_TRACE(column.name);
+    const auto n = static_cast<int32_t>(column.values.size());
+    std::vector<T> scratch(n);
+    const PforVectorPlan<T> gated =
+        ChooseVectorPlan<T>(column.values.data(), n, scratch.data());
+    const PforVectorPlan<T> ungated =
+        ChooseVectorPlanUngated<T>(column.values.data(), n, scratch.data());
+
+    EXPECT_EQ(ungated.delta, gated.delta);
+    EXPECT_EQ(ungated.cost_bits, gated.cost_bits);
+    EXPECT_EQ(ungated.bit_width, gated.bit_width);
+    EXPECT_EQ(ungated.frame_of_reference, gated.frame_of_reference);
+    EXPECT_EQ(ungated.num_exceptions, gated.num_exceptions);
+    if (gated.delta) ++delta_chosen;
+  }
+  // The battery has to exercise both answers, or the agreement above is only
+  // evidence that the gate declines everything.
+  EXPECT_GT(delta_chosen, 0);
+}
+
+// The estimate is the point of the gate, so check it reaches the shape it was
+// built for. A gate reading the spread of the differences rather than their
+// distribution declines the sawtooth, whose differences are as widely spread as
+// its values and far cheaper to pack.
+TYPED_TEST(PforTest, DeltaGateAdmitsTheSawtooth) {
+  using T = TypeParam;
+  constexpr int32_t kN = static_cast<int32_t>(PforConstants::kPforVectorSize);
+  std::vector<T> values(kN);
+  for (int32_t i = 0; i < kN; ++i) {
+    values[i] = static_cast<T>((i % 200) * 13 + 100'000);
+  }
+  std::vector<T> scratch(kN);
+  const PforVectorPlan<T> plan = ChooseVectorPlan<T>(values.data(), kN, scratch.data());
+  EXPECT_TRUE(plan.delta);
+  // Five resets in 1024 values, patched, leaving a very narrow packed window.
+  EXPECT_LE(plan.bit_width, 5);
+}
+
 }  // namespace arrow::util::pfor

From 4fd7ac7cc969d207eb53a996a3eed044b853d682 Mon Sep 17 00:00:00 2001
From: Prateek Gaur <prateek.gaur@snowflake.com>
Date: Thu, 3 Sep 2026 02:18:51 +0000
Subject: [PATCH 10/27] Gate PFOR and delta mode with writer properties

PFOR is a Preview encoding, so a writer has to opt in before it is
emitted. Delta planning has its own per-column switch on top of that.
Readers accept either form regardless.
---
 cpp/src/arrow/util/pfor/pfor.cc               |   6 +-
 cpp/src/arrow/util/pfor/pfor_internal.h       |  14 +-
 cpp/src/arrow/util/pfor/pfor_plan_internal.h  |   5 +-
 cpp/src/arrow/util/pfor/pfor_test.cc          |   6 +-
 cpp/src/arrow/util/pfor/pfor_wrapper.cc       |   9 +-
 .../arrow/util/pfor/pfor_wrapper_internal.h   |   6 +-
 cpp/src/parquet/arrow/arrow_encoding_test.cc  |  54 +++++-
 cpp/src/parquet/column_writer.cc              |   2 +-
 cpp/src/parquet/column_writer_test.cc         |   4 +
 cpp/src/parquet/encoder.cc                    |  23 ++-
 cpp/src/parquet/encoding.h                    |  15 +-
 cpp/src/parquet/properties.cc                 |  17 ++
 cpp/src/parquet/properties.h                  | 182 +++++++++++++++++-
 cpp/src/parquet/properties_test.cc            | 142 ++++++++++++++
 14 files changed, 456 insertions(+), 29 deletions(-)

diff --git a/cpp/src/arrow/util/pfor/pfor.cc b/cpp/src/arrow/util/pfor/pfor.cc
index f66eb3106575..bb0b45bbe461 100644
--- a/cpp/src/arrow/util/pfor/pfor.cc
+++ b/cpp/src/arrow/util/pfor/pfor.cc
@@ -81,7 +81,8 @@ BitWidthResult PforCompression<T>::FindOptimalBitWidth(const UnsignedT* deltas,
 
 template <typename T>
 PforEncodedVector<T> PforCompression<T>::EncodeVector(const T* values,
-                                                      int32_t num_elements) {
+                                                      int32_t num_elements,
+                                                      const PforEncodeOptions& options) {
   ARROW_DCHECK(num_elements > 0);
 
   // One scratch buffer serves both stages. ChooseVectorPlan fills it with the
@@ -98,7 +99,8 @@ PforEncodedVector<T> PforCompression<T>::EncodeVector(const T* values,
     scratch = heap_scratch.data();
   }
 
-  const PforVectorPlan<T> plan = ChooseVectorPlan<T>(values, num_elements, scratch);
+  const PforVectorPlan<T> plan =
+      ChooseVectorPlan<T>(values, num_elements, scratch, options.delta_enabled);
   const T* source = plan.delta ? scratch : values;
 
   PforEncodedVector<T> result;
diff --git a/cpp/src/arrow/util/pfor/pfor_internal.h b/cpp/src/arrow/util/pfor/pfor_internal.h
index af7dd9168a80..4d756f9b126e 100644
--- a/cpp/src/arrow/util/pfor/pfor_internal.h
+++ b/cpp/src/arrow/util/pfor/pfor_internal.h
@@ -204,6 +204,16 @@ class PforEncodedVector {
 // ----------------------------------------------------------------------
 // Core compression/decompression
 
+/// \brief What the encoder is allowed to do, for one page.
+///
+/// Nothing here changes how a page is read: a decoder is told which mode each
+/// vector used by the vector's own header, so turning a mode off only narrows
+/// what the encoder will choose, and pages written either way read the same.
+struct PforEncodeOptions {
+  /// Let the planner difference a vector when its cost model prefers that.
+  bool delta_enabled = true;
+};
+
 /// \brief PFOR compression and decompression algorithms
 ///
 /// \tparam T the integer type (int32_t or int64_t)
@@ -230,9 +240,11 @@ class ARROW_EXPORT PforCompression {
   ///
   /// \param[in] values input integer values
   /// \param[in] num_elements number of elements (up to vector_size)
+  /// \param[in] options what the encoder is allowed to choose
   /// \pre num_elements > 0; there is no frame of reference for an empty vector
   /// \return the encoded vector with all sections
-  static PforEncodedVector<T> EncodeVector(const T* values, int32_t num_elements);
+  static PforEncodedVector<T> EncodeVector(const T* values, int32_t num_elements,
+                                           const PforEncodeOptions& options = {});
 
   /// \brief Decode a single vector from compressed data
   ///
diff --git a/cpp/src/arrow/util/pfor/pfor_plan_internal.h b/cpp/src/arrow/util/pfor/pfor_plan_internal.h
index a8022336842c..2c530906a644 100644
--- a/cpp/src/arrow/util/pfor/pfor_plan_internal.h
+++ b/cpp/src/arrow/util/pfor/pfor_plan_internal.h
@@ -498,13 +498,14 @@ int64_t EstimateDeltaCostBits(const T* values, int32_t num_elements) {
 /// \param[out] delta_scratch scratch for num_elements differences; on return it
 ///             holds the differences if the plan chose the delta mode, and is
 ///             clobbered either way
+/// \param[in] delta_enabled whether the delta mode may be chosen at all
 ///
 /// Both transforms are costed with the same model and the cheaper one wins, so
 /// the mode is a per-vector decision. It has to be: differencing loses 6-19% on
 /// every unclustered draw, and a column is rarely all one shape.
 template <typename T>
 PforVectorPlan<T> ChooseVectorPlan(const T* values, int32_t num_elements,
-                                   T* delta_scratch) {
+                                   T* delta_scratch, bool delta_enabled) {
   const FrameChoice<T> raw = ChooseFrameAndWidth<T>(values, num_elements);
 
   PforVectorPlan<T> plan;
@@ -516,7 +517,7 @@ PforVectorPlan<T> ChooseVectorPlan(const T* values, int32_t num_elements,
 
   // One element has no difference to take, and a vector already packing at
   // width 0 cannot be improved on.
-  if (num_elements < 2 || raw.bit_width == 0) return plan;
+  if (!delta_enabled || num_elements < 2 || raw.bit_width == 0) return plan;
 
   // A delta vector carries its own first value, so it starts one full-width
   // value behind whatever its differences pack to.
diff --git a/cpp/src/arrow/util/pfor/pfor_test.cc b/cpp/src/arrow/util/pfor/pfor_test.cc
index c6f63e565dcc..a5a9d5c56199 100644
--- a/cpp/src/arrow/util/pfor/pfor_test.cc
+++ b/cpp/src/arrow/util/pfor/pfor_test.cc
@@ -1178,7 +1178,8 @@ TYPED_TEST(PforTest, DeltaGateAgreesWithTheUngatedChooser) {
     const auto n = static_cast<int32_t>(column.values.size());
     std::vector<T> scratch(n);
     const PforVectorPlan<T> gated =
-        ChooseVectorPlan<T>(column.values.data(), n, scratch.data());
+        ChooseVectorPlan<T>(column.values.data(), n, scratch.data(),
+                            /*delta_enabled=*/true);
     const PforVectorPlan<T> ungated =
         ChooseVectorPlanUngated<T>(column.values.data(), n, scratch.data());
 
@@ -1206,7 +1207,8 @@ TYPED_TEST(PforTest, DeltaGateAdmitsTheSawtooth) {
     values[i] = static_cast<T>((i % 200) * 13 + 100'000);
   }
   std::vector<T> scratch(kN);
-  const PforVectorPlan<T> plan = ChooseVectorPlan<T>(values.data(), kN, scratch.data());
+  const PforVectorPlan<T> plan =
+      ChooseVectorPlan<T>(values.data(), kN, scratch.data(), /*delta_enabled=*/true);
   EXPECT_TRUE(plan.delta);
   // Five resets in 1024 values, patched, leaving a very narrow packed window.
   EXPECT_LE(plan.bit_width, 5);
diff --git a/cpp/src/arrow/util/pfor/pfor_wrapper.cc b/cpp/src/arrow/util/pfor/pfor_wrapper.cc
index 0e1fadc5a650..65dbafe4a511 100644
--- a/cpp/src/arrow/util/pfor/pfor_wrapper.cc
+++ b/cpp/src/arrow/util/pfor/pfor_wrapper.cc
@@ -153,7 +153,8 @@ Result<typename PforWrapper<T>::PforHeader> PforWrapper<T>::LoadHeader(
 
 template <typename T>
 Status PforWrapper<T>::Encode(const T* values, int32_t num_values, int32_t vector_size,
-                              uint8_t* comp, int64_t* comp_size) {
+                              uint8_t* comp, int64_t* comp_size,
+                              const PforEncodeOptions& options) {
   if (num_values < 0) {
     return Status::Invalid("PFOR num_values must be non-negative: ", num_values);
   }
@@ -220,7 +221,7 @@ Status PforWrapper<T>::Encode(const T* values, int32_t num_values, int32_t vecto
     int32_t elements_in_vector = std::min(vector_size, num_values - start_idx);
 
     auto encoded =
-        PforCompression<T>::EncodeVector(values + start_idx, elements_in_vector);
+        PforCompression<T>::EncodeVector(values + start_idx, elements_in_vector, options);
 
     // Serialize to output
     ARROW_ASSIGN_OR_RAISE(
@@ -237,8 +238,8 @@ Status PforWrapper<T>::Encode(const T* values, int32_t num_values, int32_t vecto
 
 template <typename T>
 Status PforWrapper<T>::Encode(const T* values, int32_t num_values, uint8_t* comp,
-                              int64_t* comp_size) {
-  return Encode(values, num_values, kVectorSize, comp, comp_size);
+                              int64_t* comp_size, const PforEncodeOptions& options) {
+  return Encode(values, num_values, kVectorSize, comp, comp_size, options);
 }
 
 // ----------------------------------------------------------------------
diff --git a/cpp/src/arrow/util/pfor/pfor_wrapper_internal.h b/cpp/src/arrow/util/pfor/pfor_wrapper_internal.h
index 02a422e3b62e..dbcdcd265a3e 100644
--- a/cpp/src/arrow/util/pfor/pfor_wrapper_internal.h
+++ b/cpp/src/arrow/util/pfor/pfor_wrapper_internal.h
@@ -94,13 +94,15 @@ class ARROW_EXPORT PforWrapper {
   /// \param[in,out] comp_size input: available buffer size, which must be at
   ///                least GetMaxCompressedSize(num_values, vector_size);
   ///                output: bytes written
+  /// \param[in] options what the encoder is allowed to choose
   /// \return Status::OK on success, or an error if the arguments are invalid
   static Status Encode(const T* values, int32_t num_values, int32_t vector_size,
-                       uint8_t* comp, int64_t* comp_size);
+                       uint8_t* comp, int64_t* comp_size,
+                       const PforEncodeOptions& options = {});
 
   /// Convenience overload with default vector_size = kPforVectorSize
   static Status Encode(const T* values, int32_t num_values, uint8_t* comp,
-                       int64_t* comp_size);
+                       int64_t* comp_size, const PforEncodeOptions& options = {});
 
   /// \brief Decode a PFOR-compressed page
   ///
diff --git a/cpp/src/parquet/arrow/arrow_encoding_test.cc b/cpp/src/parquet/arrow/arrow_encoding_test.cc
index 1adec93341ea..f1ff50a9c1ec 100644
--- a/cpp/src/parquet/arrow/arrow_encoding_test.cc
+++ b/cpp/src/parquet/arrow/arrow_encoding_test.cc
@@ -100,6 +100,7 @@ class ParquetPforEncodingTest : public ::testing::Test {
                          int64_t row_group_size = -1) {
     auto writer_props = WriterProperties::Builder()
                             .disable_dictionary()
+                            ->enable_pfor_encoding()
                             ->encoding(Encoding::PFOR)
                             ->build();
 
@@ -116,6 +117,7 @@ class ParquetPforEncodingTest : public ::testing::Test {
                                Compression::type compression) {
     auto writer_props = WriterProperties::Builder()
                             .disable_dictionary()
+                            ->enable_pfor_encoding()
                             ->encoding(Encoding::PFOR)
                             ->compression(compression)
                             ->build();
@@ -166,6 +168,7 @@ TEST_F(ParquetPforEncodingTest, MixedTypesWithInt32Int64) {
   // PFOR takes only the two integer columns; the rest keep their defaults.
   auto writer_props = WriterProperties::Builder()
                           .disable_dictionary()
+                          ->enable_pfor_encoding()
                           ->encoding("id", Encoding::PFOR)
                           ->encoding("count", Encoding::PFOR)
                           ->build();
@@ -337,8 +340,11 @@ TEST_F(ParquetPforEncodingTest, VerifyPforEncodingUsed) {
   }
   auto table = TableOf<::arrow::Int64Type>(::arrow::int64(), values);
 
-  auto writer_props =
-      WriterProperties::Builder().disable_dictionary()->encoding(Encoding::PFOR)->build();
+  auto writer_props = WriterProperties::Builder()
+                          .disable_dictionary()
+                          ->enable_pfor_encoding()
+                          ->encoding(Encoding::PFOR)
+                          ->build();
 
   auto sink = CreateOutputStream();
   ASSERT_OK(WriteTable(*table, ::arrow::default_memory_pool(), sink, table->num_rows(),
@@ -366,8 +372,11 @@ TEST_F(ParquetPforEncodingTest, ReadInSmallBatches) {
   auto schema = ::arrow::schema({::arrow::field("values", ::arrow::int32())});
   auto table = Table::Make(schema, {std::make_shared<ChunkedArray>(array)});
 
-  auto writer_props =
-      WriterProperties::Builder().disable_dictionary()->encoding(Encoding::PFOR)->build();
+  auto writer_props = WriterProperties::Builder()
+                          .disable_dictionary()
+                          ->enable_pfor_encoding()
+                          ->encoding(Encoding::PFOR)
+                          ->build();
 
   auto sink = CreateOutputStream();
   ASSERT_OK(WriteTable(*table, ::arrow::default_memory_pool(), sink, table->num_rows(),
@@ -387,6 +396,43 @@ TEST_F(ParquetPforEncodingTest, ReadInSmallBatches) {
       ::arrow::AssertTablesEqual(*table, *result, /*same_chunk_layout=*/false));
 }
 
+// Verify that the per-column delta option reduces this column's encoded size
+// without changing its values.
+TEST_F(ParquetPforEncodingTest, DeltaModeCanBeTurnedOffPerColumn) {
+  // A long arithmetic run: undifferenced it needs enough bits to cover the whole
+  // span, differenced it is a constant and needs none.
+  std::vector<int64_t> values(4096);
+  for (size_t i = 0; i < values.size(); ++i) {
+    values[i] = 3'000'000'000'000LL + static_cast<int64_t>(i) * 7;
+  }
+  auto table = TableOf<::arrow::Int64Type>(::arrow::int64(), values);
+
+  auto size_of = [&](bool delta_enabled) {
+    auto builder = WriterProperties::Builder();
+    builder.disable_dictionary()
+        ->enable_pfor_encoding()
+        ->encoding(Encoding::PFOR)
+        ->disable_statistics();
+    if (!delta_enabled) {
+      builder.disable_pfor_delta_encoding("values");
+    }
+    std::shared_ptr<Table> result;
+    std::shared_ptr<Buffer> file;
+    DoRoundtrip(table, table->num_rows(), &result, builder.build(), &file);
+    ::arrow::AssertTablesEqual(*table, *result);
+
+    auto metadata =
+        ParquetFileReader::Open(std::make_shared<BufferReader>(file))->metadata();
+    return metadata->RowGroup(0)->ColumnChunk(0)->total_uncompressed_size();
+  };
+
+  const int64_t with_delta = size_of(/*delta_enabled=*/true);
+  const int64_t without_delta = size_of(/*delta_enabled=*/false);
+  EXPECT_LT(with_delta, without_delta)
+      << "disable_pfor_delta_encoding did not reach the encoder: " << with_delta
+      << " bytes with the mode on, " << without_delta << " with it off";
+}
+
 }  // namespace
 }  // namespace arrow
 }  // namespace parquet
diff --git a/cpp/src/parquet/column_writer.cc b/cpp/src/parquet/column_writer.cc
index 653f28f64bde..d17949659ef5 100644
--- a/cpp/src/parquet/column_writer.cc
+++ b/cpp/src/parquet/column_writer.cc
@@ -1290,7 +1290,7 @@ class TypedColumnWriterImpl : public ColumnWriterImpl,
       : ColumnWriterImpl(metadata, std::move(pager), use_dictionary, encoding,
                          properties) {
     current_encoder_ = MakeEncoder(ParquetType::type_num, encoding, use_dictionary,
-                                   descr_, properties->memory_pool());
+                                   descr_, properties->memory_pool(), properties);
     // We have to dynamic_cast as some compilers don't want to static_cast
     // through virtual inheritance.
     current_value_encoder_ =
diff --git a/cpp/src/parquet/column_writer_test.cc b/cpp/src/parquet/column_writer_test.cc
index d4b183305da4..dd8e5198b89a 100644
--- a/cpp/src/parquet/column_writer_test.cc
+++ b/cpp/src/parquet/column_writer_test.cc
@@ -122,6 +122,10 @@ class TestPrimitiveWriter : public PrimitiveTypedTest<TestType> {
       wp_builder.dictionary_pagesize_limit(DICTIONARY_PAGE_SIZE);
     } else {
       wp_builder.disable_dictionary();
+      if (column_properties.encoding() == Encoding::PFOR) {
+        // PFOR is opt-in because it is a Preview feature in the format.
+        wp_builder.enable_pfor_encoding();
+      }
       wp_builder.encoding(column_properties.encoding());
     }
     if (enable_checksum) {
diff --git a/cpp/src/parquet/encoder.cc b/cpp/src/parquet/encoder.cc
index ce675a2dfb4c..414e127c2299 100644
--- a/cpp/src/parquet/encoder.cc
+++ b/cpp/src/parquet/encoder.cc
@@ -48,6 +48,7 @@
 
 #include "parquet/exception.h"
 #include "parquet/platform.h"
+#include "parquet/properties.h"
 #include "parquet/schema.h"
 #include "parquet/types.h"
 
@@ -1800,8 +1801,9 @@ class PforEncoder : public EncoderImpl, virtual public TypedEncoder<DType> {
   using T = typename DType::c_type;
   using TypedEncoder<DType>::Put;
 
-  explicit PforEncoder(const ColumnDescriptor* descr, MemoryPool* pool)
-      : EncoderImpl(descr, Encoding::PFOR, pool), pool_(pool) {}
+  PforEncoder(const ColumnDescriptor* descr, MemoryPool* pool,
+              const ::arrow::util::pfor::PforEncodeOptions& options)
+      : EncoderImpl(descr, Encoding::PFOR, pool), pool_(pool), options_(options) {}
 
   std::shared_ptr<Buffer> FlushValues() override {
     // An all-null optional page adds no values and is still written, so an empty
@@ -1816,7 +1818,7 @@ class PforEncoder : public EncoderImpl, virtual public TypedEncoder<DType> {
 
     int64_t comp_size = max_size;
     PARQUET_THROW_NOT_OK(::arrow::util::pfor::PforWrapper<T>::Encode(
-        values_.data(), num_values, buffer->mutable_data(), &comp_size));
+        values_.data(), num_values, buffer->mutable_data(), &comp_size, options_));
 
     PARQUET_THROW_NOT_OK(buffer->Resize(comp_size));
     values_.clear();
@@ -1861,6 +1863,7 @@ class PforEncoder : public EncoderImpl, virtual public TypedEncoder<DType> {
 
  private:
   MemoryPool* pool_;
+  ::arrow::util::pfor::PforEncodeOptions options_;
   std::vector<T> values_;
 };
 
@@ -1869,7 +1872,8 @@ class PforEncoder : public EncoderImpl, virtual public TypedEncoder<DType> {
 
 std::unique_ptr<Encoder> MakeEncoder(Type::type type_num, Encoding::type encoding,
                                      bool use_dictionary, const ColumnDescriptor* descr,
-                                     MemoryPool* pool) {
+                                     MemoryPool* pool,
+                                     const WriterProperties* properties) {
   if (use_dictionary) {
     switch (type_num) {
       case Type::INT32:
@@ -1964,11 +1968,18 @@ std::unique_ptr<Encoder> MakeEncoder(Type::type type_num, Encoding::type encodin
             "DELTA_BYTE_ARRAY only supports BYTE_ARRAY and FIXED_LEN_BYTE_ARRAY");
     }
   } else if (encoding == Encoding::PFOR) {
+    // The delta mode is a per-column option, so it is read off the properties
+    // rather than baked into the encoder. A caller with no properties to hand --
+    // the encoding tests, and MakeTypedEncoder's default -- gets the default.
+    ::arrow::util::pfor::PforEncodeOptions options;
+    if (properties != nullptr && descr != nullptr) {
+      options.delta_enabled = properties->pfor_delta_enabled(descr->path());
+    }
     switch (type_num) {
       case Type::INT32:
-        return std::make_unique<PforEncoder<Int32Type>>(descr, pool);
+        return std::make_unique<PforEncoder<Int32Type>>(descr, pool, options);
       case Type::INT64:
-        return std::make_unique<PforEncoder<Int64Type>>(descr, pool);
+        return std::make_unique<PforEncoder<Int64Type>>(descr, pool, options);
       default:
         throw ParquetException("PFOR encoder only supports INT32 and INT64");
     }
diff --git a/cpp/src/parquet/encoding.h b/cpp/src/parquet/encoding.h
index e3de4f2aa60b..cdfff30c2f33 100644
--- a/cpp/src/parquet/encoding.h
+++ b/cpp/src/parquet/encoding.h
@@ -35,6 +35,8 @@ class Dictionary32Builder;
 
 namespace parquet {
 
+class WriterProperties;
+
 template <typename DType>
 class TypedEncoder;
 
@@ -418,20 +420,27 @@ class FLBADecoder : virtual public TypedDecoder<FLBAType> {
   // then perhaps not
 };
 
+/// \brief Construct an encoder.
+///
+/// \param[in] properties the writer properties, consulted for the options an
+///            encoding offers per column. May be null, in which case every such
+///            option takes its default.
 PARQUET_EXPORT
 std::unique_ptr<Encoder> MakeEncoder(
     Type::type type_num, Encoding::type encoding, bool use_dictionary = false,
     const ColumnDescriptor* descr = NULLPTR,
-    ::arrow::MemoryPool* pool = ::arrow::default_memory_pool());
+    ::arrow::MemoryPool* pool = ::arrow::default_memory_pool(),
+    const WriterProperties* properties = NULLPTR);
 
 template <typename DType>
 std::unique_ptr<typename EncodingTraits<DType>::Encoder> MakeTypedEncoder(
     Encoding::type encoding, bool use_dictionary = false,
     const ColumnDescriptor* descr = NULLPTR,
-    ::arrow::MemoryPool* pool = ::arrow::default_memory_pool()) {
+    ::arrow::MemoryPool* pool = ::arrow::default_memory_pool(),
+    const WriterProperties* properties = NULLPTR) {
   using OutType = typename EncodingTraits<DType>::Encoder;
   std::unique_ptr<Encoder> base =
-      MakeEncoder(DType::type_num, encoding, use_dictionary, descr, pool);
+      MakeEncoder(DType::type_num, encoding, use_dictionary, descr, pool, properties);
   return std::unique_ptr<OutType>(dynamic_cast<OutType*>(base.release()));
 }
 
diff --git a/cpp/src/parquet/properties.cc b/cpp/src/parquet/properties.cc
index 6e3cfddd7bb8..06e7da4acf90 100644
--- a/cpp/src/parquet/properties.cc
+++ b/cpp/src/parquet/properties.cc
@@ -91,6 +91,23 @@ void WriterProperties::Builder::CopyColumnSpecificProperties(
       }
     }
 
+    if (col_props.pfor_enabled() != default_column_properties_.pfor_enabled()) {
+      if (col_props.pfor_enabled()) {
+        this->enable_pfor_encoding(col_path);
+      } else {
+        this->disable_pfor_encoding(col_path);
+      }
+    }
+
+    if (col_props.pfor_delta_enabled() !=
+        default_column_properties_.pfor_delta_enabled()) {
+      if (col_props.pfor_delta_enabled()) {
+        this->enable_pfor_delta_encoding(col_path);
+      } else {
+        this->disable_pfor_delta_encoding(col_path);
+      }
+    }
+
     if (col_props.compression() != default_column_properties_.compression()) {
       this->compression(col_path, col_props.compression());
     }
diff --git a/cpp/src/parquet/properties.h b/cpp/src/parquet/properties.h
index e2244a1176e3..76a9b4833c48 100644
--- a/cpp/src/parquet/properties.h
+++ b/cpp/src/parquet/properties.h
@@ -168,6 +168,17 @@ static constexpr Encoding::type DEFAULT_ENCODING = Encoding::UNKNOWN;
 static const char DEFAULT_CREATED_BY[] = CREATED_BY_VERSION;
 static constexpr Compression::type DEFAULT_COMPRESSION_TYPE = Compression::UNCOMPRESSED;
 static constexpr bool DEFAULT_IS_PAGE_INDEX_ENABLED = true;
+
+/// PFOR is a Preview feature in the Parquet format, so writers must not emit it
+/// unless the user has explicitly asked for it. See the PFOR section of
+/// `Encodings.md` in apache/parquet-format.
+static constexpr bool DEFAULT_IS_PFOR_ENABLED = false;
+
+/// The delta mode is part of PFOR, not a separate encoding: every PFOR reader
+/// has to handle it, because each vector says in its own header which mode it
+/// used. It is on wherever PFOR is, and this exists to turn it off for a column
+/// whose writer would rather spend nothing deciding.
+static constexpr bool DEFAULT_IS_PFOR_DELTA_ENABLED = true;
 static constexpr SizeStatisticsLevel DEFAULT_SIZE_STATISTICS_LEVEL =
     SizeStatisticsLevel::PageAndColumnChunk;
 
@@ -230,13 +241,17 @@ class PARQUET_EXPORT ColumnProperties {
                    bool dictionary_enabled = DEFAULT_IS_DICTIONARY_ENABLED,
                    bool statistics_enabled = DEFAULT_ARE_STATISTICS_ENABLED,
                    size_t max_stats_size = DEFAULT_MAX_STATISTICS_SIZE,
-                   bool page_index_enabled = DEFAULT_IS_PAGE_INDEX_ENABLED)
+                   bool page_index_enabled = DEFAULT_IS_PAGE_INDEX_ENABLED,
+                   bool pfor_enabled = DEFAULT_IS_PFOR_ENABLED,
+                   bool pfor_delta_enabled = DEFAULT_IS_PFOR_DELTA_ENABLED)
       : encoding_(encoding),
         codec_(codec),
         dictionary_enabled_(dictionary_enabled),
         statistics_enabled_(statistics_enabled),
         max_stats_size_(max_stats_size),
-        page_index_enabled_(page_index_enabled) {}
+        page_index_enabled_(page_index_enabled),
+        pfor_enabled_(pfor_enabled),
+        pfor_delta_enabled_(pfor_delta_enabled) {}
 
   void set_encoding(Encoding::type encoding) { encoding_ = encoding; }
 
@@ -269,6 +284,12 @@ class PARQUET_EXPORT ColumnProperties {
     page_index_enabled_ = page_index_enabled;
   }
 
+  void set_pfor_enabled(bool pfor_enabled) { pfor_enabled_ = pfor_enabled; }
+
+  void set_pfor_delta_enabled(bool pfor_delta_enabled) {
+    pfor_delta_enabled_ = pfor_delta_enabled;
+  }
+
   void set_bloom_filter_options(const BloomFilterOptions& bloom_filter_options) {
     if (!(bloom_filter_options.fpp > 0.0 && bloom_filter_options.fpp < 1.0)) {
       throw ParquetException(
@@ -303,6 +324,10 @@ class PARQUET_EXPORT ColumnProperties {
 
   bool page_index_enabled() const { return page_index_enabled_; }
 
+  bool pfor_enabled() const { return pfor_enabled_; }
+
+  bool pfor_delta_enabled() const { return pfor_delta_enabled_; }
+
   std::optional<BloomFilterOptions> bloom_filter_options() const {
     return bloom_filter_options_;
   }
@@ -317,6 +342,8 @@ class PARQUET_EXPORT ColumnProperties {
   size_t max_stats_size_;
   std::shared_ptr<CodecOptions> codec_options_;
   bool page_index_enabled_;
+  bool pfor_enabled_;
+  bool pfor_delta_enabled_;
   std::optional<BloomFilterOptions> bloom_filter_options_;
 };
 
@@ -853,6 +880,102 @@ class PARQUET_EXPORT WriterProperties {
       return this->disable_write_page_index(path->ToDotString());
     }
 
+    /// \brief Allow PFOR encoding to be written for all columns. Default disabled.
+    ///
+    /// PFOR is a Preview feature in the Parquet format: the specification is
+    /// stable, but readers across the ecosystem may not implement it yet, and a
+    /// reader that does not implement it must fail rather than return wrong
+    /// values. parquet-format therefore asks writers to keep PFOR behind an
+    /// opt-in flag, which is what this method is.
+    ///
+    /// This flag only grants permission; it does not select PFOR. To write PFOR,
+    /// enable the flag *and* select the encoding, for example:
+    ///
+    ///     builder.enable_pfor_encoding()->encoding(Encoding::PFOR);
+    ///
+    /// Selecting Encoding::PFOR for a column that has not been granted
+    /// permission makes `build()` throw.
+    ///
+    /// Please check the link below for more details:
+    /// https://github.com/apache/parquet-format/blob/master/Encodings.md#patched-frame-of-reference-pfor--11
+    Builder* enable_pfor_encoding() {
+      default_column_properties_.set_pfor_enabled(true);
+      return this;
+    }
+
+    /// Disallow PFOR encoding for all columns. Default disabled.
+    Builder* disable_pfor_encoding() {
+      default_column_properties_.set_pfor_enabled(false);
+      return this;
+    }
+
+    /// Allow PFOR encoding for the column specified by `path`. Default disabled.
+    Builder* enable_pfor_encoding(const std::string& path) {
+      pfor_enabled_[path] = true;
+      return this;
+    }
+
+    /// Allow PFOR encoding for the column specified by `path`. Default disabled.
+    Builder* enable_pfor_encoding(const std::shared_ptr<schema::ColumnPath>& path) {
+      return this->enable_pfor_encoding(path->ToDotString());
+    }
+
+    /// Disallow PFOR encoding for the column specified by `path`. Default disabled.
+    Builder* disable_pfor_encoding(const std::string& path) {
+      pfor_enabled_[path] = false;
+      return this;
+    }
+
+    /// Disallow PFOR encoding for the column specified by `path`. Default disabled.
+    Builder* disable_pfor_encoding(const std::shared_ptr<schema::ColumnPath>& path) {
+      return this->disable_pfor_encoding(path->ToDotString());
+    }
+
+    /// \brief Let PFOR difference a vector before packing it. Default enabled.
+    ///
+    /// PFOR decides per vector whether to pack the values or their differences,
+    /// whichever its cost model makes smaller, and records the choice in the
+    /// vector's own header. Turning this off narrows the encoder to packing
+    /// values; it does not change how a page is read, and it has no effect on a
+    /// column that is not written with PFOR.
+    ///
+    /// Deciding is not free -- a vector that ends up declining the mode still
+    /// pays for an estimate -- so a writer that knows a column has no structure
+    /// between neighbouring values can turn it off and keep that.
+    Builder* enable_pfor_delta_encoding() {
+      default_column_properties_.set_pfor_delta_enabled(true);
+      return this;
+    }
+
+    /// Stop PFOR from differencing any column. Default enabled.
+    Builder* disable_pfor_delta_encoding() {
+      default_column_properties_.set_pfor_delta_enabled(false);
+      return this;
+    }
+
+    /// Let PFOR difference the column specified by `path`. Default enabled.
+    Builder* enable_pfor_delta_encoding(const std::string& path) {
+      pfor_delta_enabled_[path] = true;
+      return this;
+    }
+
+    /// Let PFOR difference the column specified by `path`. Default enabled.
+    Builder* enable_pfor_delta_encoding(const std::shared_ptr<schema::ColumnPath>& path) {
+      return this->enable_pfor_delta_encoding(path->ToDotString());
+    }
+
+    /// Stop PFOR from differencing the column specified by `path`. Default enabled.
+    Builder* disable_pfor_delta_encoding(const std::string& path) {
+      pfor_delta_enabled_[path] = false;
+      return this;
+    }
+
+    /// Stop PFOR from differencing the column specified by `path`. Default enabled.
+    Builder* disable_pfor_delta_encoding(
+        const std::shared_ptr<schema::ColumnPath>& path) {
+      return this->disable_pfor_delta_encoding(path->ToDotString());
+    }
+
     /// \brief Set the level to write size statistics for all columns. Default is
     /// PageAndColumnChunk.
     ///
@@ -886,6 +1009,10 @@ class PARQUET_EXPORT WriterProperties {
         get(item.first).set_statistics_enabled(item.second);
       for (const auto& item : page_index_enabled_)
         get(item.first).set_page_index_enabled(item.second);
+      for (const auto& item : pfor_enabled_)
+        get(item.first).set_pfor_enabled(item.second);
+      for (const auto& item : pfor_delta_enabled_)
+        get(item.first).set_pfor_delta_enabled(item.second);
       for (const auto& item : bloom_filter_options_) {
         const auto& bloom_filter_options = item.second;
         if (bloom_filter_options.ndv.has_value()) {
@@ -897,6 +1024,16 @@ class PARQUET_EXPORT WriterProperties {
         }
       }
 
+      // PFOR is a Preview feature in the Parquet format, so it must never be
+      // written by accident. Refuse to build properties that select PFOR for a
+      // column without also granting permission for it. `default_column_properties_`
+      // covers every column not named in one of the maps above; the map covers
+      // the rest.
+      CheckPforEnabled(default_column_properties_, "the default column properties");
+      for (const auto& item : column_properties) {
+        CheckPforEnabled(item.second, "column '" + item.first + "'");
+      }
+
       return std::shared_ptr<WriterProperties>(new WriterProperties(
           pool_, dictionary_pagesize_limit_, write_batch_size_, max_row_group_length_,
           pagesize_, max_rows_per_page_, version_, created_by_, page_checksum_enabled_,
@@ -909,6 +1046,19 @@ class PARQUET_EXPORT WriterProperties {
    private:
     void CopyColumnSpecificProperties(const WriterProperties& properties);
 
+    static void CheckPforEnabled(const ColumnProperties& properties,
+                                 const std::string& what) {
+      if (properties.encoding() == Encoding::PFOR && !properties.pfor_enabled()) {
+        throw ParquetException(
+            "PFOR is a Preview feature in the Parquet format and is disabled by "
+            "default, but " +
+            what +
+            " selected Encoding::PFOR. Call "
+            "WriterProperties::Builder::enable_pfor_encoding(), optionally with a "
+            "column path, to allow it.");
+      }
+    }
+
     MemoryPool* pool_;
     int64_t dictionary_pagesize_limit_;
     int64_t write_batch_size_;
@@ -935,6 +1085,8 @@ class PARQUET_EXPORT WriterProperties {
     std::unordered_map<std::string, bool> dictionary_enabled_;
     std::unordered_map<std::string, bool> statistics_enabled_;
     std::unordered_map<std::string, bool> page_index_enabled_;
+    std::unordered_map<std::string, bool> pfor_enabled_;
+    std::unordered_map<std::string, bool> pfor_delta_enabled_;
     std::unordered_map<std::string, BloomFilterOptions> bloom_filter_options_;
 
     bool content_defined_chunking_enabled_;
@@ -1046,6 +1198,32 @@ class PARQUET_EXPORT WriterProperties {
     return false;
   }
 
+  /// \brief Whether PFOR encoding is allowed for the column at `path`.
+  ///
+  /// PFOR is a Preview feature in the Parquet format, so this is false unless the
+  /// writer opted in through WriterProperties::Builder::enable_pfor_encoding().
+  bool pfor_enabled(const std::shared_ptr<schema::ColumnPath>& path) const {
+    return column_properties(path).pfor_enabled();
+  }
+
+  /// \brief Whether PFOR encoding is allowed for any column.
+  bool pfor_enabled() const {
+    if (default_column_properties_.pfor_enabled()) {
+      return true;
+    }
+    for (const auto& item : column_properties_) {
+      if (item.second.pfor_enabled()) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /// \brief Whether PFOR may difference the column at `path` before packing it.
+  bool pfor_delta_enabled(const std::shared_ptr<schema::ColumnPath>& path) const {
+    return column_properties(path).pfor_delta_enabled();
+  }
+
   // Return whether bloom filter is enabled for any column.
   bool bloom_filter_enabled() const {
     return std::any_of(column_properties_.cbegin(), column_properties_.cend(),
diff --git a/cpp/src/parquet/properties_test.cc b/cpp/src/parquet/properties_test.cc
index 324ea2026a9e..ecfbb944dc7d 100644
--- a/cpp/src/parquet/properties_test.cc
+++ b/cpp/src/parquet/properties_test.cc
@@ -254,6 +254,148 @@ TEST(TestReaderProperties, GetStreamInsufficientData) {
   }
 }
 
+TEST(TestWriterProperties, PforDisabledByDefault) {
+  auto props = WriterProperties::Builder().build();
+
+  ASSERT_FALSE(props->pfor_enabled());
+  ASSERT_FALSE(props->pfor_enabled(ColumnPath::FromDotString("a")));
+}
+
+TEST(TestWriterProperties, PforRejectedWithoutOptIn) {
+  EXPECT_THROW_THAT(
+      [&]() { WriterProperties::Builder().encoding(Encoding::PFOR)->build(); },
+      ParquetException,
+      ::testing::Property(&ParquetException::what,
+                          ::testing::HasSubstr("enable_pfor_encoding")));
+}
+
+TEST(TestWriterProperties, PforRejectedForColumnWithoutOptIn) {
+  EXPECT_THROW_THAT(
+      [&]() { WriterProperties::Builder().encoding("a", Encoding::PFOR)->build(); },
+      ParquetException,
+      ::testing::Property(&ParquetException::what, ::testing::HasSubstr("column 'a'")));
+}
+
+// Enabling PFOR for one column does not grant permission to another.
+TEST(TestWriterProperties, PforRejectedForColumnEnabledElsewhere) {
+  EXPECT_THROW_THAT(
+      [&]() {
+        WriterProperties::Builder()
+            .enable_pfor_encoding("a")
+            ->encoding("b", Encoding::PFOR)
+            ->build();
+      },
+      ParquetException,
+      ::testing::Property(&ParquetException::what, ::testing::HasSubstr("column 'b'")));
+}
+
+// A global PFOR selection reaches every column, including one that opted out.
+TEST(TestWriterProperties, PforRejectedWhenDisabledForColumnUnderGlobalEncoding) {
+  EXPECT_THROW_THAT(
+      [&]() {
+        WriterProperties::Builder()
+            .enable_pfor_encoding()
+            ->disable_pfor_encoding("a")
+            ->encoding(Encoding::PFOR)
+            ->build();
+      },
+      ParquetException,
+      ::testing::Property(&ParquetException::what, ::testing::HasSubstr("column 'a'")));
+}
+
+// A per-column disable overrides a global enable, so the column must be rejected.
+TEST(TestWriterProperties, PforRejectedWhenDisabledForColumn) {
+  EXPECT_THROW_THAT(
+      [&]() {
+        WriterProperties::Builder()
+            .enable_pfor_encoding()
+            ->disable_pfor_encoding("a")
+            ->encoding("a", Encoding::PFOR)
+            ->build();
+      },
+      ParquetException,
+      ::testing::Property(&ParquetException::what, ::testing::HasSubstr("column 'a'")));
+}
+
+TEST(TestWriterProperties, PforAcceptedWhenEnabledForAllColumns) {
+  auto props = WriterProperties::Builder()
+                   .enable_pfor_encoding()
+                   ->encoding(Encoding::PFOR)
+                   ->build();
+
+  ASSERT_TRUE(props->pfor_enabled());
+  ASSERT_TRUE(props->pfor_enabled(ColumnPath::FromDotString("a")));
+  ASSERT_EQ(Encoding::PFOR, props->encoding(ColumnPath::FromDotString("a")));
+}
+
+TEST(TestWriterProperties, PforAcceptedWhenEnabledForOneColumn) {
+  auto props = WriterProperties::Builder()
+                   .enable_pfor_encoding("a")
+                   ->encoding("a", Encoding::PFOR)
+                   ->build();
+
+  // pfor_enabled() with no argument answers "any column", so it is true here even
+  // though only one column opted in.
+  ASSERT_TRUE(props->pfor_enabled());
+  ASSERT_TRUE(props->pfor_enabled(ColumnPath::FromDotString("a")));
+  ASSERT_FALSE(props->pfor_enabled(ColumnPath::FromDotString("b")));
+}
+
+// The flag grants permission; it does not select the encoding.
+TEST(TestWriterProperties, PforEnabledDoesNotSelectPfor) {
+  auto props = WriterProperties::Builder().enable_pfor_encoding()->build();
+
+  ASSERT_TRUE(props->pfor_enabled());
+  ASSERT_EQ(DEFAULT_ENCODING, props->encoding(ColumnPath::FromDotString("a")));
+}
+
+// The delta mode is part of PFOR rather than a Preview feature of its own, so it
+// is on by default and needs no opt-in.
+TEST(TestWriterProperties, PforDeltaEnabledByDefault) {
+  auto props = WriterProperties::Builder().build();
+
+  ASSERT_TRUE(props->pfor_delta_enabled(ColumnPath::FromDotString("a")));
+}
+
+TEST(TestWriterProperties, PforDeltaCanBeDisabledForAllColumns) {
+  auto props = WriterProperties::Builder().disable_pfor_delta_encoding()->build();
+
+  ASSERT_FALSE(props->pfor_delta_enabled(ColumnPath::FromDotString("a")));
+  ASSERT_FALSE(props->pfor_delta_enabled(ColumnPath::FromDotString("b")));
+}
+
+TEST(TestWriterProperties, PforDeltaCanBeDisabledForOneColumn) {
+  auto props = WriterProperties::Builder().disable_pfor_delta_encoding("a")->build();
+
+  ASSERT_FALSE(props->pfor_delta_enabled(ColumnPath::FromDotString("a")));
+  ASSERT_TRUE(props->pfor_delta_enabled(ColumnPath::FromDotString("b")));
+}
+
+// A per-column enable survives a global disable, so a writer can turn the mode
+// off broadly and keep it for the one column that benefits.
+TEST(TestWriterProperties, PforDeltaPerColumnEnableOverridesGlobalDisable) {
+  auto props = WriterProperties::Builder()
+                   .disable_pfor_delta_encoding()
+                   ->enable_pfor_delta_encoding("a")
+                   ->build();
+
+  ASSERT_TRUE(props->pfor_delta_enabled(ColumnPath::FromDotString("a")));
+  ASSERT_FALSE(props->pfor_delta_enabled(ColumnPath::FromDotString("b")));
+}
+
+// The delta mode is not a permission, so turning it off never makes build()
+// throw the way a missing PFOR opt-in does.
+TEST(TestWriterProperties, PforDeltaDisabledStillBuildsWithPfor) {
+  auto props = WriterProperties::Builder()
+                   .enable_pfor_encoding()
+                   ->disable_pfor_delta_encoding()
+                   ->encoding(Encoding::PFOR)
+                   ->build();
+
+  ASSERT_EQ(Encoding::PFOR, props->encoding(ColumnPath::FromDotString("a")));
+  ASSERT_FALSE(props->pfor_delta_enabled(ColumnPath::FromDotString("a")));
+}
+
 struct WriterPropertiesTestCase {
   WriterPropertiesTestCase(std::shared_ptr<WriterProperties> props, std::string label)
       : properties(std::move(props)), label(std::move(label)) {}

From 25d786a42b40661e962acfc66f529f594538669f Mon Sep 17 00:00:00 2001
From: Prateek Gaur <prateek.gaur@snowflake.com>
Date: Thu, 3 Sep 2026 02:24:06 +0000
Subject: [PATCH 11/27] Validate PFOR delta metadata and page bounds

A delta vector carries a flag, a start value and a frame, and a corrupt
page can make any of them inconsistent. The decoder now rejects a
mismatched flag, a truncated start value and a vector that runs past the
end of the page. How far the unpacker may read is now computed from the
full delta header, not the raw one.
---
 cpp/src/arrow/util/pfor/pfor.cc              |  9 ++-
 cpp/src/arrow/util/pfor/pfor_internal.h      |  6 ++
 cpp/src/arrow/util/pfor/pfor_plan_internal.h | 10 +---
 cpp/src/arrow/util/pfor/pfor_test.cc         | 59 +++++++++++++++++++-
 cpp/src/parquet/pfor_comparison_benchmark.cc |  2 +-
 5 files changed, 72 insertions(+), 14 deletions(-)

diff --git a/cpp/src/arrow/util/pfor/pfor.cc b/cpp/src/arrow/util/pfor/pfor.cc
index bb0b45bbe461..f01ce19567f9 100644
--- a/cpp/src/arrow/util/pfor/pfor.cc
+++ b/cpp/src/arrow/util/pfor/pfor.cc
@@ -232,10 +232,13 @@ Result<int64_t> PforCompression<T>::DecodeVector(std::span<const uint8_t> data,
     // its load extends beyond this vector's packed payload.
     //
     // `data` runs from this vector to the end of the page, so every byte after
-    // this vector's header is inside the caller's buffer and ours to read.
+    // this vector's header is inside the caller's buffer and ours to read. The
+    // bound is measured from `info_bytes` rather than the fixed metadata size,
+    // because a delta vector's header also carries its start value and
+    // `read_ptr` is already past it -- subtracting the fixed size would hand
+    // the kernels sizeof(T) bytes that belong to no one.
     const auto readable_bytes = static_cast<int>(std::min<int64_t>(
-        static_cast<int64_t>(data.size()) - PforVectorInfo<T>::kStoredSize,
-        std::numeric_limits<int>::max()));
+        static_cast<int64_t>(data.size()) - info_bytes, std::numeric_limits<int>::max()));
 
     if (unsigned_for == 0) {
       // FOR is zero: there is no bias to add, so unpack straight into the
diff --git a/cpp/src/arrow/util/pfor/pfor_internal.h b/cpp/src/arrow/util/pfor/pfor_internal.h
index 4d756f9b126e..bea287abb185 100644
--- a/cpp/src/arrow/util/pfor/pfor_internal.h
+++ b/cpp/src/arrow/util/pfor/pfor_internal.h
@@ -33,6 +33,7 @@
 #include "arrow/result.h"
 #include "arrow/status.h"
 #include "arrow/util/endian.h"
+#include "arrow/util/logging.h"
 #include "arrow/util/pfor/pfor_constants_internal.h"
 #include "arrow/util/pfor/pfor_plan_internal.h"
 #include "arrow/util/ubsan.h"
@@ -109,6 +110,11 @@ class PforVectorInfo {
 
   /// \brief Store this info to a byte buffer (little-endian)
   void Store(std::span<uint8_t> dest) const {
+    // A width above the type's maximum would lose its high bits to the mask and
+    // set the delta flag on the way out, turning an encoder bug into a page that
+    // decodes to the wrong values with no error anywhere. Load rejects such a
+    // width on the way in; this catches it on the way out, where the bug is.
+    ARROW_DCHECK_LE(bit_width_, PforTypeTraits<T>::kMaxBitWidth);
     uint8_t* ptr = dest.data();
     util::SafeStore(ptr, bit_util::ToLittleEndian(frame_of_reference_));
     // bits 0..6 = bit width; bit 7 = delta flag.
diff --git a/cpp/src/arrow/util/pfor/pfor_plan_internal.h b/cpp/src/arrow/util/pfor/pfor_plan_internal.h
index 2c530906a644..db79c691c43e 100644
--- a/cpp/src/arrow/util/pfor/pfor_plan_internal.h
+++ b/cpp/src/arrow/util/pfor/pfor_plan_internal.h
@@ -257,13 +257,9 @@ FrameChoice<T> ChooseFrameAndWidth(const T* values, int32_t num_elements,
   best.num_exceptions = r.num_exceptions;
   best.cost_bits = cost_bits;
 
-  // Already at width 0, with a handful of patches carrying the rest. Nothing a
-  // frame can do about it. Note this is not the same as having no exceptions:
-  // the whole point of a frame above the minimum is to trade a narrower width
-  // for a few patches, so an exception-free choice is where the search starts,
-  // not a reason to skip it. The sawtooth is the example -- its differences pack
-  // at width 12 with no exceptions, or at width 0 with five; only the latter is
-  // beneficial.
+  // A width-zero plan cannot be improved by moving the frame. Do not apply this
+  // shortcut merely because a plan has no exceptions: another frame may trade
+  // a narrower width for a small patch list.
   if (best.bit_width == 0) return best;
 
   const int32_t num_buckets = static_cast<int32_t>(range >> shift) + 1;
diff --git a/cpp/src/arrow/util/pfor/pfor_test.cc b/cpp/src/arrow/util/pfor/pfor_test.cc
index a5a9d5c56199..ef3226b4d73c 100644
--- a/cpp/src/arrow/util/pfor/pfor_test.cc
+++ b/cpp/src/arrow/util/pfor/pfor_test.cc
@@ -683,6 +683,59 @@ TYPED_TEST(PforTest, CorruptExceptionDataTruncated) {
                                       5, decoded.data()));
 }
 
+// ----------------------------------------------------------------------
+// A page whose vector is sized exactly leaves no slack, so setting the delta
+// flag on a vector that was written without one makes the decoder ask for
+// sizeof(T) more bytes than the page holds. That has to be an error rather than
+// a read past the end.
+TYPED_TEST(PforTest, CorruptDeltaFlagSetOnANonDeltaVector) {
+  using T = TypeParam;
+  const std::vector<T> values = ClusterWithOutlier<T>();
+  auto compressed = TestFixture::EncodePage(values);
+
+  const int64_t width_byte =
+      TestFixture::kFirstVectorOffset + TestFixture::kBitWidthOffset;
+  ASSERT_EQ(compressed[width_byte] & PforVectorInfo<T>::kDeltaFlag, 0)
+      << "this page was supposed to be encoded without the delta mode";
+  compressed[width_byte] |= PforVectorInfo<T>::kDeltaFlag;
+
+  std::vector<T> decoded(values.size());
+  ASSERT_RAISES(Invalid, PforWrapper<T>::Decode(
+                             compressed.data(), static_cast<int64_t>(compressed.size()),
+                             static_cast<int32_t>(values.size()), decoded.data()));
+}
+
+// A delta vector's start value sits between the info block and the packed
+// payload, so a page that ends inside it has enough bytes for the info block
+// and not enough for the vector. The check that catches this is the only one
+// that reads is_delta(), so it needs its own case: the width and exception
+// fields are already valid here.
+TYPED_TEST(PforTest, CorruptDeltaVectorTruncatedInsideTheStartValue) {
+  using T = TypeParam;
+  std::vector<T> values(64);
+  std::iota(values.begin(), values.end(), static_cast<T>(1'000'000));
+  auto compressed = TestFixture::EncodePage(values);
+
+  const int64_t width_byte =
+      TestFixture::kFirstVectorOffset + TestFixture::kBitWidthOffset;
+  ASSERT_NE(compressed[width_byte] & PforVectorInfo<T>::kDeltaFlag, 0)
+      << "an arithmetic run was supposed to be encoded in the delta mode";
+
+  // One byte short of the start value, so PforVectorInfo::Load succeeds and the
+  // vector as a whole does not fit.
+  const int64_t truncated =
+      TestFixture::kFirstVectorOffset + PforVectorInfo<T>::kStoredSize + sizeof(T) - 1;
+  ASSERT_LT(truncated, static_cast<int64_t>(compressed.size()));
+
+  std::vector<T> decoded(values.size());
+  const Status status = PforWrapper<T>::Decode(
+      compressed.data(), truncated, static_cast<int32_t>(values.size()), decoded.data());
+  ASSERT_RAISES(Invalid, status);
+  EXPECT_NE(status.message().find("metadata"), std::string::npos)
+      << "a truncated start value should be reported as missing metadata, got: "
+      << status.message();
+}
+
 // ----------------------------------------------------------------------
 // Output sizing
 
@@ -793,7 +846,7 @@ TYPED_TEST(PforTest, MaxCompressedSizeBoundHoldsForAdversarialInputs) {
   }
 }
 
-// ======================================================================
+// ----------------------------------------------------------------------
 // Delta Mode and Frame Search Tests
 
 // The mode has to survive every width, not just the ones a plausible column
@@ -873,8 +926,8 @@ TYPED_TEST(PforTest, DeltaVectorDecodesWithoutThePrecedingVector) {
       decoded);
 }
 
-// Two-sided patching. A tight cluster with one value far below it is the case
-// the old frame could not handle: at the minimum, the packed window has to span
+// Two-sided patching. A tight cluster with one value far below it is the case a
+// frame pinned to the minimum cannot handle: the packed window then has to span
 // the whole gap and every value in the cluster pays for it. The frame belongs
 // above the low value, which then becomes an exception like any other.
 TYPED_TEST(PforTest, FrameSitsAboveTheMinimumToPatchALowOutlier) {
diff --git a/cpp/src/parquet/pfor_comparison_benchmark.cc b/cpp/src/parquet/pfor_comparison_benchmark.cc
index 30223418d0f7..852da936d4ef 100644
--- a/cpp/src/parquet/pfor_comparison_benchmark.cc
+++ b/cpp/src/parquet/pfor_comparison_benchmark.cc
@@ -450,7 +450,7 @@ std::vector<int64_t> GenByteCount(int64_t n) {
 // in order to compare the two.
 //
 // Unlike the generators above, these are templates rather than a pair of
-// per-width functions: it keeps the int32 and int64 arms of every REGISTER
+// per-width functions: it keeps the two widths of every REGISTER_DELTA_SHAPE
 // below on provably the same distribution, which two hand-written copies would
 // not. They live in their own namespace because two of them build on base
 // distributions whose names are already taken in this file by columns drawn

From 6e15dc9bcec646293b2498492f3216d007ba3855 Mon Sep 17 00:00:00 2001
From: Prateek Gaur <prateek.gaur@snowflake.com>
Date: Mon, 28 Sep 2026 01:24:06 +0000
Subject: [PATCH 12/27] Let benchmarks force delta vectors

Comparing the raw and delta payloads of one input needs both to exist,
and the planner usually rejects one. A force_delta option, off by
default, skips that rejection while still writing an ordinary delta
vector that any reader decodes. The round-trip tests cover it.
---
 cpp/src/arrow/util/pfor/pfor.cc              |   4 +-
 cpp/src/arrow/util/pfor/pfor_internal.h      |   3 +
 cpp/src/arrow/util/pfor/pfor_plan_internal.h |  14 +-
 cpp/src/arrow/util/pfor/pfor_test.cc         |  18 ++
 cpp/src/parquet/pfor_comparison_benchmark.cc | 223 ++++++++++++++++---
 5 files changed, 222 insertions(+), 40 deletions(-)

diff --git a/cpp/src/arrow/util/pfor/pfor.cc b/cpp/src/arrow/util/pfor/pfor.cc
index f01ce19567f9..ab3fe24407d6 100644
--- a/cpp/src/arrow/util/pfor/pfor.cc
+++ b/cpp/src/arrow/util/pfor/pfor.cc
@@ -99,8 +99,8 @@ PforEncodedVector<T> PforCompression<T>::EncodeVector(const T* values,
     scratch = heap_scratch.data();
   }
 
-  const PforVectorPlan<T> plan =
-      ChooseVectorPlan<T>(values, num_elements, scratch, options.delta_enabled);
+  const PforVectorPlan<T> plan = ChooseVectorPlan<T>(
+      values, num_elements, scratch, options.delta_enabled, options.force_delta);
   const T* source = plan.delta ? scratch : values;
 
   PforEncodedVector<T> result;
diff --git a/cpp/src/arrow/util/pfor/pfor_internal.h b/cpp/src/arrow/util/pfor/pfor_internal.h
index bea287abb185..c5bfcfae4f74 100644
--- a/cpp/src/arrow/util/pfor/pfor_internal.h
+++ b/cpp/src/arrow/util/pfor/pfor_internal.h
@@ -218,6 +218,9 @@ class PforEncodedVector {
 struct PforEncodeOptions {
   /// Let the planner difference a vector when its cost model prefers that.
   bool delta_enabled = true;
+  /// Require the delta representation even when the raw representation is cheaper.
+  /// Off by default; set it only to exercise or measure the delta path directly.
+  bool force_delta = false;
 };
 
 /// \brief PFOR compression and decompression algorithms
diff --git a/cpp/src/arrow/util/pfor/pfor_plan_internal.h b/cpp/src/arrow/util/pfor/pfor_plan_internal.h
index db79c691c43e..542897abc1ce 100644
--- a/cpp/src/arrow/util/pfor/pfor_plan_internal.h
+++ b/cpp/src/arrow/util/pfor/pfor_plan_internal.h
@@ -495,13 +495,15 @@ int64_t EstimateDeltaCostBits(const T* values, int32_t num_elements) {
 ///             holds the differences if the plan chose the delta mode, and is
 ///             clobbered either way
 /// \param[in] delta_enabled whether the delta mode may be chosen at all
+/// \param[in] force_delta choose delta regardless of its estimated or exact cost
 ///
 /// Both transforms are costed with the same model and the cheaper one wins, so
 /// the mode is a per-vector decision. It has to be: differencing loses 6-19% on
 /// every unclustered draw, and a column is rarely all one shape.
 template <typename T>
 PforVectorPlan<T> ChooseVectorPlan(const T* values, int32_t num_elements,
-                                   T* delta_scratch, bool delta_enabled) {
+                                   T* delta_scratch, bool delta_enabled,
+                                   bool force_delta = false) {
   const FrameChoice<T> raw = ChooseFrameAndWidth<T>(values, num_elements);
 
   PforVectorPlan<T> plan;
@@ -513,7 +515,9 @@ PforVectorPlan<T> ChooseVectorPlan(const T* values, int32_t num_elements,
 
   // One element has no difference to take, and a vector already packing at
   // width 0 cannot be improved on.
-  if (!delta_enabled || num_elements < 2 || raw.bit_width == 0) return plan;
+  if (!delta_enabled || (!force_delta && (num_elements < 2 || raw.bit_width == 0))) {
+    return plan;
+  }
 
   // A delta vector carries its own first value, so it starts one full-width
   // value behind whatever its differences pack to.
@@ -525,8 +529,8 @@ PforVectorPlan<T> ChooseVectorPlan(const T* values, int32_t num_elements,
   // them. The estimate is deliberately loose, so it declines only where the two
   // modes are more than a sampling error apart -- which is where the choice
   // matters least.
-  if (EstimateDeltaCostBits<T>(values, num_elements) + start_value_bits >=
-      plan.cost_bits) {
+  if (!force_delta && EstimateDeltaCostBits<T>(values, num_elements) + start_value_bits >=
+                          plan.cost_bits) {
     return plan;
   }
 
@@ -537,7 +541,7 @@ PforVectorPlan<T> ChooseVectorPlan(const T* values, int32_t num_elements,
       ChooseFrameAndWidth<T>(delta_scratch, num_elements, delta_bounds);
 
   const int64_t delta_cost = delta.cost_bits + start_value_bits;
-  if (delta_cost < plan.cost_bits) {
+  if (force_delta || delta_cost < plan.cost_bits) {
     plan.delta = true;
     plan.frame_of_reference = delta.frame_of_reference;
     plan.start_value = values[0];
diff --git a/cpp/src/arrow/util/pfor/pfor_test.cc b/cpp/src/arrow/util/pfor/pfor_test.cc
index ef3226b4d73c..b17e5260dd4f 100644
--- a/cpp/src/arrow/util/pfor/pfor_test.cc
+++ b/cpp/src/arrow/util/pfor/pfor_test.cc
@@ -309,6 +309,24 @@ TYPED_TEST(PforTest, VectorSimpleSequenceWithoutDelta) {
   EXPECT_EQ(encoded.info().num_exceptions(), 0);
 }
 
+// The planner correctly chooses raw PFOR for this data, so the flag is the only
+// way to reach the delta round trip on it.
+TYPED_TEST(PforTest, ForceDeltaBypassesThePlannerChoice) {
+  using T = TypeParam;
+  std::vector<T> values = this->RandomValues(64, 100, 163, 11);
+  const PforEncodeOptions options{.delta_enabled = true, .force_delta = true};
+  auto encoded = PforCompression<T>::EncodeVector(
+      values.data(), static_cast<int32_t>(values.size()), options);
+  ASSERT_TRUE(encoded.info().is_delta());
+
+  const int64_t size = PforCompression<T>::SerializedVectorSize(encoded, values.size());
+  std::vector<uint8_t> buffer(size);
+  ASSERT_OK(PforCompression<T>::SerializeVector(encoded, values.size(), buffer));
+  std::vector<T> decoded(values.size());
+  ASSERT_OK(PforCompression<T>::DecodeVector(buffer, values.size(), decoded.data()));
+  ASSERT_EQ(values, decoded);
+}
+
 TYPED_TEST(PforTest, VectorWithOutlier) {
   using T = TypeParam;
   std::vector<T> values = {100, 102, 101, 103, 100, 99, 50000, 104};
diff --git a/cpp/src/parquet/pfor_comparison_benchmark.cc b/cpp/src/parquet/pfor_comparison_benchmark.cc
index 852da936d4ef..d7deeb0edbc2 100644
--- a/cpp/src/parquet/pfor_comparison_benchmark.cc
+++ b/cpp/src/parquet/pfor_comparison_benchmark.cc
@@ -38,6 +38,7 @@
 
 #include "benchmark/benchmark.h"
 
+#include "arrow/util/bit_util.h"
 #include "arrow/util/compression.h"
 #include "arrow/util/logging.h"
 #include "arrow/util/pfor/pfor_wrapper_internal.h"
@@ -63,6 +64,13 @@ using GenT = std::vector<T> (*)(int64_t);
 using Gen32 = GenT<int32_t>;
 using Gen64 = GenT<int64_t>;
 
+// Payload used when a PFOR vector is placed in delta mode. Both layouts are
+// independently restarted at every 1024-value PFOR vector boundary.
+enum class PforDeltaLayout {
+  kPatchedDelta,
+  kDeltaBinaryPacked,
+};
+
 // Map the C++ value type to its Parquet physical type + descriptor type.
 template <typename T>
 struct PqTraits;
@@ -662,7 +670,8 @@ static std::shared_ptr<ColumnDescriptor> MakeDescriptor() {
 // PFOR Encode/Decode
 
 template <typename T>
-static void PforEncodeImpl(benchmark::State& state, GenT<T> gen) {
+static void PforEncodeImpl(benchmark::State& state, GenT<T> gen,
+                           const ::arrow::util::pfor::PforEncodeOptions& options = {}) {
   const int64_t num_values = state.range(0);
   auto values = gen(num_values);
   const int64_t uncompressed_size = num_values * sizeof(T);
@@ -675,12 +684,14 @@ static void PforEncodeImpl(benchmark::State& state, GenT<T> gen) {
   // Compute comp_size once for the counter
   int64_t comp_size = max_size;
   ARROW_CHECK_OK(::arrow::util::pfor::PforWrapper<T>::Encode(
-      values.data(), static_cast<int32_t>(num_values), compressed.data(), &comp_size));
+      values.data(), static_cast<int32_t>(num_values), compressed.data(), &comp_size,
+      options));
 
   for (auto _ : state) {
     int64_t sz = max_size;
     ARROW_CHECK_OK(::arrow::util::pfor::PforWrapper<T>::Encode(
-        values.data(), static_cast<int32_t>(num_values), compressed.data(), &sz));
+        values.data(), static_cast<int32_t>(num_values), compressed.data(), &sz,
+        options));
     benchmark::DoNotOptimize(sz);
     benchmark::ClobberMemory();
   }
@@ -696,9 +707,16 @@ static void BM_PforEncode(benchmark::State& state, Gen32 gen) {
 static void BM_Pfor64Encode(benchmark::State& state, Gen64 gen) {
   PforEncodeImpl<int64_t>(state, gen);
 }
+static void BM_PforRawEncode(benchmark::State& state, Gen32 gen) {
+  PforEncodeImpl<int32_t>(state, gen, {.delta_enabled = false, .force_delta = false});
+}
+static void BM_PforRaw64Encode(benchmark::State& state, Gen64 gen) {
+  PforEncodeImpl<int64_t>(state, gen, {.delta_enabled = false, .force_delta = false});
+}
 
 template <typename T>
-static void PforDecodeImpl(benchmark::State& state, GenT<T> gen) {
+static void PforDecodeImpl(benchmark::State& state, GenT<T> gen,
+                           const ::arrow::util::pfor::PforEncodeOptions& options = {}) {
   const int64_t num_values = state.range(0);
   auto values = gen(num_values);
   const int64_t uncompressed_size = num_values * sizeof(T);
@@ -709,7 +727,8 @@ static void PforDecodeImpl(benchmark::State& state, GenT<T> gen) {
   std::vector<uint8_t> compressed(max_size);
   int64_t comp_size = max_size;
   ARROW_CHECK_OK(::arrow::util::pfor::PforWrapper<T>::Encode(
-      values.data(), static_cast<int32_t>(num_values), compressed.data(), &comp_size));
+      values.data(), static_cast<int32_t>(num_values), compressed.data(), &comp_size,
+      options));
 
   std::vector<T> decoded(num_values);
   for (auto _ : state) {
@@ -731,6 +750,134 @@ static void BM_Pfor64Decode(benchmark::State& state, Gen64 gen) {
   PforDecodeImpl<int64_t>(state, gen);
 }
 
+// ----------------------------------------------------------------------
+// PFOR-DBPDelta Encode/Decode
+
+// Model the alternative wire layout directly: the outer PFOR page keeps its
+// seven-byte header and one four-byte offset per vector, while each vector body
+// is an independently decodable DELTA_BINARY_PACKED stream. Consequently DBP's
+// first value and block header restart at every PFOR vector boundary.
+template <typename T>
+static int64_t PforDbpOuterBytes(int64_t num_values) {
+  constexpr int64_t kVectorSize = ::arrow::util::pfor::PforConstants::kPforVectorSize;
+  const int64_t num_vectors = ::arrow::bit_util::CeilDiv(num_values, kVectorSize);
+  return ::arrow::util::pfor::PforConstants::kHeaderSize +
+         num_vectors * sizeof(::arrow::util::pfor::PforConstants::OffsetType);
+}
+
+template <typename T>
+static void PforDbpDeltaEncodeImpl(benchmark::State& state, GenT<T> gen) {
+  using PType = typename PqTraits<T>::PType;
+  constexpr int64_t kVectorSize = ::arrow::util::pfor::PforConstants::kPforVectorSize;
+  const int64_t num_values = state.range(0);
+  auto values = gen(num_values);
+  const int64_t uncompressed_size = num_values * sizeof(T);
+  auto encoder = MakeTypedEncoder<PType>(Encoding::DELTA_BINARY_PACKED);
+
+  int64_t comp_size = PforDbpOuterBytes<T>(num_values);
+  for (int64_t start = 0; start < num_values; start += kVectorSize) {
+    const int count = static_cast<int>(std::min(kVectorSize, num_values - start));
+    encoder->Put(values.data() + start, count);
+    comp_size += encoder->FlushValues()->size();
+  }
+
+  for (auto _ : state) {
+    int64_t encoded_bytes = PforDbpOuterBytes<T>(num_values);
+    for (int64_t start = 0; start < num_values; start += kVectorSize) {
+      const int count = static_cast<int>(std::min(kVectorSize, num_values - start));
+      encoder->Put(values.data() + start, count);
+      encoded_bytes += encoder->FlushValues()->size();
+    }
+    benchmark::DoNotOptimize(encoded_bytes);
+  }
+
+  state.SetBytesProcessed(state.iterations() * uncompressed_size);
+  state.SetItemsProcessed(state.iterations() * num_values);
+  state.counters["compression_ratio"] =
+      static_cast<double>(uncompressed_size) / static_cast<double>(comp_size);
+}
+
+template <typename T>
+static void PforDbpDeltaDecodeImpl(benchmark::State& state, GenT<T> gen) {
+  using PType = typename PqTraits<T>::PType;
+  constexpr int64_t kVectorSize = ::arrow::util::pfor::PforConstants::kPforVectorSize;
+  const int64_t num_values = state.range(0);
+  auto values = gen(num_values);
+  const int64_t uncompressed_size = num_values * sizeof(T);
+
+  auto encoder = MakeTypedEncoder<PType>(Encoding::DELTA_BINARY_PACKED);
+  std::vector<std::shared_ptr<Buffer>> vectors;
+  int64_t comp_size = PforDbpOuterBytes<T>(num_values);
+  for (int64_t start = 0; start < num_values; start += kVectorSize) {
+    const int count = static_cast<int>(std::min(kVectorSize, num_values - start));
+    encoder->Put(values.data() + start, count);
+    vectors.push_back(encoder->FlushValues());
+    comp_size += vectors.back()->size();
+  }
+
+  auto decoder = MakeTypedDecoder<PType>(Encoding::DELTA_BINARY_PACKED);
+  std::vector<T> decoded(num_values);
+  for (auto _ : state) {
+    int64_t start = 0;
+    for (const auto& vector : vectors) {
+      const int count = static_cast<int>(std::min(kVectorSize, num_values - start));
+      decoder->SetData(count, vector->data(), static_cast<int>(vector->size()));
+      ARROW_CHECK_EQ(decoder->Decode(decoded.data() + start, count), count);
+      start += count;
+    }
+    benchmark::ClobberMemory();
+  }
+
+  state.SetBytesProcessed(state.iterations() * uncompressed_size);
+  state.SetItemsProcessed(state.iterations() * num_values);
+  state.counters["compression_ratio"] =
+      static_cast<double>(uncompressed_size) / static_cast<double>(comp_size);
+}
+
+template <PforDeltaLayout Layout, typename T>
+static void PforDeltaLayoutEncodeImpl(benchmark::State& state, GenT<T> gen) {
+  if constexpr (Layout == PforDeltaLayout::kPatchedDelta) {
+    PforEncodeImpl<T>(state, gen, {.delta_enabled = true, .force_delta = true});
+  } else {
+    PforDbpDeltaEncodeImpl<T>(state, gen);
+  }
+}
+
+template <PforDeltaLayout Layout, typename T>
+static void PforDeltaLayoutDecodeImpl(benchmark::State& state, GenT<T> gen) {
+  if constexpr (Layout == PforDeltaLayout::kPatchedDelta) {
+    PforDecodeImpl<T>(state, gen, {.delta_enabled = true, .force_delta = true});
+  } else {
+    PforDbpDeltaDecodeImpl<T>(state, gen);
+  }
+}
+
+static void BM_PforPatchedDeltaEncode(benchmark::State& state, Gen32 gen) {
+  PforDeltaLayoutEncodeImpl<PforDeltaLayout::kPatchedDelta, int32_t>(state, gen);
+}
+static void BM_PforPatchedDelta64Encode(benchmark::State& state, Gen64 gen) {
+  PforDeltaLayoutEncodeImpl<PforDeltaLayout::kPatchedDelta, int64_t>(state, gen);
+}
+static void BM_PforPatchedDeltaDecode(benchmark::State& state, Gen32 gen) {
+  PforDeltaLayoutDecodeImpl<PforDeltaLayout::kPatchedDelta, int32_t>(state, gen);
+}
+static void BM_PforPatchedDelta64Decode(benchmark::State& state, Gen64 gen) {
+  PforDeltaLayoutDecodeImpl<PforDeltaLayout::kPatchedDelta, int64_t>(state, gen);
+}
+
+static void BM_PforDbpDeltaEncode(benchmark::State& state, Gen32 gen) {
+  PforDeltaLayoutEncodeImpl<PforDeltaLayout::kDeltaBinaryPacked, int32_t>(state, gen);
+}
+static void BM_PforDbpDelta64Encode(benchmark::State& state, Gen64 gen) {
+  PforDeltaLayoutEncodeImpl<PforDeltaLayout::kDeltaBinaryPacked, int64_t>(state, gen);
+}
+static void BM_PforDbpDeltaDecode(benchmark::State& state, Gen32 gen) {
+  PforDeltaLayoutDecodeImpl<PforDeltaLayout::kDeltaBinaryPacked, int32_t>(state, gen);
+}
+static void BM_PforDbpDelta64Decode(benchmark::State& state, Gen64 gen) {
+  PforDeltaLayoutDecodeImpl<PforDeltaLayout::kDeltaBinaryPacked, int64_t>(state, gen);
+}
+
 // ----------------------------------------------------------------------
 // DeltaBitPack Encode/Decode
 
@@ -1136,38 +1283,48 @@ static void BM_BssLz464Decode(benchmark::State& state, Gen64 gen) {
 static void CustomArgs(benchmark::internal::Benchmark* b) { b->Arg(102400); }
 
 // Macro to register all algorithms for a given dataset
-#define REGISTER_DATASET(Name, GenFunc)                                        \
-  BENCHMARK_CAPTURE(BM_PforEncode, Name, &GenFunc)->Apply(CustomArgs);         \
-  BENCHMARK_CAPTURE(BM_PforDecode, Name, &GenFunc)->Apply(CustomArgs);         \
-  BENCHMARK_CAPTURE(BM_DeltaBitPackEncode, Name, &GenFunc)->Apply(CustomArgs); \
-  BENCHMARK_CAPTURE(BM_DeltaBitPackDecode, Name, &GenFunc)->Apply(CustomArgs); \
-  BENCHMARK_CAPTURE(BM_PlainZstdEncode, Name, &GenFunc)->Apply(CustomArgs);    \
-  BENCHMARK_CAPTURE(BM_PlainZstdDecode, Name, &GenFunc)->Apply(CustomArgs);    \
-  BENCHMARK_CAPTURE(BM_PlainLz4Encode, Name, &GenFunc)->Apply(CustomArgs);     \
-  BENCHMARK_CAPTURE(BM_PlainLz4Decode, Name, &GenFunc)->Apply(CustomArgs);     \
-  BENCHMARK_CAPTURE(BM_RleBitPackEncode, Name, &GenFunc)->Apply(CustomArgs);   \
-  BENCHMARK_CAPTURE(BM_RleBitPackDecode, Name, &GenFunc)->Apply(CustomArgs);   \
-  BENCHMARK_CAPTURE(BM_BssZstdEncode, Name, &GenFunc)->Apply(CustomArgs);      \
-  BENCHMARK_CAPTURE(BM_BssZstdDecode, Name, &GenFunc)->Apply(CustomArgs);      \
-  BENCHMARK_CAPTURE(BM_BssLz4Encode, Name, &GenFunc)->Apply(CustomArgs);       \
+#define REGISTER_DATASET(Name, GenFunc)                                            \
+  BENCHMARK_CAPTURE(BM_PforEncode, Name, &GenFunc)->Apply(CustomArgs);             \
+  BENCHMARK_CAPTURE(BM_PforDecode, Name, &GenFunc)->Apply(CustomArgs);             \
+  BENCHMARK_CAPTURE(BM_PforRawEncode, Name, &GenFunc)->Apply(CustomArgs);          \
+  BENCHMARK_CAPTURE(BM_PforPatchedDeltaEncode, Name, &GenFunc)->Apply(CustomArgs); \
+  BENCHMARK_CAPTURE(BM_PforPatchedDeltaDecode, Name, &GenFunc)->Apply(CustomArgs); \
+  BENCHMARK_CAPTURE(BM_PforDbpDeltaEncode, Name, &GenFunc)->Apply(CustomArgs);     \
+  BENCHMARK_CAPTURE(BM_PforDbpDeltaDecode, Name, &GenFunc)->Apply(CustomArgs);     \
+  BENCHMARK_CAPTURE(BM_DeltaBitPackEncode, Name, &GenFunc)->Apply(CustomArgs);     \
+  BENCHMARK_CAPTURE(BM_DeltaBitPackDecode, Name, &GenFunc)->Apply(CustomArgs);     \
+  BENCHMARK_CAPTURE(BM_PlainZstdEncode, Name, &GenFunc)->Apply(CustomArgs);        \
+  BENCHMARK_CAPTURE(BM_PlainZstdDecode, Name, &GenFunc)->Apply(CustomArgs);        \
+  BENCHMARK_CAPTURE(BM_PlainLz4Encode, Name, &GenFunc)->Apply(CustomArgs);         \
+  BENCHMARK_CAPTURE(BM_PlainLz4Decode, Name, &GenFunc)->Apply(CustomArgs);         \
+  BENCHMARK_CAPTURE(BM_RleBitPackEncode, Name, &GenFunc)->Apply(CustomArgs);       \
+  BENCHMARK_CAPTURE(BM_RleBitPackDecode, Name, &GenFunc)->Apply(CustomArgs);       \
+  BENCHMARK_CAPTURE(BM_BssZstdEncode, Name, &GenFunc)->Apply(CustomArgs);          \
+  BENCHMARK_CAPTURE(BM_BssZstdDecode, Name, &GenFunc)->Apply(CustomArgs);          \
+  BENCHMARK_CAPTURE(BM_BssLz4Encode, Name, &GenFunc)->Apply(CustomArgs);           \
   BENCHMARK_CAPTURE(BM_BssLz4Decode, Name, &GenFunc)->Apply(CustomArgs);
 
 // Same as REGISTER_DATASET but for int64 (BIGINT) columns; benchmark names get
 // the "64" codec suffix (e.g. BM_Pfor64Encode) to distinguish them.
-#define REGISTER_DATASET64(Name, GenFunc)                                        \
-  BENCHMARK_CAPTURE(BM_Pfor64Encode, Name, &GenFunc)->Apply(CustomArgs);         \
-  BENCHMARK_CAPTURE(BM_Pfor64Decode, Name, &GenFunc)->Apply(CustomArgs);         \
-  BENCHMARK_CAPTURE(BM_DeltaBitPack64Encode, Name, &GenFunc)->Apply(CustomArgs); \
-  BENCHMARK_CAPTURE(BM_DeltaBitPack64Decode, Name, &GenFunc)->Apply(CustomArgs); \
-  BENCHMARK_CAPTURE(BM_PlainZstd64Encode, Name, &GenFunc)->Apply(CustomArgs);    \
-  BENCHMARK_CAPTURE(BM_PlainZstd64Decode, Name, &GenFunc)->Apply(CustomArgs);    \
-  BENCHMARK_CAPTURE(BM_PlainLz464Encode, Name, &GenFunc)->Apply(CustomArgs);     \
-  BENCHMARK_CAPTURE(BM_PlainLz464Decode, Name, &GenFunc)->Apply(CustomArgs);     \
-  BENCHMARK_CAPTURE(BM_RleBitPack64Encode, Name, &GenFunc)->Apply(CustomArgs);   \
-  BENCHMARK_CAPTURE(BM_RleBitPack64Decode, Name, &GenFunc)->Apply(CustomArgs);   \
-  BENCHMARK_CAPTURE(BM_BssZstd64Encode, Name, &GenFunc)->Apply(CustomArgs);      \
-  BENCHMARK_CAPTURE(BM_BssZstd64Decode, Name, &GenFunc)->Apply(CustomArgs);      \
-  BENCHMARK_CAPTURE(BM_BssLz464Encode, Name, &GenFunc)->Apply(CustomArgs);       \
+#define REGISTER_DATASET64(Name, GenFunc)                                            \
+  BENCHMARK_CAPTURE(BM_Pfor64Encode, Name, &GenFunc)->Apply(CustomArgs);             \
+  BENCHMARK_CAPTURE(BM_Pfor64Decode, Name, &GenFunc)->Apply(CustomArgs);             \
+  BENCHMARK_CAPTURE(BM_PforRaw64Encode, Name, &GenFunc)->Apply(CustomArgs);          \
+  BENCHMARK_CAPTURE(BM_PforPatchedDelta64Encode, Name, &GenFunc)->Apply(CustomArgs); \
+  BENCHMARK_CAPTURE(BM_PforPatchedDelta64Decode, Name, &GenFunc)->Apply(CustomArgs); \
+  BENCHMARK_CAPTURE(BM_PforDbpDelta64Encode, Name, &GenFunc)->Apply(CustomArgs);     \
+  BENCHMARK_CAPTURE(BM_PforDbpDelta64Decode, Name, &GenFunc)->Apply(CustomArgs);     \
+  BENCHMARK_CAPTURE(BM_DeltaBitPack64Encode, Name, &GenFunc)->Apply(CustomArgs);     \
+  BENCHMARK_CAPTURE(BM_DeltaBitPack64Decode, Name, &GenFunc)->Apply(CustomArgs);     \
+  BENCHMARK_CAPTURE(BM_PlainZstd64Encode, Name, &GenFunc)->Apply(CustomArgs);        \
+  BENCHMARK_CAPTURE(BM_PlainZstd64Decode, Name, &GenFunc)->Apply(CustomArgs);        \
+  BENCHMARK_CAPTURE(BM_PlainLz464Encode, Name, &GenFunc)->Apply(CustomArgs);         \
+  BENCHMARK_CAPTURE(BM_PlainLz464Decode, Name, &GenFunc)->Apply(CustomArgs);         \
+  BENCHMARK_CAPTURE(BM_RleBitPack64Encode, Name, &GenFunc)->Apply(CustomArgs);       \
+  BENCHMARK_CAPTURE(BM_RleBitPack64Decode, Name, &GenFunc)->Apply(CustomArgs);       \
+  BENCHMARK_CAPTURE(BM_BssZstd64Encode, Name, &GenFunc)->Apply(CustomArgs);          \
+  BENCHMARK_CAPTURE(BM_BssZstd64Decode, Name, &GenFunc)->Apply(CustomArgs);          \
+  BENCHMARK_CAPTURE(BM_BssLz464Encode, Name, &GenFunc)->Apply(CustomArgs);           \
   BENCHMARK_CAPTURE(BM_BssLz464Decode, Name, &GenFunc)->Apply(CustomArgs);
 
 // ClickBench datasets

From abbf3662ab54df1879052fc32884480b8a613ae2 Mon Sep 17 00:00:00 2001
From: Prateek Gaur <prateek.gaur@snowflake.com>
Date: Fri, 4 Sep 2026 19:20:37 +0000
Subject: [PATCH 13/27] Add lane-interleaved packing to PFOR

Packing 1024 values as 32 lanes that advance together lets a decoder
unpack them with plain vector shifts at any width. This adds a portable
32-lane kernel and records the layout in the page header. Only complete
int32 vectors use it; int64 and partial tail vectors stay sequential.
---
 .../fastlanes/fastlanes_kernels_internal.h    | 182 ++++++++++++++++++
 cpp/src/arrow/util/pfor/pfor.cc               | 102 +++++++++-
 .../arrow/util/pfor/pfor_constants_internal.h |  34 +++-
 cpp/src/arrow/util/pfor/pfor_internal.h       |  34 +++-
 cpp/src/arrow/util/pfor/pfor_wrapper.cc       |  45 ++++-
 .../arrow/util/pfor/pfor_wrapper_internal.h   |  16 +-
 6 files changed, 394 insertions(+), 19 deletions(-)
 create mode 100644 cpp/src/arrow/util/fastlanes/fastlanes_kernels_internal.h

diff --git a/cpp/src/arrow/util/fastlanes/fastlanes_kernels_internal.h b/cpp/src/arrow/util/fastlanes/fastlanes_kernels_internal.h
new file mode 100644
index 000000000000..b9df86d12043
--- /dev/null
+++ b/cpp/src/arrow/util/fastlanes/fastlanes_kernels_internal.h
@@ -0,0 +1,182 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+// Lane-interleaved bit-packing kernels (header-only).
+//
+// A portable port of the lane-interleaved 1024-bit container from FastLanes
+// (Afroozeh & Boncz, VLDB '23). There are no SIMD intrinsics here: the inner
+// lane loop is shaped so that every lane does identical work, which is what
+// lets the compiler auto-vectorize one source body to 4-wide NEON, 8-wide
+// AVX2 or 16-wide AVX-512 without a per-ISA variant.
+//
+// FastLanes couples two independent ideas, and only the container is here. The
+// other is the FL_ORDER permutation (the 8x16 -> 16x8 within-sub-block
+// transpose plus the 04261537 sub-block reorder), which exists to give a
+// sequential codec -- DELTA, RLE -- one independent chain per lane, and to let
+// one packed buffer be read at several lane widths. PFOR has no sequential
+// dependency to break, and Parquet's decoder contract is positional, so
+// FL_ORDER would have to be undone by a gather before any value could be handed
+// back. It is deliberately absent: this layout returns values in input order,
+// so nothing has to be permuted on the way out and exception positions stay
+// meaningful without translation.
+//
+// Within a 1024-value block (32 lanes x 32 rows for uint32_t), the packed
+// buffer holds w u32 rows of 32 u32 words, where w is the bit width. Row r,
+// lane l contributes to packed[word * 32 + l] at bit shift (r*w) % 32, where
+// word = (r*w) / 32, possibly straddling into packed[word * 32 + 32 + l].
+// (word == r only when w == 32.)
+//
+// Bits are assembled exactly as sequential bit-packing assembles them: within
+// one lane, successive rows occupy successive bit positions LSB-first, and a
+// value that runs off the end of a word continues in the low bits of the next.
+// The two layouts differ only in which values land at adjacent bit positions --
+// successive rows of one lane here, successive values of the stream in
+// arrow::internal::unpack -- not in how the bits of a value are laid out. That
+// is why the shift and the straddle depend on the row and never on the lane,
+// and so why all 32 lanes do identical work.
+//
+// The payload is byte-identical in size to the sequential layout for a full
+// block: 1024 * w bits either way, or 128 * w bytes.
+
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+
+#include "arrow/util/macros.h"
+
+namespace arrow {
+namespace util {
+namespace fastlanes {
+
+constexpr size_t kBlockSize = 1024;
+constexpr size_t kLanes = 32;         // 1024 / sizeof(uint32_t) / 8
+constexpr size_t kRowsPerBlock = 32;  // 1024 / kLanes
+
+static_assert(kLanes * kRowsPerBlock == kBlockSize,
+              "every value of a block must land in exactly one lane and row");
+
+// ---------------------------------------------------------------------------
+// Pack: 1024 u32 inputs, in input order -> w*32 u32 packed words.
+// ---------------------------------------------------------------------------
+template <uint32_t w>
+inline void PackBlock(const uint32_t* ARROW_RESTRICT in, uint32_t* ARROW_RESTRICT out) {
+  static_assert(w >= 1 && w <= 32);
+  constexpr uint32_t kMask = (w == 32) ? 0xFFFFFFFFu : ((1u << w) - 1);
+
+  if constexpr (w == 32) {
+    std::memcpy(out, in, kBlockSize * sizeof(uint32_t));
+    return;
+  }
+
+  std::memset(out, 0, w * kLanes * sizeof(uint32_t));
+
+#pragma GCC unroll 32
+  for (uint32_t row = 0; row < kRowsPerBlock; ++row) {
+    constexpr uint32_t kT = 32;
+    const uint32_t startBit = row * w;
+    const uint32_t word = startBit / kT;
+    const uint32_t shift = startBit % kT;
+    const uint32_t endBit = startBit + w;
+    const uint32_t endWord = (endBit - 1) / kT;
+
+    if (word == endWord) {
+      for (uint32_t lane = 0; lane < kLanes; ++lane) {
+        const uint32_t v = in[row * kLanes + lane] & kMask;
+        out[word * kLanes + lane] |= (v << shift);
+      }
+    } else {
+      // shift is never 0 in this branch -- a value that straddles has to start
+      // partway into its word -- so the >> below is never a shift by 32.
+      const uint32_t lowBits = kT - shift;
+      for (uint32_t lane = 0; lane < kLanes; ++lane) {
+        const uint32_t v = in[row * kLanes + lane] & kMask;
+        out[word * kLanes + lane] |= (v << shift);
+        out[endWord * kLanes + lane] |= (v >> lowBits);
+      }
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Unpack: w*32 packed u32 words -> 1024 u32 outputs in input order.
+//
+// With kHasBias, `bias` is added to every value before it is stored, so a
+// frame-of-reference decoder does not need a second pass over the output to
+// add it. That pass is not cheap: measured against the unpack it follows, it
+// costs 1.47x-2.40x, and a pass that only copies costs the same as one that
+// adds, so what is paid for is the traversal rather than the arithmetic. The
+// add is modular in uint32_t, matching the encoder's subtraction.
+//
+// kHasBias is a template parameter rather than a runtime argument so that the
+// no-bias instantiations carry no test in their inner loop.
+// ---------------------------------------------------------------------------
+template <uint32_t w, bool kHasBias = false>
+inline void UnpackBlock(const uint32_t* ARROW_RESTRICT packed,
+                        uint32_t* ARROW_RESTRICT out, uint32_t bias = 0) {
+  static_assert(w >= 1 && w <= 32);
+  constexpr uint32_t kMask = (w == 32) ? 0xFFFFFFFFu : ((1u << w) - 1);
+
+  if constexpr (w == 32) {
+    if constexpr (kHasBias) {
+      // A loop, not memcpy-then-add: both pointers are restrict-qualified
+      // uint32_t*, so this vectorizes and stays a single traversal.
+      for (size_t i = 0; i < kBlockSize; ++i) {
+        out[i] = packed[i] + bias;
+      }
+    } else {
+      std::memcpy(out, packed, kBlockSize * sizeof(uint32_t));
+    }
+    return;
+  }
+
+#pragma GCC unroll 32
+  for (uint32_t row = 0; row < kRowsPerBlock; ++row) {
+    constexpr uint32_t kT = 32;
+    const uint32_t startBit = row * w;
+    const uint32_t word = startBit / kT;
+    const uint32_t shift = startBit % kT;
+    const uint32_t endBit = startBit + w;
+    const uint32_t endWord = (endBit - 1) / kT;
+
+    if (word == endWord) {
+      for (uint32_t lane = 0; lane < kLanes; ++lane) {
+        uint32_t v = (packed[word * kLanes + lane] >> shift) & kMask;
+        if constexpr (kHasBias) {
+          v += bias;
+        }
+        out[row * kLanes + lane] = v;
+      }
+    } else {
+      const uint32_t lowBits = kT - shift;
+      for (uint32_t lane = 0; lane < kLanes; ++lane) {
+        const uint32_t lo = packed[word * kLanes + lane] >> shift;
+        const uint32_t hi = packed[endWord * kLanes + lane] << lowBits;
+        uint32_t v = (lo | hi) & kMask;
+        if constexpr (kHasBias) {
+          v += bias;
+        }
+        out[row * kLanes + lane] = v;
+      }
+    }
+  }
+}
+
+}  // namespace fastlanes
+}  // namespace util
+}  // namespace arrow
diff --git a/cpp/src/arrow/util/pfor/pfor.cc b/cpp/src/arrow/util/pfor/pfor.cc
index ab3fe24407d6..23a3f88418e3 100644
--- a/cpp/src/arrow/util/pfor/pfor.cc
+++ b/cpp/src/arrow/util/pfor/pfor.cc
@@ -21,7 +21,8 @@
 //   - Vector size: 1024
 //   - Max exceptions: PforConstants::ExceptionCountType
 //   - Exception values: original integers (not FOR offsets)
-//   - Bit packing: Arrow's BitWriter/unpack
+//   - Bit packing: Arrow's BitWriter/unpack, or the lane-interleaved kernels in
+//     arrow::util::fastlanes when the page asks for that layout
 
 #include "arrow/util/pfor/pfor_internal.h"
 
@@ -30,11 +31,13 @@
 #include <cstring>
 #include <limits>
 #include <span>
+#include <utility>
 
 #include "arrow/util/bit_stream_utils_internal.h"
 #include "arrow/util/bit_util.h"
 #include "arrow/util/bpacking_internal.h"
 #include "arrow/util/endian.h"
+#include "arrow/util/fastlanes/fastlanes_kernels_internal.h"
 #include "arrow/util/logging.h"
 #include "arrow/util/macros.h"
 #include "arrow/util/ubsan.h"
@@ -76,6 +79,61 @@ BitWidthResult PforCompression<T>::FindOptimalBitWidth(const UnsignedT* deltas,
   return BestWidthFromHistogram<T>(histogram, num_elements, &cost_bits);
 }
 
+namespace {
+
+static_assert(PforConstants::kPforVectorSize ==
+                  static_cast<int64_t>(fastlanes::kBlockSize),
+              "the interleaved layout is only reachable while PFOR's vector size "
+              "and the interleaved block size are the same number");
+
+// Dispatch a runtime bit width into the templated interleaved kernels. Only
+// reached when InterleavedApplies<T>() holds, so the width is in [1, 32] and
+// the block is a full 1024 values.
+//
+// A table of function pointers rather than a switch over 32 cases, because the
+// table keeps each width's body out of line. Folding all 32 into one dispatch
+// function is not free: doing exactly that to Arrow's NEON unpacker cost
+// between 1.2x and 2.1x, the compiler having lost the register allocation it
+// finds for a body it compiles on its own. One indirect call per 1024 values
+// is not measurable against that.
+using InterleavedPackFn = void (*)(const uint32_t*, uint32_t*);
+using InterleavedUnpackFn = void (*)(const uint32_t*, uint32_t*, uint32_t);
+
+// Index by bit width: entry w handles width w, and entry 0 is never called
+// because a vector of width 0 is constant and never reaches a kernel.
+template <size_t... W>
+constexpr std::array<InterleavedPackFn, 33> MakePackTable(std::index_sequence<W...>) {
+  return {nullptr, &fastlanes::PackBlock<W + 1>...};
+}
+
+template <bool kHasBias, size_t... W>
+constexpr std::array<InterleavedUnpackFn, 33> MakeUnpackTable(std::index_sequence<W...>) {
+  return {nullptr, &fastlanes::UnpackBlock<W + 1, kHasBias>...};
+}
+
+constexpr auto kPackTable = MakePackTable(std::make_index_sequence<32>{});
+constexpr auto kUnpackTable = MakeUnpackTable<false>(std::make_index_sequence<32>{});
+constexpr auto kUnpackBiasTable = MakeUnpackTable<true>(std::make_index_sequence<32>{});
+
+inline void InterleavedPackBlock(uint8_t bit_width, const uint32_t* in, uint32_t* out) {
+  ARROW_DCHECK(bit_width >= 1 && bit_width <= 32);
+  kPackTable[bit_width](in, out);
+}
+
+// The frame of reference is folded into the kernel's own store, so a non-zero
+// frame costs no second pass over the output.
+inline void InterleavedUnpackBlock(uint8_t bit_width, const uint32_t* packed,
+                                   uint32_t* out, uint32_t bias) {
+  ARROW_DCHECK(bit_width >= 1 && bit_width <= 32);
+  if (bias == 0) {
+    kUnpackTable[bit_width](packed, out, 0);
+  } else {
+    kUnpackBiasTable[bit_width](packed, out, bias);
+  }
+}
+
+}  // namespace
+
 // ----------------------------------------------------------------------
 // EncodeVector
 
@@ -153,12 +211,25 @@ PforEncodedVector<T> PforCompression<T>::EncodeVector(const T* values,
         bit_util::BytesForBits(static_cast<int64_t>(num_elements) * bit_width);
     result.mutable_packed_values().resize(static_cast<size_t>(packed_size), 0);
 
-    bit_util::BitWriter writer(result.mutable_packed_values().data(),
-                               static_cast<int>(packed_size));
-    for (int32_t i = 0; i < num_elements; ++i) {
-      writer.PutValue(static_cast<uint64_t>(offsets[i]), bit_width);
+    if (InterleavedApplies<T>(options.mode, num_elements)) {
+      // A full block of 4-byte deltas. The interleaved payload is 128 * w bytes,
+      // which is what BytesForBits computed above, so both layouts write the
+      // same number of bytes and only their arrangement differs. Values keep
+      // their input positions, so there is nothing to gather on the way in and
+      // the exception positions recorded in step 4 stay correct.
+      if constexpr (sizeof(T) == 4) {
+        InterleavedPackBlock(
+            bit_width, reinterpret_cast<const uint32_t*>(offsets),
+            reinterpret_cast<uint32_t*>(result.mutable_packed_values().data()));
+      }
+    } else {
+      bit_util::BitWriter writer(result.mutable_packed_values().data(),
+                                 static_cast<int>(packed_size));
+      for (int32_t i = 0; i < num_elements; ++i) {
+        writer.PutValue(static_cast<uint64_t>(offsets[i]), bit_width);
+      }
+      writer.Flush();
     }
-    writer.Flush();
   }
 
   return result;
@@ -169,7 +240,8 @@ PforEncodedVector<T> PforCompression<T>::EncodeVector(const T* values,
 
 template <typename T>
 Result<int64_t> PforCompression<T>::DecodeVector(std::span<const uint8_t> data,
-                                                 int32_t num_elements, T* values) {
+                                                 int32_t num_elements, T* values,
+                                                 PackingMode mode) {
   // Step 1: Read vector info
   ARROW_ASSIGN_OR_RAISE(auto info, PforVectorInfo<T>::Load(data));
   const int64_t info_bytes = info.stored_bytes();
@@ -240,7 +312,21 @@ Result<int64_t> PforCompression<T>::DecodeVector(std::span<const uint8_t> data,
     const auto readable_bytes = static_cast<int>(std::min<int64_t>(
         static_cast<int64_t>(data.size()) - info_bytes, std::numeric_limits<int>::max()));
 
-    if (unsigned_for == 0) {
+    if (InterleavedApplies<T>(mode, num_elements)) {
+      // The interleaved kernel writes values in input order, so it writes into
+      // `values` directly for the same reason the two sequential paths below do:
+      // T and UnsignedT are the same width, so the unsigned bits the kernel
+      // stores are the signed values. It also takes the frame of reference as a
+      // bias, so a non-zero frame costs no extra traversal -- there is no
+      // separate FOR==0 fast path to write here. Exceptions are patched in
+      // step 4, at the positions the encoder recorded, which need no
+      // translation because nothing was permuted.
+      if constexpr (sizeof(T) == 4) {
+        InterleavedUnpackBlock(
+            info.bit_width(), reinterpret_cast<const uint32_t*>(read_ptr),
+            reinterpret_cast<uint32_t*>(values), static_cast<uint32_t>(unsigned_for));
+      }
+    } else if (unsigned_for == 0) {
       // FOR is zero: there is no bias to add, so unpack straight into the
       // output. T and UnsignedT are the same width, so the unsigned bits the
       // unpacker writes are the signed values — no scratch buffer and no
diff --git a/cpp/src/arrow/util/pfor/pfor_constants_internal.h b/cpp/src/arrow/util/pfor/pfor_constants_internal.h
index 863ffa5a7343..346c775449eb 100644
--- a/cpp/src/arrow/util/pfor/pfor_constants_internal.h
+++ b/cpp/src/arrow/util/pfor/pfor_constants_internal.h
@@ -63,11 +63,41 @@ class PforConstants {
   /// constant behind; StoreHeader and LoadHeader are the two readers of it.
   static constexpr int64_t kHeaderSize =
       sizeof(uint8_t) + sizeof(uint8_t) + sizeof(uint8_t) + sizeof(int32_t);
+};
 
-  /// Packing mode: FOR + bit-packing (currently the only mode).
-  static constexpr uint8_t kPackingModeForBitPack = 0;
+/// \brief Layout of the bit-packed payload, recorded in the page header.
+///
+/// One byte per page, not per vector: a reader picks its unpacking kernel once
+/// and the choice is uniform for the page, which is also what makes a reader
+/// that does not implement a layout able to reject the page up front instead of
+/// misreading it.
+enum class PackingMode : uint8_t {
+  /// Frame of reference plus a sequential little-endian bit-packed stream --
+  /// the layout every Parquet implementation already has, expanded here by
+  /// arrow::internal::unpack. Values of a vector occupy consecutive bit
+  /// positions in stream order.
+  kForBitPack = 0,
+
+  /// Frame of reference plus the lane-interleaved container from FastLanes
+  /// (Afroozeh & Boncz, VLDB '23), packed by arrow::util::fastlanes. Same
+  /// payload size as kForBitPack and the same value order on the way out; the
+  /// bits of one vector are distributed across 32 lanes so that a register load
+  /// brings in values the unpacker needs together.
+  ///
+  /// Only legal for a page whose vector size is exactly the interleaved block
+  /// size (1024) and whose values are 4 bytes wide. A vector shorter than a
+  /// full block -- which is to say the tail vector of a page -- uses
+  /// kForBitPack, so a page mixes the two, and the decoder derives which is
+  /// which from the element count rather than reading a per-vector flag.
+  kForBitPackInterleaved = 1,
 };
 
+/// \brief Whether `mode` names a layout this build can read and write.
+inline bool IsSupportedPackingMode(uint8_t mode) {
+  return mode == static_cast<uint8_t>(PackingMode::kForBitPack) ||
+         mode == static_cast<uint8_t>(PackingMode::kForBitPackInterleaved);
+}
+
 /// \brief Type traits for PFOR integer types
 template <typename T>
 struct PforTypeTraits {};
diff --git a/cpp/src/arrow/util/pfor/pfor_internal.h b/cpp/src/arrow/util/pfor/pfor_internal.h
index c5bfcfae4f74..9fcf182b78b1 100644
--- a/cpp/src/arrow/util/pfor/pfor_internal.h
+++ b/cpp/src/arrow/util/pfor/pfor_internal.h
@@ -43,6 +43,23 @@ namespace arrow {
 namespace util {
 namespace pfor {
 
+// ----------------------------------------------------------------------
+// Layout applicability
+
+/// \brief Whether the interleaved layout covers a vector of this size and type.
+///
+/// The interleaved container is defined for one block of 1024 four-byte values.
+/// Anything else -- a 64-bit column, or the short tail vector of a page whose
+/// length is not a multiple of the vector size -- takes the sequential layout.
+/// So a page can hold both, and neither side needs a per-vector flag to say
+/// which: the element count answers it, and encoder and decoder ask the same
+/// question of the same number.
+template <typename T>
+constexpr bool InterleavedApplies(PackingMode mode, int32_t num_elements) {
+  return mode == PackingMode::kForBitPackInterleaved && sizeof(T) == 4 &&
+         num_elements == static_cast<int32_t>(PforConstants::kPforVectorSize);
+}
+
 // ----------------------------------------------------------------------
 // Per-vector metadata
 
@@ -221,6 +238,13 @@ struct PforEncodeOptions {
   /// Require the delta representation even when the raw representation is cheaper.
   /// Off by default; set it only to exercise or measure the delta path directly.
   bool force_delta = false;
+  /// Layout for the bit-packed payload. Advisory:
+  /// PackingMode::kForBitPackInterleaved is honoured only when
+  /// InterleavedApplies<T>() holds for this vector, and the sequential layout
+  /// is used otherwise. The caller cannot tell from the returned vector which
+  /// was used -- the page header records the request and the decoder
+  /// re-derives the same answer.
+  PackingMode mode = PackingMode::kForBitPack;
 };
 
 /// \brief PFOR compression and decompression algorithms
@@ -249,7 +273,8 @@ class ARROW_EXPORT PforCompression {
   ///
   /// \param[in] values input integer values
   /// \param[in] num_elements number of elements (up to vector_size)
-  /// \param[in] options what the encoder is allowed to choose
+  /// \param[in] options what the encoder is allowed to choose: whether to
+  ///            difference the vector, and which bit-packing layout to use
   /// \pre num_elements > 0; there is no frame of reference for an empty vector
   /// \return the encoded vector with all sections
   static PforEncodedVector<T> EncodeVector(const T* values, int32_t num_elements,
@@ -260,9 +285,14 @@ class ARROW_EXPORT PforCompression {
   /// \param[in] data span over the compressed vector data
   /// \param[in] num_elements number of elements in this vector
   /// \param[out] values output buffer for num_elements decoded integers
+  /// \param[in] mode the layout the page header declares. Must be the mode the
+  ///            encoder was given: the two layouts produce payloads of the same
+  ///            size, so reading one as the other yields wrong values rather
+  ///            than a length error.
   /// \return number of bytes consumed from data, or error
   static Result<int64_t> DecodeVector(std::span<const uint8_t> data, int32_t num_elements,
-                                      T* values);
+                                      T* values,
+                                      PackingMode mode = PackingMode::kForBitPack);
 
   /// \brief Calculate the serialized size of an encoded vector
   static int64_t SerializedVectorSize(const PforEncodedVector<T>& vec,
diff --git a/cpp/src/arrow/util/pfor/pfor_wrapper.cc b/cpp/src/arrow/util/pfor/pfor_wrapper.cc
index 65dbafe4a511..ec3a93d055a0 100644
--- a/cpp/src/arrow/util/pfor/pfor_wrapper.cc
+++ b/cpp/src/arrow/util/pfor/pfor_wrapper.cc
@@ -128,7 +128,7 @@ Result<typename PforWrapper<T>::PforHeader> PforWrapper<T>::LoadHeader(
   header.value_byte_width = util::SafeLoadAs<uint8_t>(ptr + 2);
   header.num_elements = bit_util::FromLittleEndian(util::SafeLoadAs<int32_t>(ptr + 3));
 
-  if (header.packing_mode != PforConstants::kPackingModeForBitPack) {
+  if (!IsSupportedPackingMode(header.packing_mode)) {
     return Status::Invalid("PFOR unsupported packing mode: ",
                            static_cast<int>(header.packing_mode));
   }
@@ -145,6 +145,23 @@ Result<typename PforWrapper<T>::PforHeader> PforWrapper<T>::LoadHeader(
   if (header.num_elements < 0) {
     return Status::Invalid("PFOR invalid num_elements: ", header.num_elements);
   }
+  // The interleaved layout is defined for one block of 1024 four-byte values, so
+  // a page that declares it and then declares a vector size or a value width it
+  // can never apply to is self-contradictory. Rejecting it here means the decode
+  // loop never has to ask whether the mode it was handed is reachable.
+  if (header.packing_mode == static_cast<uint8_t>(PackingMode::kForBitPackInterleaved)) {
+    if (header.log_vector_size != PforConstants::kDefaultLogVectorSize) {
+      return Status::Invalid("PFOR interleaved layout needs a vector size of ",
+                             PforConstants::kPforVectorSize,
+                             " but the page declares log_vector_size ",
+                             static_cast<int>(header.log_vector_size));
+    }
+    if (header.value_byte_width != 4) {
+      return Status::Invalid(
+          "PFOR interleaved layout needs 4-byte values but the page declares ",
+          static_cast<int>(header.value_byte_width));
+    }
+  }
   return header;
 }
 
@@ -194,9 +211,20 @@ Status PforWrapper<T>::Encode(const T* values, int32_t num_values, int32_t vecto
 
   uint8_t* dest = comp;
 
+  // A page's layout is one byte in its header, so a request the page cannot
+  // satisfy is answered by writing the layout used rather than by failing: a
+  // writer sets the option once for a file and every column type and vector
+  // size then has to encode under it. LoadHeader rejects the combination this
+  // drops, so the downgrade keeps the header valid.
+  const PackingMode effective_mode =
+      (options.mode == PackingMode::kForBitPackInterleaved && sizeof(T) == 4 &&
+       vector_size == static_cast<int32_t>(PforConstants::kPforVectorSize))
+          ? PackingMode::kForBitPackInterleaved
+          : PackingMode::kForBitPack;
+
   // Step 1: Write header
   PforHeader header;
-  header.packing_mode = PforConstants::kPackingModeForBitPack;
+  header.packing_mode = static_cast<uint8_t>(effective_mode);
   header.log_vector_size = log_vector_size;
   header.value_byte_width = sizeof(T);
   header.num_elements = num_values;
@@ -220,8 +248,14 @@ Status PforWrapper<T>::Encode(const T* values, int32_t num_values, int32_t vecto
     int32_t start_idx = v * vector_size;
     int32_t elements_in_vector = std::min(vector_size, num_values - start_idx);
 
-    auto encoded =
-        PforCompression<T>::EncodeVector(values + start_idx, elements_in_vector, options);
+    // EncodeVector applies the interleaved layout only to a full block, so the
+    // short tail vector of a page falls back on its own; the decoder derives the
+    // same split from the same element count.
+    auto encoded = PforCompression<T>::EncodeVector(
+        values + start_idx, elements_in_vector,
+        PforEncodeOptions{.delta_enabled = options.delta_enabled,
+                          .force_delta = options.force_delta,
+                          .mode = effective_mode});
 
     // Serialize to output
     ARROW_ASSIGN_OR_RAISE(
@@ -304,7 +338,8 @@ Status PforWrapper<T>::Decode(const uint8_t* comp, int64_t comp_size, int32_t nu
 
     ARROW_RETURN_NOT_OK(PforCompression<T>::DecodeVector(
         std::span<const uint8_t>(vector_data, src + comp_size - vector_data),
-        elements_in_vector, values + start_idx));
+        elements_in_vector, values + start_idx,
+        static_cast<PackingMode>(header.packing_mode)));
   }
 
   return Status::OK();
diff --git a/cpp/src/arrow/util/pfor/pfor_wrapper_internal.h b/cpp/src/arrow/util/pfor/pfor_wrapper_internal.h
index dbcdcd265a3e..8bafa520a3e8 100644
--- a/cpp/src/arrow/util/pfor/pfor_wrapper_internal.h
+++ b/cpp/src/arrow/util/pfor/pfor_wrapper_internal.h
@@ -94,7 +94,14 @@ class ARROW_EXPORT PforWrapper {
   /// \param[in,out] comp_size input: available buffer size, which must be at
   ///                least GetMaxCompressedSize(num_values, vector_size);
   ///                output: bytes written
-  /// \param[in] options what the encoder is allowed to choose
+  /// \param[in] options what the encoder is allowed to choose: whether to
+  ///            difference the vector, and which bit-packing layout to use.
+  ///            A request for PackingMode::kForBitPackInterleaved that this
+  ///            page cannot satisfy -- a 64-bit column, or a vector size
+  ///            other than kPforVectorSize -- is written as
+  ///            PackingMode::kForBitPack instead of refused, so that one
+  ///            writer-level setting can cover a file of mixed column types.
+  ///            Either way the page says which layout it holds.
   /// \return Status::OK on success, or an error if the arguments are invalid
   static Status Encode(const T* values, int32_t num_values, int32_t vector_size,
                        uint8_t* comp, int64_t* comp_size,
@@ -113,6 +120,11 @@ class ARROW_EXPORT PforWrapper {
   ///            valid: an all-null page is a bare header.
   /// \param[out] values pointer to output buffer, sized for num_values
   /// \return Status::OK on success, or an error if the data is malformed
+  ///
+  /// The payload layout is not a parameter: it comes from the page's own header,
+  /// so a reader does not have to be told which one a page holds, and a page
+  /// written under a layout this build does not implement is rejected by
+  /// LoadHeader rather than misread.
   static Status Decode(const uint8_t* comp, int64_t comp_size, int32_t num_values,
                        T* values);
 
@@ -141,7 +153,7 @@ class ARROW_EXPORT PforWrapper {
  private:
   /// \brief Page header structure (7 bytes)
   struct PforHeader {
-    uint8_t packing_mode;      // 0 = FOR + bit-packing
+    uint8_t packing_mode;      // PackingMode: sequential or interleaved
     uint8_t log_vector_size;   // log2(vector_size)
     uint8_t value_byte_width;  // sizeof(T): 4 or 8
     int32_t num_elements;      // total element count

From 3c2054c884407c8073a403b4f6c490aedcfd3f3d Mon Sep 17 00:00:00 2001
From: Prateek Gaur <prateek.gaur@snowflake.com>
Date: Fri, 4 Sep 2026 19:27:13 +0000
Subject: [PATCH 14/27] Integrate and test interleaved PFOR writing

Exposes the layout as an experimental writer option. The tests cover
every bit width, exception patching, the sequential tail, equal encoded
size for both layouts, and a round trip through a Parquet file.
Vector-at-a-time reads used to lose the packing mode and decode an
interleaved vector as sequential; they now carry it through.
---
 cpp/src/arrow/util/pfor/pfor_test.cc          | 331 ++++++++++++++++++
 cpp/src/arrow/util/pfor/pfor_wrapper.cc       |   3 +-
 .../arrow/util/pfor/pfor_wrapper_internal.h   |   5 +
 cpp/src/parquet/arrow/arrow_encoding_test.cc  |  65 ++++
 cpp/src/parquet/encoder.cc                    |  19 +-
 cpp/src/parquet/encoding.h                    |   5 +-
 cpp/src/parquet/properties.h                  |  40 ++-
 7 files changed, 459 insertions(+), 9 deletions(-)

diff --git a/cpp/src/arrow/util/pfor/pfor_test.cc b/cpp/src/arrow/util/pfor/pfor_test.cc
index b17e5260dd4f..c0d55f5d9e08 100644
--- a/cpp/src/arrow/util/pfor/pfor_test.cc
+++ b/cpp/src/arrow/util/pfor/pfor_test.cc
@@ -1285,4 +1285,335 @@ TYPED_TEST(PforTest, DeltaGateAdmitsTheSawtooth) {
   EXPECT_LE(plan.bit_width, 5);
 }
 
+// Interleaved bit-packing layout
+//
+// The interleaved layout writes the same number of bytes as the sequential one,
+// so a wrong-layout decode returns wrong values rather than running out of
+// input. That makes these round trips the only thing standing between the two
+// layouts, and it is why the tests below also assert that the two payloads are
+// different bytes: without that, a silent fallback on both sides would pass
+// every round trip here.
+
+namespace {
+
+/// The packing_mode byte a page recorded, which is the first byte of the header.
+uint8_t PackingModeOf(const std::vector<uint8_t>& page) { return page[0]; }
+
+/// Build a vector whose deltas need exactly `width` bits, so that a loop over
+/// widths reaches every one of the packing kernels.
+///
+/// A frame of reference of zero exercises the plain unpack; a non-zero one the
+/// unpack that folds the frame into its own store. At the full width of the type
+/// there is no choice between them: deltas that wide only fit under the type's
+/// minimum, so that width is always framed.
+template <typename T>
+std::vector<T> ValuesForWidth(int width, bool zero_frame, int32_t num_values,
+                              uint32_t seed) {
+  using UnsignedT = typename PforTypeTraits<T>::UnsignedType;
+  constexpr int kBits = 8 * static_cast<int>(sizeof(T));
+
+  const T base =
+      width == kBits ? std::numeric_limits<T>::min() : (zero_frame ? T{0} : T{-1000});
+  std::vector<T> values(num_values, base);
+  if (width == 0) {
+    return values;
+  }
+
+  const UnsignedT mask = width == kBits
+                             ? ~UnsignedT{0}
+                             : static_cast<UnsignedT>((UnsignedT{1} << width) - 1);
+  std::mt19937_64 rng(seed);
+  for (int32_t i = 0; i < num_values; ++i) {
+    values[i] = static_cast<T>(static_cast<UnsignedT>(base) +
+                               (static_cast<UnsignedT>(rng()) & mask));
+  }
+  // Pin the two ends, so the vector cannot land on a narrower width by chance.
+  values[0] = base;
+  values[1] = static_cast<T>(static_cast<UnsignedT>(base) + mask);
+  return values;
+}
+
+}  // namespace
+
+/// Every bit width round-trips through the interleaved layout, with and without
+/// a frame of reference to fold into the unpack.
+///
+/// For int64 this exercises the other side of the same request: the layout does
+/// not apply, so the page must come back correct in the sequential layout.
+TYPED_TEST(PforTest, InterleavedAllBitWidths) {
+  using T = TypeParam;
+  constexpr auto kInterleaved = PackingMode::kForBitPackInterleaved;
+  const auto num_values = static_cast<int32_t>(PforConstants::kPforVectorSize);
+
+  for (int width = 0; width <= 32; ++width) {
+    for (const bool zero_frame : {true, false}) {
+      // A 32-bit delta only fits under the minimum of a 32-bit type, so there is
+      // no unframed form of that width to test.
+      if (zero_frame && width == 8 * static_cast<int>(sizeof(T))) continue;
+      const auto values =
+          ValuesForWidth<T>(width, zero_frame, num_values, static_cast<uint32_t>(width));
+
+      int64_t comp_size = PforWrapper<T>::GetMaxCompressedSize(num_values).ValueOrDie();
+      std::vector<uint8_t> page(comp_size);
+      ASSERT_OK(PforWrapper<T>::Encode(values.data(), num_values, page.data(), &comp_size,
+                                       PforEncodeOptions{.mode = kInterleaved}));
+      page.resize(comp_size);
+
+      std::vector<T> decoded(num_values);
+      ASSERT_OK(
+          PforWrapper<T>::Decode(page.data(), comp_size, num_values, decoded.data()))
+          << "width " << width << " zero_frame " << zero_frame;
+      ASSERT_EQ(values, decoded) << "width " << width << " zero_frame " << zero_frame;
+
+      const uint8_t expected_mode =
+          static_cast<uint8_t>(sizeof(T) == 4 ? kInterleaved : PackingMode::kForBitPack);
+      ASSERT_EQ(expected_mode, PackingModeOf(page)) << "width " << width;
+    }
+  }
+}
+
+/// Exceptions are stored at the positions the encoder recorded, and the
+/// interleaved layout does not move values between positions, so those
+/// positions need no translation.
+TYPED_TEST(PforTest, InterleavedWithExceptions) {
+  using T = TypeParam;
+  const auto num_values = static_cast<int32_t>(PforConstants::kPforVectorSize);
+  auto values = TestFixture::RandomValues(num_values, T{100}, T{140}, /*seed=*/7);
+  // First, middle and last position, so an off-by-one in either direction shows.
+  values[0] = std::numeric_limits<T>::max() / 2;
+  values[num_values / 2] = std::numeric_limits<T>::max() / 2;
+  values[num_values - 1] = std::numeric_limits<T>::max() / 2;
+
+  int64_t comp_size = PforWrapper<T>::GetMaxCompressedSize(num_values).ValueOrDie();
+  std::vector<uint8_t> page(comp_size);
+  ASSERT_OK(PforWrapper<T>::Encode(
+      values.data(), num_values, page.data(), &comp_size,
+      PforEncodeOptions{.mode = PackingMode::kForBitPackInterleaved}));
+
+  std::vector<T> decoded(num_values);
+  ASSERT_OK(PforWrapper<T>::Decode(page.data(), comp_size, num_values, decoded.data()));
+  ASSERT_EQ(values, decoded);
+}
+
+/// A page whose length is not a multiple of the vector size ends in a short
+/// vector, which the interleaved layout cannot hold. Both sides derive that from
+/// the element count, so it round-trips without a per-vector flag.
+TYPED_TEST(PforTest, InterleavedShortTailVector) {
+  using T = TypeParam;
+  for (const int32_t num_values : {1, 1023, 1025, 2048, 3000, 4096}) {
+    auto values = TestFixture::RandomValues(num_values, T{0}, T{5000},
+                                            static_cast<uint32_t>(num_values));
+    int64_t comp_size = PforWrapper<T>::GetMaxCompressedSize(num_values).ValueOrDie();
+    std::vector<uint8_t> page(comp_size);
+    ASSERT_OK(PforWrapper<T>::Encode(
+        values.data(), num_values, page.data(), &comp_size,
+        PforEncodeOptions{.mode = PackingMode::kForBitPackInterleaved}));
+
+    std::vector<T> decoded(num_values);
+    ASSERT_OK(PforWrapper<T>::Decode(page.data(), comp_size, num_values, decoded.data()))
+        << "num_values " << num_values;
+    ASSERT_EQ(values, decoded) << "num_values " << num_values;
+  }
+}
+
+/// The two layouts write the same number of bytes, so choosing one costs no
+/// space.
+TYPED_TEST(PforTest, InterleavedCostsNoSpace) {
+  using T = TypeParam;
+  for (const int32_t num_values : {1024, 2048, 3000}) {
+    auto values = TestFixture::RandomValues(num_values, T{0}, T{5000}, /*seed=*/11);
+
+    int64_t sequential_size =
+        PforWrapper<T>::GetMaxCompressedSize(num_values).ValueOrDie();
+    std::vector<uint8_t> sequential(sequential_size);
+    ASSERT_OK(PforWrapper<T>::Encode(values.data(), num_values, sequential.data(),
+                                     &sequential_size));
+
+    int64_t interleaved_size =
+        PforWrapper<T>::GetMaxCompressedSize(num_values).ValueOrDie();
+    std::vector<uint8_t> interleaved(interleaved_size);
+    ASSERT_OK(PforWrapper<T>::Encode(
+        values.data(), num_values, interleaved.data(), &interleaved_size,
+        PforEncodeOptions{.mode = PackingMode::kForBitPackInterleaved}));
+
+    ASSERT_EQ(sequential_size, interleaved_size) << "num_values " << num_values;
+  }
+}
+
+/// The two layouts are different bytes. Without this check, a mode request that
+/// fell back to sequential on both the encode and the decode side would still
+/// pass every round trip above.
+///
+/// At 32 bits the layouts coincide -- the sequential layout puts value i in word
+/// i, and so does the interleaved one -- so the payloads are identical there by
+/// construction, not by accident.
+TEST(PforInterleavedTest, LayoutsDifferBelowThirtyTwoBits) {
+  using T = int32_t;
+  const auto num_values = static_cast<int32_t>(PforConstants::kPforVectorSize);
+
+  for (int width = 1; width <= 32; ++width) {
+    const auto values = ValuesForWidth<T>(width, /*zero_frame=*/width < 32, num_values,
+                                          static_cast<uint32_t>(width));
+
+    int64_t sequential_size =
+        PforWrapper<T>::GetMaxCompressedSize(num_values).ValueOrDie();
+    std::vector<uint8_t> sequential(sequential_size);
+    ASSERT_OK(PforWrapper<T>::Encode(values.data(), num_values, sequential.data(),
+                                     &sequential_size));
+    sequential.resize(sequential_size);
+
+    int64_t interleaved_size =
+        PforWrapper<T>::GetMaxCompressedSize(num_values).ValueOrDie();
+    std::vector<uint8_t> interleaved(interleaved_size);
+    ASSERT_OK(PforWrapper<T>::Encode(
+        values.data(), num_values, interleaved.data(), &interleaved_size,
+        PforEncodeOptions{.mode = PackingMode::kForBitPackInterleaved}));
+    interleaved.resize(interleaved_size);
+
+    ASSERT_EQ(sequential.size(), interleaved.size()) << "width " << width;
+
+    // The cost model is free to choose a narrower width and pay for exceptions,
+    // which would leave this loop testing one width many times over. Read the
+    // width it settled on out of the vector's own metadata: header, then the
+    // one-entry offset array, then the frame of reference.
+    const int64_t bit_width_offset =
+        PforConstants::kHeaderSize +
+        static_cast<int64_t>(sizeof(PforConstants::OffsetType)) +
+        static_cast<int64_t>(sizeof(T));
+    ASSERT_EQ(width, sequential[bit_width_offset]) << "requested width " << width;
+
+    // Skip the header, whose packing_mode byte differs on purpose.
+    const bool payload_differs =
+        !std::equal(sequential.begin() + PforConstants::kHeaderSize, sequential.end(),
+                    interleaved.begin() + PforConstants::kHeaderSize);
+    if (width == 32) {
+      ASSERT_FALSE(payload_differs) << "the layouts coincide at 32 bits";
+    } else {
+      ASSERT_TRUE(payload_differs) << "width " << width;
+    }
+  }
+}
+
+/// A request the page cannot satisfy is recorded as the sequential layout rather
+/// than refused, so one writer-side setting can cover a file whose columns are
+/// not all eligible.
+TEST(PforInterleavedTest, UnsatisfiableRequestRecordsSequential) {
+  const auto num_values = static_cast<int32_t>(PforConstants::kPforVectorSize);
+  constexpr auto kInterleaved = PackingMode::kForBitPackInterleaved;
+
+  // Eight bytes per element.
+  {
+    std::vector<int64_t> values(num_values);
+    std::iota(values.begin(), values.end(), int64_t{1} << 40);
+    int64_t comp_size =
+        PforWrapper<int64_t>::GetMaxCompressedSize(num_values).ValueOrDie();
+    std::vector<uint8_t> page(comp_size);
+    ASSERT_OK(PforWrapper<int64_t>::Encode(values.data(), num_values, page.data(),
+                                           &comp_size,
+                                           PforEncodeOptions{.mode = kInterleaved}));
+    ASSERT_EQ(static_cast<uint8_t>(PackingMode::kForBitPack), PackingModeOf(page));
+
+    std::vector<int64_t> decoded(num_values);
+    ASSERT_OK(
+        PforWrapper<int64_t>::Decode(page.data(), comp_size, num_values, decoded.data()));
+    ASSERT_EQ(values, decoded);
+  }
+
+  // A vector size other than 1024.
+  {
+    std::vector<int32_t> values(num_values);
+    std::iota(values.begin(), values.end(), 0);
+    constexpr int32_t kVectorSize = 512;
+    int64_t comp_size =
+        PforWrapper<int32_t>::GetMaxCompressedSize(num_values, kVectorSize).ValueOrDie();
+    std::vector<uint8_t> page(comp_size);
+    ASSERT_OK(PforWrapper<int32_t>::Encode(values.data(), num_values, kVectorSize,
+                                           page.data(), &comp_size,
+                                           PforEncodeOptions{.mode = kInterleaved}));
+    ASSERT_EQ(static_cast<uint8_t>(PackingMode::kForBitPack), PackingModeOf(page));
+
+    std::vector<int32_t> decoded(num_values);
+    ASSERT_OK(
+        PforWrapper<int32_t>::Decode(page.data(), comp_size, num_values, decoded.data()));
+    ASSERT_EQ(values, decoded);
+  }
+}
+
+/// A page that declares the interleaved layout alongside a vector size or an
+/// element width that cannot support it is rejected, rather than decoded into
+/// wrong values.
+TEST(PforInterleavedTest, ForgedHeaderIsRejected) {
+  const auto num_values = static_cast<int32_t>(PforConstants::kPforVectorSize);
+  std::vector<int32_t> values(num_values);
+  std::iota(values.begin(), values.end(), 0);
+  constexpr int32_t kVectorSize = 512;
+
+  int64_t comp_size =
+      PforWrapper<int32_t>::GetMaxCompressedSize(num_values, kVectorSize).ValueOrDie();
+  std::vector<uint8_t> page(comp_size);
+  ASSERT_OK(PforWrapper<int32_t>::Encode(values.data(), num_values, kVectorSize,
+                                         page.data(), &comp_size));
+
+  std::vector<int32_t> decoded(num_values);
+  page[0] = static_cast<uint8_t>(PackingMode::kForBitPackInterleaved);
+  ASSERT_RAISES(Invalid, PforWrapper<int32_t>::Decode(page.data(), comp_size, num_values,
+                                                      decoded.data()));
+
+  // An unknown layout is an error too, so a page written by a later encoder is
+  // refused instead of misread. The two layouts are the same size, so a reader
+  // that guessed would not run short.
+  page[0] = 2;
+  ASSERT_RAISES(Invalid, PforWrapper<int32_t>::Decode(page.data(), comp_size, num_values,
+                                                      decoded.data()));
+}
+
+/// A column reader does not hand a whole page to the decoder: it opens the page
+/// once and asks for one vector at a time, which is a second decode path over
+/// the same bytes. The layout a page declares has to reach that path too, or
+/// every full interleaved vector read through a Parquet file expands as though
+/// it were sequential -- wrong values, and no error to say so.
+///
+/// The page here is three vectors and a short tail, so it covers both rules the
+/// path has to get right: the full vectors are interleaved, and the tail, which
+/// is too short for a block, is sequential on the same page.
+TEST(PforInterleavedTest, VectorAtATimeReadMatchesWholePage) {
+  using T = int32_t;
+  const auto vector_size = static_cast<int32_t>(PforConstants::kPforVectorSize);
+  const int32_t num_values = 3 * vector_size + 300;
+
+  for (int width : {1, 3, 7, 8, 13, 16, 24, 31}) {
+    const auto values = ValuesForWidth<T>(width, /*zero_frame=*/true, num_values,
+                                          static_cast<uint32_t>(width));
+
+    int64_t comp_size = PforWrapper<T>::GetMaxCompressedSize(num_values).ValueOrDie();
+    std::vector<uint8_t> page(comp_size);
+    ASSERT_OK(PforWrapper<T>::Encode(
+        values.data(), num_values, page.data(), &comp_size,
+        PforEncodeOptions{.mode = PackingMode::kForBitPackInterleaved}));
+    ASSERT_EQ(static_cast<uint8_t>(PackingMode::kForBitPackInterleaved),
+              PackingModeOf(page))
+        << "width " << width;
+
+    ASSERT_OK_AND_ASSIGN(auto reader, PforWrapper<T>::VectorReader::Open(
+                                          {page.data(), static_cast<size_t>(comp_size)}));
+    ASSERT_EQ(num_values, reader.num_elements()) << "width " << width;
+    ASSERT_EQ(4, reader.num_vectors()) << "width " << width;
+
+    std::vector<T> streamed;
+    streamed.reserve(num_values);
+    for (int32_t v = 0; v < reader.num_vectors(); ++v) {
+      ASSERT_OK_AND_ASSIGN(const int32_t length, reader.VectorLength(v));
+      std::vector<T> one(length);
+      ASSERT_OK(reader.DecodeVector(v, one)) << "width " << width << " vector " << v;
+      streamed.insert(streamed.end(), one.begin(), one.end());
+    }
+    ASSERT_EQ(values, streamed) << "width " << width;
+
+    // The whole-page decoder is the reference the two paths have to agree on.
+    std::vector<T> whole(num_values);
+    ASSERT_OK(PforWrapper<T>::Decode(page.data(), comp_size, num_values, whole.data()));
+    ASSERT_EQ(whole, streamed) << "width " << width;
+  }
+}
+
 }  // namespace arrow::util::pfor
diff --git a/cpp/src/arrow/util/pfor/pfor_wrapper.cc b/cpp/src/arrow/util/pfor/pfor_wrapper.cc
index ec3a93d055a0..4067cb79d971 100644
--- a/cpp/src/arrow/util/pfor/pfor_wrapper.cc
+++ b/cpp/src/arrow/util/pfor/pfor_wrapper.cc
@@ -376,6 +376,7 @@ Result<typename PforWrapper<T>::VectorReader> PforWrapper<T>::VectorReader::Open
   reader.vector_size_ = 1 << header.log_vector_size;
   reader.num_vectors_ =
       static_cast<int32_t>(bit_util::CeilDiv(reader.num_elements_, reader.vector_size_));
+  reader.packing_mode_ = static_cast<PackingMode>(header.packing_mode);
   reader.offset_array_start_ = input.data() + PforConstants::kHeaderSize;
   const int64_t offset_array_size =
       static_cast<int64_t>(reader.num_vectors_) * kOffsetSize;
@@ -414,7 +415,7 @@ Status PforWrapper<T>::VectorReader::DecodeVector(int32_t vector_index,
   return PforCompression<T>::DecodeVector(
              std::span<const uint8_t>(vector_data,
                                       input_.data() + input_.size() - vector_data),
-             vector_length, output.data())
+             vector_length, output.data(), packing_mode_)
       .status();
 }
 
diff --git a/cpp/src/arrow/util/pfor/pfor_wrapper_internal.h b/cpp/src/arrow/util/pfor/pfor_wrapper_internal.h
index 8bafa520a3e8..8f95347d2b3b 100644
--- a/cpp/src/arrow/util/pfor/pfor_wrapper_internal.h
+++ b/cpp/src/arrow/util/pfor/pfor_wrapper_internal.h
@@ -80,6 +80,11 @@ class ARROW_EXPORT PforWrapper {
     int32_t num_elements_ = 0;
     int32_t vector_size_ = 0;
     int32_t num_vectors_ = 0;
+    // Which bit-packing layout the page declares. A vector shorter than a full
+    // interleaved block is written as kForBitPack even on an interleaved page,
+    // and DecodeVector derives that from the element count the way the
+    // whole-page decoder does.
+    PackingMode packing_mode_ = PackingMode::kForBitPack;
   };
 
   /// \brief Encode integer values into a PFOR-compressed page
diff --git a/cpp/src/parquet/arrow/arrow_encoding_test.cc b/cpp/src/parquet/arrow/arrow_encoding_test.cc
index f1ff50a9c1ec..0bc09f6c01ff 100644
--- a/cpp/src/parquet/arrow/arrow_encoding_test.cc
+++ b/cpp/src/parquet/arrow/arrow_encoding_test.cc
@@ -206,6 +206,71 @@ TEST_F(ParquetPforEncodingTest, LargeInt64Dataset) {
   TestPforRoundTrip(table);
 }
 
+// EXPERIMENTAL: the lane-interleaved bit-packing layout is off unless a writer
+// asks for it, and when it is on it reaches the page and costs no space.
+//
+// The two layouts write the same number of bytes, so a flag that never reached
+// the encoder would still round-trip. Writing the same table both ways and
+// comparing the files is what shows it arrived: same length, different bytes.
+TEST_F(ParquetPforEncodingTest, InterleavedBitPackingLayout) {
+  ::arrow::random::RandomArrayGenerator rag(42);
+  // Several full vectors and a short tail, which is written in the layout PFOR
+  // has always used whatever the writer asked for.
+  auto array = rag.Int32(3000, -1000000, 1000000);
+  auto schema = ::arrow::schema({::arrow::field("values", ::arrow::int32())});
+  auto table = Table::Make(schema, {std::make_shared<ChunkedArray>(array)});
+
+  auto build = [](bool interleaved) {
+    auto builder = WriterProperties::Builder();
+    builder.disable_dictionary()->encoding(Encoding::PFOR);
+    if (interleaved) {
+      builder.enable_pfor_interleaved_bit_packing();
+    }
+    return builder.build();
+  };
+
+  std::shared_ptr<Table> sequential_result, interleaved_result;
+  std::shared_ptr<Buffer> sequential_file, interleaved_file;
+  DoRoundtrip(table, table->num_rows(), &sequential_result, build(false),
+              &sequential_file);
+  DoRoundtrip(table, table->num_rows(), &interleaved_result, build(true),
+              &interleaved_file);
+
+  ASSERT_NO_FATAL_FAILURE(AssertAllColumnsUse(interleaved_file, Encoding::PFOR));
+  ASSERT_NO_FATAL_FAILURE(::arrow::AssertTablesEqual(*table, *interleaved_result));
+  ASSERT_NO_FATAL_FAILURE(::arrow::AssertTablesEqual(*table, *sequential_result));
+
+  ASSERT_EQ(sequential_file->size(), interleaved_file->size());
+  ASSERT_FALSE(sequential_file->Equals(*interleaved_file));
+}
+
+// An int64 column cannot use the interleaved layout, and asking for it is not an
+// error: the writer records the layout PFOR has always used, so one setting can
+// cover a file whose columns are not all eligible.
+TEST_F(ParquetPforEncodingTest, InterleavedRequestIgnoredForInt64) {
+  ::arrow::random::RandomArrayGenerator rag(42);
+  auto array = rag.Int64(3000, -1000000000LL, 1000000000LL);
+  auto schema = ::arrow::schema({::arrow::field("values", ::arrow::int64())});
+  auto table = Table::Make(schema, {std::make_shared<ChunkedArray>(array)});
+
+  auto with_flag = WriterProperties::Builder()
+                       .disable_dictionary()
+                       ->encoding(Encoding::PFOR)
+                       ->enable_pfor_interleaved_bit_packing()
+                       ->build();
+  auto without_flag =
+      WriterProperties::Builder().disable_dictionary()->encoding(Encoding::PFOR)->build();
+
+  std::shared_ptr<Table> flagged_result, plain_result;
+  std::shared_ptr<Buffer> flagged_file, plain_file;
+  DoRoundtrip(table, table->num_rows(), &flagged_result, with_flag, &flagged_file);
+  DoRoundtrip(table, table->num_rows(), &plain_result, without_flag, &plain_file);
+
+  ASSERT_NO_FATAL_FAILURE(::arrow::AssertTablesEqual(*table, *flagged_result));
+  // Byte for byte the same file, because the request could not be honoured.
+  ASSERT_TRUE(plain_file->Equals(*flagged_file));
+}
+
 // The distribution PFOR is built for: a tight cluster sitting a long way from
 // zero, so the frame of reference carries the magnitude and the bit-packed
 // payload carries only the spread.
diff --git a/cpp/src/parquet/encoder.cc b/cpp/src/parquet/encoder.cc
index 414e127c2299..b5ce517b670f 100644
--- a/cpp/src/parquet/encoder.cc
+++ b/cpp/src/parquet/encoder.cc
@@ -1968,12 +1968,21 @@ std::unique_ptr<Encoder> MakeEncoder(Type::type type_num, Encoding::type encodin
             "DELTA_BYTE_ARRAY only supports BYTE_ARRAY and FIXED_LEN_BYTE_ARRAY");
     }
   } else if (encoding == Encoding::PFOR) {
-    // The delta mode is a per-column option, so it is read off the properties
-    // rather than baked into the encoder. A caller with no properties to hand --
-    // the encoding tests, and MakeTypedEncoder's default -- gets the default.
+    // The delta mode and the bit-packing layout are both per-writer options, so
+    // they are read off the properties rather than baked into the encoder. A
+    // caller with no properties to hand -- the encoding tests, and
+    // MakeTypedEncoder's default -- gets the default for both.
     ::arrow::util::pfor::PforEncodeOptions options;
-    if (properties != nullptr && descr != nullptr) {
-      options.delta_enabled = properties->pfor_delta_enabled(descr->path());
+    if (properties != nullptr) {
+      if (descr != nullptr) {
+        options.delta_enabled = properties->pfor_delta_enabled(descr->path());
+      }
+      // The encoder treats the layout as a request: a column it cannot apply to
+      // records the layout PFOR has always used, so one writer-side setting can
+      // cover a file whose columns are not all eligible.
+      options.mode = properties->pfor_interleaved_bit_packing()
+                         ? ::arrow::util::pfor::PackingMode::kForBitPackInterleaved
+                         : ::arrow::util::pfor::PackingMode::kForBitPack;
     }
     switch (type_num) {
       case Type::INT32:
diff --git a/cpp/src/parquet/encoding.h b/cpp/src/parquet/encoding.h
index cdfff30c2f33..f51454a8b310 100644
--- a/cpp/src/parquet/encoding.h
+++ b/cpp/src/parquet/encoding.h
@@ -424,7 +424,10 @@ class FLBADecoder : virtual public TypedDecoder<FLBAType> {
 ///
 /// \param[in] properties the writer properties, consulted for the options an
 ///            encoding offers per column. May be null, in which case every such
-///            option takes its default.
+///            option takes its default -- including PFOR's EXPERIMENTAL
+///            lane-interleaved bit-packing layout, ignored by every other
+///            encoding and by PFOR itself where the layout cannot apply. See
+///            WriterProperties::Builder::enable_pfor_interleaved_bit_packing.
 PARQUET_EXPORT
 std::unique_ptr<Encoder> MakeEncoder(
     Type::type type_num, Encoding::type encoding, bool use_dictionary = false,
diff --git a/cpp/src/parquet/properties.h b/cpp/src/parquet/properties.h
index 76a9b4833c48..c25cb80b97a8 100644
--- a/cpp/src/parquet/properties.h
+++ b/cpp/src/parquet/properties.h
@@ -401,6 +401,7 @@ class PARQUET_EXPORT WriterProperties {
           created_by_(DEFAULT_CREATED_BY),
           store_decimal_as_integer_(false),
           page_checksum_enabled_(false),
+          pfor_interleaved_bit_packing_(false),
           size_statistics_level_(DEFAULT_SIZE_STATISTICS_LEVEL),
           content_defined_chunking_enabled_(false),
           content_defined_chunking_options_({}) {}
@@ -417,6 +418,7 @@ class PARQUET_EXPORT WriterProperties {
           created_by_(properties.created_by()),
           store_decimal_as_integer_(properties.store_decimal_as_integer()),
           page_checksum_enabled_(properties.page_checksum_enabled()),
+          pfor_interleaved_bit_packing_(properties.pfor_interleaved_bit_packing()),
           size_statistics_level_(properties.size_statistics_level()),
           sorting_columns_(properties.sorting_columns()),
           default_column_properties_(properties.default_column_properties()),
@@ -837,6 +839,30 @@ class PARQUET_EXPORT WriterProperties {
       return this;
     }
 
+    /// EXPERIMENTAL: Ask the PFOR encoder for the lane-interleaved bit-packing
+    /// layout, which decodes faster and takes the same number of bytes.
+    ///
+    /// Default disabled. The layout is not yet in the Parquet specification, so
+    /// a file written with it can only be read by an implementation that knows
+    /// it; a reader that does not will reject the page rather than misread it.
+    ///
+    /// This applies to 4-byte columns only, and only to pages whose vectors are
+    /// full. Anything it cannot apply to is written in the layout PFOR has
+    /// always used, so this can be set for a file whose columns are not all
+    /// eligible.
+    Builder* enable_pfor_interleaved_bit_packing() {
+      pfor_interleaved_bit_packing_ = true;
+      return this;
+    }
+
+    /// Write PFOR pages in the bit-packing layout that needs no reader opt-in.
+    ///
+    /// This is the default.
+    Builder* disable_pfor_interleaved_bit_packing() {
+      pfor_interleaved_bit_packing_ = false;
+      return this;
+    }
+
     /// Enable writing page index in general for all columns. Default enabled.
     ///
     /// Writing statistics to the page index disables the old method of writing
@@ -1040,7 +1066,8 @@ class PARQUET_EXPORT WriterProperties {
           size_statistics_level_, std::move(file_encryption_properties_),
           default_column_properties_, column_properties, data_page_version_,
           store_decimal_as_integer_, std::move(sorting_columns_),
-          content_defined_chunking_enabled_, content_defined_chunking_options_));
+          content_defined_chunking_enabled_, content_defined_chunking_options_,
+          pfor_interleaved_bit_packing_));
     }
 
    private:
@@ -1070,6 +1097,7 @@ class PARQUET_EXPORT WriterProperties {
     std::string created_by_;
     bool store_decimal_as_integer_;
     bool page_checksum_enabled_;
+    bool pfor_interleaved_bit_packing_;
     SizeStatisticsLevel size_statistics_level_;
 
     std::shared_ptr<FileEncryptionProperties> file_encryption_properties_;
@@ -1117,6 +1145,12 @@ class PARQUET_EXPORT WriterProperties {
 
   inline bool page_checksum_enabled() const { return page_checksum_enabled_; }
 
+  /// EXPERIMENTAL: whether PFOR pages use the lane-interleaved bit-packing
+  /// layout. See WriterProperties::Builder::enable_pfor_interleaved_bit_packing.
+  inline bool pfor_interleaved_bit_packing() const {
+    return pfor_interleaved_bit_packing_;
+  }
+
   inline bool content_defined_chunking_enabled() const {
     return content_defined_chunking_enabled_;
   }
@@ -1264,7 +1298,7 @@ class PARQUET_EXPORT WriterProperties {
       const std::unordered_map<std::string, ColumnProperties>& column_properties,
       ParquetDataPageVersion data_page_version, bool store_short_decimal_as_integer,
       std::vector<SortingColumn> sorting_columns, bool content_defined_chunking_enabled,
-      CdcOptions content_defined_chunking_options)
+      CdcOptions content_defined_chunking_options, bool pfor_interleaved_bit_packing)
       : pool_(pool),
         dictionary_pagesize_limit_(dictionary_pagesize_limit),
         write_batch_size_(write_batch_size),
@@ -1276,6 +1310,7 @@ class PARQUET_EXPORT WriterProperties {
         parquet_created_by_(created_by),
         store_decimal_as_integer_(store_short_decimal_as_integer),
         page_checksum_enabled_(page_write_checksum_enabled),
+        pfor_interleaved_bit_packing_(pfor_interleaved_bit_packing),
         size_statistics_level_(size_statistics_level),
         file_encryption_properties_(file_encryption_properties),
         sorting_columns_(std::move(sorting_columns)),
@@ -1295,6 +1330,7 @@ class PARQUET_EXPORT WriterProperties {
   std::string parquet_created_by_;
   bool store_decimal_as_integer_;
   bool page_checksum_enabled_;
+  bool pfor_interleaved_bit_packing_;
   SizeStatisticsLevel size_statistics_level_;
 
   std::shared_ptr<FileEncryptionProperties> file_encryption_properties_;

From b69d4f0aa49c103a34b9526807ceee6a86f3a7fb Mon Sep 17 00:00:00 2001
From: Prateek Gaur <prateek.gaur@snowflake.com>
Date: Fri, 4 Sep 2026 19:46:39 +0000
Subject: [PATCH 15/27] Benchmark sequential and interleaved PFOR layouts

Registers each decode benchmark in both layouts, generated from the same
values so the encoded size matches and only the layout differs. A
page-sized destination is added next to the full-column one, and a
header comment says which comparisons are valid.
---
 cpp/src/arrow/util/pfor/pfor.cc           |  6 +-
 cpp/src/arrow/util/pfor/pfor_benchmark.cc | 90 ++++++++++++++++++++---
 cpp/src/parquet/properties.h              |  3 +-
 3 files changed, 84 insertions(+), 15 deletions(-)

diff --git a/cpp/src/arrow/util/pfor/pfor.cc b/cpp/src/arrow/util/pfor/pfor.cc
index 23a3f88418e3..d0aa6028bb98 100644
--- a/cpp/src/arrow/util/pfor/pfor.cc
+++ b/cpp/src/arrow/util/pfor/pfor.cc
@@ -299,9 +299,9 @@ Result<int64_t> PforCompression<T>::DecodeVector(std::span<const uint8_t> data,
   if (info.bit_width() > 0) {
     const auto unsigned_for = static_cast<UnsignedT>(info.frame_of_reference());
 
-    // The vector kernels load a fixed-size window per step. Use the remaining
-    // page bytes as the read bound so a kernel can process the final step when
-    // its load extends beyond this vector's packed payload.
+    // The sequential vector kernels load a fixed-size window per step. Use the
+    // remaining page bytes as the read bound so a kernel can process the final
+    // step when its load extends beyond this vector's packed payload.
     //
     // `data` runs from this vector to the end of the page, so every byte after
     // this vector's header is inside the caller's buffer and ours to read. The
diff --git a/cpp/src/arrow/util/pfor/pfor_benchmark.cc b/cpp/src/arrow/util/pfor/pfor_benchmark.cc
index ae878dab2036..4092e2c1801b 100644
--- a/cpp/src/arrow/util/pfor/pfor_benchmark.cc
+++ b/cpp/src/arrow/util/pfor/pfor_benchmark.cc
@@ -323,7 +323,8 @@ std::vector<T> GenBimodal(int64_t n) {
 // Benchmark Core
 
 template <typename T>
-void BM_PforEncodeImpl(benchmark::State& state, std::vector<T> (*generator)(int64_t)) {
+void BM_PforEncodeImpl(benchmark::State& state, std::vector<T> (*generator)(int64_t),
+                       PackingMode mode = PackingMode::kForBitPack) {
   const int64_t num_values = state.range(0);
   auto values = generator(num_values);
 
@@ -333,8 +334,8 @@ void BM_PforEncodeImpl(benchmark::State& state, std::vector<T> (*generator)(int6
 
   for (auto _ : state) {
     int64_t comp_size = max_size;
-    ARROW_CHECK_OK(
-        PforWrapper<T>::Encode(values.data(), num_values, compressed.data(), &comp_size));
+    ARROW_CHECK_OK(PforWrapper<T>::Encode(values.data(), num_values, compressed.data(),
+                                          &comp_size, PforEncodeOptions{.mode = mode}));
     benchmark::DoNotOptimize(comp_size);
     benchmark::ClobberMemory();
   }
@@ -345,15 +346,16 @@ void BM_PforEncodeImpl(benchmark::State& state, std::vector<T> (*generator)(int6
 
   // Report compression ratio
   int64_t comp_size = max_size;
-  ARROW_CHECK_OK(
-      PforWrapper<T>::Encode(values.data(), num_values, compressed.data(), &comp_size));
+  ARROW_CHECK_OK(PforWrapper<T>::Encode(values.data(), num_values, compressed.data(),
+                                        &comp_size, PforEncodeOptions{.mode = mode}));
   state.counters["CompRatio%"] =
       benchmark::Counter(100.0 * static_cast<double>(comp_size) /
                          static_cast<double>(num_values * sizeof(T)));
 }
 
 template <typename T>
-void BM_PforDecodeImpl(benchmark::State& state, std::vector<T> (*generator)(int64_t)) {
+void BM_PforDecodeImpl(benchmark::State& state, std::vector<T> (*generator)(int64_t),
+                       PackingMode mode = PackingMode::kForBitPack) {
   const int64_t num_values = state.range(0);
   auto values = generator(num_values);
 
@@ -361,8 +363,8 @@ void BM_PforDecodeImpl(benchmark::State& state, std::vector<T> (*generator)(int6
       PforWrapper<T>::GetMaxCompressedSize(static_cast<int32_t>(num_values)).ValueOrDie();
   std::vector<uint8_t> compressed(max_size);
   int64_t comp_size = max_size;
-  ARROW_CHECK_OK(
-      PforWrapper<T>::Encode(values.data(), num_values, compressed.data(), &comp_size));
+  ARROW_CHECK_OK(PforWrapper<T>::Encode(values.data(), num_values, compressed.data(),
+                                        &comp_size, PforEncodeOptions{.mode = mode}));
 
   std::vector<T> decoded(num_values);
 
@@ -386,6 +388,14 @@ void BM_PforEncodeInt32(benchmark::State& state, Int32Gen gen) {
 void BM_PforDecodeInt32(benchmark::State& state, Int32Gen gen) {
   BM_PforDecodeImpl<int32_t>(state, gen);
 }
+// The lane-interleaved layout, for a paired comparison against the two decoders
+// above. Only 32-bit values reach it, so there is no int64 counterpart.
+void BM_PforEncodeInt32Interleaved(benchmark::State& state, Int32Gen gen) {
+  BM_PforEncodeImpl<int32_t>(state, gen, PackingMode::kForBitPackInterleaved);
+}
+void BM_PforDecodeInt32Interleaved(benchmark::State& state, Int32Gen gen) {
+  BM_PforDecodeImpl<int32_t>(state, gen, PackingMode::kForBitPackInterleaved);
+}
 void BM_PforEncodeInt64(benchmark::State& state, Int64Gen gen) {
   BM_PforEncodeImpl<int64_t>(state, gen);
 }
@@ -394,10 +404,10 @@ void BM_PforDecodeInt64(benchmark::State& state, Int64Gen gen) {
 }
 
 // ----------------------------------------------------------------------
-// Benchmark sizes: 1K, 10K, 100K, 1M
+// Benchmark sizes: one vector, 10K, a default page (max_rows_per_page), 100K, 1M
 
 static void CustomArgs(benchmark::internal::Benchmark* b) {
-  for (int64_t n : {1024, 10240, 102400, 1048576}) {
+  for (int64_t n : {1024, 10240, 20000, 102400, 1048576}) {
     b->Arg(n);
   }
 }
@@ -552,5 +562,65 @@ BENCHMARK_CAPTURE(BM_PforDecodeInt64, LowSentinel, &GenLowSentinel<int64_t>)
     ->Apply(CustomArgs);
 BENCHMARK_CAPTURE(BM_PforDecodeInt64, Bimodal, &GenBimodal<int64_t>)->Apply(CustomArgs);
 
+// ----------------------------------------------------------------------
+// INT32 with the lane-interleaved bit-packing layout
+//
+// Every size here is a multiple of the 1024-value vector, so each vector is
+// packed interleaved rather than sequentially. Compare each decoder against the
+// same distribution above: CompRatio% should match to the byte, because the
+// two layouts write the same number of bits.
+
+// Interleaved Encode
+
+BENCHMARK_CAPTURE(BM_PforEncodeInt32Interleaved, Constant, &GenConstant<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt32Interleaved, Sequential, &GenSequential<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt32Interleaved, SmallRange, &GenSmallRange<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt32Interleaved, HighBaseSmallRange,
+                  &GenHighBaseSmallRange<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt32Interleaved, WithOutliers, &GenWithOutliers<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt32Interleaved, Random, &GenRandom<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt32Interleaved, TpcdsSoldDateSk,
+                  &GenTpcdsSoldDateSk<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt32Interleaved, TpcdsStoreSk, &GenTpcdsStoreSk<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt32Interleaved, TpcdsItemSk, &GenTpcdsItemSk<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforEncodeInt32Interleaved, TpcdsQuantity,
+                  &GenTpcdsQuantity<int32_t>)
+    ->Apply(CustomArgs);
+
+// Interleaved Decode
+
+BENCHMARK_CAPTURE(BM_PforDecodeInt32Interleaved, Constant, &GenConstant<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt32Interleaved, Sequential, &GenSequential<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt32Interleaved, SmallRange, &GenSmallRange<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt32Interleaved, HighBaseSmallRange,
+                  &GenHighBaseSmallRange<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt32Interleaved, WithOutliers, &GenWithOutliers<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt32Interleaved, Random, &GenRandom<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt32Interleaved, TpcdsSoldDateSk,
+                  &GenTpcdsSoldDateSk<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt32Interleaved, TpcdsStoreSk, &GenTpcdsStoreSk<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt32Interleaved, TpcdsItemSk, &GenTpcdsItemSk<int32_t>)
+    ->Apply(CustomArgs);
+BENCHMARK_CAPTURE(BM_PforDecodeInt32Interleaved, TpcdsQuantity,
+                  &GenTpcdsQuantity<int32_t>)
+    ->Apply(CustomArgs);
+
 }  // namespace
 }  // namespace arrow::util::pfor
diff --git a/cpp/src/parquet/properties.h b/cpp/src/parquet/properties.h
index c25cb80b97a8..d098c0cde91b 100644
--- a/cpp/src/parquet/properties.h
+++ b/cpp/src/parquet/properties.h
@@ -839,8 +839,7 @@ class PARQUET_EXPORT WriterProperties {
       return this;
     }
 
-    /// EXPERIMENTAL: Ask the PFOR encoder for the lane-interleaved bit-packing
-    /// layout, which decodes faster and takes the same number of bytes.
+    /// EXPERIMENTAL: Ask the PFOR encoder to use lane-interleaved bit packing.
     ///
     /// Default disabled. The layout is not yet in the Parquet specification, so
     /// a file written with it can only be read by an implementation that knows

From ddb3faa267c17e2fbc1bb19341f34b1d04294f11 Mon Sep 17 00:00:00 2001
From: Prateek Gaur <prateek.gaur@snowflake.com>
Date: Sat, 5 Sep 2026 22:48:52 +0000
Subject: [PATCH 16/27] Add FastLanes-style lane-parallel delta kernels

Sequential delta decoding is one long dependency chain. The FastLanes
paper splits a block into lanes of 32 consecutive values, each with its
own base, so 32 prefix sums run side by side. This implements that
assignment with a choice of how the bases are coded, and a decoder that
does the prefix sum and the transpose back to file order in one pass.
The benchmarks separate the cost of base coding, of the lane layout and
of the permutation.
---
 cpp/src/arrow/util/fastlanes/lane_delta.h     | 257 ++++++
 .../arrow/util/fastlanes/transposed_delta.h   | 479 +++++++++++
 cpp/src/parquet/pfor_comparison_benchmark.cc  | 758 ++++++++++++++++++
 3 files changed, 1494 insertions(+)
 create mode 100644 cpp/src/arrow/util/fastlanes/lane_delta.h
 create mode 100644 cpp/src/arrow/util/fastlanes/transposed_delta.h

diff --git a/cpp/src/arrow/util/fastlanes/lane_delta.h b/cpp/src/arrow/util/fastlanes/lane_delta.h
new file mode 100644
index 000000000000..764c7dfd2c22
--- /dev/null
+++ b/cpp/src/arrow/util/fastlanes/lane_delta.h
@@ -0,0 +1,257 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+// ---------------------------------------------------------------------------
+// Lane-parallel delta, an experiment: DELTA_BINARY_PACKED's cost is dominated
+// by its prefix sum, which is one dependent add per value and therefore
+// unvectorizable. Deltaing inside a bit-packing lane instead of along the file
+// order replaces that single 1024-long chain with 32 independent chains of
+// length 32, so one vector add per row advances all 32 at once.
+//
+// Two value orders are provided, differing only in which value sits one step
+// back in a lane:
+//
+//   kInterleaved  lane l holds original indices l, 32+l, ..., 992+l, so the
+//                 in-lane step is a uniform +32 in file order. Container order
+//                 equals file order, so decode needs no permutation, and the
+//                 step from one block's last row to the next block's first row
+//                 is also +32 -- the lane seeds are written once per column.
+//
+// The kFlOrder path this file once carried used Arrow's fromTransposed32, which
+// is not the FastLanes order and has since been deleted from the tree. The
+// paper's own lane assignment lives in transposed_delta.h.
+//
+// Wire layout for n values (n a multiple of 1024; any tail is stored raw):
+//
+//   [0, 128)                     32 uint32 lane seeds
+//   [128, 128 + nblocks)         uint8 bit width per block
+//   padded to a 4-byte boundary
+//   next 4 * nblocks bytes       int32 min delta per block
+//   remainder                    per block, bit_width * 32 uint32 packed words
+//
+// Headers are hoisted out of the payload so every block's packed words land
+// 4-byte aligned without the decoder copying them to a scratch buffer first.
+// ---------------------------------------------------------------------------
+
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <limits>
+
+#include "arrow/util/fastlanes/fastlanes_kernels_internal.h"
+
+namespace arrow {
+namespace util {
+namespace fastlanes {
+
+enum class LaneDeltaOrder { kInterleaved };
+
+// Bits needed to hold v, 0 for v == 0. Encode-side only, so a loop is fine.
+inline uint32_t LaneDeltaBitsFor(uint64_t v) {
+  uint32_t bits = 0;
+  while (v != 0) {
+    ++bits;
+    v >>= 1;
+  }
+  return bits;
+}
+
+// Original-block index held by container slot t.
+template <LaneDeltaOrder kOrder>
+inline size_t LaneDeltaSource(size_t t) {
+  return t;
+}
+
+inline size_t LaneDeltaHeaderSize(size_t n) {
+  const size_t nblocks = n / kBlockSize;
+  const size_t widths = (nblocks + 3) & ~size_t(3);
+  return kLanes * sizeof(uint32_t) + widths + nblocks * sizeof(int32_t);
+}
+
+inline size_t LaneDeltaMaxEncodedSize(size_t n) {
+  return LaneDeltaHeaderSize(n) + n * sizeof(uint32_t) +
+         (n % kBlockSize) * sizeof(int32_t);
+}
+
+#define LANE_DELTA_PACK_CASE(W) \
+  case W:                       \
+    PackBlock<W>(grid, dst);    \
+    break;
+
+#define LANE_DELTA_UNPACK_CASE(W)          \
+  case W:                                  \
+    UnpackBlock<W, true>(src, grid, bias); \
+    break;
+
+// clang-format off
+#define LANE_DELTA_WIDTH_CASES(M)                 \
+  M(1) M(2) M(3) M(4) M(5) M(6) M(7) M(8)         \
+  M(9) M(10) M(11) M(12) M(13) M(14) M(15) M(16)  \
+  M(17) M(18) M(19) M(20) M(21) M(22) M(23) M(24) \
+  M(25) M(26) M(27) M(28) M(29) M(30) M(31) M(32)
+// clang-format on
+
+// Returns bytes written, or 0 if some block's delta span exceeds 32 bits and
+// the block therefore cannot be represented. Callers must check.
+template <LaneDeltaOrder kOrder>
+inline size_t LaneDeltaEncode(const int32_t* in, size_t n, uint8_t* out) {
+  const size_t nblocks = n / kBlockSize;
+  const size_t header = LaneDeltaHeaderSize(n);
+
+  uint32_t* seeds = reinterpret_cast<uint32_t*>(out);
+  uint8_t* widths = out + kLanes * sizeof(uint32_t);
+  int32_t* mins = reinterpret_cast<int32_t*>(out + kLanes * sizeof(uint32_t) +
+                                             ((nblocks + 3) & ~size_t(3)));
+  uint32_t* dst = reinterpret_cast<uint32_t*>(out + header);
+
+  uint32_t carry[kLanes] = {};
+  uint32_t vals[kBlockSize];
+  int64_t deltas[kBlockSize];
+  uint32_t grid[kBlockSize];
+
+  for (size_t b = 0; b < nblocks; ++b) {
+    const int32_t* blk = in + b * kBlockSize;
+    for (size_t t = 0; t < kBlockSize; ++t) {
+      vals[t] = static_cast<uint32_t>(blk[LaneDeltaSource<kOrder>(t)]);
+    }
+    if (b == 0) {
+      // The first row has no predecessor; seed each lane from it so that its
+      // delta is zero, and hand the seeds to the decoder.
+      std::memcpy(carry, vals, sizeof(carry));
+      std::memcpy(seeds, vals, sizeof(carry));
+    }
+
+    int64_t min_delta = std::numeric_limits<int64_t>::max();
+    for (size_t lane = 0; lane < kLanes; ++lane) {
+      int64_t prev = static_cast<int32_t>(carry[lane]);
+      for (size_t row = 0; row < kRowsPerBlock; ++row) {
+        const int64_t cur = static_cast<int32_t>(vals[row * kLanes + lane]);
+        const int64_t d = cur - prev;
+        deltas[row * kLanes + lane] = d;
+        if (d < min_delta) min_delta = d;
+        prev = cur;
+      }
+      carry[lane] = vals[(kRowsPerBlock - 1) * kLanes + lane];
+    }
+
+    uint64_t span = 0;
+    for (size_t t = 0; t < kBlockSize; ++t) {
+      const uint64_t adj = static_cast<uint64_t>(deltas[t] - min_delta);
+      if (adj > span) span = adj;
+    }
+    // A delta of two int32 spans up to 33 bits, so subtracting the minimum
+    // does not always fit. It does not have to: reconstruction is a chain of
+    // uint32 adds, so deltas truncated to 32 bits round-trip exactly. Pay the
+    // full width and drop the minimum in that case.
+    const bool modular = span > 0xFFFFFFFFull;
+    if (modular) min_delta = 0;
+
+    const uint32_t w = modular ? 32 : LaneDeltaBitsFor(span);
+    widths[b] = static_cast<uint8_t>(w);
+    mins[b] = static_cast<int32_t>(min_delta);
+
+    if (w > 0) {
+      for (size_t t = 0; t < kBlockSize; ++t) {
+        grid[t] = static_cast<uint32_t>(deltas[t] - min_delta);
+      }
+      switch (w) {
+        LANE_DELTA_WIDTH_CASES(LANE_DELTA_PACK_CASE)
+        default:
+          return 0;
+      }
+      dst += w * kLanes;
+    }
+  }
+
+  for (size_t b = nblocks; b < ((nblocks + 3) & ~size_t(3)); ++b) {
+    widths[b] = 0;
+  }
+
+  uint8_t* end = reinterpret_cast<uint8_t*>(dst);
+  const size_t tail = n % kBlockSize;
+  if (tail > 0) {
+    std::memcpy(end, in + nblocks * kBlockSize, tail * sizeof(int32_t));
+    end += tail * sizeof(int32_t);
+  }
+  return static_cast<size_t>(end - out);
+}
+
+template <LaneDeltaOrder kOrder, bool kRepair = true>
+inline void LaneDeltaDecode(const uint8_t* in, size_t n, int32_t* out) {
+  const size_t nblocks = n / kBlockSize;
+  const size_t header = LaneDeltaHeaderSize(n);
+
+  const uint32_t* seeds = reinterpret_cast<const uint32_t*>(in);
+  const uint8_t* widths = in + kLanes * sizeof(uint32_t);
+  const int32_t* mins = reinterpret_cast<const int32_t*>(in + kLanes * sizeof(uint32_t) +
+                                                         ((nblocks + 3) & ~size_t(3)));
+  const uint32_t* src = reinterpret_cast<const uint32_t*>(in + header);
+
+  uint32_t carry[kLanes];
+  std::memcpy(carry, seeds, sizeof(carry));
+
+  uint32_t grid[kBlockSize];
+
+  for (size_t b = 0; b < nblocks; ++b) {
+    const uint32_t w = widths[b];
+    const uint32_t bias = static_cast<uint32_t>(mins[b]);
+
+    if (w == 0) {
+      for (size_t t = 0; t < kBlockSize; ++t) grid[t] = bias;
+    } else {
+      switch (w) {
+        LANE_DELTA_WIDTH_CASES(LANE_DELTA_UNPACK_CASE)
+        default:
+          break;
+      }
+      src += w * kLanes;
+    }
+
+    // 32 independent prefix sums, one row at a time. Each of these inner loops
+    // is 32 lanes of pure vertical add with no carry between them, which is
+    // what the serial version cannot do.
+    for (size_t lane = 0; lane < kLanes; ++lane) {
+      grid[lane] += carry[lane];
+    }
+    for (size_t row = 1; row < kRowsPerBlock; ++row) {
+      uint32_t* cur = grid + row * kLanes;
+      const uint32_t* prev = cur - kLanes;
+      for (size_t lane = 0; lane < kLanes; ++lane) {
+        cur[lane] += prev[lane];
+      }
+    }
+    std::memcpy(carry, grid + (kRowsPerBlock - 1) * kLanes, sizeof(carry));
+
+    std::memcpy(out + b * kBlockSize, grid, sizeof(grid));
+  }
+
+  const size_t tail = n % kBlockSize;
+  if (tail > 0) {
+    std::memcpy(out + nblocks * kBlockSize, reinterpret_cast<const uint8_t*>(src),
+                tail * sizeof(int32_t));
+  }
+}
+
+#undef LANE_DELTA_PACK_CASE
+#undef LANE_DELTA_UNPACK_CASE
+#undef LANE_DELTA_WIDTH_CASES
+
+}  // namespace fastlanes
+}  // namespace util
+}  // namespace arrow
diff --git a/cpp/src/arrow/util/fastlanes/transposed_delta.h b/cpp/src/arrow/util/fastlanes/transposed_delta.h
new file mode 100644
index 000000000000..880120ea04a9
--- /dev/null
+++ b/cpp/src/arrow/util/fastlanes/transposed_delta.h
@@ -0,0 +1,479 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+// ---------------------------------------------------------------------------
+// The FastLanes paper's lane assignment for DELTA, as opposed to the +32 stride
+// in lane_delta.h.
+//
+// Both break DELTA_BINARY_PACKED's single 1024-long dependency chain into 32
+// independent chains, and both therefore decode with one vector add per row.
+// They differ in which value sits one step back in a lane, and that decides the
+// compression ratio:
+//
+//   lane_delta.h        lane l holds original indices l, 32+l, ..., 992+l. The
+//                       in-lane predecessor is 32 positions back in file order,
+//                       so the stored differences are wider than the format's.
+//                       Container order is file order, so decode writes
+//                       straight to the output.
+//
+//   this file           lane l holds the contiguous run [32l, 32l+32). The
+//                       in-lane predecessor is the immediately preceding value,
+//                       so the stored differences are exactly the ones
+//                       DELTA_BINARY_PACKED stores. Decode ends in transposed
+//                       order and owes a 32x32 transpose.
+//
+// The second is the paper's: section 2.3 states the order for its own
+// 16-value example as 0,4,8,12 | 1,5,9,13 | 2,6,10,14 | 3,7,11,15, i.e. lane
+// 0 holds 0,1,2,3, and Figure 4c shows the entry points such a chain needs.
+// Reconstructing the Unified Transposed Layout from Figure 6d's caption and
+// walking the chain as section 2.4 describes it, the in-lane distance is +1
+// for 100% of steps at all four lane widths; the 04261537 tile order is what
+// makes one stored order do that for 8, 16, 32 and 64-bit lanes at once. A
+// Parquet column has one physical type, so a 32x32 transpose reproduces the
+// property this file needs.
+//
+// The price is the entry points: 32 per vector rather than the format's one.
+// The paper charges itself "1 bit per value" for storing them plainly and about
+// 0.21 bits for delta-encoding them across vectors, and both are provided here
+// (TransposedBaseCoding).
+//
+// The base for lane l is the value *before* its run, v[32l - 1], rather than
+// v[32l]. That way all 1024 payload slots carry a real difference: without it
+// row 0 of every block would be a known zero and 1/32 of the packed words would
+// be wasted.
+//
+// Wire layout for n values (n a multiple of 1024; any tail is stored raw):
+//
+//   [0, nblocks)                 uint8 payload bit width per block
+//   padded to a 4-byte boundary
+//   next 4 * nblocks             int32 payload min delta per block
+//   next, per block              the 32 bases: 4 * 32 bytes raw, or, packed,
+//                                one uint8 width + one int32 min + the 32
+//                                base deltas bit-packed LSB-first
+//   remainder                    per block, bit_width * 32 uint32 packed words
+// ---------------------------------------------------------------------------
+
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <limits>
+
+#if defined(__ARM_NEON) || defined(__ARM_NEON__)
+#  include <arm_neon.h>
+#  define ARROW_TRANSPOSED_DELTA_NEON 1
+#endif
+
+#include "arrow/util/fastlanes/fastlanes_kernels_internal.h"
+
+namespace arrow {
+namespace util {
+namespace fastlanes {
+
+enum class TransposedBaseCoding { kRaw, kPacked };
+
+// How a decoder gets back to file order. kNone is not a conforming decoder and
+// exists only to price the other two. kSeparate walks the block twice, once for
+// the prefix sums and once to permute; kFused does both in one pass, which is
+// available because a lane's chain does not depend on any other lane.
+enum class TransposedRepair { kNone, kSeparate, kFused };
+
+// The output slot that container slot (row, lane) belongs to, and its inverse.
+// Not used on the hot path -- the decoder transposes in blocks instead.
+inline size_t TransposedSource(size_t t) {
+  const size_t row = t / kLanes;
+  const size_t lane = t % kLanes;
+  return lane * kRowsPerBlock + row;
+}
+
+inline uint32_t TransposedBitsFor(uint64_t v) {
+  uint32_t bits = 0;
+  while (v != 0) {
+    ++bits;
+    v >>= 1;
+  }
+  return bits;
+}
+
+// An LSB-first bit codec for the 32 base deltas of one block. 32 values per 1024
+// is not a hot path, so it does not need the register-width container -- but it
+// does need to be word-based rather than bit-at-a-time, which costs an operation
+// per value of the block rather than per value of the base stream.
+inline void PackScalar32(const uint32_t* in, uint32_t w, uint8_t* out) {
+  if (w == 0) return;
+  uint64_t acc = 0;
+  uint32_t have = 0;
+  for (size_t i = 0; i < kLanes; ++i) {
+    acc |= static_cast<uint64_t>(in[i]) << have;
+    have += w;
+    while (have >= 8) {
+      *out++ = static_cast<uint8_t>(acc);
+      acc >>= 8;
+      have -= 8;
+    }
+  }
+  if (have > 0) *out = static_cast<uint8_t>(acc);
+}
+
+inline void UnpackScalar32(const uint8_t* in, uint32_t w, uint32_t* out) {
+  if (w == 0) {
+    std::memset(out, 0, kLanes * sizeof(uint32_t));
+    return;
+  }
+  const uint32_t mask = w == 32 ? ~uint32_t{0} : ((uint32_t{1} << w) - 1);
+  // Branchless: one unaligned 64-bit load per value covers any w <= 32 at any
+  // bit offset. The last load reads up to 7 bytes beyond the base stream, which
+  // TransposedMaxEncodedSize leaves slack for.
+  for (size_t i = 0; i < kLanes; ++i) {
+    const size_t bit = i * w;
+    uint64_t word;
+    std::memcpy(&word, in + (bit >> 3), sizeof(word));
+    out[i] = static_cast<uint32_t>(word >> (bit & 7)) & mask;
+  }
+}
+
+template <TransposedBaseCoding kBases>
+inline size_t TransposedBaseBytes(uint32_t base_width) {
+  if constexpr (kBases == TransposedBaseCoding::kRaw) {
+    return kLanes * sizeof(uint32_t);
+  } else {
+    return 1 + sizeof(int32_t) + (kLanes * base_width + 7) / 8;
+  }
+}
+
+inline size_t TransposedFixedHeader(size_t n) {
+  const size_t nblocks = n / kBlockSize;
+  return ((nblocks + 3) & ~size_t(3)) + nblocks * sizeof(int32_t);
+}
+
+inline size_t TransposedMaxEncodedSize(size_t n) {
+  const size_t nblocks = n / kBlockSize;
+  // Per block: the widest base stream (a uint8 width, an int32 min and 32
+  // deltas at 32 bits), up to 3 bytes of padding before the packed words, and
+  // the payload, which n * sizeof(uint32_t) covers for every block at once.
+  return TransposedFixedHeader(n) + nblocks * (kLanes * sizeof(uint32_t) + 5 + 3) +
+         n * sizeof(uint32_t) + (n % kBlockSize) * sizeof(int32_t) + 8;
+}
+
+#define TPOSE_PACK_CASE(W)   \
+  case W:                    \
+    PackBlock<W>(grid, dst); \
+    break;
+
+#define TPOSE_UNPACK_CASE(W)               \
+  case W:                                  \
+    UnpackBlock<W, true>(src, grid, bias); \
+    break;
+
+// clang-format off
+#define TPOSE_WIDTH_CASES(M)                      \
+  M(1) M(2) M(3) M(4) M(5) M(6) M(7) M(8)         \
+  M(9) M(10) M(11) M(12) M(13) M(14) M(15) M(16)  \
+  M(17) M(18) M(19) M(20) M(21) M(22) M(23) M(24) \
+  M(25) M(26) M(27) M(28) M(29) M(30) M(31) M(32)
+// clang-format on
+
+// Returns bytes written, 0 if some block cannot be represented.
+template <TransposedBaseCoding kBases>
+inline size_t TransposedDeltaEncode(const int32_t* in, size_t n, uint8_t* out) {
+  const size_t nblocks = n / kBlockSize;
+  uint8_t* widths = out;
+  int32_t* mins = reinterpret_cast<int32_t*>(out + ((nblocks + 3) & ~size_t(3)));
+  uint8_t* cur = out + TransposedFixedHeader(n);
+
+  int64_t deltas[kBlockSize];
+  uint32_t grid[kBlockSize];
+  uint32_t bases[kLanes];
+  uint32_t base_deltas[kLanes];
+
+  for (size_t b = 0; b < nblocks; ++b) {
+    const int32_t* blk = in + b * kBlockSize;
+    // Previous value in file order for the block's very first element.
+    // For the first block there is no predecessor; seeding from the first value
+    // makes its delta zero rather than the value itself.
+    const int64_t before = b == 0 ? static_cast<int64_t>(in[0])
+                                  : static_cast<int64_t>(in[b * kBlockSize - 1]);
+
+    // deltas[row * kLanes + lane] is the difference between the value at
+    // output position lane * 32 + row and the one before it in file order.
+    int64_t min_delta = std::numeric_limits<int64_t>::max();
+    for (size_t lane = 0; lane < kLanes; ++lane) {
+      const size_t run = lane * kRowsPerBlock;
+      int64_t prev = run == 0 ? before : static_cast<int64_t>(blk[run - 1]);
+      bases[lane] = static_cast<uint32_t>(prev);
+      for (size_t row = 0; row < kRowsPerBlock; ++row) {
+        const int64_t v = static_cast<int64_t>(blk[run + row]);
+        const int64_t d = v - prev;
+        deltas[row * kLanes + lane] = d;
+        if (d < min_delta) min_delta = d;
+        prev = v;
+      }
+    }
+
+    uint64_t span = 0;
+    for (size_t t = 0; t < kBlockSize; ++t) {
+      const uint64_t adj = static_cast<uint64_t>(deltas[t] - min_delta);
+      if (adj > span) span = adj;
+    }
+    const bool modular = span > 0xFFFFFFFFull;
+    if (modular) min_delta = 0;
+    const uint32_t w = modular ? 32 : TransposedBitsFor(span);
+    widths[b] = static_cast<uint8_t>(w);
+    mins[b] = static_cast<int32_t>(min_delta);
+
+    if constexpr (kBases == TransposedBaseCoding::kRaw) {
+      std::memcpy(cur, bases, sizeof(bases));
+      cur += sizeof(bases);
+    } else {
+      // Bases sit 32 values apart, so their own differences are small. Chain
+      // the first one to the previous block's last base.
+      int64_t bmin = std::numeric_limits<int64_t>::max();
+      int64_t bd[kLanes];
+      const size_t last = (b - 1) * kBlockSize + (kLanes - 1) * kRowsPerBlock - 1;
+      int64_t prev_base = b == 0 ? 0 : static_cast<int64_t>(in[last]);
+      for (size_t lane = 0; lane < kLanes; ++lane) {
+        const int64_t cur_base = static_cast<int32_t>(bases[lane]);
+        bd[lane] = cur_base - prev_base;
+        if (bd[lane] < bmin) bmin = bd[lane];
+        prev_base = cur_base;
+      }
+      uint64_t bspan = 0;
+      for (size_t lane = 0; lane < kLanes; ++lane) {
+        const uint64_t adj = static_cast<uint64_t>(bd[lane] - bmin);
+        if (adj > bspan) bspan = adj;
+      }
+      const bool bmodular = bspan > 0xFFFFFFFFull;
+      if (bmodular) bmin = 0;
+      const uint32_t bw = bmodular ? 32 : TransposedBitsFor(bspan);
+      for (size_t lane = 0; lane < kLanes; ++lane) {
+        base_deltas[lane] = static_cast<uint32_t>(bd[lane] - bmin);
+      }
+      *cur++ = static_cast<uint8_t>(bw);
+      const int32_t bmin32 = static_cast<int32_t>(bmin);
+      std::memcpy(cur, &bmin32, sizeof(bmin32));
+      cur += sizeof(bmin32);
+      PackScalar32(base_deltas, bw, cur);
+      cur += (kLanes * bw + 7) / 8;
+    }
+
+    if (w > 0) {
+      for (size_t t = 0; t < kBlockSize; ++t) {
+        grid[t] = static_cast<uint32_t>(deltas[t] - min_delta);
+      }
+      // The packed words must be 4-byte aligned; the base stream keeps that
+      // for kRaw but not for kPacked, so pad.
+      const size_t pad = (4 - (static_cast<size_t>(cur - out) & 3)) & 3;
+      std::memset(cur, 0, pad);
+      cur += pad;
+      uint32_t* dst = reinterpret_cast<uint32_t*>(cur);
+      switch (w) {
+        TPOSE_WIDTH_CASES(TPOSE_PACK_CASE)
+        default:
+          return 0;
+      }
+      cur += w * kLanes * sizeof(uint32_t);
+    }
+  }
+
+  for (size_t b = nblocks; b < ((nblocks + 3) & ~size_t(3)); ++b) widths[b] = 0;
+
+  const size_t tail = n % kBlockSize;
+  if (tail > 0) {
+    std::memcpy(cur, in + nblocks * kBlockSize, tail * sizeof(int32_t));
+    cur += tail * sizeof(int32_t);
+  }
+  return static_cast<size_t>(cur - out);
+}
+
+// A blocked 8x8 transpose of the 32x32 grid. Reads and writes stay inside the
+// 4 KB grid and the 4 KB output block, so this is an L1-resident permutation
+// rather than the scattered stores a general gather would issue.
+inline void Transpose32x32Scalar(const uint32_t* ARROW_RESTRICT grid,
+                                 int32_t* ARROW_RESTRICT out) {
+  for (size_t lb = 0; lb < kLanes; lb += 8) {
+    for (size_t rb = 0; rb < kRowsPerBlock; rb += 8) {
+      for (size_t lane = lb; lane < lb + 8; ++lane) {
+        int32_t* dst = out + lane * kRowsPerBlock + rb;
+        const uint32_t* src = grid + rb * kLanes + lane;
+        dst[0] = static_cast<int32_t>(src[0 * kLanes]);
+        dst[1] = static_cast<int32_t>(src[1 * kLanes]);
+        dst[2] = static_cast<int32_t>(src[2 * kLanes]);
+        dst[3] = static_cast<int32_t>(src[3 * kLanes]);
+        dst[4] = static_cast<int32_t>(src[4 * kLanes]);
+        dst[5] = static_cast<int32_t>(src[5 * kLanes]);
+        dst[6] = static_cast<int32_t>(src[6 * kLanes]);
+        dst[7] = static_cast<int32_t>(src[7 * kLanes]);
+      }
+    }
+  }
+}
+
+#ifdef ARROW_TRANSPOSED_DELTA_NEON
+// Four 4x4 transposes per iteration. The permuted copy is one traversal either
+// way, so what this removes is the strided access, not the traffic.
+inline void Transpose32x32Neon(const uint32_t* ARROW_RESTRICT grid,
+                               int32_t* ARROW_RESTRICT out) {
+  for (size_t lane = 0; lane < kLanes; lane += 4) {
+    for (size_t row = 0; row < kRowsPerBlock; row += 4) {
+      const uint32_t* src = grid + row * kLanes + lane;
+      const uint32x4x2_t a = vtrnq_u32(vld1q_u32(src), vld1q_u32(src + kLanes));
+      const uint32x4x2_t b =
+          vtrnq_u32(vld1q_u32(src + 2 * kLanes), vld1q_u32(src + 3 * kLanes));
+      uint32_t* dst = reinterpret_cast<uint32_t*>(out) + lane * kRowsPerBlock + row;
+      vst1q_u32(dst, vcombine_u32(vget_low_u32(a.val[0]), vget_low_u32(b.val[0])));
+      dst += kRowsPerBlock;
+      vst1q_u32(dst, vcombine_u32(vget_low_u32(a.val[1]), vget_low_u32(b.val[1])));
+      dst += kRowsPerBlock;
+      vst1q_u32(dst, vcombine_u32(vget_high_u32(a.val[0]), vget_high_u32(b.val[0])));
+      dst += kRowsPerBlock;
+      vst1q_u32(dst, vcombine_u32(vget_high_u32(a.val[1]), vget_high_u32(b.val[1])));
+    }
+  }
+}
+#endif
+
+inline void Transpose32x32(const uint32_t* ARROW_RESTRICT grid,
+                           int32_t* ARROW_RESTRICT out) {
+#ifdef ARROW_TRANSPOSED_DELTA_NEON
+  Transpose32x32Neon(grid, out);
+#else
+  Transpose32x32Scalar(grid, out);
+#endif
+}
+
+#ifdef ARROW_TRANSPOSED_DELTA_NEON
+// The 32 prefix sums and the permutation in one pass. Four lanes' chains run in
+// one register, so four rows of results can be transposed and stored while they
+// are still in registers, sparing the block a second 4 KB round trip.
+inline void PrefixSumAndTranspose(const uint32_t* ARROW_RESTRICT grid,
+                                  const uint32_t* ARROW_RESTRICT bases,
+                                  int32_t* ARROW_RESTRICT out) {
+  for (size_t lane = 0; lane < kLanes; lane += 4) {
+    uint32x4_t acc = vld1q_u32(bases + lane);
+    for (size_t row = 0; row < kRowsPerBlock; row += 4) {
+      const uint32_t* src = grid + row * kLanes + lane;
+      const uint32x4_t v0 = vaddq_u32(acc, vld1q_u32(src));
+      const uint32x4_t v1 = vaddq_u32(v0, vld1q_u32(src + kLanes));
+      const uint32x4_t v2 = vaddq_u32(v1, vld1q_u32(src + 2 * kLanes));
+      const uint32x4_t v3 = vaddq_u32(v2, vld1q_u32(src + 3 * kLanes));
+      acc = v3;
+      const uint32x4x2_t a = vtrnq_u32(v0, v1);
+      const uint32x4x2_t c = vtrnq_u32(v2, v3);
+      uint32_t* dst = reinterpret_cast<uint32_t*>(out) + lane * kRowsPerBlock + row;
+      vst1q_u32(dst, vcombine_u32(vget_low_u32(a.val[0]), vget_low_u32(c.val[0])));
+      dst += kRowsPerBlock;
+      vst1q_u32(dst, vcombine_u32(vget_low_u32(a.val[1]), vget_low_u32(c.val[1])));
+      dst += kRowsPerBlock;
+      vst1q_u32(dst, vcombine_u32(vget_high_u32(a.val[0]), vget_high_u32(c.val[0])));
+      dst += kRowsPerBlock;
+      vst1q_u32(dst, vcombine_u32(vget_high_u32(a.val[1]), vget_high_u32(c.val[1])));
+    }
+  }
+}
+#endif
+
+// kRepair off leaves the block in transposed order, which isolates the cost of
+// the transpose from the rest of the decode. Only kRepair on is a conforming
+// Parquet decoder.
+template <TransposedBaseCoding kBases,
+          TransposedRepair kRepair = TransposedRepair::kFused>
+inline void TransposedDeltaDecode(const uint8_t* in, size_t n, int32_t* out) {
+  const size_t nblocks = n / kBlockSize;
+  const uint8_t* widths = in;
+  const int32_t* mins =
+      reinterpret_cast<const int32_t*>(in + ((nblocks + 3) & ~size_t(3)));
+  const uint8_t* cur = in + TransposedFixedHeader(n);
+
+  uint32_t grid[kBlockSize];
+  uint32_t bases[kLanes];
+
+  for (size_t b = 0; b < nblocks; ++b) {
+    const uint32_t w = widths[b];
+    const uint32_t bias = static_cast<uint32_t>(mins[b]);
+
+    if constexpr (kBases == TransposedBaseCoding::kRaw) {
+      std::memcpy(bases, cur, sizeof(bases));
+      cur += sizeof(bases);
+    } else {
+      const uint32_t bw = *cur++;
+      int32_t bmin;
+      std::memcpy(&bmin, cur, sizeof(bmin));
+      cur += sizeof(bmin);
+      uint32_t bd[kLanes];
+      UnpackScalar32(cur, bw, bd);
+      cur += (kLanes * bw + 7) / 8;
+      // 32 serial adds per 1024 values, against the format's 1024.
+      uint32_t running = b == 0 ? 0u : bases[kLanes - 1];
+      for (size_t lane = 0; lane < kLanes; ++lane) {
+        running += bd[lane] + static_cast<uint32_t>(bmin);
+        bases[lane] = running;
+      }
+    }
+
+    if (w == 0) {
+      for (size_t t = 0; t < kBlockSize; ++t) grid[t] = bias;
+    } else {
+      cur += (4 - (static_cast<size_t>(cur - in) & 3)) & 3;
+      const uint32_t* src = reinterpret_cast<const uint32_t*>(cur);
+      switch (w) {
+        TPOSE_WIDTH_CASES(TPOSE_UNPACK_CASE)
+        default:
+          break;
+      }
+      cur += w * kLanes * sizeof(uint32_t);
+    }
+
+#ifdef ARROW_TRANSPOSED_DELTA_NEON
+    if constexpr (kRepair == TransposedRepair::kFused) {
+      PrefixSumAndTranspose(grid, bases, out + b * kBlockSize);
+      continue;
+    }
+#endif
+    // 32 independent prefix sums, one vector add per row. Row 0 starts from
+    // the base, which is the value before the lane's run.
+    for (size_t lane = 0; lane < kLanes; ++lane) {
+      grid[lane] += bases[lane];
+    }
+    for (size_t row = 1; row < kRowsPerBlock; ++row) {
+      uint32_t* c = grid + row * kLanes;
+      const uint32_t* p = c - kLanes;
+      for (size_t lane = 0; lane < kLanes; ++lane) {
+        c[lane] += p[lane];
+      }
+    }
+
+    if constexpr (kRepair == TransposedRepair::kNone) {
+      std::memcpy(out + b * kBlockSize, grid, sizeof(grid));
+    } else {
+      Transpose32x32(grid, out + b * kBlockSize);
+    }
+  }
+
+  const size_t tail = n % kBlockSize;
+  if (tail > 0) {
+    std::memcpy(out + nblocks * kBlockSize, cur, tail * sizeof(int32_t));
+  }
+}
+
+#undef TPOSE_PACK_CASE
+#undef TPOSE_UNPACK_CASE
+#undef TPOSE_WIDTH_CASES
+
+}  // namespace fastlanes
+}  // namespace util
+}  // namespace arrow
diff --git a/cpp/src/parquet/pfor_comparison_benchmark.cc b/cpp/src/parquet/pfor_comparison_benchmark.cc
index d7deeb0edbc2..fb7ecb9d9437 100644
--- a/cpp/src/parquet/pfor_comparison_benchmark.cc
+++ b/cpp/src/parquet/pfor_comparison_benchmark.cc
@@ -38,8 +38,12 @@
 
 #include "benchmark/benchmark.h"
 
+#include "arrow/util/bit_stream_utils_internal.h"
 #include "arrow/util/bit_util.h"
+#include "arrow/util/bpacking_internal.h"
 #include "arrow/util/compression.h"
+#include "arrow/util/fastlanes/lane_delta.h"
+#include "arrow/util/fastlanes/transposed_delta.h"
 #include "arrow/util/logging.h"
 #include "arrow/util/pfor/pfor_wrapper_internal.h"
 #include "arrow/util/rle_encoding_internal.h"
@@ -424,6 +428,69 @@ std::vector<int64_t> GenPriceMicros(int64_t n) {
   return v;
 }
 
+// ============================================================================
+// Data generators: sorted and near-sorted
+//
+// The generators above draw independently around a base, which is the case
+// delta encoding is not for: subtracting two i.i.d. values spans the whole
+// range whichever two you pick, so the distance between them does not matter
+// and every delta variant lands within a bit or two of frame of reference.
+// Comparing delta schemes needs columns whose value depends on the previous
+// one. These cover the shapes that occur in practice: a clustered timestamp
+// column, a sorted key with duplicates, an exact counter, and a column that
+// is sorted apart from a few late arrivals.
+// ============================================================================
+
+// Event timestamps in seconds, arriving a few seconds apart. The common case
+// for a table clustered or sorted on time.
+std::vector<int32_t> GenSortedUnixTime(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(401);
+  std::uniform_int_distribution<int32_t> gap(0, 7);
+  int32_t t = 1700000000;
+  for (auto& x : v) {
+    t += gap(rng);
+    x = t;
+  }
+  return v;
+}
+
+// A sorted surrogate key with runs of duplicates, as produced by a join key or
+// a dictionary-sorted column: most steps are 0, some are 1.
+std::vector<int32_t> GenSortedKeyDups(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(402);
+  std::uniform_int_distribution<int32_t> step(0, 1);
+  int32_t k = 5000000;
+  for (auto& x : v) {
+    k += step(rng);
+    x = k;
+  }
+  return v;
+}
+
+// An exact +1 row id. The best case for any delta scheme, and the case where
+// stride-1 and lane-parallel delta differ most.
+std::vector<int32_t> GenMonotoneRowId(int64_t n) {
+  std::vector<int32_t> v(n);
+  int32_t k = 1;
+  for (auto& x : v) x = k++;
+  return v;
+}
+
+// Sorted except that 2% of rows arrive late, so a few deltas are large and
+// negative. Tests whether one bit width per block survives outliers.
+std::vector<int32_t> GenNearSortedUnixTime(int64_t n) {
+  std::vector<int32_t> v = GenSortedUnixTime(n);
+  std::mt19937 rng(403);
+  std::uniform_int_distribution<int> pick(0, 49);
+  std::uniform_int_distribution<int32_t> late(1, 3600);
+  for (auto& x : v) {
+    if (pick(rng) == 0) x -= late(rng);
+  }
+  return v;
+}
+
 // Snowflake-style monotone ID: large base + jittered per-row increments.
 // Monotone -> ideal for DELTA_BINARY_PACKED; huge min -> ideal for PFOR's FOR.
 std::vector<int64_t> GenSnowflakeId(int64_t n) {
@@ -1277,6 +1344,668 @@ static void BM_BssLz464Decode(benchmark::State& state, Gen64 gen) {
   BssCodecDecodeImpl<int64_t>(state, gen, Compression::LZ4_FRAME);
 }
 
+// ----------------------------------------------------------------------
+// DELTA_BINARY_PACKED cost decomposition
+// ----------------------------------------------------------------------
+//
+// Splits the cost of decoding a DELTA_BINARY_PACKED page into three parts:
+// per-block header parsing, the call into the bit unpacker, and the serial
+// prefix sum. Each ablated arm reads the same stream and calls the same
+// out-of-line `arrow::internal::unpack` in libarrow, so only the surrounding
+// loop is recompiled here. `kFull` exists to be cross-checked against the
+// in-tree BM_DeltaBitPackDecode arm; if the two disagree, none of the ablated
+// arms mean anything.
+
+enum class DbpAblate {
+  kFull,        // headers + unpack + prefix sum
+  kNoSum,       // headers + unpack
+  kNoUnpack,    // headers + prefix sum, bit reader advanced instead of unpacked
+  kHeaderOnly,  // headers only
+  // Reader-side variants. Both read a byte-identical stream and are available
+  // to any conforming reader with no format change.
+  kCoalesce,  // one unpack call per run of miniblocks sharing a bit width
+  kBlockSum,  // one prefix-sum loop per block instead of one per miniblock
+  kBoth,      // both of the above
+  kDirect,    // kBoth, plus unpack_bias called directly with min_delta as bias
+};
+
+constexpr bool DbpIsReaderSide(DbpAblate a) {
+  return a == DbpAblate::kCoalesce || a == DbpAblate::kBlockSum ||
+         a == DbpAblate::kBoth || a == DbpAblate::kDirect;
+}
+constexpr bool DbpDoesCoalesce(DbpAblate a) {
+  return a == DbpAblate::kCoalesce || a == DbpAblate::kBoth || a == DbpAblate::kDirect;
+}
+constexpr bool DbpDoesBlockSum(DbpAblate a) {
+  return a == DbpAblate::kBlockSum || a == DbpAblate::kBoth || a == DbpAblate::kDirect;
+}
+// kDirect skips BitReader::GetBatch and calls the unpacker itself. Legal here
+// because every miniblock boundary is byte-aligned: the block header is read
+// with byte-aligned primitives, and a miniblock of v values at width w occupies
+// exactly v*w/8 bytes with v a multiple of 32, so w*v is always a multiple of 8.
+// Folding min_delta in as the unpacker's bias also removes one add per value
+// from the prefix-sum loop body.
+constexpr bool DbpDoesDirectUnpack(DbpAblate a) { return a == DbpAblate::kDirect; }
+
+// A DELTA_BINARY_PACKED writer with configurable block geometry. The format
+// carries values_per_block and mini_blocks_per_block as varints at the front of
+// every stream, constrained only to multiples of 128 and 32 respectively.
+// Arrow's own encoder takes both as constructor arguments but is declared in an
+// anonymous namespace, so sweeping the geometry needs a writer here.
+template <typename T>
+std::shared_ptr<::arrow::Buffer> WriteDbpStream(const std::vector<T>& values,
+                                                uint32_t values_per_block,
+                                                uint32_t mini_blocks_per_block) {
+  using UT = std::make_unsigned_t<T>;
+  const uint32_t values_per_mini_block = values_per_block / mini_blocks_per_block;
+  ARROW_CHECK_EQ(values_per_block % 128, 0u);
+  ARROW_CHECK_EQ(values_per_mini_block % 32, 0u);
+
+  const size_t n = values.size();
+  // Deltas are v[i] - v[i-1]; the first value travels in the header.
+  std::vector<UT> deltas(n > 0 ? n - 1 : 0);
+  for (size_t i = 1; i < n; ++i) {
+    deltas[i - 1] = static_cast<UT>(values[i]) - static_cast<UT>(values[i - 1]);
+  }
+
+  auto buf = AllocateBuffer(::arrow::default_memory_pool(),
+                            static_cast<int64_t>(n * sizeof(T) * 2 + 1024));
+  ::arrow::bit_util::BitWriter writer(buf->mutable_data(), static_cast<int>(buf->size()));
+  ARROW_CHECK(writer.PutVlqInt(values_per_block));
+  ARROW_CHECK(writer.PutVlqInt(mini_blocks_per_block));
+  ARROW_CHECK(writer.PutVlqInt(static_cast<uint32_t>(n)));
+  ARROW_CHECK(writer.PutZigZagVlqInt(n > 0 ? values[0] : T{0}));
+
+  std::vector<UT> residuals(values_per_block);
+  std::vector<uint8_t> widths(mini_blocks_per_block);
+  for (size_t base = 0; base < deltas.size(); base += values_per_block) {
+    const size_t present = std::min<size_t>(values_per_block, deltas.size() - base);
+    // min_delta is signed-minimum over the deltas present.
+    T min_delta = static_cast<T>(deltas[base]);
+    for (size_t k = 1; k < present; ++k) {
+      min_delta = std::min(min_delta, static_cast<T>(deltas[base + k]));
+    }
+    for (size_t k = 0; k < present; ++k) {
+      residuals[k] = deltas[base + k] - static_cast<UT>(min_delta);
+    }
+    // Pad the block out with zero residuals, i.e. with a delta of min_delta.
+    std::fill(residuals.begin() + present, residuals.end(), UT{0});
+
+    for (uint32_t m = 0; m < mini_blocks_per_block; ++m) {
+      UT max_res = 0;
+      for (uint32_t k = 0; k < values_per_mini_block; ++k) {
+        max_res = std::max(max_res, residuals[m * values_per_mini_block + k]);
+      }
+      widths[m] = static_cast<uint8_t>(std::bit_width(max_res));
+    }
+    ARROW_CHECK(writer.PutZigZagVlqInt(min_delta));
+    uint8_t* wp = writer.GetNextBytePtr(static_cast<int>(mini_blocks_per_block));
+    ARROW_CHECK(wp != nullptr);
+    memcpy(wp, widths.data(), mini_blocks_per_block);
+    for (uint32_t m = 0; m < mini_blocks_per_block; ++m) {
+      if (widths[m] == 0) continue;
+      for (uint32_t k = 0; k < values_per_mini_block; ++k) {
+        ARROW_CHECK(writer.PutValue(residuals[m * values_per_mini_block + k], widths[m]));
+      }
+    }
+  }
+  writer.Flush();
+  return SliceBuffer(buf, 0, writer.bytes_written());
+}
+
+// Shadow of DeltaBitPackDecoder::GetInternal with the same stream handling and
+// the same call into libarrow's unpacker, minus whichever part is ablated.
+template <typename T, DbpAblate kAblate, bool kHeapReader = false>
+int DbpAblatedDecode(const uint8_t* data, int len, T* out) {
+  using UT = std::make_unsigned_t<T>;
+  // The shipping decoder holds its BitReader behind a shared_ptr, so its bit
+  // position lives in heap memory reached through a load rather than in a
+  // stack slot the compiler can keep in registers. kHeapReader reproduces that
+  // placement so the shadow can be compared with the real thing.
+  std::shared_ptr<::arrow::bit_util::BitReader> heap_reader;
+  if constexpr (kHeapReader) {
+    heap_reader = std::make_shared<::arrow::bit_util::BitReader>(data, len);
+  }
+  ::arrow::bit_util::BitReader stack_reader(data, len);
+  ::arrow::bit_util::BitReader& reader = kHeapReader ? *heap_reader : stack_reader;
+  uint32_t values_per_block = 0, mini_blocks_per_block = 0, total_count = 0;
+  T first_value = 0;
+  ARROW_CHECK(reader.GetVlqInt(&values_per_block));
+  ARROW_CHECK(reader.GetVlqInt(&mini_blocks_per_block));
+  ARROW_CHECK(reader.GetVlqInt(&total_count));
+  ARROW_CHECK(reader.GetZigZagVlqInt(&first_value));
+  const uint32_t values_per_mini_block = values_per_block / mini_blocks_per_block;
+
+  int i = 0;
+  out[i++] = first_value;
+  UT last = static_cast<UT>(first_value);
+  uint32_t remaining = total_count - 1;
+  std::vector<uint8_t> widths(mini_blocks_per_block);
+
+  while (remaining > 0) {
+    T min_delta = 0;
+    ARROW_CHECK(reader.GetZigZagVlqInt(&min_delta));
+    for (uint32_t m = 0; m < mini_blocks_per_block; ++m) {
+      ARROW_CHECK(reader.GetAligned<uint8_t>(1, widths.data() + m));
+    }
+    for (uint32_t m = 0; m < mini_blocks_per_block && remaining > 0; ++m) {
+      const uint32_t count = std::min(values_per_mini_block, remaining);
+      const int w = widths[m];
+      if (w == 0) {
+        // Same zero-width shortcut the in-tree decoder takes.
+        if constexpr (kAblate == DbpAblate::kFull || kAblate == DbpAblate::kNoUnpack) {
+          for (uint32_t k = 0; k < count; ++k) {
+            out[i + k] = static_cast<T>(last + static_cast<UT>(k + 1) *
+                                                   static_cast<UT>(min_delta));
+          }
+          last += static_cast<UT>(count) * static_cast<UT>(min_delta);
+        }
+      } else {
+        if constexpr (kAblate == DbpAblate::kFull || kAblate == DbpAblate::kNoSum) {
+          ARROW_CHECK_EQ(reader.GetBatch(w, out + i, static_cast<int>(count)),
+                         static_cast<int>(count));
+        } else {
+          ARROW_CHECK(reader.Advance(static_cast<int64_t>(w) * count));
+        }
+        if constexpr (kAblate == DbpAblate::kFull || kAblate == DbpAblate::kNoUnpack) {
+          const UT md = static_cast<UT>(min_delta);
+          for (uint32_t k = 0; k < count; ++k) {
+            last += md + static_cast<UT>(out[i + k]);
+            out[i + k] = static_cast<T>(last);
+          }
+        }
+      }
+      i += static_cast<int>(count);
+      remaining -= count;
+    }
+  }
+  return i;
+}
+
+// Reader-side variants, reading a byte-identical stream.
+//
+// Coalescing: the payload is one sequential LSB-first bit run with no padding
+// between miniblocks, so two adjacent miniblocks that share a bit width are
+// bit-identical to a single run of twice the length at that width. Unpacking
+// them in one call raises the values-per-call the unpacker sees without
+// touching the stream. Nothing in the format has to change; the reader just
+// stops asking for 32 values at a time when it could ask for 128.
+//
+// Block sum: min_delta is a per-block quantity, so the serial prefix sum need
+// not restart at every miniblock boundary.
+template <typename T, DbpAblate kAblate>
+int DbpReaderSideDecode(const uint8_t* data, int len, T* out) {
+  using UT = std::make_unsigned_t<T>;
+  ::arrow::bit_util::BitReader reader(data, len);
+  uint32_t values_per_block = 0, mini_blocks_per_block = 0, total_count = 0;
+  T first_value = 0;
+  ARROW_CHECK(reader.GetVlqInt(&values_per_block));
+  ARROW_CHECK(reader.GetVlqInt(&mini_blocks_per_block));
+  ARROW_CHECK(reader.GetVlqInt(&total_count));
+  ARROW_CHECK(reader.GetZigZagVlqInt(&first_value));
+  const uint32_t values_per_mini_block = values_per_block / mini_blocks_per_block;
+
+  int i = 0;
+  out[i++] = first_value;
+  UT last = static_cast<UT>(first_value);
+  uint32_t remaining = total_count - 1;
+  std::vector<uint8_t> widths(mini_blocks_per_block);
+
+  while (remaining > 0) {
+    T min_delta = 0;
+    ARROW_CHECK(reader.GetZigZagVlqInt(&min_delta));
+    for (uint32_t m = 0; m < mini_blocks_per_block; ++m) {
+      ARROW_CHECK(reader.GetAligned<uint8_t>(1, widths.data() + m));
+    }
+    const UT md = static_cast<UT>(min_delta);
+    const int block_start = i;
+    uint32_t block_values = 0;
+
+    for (uint32_t m = 0; m < mini_blocks_per_block && remaining > 0;) {
+      uint32_t run = 1;
+      if constexpr (DbpDoesCoalesce(kAblate)) {
+        // Extend the run while the next miniblock shares this width and is
+        // fully present, so the coalesced call never crosses the tail.
+        while (m + run < mini_blocks_per_block && widths[m + run] == widths[m] &&
+               remaining > run * values_per_mini_block) {
+          ++run;
+        }
+      }
+      const uint32_t count = std::min(run * values_per_mini_block, remaining);
+      const int w = widths[m];
+      if (w == 0) {
+        if constexpr (DbpDoesBlockSum(kAblate)) {
+          // Leave a residual of zero for the block-wide pass below.
+          std::fill(out + i, out + i + count, T{0});
+        } else {
+          for (uint32_t k = 0; k < count; ++k) {
+            out[i + k] = static_cast<T>(last + static_cast<UT>(k + 1) * md);
+          }
+          last += static_cast<UT>(count) * md;
+        }
+      } else {
+        ARROW_CHECK_EQ(reader.GetBatch(w, out + i, static_cast<int>(count)),
+                       static_cast<int>(count));
+        if constexpr (!DbpDoesBlockSum(kAblate)) {
+          for (uint32_t k = 0; k < count; ++k) {
+            last += md + static_cast<UT>(out[i + k]);
+            out[i + k] = static_cast<T>(last);
+          }
+        }
+      }
+      i += static_cast<int>(count);
+      remaining -= count;
+      block_values += count;
+      m += run;
+    }
+
+    if constexpr (DbpDoesBlockSum(kAblate)) {
+      // One serial pass over the whole block, once every miniblock in it has
+      // been unpacked. With a direct biased unpack min_delta is already folded
+      // into each residual, so the chain is a bare running sum.
+      for (uint32_t k = 0; k < block_values; ++k) {
+        last += md + static_cast<UT>(out[block_start + k]);
+        out[block_start + k] = static_cast<T>(last);
+      }
+    }
+  }
+  return i;
+}
+
+// The most optimized reader this format admits, as a lower bound on what is
+// available without a spec change. Three things beyond the shipping decoder:
+// coalescing equal-width miniblocks into one unpack call, one prefix-sum pass
+// per block instead of per miniblock, and calling unpack_bias directly with
+// min_delta as the bias, which both skips BitReader::GetBatch's per-call
+// bookkeeping and removes one add per value from the sum loop.
+//
+// A byte cursor is enough because every position this walks is byte-aligned:
+// the stream header and block headers are byte-aligned varints and width bytes,
+// and a miniblock of v values at width w occupies exactly v*w/8 bytes with v a
+// multiple of 32, so v*w is always a multiple of 8.
+template <typename T>
+int DbpDirectDecode(const uint8_t* data, int len, T* out) {
+  using UT = std::make_unsigned_t<T>;
+  int pos = 0;
+  auto get_vlq = [&](uint32_t* v) {
+    uint32_t r = 0;
+    int shift = 0;
+    while (true) {
+      ARROW_CHECK_LT(pos, len);
+      const uint8_t b = data[pos++];
+      r |= static_cast<uint32_t>(b & 0x7F) << shift;
+      if ((b & 0x80) == 0) break;
+      shift += 7;
+      ARROW_CHECK_LE(shift, 28);
+    }
+    *v = r;
+  };
+  auto get_zigzag = [&](T* v) {
+    uint32_t u = 0;
+    get_vlq(&u);
+    *v = static_cast<T>((u >> 1) ^ (~(u & 1) + 1));
+  };
+
+  uint32_t values_per_block = 0, mini_blocks_per_block = 0, total_count = 0;
+  T first_value = 0;
+  get_vlq(&values_per_block);
+  get_vlq(&mini_blocks_per_block);
+  get_vlq(&total_count);
+  get_zigzag(&first_value);
+  const uint32_t values_per_mini_block = values_per_block / mini_blocks_per_block;
+
+  int i = 0;
+  out[i++] = first_value;
+  UT last = static_cast<UT>(first_value);
+  uint32_t remaining = total_count - 1;
+
+  while (remaining > 0) {
+    T min_delta = 0;
+    get_zigzag(&min_delta);
+    const uint8_t* widths = data + pos;
+    pos += static_cast<int>(mini_blocks_per_block);
+    ARROW_CHECK_LE(pos, len);
+    const UT md = static_cast<UT>(min_delta);
+    const int block_start = i;
+    uint32_t block_values = 0;
+
+    for (uint32_t m = 0; m < mini_blocks_per_block && remaining > 0;) {
+      uint32_t run = 1;
+      while (m + run < mini_blocks_per_block && widths[m + run] == widths[m] &&
+             remaining > run * values_per_mini_block) {
+        ++run;
+      }
+      const uint32_t count = std::min(run * values_per_mini_block, remaining);
+      const int w = widths[m];
+      if (w == 0) {
+        // No payload; the residual is min_delta itself, which the biased
+        // unpack would otherwise have supplied.
+        std::fill(out + i, out + i + count, static_cast<T>(md));
+      } else {
+        const ::arrow::internal::UnpackOptions opts{
+            .batch_size = static_cast<int>(count),
+            .bit_width = w,
+            .bit_offset = 0,
+            .max_read_bytes = len - pos,
+        };
+        ::arrow::internal::unpack_bias(data + pos, reinterpret_cast<UT*>(out + i), opts,
+                                       md);
+        pos += static_cast<int>((static_cast<int64_t>(w) * count) / 8);
+        ARROW_CHECK_LE(pos, len);
+      }
+      i += static_cast<int>(count);
+      remaining -= count;
+      block_values += count;
+      m += run;
+    }
+    // min_delta is already folded into every residual, so this is a bare
+    // running sum: one dependent add per value and nothing else.
+    for (uint32_t k = 0; k < block_values; ++k) {
+      last += static_cast<UT>(out[block_start + k]);
+      out[block_start + k] = static_cast<T>(last);
+    }
+  }
+  return i;
+}
+
+// Mean values per unpack call a coalescing reader achieves on this stream.
+// Without coalescing it is always values_per_mini_block, so the ratio of the two
+// is the granularity gain available on this column, and it bounds what the
+// kCoalesce arm can show.
+template <typename T>
+double DbpMeanValuesPerUnpackCall(const uint8_t* data, int len) {
+  ::arrow::bit_util::BitReader reader(data, len);
+  uint32_t values_per_block = 0, mini_blocks_per_block = 0, total_count = 0;
+  T first_value = 0;
+  ARROW_CHECK(reader.GetVlqInt(&values_per_block));
+  ARROW_CHECK(reader.GetVlqInt(&mini_blocks_per_block));
+  ARROW_CHECK(reader.GetVlqInt(&total_count));
+  ARROW_CHECK(reader.GetZigZagVlqInt(&first_value));
+  const uint32_t values_per_mini_block = values_per_block / mini_blocks_per_block;
+
+  uint32_t remaining = total_count - 1;
+  int64_t calls = 0, values_unpacked = 0;
+  std::vector<uint8_t> widths(mini_blocks_per_block);
+  while (remaining > 0) {
+    T min_delta = 0;
+    ARROW_CHECK(reader.GetZigZagVlqInt(&min_delta));
+    for (uint32_t m = 0; m < mini_blocks_per_block; ++m) {
+      ARROW_CHECK(reader.GetAligned<uint8_t>(1, widths.data() + m));
+    }
+    for (uint32_t m = 0; m < mini_blocks_per_block && remaining > 0;) {
+      uint32_t run = 1;
+      while (m + run < mini_blocks_per_block && widths[m + run] == widths[m] &&
+             remaining > run * values_per_mini_block) {
+        ++run;
+      }
+      const uint32_t count = std::min(run * values_per_mini_block, remaining);
+      if (widths[m] != 0) {
+        ++calls;
+        values_unpacked += count;
+        ARROW_CHECK(reader.Advance(static_cast<int64_t>(widths[m]) * count));
+      }
+      remaining -= count;
+      m += run;
+    }
+  }
+  return calls == 0 ? 0.0
+                    : static_cast<double>(values_unpacked) / static_cast<double>(calls);
+}
+
+template <typename T, DbpAblate kAblate, bool kHeapReader = false>
+static void DbpAblateImpl(benchmark::State& state, GenT<T> gen, uint32_t values_per_block,
+                          uint32_t mini_blocks_per_block) {
+  const int64_t num_values = state.range(0);
+  auto values = gen(num_values);
+  const int64_t uncompressed_size = num_values * sizeof(T);
+  auto buf = WriteDbpStream<T>(values, values_per_block, mini_blocks_per_block);
+
+  std::vector<T> decoded(num_values);
+  // Correctness gate: the unablated path must round-trip this stream exactly.
+  {
+    std::vector<T> check(num_values);
+    const int n = DbpAblatedDecode<T, DbpAblate::kFull>(
+        buf->data(), static_cast<int>(buf->size()), check.data());
+    ARROW_CHECK_EQ(n, static_cast<int>(num_values));
+    ARROW_CHECK(check == values) << "hand-built DBP stream does not round-trip";
+    // A reader-side variant must produce an identical result, or its speed
+    // means nothing.
+    if constexpr (DbpIsReaderSide(kAblate)) {
+      std::vector<T> rs(num_values);
+      const int m =
+          kAblate == DbpAblate::kDirect
+              ? DbpDirectDecode<T>(buf->data(), static_cast<int>(buf->size()), rs.data())
+              : DbpReaderSideDecode<T, kAblate>(buf->data(),
+                                                static_cast<int>(buf->size()), rs.data());
+      ARROW_CHECK_EQ(m, static_cast<int>(num_values));
+      ARROW_CHECK(rs == values) << "reader-side DBP variant disagrees";
+    }
+  }
+
+  for (auto _ : state) {
+    if constexpr (kAblate == DbpAblate::kDirect) {
+      DbpDirectDecode<T>(buf->data(), static_cast<int>(buf->size()), decoded.data());
+    } else if constexpr (DbpIsReaderSide(kAblate)) {
+      DbpReaderSideDecode<T, kAblate>(buf->data(), static_cast<int>(buf->size()),
+                                      decoded.data());
+    } else {
+      DbpAblatedDecode<T, kAblate, kHeapReader>(
+          buf->data(), static_cast<int>(buf->size()), decoded.data());
+    }
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(state.iterations() * uncompressed_size);
+  state.SetItemsProcessed(state.iterations() * num_values);
+  state.counters["compression_ratio"] =
+      static_cast<double>(uncompressed_size) / static_cast<double>(buf->size());
+  if constexpr (DbpDoesCoalesce(kAblate)) {
+    state.counters["values_per_unpack_call"] =
+        DbpMeanValuesPerUnpackCall<T>(buf->data(), static_cast<int>(buf->size()));
+    state.counters["values_per_unpack_call_plain"] =
+        static_cast<double>(values_per_block / mini_blocks_per_block);
+  }
+}
+
+// Ablation arms, all at Arrow's default int32 geometry (128 values per block,
+// 4 miniblocks, so 32 values per unpack call).
+static void BM_DbpAbFull(benchmark::State& state, Gen32 gen) {
+  DbpAblateImpl<int32_t, DbpAblate::kFull>(state, gen, 128, 4);
+}
+static void BM_DbpAbNoSum(benchmark::State& state, Gen32 gen) {
+  DbpAblateImpl<int32_t, DbpAblate::kNoSum>(state, gen, 128, 4);
+}
+static void BM_DbpAbNoUnpack(benchmark::State& state, Gen32 gen) {
+  DbpAblateImpl<int32_t, DbpAblate::kNoUnpack>(state, gen, 128, 4);
+}
+static void BM_DbpAbHeaderOnly(benchmark::State& state, Gen32 gen) {
+  DbpAblateImpl<int32_t, DbpAblate::kHeaderOnly>(state, gen, 128, 4);
+}
+
+// Same work as BM_DbpAbFull with the bit reader placed on the heap, isolating
+// how much of the shadow-versus-shipping gap that placement accounts for.
+static void BM_DbpAbFullHeapReader(benchmark::State& state, Gen32 gen) {
+  DbpAblateImpl<int32_t, DbpAblate::kFull, /*kHeapReader=*/true>(state, gen, 128, 4);
+}
+
+// Reader-side arms, at Arrow's default 128/4 geometry so they are directly
+// comparable with BM_DbpAbFull.
+static void BM_DbpRsCoalesce(benchmark::State& state, Gen32 gen) {
+  DbpAblateImpl<int32_t, DbpAblate::kCoalesce>(state, gen, 128, 4);
+}
+static void BM_DbpRsBlockSum(benchmark::State& state, Gen32 gen) {
+  DbpAblateImpl<int32_t, DbpAblate::kBlockSum>(state, gen, 128, 4);
+}
+static void BM_DbpRsBoth(benchmark::State& state, Gen32 gen) {
+  DbpAblateImpl<int32_t, DbpAblate::kBoth>(state, gen, 128, 4);
+}
+static void BM_DbpRsDirect(benchmark::State& state, Gen32 gen) {
+  DbpAblateImpl<int32_t, DbpAblate::kDirect>(state, gen, 128, 4);
+}
+
+// Geometry sweep, full decode each time. The 128/4 control is Arrow's default and
+// is registered as BM_DbpAbFull above; these vary how many values one unpack call
+// covers and how often a block header is parsed.
+static void BM_DbpGeom128x1(benchmark::State& state, Gen32 gen) {
+  DbpAblateImpl<int32_t, DbpAblate::kFull>(state, gen, 128, 1);
+}
+static void BM_DbpGeom1024x32(benchmark::State& state, Gen32 gen) {
+  DbpAblateImpl<int32_t, DbpAblate::kFull>(state, gen, 1024, 32);
+}
+static void BM_DbpGeom1024x8(benchmark::State& state, Gen32 gen) {
+  DbpAblateImpl<int32_t, DbpAblate::kFull>(state, gen, 1024, 8);
+}
+static void BM_DbpGeom1024x1(benchmark::State& state, Gen32 gen) {
+  DbpAblateImpl<int32_t, DbpAblate::kFull>(state, gen, 1024, 1);
+}
+
+// ----------------------------------------------------------------------
+// Lane-parallel delta: the +32 stride against the paper's lane assignment
+// ----------------------------------------------------------------------
+//
+// Both replace DELTA_BINARY_PACKED's 1024-long dependency chain with 32
+// independent chains of 32. They differ only in which value a lane's chain
+// steps back to, and that is what decides the compression ratio:
+//
+//   LaneDelta   lane l holds l, 32+l, ..., 992+l -- the in-lane predecessor is
+//               32 positions back, so the differences are wider than the
+//               format's. Container order is file order, so no permutation.
+//   Tpose       lane l holds the contiguous run [32l, 32l+32) -- the in-lane
+//               predecessor is the immediately preceding value, so the
+//               differences are exactly the format's. Decode ends transposed.
+//
+// Tpose comes in two base codings (32 entry points per block stored raw, or
+// delta-coded across lanes) and, for the decode side, with and without the
+// transpose back to file order. Only the repairing arm is a conforming decoder;
+// the other one isolates what the transpose costs.
+
+using ::arrow::util::fastlanes::TransposedBaseCoding;
+using ::arrow::util::fastlanes::TransposedRepair;
+
+static void BM_LaneDeltaDecode(benchmark::State& state, Gen32 gen) {
+  namespace fl = ::arrow::util::fastlanes;
+  const int64_t num_values = state.range(0);
+  auto values = gen(num_values);
+  const int64_t uncompressed_size = num_values * sizeof(int32_t);
+
+  std::vector<uint8_t> buf(fl::LaneDeltaMaxEncodedSize(num_values));
+  const size_t comp_size = fl::LaneDeltaEncode<fl::LaneDeltaOrder::kInterleaved>(
+      values.data(), num_values, buf.data());
+  ARROW_CHECK_GT(comp_size, 0);
+
+  std::vector<int32_t> decoded(num_values);
+  fl::LaneDeltaDecode<fl::LaneDeltaOrder::kInterleaved>(buf.data(), num_values,
+                                                        decoded.data());
+  ARROW_CHECK(decoded == values) << "lane delta round trip failed";
+
+  for (auto _ : state) {
+    fl::LaneDeltaDecode<fl::LaneDeltaOrder::kInterleaved>(buf.data(), num_values,
+                                                          decoded.data());
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(state.iterations() * uncompressed_size);
+  state.SetItemsProcessed(state.iterations() * num_values);
+  state.counters["compression_ratio"] =
+      static_cast<double>(uncompressed_size) / static_cast<double>(comp_size);
+}
+
+// The values a decoder that stops in transposed order should produce.
+static std::vector<int32_t> TransposeReference(const std::vector<int32_t>& in) {
+  namespace fl = ::arrow::util::fastlanes;
+  std::vector<int32_t> out(in.size());
+  const size_t nblocks = in.size() / fl::kBlockSize;
+  for (size_t b = 0; b < nblocks; ++b) {
+    for (size_t t = 0; t < fl::kBlockSize; ++t) {
+      out[b * fl::kBlockSize + t] = in[b * fl::kBlockSize + fl::TransposedSource(t)];
+    }
+  }
+  return out;
+}
+
+template <TransposedBaseCoding kBases, TransposedRepair kRepair>
+static void TposeDecodeImpl(benchmark::State& state, Gen32 gen) {
+  namespace fl = ::arrow::util::fastlanes;
+  const int64_t num_values = state.range(0);
+  auto values = gen(num_values);
+  const int64_t uncompressed_size = num_values * sizeof(int32_t);
+
+  std::vector<uint8_t> buf(fl::TransposedMaxEncodedSize(num_values));
+  const size_t comp_size =
+      fl::TransposedDeltaEncode<kBases>(values.data(), num_values, buf.data());
+  ARROW_CHECK_GT(comp_size, 0);
+
+  std::vector<int32_t> decoded(num_values);
+  fl::TransposedDeltaDecode<kBases, kRepair>(buf.data(), num_values, decoded.data());
+  if constexpr (kRepair != TransposedRepair::kNone) {
+    ARROW_CHECK(decoded == values) << "transposed delta round trip failed";
+  } else {
+    ARROW_CHECK(decoded == TransposeReference(values))
+        << "transposed delta round trip failed in transposed order";
+  }
+
+  for (auto _ : state) {
+    fl::TransposedDeltaDecode<kBases, kRepair>(buf.data(), num_values, decoded.data());
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(state.iterations() * uncompressed_size);
+  state.SetItemsProcessed(state.iterations() * num_values);
+  state.counters["compression_ratio"] =
+      static_cast<double>(uncompressed_size) / static_cast<double>(comp_size);
+}
+
+static void BM_TposeRawDecode(benchmark::State& state, Gen32 gen) {
+  TposeDecodeImpl<TransposedBaseCoding::kRaw, TransposedRepair::kSeparate>(state, gen);
+}
+static void BM_TposePackedDecode(benchmark::State& state, Gen32 gen) {
+  TposeDecodeImpl<TransposedBaseCoding::kPacked, TransposedRepair::kSeparate>(state, gen);
+}
+// The conforming decoder: adjacent deltas, file order out, one pass over the block.
+static void BM_TposeFusedDecode(benchmark::State& state, Gen32 gen) {
+  TposeDecodeImpl<TransposedBaseCoding::kPacked, TransposedRepair::kFused>(state, gen);
+}
+// Neither of these is a conforming decoder: they leave the block transposed.
+// Raw-vs-Packed at fixed repair isolates the base stream, and NoRepair-vs-not at
+// fixed base coding isolates the 32x32 transpose.
+static void BM_TposeNoRepairDecode(benchmark::State& state, Gen32 gen) {
+  TposeDecodeImpl<TransposedBaseCoding::kPacked, TransposedRepair::kNone>(state, gen);
+}
+static void BM_TposeRawNoRepairDecode(benchmark::State& state, Gen32 gen) {
+  TposeDecodeImpl<TransposedBaseCoding::kRaw, TransposedRepair::kNone>(state, gen);
+}
+
+static void BM_LaneDeltaEncode(benchmark::State& state, Gen32 gen) {
+  namespace fl = ::arrow::util::fastlanes;
+  const int64_t num_values = state.range(0);
+  auto values = gen(num_values);
+  std::vector<uint8_t> buf(fl::LaneDeltaMaxEncodedSize(num_values));
+  size_t comp_size = 0;
+  for (auto _ : state) {
+    comp_size = fl::LaneDeltaEncode<fl::LaneDeltaOrder::kInterleaved>(
+        values.data(), num_values, buf.data());
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(state.iterations() * num_values * sizeof(int32_t));
+  state.SetItemsProcessed(state.iterations() * num_values);
+  const double raw = static_cast<double>(num_values * sizeof(int32_t));
+  state.counters["compression_ratio"] = raw / static_cast<double>(comp_size);
+}
+
+static void BM_TposePackedEncode(benchmark::State& state, Gen32 gen) {
+  namespace fl = ::arrow::util::fastlanes;
+  const int64_t num_values = state.range(0);
+  auto values = gen(num_values);
+  std::vector<uint8_t> buf(fl::TransposedMaxEncodedSize(num_values));
+  size_t comp_size = 0;
+  for (auto _ : state) {
+    comp_size = fl::TransposedDeltaEncode<TransposedBaseCoding::kPacked>(
+        values.data(), num_values, buf.data());
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(state.iterations() * num_values * sizeof(int32_t));
+  state.SetItemsProcessed(state.iterations() * num_values);
+  const double raw = static_cast<double>(num_values * sizeof(int32_t));
+  state.counters["compression_ratio"] = raw / static_cast<double>(comp_size);
+}
+
 // ----------------------------------------------------------------------
 // Benchmark Registration
 
@@ -1293,6 +2022,27 @@ static void CustomArgs(benchmark::internal::Benchmark* b) { b->Arg(102400); }
   BENCHMARK_CAPTURE(BM_PforDbpDeltaDecode, Name, &GenFunc)->Apply(CustomArgs);     \
   BENCHMARK_CAPTURE(BM_DeltaBitPackEncode, Name, &GenFunc)->Apply(CustomArgs);     \
   BENCHMARK_CAPTURE(BM_DeltaBitPackDecode, Name, &GenFunc)->Apply(CustomArgs);     \
+  BENCHMARK_CAPTURE(BM_DbpAbFull, Name, &GenFunc)->Apply(CustomArgs);              \
+  BENCHMARK_CAPTURE(BM_DbpAbNoSum, Name, &GenFunc)->Apply(CustomArgs);             \
+  BENCHMARK_CAPTURE(BM_DbpAbNoUnpack, Name, &GenFunc)->Apply(CustomArgs);          \
+  BENCHMARK_CAPTURE(BM_DbpAbHeaderOnly, Name, &GenFunc)->Apply(CustomArgs);        \
+  BENCHMARK_CAPTURE(BM_DbpAbFullHeapReader, Name, &GenFunc)->Apply(CustomArgs);    \
+  BENCHMARK_CAPTURE(BM_DbpRsCoalesce, Name, &GenFunc)->Apply(CustomArgs);          \
+  BENCHMARK_CAPTURE(BM_DbpRsBlockSum, Name, &GenFunc)->Apply(CustomArgs);          \
+  BENCHMARK_CAPTURE(BM_DbpRsBoth, Name, &GenFunc)->Apply(CustomArgs);              \
+  BENCHMARK_CAPTURE(BM_DbpRsDirect, Name, &GenFunc)->Apply(CustomArgs);            \
+  BENCHMARK_CAPTURE(BM_DbpGeom128x1, Name, &GenFunc)->Apply(CustomArgs);           \
+  BENCHMARK_CAPTURE(BM_DbpGeom1024x32, Name, &GenFunc)->Apply(CustomArgs);         \
+  BENCHMARK_CAPTURE(BM_DbpGeom1024x8, Name, &GenFunc)->Apply(CustomArgs);          \
+  BENCHMARK_CAPTURE(BM_DbpGeom1024x1, Name, &GenFunc)->Apply(CustomArgs);          \
+  BENCHMARK_CAPTURE(BM_LaneDeltaDecode, Name, &GenFunc)->Apply(CustomArgs);        \
+  BENCHMARK_CAPTURE(BM_TposeRawDecode, Name, &GenFunc)->Apply(CustomArgs);         \
+  BENCHMARK_CAPTURE(BM_TposePackedDecode, Name, &GenFunc)->Apply(CustomArgs);      \
+  BENCHMARK_CAPTURE(BM_TposeFusedDecode, Name, &GenFunc)->Apply(CustomArgs);       \
+  BENCHMARK_CAPTURE(BM_TposeNoRepairDecode, Name, &GenFunc)->Apply(CustomArgs);    \
+  BENCHMARK_CAPTURE(BM_TposeRawNoRepairDecode, Name, &GenFunc)->Apply(CustomArgs); \
+  BENCHMARK_CAPTURE(BM_LaneDeltaEncode, Name, &GenFunc)->Apply(CustomArgs);        \
+  BENCHMARK_CAPTURE(BM_TposePackedEncode, Name, &GenFunc)->Apply(CustomArgs);      \
   BENCHMARK_CAPTURE(BM_PlainZstdEncode, Name, &GenFunc)->Apply(CustomArgs);        \
   BENCHMARK_CAPTURE(BM_PlainZstdDecode, Name, &GenFunc)->Apply(CustomArgs);        \
   BENCHMARK_CAPTURE(BM_PlainLz4Encode, Name, &GenFunc)->Apply(CustomArgs);         \
@@ -1361,6 +2111,14 @@ REGISTER_DATASET(TpchLShipDate, GenTpchLShipDate)
 REGISTER_DATASET(TaxiPickupUnixTime, GenTaxiPickupUnixTime)
 REGISTER_DATASET(TaxiTripDistanceX100, GenTaxiTripDistanceX100)
 REGISTER_DATASET(TaxiFareCents, GenTaxiFareCents)
+
+// Correlated columns. DELTA_BINARY_PACKED is only used on data of this shape,
+// so any claim about its decode cost has to be measured here and not only on
+// the independently-drawn columns above.
+REGISTER_DATASET(SortedUnixTime, GenSortedUnixTime)
+REGISTER_DATASET(SortedKeyDups, GenSortedKeyDups)
+REGISTER_DATASET(MonotoneRowId, GenMonotoneRowId)
+REGISTER_DATASET(NearSortedUnixTime, GenNearSortedUnixTime)
 // int64 / BIGINT datasets (8-byte signed values)
 REGISTER_DATASET64(TsNanos, GenTsNanos)
 REGISTER_DATASET64(OrderKey, GenOrderKey)

From 02564e2479794ec46f8e23954b5b0d924b4eac25 Mon Sep 17 00:00:00 2001
From: Prateek Gaur <prateek.gaur@snowflake.com>
Date: Tue, 8 Sep 2026 19:30:07 +0000
Subject: [PATCH 17/27] Decode lane-parallel delta pages

Adds an int32 page decoder for the lane layout that checks the layout
marker and stream length and stops at the declared value count. A
benchmark runs it end to end next to Arrow's existing delta decoder.
---
 .../fastlanes/lane_delta_wrapper_internal.h   | 209 +++++++++++++++
 .../arrow/util/fastlanes/transposed_delta.h   |  16 +-
 cpp/src/parquet/arrow/arrow_encoding_test.cc  | 113 +++++++++
 cpp/src/parquet/column_reader.cc              |   3 +-
 cpp/src/parquet/decoder.cc                    | 167 ++++++++++++
 cpp/src/parquet/encoder.cc                    |  82 ++++++
 cpp/src/parquet/encoding_test.cc              | 240 ++++++++++++++++++
 cpp/src/parquet/pfor_comparison_benchmark.cc  |  63 +++++
 cpp/src/parquet/types.cc                      |   2 +
 cpp/src/parquet/types.h                       |   3 +-
 10 files changed, 892 insertions(+), 6 deletions(-)
 create mode 100644 cpp/src/arrow/util/fastlanes/lane_delta_wrapper_internal.h

diff --git a/cpp/src/arrow/util/fastlanes/lane_delta_wrapper_internal.h b/cpp/src/arrow/util/fastlanes/lane_delta_wrapper_internal.h
new file mode 100644
index 000000000000..c22fcf736d7d
--- /dev/null
+++ b/cpp/src/arrow/util/fastlanes/lane_delta_wrapper_internal.h
@@ -0,0 +1,209 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+// ---------------------------------------------------------------------------
+// Page-level framing for lane-parallel delta, so the layout can be read through
+// a Parquet decoder rather than called as a kernel. A kernel measurement skips
+// the page header, the decoder's own dispatch and the level handling, so
+// dividing one by a full decoder's rate overstates what a reader would gain.
+//
+// The framing this adds over the kernel's wire layout is a value count:
+//
+//   [0, 4)      uint32 value count, little endian
+//   [4, ...)    the payload described in lane_delta.h
+//
+// The count has to live here because the payload's own header does not carry
+// one, while decode needs it to locate every section. A page's level count
+// cannot stand in for it, since that count includes nulls.
+//
+// Two properties of the payload are the kernel's and are not fixed here. Its
+// packed words and its per-block minimums are stored in host byte order, which
+// a format specification would have to pin down before this could be written to
+// a file anyone else reads. And it is int32 only, so this wrapper is too.
+// ---------------------------------------------------------------------------
+
+#pragma once
+
+#include <cstdint>
+#include <cstring>
+#include <limits>
+
+#include "arrow/buffer.h"
+#include "arrow/result.h"
+#include "arrow/status.h"
+#include "arrow/util/bit_util.h"
+#include "arrow/util/fastlanes/lane_delta.h"
+
+namespace arrow {
+namespace util {
+namespace fastlanes {
+
+/// \brief Page-level encode and decode for the lane-parallel delta layout
+///
+/// Only int32 is implemented, because the kernel is int32 only.
+template <typename T>
+class LaneDeltaWrapper;
+
+template <>
+class LaneDeltaWrapper<int32_t> {
+ public:
+  /// Bytes the value count occupies ahead of the payload.
+  static constexpr int64_t kCountSize = sizeof(uint32_t);
+
+  /// \brief Upper bound on the bytes Encode writes for `num_values` values
+  static int64_t GetMaxCompressedSize(int32_t num_values) {
+    if (num_values <= 0) return kCountSize;
+    return kCountSize +
+           static_cast<int64_t>(LaneDeltaMaxEncodedSize(static_cast<size_t>(num_values)));
+  }
+
+  /// \brief Encode values into one page
+  ///
+  /// \param[in] values the values to encode
+  /// \param[in] num_values how many; zero writes a bare count, which is what an
+  ///            all-null page encodes to
+  /// \param[out] comp output buffer, at least GetMaxCompressedSize bytes
+  /// \param[in,out] comp_size in: bytes available; out: bytes written
+  static Status Encode(const int32_t* values, int32_t num_values, uint8_t* comp,
+                       int64_t* comp_size) {
+    if (num_values < 0) {
+      return Status::Invalid("Lane delta encode: negative value count ", num_values);
+    }
+    if (comp == nullptr || comp_size == nullptr) {
+      return Status::Invalid("Lane delta encode: null output");
+    }
+    const int64_t needed = GetMaxCompressedSize(num_values);
+    if (*comp_size < needed) {
+      return Status::Invalid("Lane delta encode: buffer holds ", *comp_size,
+                             " bytes, needs ", needed);
+    }
+    StoreCount(comp, static_cast<uint32_t>(num_values));
+    if (num_values == 0) {
+      *comp_size = kCountSize;
+      return Status::OK();
+    }
+    if (values == nullptr) {
+      return Status::Invalid("Lane delta encode: null input for ", num_values, " values");
+    }
+    const size_t written = LaneDeltaEncode<LaneDeltaOrder::kInterleaved>(
+        values, static_cast<size_t>(num_values), comp + kCountSize);
+    if (written == 0) {
+      return Status::Invalid("Lane delta encode: no block width fits ", num_values,
+                             " values");
+    }
+    *comp_size = kCountSize + static_cast<int64_t>(written);
+    return Status::OK();
+  }
+
+  /// \brief Read how many values a page holds, without decoding it
+  static Result<int32_t> DecodeElementCount(const uint8_t* comp, int64_t comp_size) {
+    if (comp == nullptr || comp_size < kCountSize) {
+      return Status::Invalid("Lane delta page is ", comp_size,
+                             " bytes, too short to hold a value count");
+    }
+    const uint32_t count = LoadCount(comp);
+    if (count > static_cast<uint32_t>(std::numeric_limits<int32_t>::max())) {
+      return Status::Invalid("Lane delta page declares ", count, " values");
+    }
+    return static_cast<int32_t>(count);
+  }
+
+  /// \brief Decode a whole page
+  ///
+  /// \param[in] comp the page
+  /// \param[in] comp_size its size
+  /// \param[in] num_values values to decode, which must equal the page's own count
+  /// \param[out] values output, sized for num_values
+  ///
+  /// The kernel reads the payload as 4-byte words, so a payload that does not
+  /// start 4-byte aligned is copied to an aligned buffer first. Page buffers are
+  /// normally aligned and the copy does not happen.
+  static Status Decode(const uint8_t* comp, int64_t comp_size, int32_t num_values,
+                       int32_t* values) {
+    ARROW_ASSIGN_OR_RAISE(const int32_t declared, DecodeElementCount(comp, comp_size));
+    if (declared != num_values) {
+      return Status::Invalid("Lane delta page declares ", declared,
+                             " values but the caller asked for ", num_values);
+    }
+    if (num_values == 0) return Status::OK();
+    if (values == nullptr) {
+      return Status::Invalid("Lane delta decode: null output");
+    }
+
+    const uint8_t* payload = comp + kCountSize;
+    const int64_t payload_size = comp_size - kCountSize;
+    ARROW_ASSIGN_OR_RAISE(
+        const int64_t expected,
+        PayloadSize(payload, payload_size, static_cast<size_t>(num_values)));
+    if (payload_size < expected) {
+      return Status::Invalid("Lane delta page holds ", payload_size,
+                             " payload bytes, needs ", expected);
+    }
+
+    if (reinterpret_cast<uintptr_t>(payload) % sizeof(uint32_t) == 0) {
+      LaneDeltaDecode<LaneDeltaOrder::kInterleaved>(
+          payload, static_cast<size_t>(num_values), values);
+      return Status::OK();
+    }
+    ARROW_ASSIGN_OR_RAISE(auto aligned, AllocateBuffer(expected));
+    std::memcpy(aligned->mutable_data(), payload, static_cast<size_t>(expected));
+    LaneDeltaDecode<LaneDeltaOrder::kInterleaved>(
+        aligned->data(), static_cast<size_t>(num_values), values);
+    return Status::OK();
+  }
+
+ private:
+  static void StoreCount(uint8_t* comp, uint32_t count) {
+    const uint32_t le = ::arrow::bit_util::ToLittleEndian(count);
+    std::memcpy(comp, &le, sizeof(le));
+  }
+
+  static uint32_t LoadCount(const uint8_t* comp) {
+    uint32_t le = 0;
+    std::memcpy(&le, comp, sizeof(le));
+    return ::arrow::bit_util::FromLittleEndian(le);
+  }
+
+  /// Bytes the payload occupies for `n` values, summed from the block widths the
+  /// payload itself carries. Reading those widths needs the header to be present,
+  /// so that much is checked first.
+  static Result<int64_t> PayloadSize(const uint8_t* payload, int64_t payload_size,
+                                     size_t n) {
+    const int64_t header = static_cast<int64_t>(LaneDeltaHeaderSize(n));
+    if (payload_size < header) {
+      return Status::Invalid("Lane delta payload is ", payload_size,
+                             " bytes, too short for a ", header, " byte header");
+    }
+    const size_t nblocks = n / kBlockSize;
+    const uint8_t* widths = payload + kLanes * sizeof(uint32_t);
+    int64_t packed_words = 0;
+    for (size_t b = 0; b < nblocks; ++b) {
+      if (widths[b] > 32) {
+        return Status::Invalid("Lane delta block ", b, " declares width ",
+                               static_cast<int>(widths[b]));
+      }
+      packed_words += static_cast<int64_t>(widths[b]) * static_cast<int64_t>(kLanes);
+    }
+    const int64_t tail = static_cast<int64_t>(n % kBlockSize);
+    return header + packed_words * static_cast<int64_t>(sizeof(uint32_t)) +
+           tail * static_cast<int64_t>(sizeof(int32_t));
+  }
+};
+
+}  // namespace fastlanes
+}  // namespace util
+}  // namespace arrow
diff --git a/cpp/src/arrow/util/fastlanes/transposed_delta.h b/cpp/src/arrow/util/fastlanes/transposed_delta.h
index 880120ea04a9..04bc8dd925f2 100644
--- a/cpp/src/arrow/util/fastlanes/transposed_delta.h
+++ b/cpp/src/arrow/util/fastlanes/transposed_delta.h
@@ -136,13 +136,21 @@ inline void UnpackScalar32(const uint8_t* in, uint32_t w, uint32_t* out) {
     return;
   }
   const uint32_t mask = w == 32 ? ~uint32_t{0} : ((uint32_t{1} << w) - 1);
-  // Branchless: one unaligned 64-bit load per value covers any w <= 32 at any
-  // bit offset. The last load reads up to 7 bytes beyond the base stream, which
-  // TransposedMaxEncodedSize leaves slack for.
+  // One unaligned 64-bit load per value covers any w <= 32 at any bit offset,
+  // and the load for the last value or two reaches past the stream. That is off
+  // the end of the page when the last block of a page needs no payload words,
+  // so the stream is staged first: it is at most 128 bytes, one copy per 1024
+  // values, and it buys a loop with no bounds test and no short loads. Bytes
+  // above the stream never reach the output -- every value's bits lie inside
+  // it, and the mask keeps only those.
+  const size_t stream = (kLanes * w + 7) / 8;
+  alignas(8) uint8_t staged[kLanes * sizeof(uint32_t) + sizeof(uint64_t)];
+  std::memcpy(staged, in, stream);
+  std::memset(staged + stream, 0, sizeof(uint64_t));
   for (size_t i = 0; i < kLanes; ++i) {
     const size_t bit = i * w;
     uint64_t word;
-    std::memcpy(&word, in + (bit >> 3), sizeof(word));
+    std::memcpy(&word, staged + (bit >> 3), sizeof(word));
     out[i] = static_cast<uint32_t>(word >> (bit & 7)) & mask;
   }
 }
diff --git a/cpp/src/parquet/arrow/arrow_encoding_test.cc b/cpp/src/parquet/arrow/arrow_encoding_test.cc
index 0bc09f6c01ff..ee792047e900 100644
--- a/cpp/src/parquet/arrow/arrow_encoding_test.cc
+++ b/cpp/src/parquet/arrow/arrow_encoding_test.cc
@@ -498,6 +498,119 @@ TEST_F(ParquetPforEncodingTest, DeltaModeCanBeTurnedOffPerColumn) {
       << " bytes with the mode on, " << without_delta << " with it off";
 }
 
+// ----------------------------------------------------------------------
+// Lane-parallel delta encoding file-level integration tests
+
+// INT32 only, so a table mixing types leaves its other columns on their
+// defaults rather than failing the write.
+class ParquetLaneDeltaEncodingTest : public ::testing::Test {
+ public:
+  void TestRoundTrip(const std::shared_ptr<Table>& table, int64_t row_group_size = -1,
+                     Compression::type compression = Compression::UNCOMPRESSED) {
+    auto writer_props = WriterProperties::Builder()
+                            .disable_dictionary()
+                            ->encoding(Encoding::LANE_DELTA)
+                            ->compression(compression)
+                            ->build();
+
+    std::shared_ptr<Table> result;
+    std::shared_ptr<Buffer> file;
+    DoRoundtrip(table, row_group_size < 0 ? table->num_rows() : row_group_size, &result,
+                writer_props, &file);
+
+    ASSERT_NO_FATAL_FAILURE(AssertAllColumnsUse(file, Encoding::LANE_DELTA));
+    ASSERT_NO_FATAL_FAILURE(::arrow::AssertTablesEqual(*table, *result));
+  }
+};
+
+TEST_F(ParquetLaneDeltaEncodingTest, SimpleInt32Table) {
+  auto schema = ::arrow::schema({::arrow::field("values", ::arrow::int32())});
+  auto table = ::arrow::TableFromJSON(
+      schema, {R"([[1], [2], [3], [4], [5], [6], [7], [8], [9], [10]])"});
+  TestRoundTrip(table);
+}
+
+// Blocks are 1024 values, so a column longer than one block exercises the carry
+// from one block's last row into the next block's first.
+TEST_F(ParquetLaneDeltaEncodingTest, ManyBlocksAndATail) {
+  ::arrow::random::RandomArrayGenerator rag(1234);
+  auto array = rag.Int32(5000, -1'000'000, 1'000'000, /*null_probability=*/0.0);
+  auto schema = ::arrow::schema({::arrow::field("values", ::arrow::int32())});
+  TestRoundTrip(Table::Make(schema, {std::make_shared<ChunkedArray>(array)}));
+}
+
+TEST_F(ParquetLaneDeltaEncodingTest, WithNulls) {
+  ::arrow::random::RandomArrayGenerator rag(4321);
+  auto array = rag.Int32(5000, -50'000, 50'000, /*null_probability=*/0.3);
+  auto schema = ::arrow::schema({::arrow::field("values", ::arrow::int32(),
+                                                /*nullable=*/true)});
+  TestRoundTrip(Table::Make(schema, {std::make_shared<ChunkedArray>(array)}));
+}
+
+TEST_F(ParquetLaneDeltaEncodingTest, MultipleRowGroups) {
+  ::arrow::random::RandomArrayGenerator rag(555);
+  auto array = rag.Int32(4000, 0, 1'000'000, /*null_probability=*/0.0);
+  auto schema = ::arrow::schema({::arrow::field("values", ::arrow::int32())});
+  TestRoundTrip(Table::Make(schema, {std::make_shared<ChunkedArray>(array)}),
+                /*row_group_size=*/1500);
+}
+
+#ifdef ARROW_WITH_ZSTD
+TEST_F(ParquetLaneDeltaEncodingTest, WithCompression) {
+  ::arrow::random::RandomArrayGenerator rag(777);
+  auto array = rag.Int32(3000, -2000, 2000, /*null_probability=*/0.0);
+  auto schema = ::arrow::schema({::arrow::field("values", ::arrow::int32())});
+  TestRoundTrip(Table::Make(schema, {std::make_shared<ChunkedArray>(array)}),
+                /*row_group_size=*/-1, Compression::ZSTD);
+}
+#endif
+
+// A reader that asks for fewer values than the page holds is served the rest on
+// later calls, so batches smaller than a page must reassemble exactly.
+TEST_F(ParquetLaneDeltaEncodingTest, ReadInSmallBatches) {
+  ::arrow::random::RandomArrayGenerator rag(99);
+  auto array = rag.Int32(4096, -30000, 30000, /*null_probability=*/0.0);
+
+  auto schema = ::arrow::schema({::arrow::field("values", ::arrow::int32())});
+  auto table = Table::Make(schema, {std::make_shared<ChunkedArray>(array)});
+
+  auto writer_props = WriterProperties::Builder()
+                          .disable_dictionary()
+                          ->encoding(Encoding::LANE_DELTA)
+                          ->build();
+
+  auto sink = CreateOutputStream();
+  ASSERT_OK(WriteTable(*table, ::arrow::default_memory_pool(), sink, table->num_rows(),
+                       writer_props));
+  ASSERT_OK_AND_ASSIGN(auto buffer, sink->Finish());
+
+  std::unique_ptr<FileReader> reader;
+  FileReaderBuilder builder;
+  ASSERT_OK_NO_THROW(builder.Open(std::make_shared<BufferReader>(buffer)));
+  ASSERT_OK(builder.properties(default_arrow_reader_properties())->Build(&reader));
+  reader->set_batch_size(97);
+
+  ASSERT_OK_AND_ASSIGN(auto batch_reader, reader->GetRecordBatchReader());
+  ASSERT_OK_AND_ASSIGN(auto result, batch_reader->ToTable());
+
+  ASSERT_NO_FATAL_FAILURE(
+      ::arrow::AssertTablesEqual(*table, *result, /*same_chunk_layout=*/false));
+}
+
+// An INT64 column cannot be written in this encoding, and the writer has to say
+// so rather than fall back silently.
+TEST_F(ParquetLaneDeltaEncodingTest, Int64Rejected) {
+  auto schema = ::arrow::schema({::arrow::field("values", ::arrow::int64())});
+  auto table = ::arrow::TableFromJSON(schema, {R"([[1], [2], [3]])"});
+  auto writer_props = WriterProperties::Builder()
+                          .disable_dictionary()
+                          ->encoding(Encoding::LANE_DELTA)
+                          ->build();
+  auto sink = CreateOutputStream();
+  ASSERT_RAISES(IOError, WriteTable(*table, ::arrow::default_memory_pool(), sink,
+                                    table->num_rows(), writer_props));
+}
+
 }  // namespace
 }  // namespace arrow
 }  // namespace parquet
diff --git a/cpp/src/parquet/column_reader.cc b/cpp/src/parquet/column_reader.cc
index b2d5c18630c8..4ae17c6dbd7b 100644
--- a/cpp/src/parquet/column_reader.cc
+++ b/cpp/src/parquet/column_reader.cc
@@ -972,7 +972,8 @@ class ColumnReaderImplBase {
         case Encoding::DELTA_BINARY_PACKED:
         case Encoding::DELTA_BYTE_ARRAY:
         case Encoding::DELTA_LENGTH_BYTE_ARRAY:
-        case Encoding::PFOR: {
+        case Encoding::PFOR:
+        case Encoding::LANE_DELTA: {
           auto decoder = MakeTypedDecoder<DType>(encoding, descr_, pool_);
           current_decoder_.SetDecoder(decoder.get());
           decoders_[static_cast<int>(encoding)] = std::move(decoder);
diff --git a/cpp/src/parquet/decoder.cc b/cpp/src/parquet/decoder.cc
index 1a4e8c93af49..e136e70798e8 100644
--- a/cpp/src/parquet/decoder.cc
+++ b/cpp/src/parquet/decoder.cc
@@ -44,6 +44,7 @@
 #include "arrow/util/bitmap_ops.h"
 #include "arrow/util/byte_stream_split_internal.h"
 #include "arrow/util/checked_cast.h"
+#include "arrow/util/fastlanes/lane_delta_wrapper_internal.h"
 #include "arrow/util/int_util_overflow.h"
 #include "arrow/util/logging_internal.h"
 #include "arrow/util/pfor/pfor_wrapper_internal.h"
@@ -2552,6 +2553,163 @@ class PforDecoder : public TypedDecoderImpl<DType> {
   int64_t levels_remaining_ = 0;
 };
 
+// ----------------------------------------------------------------------
+// Lane-parallel delta decoder
+
+// The mirror of the lane-parallel delta encoder. Its reconstruction advances 32
+// independent chains with one vector add per row, in place of the single chain
+// of dependent adds that DELTA_BINARY_PACKED walks. INT32 only.
+//
+// Partial reads take the same route as PFOR's: the kernel keeps no resumption
+// state, so a caller reading a page in batches decodes the whole page into
+// scratch on the first batch and is served from it afterwards.
+class LaneDeltaDecoder : public TypedDecoderImpl<Int32Type> {
+ public:
+  using Base = TypedDecoderImpl<Int32Type>;
+  using T = int32_t;
+  using Wrapper = ::arrow::util::fastlanes::LaneDeltaWrapper<T>;
+
+  explicit LaneDeltaDecoder(const ColumnDescriptor* descr,
+                            MemoryPool* pool = ::arrow::default_memory_pool())
+      : Base(descr, Encoding::LANE_DELTA),
+        pool_(pool),
+        decoded_values_(AllocateBuffer(pool, 0)) {}
+
+  void SetData(int num_values, const uint8_t* data, int len) override {
+    Base::SetData(num_values, data, len);
+    if (num_values > 0 && len <= 0) {
+      throw ParquetException(
+          "LANE_DELTA SetData: num_values=" + std::to_string(num_values) +
+          " but len=" + std::to_string(len));
+    }
+    // A decoder is cached per encoding and reused across the data pages of a
+    // column chunk, so state describing the previous page has to be dropped
+    // with the page.
+    scratch_filled_ = false;
+    // `num_values` is the page's level count, which includes nulls, while the
+    // page stores only the non-null values. Its own count is the authority.
+    if (len > 0) {
+      PARQUET_ASSIGN_OR_THROW(total_values_,
+                              Wrapper::DecodeElementCount(this->data_, this->len_));
+      if (total_values_ > num_values) {
+        throw ParquetException(
+            "LANE_DELTA page declares " + std::to_string(total_values_) +
+            " values but the page header allows at most " + std::to_string(num_values));
+      }
+    } else {
+      total_values_ = 0;
+    }
+    this->num_values_ = total_values_;
+  }
+
+  int Decode(T* buffer, int max_values) override {
+    max_values = std::min(max_values, this->num_values_);
+    if (max_values == 0) return 0;
+
+    // The caller asked for the whole page and none of it has been served yet,
+    // so decode straight into its buffer -- no page-sized scratch and no copy.
+    if (CanDecodeWholePage(max_values)) {
+      PARQUET_THROW_NOT_OK(
+          Wrapper::Decode(this->data_, this->len_, total_values_, buffer));
+    } else {
+      std::memcpy(buffer, NextDecoded(), static_cast<size_t>(max_values) * sizeof(T));
+    }
+    this->num_values_ -= max_values;
+    return max_values;
+  }
+
+  // `num_values` counts output slots; only the non-null ones are backed by
+  // encoded values, so decode that many and spread them over the valid runs.
+  int DecodeArrow(int num_values, int null_count, const uint8_t* valid_bits,
+                  int64_t valid_bits_offset,
+                  typename EncodingTraits<Int32Type>::Accumulator* builder) override {
+    const int values_to_decode = num_values - null_count;
+    if (ARROW_PREDICT_FALSE(this->num_values_ < values_to_decode)) {
+      ParquetException::EofException(
+          "LANE_DELTA DecodeArrow: not enough values available. "
+          "Available: " +
+          std::to_string(this->num_values_) +
+          ", requested: " + std::to_string(values_to_decode));
+    }
+
+    PARQUET_THROW_NOT_OK(builder->Reserve(num_values));
+
+    // 1. Land the values in the builder's storage packed to the right, so step
+    //    2 can expand them in place into their final positions.
+    if (values_to_decode > 0) {
+      T* decode_out = builder->GetMutableValue(builder->length() + null_count);
+      if (CanDecodeWholePage(values_to_decode)) {
+        PARQUET_THROW_NOT_OK(
+            Wrapper::Decode(this->data_, this->len_, total_values_, decode_out));
+      } else {
+        std::memcpy(decode_out, NextDecoded(),
+                    static_cast<size_t>(values_to_decode) * sizeof(T));
+      }
+    }
+
+    // 2. Expand the values into their final positions.
+    if (null_count == 0) {
+      builder->UnsafeAdvance(num_values);
+    } else {
+      ::arrow::util::internal::SpacedExpandLeftward(
+          reinterpret_cast<uint8_t*>(builder->GetMutableValue(builder->length())),
+          static_cast<int>(sizeof(T)), num_values, null_count, valid_bits,
+          valid_bits_offset);
+      builder->UnsafeAdvance(num_values, valid_bits, valid_bits_offset);
+    }
+    this->num_values_ -= values_to_decode;
+    return values_to_decode;
+  }
+
+  int DecodeArrow(int num_values, int null_count, const uint8_t* valid_bits,
+                  int64_t valid_bits_offset,
+                  typename EncodingTraits<Int32Type>::DictAccumulator* out) override {
+    const int values_decoded = num_values - null_count;
+    std::vector<T> values(values_decoded);
+    if (Decode(values.data(), values_decoded) != values_decoded) {
+      ParquetException::EofException();
+    }
+    const T* data = values.data();
+    PARQUET_THROW_NOT_OK(out->Reserve(num_values));
+    VisitNullBitmapInline(
+        valid_bits, valid_bits_offset, num_values, null_count,
+        [&]() { PARQUET_THROW_NOT_OK(out->Append(*data++)); },
+        [&]() { PARQUET_THROW_NOT_OK(out->AppendNull()); });
+    return values_decoded;
+  }
+
+ private:
+  /// \brief Whether `count` values can be decoded straight to the caller
+  ///
+  /// The kernel only decodes a page from its start, so this holds when the
+  /// caller wants the whole page and nothing has been served from it yet.
+  bool CanDecodeWholePage(int count) const {
+    return !scratch_filled_ && count == total_values_;
+  }
+
+  /// \brief Pointer to the next undelivered value, decoding the page if needed
+  const T* NextDecoded() {
+    if (!scratch_filled_) {
+      PARQUET_THROW_NOT_OK(
+          decoded_values_->Resize(static_cast<int64_t>(total_values_) * sizeof(T),
+                                  /*shrink_to_fit=*/false));
+      PARQUET_THROW_NOT_OK(Wrapper::Decode(this->data_, this->len_, total_values_,
+                                           decoded_values_->mutable_data_as<T>()));
+      scratch_filled_ = true;
+    }
+    return decoded_values_->data_as<T>() + (total_values_ - this->num_values_);
+  }
+
+  MemoryPool* pool_;
+  /// Values the page's own count declares. The inherited `num_values_` counts
+  /// down from this as values are served and is the only record of progress, so
+  /// the next value sits at index `total_values_ - num_values_`.
+  int32_t total_values_ = 0;
+  // Whole-page scratch, used only by partial reads.
+  std::shared_ptr<ResizableBuffer> decoded_values_;
+  bool scratch_filled_ = false;
+};
+
 }  // namespace
 
 // ----------------------------------------------------------------------
@@ -2637,6 +2795,13 @@ std::unique_ptr<Decoder> MakeDecoder(Type::type type_num, Encoding::type encodin
       default:
         throw ParquetException("PFOR decoder only supports INT32 and INT64");
     }
+  } else if (encoding == Encoding::LANE_DELTA) {
+    switch (type_num) {
+      case Type::INT32:
+        return std::make_unique<LaneDeltaDecoder>(descr, pool);
+      default:
+        throw ParquetException("LANE_DELTA decoder only supports INT32");
+    }
   } else {
     ParquetException::NYI("Selected encoding is not supported");
   }
@@ -2679,6 +2844,8 @@ std::vector<Encoding::type> SupportedEncodings(Type::type physical_type) {
     case Type::BOOLEAN:
       return {Encoding::PLAIN, Encoding::RLE};
     case Type::INT32:
+      return {Encoding::PLAIN, Encoding::DELTA_BINARY_PACKED, Encoding::BYTE_STREAM_SPLIT,
+              Encoding::PFOR, Encoding::LANE_DELTA};
     case Type::INT64:
       return {Encoding::PLAIN, Encoding::DELTA_BINARY_PACKED, Encoding::BYTE_STREAM_SPLIT,
               Encoding::PFOR};
diff --git a/cpp/src/parquet/encoder.cc b/cpp/src/parquet/encoder.cc
index b5ce517b670f..d01e3be52efb 100644
--- a/cpp/src/parquet/encoder.cc
+++ b/cpp/src/parquet/encoder.cc
@@ -37,6 +37,7 @@
 #include "arrow/util/bitmap_ops.h"
 #include "arrow/util/byte_stream_split_internal.h"
 #include "arrow/util/checked_cast.h"
+#include "arrow/util/fastlanes/lane_delta_wrapper_internal.h"
 #include "arrow/util/hashing.h"
 #include "arrow/util/int_util_overflow.h"
 #include "arrow/util/logging_internal.h"
@@ -1867,6 +1868,80 @@ class PforEncoder : public EncoderImpl, virtual public TypedEncoder<DType> {
   std::vector<T> values_;
 };
 
+// ----------------------------------------------------------------------
+// Lane-parallel delta encoder
+
+// Deltas a value against the one 32 positions back rather than the one
+// immediately before it, so the decoder advances 32 independent chains with one
+// vector add per row instead of walking a single chain of dependent adds. INT32
+// only: the kernel packs 32-bit lanes.
+class LaneDeltaEncoder : public EncoderImpl, virtual public TypedEncoder<Int32Type> {
+ public:
+  using T = int32_t;
+  using TypedEncoder<Int32Type>::Put;
+
+  LaneDeltaEncoder(const ColumnDescriptor* descr, MemoryPool* pool)
+      : EncoderImpl(descr, Encoding::LANE_DELTA, pool), pool_(pool) {}
+
+  std::shared_ptr<Buffer> FlushValues() override {
+    // An all-null optional page carries no values and is still written, so it
+    // has to encode to a bare value count rather than to zero bytes.
+    const int32_t num_values = static_cast<int32_t>(values_.size());
+    const int64_t max_size =
+        ::arrow::util::fastlanes::LaneDeltaWrapper<T>::GetMaxCompressedSize(num_values);
+    PARQUET_ASSIGN_OR_THROW(auto buffer,
+                            ::arrow::AllocateResizableBuffer(max_size, pool_));
+
+    int64_t comp_size = max_size;
+    PARQUET_THROW_NOT_OK(::arrow::util::fastlanes::LaneDeltaWrapper<T>::Encode(
+        values_.data(), num_values, buffer->mutable_data(), &comp_size));
+
+    PARQUET_THROW_NOT_OK(buffer->Resize(comp_size));
+    values_.clear();
+    return buffer;
+  }
+
+  int64_t EstimatedDataEncodedSize() override {
+    return static_cast<int64_t>(values_.size() * sizeof(T));
+  }
+
+  void Put(const ::arrow::Array& values) override {
+    const auto& data = *values.data();
+    if (data.length > std::numeric_limits<int32_t>::max()) {
+      throw ParquetException("Array cannot be longer than ",
+                             std::numeric_limits<int32_t>::max());
+    }
+    if (values.null_count() == 0) {
+      Put(data.GetValues<T>(1), static_cast<int>(data.length));
+    } else {
+      PutSpaced(data.GetValues<T>(1), static_cast<int>(data.length),
+                data.GetValues<uint8_t>(0, 0), data.offset);
+    }
+  }
+
+  void Put(const T* buffer, int num_values) override {
+    values_.insert(values_.end(), buffer, buffer + num_values);
+  }
+
+  void PutSpaced(const T* src, int num_values, const uint8_t* valid_bits,
+                 int64_t valid_bits_offset) override {
+    if (valid_bits != NULLPTR) {
+      PARQUET_ASSIGN_OR_THROW(auto buffer,
+                              ::arrow::AllocateBuffer(num_values * sizeof(T), pool_));
+      T* dest = reinterpret_cast<T*>(buffer->mutable_data());
+      int num_valid = ::arrow::util::internal::SpacedCompress<T>(
+          src, num_values, valid_bits, valid_bits_offset, dest);
+      Put(dest, num_valid);
+    } else {
+      Put(src, num_values);
+    }
+  }
+
+ private:
+  MemoryPool* pool_;
+  std::vector<T> values_;
+};
+
 // ----------------------------------------------------------------------
 // Factory function
 
@@ -1992,6 +2067,13 @@ std::unique_ptr<Encoder> MakeEncoder(Type::type type_num, Encoding::type encodin
       default:
         throw ParquetException("PFOR encoder only supports INT32 and INT64");
     }
+  } else if (encoding == Encoding::LANE_DELTA) {
+    switch (type_num) {
+      case Type::INT32:
+        return std::make_unique<LaneDeltaEncoder>(descr, pool);
+      default:
+        throw ParquetException("LANE_DELTA encoder only supports INT32");
+    }
   } else {
     ParquetException::NYI("Selected encoding is not supported");
   }
diff --git a/cpp/src/parquet/encoding_test.cc b/cpp/src/parquet/encoding_test.cc
index c9315f56c378..b2ba967fbbaf 100644
--- a/cpp/src/parquet/encoding_test.cc
+++ b/cpp/src/parquet/encoding_test.cc
@@ -2272,6 +2272,246 @@ TYPED_TEST(TestPforEncoding, RejectsNegativeArguments) {
   ASSERT_THROW(decoder->Decode(&output, -1), ParquetException);
 }
 
+// ----------------------------------------------------------------------
+// Lane-parallel delta encode/decode tests.
+
+template <typename Type>
+class TestLaneDeltaEncoding : public TestEncodingBase<Type> {
+ public:
+  using c_type = typename Type::c_type;
+  static constexpr int TYPE = Type::type_num;
+
+  void CheckDecoding(int read_batch_size) {
+    auto decoder = MakeTypedDecoder<Type>(Encoding::LANE_DELTA, descr_.get());
+    decoder->SetData(num_values_, encode_buffer_->data(),
+                     static_cast<int>(encode_buffer_->size()));
+
+    std::vector<c_type> decoded(num_values_);
+    int values_decoded = 0;
+    while (values_decoded < num_values_) {
+      const int decoded_now =
+          decoder->Decode(decoded.data() + values_decoded, read_batch_size);
+      ASSERT_GT(decoded_now, 0);
+      values_decoded += decoded_now;
+    }
+    ASSERT_EQ(num_values_, values_decoded);
+    ASSERT_NO_FATAL_FAILURE(VerifyResults<c_type>(decoded.data(), draws_, num_values_));
+  }
+
+  void CheckRoundtrip() override {
+    auto encoder = MakeTypedEncoder<Type>(Encoding::LANE_DELTA,
+                                          /*use_dictionary=*/false, descr_.get());
+    encoder->Put(draws_, num_values_);
+    encode_buffer_ = encoder->FlushValues();
+
+    // A reader asks for whatever its batch size is, so the page has to come out
+    // the same whether it is drained in one call or in many.
+    for (const int read_batch_size : {1, 11, num_values_}) {
+      if (read_batch_size > 0) {
+        ASSERT_NO_FATAL_FAILURE(CheckDecoding(read_batch_size));
+      }
+    }
+  }
+
+ protected:
+  USING_BASE_MEMBERS();
+};
+
+// INT32 only: the packing kernel works on 32-bit lanes.
+using TestLaneDeltaEncodingTypes = ::testing::Types<Int32Type>;
+TYPED_TEST_SUITE(TestLaneDeltaEncoding, TestLaneDeltaEncodingTypes);
+
+TYPED_TEST(TestLaneDeltaEncoding, BasicRoundTrip) {
+  // Blocks are 1024 values and any tail is stored raw, so cover an empty page, a
+  // page shorter than one block, an exact multiple, and both sides of a boundary.
+  ASSERT_NO_FATAL_FAILURE(this->Execute(0, 0));
+  ASSERT_NO_FATAL_FAILURE(this->Execute(1, 1));
+  ASSERT_NO_FATAL_FAILURE(this->Execute(100, 1));
+  ASSERT_NO_FATAL_FAILURE(this->Execute(1023, 1));
+  ASSERT_NO_FATAL_FAILURE(this->Execute(1024, 1));
+  ASSERT_NO_FATAL_FAILURE(this->Execute(1025, 1));
+  ASSERT_NO_FATAL_FAILURE(this->Execute(1024, 4));
+  ASSERT_NO_FATAL_FAILURE(this->Execute(4099, 1));
+}
+
+TYPED_TEST(TestLaneDeltaEncoding, WideDeltas) {
+  using c_type = typename TypeParam::c_type;
+  auto encoder =
+      MakeTypedEncoder<TypeParam>(Encoding::LANE_DELTA,
+                                  /*use_dictionary=*/false, this->descr_.get());
+  auto decoder = MakeTypedDecoder<TypeParam>(Encoding::LANE_DELTA, this->descr_.get());
+
+  // Alternating extremes make an in-lane delta span 33 bits, which does not fit
+  // a 32-bit width after subtracting the minimum. Reconstruction wraps, so the
+  // block is stored at full width with no minimum and still round-trips.
+  constexpr int kNumValues = 2048;
+  std::vector<c_type> values(kNumValues);
+  for (int i = 0; i < kNumValues; ++i) {
+    values[i] = (i % 2 == 0) ? std::numeric_limits<c_type>::min()
+                             : std::numeric_limits<c_type>::max();
+  }
+
+  encoder->Put(values.data(), kNumValues);
+  auto buffer = encoder->FlushValues();
+  decoder->SetData(kNumValues, buffer->data(), static_cast<int>(buffer->size()));
+
+  std::vector<c_type> decoded(kNumValues);
+  ASSERT_EQ(kNumValues, decoder->Decode(decoded.data(), kNumValues));
+  ASSERT_EQ(values, decoded);
+}
+
+TYPED_TEST(TestLaneDeltaEncoding, DecoderReusedAcrossPages) {
+  using c_type = typename TypeParam::c_type;
+  auto encoder =
+      MakeTypedEncoder<TypeParam>(Encoding::LANE_DELTA,
+                                  /*use_dictionary=*/false, this->descr_.get());
+  auto decoder = MakeTypedDecoder<TypeParam>(Encoding::LANE_DELTA, this->descr_.get());
+
+  // A column chunk reuses one decoder for all of its data pages, with only
+  // SetData between them. The second page is the longer one, so a decoder that
+  // kept the first page's values would also read past the end of them.
+  std::vector<std::vector<c_type>> pages = {{10, 11, 12, 13}, {}};
+  pages[1].resize(1100);
+  for (int i = 0; i < 1100; ++i) {
+    pages[1][i] = 900 + i * 3;
+  }
+
+  for (const auto& page : pages) {
+    const int page_values = static_cast<int>(page.size());
+    encoder->Put(page.data(), page_values);
+    auto buffer = encoder->FlushValues();
+    decoder->SetData(page_values, buffer->data(), static_cast<int>(buffer->size()));
+
+    std::vector<c_type> decoded(page.size());
+    ASSERT_EQ(page_values, decoder->Decode(decoded.data(), page_values));
+    ASSERT_EQ(page, decoded);
+  }
+}
+
+TYPED_TEST(TestLaneDeltaEncoding, AllNullPage) {
+  constexpr int kNumValues = 40;
+  auto encoder =
+      MakeTypedEncoder<TypeParam>(Encoding::LANE_DELTA,
+                                  /*use_dictionary=*/false, this->descr_.get());
+  auto buffer = encoder->FlushValues();
+
+  // A reader hands the decoder the page's level count, which counts the nulls, so
+  // the page and its bare value count have to survive being handed the full count.
+  auto decoder = MakeTypedDecoder<TypeParam>(Encoding::LANE_DELTA, this->descr_.get());
+  decoder->SetData(kNumValues, buffer->data(), static_cast<int>(buffer->size()));
+
+  // All slots are null, so the page carries no encoded values at all.
+  std::vector<uint8_t> valid_bits(bit_util::BytesForBits(kNumValues), 0);
+  typename EncodingTraits<TypeParam>::Accumulator acc;
+  ASSERT_EQ(0, decoder->DecodeArrow(kNumValues, /*null_count=*/kNumValues,
+                                    valid_bits.data(), /*valid_bits_offset=*/0, &acc));
+
+  std::shared_ptr<::arrow::Array> result;
+  ASSERT_OK(acc.Finish(&result));
+  ASSERT_OK(result->ValidateFull());
+  ASSERT_EQ(kNumValues, result->length());
+  ASSERT_EQ(kNumValues, result->null_count());
+}
+
+TYPED_TEST(TestLaneDeltaEncoding, SpacedRoundTrip) {
+  using c_type = typename TypeParam::c_type;
+  // Nulls are dropped on the way in and re-spread on the way out, so the values
+  // the page carries are fewer than the slots the reader asks for.
+  constexpr int kNumValues = 3000;
+  auto encoder =
+      MakeTypedEncoder<TypeParam>(Encoding::LANE_DELTA,
+                                  /*use_dictionary=*/false, this->descr_.get());
+
+  std::vector<c_type> values(kNumValues);
+  std::vector<uint8_t> valid_bits(bit_util::BytesForBits(kNumValues), 0);
+  int null_count = 0;
+  for (int i = 0; i < kNumValues; ++i) {
+    values[i] = i * 7 - 100;
+    // Every fifth slot is null.
+    if (i % 5 == 4) {
+      ++null_count;
+    } else {
+      bit_util::SetBit(valid_bits.data(), i);
+    }
+  }
+
+  encoder->PutSpaced(values.data(), kNumValues, valid_bits.data(),
+                     /*valid_bits_offset=*/0);
+  auto buffer = encoder->FlushValues();
+
+  auto decoder = MakeTypedDecoder<TypeParam>(Encoding::LANE_DELTA, this->descr_.get());
+  decoder->SetData(kNumValues, buffer->data(), static_cast<int>(buffer->size()));
+
+  typename EncodingTraits<TypeParam>::Accumulator acc;
+  ASSERT_EQ(kNumValues - null_count,
+            decoder->DecodeArrow(kNumValues, null_count, valid_bits.data(),
+                                 /*valid_bits_offset=*/0, &acc));
+
+  std::shared_ptr<::arrow::Array> result;
+  ASSERT_OK(acc.Finish(&result));
+  ASSERT_OK(result->ValidateFull());
+  ASSERT_EQ(kNumValues, result->length());
+  ASSERT_EQ(null_count, result->null_count());
+  const auto& typed = checked_cast<const ::arrow::Int32Array&>(*result);
+  for (int i = 0; i < kNumValues; ++i) {
+    if (bit_util::GetBit(valid_bits.data(), i)) {
+      ASSERT_EQ(values[i], typed.Value(i)) << "at " << i;
+    }
+  }
+}
+
+TYPED_TEST(TestLaneDeltaEncoding, RejectsCorruptPages) {
+  using c_type = typename TypeParam::c_type;
+  // The fuzzer reaches every registered encoding, so a page that does not
+  // describe itself consistently has to be refused rather than read past.
+  constexpr int kNumValues = 2048;
+  std::vector<c_type> values(kNumValues);
+  // Vary the stride so the blocks carry packed words: a constant stride packs
+  // to width zero, and then a truncation test never reaches the width bytes.
+  for (int i = 0; i < kNumValues; ++i) {
+    values[i] = i * 3 + (i % 7);
+  }
+  auto encoder =
+      MakeTypedEncoder<TypeParam>(Encoding::LANE_DELTA,
+                                  /*use_dictionary=*/false, this->descr_.get());
+  encoder->Put(values.data(), kNumValues);
+  auto page = encoder->FlushValues();
+  std::vector<c_type> decoded(kNumValues);
+
+  // A page shorter than its own value count.
+  {
+    auto decoder = MakeTypedDecoder<TypeParam>(Encoding::LANE_DELTA, this->descr_.get());
+    decoder->SetData(kNumValues, page->data(),
+                     static_cast<int>(page->size()) - static_cast<int>(sizeof(c_type)));
+    EXPECT_THROW(decoder->Decode(decoded.data(), kNumValues), ParquetException);
+  }
+
+  // A page too short to hold even a value count.
+  {
+    auto decoder = MakeTypedDecoder<TypeParam>(Encoding::LANE_DELTA, this->descr_.get());
+    EXPECT_THROW(decoder->SetData(kNumValues, page->data(), 2), ParquetException);
+  }
+
+  // A page whose declared count exceeds what the level count allows.
+  {
+    auto decoder = MakeTypedDecoder<TypeParam>(Encoding::LANE_DELTA, this->descr_.get());
+    EXPECT_THROW(
+        decoder->SetData(kNumValues - 1, page->data(), static_cast<int>(page->size())),
+        ParquetException);
+  }
+
+  // A block claiming a width no 32-bit lane can hold. The width bytes sit right
+  // after the lane seeds.
+  {
+    std::vector<uint8_t> corrupt(page->data(), page->data() + page->size());
+    constexpr int kWidthsOffset = 4 + 32 * static_cast<int>(sizeof(uint32_t));
+    corrupt[kWidthsOffset] = 33;
+    auto decoder = MakeTypedDecoder<TypeParam>(Encoding::LANE_DELTA, this->descr_.get());
+    decoder->SetData(kNumValues, corrupt.data(), static_cast<int>(corrupt.size()));
+    EXPECT_THROW(decoder->Decode(decoded.data(), kNumValues), ParquetException);
+  }
+}
+
 // ----------------------------------------------------------------------
 // Rle for Boolean encode/decode tests.
 
diff --git a/cpp/src/parquet/pfor_comparison_benchmark.cc b/cpp/src/parquet/pfor_comparison_benchmark.cc
index fb7ecb9d9437..f5269cc4a917 100644
--- a/cpp/src/parquet/pfor_comparison_benchmark.cc
+++ b/cpp/src/parquet/pfor_comparison_benchmark.cc
@@ -1908,6 +1908,67 @@ static void BM_LaneDeltaDecode(benchmark::State& state, Gen32 gen) {
       static_cast<double>(uncompressed_size) / static_cast<double>(comp_size);
 }
 
+// ============================================================================
+// Lane-parallel delta through the decoder interface
+// ============================================================================
+//
+// BM_LaneDeltaDecode above measures the kernel: it is handed a payload and told
+// how many values it holds. These two arms go through the encoder and decoder
+// the library registers for the encoding, so they pay for page framing, for
+// SetData, and for reading the value count out of the page. That makes them
+// comparable with BM_DeltaBitPackEncode / BM_DeltaBitPackDecode, which is the
+// pair libparquet ships, and it is the comparison a margin should be quoted
+// over -- decoder against decoder rather than kernel against decoder.
+
+static void BM_LaneDeltaApiDecode(benchmark::State& state, Gen32 gen) {
+  const int64_t num_values = state.range(0);
+  auto values = gen(num_values);
+  const int64_t uncompressed_size = num_values * sizeof(int32_t);
+
+  auto encoder = MakeTypedEncoder<Int32Type>(Encoding::LANE_DELTA);
+  encoder->Put(values.data(), static_cast<int>(num_values));
+  auto buf = encoder->FlushValues();
+  const int64_t comp_size = buf->size();
+
+  std::vector<int32_t> decoded(num_values);
+  auto decoder = MakeTypedDecoder<Int32Type>(Encoding::LANE_DELTA);
+  decoder->SetData(static_cast<int>(num_values), buf->data(),
+                   static_cast<int>(buf->size()));
+  ARROW_CHECK_EQ(decoder->Decode(decoded.data(), static_cast<int>(num_values)),
+                 static_cast<int>(num_values));
+  ARROW_CHECK(decoded == values) << "lane delta decoder round trip failed";
+
+  for (auto _ : state) {
+    decoder->SetData(static_cast<int>(num_values), buf->data(),
+                     static_cast<int>(buf->size()));
+    decoder->Decode(decoded.data(), static_cast<int>(num_values));
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(state.iterations() * uncompressed_size);
+  state.SetItemsProcessed(state.iterations() * num_values);
+  state.counters["compression_ratio"] =
+      static_cast<double>(uncompressed_size) / static_cast<double>(comp_size);
+}
+
+static void BM_LaneDeltaApiEncode(benchmark::State& state, Gen32 gen) {
+  const int64_t num_values = state.range(0);
+  auto values = gen(num_values);
+  const int64_t uncompressed_size = num_values * sizeof(int32_t);
+
+  int64_t comp_size = 0;
+  auto encoder = MakeTypedEncoder<Int32Type>(Encoding::LANE_DELTA);
+  for (auto _ : state) {
+    encoder->Put(values.data(), static_cast<int>(num_values));
+    auto buf = encoder->FlushValues();
+    comp_size = buf->size();
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(state.iterations() * uncompressed_size);
+  state.SetItemsProcessed(state.iterations() * num_values);
+  state.counters["compression_ratio"] =
+      static_cast<double>(uncompressed_size) / static_cast<double>(comp_size);
+}
+
 // The values a decoder that stops in transposed order should produce.
 static std::vector<int32_t> TransposeReference(const std::vector<int32_t>& in) {
   namespace fl = ::arrow::util::fastlanes;
@@ -2036,6 +2097,8 @@ static void CustomArgs(benchmark::internal::Benchmark* b) { b->Arg(102400); }
   BENCHMARK_CAPTURE(BM_DbpGeom1024x8, Name, &GenFunc)->Apply(CustomArgs);          \
   BENCHMARK_CAPTURE(BM_DbpGeom1024x1, Name, &GenFunc)->Apply(CustomArgs);          \
   BENCHMARK_CAPTURE(BM_LaneDeltaDecode, Name, &GenFunc)->Apply(CustomArgs);        \
+  BENCHMARK_CAPTURE(BM_LaneDeltaApiDecode, Name, &GenFunc)->Apply(CustomArgs);     \
+  BENCHMARK_CAPTURE(BM_LaneDeltaApiEncode, Name, &GenFunc)->Apply(CustomArgs);     \
   BENCHMARK_CAPTURE(BM_TposeRawDecode, Name, &GenFunc)->Apply(CustomArgs);         \
   BENCHMARK_CAPTURE(BM_TposePackedDecode, Name, &GenFunc)->Apply(CustomArgs);      \
   BENCHMARK_CAPTURE(BM_TposeFusedDecode, Name, &GenFunc)->Apply(CustomArgs);       \
diff --git a/cpp/src/parquet/types.cc b/cpp/src/parquet/types.cc
index 1567d2b559e2..99cd5d3e35e9 100644
--- a/cpp/src/parquet/types.cc
+++ b/cpp/src/parquet/types.cc
@@ -272,6 +272,8 @@ std::string EncodingToString(Encoding::type t) {
       return "BYTE_STREAM_SPLIT";
     case Encoding::PFOR:
       return "PFOR";
+    case Encoding::LANE_DELTA:
+      return "LANE_DELTA";
     default:
       return "UNKNOWN";
   }
diff --git a/cpp/src/parquet/types.h b/cpp/src/parquet/types.h
index acfedb45d795..bba5931eb3ac 100644
--- a/cpp/src/parquet/types.h
+++ b/cpp/src/parquet/types.h
@@ -540,8 +540,9 @@ struct Encoding {
     RLE_DICTIONARY = 8,
     BYTE_STREAM_SPLIT = 9,
     PFOR = 11,
+    LANE_DELTA = 12,
     // Should always be last element (except UNKNOWN)
-    UNDEFINED = 12,
+    UNDEFINED = 13,
     UNKNOWN = 999
   };
 };

From c7f3dd01ab3ea3a32f25f5167c38e0fd782c7186 Mon Sep 17 00:00:00 2001
From: Prateek Gaur <prateek.gaur@snowflake.com>
Date: Wed, 9 Sep 2026 00:49:22 +0000
Subject: [PATCH 18/27] Frame FastLanes delta pages

Gives both lane-delta and transposed-delta payloads a page frame: a
little-endian value count, followed by sections that are each checked
against the page before decoding. A payload that does not start 4-byte
aligned is copied to an aligned buffer first. The tests only run with
the PFOR Preview option on, like the rest of the encoding.
---
 .../transposed_delta_wrapper_internal.h       | 250 ++++++++++++++++++
 cpp/src/parquet/arrow/arrow_encoding_test.cc  |  10 +-
 cpp/src/parquet/decoder.cc                    |   7 +-
 cpp/src/parquet/encoder.cc                    |  20 +-
 cpp/src/parquet/encoding_test.cc              |  72 ++++-
 cpp/src/parquet/pfor_comparison_benchmark.cc  |  24 +-
 6 files changed, 354 insertions(+), 29 deletions(-)
 create mode 100644 cpp/src/arrow/util/fastlanes/transposed_delta_wrapper_internal.h

diff --git a/cpp/src/arrow/util/fastlanes/transposed_delta_wrapper_internal.h b/cpp/src/arrow/util/fastlanes/transposed_delta_wrapper_internal.h
new file mode 100644
index 000000000000..a1d3bc59d0bf
--- /dev/null
+++ b/cpp/src/arrow/util/fastlanes/transposed_delta_wrapper_internal.h
@@ -0,0 +1,250 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+// ---------------------------------------------------------------------------
+// Page-level framing for the FastLanes paper's lane assignment, so that layout
+// can be read through a Parquet decoder rather than called as a kernel. A kernel
+// measurement skips the page header, the decoder's own dispatch and the level
+// handling, so dividing one by a full decoder's rate overstates what a reader
+// would gain.
+//
+// This is the framing counterpart of the one in lane_delta_wrapper_internal.h,
+// which frames the +32 stride instead. The two differ only in which value a
+// lane's stored difference is taken against; the framing added here is the same:
+//
+//   [0, 4)      uint32 value count, little endian
+//   [4, ...)    the payload described in transposed_delta.h
+//
+// The count has to live here because the payload's own header does not carry
+// one, while decode needs it to locate every section. A page's level count
+// cannot stand in for it, since that count includes nulls.
+//
+// Two properties of the payload are the kernel's and are not fixed here. Its
+// packed words and its per-block minimums are stored in host byte order, which
+// a format specification would have to pin down before this could be written to
+// a file anyone else reads. And it is int32 only, so this wrapper is too.
+// ---------------------------------------------------------------------------
+
+#pragma once
+
+#include <cstdint>
+#include <cstring>
+#include <limits>
+
+#include "arrow/buffer.h"
+#include "arrow/result.h"
+#include "arrow/status.h"
+#include "arrow/util/bit_util.h"
+#include "arrow/util/fastlanes/transposed_delta.h"
+
+namespace arrow {
+namespace util {
+namespace fastlanes {
+
+/// \brief Page-level encode and decode for the paper's lane assignment
+///
+/// Only int32 is implemented, because the kernel is int32 only.
+template <typename T>
+class TransposedDeltaWrapper;
+
+template <>
+class TransposedDeltaWrapper<int32_t> {
+ public:
+  /// Bytes the value count occupies ahead of the payload.
+  static constexpr int64_t kCountSize = sizeof(uint32_t);
+
+  /// The bases are delta-coded against each other, which costs about 0.2 bits
+  /// per value against 1 bit for storing them plainly.
+  static constexpr TransposedBaseCoding kBases = TransposedBaseCoding::kPacked;
+
+  /// A conforming decoder has to return file order, and doing that in the same
+  /// pass as the prefix sums is free.
+  static constexpr TransposedRepair kRepair = TransposedRepair::kFused;
+
+  /// \brief Upper bound on the bytes Encode writes for `num_values` values
+  static int64_t GetMaxCompressedSize(int32_t num_values) {
+    if (num_values <= 0) return kCountSize;
+    return kCountSize + static_cast<int64_t>(
+                            TransposedMaxEncodedSize(static_cast<size_t>(num_values)));
+  }
+
+  /// \brief Encode values into one page
+  ///
+  /// \param[in] values the values to encode
+  /// \param[in] num_values how many; zero writes a bare count, which is what an
+  ///            all-null page encodes to
+  /// \param[out] comp output buffer, at least GetMaxCompressedSize bytes
+  /// \param[in,out] comp_size in: bytes available; out: bytes written
+  static Status Encode(const int32_t* values, int32_t num_values, uint8_t* comp,
+                       int64_t* comp_size) {
+    if (num_values < 0) {
+      return Status::Invalid("Transposed delta encode: negative value count ",
+                             num_values);
+    }
+    if (comp == nullptr || comp_size == nullptr) {
+      return Status::Invalid("Transposed delta encode: null output");
+    }
+    const int64_t needed = GetMaxCompressedSize(num_values);
+    if (*comp_size < needed) {
+      return Status::Invalid("Transposed delta encode: buffer holds ", *comp_size,
+                             " bytes, needs ", needed);
+    }
+    StoreCount(comp, static_cast<uint32_t>(num_values));
+    if (num_values == 0) {
+      *comp_size = kCountSize;
+      return Status::OK();
+    }
+    if (values == nullptr) {
+      return Status::Invalid("Transposed delta encode: null input for ", num_values,
+                             " values");
+    }
+    const size_t written = TransposedDeltaEncode<kBases>(
+        values, static_cast<size_t>(num_values), comp + kCountSize);
+    if (written == 0) {
+      return Status::Invalid("Transposed delta encode: no block width fits ", num_values,
+                             " values");
+    }
+    *comp_size = kCountSize + static_cast<int64_t>(written);
+    return Status::OK();
+  }
+
+  /// \brief Read how many values a page holds, without decoding it
+  static Result<int32_t> DecodeElementCount(const uint8_t* comp, int64_t comp_size) {
+    if (comp == nullptr || comp_size < kCountSize) {
+      return Status::Invalid("Transposed delta page is ", comp_size,
+                             " bytes, too short to hold a value count");
+    }
+    const uint32_t count = LoadCount(comp);
+    if (count > static_cast<uint32_t>(std::numeric_limits<int32_t>::max())) {
+      return Status::Invalid("Transposed delta page declares ", count, " values");
+    }
+    return static_cast<int32_t>(count);
+  }
+
+  /// \brief Decode a whole page
+  ///
+  /// \param[in] comp the page
+  /// \param[in] comp_size its size
+  /// \param[in] num_values values to decode, which must equal the page's own count
+  /// \param[out] values output, sized for num_values
+  ///
+  /// The kernel reads the payload as 4-byte words, so a payload that does not
+  /// start 4-byte aligned is copied to an aligned buffer first. Page buffers are
+  /// normally aligned and the copy does not happen.
+  static Status Decode(const uint8_t* comp, int64_t comp_size, int32_t num_values,
+                       int32_t* values) {
+    ARROW_ASSIGN_OR_RAISE(const int32_t declared, DecodeElementCount(comp, comp_size));
+    if (declared != num_values) {
+      return Status::Invalid("Transposed delta page declares ", declared,
+                             " values but the caller asked for ", num_values);
+    }
+    if (num_values == 0) return Status::OK();
+    if (values == nullptr) {
+      return Status::Invalid("Transposed delta decode: null output");
+    }
+
+    const uint8_t* payload = comp + kCountSize;
+    const int64_t payload_size = comp_size - kCountSize;
+    ARROW_ASSIGN_OR_RAISE(
+        const int64_t expected,
+        PayloadSize(payload, payload_size, static_cast<size_t>(num_values)));
+    if (payload_size < expected) {
+      return Status::Invalid("Transposed delta page holds ", payload_size,
+                             " payload bytes, needs ", expected);
+    }
+
+    if (reinterpret_cast<uintptr_t>(payload) % sizeof(uint32_t) == 0) {
+      TransposedDeltaDecode<kBases, kRepair>(payload, static_cast<size_t>(num_values),
+                                             values);
+      return Status::OK();
+    }
+    ARROW_ASSIGN_OR_RAISE(auto aligned, AllocateBuffer(expected));
+    std::memcpy(aligned->mutable_data(), payload, static_cast<size_t>(expected));
+    TransposedDeltaDecode<kBases, kRepair>(aligned->data(),
+                                           static_cast<size_t>(num_values), values);
+    return Status::OK();
+  }
+
+ private:
+  static void StoreCount(uint8_t* comp, uint32_t count) {
+    const uint32_t le = ::arrow::bit_util::ToLittleEndian(count);
+    std::memcpy(comp, &le, sizeof(le));
+  }
+
+  static uint32_t LoadCount(const uint8_t* comp) {
+    uint32_t le = 0;
+    std::memcpy(&le, comp, sizeof(le));
+    return ::arrow::bit_util::FromLittleEndian(le);
+  }
+
+  /// Bytes the payload occupies for `n` values.
+  ///
+  /// Unlike the +32 stride's payload, whose per-block sizes are all listed in a
+  /// header, this one carries the width of each block's base stream inside that
+  /// block. Walking a block therefore means reading it, so the walk checks the
+  /// bytes it is about to read are present before reading them, rather than
+  /// summing a header and comparing once.
+  static Result<int64_t> PayloadSize(const uint8_t* payload, int64_t payload_size,
+                                     size_t n) {
+    const int64_t header = static_cast<int64_t>(TransposedFixedHeader(n));
+    if (payload_size < header) {
+      return Status::Invalid("Transposed delta payload is ", payload_size,
+                             " bytes, too short for a ", header, " byte header");
+    }
+    const size_t nblocks = n / kBlockSize;
+    int64_t off = header;
+    for (size_t b = 0; b < nblocks; ++b) {
+      const uint8_t w = payload[b];
+      if (w > 32) {
+        return Status::Invalid("Transposed delta block ", b, " declares payload width ",
+                               static_cast<int>(w));
+      }
+      if constexpr (kBases == TransposedBaseCoding::kRaw) {
+        off += static_cast<int64_t>(kLanes * sizeof(uint32_t));
+      } else {
+        // A base width and a base minimum, then the packed base deltas.
+        if (off + 1 + static_cast<int64_t>(sizeof(int32_t)) > payload_size) {
+          return Status::Invalid("Transposed delta payload is ", payload_size,
+                                 " bytes, too short for block ", b, "'s bases");
+        }
+        const uint8_t base_width = payload[off];
+        if (base_width > 32) {
+          return Status::Invalid("Transposed delta block ", b, " declares base width ",
+                                 static_cast<int>(base_width));
+        }
+        off += static_cast<int64_t>(TransposedBaseBytes<kBases>(base_width));
+      }
+      if (off > payload_size) {
+        return Status::Invalid("Transposed delta payload is ", payload_size,
+                               " bytes, too short for block ", b, "'s bases");
+      }
+      if (w > 0) {
+        // The packed words are 4-byte aligned, which the base stream does not
+        // leave them, so the encoder pads to the next boundary.
+        off += (4 - (off & 3)) & 3;
+        off += static_cast<int64_t>(w) * static_cast<int64_t>(kLanes) *
+               static_cast<int64_t>(sizeof(uint32_t));
+      }
+    }
+    const int64_t tail = static_cast<int64_t>(n % kBlockSize);
+    return off + tail * static_cast<int64_t>(sizeof(int32_t));
+  }
+};
+
+}  // namespace fastlanes
+}  // namespace util
+}  // namespace arrow
diff --git a/cpp/src/parquet/arrow/arrow_encoding_test.cc b/cpp/src/parquet/arrow/arrow_encoding_test.cc
index ee792047e900..0cec38245cfe 100644
--- a/cpp/src/parquet/arrow/arrow_encoding_test.cc
+++ b/cpp/src/parquet/arrow/arrow_encoding_test.cc
@@ -222,7 +222,7 @@ TEST_F(ParquetPforEncodingTest, InterleavedBitPackingLayout) {
 
   auto build = [](bool interleaved) {
     auto builder = WriterProperties::Builder();
-    builder.disable_dictionary()->encoding(Encoding::PFOR);
+    builder.disable_dictionary()->enable_pfor_encoding()->encoding(Encoding::PFOR);
     if (interleaved) {
       builder.enable_pfor_interleaved_bit_packing();
     }
@@ -255,11 +255,15 @@ TEST_F(ParquetPforEncodingTest, InterleavedRequestIgnoredForInt64) {
 
   auto with_flag = WriterProperties::Builder()
                        .disable_dictionary()
+                       ->enable_pfor_encoding()
                        ->encoding(Encoding::PFOR)
                        ->enable_pfor_interleaved_bit_packing()
                        ->build();
-  auto without_flag =
-      WriterProperties::Builder().disable_dictionary()->encoding(Encoding::PFOR)->build();
+  auto without_flag = WriterProperties::Builder()
+                          .disable_dictionary()
+                          ->enable_pfor_encoding()
+                          ->encoding(Encoding::PFOR)
+                          ->build();
 
   std::shared_ptr<Table> flagged_result, plain_result;
   std::shared_ptr<Buffer> flagged_file, plain_file;
diff --git a/cpp/src/parquet/decoder.cc b/cpp/src/parquet/decoder.cc
index e136e70798e8..ef5961a378f8 100644
--- a/cpp/src/parquet/decoder.cc
+++ b/cpp/src/parquet/decoder.cc
@@ -44,7 +44,7 @@
 #include "arrow/util/bitmap_ops.h"
 #include "arrow/util/byte_stream_split_internal.h"
 #include "arrow/util/checked_cast.h"
-#include "arrow/util/fastlanes/lane_delta_wrapper_internal.h"
+#include "arrow/util/fastlanes/transposed_delta_wrapper_internal.h"
 #include "arrow/util/int_util_overflow.h"
 #include "arrow/util/logging_internal.h"
 #include "arrow/util/pfor/pfor_wrapper_internal.h"
@@ -2558,7 +2558,8 @@ class PforDecoder : public TypedDecoderImpl<DType> {
 
 // The mirror of the lane-parallel delta encoder. Its reconstruction advances 32
 // independent chains with one vector add per row, in place of the single chain
-// of dependent adds that DELTA_BINARY_PACKED walks. INT32 only.
+// of dependent adds that DELTA_BINARY_PACKED walks, and returns file order in
+// the same pass. INT32 only.
 //
 // Partial reads take the same route as PFOR's: the kernel keeps no resumption
 // state, so a caller reading a page in batches decodes the whole page into
@@ -2567,7 +2568,7 @@ class LaneDeltaDecoder : public TypedDecoderImpl<Int32Type> {
  public:
   using Base = TypedDecoderImpl<Int32Type>;
   using T = int32_t;
-  using Wrapper = ::arrow::util::fastlanes::LaneDeltaWrapper<T>;
+  using Wrapper = ::arrow::util::fastlanes::TransposedDeltaWrapper<T>;
 
   explicit LaneDeltaDecoder(const ColumnDescriptor* descr,
                             MemoryPool* pool = ::arrow::default_memory_pool())
diff --git a/cpp/src/parquet/encoder.cc b/cpp/src/parquet/encoder.cc
index d01e3be52efb..40555196c519 100644
--- a/cpp/src/parquet/encoder.cc
+++ b/cpp/src/parquet/encoder.cc
@@ -37,7 +37,7 @@
 #include "arrow/util/bitmap_ops.h"
 #include "arrow/util/byte_stream_split_internal.h"
 #include "arrow/util/checked_cast.h"
-#include "arrow/util/fastlanes/lane_delta_wrapper_internal.h"
+#include "arrow/util/fastlanes/transposed_delta_wrapper_internal.h"
 #include "arrow/util/hashing.h"
 #include "arrow/util/int_util_overflow.h"
 #include "arrow/util/logging_internal.h"
@@ -1871,13 +1871,16 @@ class PforEncoder : public EncoderImpl, virtual public TypedEncoder<DType> {
 // ----------------------------------------------------------------------
 // Lane-parallel delta encoder
 
-// Deltas a value against the one 32 positions back rather than the one
-// immediately before it, so the decoder advances 32 independent chains with one
-// vector add per row instead of walking a single chain of dependent adds. INT32
-// only: the kernel packs 32-bit lanes.
+// Splits a page into 32 independent difference chains, one per lane, so the
+// decoder advances all 32 with one vector add per row instead of walking the
+// single chain of dependent adds DELTA_BINARY_PACKED stores. A lane holds a
+// contiguous run of 32 values, so the differences stored are the ones the format
+// already stores, and the 32 entry points that arrangement needs are themselves
+// delta-coded. INT32 only: the kernel packs 32-bit lanes.
 class LaneDeltaEncoder : public EncoderImpl, virtual public TypedEncoder<Int32Type> {
  public:
   using T = int32_t;
+  using Wrapper = ::arrow::util::fastlanes::TransposedDeltaWrapper<T>;
   using TypedEncoder<Int32Type>::Put;
 
   LaneDeltaEncoder(const ColumnDescriptor* descr, MemoryPool* pool)
@@ -1887,14 +1890,13 @@ class LaneDeltaEncoder : public EncoderImpl, virtual public TypedEncoder<Int32Ty
     // An all-null optional page carries no values and is still written, so it
     // has to encode to a bare value count rather than to zero bytes.
     const int32_t num_values = static_cast<int32_t>(values_.size());
-    const int64_t max_size =
-        ::arrow::util::fastlanes::LaneDeltaWrapper<T>::GetMaxCompressedSize(num_values);
+    const int64_t max_size = Wrapper::GetMaxCompressedSize(num_values);
     PARQUET_ASSIGN_OR_THROW(auto buffer,
                             ::arrow::AllocateResizableBuffer(max_size, pool_));
 
     int64_t comp_size = max_size;
-    PARQUET_THROW_NOT_OK(::arrow::util::fastlanes::LaneDeltaWrapper<T>::Encode(
-        values_.data(), num_values, buffer->mutable_data(), &comp_size));
+    PARQUET_THROW_NOT_OK(
+        Wrapper::Encode(values_.data(), num_values, buffer->mutable_data(), &comp_size));
 
     PARQUET_THROW_NOT_OK(buffer->Resize(comp_size));
     values_.clear();
diff --git a/cpp/src/parquet/encoding_test.cc b/cpp/src/parquet/encoding_test.cc
index b2ba967fbbaf..7c561c7b4fd3 100644
--- a/cpp/src/parquet/encoding_test.cc
+++ b/cpp/src/parquet/encoding_test.cc
@@ -2360,6 +2360,59 @@ TYPED_TEST(TestLaneDeltaEncoding, WideDeltas) {
   ASSERT_EQ(values, decoded);
 }
 
+TYPED_TEST(TestLaneDeltaEncoding, PageEndsOnEntryPoints) {
+  using c_type = typename TypeParam::c_type;
+  // A block whose values all advance by the same amount packs to width zero and
+  // so contributes nothing after its entry points. When such a block ends a page
+  // whose length is an exact multiple of the block size, those entry points are
+  // the last bytes of the page, and a decoder that reads them a machine word at
+  // a time reads past the page unless it stops short. Two strides are needed to
+  // get there: the entry points only need a width of their own if the step into
+  // a block differs from the steps inside it.
+  for (const int num_values : {2048, 3072}) {
+    std::vector<c_type> values(num_values);
+    for (int i = 0; i < num_values; ++i) {
+      values[i] = i < 1024 ? static_cast<c_type>(i * 5)
+                           : static_cast<c_type>(1023 * 5 + (i - 1023) * 3);
+    }
+    auto encoder =
+        MakeTypedEncoder<TypeParam>(Encoding::LANE_DELTA,
+                                    /*use_dictionary=*/false, this->descr_.get());
+    encoder->Put(values.data(), num_values);
+    auto buffer = encoder->FlushValues();
+
+    auto decoder = MakeTypedDecoder<TypeParam>(Encoding::LANE_DELTA, this->descr_.get());
+    decoder->SetData(num_values, buffer->data(), static_cast<int>(buffer->size()));
+    std::vector<c_type> decoded(num_values);
+    ASSERT_EQ(num_values, decoder->Decode(decoded.data(), num_values));
+    ASSERT_EQ(values, decoded);
+  }
+}
+
+TYPED_TEST(TestLaneDeltaEncoding, EntryPointsFarApart) {
+  using c_type = typename TypeParam::c_type;
+  // The 32 entry points a block needs are delta-coded against each other and
+  // against the previous block's last one. Values that jump by half the type's
+  // range make those differences as wide as they can be, over several blocks.
+  constexpr int kNumValues = 4096;
+  std::vector<c_type> values(kNumValues);
+  const c_type step = std::numeric_limits<c_type>::max() / 2;
+  for (int i = 0; i < kNumValues; ++i) {
+    values[i] = static_cast<c_type>((i % 2 == 0) ? 0 : step);
+  }
+  auto encoder =
+      MakeTypedEncoder<TypeParam>(Encoding::LANE_DELTA,
+                                  /*use_dictionary=*/false, this->descr_.get());
+  encoder->Put(values.data(), kNumValues);
+  auto buffer = encoder->FlushValues();
+
+  auto decoder = MakeTypedDecoder<TypeParam>(Encoding::LANE_DELTA, this->descr_.get());
+  decoder->SetData(kNumValues, buffer->data(), static_cast<int>(buffer->size()));
+  std::vector<c_type> decoded(kNumValues);
+  ASSERT_EQ(kNumValues, decoder->Decode(decoded.data(), kNumValues));
+  ASSERT_EQ(values, decoded);
+}
+
 TYPED_TEST(TestLaneDeltaEncoding, DecoderReusedAcrossPages) {
   using c_type = typename TypeParam::c_type;
   auto encoder =
@@ -2500,16 +2553,29 @@ TYPED_TEST(TestLaneDeltaEncoding, RejectsCorruptPages) {
         ParquetException);
   }
 
-  // A block claiming a width no 32-bit lane can hold. The width bytes sit right
-  // after the lane seeds.
+  // A block claiming a payload width no 32-bit lane can hold. One width byte per
+  // block opens the payload, so block zero's follows the value count.
   {
     std::vector<uint8_t> corrupt(page->data(), page->data() + page->size());
-    constexpr int kWidthsOffset = 4 + 32 * static_cast<int>(sizeof(uint32_t));
+    constexpr int kWidthsOffset = 4;
     corrupt[kWidthsOffset] = 33;
     auto decoder = MakeTypedDecoder<TypeParam>(Encoding::LANE_DELTA, this->descr_.get());
     decoder->SetData(kNumValues, corrupt.data(), static_cast<int>(corrupt.size()));
     EXPECT_THROW(decoder->Decode(decoded.data(), kNumValues), ParquetException);
   }
+
+  // A block claiming an entry-point width no 32-bit lane can hold. That width
+  // lives inside the block rather than in the header, so reaching it means
+  // walking past the two blocks' widths, rounded up to a 4-byte boundary, and
+  // their two minimums.
+  {
+    std::vector<uint8_t> corrupt(page->data(), page->data() + page->size());
+    constexpr int kBasesOffset = 4 + 4 + 2 * static_cast<int>(sizeof(int32_t));
+    corrupt[kBasesOffset] = 33;
+    auto decoder = MakeTypedDecoder<TypeParam>(Encoding::LANE_DELTA, this->descr_.get());
+    decoder->SetData(kNumValues, corrupt.data(), static_cast<int>(corrupt.size()));
+    EXPECT_THROW(decoder->Decode(decoded.data(), kNumValues), ParquetException);
+  }
 }
 
 // ----------------------------------------------------------------------
diff --git a/cpp/src/parquet/pfor_comparison_benchmark.cc b/cpp/src/parquet/pfor_comparison_benchmark.cc
index f5269cc4a917..1bca166f0b2b 100644
--- a/cpp/src/parquet/pfor_comparison_benchmark.cc
+++ b/cpp/src/parquet/pfor_comparison_benchmark.cc
@@ -1912,15 +1912,17 @@ static void BM_LaneDeltaDecode(benchmark::State& state, Gen32 gen) {
 // Lane-parallel delta through the decoder interface
 // ============================================================================
 //
-// BM_LaneDeltaDecode above measures the kernel: it is handed a payload and told
+// BM_TposeFusedDecode below measures the kernel: it is handed a payload and told
 // how many values it holds. These two arms go through the encoder and decoder
-// the library registers for the encoding, so they pay for page framing, for
-// SetData, and for reading the value count out of the page. That makes them
-// comparable with BM_DeltaBitPackEncode / BM_DeltaBitPackDecode, which is the
-// pair libparquet ships, and it is the comparison a margin should be quoted
-// over -- decoder against decoder rather than kernel against decoder.
-
-static void BM_LaneDeltaApiDecode(benchmark::State& state, Gen32 gen) {
+// the library registers for the encoding, which is the same layout, base coding
+// and repair that arm uses, so they pay for page framing, for SetData, and for
+// reading the value count out of the page. That makes them comparable with
+// BM_DeltaBitPackEncode / BM_DeltaBitPackDecode, which is the pair libparquet
+// ships, and it is the comparison a margin should be quoted over -- decoder
+// against decoder rather than kernel against decoder. Dividing one by the other
+// prices the framing.
+
+static void BM_TposeApiDecode(benchmark::State& state, Gen32 gen) {
   const int64_t num_values = state.range(0);
   auto values = gen(num_values);
   const int64_t uncompressed_size = num_values * sizeof(int32_t);
@@ -1950,7 +1952,7 @@ static void BM_LaneDeltaApiDecode(benchmark::State& state, Gen32 gen) {
       static_cast<double>(uncompressed_size) / static_cast<double>(comp_size);
 }
 
-static void BM_LaneDeltaApiEncode(benchmark::State& state, Gen32 gen) {
+static void BM_TposeApiEncode(benchmark::State& state, Gen32 gen) {
   const int64_t num_values = state.range(0);
   auto values = gen(num_values);
   const int64_t uncompressed_size = num_values * sizeof(int32_t);
@@ -2097,8 +2099,8 @@ static void CustomArgs(benchmark::internal::Benchmark* b) { b->Arg(102400); }
   BENCHMARK_CAPTURE(BM_DbpGeom1024x8, Name, &GenFunc)->Apply(CustomArgs);          \
   BENCHMARK_CAPTURE(BM_DbpGeom1024x1, Name, &GenFunc)->Apply(CustomArgs);          \
   BENCHMARK_CAPTURE(BM_LaneDeltaDecode, Name, &GenFunc)->Apply(CustomArgs);        \
-  BENCHMARK_CAPTURE(BM_LaneDeltaApiDecode, Name, &GenFunc)->Apply(CustomArgs);     \
-  BENCHMARK_CAPTURE(BM_LaneDeltaApiEncode, Name, &GenFunc)->Apply(CustomArgs);     \
+  BENCHMARK_CAPTURE(BM_TposeApiDecode, Name, &GenFunc)->Apply(CustomArgs);         \
+  BENCHMARK_CAPTURE(BM_TposeApiEncode, Name, &GenFunc)->Apply(CustomArgs);         \
   BENCHMARK_CAPTURE(BM_TposeRawDecode, Name, &GenFunc)->Apply(CustomArgs);         \
   BENCHMARK_CAPTURE(BM_TposePackedDecode, Name, &GenFunc)->Apply(CustomArgs);      \
   BENCHMARK_CAPTURE(BM_TposeFusedDecode, Name, &GenFunc)->Apply(CustomArgs);       \

From 954f10afe1f66e80c5e759f152bfe5c96eba88f3 Mon Sep 17 00:00:00 2001
From: Prateek Gaur <prateek.gaur@snowflake.com>
Date: Sat, 12 Sep 2026 01:03:15 +0000
Subject: [PATCH 19/27] Benchmark interleaved PFOR on the corpus

Encodes each corpus column once per layout with delta selection held
fixed, so the sequential and interleaved rows decode the same values at
the same encoded size.
---
 .../arrow/util/fastlanes/interleaved_pfor.h   | 226 ++++++++++++++++++
 cpp/src/parquet/pfor_comparison_benchmark.cc  | 159 ++++++++----
 2 files changed, 343 insertions(+), 42 deletions(-)
 create mode 100644 cpp/src/arrow/util/fastlanes/interleaved_pfor.h

diff --git a/cpp/src/arrow/util/fastlanes/interleaved_pfor.h b/cpp/src/arrow/util/fastlanes/interleaved_pfor.h
new file mode 100644
index 000000000000..ccc36bf831b2
--- /dev/null
+++ b/cpp/src/arrow/util/fastlanes/interleaved_pfor.h
@@ -0,0 +1,226 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+// ---------------------------------------------------------------------------
+// Plain (non-delta) PFOR through the FastLanes container, in two orders:
+//
+//   kFileOrder  per-block frame-of-reference subtract, then bit-pack with the
+//               interleaved container in input order. This is Building Block
+//               1 alone -- lane_delta.h and transposed_delta.h are Building
+//               Block 1 applied to a delta chain; this file applies it to
+//               plain PFOR, which has no chain to break. Decode returns
+//               values in file order with no permutation, matching the note
+//               in fastlanes_kernels_internal.h.
+//
+//   kFlOrder    the same, but the residuals are placed with the paper's lane
+//               assignment (reused from transposed_delta.h's Transpose32x32:
+//               lane l holds the contiguous run [32l, 32l+32)) before
+//               packing, and gathered back to file order after unpacking.
+//               PFOR has no chain for this ordering to help, so this arm
+//               exists to price the gather it forces rather than to recommend
+//               it -- see fastlanes_kernels_internal.h's header comment.
+//
+// Both orders are otherwise identical: same per-block FOR, same bit width
+// choice, same container. Comparing their decode cost against BM_PforDecode
+// (Arrow's shipped sequential decoder) on the same real dataset columns is
+// what isolates the layout question from the value-ordering question.
+//
+// Wire layout for n values (n a multiple of 1024; any tail is stored raw):
+//
+//   [0, nblocks)                 uint8 bit width per block
+//   padded to a 4-byte boundary
+//   next 4 * nblocks bytes       int32 min (frame of reference) per block
+//   remainder                    per block, bit_width * 32 uint32 packed words
+// ---------------------------------------------------------------------------
+
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <limits>
+
+#include "arrow/util/fastlanes/fastlanes_kernels_internal.h"
+#include "arrow/util/fastlanes/transposed_delta.h"
+
+namespace arrow {
+namespace util {
+namespace fastlanes {
+
+enum class InterleavedPforOrder { kFileOrder, kFlOrder };
+
+inline uint32_t InterleavedPforBitsFor(uint64_t v) {
+  uint32_t bits = 0;
+  while (v != 0) {
+    ++bits;
+    v >>= 1;
+  }
+  return bits;
+}
+
+inline size_t InterleavedPforHeaderSize(size_t n) {
+  const size_t nblocks = n / kBlockSize;
+  const size_t widths = (nblocks + 3) & ~size_t(3);
+  return widths + nblocks * sizeof(int32_t);
+}
+
+inline size_t InterleavedPforMaxEncodedSize(size_t n) {
+  return InterleavedPforHeaderSize(n) + n * sizeof(uint32_t) +
+         (n % kBlockSize) * sizeof(int32_t);
+}
+
+#define ILP_PACK_CASE(W)     \
+  case W:                    \
+    PackBlock<W>(grid, dst); \
+    break;
+
+#define ILP_UNPACK_CASE(W)                 \
+  case W:                                  \
+    UnpackBlock<W, true>(src, grid, bias); \
+    break;
+
+// clang-format off
+#define ILP_WIDTH_CASES(M)                        \
+  M(1) M(2) M(3) M(4) M(5) M(6) M(7) M(8)         \
+  M(9) M(10) M(11) M(12) M(13) M(14) M(15) M(16)  \
+  M(17) M(18) M(19) M(20) M(21) M(22) M(23) M(24) \
+  M(25) M(26) M(27) M(28) M(29) M(30) M(31) M(32)
+// clang-format on
+
+// Returns bytes written, or 0 if some block's span exceeds 32 bits (it never
+// does for plain int32 values: max - min fits in 32 bits unconditionally).
+template <InterleavedPforOrder kOrder>
+inline size_t InterleavedPforEncode(const int32_t* in, size_t n, uint8_t* out) {
+  const size_t nblocks = n / kBlockSize;
+
+  uint8_t* widths = out;
+  int32_t* mins = reinterpret_cast<int32_t*>(out + ((nblocks + 3) & ~size_t(3)));
+  uint32_t* dst = reinterpret_cast<uint32_t*>(out + InterleavedPforHeaderSize(n));
+
+  uint32_t grid[kBlockSize];
+
+  for (size_t b = 0; b < nblocks; ++b) {
+    const int32_t* blk = in + b * kBlockSize;
+
+    int64_t vmin = std::numeric_limits<int64_t>::max();
+    int64_t vmax = std::numeric_limits<int64_t>::min();
+    for (size_t t = 0; t < kBlockSize; ++t) {
+      const int64_t v = static_cast<int64_t>(blk[t]);
+      if (v < vmin) vmin = v;
+      if (v > vmax) vmax = v;
+    }
+    const uint32_t w = InterleavedPforBitsFor(static_cast<uint64_t>(vmax - vmin));
+    widths[b] = static_cast<uint8_t>(w);
+    mins[b] = static_cast<int32_t>(vmin);
+
+    if (w > 0) {
+      if constexpr (kOrder == InterleavedPforOrder::kFileOrder) {
+        for (size_t t = 0; t < kBlockSize; ++t) {
+          grid[t] = static_cast<uint32_t>(static_cast<int64_t>(blk[t]) - vmin);
+        }
+      } else {
+        // grid[row * kLanes + lane] takes the residual of the value at
+        // original position lane * kRowsPerBlock + row, the same placement
+        // TransposedDeltaEncode uses -- so lane l ends up holding the
+        // contiguous run [32l, 32l+32) once packed.
+        for (size_t lane = 0; lane < kLanes; ++lane) {
+          const size_t run = lane * kRowsPerBlock;
+          for (size_t row = 0; row < kRowsPerBlock; ++row) {
+            grid[row * kLanes + lane] =
+                static_cast<uint32_t>(static_cast<int64_t>(blk[run + row]) - vmin);
+          }
+        }
+      }
+      switch (w) {
+        ILP_WIDTH_CASES(ILP_PACK_CASE)
+        default:
+          return 0;
+      }
+      dst += w * kLanes;
+    }
+  }
+
+  for (size_t b = nblocks; b < ((nblocks + 3) & ~size_t(3)); ++b) widths[b] = 0;
+
+  uint8_t* end = reinterpret_cast<uint8_t*>(dst);
+  const size_t tail = n % kBlockSize;
+  if (tail > 0) {
+    std::memcpy(end, in + nblocks * kBlockSize, tail * sizeof(int32_t));
+    end += tail * sizeof(int32_t);
+  }
+  return static_cast<size_t>(end - out);
+}
+
+template <InterleavedPforOrder kOrder>
+inline void InterleavedPforDecode(const uint8_t* in, size_t n, int32_t* out) {
+  const size_t nblocks = n / kBlockSize;
+
+  const uint8_t* widths = in;
+  const int32_t* mins =
+      reinterpret_cast<const int32_t*>(in + ((nblocks + 3) & ~size_t(3)));
+  const uint32_t* src =
+      reinterpret_cast<const uint32_t*>(in + InterleavedPforHeaderSize(n));
+
+  uint32_t grid[kBlockSize];
+
+  for (size_t b = 0; b < nblocks; ++b) {
+    const uint32_t w = widths[b];
+    const uint32_t bias = static_cast<uint32_t>(mins[b]);
+    int32_t* out_blk = out + b * kBlockSize;
+
+    if (w == 0) {
+      if constexpr (kOrder == InterleavedPforOrder::kFileOrder) {
+        for (size_t t = 0; t < kBlockSize; ++t) out_blk[t] = static_cast<int32_t>(bias);
+      } else {
+        for (size_t t = 0; t < kBlockSize; ++t) grid[t] = bias;
+        Transpose32x32(grid, out_blk);
+      }
+      continue;
+    }
+
+    switch (w) {
+      ILP_WIDTH_CASES(ILP_UNPACK_CASE)
+      default:
+        break;
+    }
+    if constexpr (kOrder == InterleavedPforOrder::kFileOrder) {
+      // File order in, file order out: the container already returns values
+      // at the position they were packed from, so no permutation is owed --
+      // just the one copy out of the block-sized scratch grid.
+      std::memcpy(out_blk, grid, sizeof(grid));
+    } else {
+      // Undo the lane assignment applied at encode: Transpose32x32 is its own
+      // inverse for a square grid, so the same call used to build the FL_ORDER
+      // layout also reads it back into file order.
+      Transpose32x32(grid, out_blk);
+    }
+    src += w * kLanes;
+  }
+
+  const size_t tail = n % kBlockSize;
+  if (tail > 0) {
+    std::memcpy(out + nblocks * kBlockSize, src, tail * sizeof(int32_t));
+  }
+}
+
+#undef ILP_PACK_CASE
+#undef ILP_UNPACK_CASE
+#undef ILP_WIDTH_CASES
+
+}  // namespace fastlanes
+}  // namespace util
+}  // namespace arrow
diff --git a/cpp/src/parquet/pfor_comparison_benchmark.cc b/cpp/src/parquet/pfor_comparison_benchmark.cc
index 1bca166f0b2b..50fa068cfc6f 100644
--- a/cpp/src/parquet/pfor_comparison_benchmark.cc
+++ b/cpp/src/parquet/pfor_comparison_benchmark.cc
@@ -42,6 +42,7 @@
 #include "arrow/util/bit_util.h"
 #include "arrow/util/bpacking_internal.h"
 #include "arrow/util/compression.h"
+#include "arrow/util/fastlanes/interleaved_pfor.h"
 #include "arrow/util/fastlanes/lane_delta.h"
 #include "arrow/util/fastlanes/transposed_delta.h"
 #include "arrow/util/logging.h"
@@ -945,6 +946,29 @@ static void BM_PforDbpDelta64Decode(benchmark::State& state, Gen64 gen) {
   PforDeltaLayoutDecodeImpl<PforDeltaLayout::kDeltaBinaryPacked, int64_t>(state, gen);
 }
 
+// ----------------------------------------------------------------------
+
+// The two arms below hold the delta decision fixed so that the bit-packed
+// layout is the only thing separating them. BM_PforDecode above is the shipping
+// default, which lets the planner difference a vector whenever its cost model
+// prefers that; on a sorted or correlated column it does, and the decode then
+// also pays a serial prefix sum. A ratio taken against a layout arm that never
+// deltas therefore measures two decisions at once, not the layout. These two
+// decline delta on both sides, so the ratio between them is a layout result,
+// and it is valid on every column rather than only the ones the planner leaves
+// alone.
+static void BM_PforPlainSeqDecode(benchmark::State& state, Gen32 gen) {
+  PforDecodeImpl<int32_t>(
+      state, gen,
+      {.delta_enabled = false, .mode = ::arrow::util::pfor::PackingMode::kForBitPack});
+}
+static void BM_PforPlainInterleavedDecode(benchmark::State& state, Gen32 gen) {
+  PforDecodeImpl<int32_t>(
+      state, gen,
+      {.delta_enabled = false,
+       .mode = ::arrow::util::pfor::PackingMode::kForBitPackInterleaved});
+}
+
 // ----------------------------------------------------------------------
 // DeltaBitPack Encode/Decode
 
@@ -2035,6 +2059,53 @@ static void BM_TposeRawNoRepairDecode(benchmark::State& state, Gen32 gen) {
   TposeDecodeImpl<TransposedBaseCoding::kRaw, TransposedRepair::kNone>(state, gen);
 }
 
+// ============================================================================
+// Interleaved-layout PFOR (no delta chain to break)
+// ============================================================================
+//
+// BM_PforDecode is Arrow's shipped sequential decoder -- the layout the
+// format specifies today. These two swap only the bit-unpack kernel for the
+// FastLanes container, keeping the same per-block frame-of-reference and the
+// same real dataset columns, so the margin against BM_PforDecode isolates
+// the layout question on data instead of on synthetic per-width residuals.
+// The second arm adds the paper's lane assignment and the gather needed to
+// undo it, which fastlanes_kernels_internal.h's header comment argues plain
+// PFOR has nothing to buy with -- this prices that argument on real columns.
+
+using ::arrow::util::fastlanes::InterleavedPforOrder;
+
+template <InterleavedPforOrder kOrder>
+static void InterleavedPforDecodeImpl(benchmark::State& state, Gen32 gen) {
+  namespace fl = ::arrow::util::fastlanes;
+  const int64_t num_values = state.range(0);
+  auto values = gen(num_values);
+  const int64_t uncompressed_size = num_values * sizeof(int32_t);
+
+  std::vector<uint8_t> buf(fl::InterleavedPforMaxEncodedSize(num_values));
+  const size_t comp_size =
+      fl::InterleavedPforEncode<kOrder>(values.data(), num_values, buf.data());
+  ARROW_CHECK_GT(comp_size, 0);
+
+  std::vector<int32_t> decoded(num_values);
+  fl::InterleavedPforDecode<kOrder>(buf.data(), num_values, decoded.data());
+  ARROW_CHECK(decoded == values) << "interleaved pfor round trip failed";
+
+  for (auto _ : state) {
+    fl::InterleavedPforDecode<kOrder>(buf.data(), num_values, decoded.data());
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(state.iterations() * uncompressed_size);
+  state.SetItemsProcessed(state.iterations() * num_values);
+  state.counters["compression_ratio"] =
+      static_cast<double>(uncompressed_size) / static_cast<double>(comp_size);
+}
+static void BM_InterleavedPforDecode(benchmark::State& state, Gen32 gen) {
+  InterleavedPforDecodeImpl<InterleavedPforOrder::kFileOrder>(state, gen);
+}
+static void BM_InterleavedPforFlOrderDecode(benchmark::State& state, Gen32 gen) {
+  InterleavedPforDecodeImpl<InterleavedPforOrder::kFlOrder>(state, gen);
+}
+
 static void BM_LaneDeltaEncode(benchmark::State& state, Gen32 gen) {
   namespace fl = ::arrow::util::fastlanes;
   const int64_t num_values = state.range(0);
@@ -2075,48 +2146,52 @@ static void BM_TposePackedEncode(benchmark::State& state, Gen32 gen) {
 static void CustomArgs(benchmark::internal::Benchmark* b) { b->Arg(102400); }
 
 // Macro to register all algorithms for a given dataset
-#define REGISTER_DATASET(Name, GenFunc)                                            \
-  BENCHMARK_CAPTURE(BM_PforEncode, Name, &GenFunc)->Apply(CustomArgs);             \
-  BENCHMARK_CAPTURE(BM_PforDecode, Name, &GenFunc)->Apply(CustomArgs);             \
-  BENCHMARK_CAPTURE(BM_PforRawEncode, Name, &GenFunc)->Apply(CustomArgs);          \
-  BENCHMARK_CAPTURE(BM_PforPatchedDeltaEncode, Name, &GenFunc)->Apply(CustomArgs); \
-  BENCHMARK_CAPTURE(BM_PforPatchedDeltaDecode, Name, &GenFunc)->Apply(CustomArgs); \
-  BENCHMARK_CAPTURE(BM_PforDbpDeltaEncode, Name, &GenFunc)->Apply(CustomArgs);     \
-  BENCHMARK_CAPTURE(BM_PforDbpDeltaDecode, Name, &GenFunc)->Apply(CustomArgs);     \
-  BENCHMARK_CAPTURE(BM_DeltaBitPackEncode, Name, &GenFunc)->Apply(CustomArgs);     \
-  BENCHMARK_CAPTURE(BM_DeltaBitPackDecode, Name, &GenFunc)->Apply(CustomArgs);     \
-  BENCHMARK_CAPTURE(BM_DbpAbFull, Name, &GenFunc)->Apply(CustomArgs);              \
-  BENCHMARK_CAPTURE(BM_DbpAbNoSum, Name, &GenFunc)->Apply(CustomArgs);             \
-  BENCHMARK_CAPTURE(BM_DbpAbNoUnpack, Name, &GenFunc)->Apply(CustomArgs);          \
-  BENCHMARK_CAPTURE(BM_DbpAbHeaderOnly, Name, &GenFunc)->Apply(CustomArgs);        \
-  BENCHMARK_CAPTURE(BM_DbpAbFullHeapReader, Name, &GenFunc)->Apply(CustomArgs);    \
-  BENCHMARK_CAPTURE(BM_DbpRsCoalesce, Name, &GenFunc)->Apply(CustomArgs);          \
-  BENCHMARK_CAPTURE(BM_DbpRsBlockSum, Name, &GenFunc)->Apply(CustomArgs);          \
-  BENCHMARK_CAPTURE(BM_DbpRsBoth, Name, &GenFunc)->Apply(CustomArgs);              \
-  BENCHMARK_CAPTURE(BM_DbpRsDirect, Name, &GenFunc)->Apply(CustomArgs);            \
-  BENCHMARK_CAPTURE(BM_DbpGeom128x1, Name, &GenFunc)->Apply(CustomArgs);           \
-  BENCHMARK_CAPTURE(BM_DbpGeom1024x32, Name, &GenFunc)->Apply(CustomArgs);         \
-  BENCHMARK_CAPTURE(BM_DbpGeom1024x8, Name, &GenFunc)->Apply(CustomArgs);          \
-  BENCHMARK_CAPTURE(BM_DbpGeom1024x1, Name, &GenFunc)->Apply(CustomArgs);          \
-  BENCHMARK_CAPTURE(BM_LaneDeltaDecode, Name, &GenFunc)->Apply(CustomArgs);        \
-  BENCHMARK_CAPTURE(BM_TposeApiDecode, Name, &GenFunc)->Apply(CustomArgs);         \
-  BENCHMARK_CAPTURE(BM_TposeApiEncode, Name, &GenFunc)->Apply(CustomArgs);         \
-  BENCHMARK_CAPTURE(BM_TposeRawDecode, Name, &GenFunc)->Apply(CustomArgs);         \
-  BENCHMARK_CAPTURE(BM_TposePackedDecode, Name, &GenFunc)->Apply(CustomArgs);      \
-  BENCHMARK_CAPTURE(BM_TposeFusedDecode, Name, &GenFunc)->Apply(CustomArgs);       \
-  BENCHMARK_CAPTURE(BM_TposeNoRepairDecode, Name, &GenFunc)->Apply(CustomArgs);    \
-  BENCHMARK_CAPTURE(BM_TposeRawNoRepairDecode, Name, &GenFunc)->Apply(CustomArgs); \
-  BENCHMARK_CAPTURE(BM_LaneDeltaEncode, Name, &GenFunc)->Apply(CustomArgs);        \
-  BENCHMARK_CAPTURE(BM_TposePackedEncode, Name, &GenFunc)->Apply(CustomArgs);      \
-  BENCHMARK_CAPTURE(BM_PlainZstdEncode, Name, &GenFunc)->Apply(CustomArgs);        \
-  BENCHMARK_CAPTURE(BM_PlainZstdDecode, Name, &GenFunc)->Apply(CustomArgs);        \
-  BENCHMARK_CAPTURE(BM_PlainLz4Encode, Name, &GenFunc)->Apply(CustomArgs);         \
-  BENCHMARK_CAPTURE(BM_PlainLz4Decode, Name, &GenFunc)->Apply(CustomArgs);         \
-  BENCHMARK_CAPTURE(BM_RleBitPackEncode, Name, &GenFunc)->Apply(CustomArgs);       \
-  BENCHMARK_CAPTURE(BM_RleBitPackDecode, Name, &GenFunc)->Apply(CustomArgs);       \
-  BENCHMARK_CAPTURE(BM_BssZstdEncode, Name, &GenFunc)->Apply(CustomArgs);          \
-  BENCHMARK_CAPTURE(BM_BssZstdDecode, Name, &GenFunc)->Apply(CustomArgs);          \
-  BENCHMARK_CAPTURE(BM_BssLz4Encode, Name, &GenFunc)->Apply(CustomArgs);           \
+#define REGISTER_DATASET(Name, GenFunc)                                                  \
+  BENCHMARK_CAPTURE(BM_PforEncode, Name, &GenFunc)->Apply(CustomArgs);                   \
+  BENCHMARK_CAPTURE(BM_PforDecode, Name, &GenFunc)->Apply(CustomArgs);                   \
+  BENCHMARK_CAPTURE(BM_PforRawEncode, Name, &GenFunc)->Apply(CustomArgs);                \
+  BENCHMARK_CAPTURE(BM_PforPatchedDeltaEncode, Name, &GenFunc)->Apply(CustomArgs);       \
+  BENCHMARK_CAPTURE(BM_PforPatchedDeltaDecode, Name, &GenFunc)->Apply(CustomArgs);       \
+  BENCHMARK_CAPTURE(BM_PforDbpDeltaEncode, Name, &GenFunc)->Apply(CustomArgs);           \
+  BENCHMARK_CAPTURE(BM_PforDbpDeltaDecode, Name, &GenFunc)->Apply(CustomArgs);           \
+  BENCHMARK_CAPTURE(BM_PforPlainSeqDecode, Name, &GenFunc)->Apply(CustomArgs);           \
+  BENCHMARK_CAPTURE(BM_PforPlainInterleavedDecode, Name, &GenFunc)->Apply(CustomArgs);   \
+  BENCHMARK_CAPTURE(BM_DeltaBitPackEncode, Name, &GenFunc)->Apply(CustomArgs);           \
+  BENCHMARK_CAPTURE(BM_DeltaBitPackDecode, Name, &GenFunc)->Apply(CustomArgs);           \
+  BENCHMARK_CAPTURE(BM_DbpAbFull, Name, &GenFunc)->Apply(CustomArgs);                    \
+  BENCHMARK_CAPTURE(BM_DbpAbNoSum, Name, &GenFunc)->Apply(CustomArgs);                   \
+  BENCHMARK_CAPTURE(BM_DbpAbNoUnpack, Name, &GenFunc)->Apply(CustomArgs);                \
+  BENCHMARK_CAPTURE(BM_DbpAbHeaderOnly, Name, &GenFunc)->Apply(CustomArgs);              \
+  BENCHMARK_CAPTURE(BM_DbpAbFullHeapReader, Name, &GenFunc)->Apply(CustomArgs);          \
+  BENCHMARK_CAPTURE(BM_DbpRsCoalesce, Name, &GenFunc)->Apply(CustomArgs);                \
+  BENCHMARK_CAPTURE(BM_DbpRsBlockSum, Name, &GenFunc)->Apply(CustomArgs);                \
+  BENCHMARK_CAPTURE(BM_DbpRsBoth, Name, &GenFunc)->Apply(CustomArgs);                    \
+  BENCHMARK_CAPTURE(BM_DbpRsDirect, Name, &GenFunc)->Apply(CustomArgs);                  \
+  BENCHMARK_CAPTURE(BM_DbpGeom128x1, Name, &GenFunc)->Apply(CustomArgs);                 \
+  BENCHMARK_CAPTURE(BM_DbpGeom1024x32, Name, &GenFunc)->Apply(CustomArgs);               \
+  BENCHMARK_CAPTURE(BM_DbpGeom1024x8, Name, &GenFunc)->Apply(CustomArgs);                \
+  BENCHMARK_CAPTURE(BM_DbpGeom1024x1, Name, &GenFunc)->Apply(CustomArgs);                \
+  BENCHMARK_CAPTURE(BM_InterleavedPforDecode, Name, &GenFunc)->Apply(CustomArgs);        \
+  BENCHMARK_CAPTURE(BM_InterleavedPforFlOrderDecode, Name, &GenFunc)->Apply(CustomArgs); \
+  BENCHMARK_CAPTURE(BM_LaneDeltaDecode, Name, &GenFunc)->Apply(CustomArgs);              \
+  BENCHMARK_CAPTURE(BM_TposeApiDecode, Name, &GenFunc)->Apply(CustomArgs);               \
+  BENCHMARK_CAPTURE(BM_TposeApiEncode, Name, &GenFunc)->Apply(CustomArgs);               \
+  BENCHMARK_CAPTURE(BM_TposeRawDecode, Name, &GenFunc)->Apply(CustomArgs);               \
+  BENCHMARK_CAPTURE(BM_TposePackedDecode, Name, &GenFunc)->Apply(CustomArgs);            \
+  BENCHMARK_CAPTURE(BM_TposeFusedDecode, Name, &GenFunc)->Apply(CustomArgs);             \
+  BENCHMARK_CAPTURE(BM_TposeNoRepairDecode, Name, &GenFunc)->Apply(CustomArgs);          \
+  BENCHMARK_CAPTURE(BM_TposeRawNoRepairDecode, Name, &GenFunc)->Apply(CustomArgs);       \
+  BENCHMARK_CAPTURE(BM_LaneDeltaEncode, Name, &GenFunc)->Apply(CustomArgs);              \
+  BENCHMARK_CAPTURE(BM_TposePackedEncode, Name, &GenFunc)->Apply(CustomArgs);            \
+  BENCHMARK_CAPTURE(BM_PlainZstdEncode, Name, &GenFunc)->Apply(CustomArgs);              \
+  BENCHMARK_CAPTURE(BM_PlainZstdDecode, Name, &GenFunc)->Apply(CustomArgs);              \
+  BENCHMARK_CAPTURE(BM_PlainLz4Encode, Name, &GenFunc)->Apply(CustomArgs);               \
+  BENCHMARK_CAPTURE(BM_PlainLz4Decode, Name, &GenFunc)->Apply(CustomArgs);               \
+  BENCHMARK_CAPTURE(BM_RleBitPackEncode, Name, &GenFunc)->Apply(CustomArgs);             \
+  BENCHMARK_CAPTURE(BM_RleBitPackDecode, Name, &GenFunc)->Apply(CustomArgs);             \
+  BENCHMARK_CAPTURE(BM_BssZstdEncode, Name, &GenFunc)->Apply(CustomArgs);                \
+  BENCHMARK_CAPTURE(BM_BssZstdDecode, Name, &GenFunc)->Apply(CustomArgs);                \
+  BENCHMARK_CAPTURE(BM_BssLz4Encode, Name, &GenFunc)->Apply(CustomArgs);                 \
   BENCHMARK_CAPTURE(BM_BssLz4Decode, Name, &GenFunc)->Apply(CustomArgs);
 
 // Same as REGISTER_DATASET but for int64 (BIGINT) columns; benchmark names get

From 94a5b8151f97cf02a4c24a319de10ef6aadf6f92 Mon Sep 17 00:00:00 2001
From: Prateek Gaur <prateek.gaur@snowflake.com>
Date: Sun, 13 Sep 2026 16:14:20 +0000
Subject: [PATCH 20/27] Cap bit-unpack dispatch at AVX2

The generated AVX-512 unpacker builds its vectors from scalar loads and
calls out of line. Runtime dispatch stops at AVX2 until the AVX-512
kernels load vectors directly.
---
 cpp/src/arrow/util/bpacking.cc | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/cpp/src/arrow/util/bpacking.cc b/cpp/src/arrow/util/bpacking.cc
index 4a2ec0f9c059..0e1a8020678c 100644
--- a/cpp/src/arrow/util/bpacking.cc
+++ b/cpp/src/arrow/util/bpacking.cc
@@ -38,7 +38,11 @@ struct UnpackDynamicFunction {
         ARROW_DISPATCH_TARGET_SVE256(&bpacking::unpack_sve256<Uint>)  //
         ARROW_DISPATCH_TARGET_SSE4_2(&bpacking::unpack_sse4_2<Uint>)  //
         ARROW_DISPATCH_TARGET_AVX2(&bpacking::unpack_avx2<Uint>)      //
-        ARROW_DISPATCH_TARGET_AVX512(&bpacking::unpack_avx512<Uint>)  //
+        // Cap bit-unpack dispatch at 256 bits. The generated AVX-512 kernels
+        // assemble vectors from scalar loads and use out-of-line calls, making
+        // them slower than the AVX2 path. Re-enable this target when its kernels
+        // use vector loads directly.
+        // ARROW_DISPATCH_TARGET_AVX512(&bpacking::unpack_avx512<Uint>)  //
     };
   }
 };
@@ -55,7 +59,8 @@ struct UnpackBiasDynamicFunction {
         ARROW_DISPATCH_TARGET_SVE256(&bpacking::unpack_bias_sve256<Uint>)  //
         ARROW_DISPATCH_TARGET_SSE4_2(&bpacking::unpack_bias_sse4_2<Uint>)  //
         ARROW_DISPATCH_TARGET_AVX2(&bpacking::unpack_bias_avx2<Uint>)      //
-        ARROW_DISPATCH_TARGET_AVX512(&bpacking::unpack_bias_avx512<Uint>)  //
+        // Capped at 256 bits for the reason given in UnpackDynamicFunction above.
+        // ARROW_DISPATCH_TARGET_AVX512(&bpacking::unpack_bias_avx512<Uint>)  //
     };
   }
 };

From e9e877f15a42e1853487abbefa6afcd2a7c9fc7a Mon Sep 17 00:00:00 2001
From: Prateek Gaur <prateek.gaur@snowflake.com>
Date: Sun, 13 Sep 2026 16:14:41 +0000
Subject: [PATCH 21/27] Fuse FL_ORDER transpose into unpacking

Decoding FL_ORDER to file order used to unpack into a 4 KiB scratch grid
and then transpose it, which is 128 extra stores and loads per block.
The transpose tiles are now built from the unpacked registers directly.
Lane-parallel delta uses the same structure. A benchmark across
working-set sizes and a note on which output orders can be compared are
included.
---
 .../arrow/util/fastlanes/interleaved_pfor.h   | 256 +++++++++++--
 .../arrow/util/fastlanes/transposed_delta.h   | 356 +++++++++++++++++-
 .../transposed_delta_wrapper_internal.h       |   6 +-
 cpp/src/parquet/pfor_comparison_benchmark.cc  | 167 ++++++--
 4 files changed, 720 insertions(+), 65 deletions(-)

diff --git a/cpp/src/arrow/util/fastlanes/interleaved_pfor.h b/cpp/src/arrow/util/fastlanes/interleaved_pfor.h
index ccc36bf831b2..3c5cdd076f83 100644
--- a/cpp/src/arrow/util/fastlanes/interleaved_pfor.h
+++ b/cpp/src/arrow/util/fastlanes/interleaved_pfor.h
@@ -35,9 +35,42 @@
 //               it -- see fastlanes_kernels_internal.h's header comment.
 //
 // Both orders are otherwise identical: same per-block FOR, same bit width
-// choice, same container. Comparing their decode cost against BM_PforDecode
-// (Arrow's shipped sequential decoder) on the same real dataset columns is
-// what isolates the layout question from the value-ordering question.
+// choice, same container. That makes the difference between them the value
+// ordering and nothing else, which is the one question this file answers.
+//
+// THIS CODE HAS NO EXCEPTION HANDLING. There is no patch list on the wire and
+// no patch pass in the decoder, because a bit width wide enough for the block's
+// largest residual is always chosen. Arrow's production PFOR does carry
+// exceptions and does patch them, so a ratio taken between anything here and a
+// production arm charges one side for work the other never does, and the
+// difference is not the layout. Compare kFileOrder against kFlOrder/kFlOrderRaw
+// here; for sequential against interleaved, use the two production arms that
+// differ only in PackingMode.
+//
+// The container also appears in production as PackingMode::kForBitPackInterleaved,
+// which is what a Parquet reader would use. This file is not that code and does
+// not share its wire format: the production format has no lane-assignment mode,
+// so the ordering question has nowhere else to be asked.
+//
+// A caveat on what "the same columns" means, because an earlier version of this
+// comment overstated it: the benchmark corpus is SYNTHETIC. Its columns are
+// generators shaped after distributions seen in ClickBench, TPC-DS, TPC-H and
+// the NYC taxi set -- they are not records loaded from those datasets, and the
+// only file the harness opens is the CSV it writes. Bit-unpacking throughput is
+// data-independent at a fixed width, so that substitution is harmless for the
+// timing arms. It is NOT harmless for any claim about how wide a column packs,
+// since the generator's autocorrelation is chosen rather than observed.
+//
+// A second caveat, on register width. UnpackBlock in
+// fastlanes_kernels_internal.h contains no intrinsics: it is portable C++ that
+// the compiler auto-vectorizes, so its register width is whatever the
+// translation unit's compile-time flags permit. It has NO runtime SIMD dispatch,
+// which means ARROW_USER_SIMD_LEVEL does not reach it and ARROW_SIMD_LEVEL
+// (default: SSE4_2 on x86) decides it. On a default build this kernel compiles
+// to XMM while the sequential comparand dispatches to a hand-written AVX2 body
+// at runtime, so a layout comparison from a default build is measuring register
+// width and not layout. Build with -DARROW_SIMD_LEVEL=AVX2 or better before
+// comparing, or give these kernels real dispatch.
 //
 // Wire layout for n values (n a multiple of 1024; any tail is stored raw):
 //
@@ -61,7 +94,18 @@ namespace arrow {
 namespace util {
 namespace fastlanes {
 
-enum class InterleavedPforOrder { kFileOrder, kFlOrder };
+// kFileOrder   pack in input order, decode straight back to input order.
+// kFlOrderRaw  pack with the paper's lane assignment -- lane l holds the
+//              contiguous run [32l, 32l+32), reusing transposed_delta.h's
+//              Transpose32x32 -- and hand that order to the caller unchanged,
+//              for a consumer that does not care about value order. It runs the
+//              same PackBlock/UnpackBlock as kFileOrder against a grid that was
+//              merely filled differently at encode time, so its decode cost
+//              must come out equal to kFileOrder's; that it does is a check on
+//              the harness.
+// kFlOrder     the same wire bytes as kFlOrderRaw, but decode restores input
+//              order. This is what prices FL_ORDER's permutation.
+enum class InterleavedPforOrder { kFileOrder, kFlOrderRaw, kFlOrder };
 
 inline uint32_t InterleavedPforBitsFor(uint64_t v) {
   uint32_t bits = 0;
@@ -88,9 +132,19 @@ inline size_t InterleavedPforMaxEncodedSize(size_t n) {
     PackBlock<W>(grid, dst); \
     break;
 
-#define ILP_UNPACK_CASE(W)                 \
-  case W:                                  \
-    UnpackBlock<W, true>(src, grid, bias); \
+#define ILP_UNPACK_CASE(W)                \
+  case W:                                 \
+    UnpackBlock<W, true>(src, dst, bias); \
+    break;
+
+#define ILP_UNPACK_SCRATCH_CASE(W)            \
+  case W:                                     \
+    UnpackBlock<W, true>(src, scratch, bias); \
+    break;
+
+#define ILP_UNPACK_FUSED_CASE(W)                           \
+  case W:                                                  \
+    UnpackBlockFlToFileOrder<W, true>(src, out_blk, bias); \
     break;
 
 // clang-format off
@@ -101,6 +155,123 @@ inline size_t InterleavedPforMaxEncodedSize(size_t n) {
   M(25) M(26) M(27) M(28) M(29) M(30) M(31) M(32)
 // clang-format on
 
+// ---------------------------------------------------------------------------
+// Fused FL_ORDER unpack: packed words -> file order in a single pass.
+//
+// The naive FL_ORDER decode is UnpackBlock into a 4 KiB stack grid followed by
+// Transpose32x32 out of it. That materializes the grid in memory purely to read
+// it straight back: 128 extra 32-byte stores and 128 extra loads per block, on
+// top of the 128 stores the output needs. The permutation itself is
+// unavoidable -- FL_ORDER exists to place values where the delta chain wants
+// them, and file order has to be restored for anyone who needs it -- but the
+// round trip through memory is not.
+//
+// Folding the transpose into the store addresses of the row-major kernel is
+// inefficient: out[lane * 32 + row] means the 32
+// lanes of one row land 128 bytes apart, so each contiguous 32-byte store
+// becomes eight 4-byte scatters. That trades 128 stores per block for 1024.
+//
+// What works is doing the transpose in registers, which is what
+// Transpose32x32Avx2 already does -- it just does it on a grid that was written
+// to memory first. Here the same 8x8 register block is filled directly by the
+// unpack, so the grid never exists:
+//
+//   for each 8-lane slice lb, for each 8-row block rb:
+//     eight registers <- unpack rows rb..rb+7, lanes lb..lb+7   (8-16 loads)
+//     the unpacklo/unpackhi/permute2x128 sequence               (24 shuffles)
+//     eight 32-byte stores across out[lb..lb+7][rb..rb+7]       (8 stores)
+//
+// Load and store counts per block are then identical to the file-order kernel's
+// (each packed word read once, each output value written once); the only thing
+// FL_ORDER pays over file order is the shuffles. lb is the outer loop on
+// purpose: a fixed lb writes out[lb * 32, lb * 32 + 256), one contiguous 1 KiB
+// run, whereas rb outer would stride 128 bytes across the whole 4 KiB block.
+// ---------------------------------------------------------------------------
+#ifdef ARROW_TRANSPOSED_DELTA_AVX2
+
+namespace internal {
+
+// FlUnpackRowSlice lives in transposed_delta.h: the fused delta kernel there
+// needs it too, and that header is upstream of this one.
+
+// One 8x8 tile: unpack eight rows' worth of an 8-lane slice, transpose in
+// registers, store across eight output rows. The shuffle sequence is the same
+// one Transpose32x32Avx2 uses; only the source of r0..r7 differs.
+template <uint32_t w, bool kHasBias, uint32_t rb>
+ARROW_FORCE_INLINE void FlUnpackTile(const uint32_t* ARROW_RESTRICT packed,
+                                     int32_t* ARROW_RESTRICT out, size_t lb,
+                                     __m256i vmask, __m256i vbias) {
+  const __m256i r0 = FlUnpackRowSlice<w, kHasBias, rb + 0>(packed, lb, vmask, vbias);
+  const __m256i r1 = FlUnpackRowSlice<w, kHasBias, rb + 1>(packed, lb, vmask, vbias);
+  const __m256i r2 = FlUnpackRowSlice<w, kHasBias, rb + 2>(packed, lb, vmask, vbias);
+  const __m256i r3 = FlUnpackRowSlice<w, kHasBias, rb + 3>(packed, lb, vmask, vbias);
+  const __m256i r4 = FlUnpackRowSlice<w, kHasBias, rb + 4>(packed, lb, vmask, vbias);
+  const __m256i r5 = FlUnpackRowSlice<w, kHasBias, rb + 5>(packed, lb, vmask, vbias);
+  const __m256i r6 = FlUnpackRowSlice<w, kHasBias, rb + 6>(packed, lb, vmask, vbias);
+  const __m256i r7 = FlUnpackRowSlice<w, kHasBias, rb + 7>(packed, lb, vmask, vbias);
+
+  const __m256i t0 = _mm256_unpacklo_epi32(r0, r1);
+  const __m256i t1 = _mm256_unpackhi_epi32(r0, r1);
+  const __m256i t2 = _mm256_unpacklo_epi32(r2, r3);
+  const __m256i t3 = _mm256_unpackhi_epi32(r2, r3);
+  const __m256i t4 = _mm256_unpacklo_epi32(r4, r5);
+  const __m256i t5 = _mm256_unpackhi_epi32(r4, r5);
+  const __m256i t6 = _mm256_unpacklo_epi32(r6, r7);
+  const __m256i t7 = _mm256_unpackhi_epi32(r6, r7);
+
+  const __m256i u0 = _mm256_unpacklo_epi64(t0, t2);
+  const __m256i u1 = _mm256_unpackhi_epi64(t0, t2);
+  const __m256i u2 = _mm256_unpacklo_epi64(t1, t3);
+  const __m256i u3 = _mm256_unpackhi_epi64(t1, t3);
+  const __m256i u4 = _mm256_unpacklo_epi64(t4, t6);
+  const __m256i u5 = _mm256_unpackhi_epi64(t4, t6);
+  const __m256i u6 = _mm256_unpacklo_epi64(t5, t7);
+  const __m256i u7 = _mm256_unpackhi_epi64(t5, t7);
+
+  int32_t* dst = out + lb * kRowsPerBlock + rb;
+  _mm256_storeu_si256(reinterpret_cast<__m256i*>(dst + 0 * kRowsPerBlock),
+                      _mm256_permute2x128_si256(u0, u4, 0x20));
+  _mm256_storeu_si256(reinterpret_cast<__m256i*>(dst + 1 * kRowsPerBlock),
+                      _mm256_permute2x128_si256(u1, u5, 0x20));
+  _mm256_storeu_si256(reinterpret_cast<__m256i*>(dst + 2 * kRowsPerBlock),
+                      _mm256_permute2x128_si256(u2, u6, 0x20));
+  _mm256_storeu_si256(reinterpret_cast<__m256i*>(dst + 3 * kRowsPerBlock),
+                      _mm256_permute2x128_si256(u3, u7, 0x20));
+  _mm256_storeu_si256(reinterpret_cast<__m256i*>(dst + 4 * kRowsPerBlock),
+                      _mm256_permute2x128_si256(u0, u4, 0x31));
+  _mm256_storeu_si256(reinterpret_cast<__m256i*>(dst + 5 * kRowsPerBlock),
+                      _mm256_permute2x128_si256(u1, u5, 0x31));
+  _mm256_storeu_si256(reinterpret_cast<__m256i*>(dst + 6 * kRowsPerBlock),
+                      _mm256_permute2x128_si256(u2, u6, 0x31));
+  _mm256_storeu_si256(reinterpret_cast<__m256i*>(dst + 7 * kRowsPerBlock),
+                      _mm256_permute2x128_si256(u3, u7, 0x31));
+}
+
+}  // namespace internal
+
+#  define ARROW_FASTLANES_FUSED_FL_UNPACK 1
+
+// Unpacks a block that was packed in FL_ORDER and writes it in file order,
+// adding `bias` on the way through. Equivalent to UnpackBlock<w, true> into a
+// scratch grid followed by Transpose32x32, without the grid.
+template <uint32_t w, bool kHasBias>
+inline void UnpackBlockFlToFileOrder(const uint32_t* ARROW_RESTRICT packed,
+                                     int32_t* ARROW_RESTRICT out, uint32_t bias = 0) {
+  static_assert(w >= 1 && w <= 32);
+  constexpr uint32_t kMask = (w == 32) ? 0xFFFFFFFFu : ((1u << w) - 1);
+  const __m256i vmask = _mm256_set1_epi32(static_cast<int>(kMask));
+  const __m256i vbias = _mm256_set1_epi32(static_cast<int>(bias));
+
+  for (size_t lb = 0; lb < kLanes; lb += 8) {
+    internal::FlUnpackTile<w, kHasBias, 0>(packed, out, lb, vmask, vbias);
+    internal::FlUnpackTile<w, kHasBias, 8>(packed, out, lb, vmask, vbias);
+    internal::FlUnpackTile<w, kHasBias, 16>(packed, out, lb, vmask, vbias);
+    internal::FlUnpackTile<w, kHasBias, 24>(packed, out, lb, vmask, vbias);
+  }
+}
+
+#endif  // ARROW_TRANSPOSED_DELTA_AVX2
+
 // Returns bytes written, or 0 if some block's span exceeds 32 bits (it never
 // does for plain int32 values: max - min fits in 32 bits unconditionally).
 template <InterleavedPforOrder kOrder>
@@ -175,7 +346,17 @@ inline void InterleavedPforDecode(const uint8_t* in, size_t n, int32_t* out) {
   const uint32_t* src =
       reinterpret_cast<const uint32_t*>(in + InterleavedPforHeaderSize(n));
 
-  uint32_t grid[kBlockSize];
+  // Only kFlOrder can need a scratch grid, and only where the fused kernel is
+  // unavailable: kFileOrder owes no permutation, kFlOrderRaw hands the
+  // FastLanes order to the caller as-is, and where UnpackBlockFlToFileOrder
+  // exists the permutation happens in registers.
+#ifdef ARROW_FASTLANES_FUSED_FL_UNPACK
+  constexpr bool kNeedsScratch = false;
+#else
+  constexpr bool kNeedsScratch = (kOrder == InterleavedPforOrder::kFlOrder);
+#endif
+  uint32_t scratch[kNeedsScratch ? kBlockSize : 1];
+  ARROW_UNUSED(scratch);
 
   for (size_t b = 0; b < nblocks; ++b) {
     const uint32_t w = widths[b];
@@ -183,30 +364,47 @@ inline void InterleavedPforDecode(const uint8_t* in, size_t n, int32_t* out) {
     int32_t* out_blk = out + b * kBlockSize;
 
     if (w == 0) {
-      if constexpr (kOrder == InterleavedPforOrder::kFileOrder) {
-        for (size_t t = 0; t < kBlockSize; ++t) out_blk[t] = static_cast<int32_t>(bias);
-      } else {
-        for (size_t t = 0; t < kBlockSize; ++t) grid[t] = bias;
-        Transpose32x32(grid, out_blk);
-      }
+      // Every value in the block is the bias, so the FL_ORDER permutation is the
+      // identity on it: a constant grid transposes to itself. All three orders
+      // fill the output directly and none touches the scratch.
+      for (size_t t = 0; t < kBlockSize; ++t) out_blk[t] = static_cast<int32_t>(bias);
       continue;
     }
 
-    switch (w) {
-      ILP_WIDTH_CASES(ILP_UNPACK_CASE)
-      default:
-        break;
-    }
-    if constexpr (kOrder == InterleavedPforOrder::kFileOrder) {
-      // File order in, file order out: the container already returns values
-      // at the position they were packed from, so no permutation is owed --
-      // just the one copy out of the block-sized scratch grid.
-      std::memcpy(out_blk, grid, sizeof(grid));
+    if constexpr (kOrder == InterleavedPforOrder::kFlOrder) {
+#ifdef ARROW_FASTLANES_FUSED_FL_UNPACK
+      // Unpack and permute in one pass; no grid is ever written to memory.
+      switch (w) {
+        ILP_WIDTH_CASES(ILP_UNPACK_FUSED_CASE)
+        default:
+          break;
+      }
+#else
+      // Portable fallback: materialize the grid, then read it back out.
+      // Transpose32x32 is its own inverse for a square grid, so the same call
+      // used to build the FL_ORDER layout also reads it back into file order.
+      switch (w) {
+        ILP_WIDTH_CASES(ILP_UNPACK_SCRATCH_CASE)
+        default:
+          break;
+      }
+      Transpose32x32(scratch, out_blk);
+#endif
     } else {
-      // Undo the lane assignment applied at encode: Transpose32x32 is its own
-      // inverse for a square grid, so the same call used to build the FL_ORDER
-      // layout also reads it back into file order.
-      Transpose32x32(grid, out_blk);
+      // kFileOrder and kFlOrderRaw both want the grid exactly as UnpackBlock
+      // produces it, so the kernel writes straight into the caller's buffer.
+      // Write directly to the caller's buffer to avoid an intermediate 4 KiB
+      // grid and a second traversal. UnpackBlock writes
+      // out[row * kLanes + lane] contiguously, exactly once per value, with no
+      // read-modify-write and no alignment requirement, and both of its pointers
+      // are ARROW_RESTRICT, so retargeting it preserves the store sequence with
+      // a different destination base.
+      uint32_t* dst = reinterpret_cast<uint32_t*>(out_blk);
+      switch (w) {
+        ILP_WIDTH_CASES(ILP_UNPACK_CASE)
+        default:
+          break;
+      }
     }
     src += w * kLanes;
   }
@@ -219,6 +417,8 @@ inline void InterleavedPforDecode(const uint8_t* in, size_t n, int32_t* out) {
 
 #undef ILP_PACK_CASE
 #undef ILP_UNPACK_CASE
+#undef ILP_UNPACK_SCRATCH_CASE
+#undef ILP_UNPACK_FUSED_CASE
 #undef ILP_WIDTH_CASES
 
 }  // namespace fastlanes
diff --git a/cpp/src/arrow/util/fastlanes/transposed_delta.h b/cpp/src/arrow/util/fastlanes/transposed_delta.h
index 04bc8dd925f2..46c3cc309a84 100644
--- a/cpp/src/arrow/util/fastlanes/transposed_delta.h
+++ b/cpp/src/arrow/util/fastlanes/transposed_delta.h
@@ -79,19 +79,66 @@
 #  define ARROW_TRANSPOSED_DELTA_NEON 1
 #endif
 
+#if defined(__AVX2__)
+#  include <immintrin.h>
+#  define ARROW_TRANSPOSED_DELTA_AVX2 1
+#endif
+
 #include "arrow/util/fastlanes/fastlanes_kernels_internal.h"
 
 namespace arrow {
 namespace util {
 namespace fastlanes {
 
+#ifdef ARROW_TRANSPOSED_DELTA_AVX2
+namespace internal {
+
+// One 8-lane slice of one row, unpacked in registers. `row` is a template
+// parameter because the word index, the shift amounts and the straddle test all
+// have to be compile-time constants -- _mm256_srli_epi32 takes an immediate.
+template <uint32_t w, bool kHasBias, uint32_t row>
+ARROW_FORCE_INLINE __m256i FlUnpackRowSlice(const uint32_t* ARROW_RESTRICT packed,
+                                            size_t lb, __m256i vmask, __m256i vbias) {
+  constexpr uint32_t kT = 32;
+  constexpr uint32_t kStartBit = row * w;
+  constexpr uint32_t kWord = kStartBit / kT;
+  constexpr uint32_t kShift = kStartBit % kT;
+  constexpr uint32_t kEndWord = (kStartBit + w - 1) / kT;
+
+  __m256i v =
+      _mm256_loadu_si256(reinterpret_cast<const __m256i*>(packed + kWord * kLanes + lb));
+  if constexpr (kShift != 0) {
+    v = _mm256_srli_epi32(v, kShift);
+  }
+  if constexpr (kWord != kEndWord) {
+    // A value that straddles two words has to start partway into the first, so
+    // kShift is nonzero here and the left shift below is never by 32.
+    const __m256i hi = _mm256_loadu_si256(
+        reinterpret_cast<const __m256i*>(packed + kEndWord * kLanes + lb));
+    v = _mm256_or_si256(v, _mm256_slli_epi32(hi, kT - kShift));
+  }
+  if constexpr (w != 32) {
+    v = _mm256_and_si256(v, vmask);
+  }
+  if constexpr (kHasBias) {
+    v = _mm256_add_epi32(v, vbias);
+  }
+  return v;
+}
+
+}  // namespace internal
+#endif
+
 enum class TransposedBaseCoding { kRaw, kPacked };
 
 // How a decoder gets back to file order. kNone is not a conforming decoder and
-// exists only to price the other two. kSeparate walks the block twice, once for
-// the prefix sums and once to permute; kFused does both in one pass, which is
+// exists only to price the others. kSeparate walks the block twice, once for the
+// prefix sums and once to permute; kFused does both in one pass, which is
 // available because a lane's chain does not depend on any other lane.
-enum class TransposedRepair { kNone, kSeparate, kFused };
+// kFusedUnpack goes one step further and folds the bit-unpack in as well, so no
+// 4 KB scratch block is written or read at all. Where no fused-unpack kernel
+// exists it degrades to kFused rather than silently to kSeparate.
+enum class TransposedRepair { kNone, kSeparate, kFused, kFusedUnpack };
 
 // The output slot that container slot (row, lane) belongs to, and its inverse.
 // Not used on the hot path -- the decoder transposes in blocks instead.
@@ -188,6 +235,11 @@ inline size_t TransposedMaxEncodedSize(size_t n) {
     UnpackBlock<W, true>(src, grid, bias); \
     break;
 
+#define TPOSE_FUSED_UNPACK_CASE(W)                                              \
+  case W:                                                                       \
+    UnpackPrefixSumAndTransposeAvx2<W>(src, bases, bias, out + b * kBlockSize); \
+    break;
+
 // clang-format off
 #define TPOSE_WIDTH_CASES(M)                      \
   M(1) M(2) M(3) M(4) M(5) M(6) M(7) M(8)         \
@@ -355,10 +407,86 @@ inline void Transpose32x32Neon(const uint32_t* ARROW_RESTRICT grid,
 }
 #endif
 
+#ifdef ARROW_TRANSPOSED_DELTA_AVX2
+// Sixteen 8x8 transposes, each done entirely in registers: eight 32-byte loads
+// down a column of the grid, a shuffle sequence, eight 32-byte stores across a row
+// of the output. A permutation is the one thing in this file the autovectorizer
+// cannot do -- it is not a lane-wise operation, and GCC lowers the scalar
+// version below to 1024 four-byte loads at a 128-byte stride plus 1024 scalar
+// stores. This issues 128 loads and 128 stores instead, so the block costs
+// shuffle throughput rather than memory-op throughput. 256-bit and not 512-bit
+// on purpose: a 16x16 register block needs vpermi2d shuffles to cross the extra
+// lane boundary, and on this microarchitecture 512-bit buys nothing for the
+// unpack either.
+inline void Transpose32x32Avx2(const uint32_t* ARROW_RESTRICT grid,
+                               int32_t* ARROW_RESTRICT out) {
+  for (size_t rb = 0; rb < kRowsPerBlock; rb += 8) {
+    for (size_t lb = 0; lb < kLanes; lb += 8) {
+      const uint32_t* src = grid + rb * kLanes + lb;
+      const __m256i r0 = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(src));
+      const __m256i r1 =
+          _mm256_loadu_si256(reinterpret_cast<const __m256i*>(src + 1 * kLanes));
+      const __m256i r2 =
+          _mm256_loadu_si256(reinterpret_cast<const __m256i*>(src + 2 * kLanes));
+      const __m256i r3 =
+          _mm256_loadu_si256(reinterpret_cast<const __m256i*>(src + 3 * kLanes));
+      const __m256i r4 =
+          _mm256_loadu_si256(reinterpret_cast<const __m256i*>(src + 4 * kLanes));
+      const __m256i r5 =
+          _mm256_loadu_si256(reinterpret_cast<const __m256i*>(src + 5 * kLanes));
+      const __m256i r6 =
+          _mm256_loadu_si256(reinterpret_cast<const __m256i*>(src + 6 * kLanes));
+      const __m256i r7 =
+          _mm256_loadu_si256(reinterpret_cast<const __m256i*>(src + 7 * kLanes));
+
+      // Interleave 32-bit, then 64-bit, then swap the 128-bit halves. Each step
+      // halves the distance between elements that must end up adjacent.
+      const __m256i t0 = _mm256_unpacklo_epi32(r0, r1);
+      const __m256i t1 = _mm256_unpackhi_epi32(r0, r1);
+      const __m256i t2 = _mm256_unpacklo_epi32(r2, r3);
+      const __m256i t3 = _mm256_unpackhi_epi32(r2, r3);
+      const __m256i t4 = _mm256_unpacklo_epi32(r4, r5);
+      const __m256i t5 = _mm256_unpackhi_epi32(r4, r5);
+      const __m256i t6 = _mm256_unpacklo_epi32(r6, r7);
+      const __m256i t7 = _mm256_unpackhi_epi32(r6, r7);
+
+      const __m256i u0 = _mm256_unpacklo_epi64(t0, t2);
+      const __m256i u1 = _mm256_unpackhi_epi64(t0, t2);
+      const __m256i u2 = _mm256_unpacklo_epi64(t1, t3);
+      const __m256i u3 = _mm256_unpackhi_epi64(t1, t3);
+      const __m256i u4 = _mm256_unpacklo_epi64(t4, t6);
+      const __m256i u5 = _mm256_unpackhi_epi64(t4, t6);
+      const __m256i u6 = _mm256_unpacklo_epi64(t5, t7);
+      const __m256i u7 = _mm256_unpackhi_epi64(t5, t7);
+
+      int32_t* dst = out + lb * kRowsPerBlock + rb;
+      _mm256_storeu_si256(reinterpret_cast<__m256i*>(dst + 0 * kRowsPerBlock),
+                          _mm256_permute2x128_si256(u0, u4, 0x20));
+      _mm256_storeu_si256(reinterpret_cast<__m256i*>(dst + 1 * kRowsPerBlock),
+                          _mm256_permute2x128_si256(u1, u5, 0x20));
+      _mm256_storeu_si256(reinterpret_cast<__m256i*>(dst + 2 * kRowsPerBlock),
+                          _mm256_permute2x128_si256(u2, u6, 0x20));
+      _mm256_storeu_si256(reinterpret_cast<__m256i*>(dst + 3 * kRowsPerBlock),
+                          _mm256_permute2x128_si256(u3, u7, 0x20));
+      _mm256_storeu_si256(reinterpret_cast<__m256i*>(dst + 4 * kRowsPerBlock),
+                          _mm256_permute2x128_si256(u0, u4, 0x31));
+      _mm256_storeu_si256(reinterpret_cast<__m256i*>(dst + 5 * kRowsPerBlock),
+                          _mm256_permute2x128_si256(u1, u5, 0x31));
+      _mm256_storeu_si256(reinterpret_cast<__m256i*>(dst + 6 * kRowsPerBlock),
+                          _mm256_permute2x128_si256(u2, u6, 0x31));
+      _mm256_storeu_si256(reinterpret_cast<__m256i*>(dst + 7 * kRowsPerBlock),
+                          _mm256_permute2x128_si256(u3, u7, 0x31));
+    }
+  }
+}
+#endif
+
 inline void Transpose32x32(const uint32_t* ARROW_RESTRICT grid,
                            int32_t* ARROW_RESTRICT out) {
 #ifdef ARROW_TRANSPOSED_DELTA_NEON
   Transpose32x32Neon(grid, out);
+#elif defined(ARROW_TRANSPOSED_DELTA_AVX2)
+  Transpose32x32Avx2(grid, out);
 #else
   Transpose32x32Scalar(grid, out);
 #endif
@@ -368,9 +496,9 @@ inline void Transpose32x32(const uint32_t* ARROW_RESTRICT grid,
 // The 32 prefix sums and the permutation in one pass. Four lanes' chains run in
 // one register, so four rows of results can be transposed and stored while they
 // are still in registers, sparing the block a second 4 KB round trip.
-inline void PrefixSumAndTranspose(const uint32_t* ARROW_RESTRICT grid,
-                                  const uint32_t* ARROW_RESTRICT bases,
-                                  int32_t* ARROW_RESTRICT out) {
+inline void PrefixSumAndTransposeNeon(const uint32_t* ARROW_RESTRICT grid,
+                                      const uint32_t* ARROW_RESTRICT bases,
+                                      int32_t* ARROW_RESTRICT out) {
   for (size_t lane = 0; lane < kLanes; lane += 4) {
     uint32x4_t acc = vld1q_u32(bases + lane);
     for (size_t row = 0; row < kRowsPerBlock; row += 4) {
@@ -395,6 +523,203 @@ inline void PrefixSumAndTranspose(const uint32_t* ARROW_RESTRICT grid,
 }
 #endif
 
+#ifdef ARROW_TRANSPOSED_DELTA_AVX2
+// The 32 prefix sums and the permutation in one pass, the x86 counterpart of the
+// NEON kernel above. Without it TransposedRepair::kFused was a silent alias for
+// kSeparate on every x86 target -- the #ifdef above guarded both the kernel and
+// its call site -- so the block paid three traversals of the 4 KB grid (the
+// unpack's write, the prefix sum's read-modify-write, then the transpose's read)
+// where NEON paid two.
+//
+// The loop nest is the transpose's, with the blocking order swapped: lane block
+// outer, row block inner, so one accumulator register carries eight lanes'
+// running sums down all 32 rows and never spills. Each 8x8 register block is
+// eight loads, eight adds along the chain, the same shuffle sequence
+// Transpose32x32Avx2 uses, and eight 32-byte stores across a row of the output.
+// The adds are the only addition to the transpose's instruction stream, and they
+// sit on the load-to-shuffle path rather than after it.
+//
+// The eight chains within a register are independent, so the dependency height
+// per block is 32 vpaddd, not 1024 as the wire format's serial chain would be.
+inline void PrefixSumAndTransposeAvx2(const uint32_t* ARROW_RESTRICT grid,
+                                      const uint32_t* ARROW_RESTRICT bases,
+                                      int32_t* ARROW_RESTRICT out) {
+  for (size_t lb = 0; lb < kLanes; lb += 8) {
+    // Lanes lb..lb+7 of the value that precedes each lane's run.
+    __m256i acc = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(bases + lb));
+    for (size_t rb = 0; rb < kRowsPerBlock; rb += 8) {
+      const uint32_t* src = grid + rb * kLanes + lb;
+      const __m256i r0 = _mm256_add_epi32(
+          acc, _mm256_loadu_si256(reinterpret_cast<const __m256i*>(src)));
+      const __m256i r1 = _mm256_add_epi32(
+          r0, _mm256_loadu_si256(reinterpret_cast<const __m256i*>(src + 1 * kLanes)));
+      const __m256i r2 = _mm256_add_epi32(
+          r1, _mm256_loadu_si256(reinterpret_cast<const __m256i*>(src + 2 * kLanes)));
+      const __m256i r3 = _mm256_add_epi32(
+          r2, _mm256_loadu_si256(reinterpret_cast<const __m256i*>(src + 3 * kLanes)));
+      const __m256i r4 = _mm256_add_epi32(
+          r3, _mm256_loadu_si256(reinterpret_cast<const __m256i*>(src + 4 * kLanes)));
+      const __m256i r5 = _mm256_add_epi32(
+          r4, _mm256_loadu_si256(reinterpret_cast<const __m256i*>(src + 5 * kLanes)));
+      const __m256i r6 = _mm256_add_epi32(
+          r5, _mm256_loadu_si256(reinterpret_cast<const __m256i*>(src + 6 * kLanes)));
+      const __m256i r7 = _mm256_add_epi32(
+          r6, _mm256_loadu_si256(reinterpret_cast<const __m256i*>(src + 7 * kLanes)));
+      acc = r7;
+
+      const __m256i t0 = _mm256_unpacklo_epi32(r0, r1);
+      const __m256i t1 = _mm256_unpackhi_epi32(r0, r1);
+      const __m256i t2 = _mm256_unpacklo_epi32(r2, r3);
+      const __m256i t3 = _mm256_unpackhi_epi32(r2, r3);
+      const __m256i t4 = _mm256_unpacklo_epi32(r4, r5);
+      const __m256i t5 = _mm256_unpackhi_epi32(r4, r5);
+      const __m256i t6 = _mm256_unpacklo_epi32(r6, r7);
+      const __m256i t7 = _mm256_unpackhi_epi32(r6, r7);
+
+      const __m256i u0 = _mm256_unpacklo_epi64(t0, t2);
+      const __m256i u1 = _mm256_unpackhi_epi64(t0, t2);
+      const __m256i u2 = _mm256_unpacklo_epi64(t1, t3);
+      const __m256i u3 = _mm256_unpackhi_epi64(t1, t3);
+      const __m256i u4 = _mm256_unpacklo_epi64(t4, t6);
+      const __m256i u5 = _mm256_unpackhi_epi64(t4, t6);
+      const __m256i u6 = _mm256_unpacklo_epi64(t5, t7);
+      const __m256i u7 = _mm256_unpackhi_epi64(t5, t7);
+
+      int32_t* dst = out + lb * kRowsPerBlock + rb;
+      _mm256_storeu_si256(reinterpret_cast<__m256i*>(dst + 0 * kRowsPerBlock),
+                          _mm256_permute2x128_si256(u0, u4, 0x20));
+      _mm256_storeu_si256(reinterpret_cast<__m256i*>(dst + 1 * kRowsPerBlock),
+                          _mm256_permute2x128_si256(u1, u5, 0x20));
+      _mm256_storeu_si256(reinterpret_cast<__m256i*>(dst + 2 * kRowsPerBlock),
+                          _mm256_permute2x128_si256(u2, u6, 0x20));
+      _mm256_storeu_si256(reinterpret_cast<__m256i*>(dst + 3 * kRowsPerBlock),
+                          _mm256_permute2x128_si256(u3, u7, 0x20));
+      _mm256_storeu_si256(reinterpret_cast<__m256i*>(dst + 4 * kRowsPerBlock),
+                          _mm256_permute2x128_si256(u0, u4, 0x31));
+      _mm256_storeu_si256(reinterpret_cast<__m256i*>(dst + 5 * kRowsPerBlock),
+                          _mm256_permute2x128_si256(u1, u5, 0x31));
+      _mm256_storeu_si256(reinterpret_cast<__m256i*>(dst + 6 * kRowsPerBlock),
+                          _mm256_permute2x128_si256(u2, u6, 0x31));
+      _mm256_storeu_si256(reinterpret_cast<__m256i*>(dst + 7 * kRowsPerBlock),
+                          _mm256_permute2x128_si256(u3, u7, 0x31));
+    }
+  }
+}
+#endif
+
+#ifdef ARROW_TRANSPOSED_DELTA_AVX2
+// ---------------------------------------------------------------------------
+// The same pass again, minus the grid.
+//
+// PrefixSumAndTransposeAvx2 reads a 4 KiB scratch block written by a separate
+// UnpackBlock call. Fuse the operations to avoid the intermediate stores and
+// loads.
+//
+// The fix is the same shape: r0..r7 come from internal::FlUnpackRowSlice instead
+// of from memory, so each packed word is read once and each output value written
+// once, and the block never exists. Nothing else changes -- the accumulator
+// still carries eight lanes' running sums down all 32 rows in one register, and
+// the shuffle sequence is still the one Transpose32x32Avx2 uses.
+//
+// kHasBias is true here rather than folded into the accumulator: the wire format
+// stores min-subtracted deltas, so every one of the 32 values in a lane's chain
+// owes the block minimum, not just the first.
+template <uint32_t w, uint32_t rb>
+ARROW_FORCE_INLINE __m256i UnpackPrefixSumTransposeTile(
+    const uint32_t* ARROW_RESTRICT packed, size_t lb, __m256i vmask, __m256i vbias,
+    __m256i acc, int32_t* ARROW_RESTRICT out) {
+  const __m256i r0 = _mm256_add_epi32(
+      acc, internal::FlUnpackRowSlice<w, true, rb + 0>(packed, lb, vmask, vbias));
+  const __m256i r1 = _mm256_add_epi32(
+      r0, internal::FlUnpackRowSlice<w, true, rb + 1>(packed, lb, vmask, vbias));
+  const __m256i r2 = _mm256_add_epi32(
+      r1, internal::FlUnpackRowSlice<w, true, rb + 2>(packed, lb, vmask, vbias));
+  const __m256i r3 = _mm256_add_epi32(
+      r2, internal::FlUnpackRowSlice<w, true, rb + 3>(packed, lb, vmask, vbias));
+  const __m256i r4 = _mm256_add_epi32(
+      r3, internal::FlUnpackRowSlice<w, true, rb + 4>(packed, lb, vmask, vbias));
+  const __m256i r5 = _mm256_add_epi32(
+      r4, internal::FlUnpackRowSlice<w, true, rb + 5>(packed, lb, vmask, vbias));
+  const __m256i r6 = _mm256_add_epi32(
+      r5, internal::FlUnpackRowSlice<w, true, rb + 6>(packed, lb, vmask, vbias));
+  const __m256i r7 = _mm256_add_epi32(
+      r6, internal::FlUnpackRowSlice<w, true, rb + 7>(packed, lb, vmask, vbias));
+
+  const __m256i t0 = _mm256_unpacklo_epi32(r0, r1);
+  const __m256i t1 = _mm256_unpackhi_epi32(r0, r1);
+  const __m256i t2 = _mm256_unpacklo_epi32(r2, r3);
+  const __m256i t3 = _mm256_unpackhi_epi32(r2, r3);
+  const __m256i t4 = _mm256_unpacklo_epi32(r4, r5);
+  const __m256i t5 = _mm256_unpackhi_epi32(r4, r5);
+  const __m256i t6 = _mm256_unpacklo_epi32(r6, r7);
+  const __m256i t7 = _mm256_unpackhi_epi32(r6, r7);
+
+  const __m256i u0 = _mm256_unpacklo_epi64(t0, t2);
+  const __m256i u1 = _mm256_unpackhi_epi64(t0, t2);
+  const __m256i u2 = _mm256_unpacklo_epi64(t1, t3);
+  const __m256i u3 = _mm256_unpackhi_epi64(t1, t3);
+  const __m256i u4 = _mm256_unpacklo_epi64(t4, t6);
+  const __m256i u5 = _mm256_unpackhi_epi64(t4, t6);
+  const __m256i u6 = _mm256_unpacklo_epi64(t5, t7);
+  const __m256i u7 = _mm256_unpackhi_epi64(t5, t7);
+
+  int32_t* dst = out + lb * kRowsPerBlock + rb;
+  _mm256_storeu_si256(reinterpret_cast<__m256i*>(dst + 0 * kRowsPerBlock),
+                      _mm256_permute2x128_si256(u0, u4, 0x20));
+  _mm256_storeu_si256(reinterpret_cast<__m256i*>(dst + 1 * kRowsPerBlock),
+                      _mm256_permute2x128_si256(u1, u5, 0x20));
+  _mm256_storeu_si256(reinterpret_cast<__m256i*>(dst + 2 * kRowsPerBlock),
+                      _mm256_permute2x128_si256(u2, u6, 0x20));
+  _mm256_storeu_si256(reinterpret_cast<__m256i*>(dst + 3 * kRowsPerBlock),
+                      _mm256_permute2x128_si256(u3, u7, 0x20));
+  _mm256_storeu_si256(reinterpret_cast<__m256i*>(dst + 4 * kRowsPerBlock),
+                      _mm256_permute2x128_si256(u0, u4, 0x31));
+  _mm256_storeu_si256(reinterpret_cast<__m256i*>(dst + 5 * kRowsPerBlock),
+                      _mm256_permute2x128_si256(u1, u5, 0x31));
+  _mm256_storeu_si256(reinterpret_cast<__m256i*>(dst + 6 * kRowsPerBlock),
+                      _mm256_permute2x128_si256(u2, u6, 0x31));
+  _mm256_storeu_si256(reinterpret_cast<__m256i*>(dst + 7 * kRowsPerBlock),
+                      _mm256_permute2x128_si256(u3, u7, 0x31));
+  return r7;
+}
+
+// Unpack, prefix sum and permute one 1024-value block without materializing it.
+// lb outer for the same reason as the kernel above: a fixed lb writes the
+// contiguous 1 KB run out[lb * 32, lb * 32 + 256).
+template <uint32_t w>
+inline void UnpackPrefixSumAndTransposeAvx2(const uint32_t* ARROW_RESTRICT packed,
+                                            const uint32_t* ARROW_RESTRICT bases,
+                                            uint32_t bias, int32_t* ARROW_RESTRICT out) {
+  constexpr uint32_t kMask = (w == 32) ? 0xFFFFFFFFu : ((1u << w) - 1);
+  const __m256i vmask = _mm256_set1_epi32(static_cast<int>(kMask));
+  const __m256i vbias = _mm256_set1_epi32(static_cast<int>(bias));
+  for (size_t lb = 0; lb < kLanes; lb += 8) {
+    __m256i acc = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(bases + lb));
+    acc = UnpackPrefixSumTransposeTile<w, 0>(packed, lb, vmask, vbias, acc, out);
+    acc = UnpackPrefixSumTransposeTile<w, 8>(packed, lb, vmask, vbias, acc, out);
+    acc = UnpackPrefixSumTransposeTile<w, 16>(packed, lb, vmask, vbias, acc, out);
+    acc = UnpackPrefixSumTransposeTile<w, 24>(packed, lb, vmask, vbias, acc, out);
+  }
+}
+#  define ARROW_TRANSPOSED_DELTA_FUSED_UNPACK 1
+#endif  // ARROW_TRANSPOSED_DELTA_AVX2
+
+#if defined(ARROW_TRANSPOSED_DELTA_NEON) || defined(ARROW_TRANSPOSED_DELTA_AVX2)
+// Defined only when a fused kernel exists, so the decode below selects kFused
+// on capability rather than on architecture. A target with neither still falls
+// back to kSeparate, but now visibly.
+#  define ARROW_TRANSPOSED_DELTA_FUSED_REPAIR 1
+inline void PrefixSumAndTranspose(const uint32_t* ARROW_RESTRICT grid,
+                                  const uint32_t* ARROW_RESTRICT bases,
+                                  int32_t* ARROW_RESTRICT out) {
+#  ifdef ARROW_TRANSPOSED_DELTA_NEON
+  PrefixSumAndTransposeNeon(grid, bases, out);
+#  else
+  PrefixSumAndTransposeAvx2(grid, bases, out);
+#  endif
+}
+#endif
+
 // kRepair off leaves the block in transposed order, which isolates the cost of
 // the transpose from the rest of the decode. Only kRepair on is a conforming
 // Parquet decoder.
@@ -438,6 +763,17 @@ inline void TransposedDeltaDecode(const uint8_t* in, size_t n, int32_t* out) {
     } else {
       cur += (4 - (static_cast<size_t>(cur - in) & 3)) & 3;
       const uint32_t* src = reinterpret_cast<const uint32_t*>(cur);
+#ifdef ARROW_TRANSPOSED_DELTA_FUSED_UNPACK
+      if constexpr (kRepair == TransposedRepair::kFusedUnpack) {
+        switch (w) {
+          TPOSE_WIDTH_CASES(TPOSE_FUSED_UNPACK_CASE)
+          default:
+            break;
+        }
+        cur += w * kLanes * sizeof(uint32_t);
+        continue;
+      }
+#endif
       switch (w) {
         TPOSE_WIDTH_CASES(TPOSE_UNPACK_CASE)
         default:
@@ -446,8 +782,11 @@ inline void TransposedDeltaDecode(const uint8_t* in, size_t n, int32_t* out) {
       cur += w * kLanes * sizeof(uint32_t);
     }
 
-#ifdef ARROW_TRANSPOSED_DELTA_NEON
-    if constexpr (kRepair == TransposedRepair::kFused) {
+    // w == 0 falls through to here even under kFusedUnpack: the block is a
+    // constant delta, so there is no bit-unpack to fuse anything into.
+#ifdef ARROW_TRANSPOSED_DELTA_FUSED_REPAIR
+    if constexpr (kRepair == TransposedRepair::kFused ||
+                  kRepair == TransposedRepair::kFusedUnpack) {
       PrefixSumAndTranspose(grid, bases, out + b * kBlockSize);
       continue;
     }
@@ -480,6 +819,7 @@ inline void TransposedDeltaDecode(const uint8_t* in, size_t n, int32_t* out) {
 
 #undef TPOSE_PACK_CASE
 #undef TPOSE_UNPACK_CASE
+#undef TPOSE_FUSED_UNPACK_CASE
 #undef TPOSE_WIDTH_CASES
 
 }  // namespace fastlanes
diff --git a/cpp/src/arrow/util/fastlanes/transposed_delta_wrapper_internal.h b/cpp/src/arrow/util/fastlanes/transposed_delta_wrapper_internal.h
index a1d3bc59d0bf..2788bbb46240 100644
--- a/cpp/src/arrow/util/fastlanes/transposed_delta_wrapper_internal.h
+++ b/cpp/src/arrow/util/fastlanes/transposed_delta_wrapper_internal.h
@@ -71,9 +71,9 @@ class TransposedDeltaWrapper<int32_t> {
   /// per value against 1 bit for storing them plainly.
   static constexpr TransposedBaseCoding kBases = TransposedBaseCoding::kPacked;
 
-  /// A conforming decoder has to return file order, and doing that in the same
-  /// pass as the prefix sums is free.
-  static constexpr TransposedRepair kRepair = TransposedRepair::kFused;
+  /// Restore file order in the same pass as the prefix sums and bit unpacking
+  /// to avoid writing and reading a 4 KiB scratch block.
+  static constexpr TransposedRepair kRepair = TransposedRepair::kFusedUnpack;
 
   /// \brief Upper bound on the bytes Encode writes for `num_values` values
   static int64_t GetMaxCompressedSize(int32_t num_values) {
diff --git a/cpp/src/parquet/pfor_comparison_benchmark.cc b/cpp/src/parquet/pfor_comparison_benchmark.cc
index 50fa068cfc6f..dd8c39f714b6 100644
--- a/cpp/src/parquet/pfor_comparison_benchmark.cc
+++ b/cpp/src/parquet/pfor_comparison_benchmark.cc
@@ -28,6 +28,7 @@
 #include <bit>
 #include <cmath>
 #include <cstdint>
+#include <cstdlib>
 #include <cstring>
 #include <memory>
 #include <numeric>
@@ -769,6 +770,32 @@ static void PforEncodeImpl(benchmark::State& state, GenT<T> gen,
   state.counters["compression_ratio"] =
       static_cast<double>(uncompressed_size) / static_cast<double>(comp_size);
 }
+
+// ---------------------------------------------------------------------------
+// One process-wide, 4096-aligned output buffer shared by every decode arm.
+//
+// Output-buffer placement can affect decoder measurements. Sharing one aligned
+// buffer ensures that every variant writes to the same addresses, isolating
+// differences in decoder code.
+//
+// Safe to share: benchmarks in a process run one at a time, and every arm
+// overwrites the whole buffer before reading it back.
+// ---------------------------------------------------------------------------
+template <typename T>
+T* SharedDecodeBuffer(int64_t num_values) {
+  static void* raw = nullptr;
+  static size_t cap = 0;
+  const size_t want = static_cast<size_t>(num_values) * sizeof(T);
+  if (want > cap) {
+    std::free(raw);
+    raw = nullptr;
+    if (posix_memalign(&raw, 4096, want + 4096) != 0) std::abort();
+    cap = want;
+  }
+  std::memset(raw, 0, want);
+  return static_cast<T*>(raw);
+}
+
 static void BM_PforEncode(benchmark::State& state, Gen32 gen) {
   PforEncodeImpl<int32_t>(state, gen);
 }
@@ -798,13 +825,17 @@ static void PforDecodeImpl(benchmark::State& state, GenT<T> gen,
       values.data(), static_cast<int32_t>(num_values), compressed.data(), &comp_size,
       options));
 
-  std::vector<T> decoded(num_values);
+  T* decoded = SharedDecodeBuffer<T>(num_values);
   for (auto _ : state) {
     auto status = ::arrow::util::pfor::PforWrapper<T>::Decode(
-        compressed.data(), comp_size, static_cast<int32_t>(num_values), decoded.data());
+        compressed.data(), comp_size, static_cast<int32_t>(num_values), decoded);
     ARROW_CHECK_OK(status);
     benchmark::ClobberMemory();
   }
+  // The interleaved arms assert their round trip; this one did not, so a plan
+  // change silently producing wrong values would have read as a speedup.
+  ARROW_CHECK(std::equal(decoded, decoded + num_values, values.begin()))
+      << "pfor round trip failed";
 
   state.SetBytesProcessed(state.iterations() * uncompressed_size);
   state.SetItemsProcessed(state.iterations() * num_values);
@@ -1016,13 +1047,13 @@ static void DeltaBitPackDecodeImpl(benchmark::State& state, GenT<T> gen) {
   auto buf = encoder->FlushValues();
   int64_t comp_size = buf->size();
 
-  std::vector<T> decoded(num_values);
+  T* decoded = SharedDecodeBuffer<T>(num_values);
   auto decoder = MakeTypedDecoder<PType>(Encoding::DELTA_BINARY_PACKED);
 
   for (auto _ : state) {
     decoder->SetData(static_cast<int>(num_values), buf->data(),
                      static_cast<int>(buf->size()));
-    decoder->Decode(decoded.data(), static_cast<int>(num_values));
+    decoder->Decode(decoded, static_cast<int>(num_values));
     benchmark::ClobberMemory();
   }
 
@@ -1916,14 +1947,14 @@ static void BM_LaneDeltaDecode(benchmark::State& state, Gen32 gen) {
       values.data(), num_values, buf.data());
   ARROW_CHECK_GT(comp_size, 0);
 
-  std::vector<int32_t> decoded(num_values);
-  fl::LaneDeltaDecode<fl::LaneDeltaOrder::kInterleaved>(buf.data(), num_values,
-                                                        decoded.data());
-  ARROW_CHECK(decoded == values) << "lane delta round trip failed";
+  int32_t* decoded = SharedDecodeBuffer<int32_t>(num_values);
+  fl::LaneDeltaDecode<fl::LaneDeltaOrder::kInterleaved>(buf.data(), num_values, decoded);
+  ARROW_CHECK(std::equal(decoded, decoded + num_values, values.begin()))
+      << "lane delta round trip failed";
 
   for (auto _ : state) {
     fl::LaneDeltaDecode<fl::LaneDeltaOrder::kInterleaved>(buf.data(), num_values,
-                                                          decoded.data());
+                                                          decoded);
     benchmark::ClobberMemory();
   }
   state.SetBytesProcessed(state.iterations() * uncompressed_size);
@@ -1956,18 +1987,19 @@ static void BM_TposeApiDecode(benchmark::State& state, Gen32 gen) {
   auto buf = encoder->FlushValues();
   const int64_t comp_size = buf->size();
 
-  std::vector<int32_t> decoded(num_values);
+  int32_t* decoded = SharedDecodeBuffer<int32_t>(num_values);
   auto decoder = MakeTypedDecoder<Int32Type>(Encoding::LANE_DELTA);
   decoder->SetData(static_cast<int>(num_values), buf->data(),
                    static_cast<int>(buf->size()));
-  ARROW_CHECK_EQ(decoder->Decode(decoded.data(), static_cast<int>(num_values)),
+  ARROW_CHECK_EQ(decoder->Decode(decoded, static_cast<int>(num_values)),
                  static_cast<int>(num_values));
-  ARROW_CHECK(decoded == values) << "lane delta decoder round trip failed";
+  ARROW_CHECK(std::equal(decoded, decoded + num_values, values.begin()))
+      << "lane delta decoder round trip failed";
 
   for (auto _ : state) {
     decoder->SetData(static_cast<int>(num_values), buf->data(),
                      static_cast<int>(buf->size()));
-    decoder->Decode(decoded.data(), static_cast<int>(num_values));
+    decoder->Decode(decoded, static_cast<int>(num_values));
     benchmark::ClobberMemory();
   }
   state.SetBytesProcessed(state.iterations() * uncompressed_size);
@@ -2020,17 +2052,19 @@ static void TposeDecodeImpl(benchmark::State& state, Gen32 gen) {
       fl::TransposedDeltaEncode<kBases>(values.data(), num_values, buf.data());
   ARROW_CHECK_GT(comp_size, 0);
 
-  std::vector<int32_t> decoded(num_values);
-  fl::TransposedDeltaDecode<kBases, kRepair>(buf.data(), num_values, decoded.data());
+  int32_t* decoded = SharedDecodeBuffer<int32_t>(num_values);
+  fl::TransposedDeltaDecode<kBases, kRepair>(buf.data(), num_values, decoded);
   if constexpr (kRepair != TransposedRepair::kNone) {
-    ARROW_CHECK(decoded == values) << "transposed delta round trip failed";
+    ARROW_CHECK(std::equal(decoded, decoded + num_values, values.begin()))
+        << "transposed delta round trip failed";
   } else {
-    ARROW_CHECK(decoded == TransposeReference(values))
+    ARROW_CHECK(
+        std::equal(decoded, decoded + num_values, TransposeReference(values).begin()))
         << "transposed delta round trip failed in transposed order";
   }
 
   for (auto _ : state) {
-    fl::TransposedDeltaDecode<kBases, kRepair>(buf.data(), num_values, decoded.data());
+    fl::TransposedDeltaDecode<kBases, kRepair>(buf.data(), num_values, decoded);
     benchmark::ClobberMemory();
   }
   state.SetBytesProcessed(state.iterations() * uncompressed_size);
@@ -2049,6 +2083,12 @@ static void BM_TposePackedDecode(benchmark::State& state, Gen32 gen) {
 static void BM_TposeFusedDecode(benchmark::State& state, Gen32 gen) {
   TposeDecodeImpl<TransposedBaseCoding::kPacked, TransposedRepair::kFused>(state, gen);
 }
+// Also conforming, and the one the wrapper ships: the bit-unpack is folded in
+// too, so the 4 KB scratch block kFused still round-trips never exists.
+static void BM_TposeFusedUnpackDecode(benchmark::State& state, Gen32 gen) {
+  TposeDecodeImpl<TransposedBaseCoding::kPacked, TransposedRepair::kFusedUnpack>(state,
+                                                                                 gen);
+}
 // Neither of these is a conforming decoder: they leave the block transposed.
 // Raw-vs-Packed at fixed repair isolates the base stream, and NoRepair-vs-not at
 // fixed base coding isolates the 32x32 transpose.
@@ -2086,12 +2126,31 @@ static void InterleavedPforDecodeImpl(benchmark::State& state, Gen32 gen) {
       fl::InterleavedPforEncode<kOrder>(values.data(), num_values, buf.data());
   ARROW_CHECK_GT(comp_size, 0);
 
-  std::vector<int32_t> decoded(num_values);
-  fl::InterleavedPforDecode<kOrder>(buf.data(), num_values, decoded.data());
-  ARROW_CHECK(decoded == values) << "interleaved pfor round trip failed";
+  // kFlOrderRaw deliberately returns the FastLanes order, so its expectation is
+  // the permuted input rather than the input. Checking it against the same
+  // permutation the encoder applied is what keeps this arm honest: without it,
+  // an arm that skipped work entirely would also "pass".
+  std::vector<int32_t> expect = values;
+  if constexpr (kOrder == InterleavedPforOrder::kFlOrderRaw) {
+    const int64_t nblocks = num_values / 1024;
+    for (int64_t b = 0; b < nblocks; ++b) {
+      const int32_t* src = values.data() + b * 1024;
+      int32_t* dst = expect.data() + b * 1024;
+      for (int64_t lane = 0; lane < 32; ++lane) {
+        for (int64_t row = 0; row < 32; ++row) {
+          dst[row * 32 + lane] = src[lane * 32 + row];
+        }
+      }
+    }
+  }
+
+  int32_t* decoded = SharedDecodeBuffer<int32_t>(num_values);
+  fl::InterleavedPforDecode<kOrder>(buf.data(), num_values, decoded);
+  ARROW_CHECK(std::equal(decoded, decoded + num_values, expect.begin()))
+      << "interleaved pfor round trip failed";
 
   for (auto _ : state) {
-    fl::InterleavedPforDecode<kOrder>(buf.data(), num_values, decoded.data());
+    fl::InterleavedPforDecode<kOrder>(buf.data(), num_values, decoded);
     benchmark::ClobberMemory();
   }
   state.SetBytesProcessed(state.iterations() * uncompressed_size);
@@ -2099,9 +2158,27 @@ static void InterleavedPforDecodeImpl(benchmark::State& state, Gen32 gen) {
   state.counters["compression_ratio"] =
       static_cast<double>(uncompressed_size) / static_cast<double>(comp_size);
 }
+// The three arms below answer the value-ordering question and only that one.
+// They run arrow/util/fastlanes/interleaved_pfor.h, which has no exception
+// handling: no patch list on the wire, no patch pass in the decoder. Dividing
+// one of them by a production arm therefore charges the production side for work
+// these never do, and the quotient is not the layout. The layout question has
+// its own pair above -- BM_PforPlainSeqDecode and BM_PforPlainInterleavedDecode,
+// same production encoder and decoder, differing only in PackingMode.
+// BM_InterleavedPforDecode is the file-order control the other two are read
+// against; it is not a second interleaved-layout arm.
 static void BM_InterleavedPforDecode(benchmark::State& state, Gen32 gen) {
   InterleavedPforDecodeImpl<InterleavedPforOrder::kFileOrder>(state, gen);
 }
+// Same wire bytes as BM_InterleavedPforFlOrderDecode, but the FastLanes order is
+// handed to the caller unchanged. It runs the identical PackBlock/UnpackBlock
+// pair as BM_InterleavedPforDecode against a grid that was merely filled
+// differently at encode time, so it must measure equal to it -- the arm exists
+// to separate "FL_ORDER's bit-packing is cheaper" (it is not, it is identical)
+// from "FL_ORDER's permutation costs something" (it does).
+static void BM_InterleavedPforFlOrderRawDecode(benchmark::State& state, Gen32 gen) {
+  InterleavedPforDecodeImpl<InterleavedPforOrder::kFlOrderRaw>(state, gen);
+}
 static void BM_InterleavedPforFlOrderDecode(benchmark::State& state, Gen32 gen) {
   InterleavedPforDecodeImpl<InterleavedPforOrder::kFlOrder>(state, gen);
 }
@@ -2145,6 +2222,41 @@ static void BM_TposePackedEncode(benchmark::State& state, Gen32 gen) {
 
 static void CustomArgs(benchmark::internal::Benchmark* b) { b->Arg(102400); }
 
+// The four layout-comparison arms sweep the working set; everything else stays
+// at the single 102400 point so the suite does not get five times longer for no
+// gain. The four that sweep are the ones a layout verdict is read from:
+//
+//   BM_PforPlainSeqDecode              continuous layout, delta declined
+//                                        -- THE BASELINE
+//   BM_InterleavedPforDecode           interleaved grid, file order out
+//                                        -- CONTROL, not shippable
+//   BM_InterleavedPforFlOrderRawDecode FL_ORDER grid, permutation not charged
+//                                        -- CONTROL, not shippable
+//   BM_InterleavedPforFlOrderDecode    FL_ORDER grid -> file order, fused
+//                                        -- THE CANDIDATE
+//
+// All four must sweep together or the comparison is unreadable. Measured at one
+// working-set size the two controls and the candidate cannot be separated: the
+// grid's advantage is a compute effect that only exists while the working set is
+// small enough that stores are not the limit, so a single mid-size point shows a
+// grid that looks barely better than continuous and hides both the size of the
+// win and the size of the permutation tax that cancels it.
+//
+// The sizes are chosen against a real cache hierarchy and against what a decoder
+// holds. Unpacking expands packed bytes by 32/W, so a ~300 KB integer column
+// chunk decodes to 300 KB at W=32 and 2.4 MB at W=4: the realistic span is ~300
+// KB to ~2.4 MB, which 102400 alone (400 KiB) sits at the bottom of. On a
+// machine with 2 MiB of L2 per core and 36 MiB of shared L3 the decay in the
+// layout advantage begins inside L2, well before any memory boundary, so points
+// either side of the L2 capacity are the ones that carry information.
+static void LayoutArgs(benchmark::internal::Benchmark* b) {
+  b->Arg(4096)         //  16 KiB out -- L1-resident
+      ->Arg(102400)    // 400 KiB out -- the historical point; low end of realistic
+      ->Arg(393216)    // 1.5 MiB out -- still inside a 2 MiB L2; top of realistic
+      ->Arg(1048576)   //   4 MiB out -- spilled L2
+      ->Arg(8388608);  //  32 MiB out -- at shared L3 capacity, not DRAM
+}
+
 // Macro to register all algorithms for a given dataset
 #define REGISTER_DATASET(Name, GenFunc)                                                  \
   BENCHMARK_CAPTURE(BM_PforEncode, Name, &GenFunc)->Apply(CustomArgs);                   \
@@ -2154,8 +2266,8 @@ static void CustomArgs(benchmark::internal::Benchmark* b) { b->Arg(102400); }
   BENCHMARK_CAPTURE(BM_PforPatchedDeltaDecode, Name, &GenFunc)->Apply(CustomArgs);       \
   BENCHMARK_CAPTURE(BM_PforDbpDeltaEncode, Name, &GenFunc)->Apply(CustomArgs);           \
   BENCHMARK_CAPTURE(BM_PforDbpDeltaDecode, Name, &GenFunc)->Apply(CustomArgs);           \
-  BENCHMARK_CAPTURE(BM_PforPlainSeqDecode, Name, &GenFunc)->Apply(CustomArgs);           \
-  BENCHMARK_CAPTURE(BM_PforPlainInterleavedDecode, Name, &GenFunc)->Apply(CustomArgs);   \
+  BENCHMARK_CAPTURE(BM_PforPlainSeqDecode, Name, &GenFunc)->Apply(LayoutArgs);           \
+  BENCHMARK_CAPTURE(BM_PforPlainInterleavedDecode, Name, &GenFunc)->Apply(LayoutArgs);   \
   BENCHMARK_CAPTURE(BM_DeltaBitPackEncode, Name, &GenFunc)->Apply(CustomArgs);           \
   BENCHMARK_CAPTURE(BM_DeltaBitPackDecode, Name, &GenFunc)->Apply(CustomArgs);           \
   BENCHMARK_CAPTURE(BM_DbpAbFull, Name, &GenFunc)->Apply(CustomArgs);                    \
@@ -2171,14 +2283,17 @@ static void CustomArgs(benchmark::internal::Benchmark* b) { b->Arg(102400); }
   BENCHMARK_CAPTURE(BM_DbpGeom1024x32, Name, &GenFunc)->Apply(CustomArgs);               \
   BENCHMARK_CAPTURE(BM_DbpGeom1024x8, Name, &GenFunc)->Apply(CustomArgs);                \
   BENCHMARK_CAPTURE(BM_DbpGeom1024x1, Name, &GenFunc)->Apply(CustomArgs);                \
-  BENCHMARK_CAPTURE(BM_InterleavedPforDecode, Name, &GenFunc)->Apply(CustomArgs);        \
-  BENCHMARK_CAPTURE(BM_InterleavedPforFlOrderDecode, Name, &GenFunc)->Apply(CustomArgs); \
+  BENCHMARK_CAPTURE(BM_InterleavedPforDecode, Name, &GenFunc)->Apply(LayoutArgs);        \
+  BENCHMARK_CAPTURE(BM_InterleavedPforFlOrderRawDecode, Name, &GenFunc)                  \
+      ->Apply(LayoutArgs);                                                               \
+  BENCHMARK_CAPTURE(BM_InterleavedPforFlOrderDecode, Name, &GenFunc)->Apply(LayoutArgs); \
   BENCHMARK_CAPTURE(BM_LaneDeltaDecode, Name, &GenFunc)->Apply(CustomArgs);              \
   BENCHMARK_CAPTURE(BM_TposeApiDecode, Name, &GenFunc)->Apply(CustomArgs);               \
   BENCHMARK_CAPTURE(BM_TposeApiEncode, Name, &GenFunc)->Apply(CustomArgs);               \
   BENCHMARK_CAPTURE(BM_TposeRawDecode, Name, &GenFunc)->Apply(CustomArgs);               \
   BENCHMARK_CAPTURE(BM_TposePackedDecode, Name, &GenFunc)->Apply(CustomArgs);            \
   BENCHMARK_CAPTURE(BM_TposeFusedDecode, Name, &GenFunc)->Apply(CustomArgs);             \
+  BENCHMARK_CAPTURE(BM_TposeFusedUnpackDecode, Name, &GenFunc)->Apply(CustomArgs);       \
   BENCHMARK_CAPTURE(BM_TposeNoRepairDecode, Name, &GenFunc)->Apply(CustomArgs);          \
   BENCHMARK_CAPTURE(BM_TposeRawNoRepairDecode, Name, &GenFunc)->Apply(CustomArgs);       \
   BENCHMARK_CAPTURE(BM_LaneDeltaEncode, Name, &GenFunc)->Apply(CustomArgs);              \

From 5d0f349412d163bceb674a7c1ce0193b0ee0a2b0 Mon Sep 17 00:00:00 2001
From: Prateek Gaur <prateek.gaur@snowflake.com>
Date: Wed, 16 Sep 2026 23:00:35 +0000
Subject: [PATCH 22/27] Dispatch interleaved kernels by ISA

The baseline and vectorized kernel tables are compiled in separate files
and picked at run time through Arrow's dispatch. The kernels take the
architecture as a template parameter, so the two compiled copies have
different symbols and do not collide at link time.
---
 cpp/src/arrow/CMakeLists.txt                  | 23 +++++
 .../fastlanes/fastlanes_kernels_internal.h    | 34 ++++---
 .../fastlanes/interleaved_dispatch_internal.h | 69 ++++++++++++++
 .../interleaved_kernel_table_internal.h       | 92 +++++++++++++++++++
 .../arrow/util/fastlanes/interleaved_pfor.h   | 77 ++++++----------
 .../fastlanes/interleaved_pfor_baseline.cc    | 41 +++++++++
 .../util/fastlanes/interleaved_pfor_simd.cc   | 57 ++++++++++++
 cpp/src/arrow/util/pfor/pfor.cc               | 69 ++++++++------
 8 files changed, 371 insertions(+), 91 deletions(-)
 create mode 100644 cpp/src/arrow/util/fastlanes/interleaved_dispatch_internal.h
 create mode 100644 cpp/src/arrow/util/fastlanes/interleaved_kernel_table_internal.h
 create mode 100644 cpp/src/arrow/util/fastlanes/interleaved_pfor_baseline.cc
 create mode 100644 cpp/src/arrow/util/fastlanes/interleaved_pfor_simd.cc

diff --git a/cpp/src/arrow/CMakeLists.txt b/cpp/src/arrow/CMakeLists.txt
index 0a239e893258..6e4e90973456 100644
--- a/cpp/src/arrow/CMakeLists.txt
+++ b/cpp/src/arrow/CMakeLists.txt
@@ -551,6 +551,7 @@ set(ARROW_UTIL_SRCS
     util/decimal.cc
     util/delimiting.cc
     util/dict_util.cc
+    util/fastlanes/interleaved_pfor_baseline.cc
     util/fixed_width_internal.cc
     util/float16.cc
     util/formatting.cc
@@ -593,6 +594,28 @@ append_runtime_avx512_src(ARROW_UTIL_SRCS util/bpacking_simd_avx512.cc)
 append_runtime_sve128_src(ARROW_UTIL_SRCS util/bpacking_simd_128_alt.cc)
 append_runtime_sve256_src(ARROW_UTIL_SRCS util/bpacking_simd_256.cc)
 
+# One source compiled once per instruction set, the way bpacking_simd_256.cc is
+# registered for both AVX2 and SVE256 above: the file forks on the platform
+# macros, and only one of them is ever defined on a given target.
+append_runtime_avx2_src(ARROW_UTIL_SRCS util/fastlanes/interleaved_pfor_simd.cc)
+append_runtime_sve128_src(ARROW_UTIL_SRCS util/fastlanes/interleaved_pfor_simd.cc)
+
+# The interleaved kernels are portable C++ with no intrinsics, so what they
+# compile to is decided by the optimizer, not by the source. At width 16 gcc 11.5
+# emits 289 instructions and no vector operations at -O2, 322 with 81 vector
+# operations at Release's -O2 -ftree-vectorize, and 849 with 513 at -O3; the
+# published throughput figures for this layout were all taken at the last of
+# those. APPEND rather than a plain set, because the two calls above have already
+# put the instruction-set flags in this property. Release only -- Debug and the
+# sanitizer builds want their own level, and MSVC spells this differently.
+if(NOT MSVC)
+  set_property(SOURCE util/fastlanes/interleaved_pfor_baseline.cc
+                      util/fastlanes/interleaved_pfor_simd.cc
+               APPEND
+               PROPERTY COMPILE_OPTIONS
+                        "$<$<OR:$<CONFIG:Release>,$<CONFIG:RelWithDebInfo>>:-O3>")
+endif()
+
 if(ARROW_WITH_BROTLI)
   list(APPEND ARROW_UTIL_SRCS util/compression_brotli.cc)
 endif()
diff --git a/cpp/src/arrow/util/fastlanes/fastlanes_kernels_internal.h b/cpp/src/arrow/util/fastlanes/fastlanes_kernels_internal.h
index b9df86d12043..ae531e04edf2 100644
--- a/cpp/src/arrow/util/fastlanes/fastlanes_kernels_internal.h
+++ b/cpp/src/arrow/util/fastlanes/fastlanes_kernels_internal.h
@@ -47,10 +47,19 @@
 // successive rows of one lane here, successive values of the stream in
 // arrow::internal::unpack -- not in how the bits of a value are laid out. That
 // is why the shift and the straddle depend on the row and never on the lane,
-// and so why all 32 lanes do identical work.
+// and so why all 32 lanes do identical work. The payload is byte-identical in
+// size to the sequential layout for a full block: 128 * w bytes.
 //
-// The payload is byte-identical in size to the sequential layout for a full
-// block: 1024 * w bits either way, or 128 * w bytes.
+// Both kernels take an Arch type parameter their bodies never mention, so that
+// this one source compiled at two different instruction sets yields two
+// distinct symbols. Without it, PackBlock<16> compiled with NEON flags and
+// PackBlock<16> compiled with SVE flags share a mangled name, the linker keeps
+// one definition, and every caller silently gets whichever copy it kept --
+// undoing the per-instruction-set translation units of
+// interleaved_dispatch_internal.h with no diagnostic.
+// arrow::internal::bpacking carries the parameter for the same reason. A caller
+// that compiles exactly one copy of these kernels leaves it at its default and
+// is unaffected.
 
 #pragma once
 
@@ -74,7 +83,7 @@ static_assert(kLanes * kRowsPerBlock == kBlockSize,
 // ---------------------------------------------------------------------------
 // Pack: 1024 u32 inputs, in input order -> w*32 u32 packed words.
 // ---------------------------------------------------------------------------
-template <uint32_t w>
+template <uint32_t w, typename Arch = void>
 inline void PackBlock(const uint32_t* ARROW_RESTRICT in, uint32_t* ARROW_RESTRICT out) {
   static_assert(w >= 1 && w <= 32);
   constexpr uint32_t kMask = (w == 32) ? 0xFFFFFFFFu : ((1u << w) - 1);
@@ -117,16 +126,15 @@ inline void PackBlock(const uint32_t* ARROW_RESTRICT in, uint32_t* ARROW_RESTRIC
 // Unpack: w*32 packed u32 words -> 1024 u32 outputs in input order.
 //
 // With kHasBias, `bias` is added to every value before it is stored, so a
-// frame-of-reference decoder does not need a second pass over the output to
-// add it. That pass is not cheap: measured against the unpack it follows, it
-// costs 1.47x-2.40x, and a pass that only copies costs the same as one that
-// adds, so what is paid for is the traversal rather than the arithmetic. The
-// add is modular in uint32_t, matching the encoder's subtraction.
-//
-// kHasBias is a template parameter rather than a runtime argument so that the
-// no-bias instantiations carry no test in their inner loop.
+// frame-of-reference decoder does not need a second pass over the output to add
+// it. That pass costs 1.47x-2.40x of the unpack it follows, and a pass that
+// only copies costs the same as one that adds, so what is paid for is the
+// traversal rather than the arithmetic. The add is modular in uint32_t,
+// matching the encoder's subtraction. kHasBias is a template parameter rather
+// than a runtime argument so the no-bias instantiations carry no test in their
+// inner loop.
 // ---------------------------------------------------------------------------
-template <uint32_t w, bool kHasBias = false>
+template <uint32_t w, bool kHasBias = false, typename Arch = void>
 inline void UnpackBlock(const uint32_t* ARROW_RESTRICT packed,
                         uint32_t* ARROW_RESTRICT out, uint32_t bias = 0) {
   static_assert(w >= 1 && w <= 32);
diff --git a/cpp/src/arrow/util/fastlanes/interleaved_dispatch_internal.h b/cpp/src/arrow/util/fastlanes/interleaved_dispatch_internal.h
new file mode 100644
index 000000000000..c4000f9ada6e
--- /dev/null
+++ b/cpp/src/arrow/util/fastlanes/interleaved_dispatch_internal.h
@@ -0,0 +1,69 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+// Runtime bit-width dispatch for the lane-interleaved kernels.
+//
+// The kernels in fastlanes_kernels_internal.h are intrinsic-free C++ templated
+// on the bit width, so one compiled copy is pinned to the instruction set of
+// the translation unit that compiled it. They are therefore compiled once per
+// instruction set, and this file declares the entry point each of those units
+// exports. arrow::internal::DynamicDispatch in pfor/pfor.cc picks between them,
+// so ARROW_USER_SIMD_LEVEL reaches these kernels like it reaches the rest of
+// Arrow's SIMD code; before this existed, ARROW_SIMD_LEVEL alone fixed their
+// width, and a default x86 build ran the interleaved kernel in XMM registers
+// while the sequential unpacker it is compared against dispatched to AVX2.
+//
+// Each entry point takes the bit width as a runtime argument and resolves it
+// against a table its own translation unit builds; see
+// interleaved_kernel_table_internal.h.
+
+#pragma once
+
+#include <cstdint>
+
+namespace arrow {
+namespace util {
+namespace fastlanes {
+
+// What the per-width tables hold.
+using InterleavedPackFn = void (*)(const uint32_t*, uint32_t*);
+using InterleavedUnpackFn = void (*)(const uint32_t*, uint32_t*, uint32_t);
+
+// Compiled at whatever instruction set the build's own flags name. This is the
+// dispatch fallback and the only leg guaranteed to exist, since a build can be
+// configured with no SIMD level at all.
+void InterleavedPackBlockBaseline(uint8_t bit_width, const uint32_t* in, uint32_t* out);
+void InterleavedUnpackBlockBaseline(uint8_t bit_width, const uint32_t* packed,
+                                    uint32_t* out, uint32_t bias);
+
+// The vector legs, each declared under exactly the condition CMake uses to
+// compile it: a build that never compiles a leg must not name one either.
+#if defined(ARROW_HAVE_RUNTIME_SVE128)
+void InterleavedPackBlockSve128(uint8_t bit_width, const uint32_t* in, uint32_t* out);
+void InterleavedUnpackBlockSve128(uint8_t bit_width, const uint32_t* packed,
+                                  uint32_t* out, uint32_t bias);
+#endif
+
+#if defined(ARROW_HAVE_RUNTIME_AVX2)
+void InterleavedPackBlockAvx2(uint8_t bit_width, const uint32_t* in, uint32_t* out);
+void InterleavedUnpackBlockAvx2(uint8_t bit_width, const uint32_t* packed, uint32_t* out,
+                                uint32_t bias);
+#endif
+
+}  // namespace fastlanes
+}  // namespace util
+}  // namespace arrow
diff --git a/cpp/src/arrow/util/fastlanes/interleaved_kernel_table_internal.h b/cpp/src/arrow/util/fastlanes/interleaved_kernel_table_internal.h
new file mode 100644
index 000000000000..5cceb32093b5
--- /dev/null
+++ b/cpp/src/arrow/util/fastlanes/interleaved_kernel_table_internal.h
@@ -0,0 +1,92 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+// The per-width dispatch tables, and the body each per-instruction-set
+// translation unit wraps under its own name. Included only by those translation
+// units, never by a caller: these contents are meant to be compiled more than
+// once, at different flags.
+
+#pragma once
+
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <utility>
+
+#include <xsimd/xsimd.hpp>
+
+#include "arrow/util/fastlanes/fastlanes_kernels_internal.h"
+#include "arrow/util/fastlanes/interleaved_dispatch_internal.h"
+#include "arrow/util/logging.h"
+
+namespace arrow {
+namespace util {
+namespace fastlanes {
+
+// A table of function pointers rather than a switch over 32 cases, to keep each
+// width's body out of line. Folding all 32 into one dispatch function cost
+// between 1.2x and 2.1x when tried on Arrow's NEON unpacker, the compiler
+// having lost the register allocation it finds for a body it compiles on its
+// own; two indirect calls per 1024 values do not measure against that.
+//
+// Entry w handles width w. Entry 0 is never called: a vector of width 0 is
+// constant and never reaches a kernel.
+template <typename Arch, size_t... W>
+constexpr std::array<InterleavedPackFn, 33> MakePackTable(std::index_sequence<W...>) {
+  return {nullptr, &PackBlock<W + 1, Arch>...};
+}
+
+template <typename Arch, bool kHasBias, size_t... W>
+constexpr std::array<InterleavedUnpackFn, 33> MakeUnpackTable(std::index_sequence<W...>) {
+  return {nullptr, &UnpackBlock<W + 1, kHasBias, Arch>...};
+}
+
+// Arch defaults to the architecture xsimd derives from the including
+// translation unit's own flags, so each leg instantiates a distinct
+// specialization of these templates and of every kernel their tables point at,
+// which is what stops the linker from merging two legs into one. xsimd is used
+// for the type and nothing else. The types were checked to differ:
+// xsimd::neon64 at the aarch64 baseline against xsimd::detail::sve<128> under
+// -march=armv8-a+sve -msve-vector-bits=128.
+template <typename Arch = xsimd::default_arch>
+void PackLeg(uint8_t bit_width, const uint32_t* in, uint32_t* out) {
+  static constexpr auto kTable = MakePackTable<Arch>(std::make_index_sequence<32>{});
+  ARROW_DCHECK(bit_width >= 1 && bit_width <= 32);
+  kTable[bit_width](in, out);
+}
+
+// The frame of reference is folded into the kernel's own store, so a non-zero
+// frame costs no second pass over the output. The table choice is made here
+// rather than inside the kernel so the no-bias instantiations carry no test in
+// their inner loop.
+template <typename Arch = xsimd::default_arch>
+void UnpackLeg(uint8_t bit_width, const uint32_t* packed, uint32_t* out, uint32_t bias) {
+  static constexpr auto kUnpack =
+      MakeUnpackTable<Arch, /*kHasBias=*/false>(std::make_index_sequence<32>{});
+  static constexpr auto kUnpackBias =
+      MakeUnpackTable<Arch, /*kHasBias=*/true>(std::make_index_sequence<32>{});
+  ARROW_DCHECK(bit_width >= 1 && bit_width <= 32);
+  if (bias == 0) {
+    kUnpack[bit_width](packed, out, 0);
+  } else {
+    kUnpackBias[bit_width](packed, out, bias);
+  }
+}
+
+}  // namespace fastlanes
+}  // namespace util
+}  // namespace arrow
diff --git a/cpp/src/arrow/util/fastlanes/interleaved_pfor.h b/cpp/src/arrow/util/fastlanes/interleaved_pfor.h
index 3c5cdd076f83..0dba63a319fe 100644
--- a/cpp/src/arrow/util/fastlanes/interleaved_pfor.h
+++ b/cpp/src/arrow/util/fastlanes/interleaved_pfor.h
@@ -16,61 +16,40 @@
 // under the License.
 
 // ---------------------------------------------------------------------------
-// Plain (non-delta) PFOR through the FastLanes container, in two orders:
+// Plain (non-delta) PFOR through the FastLanes container, in two value orders:
+// input order, and the paper's lane assignment. Everything else is held equal
+// -- same per-block frame of reference, same bit width choice, same container
+// -- so the difference between them is the ordering and nothing else, which is
+// the one question this file answers. lane_delta.h and transposed_delta.h ask
+// that question of a delta chain; plain PFOR has no chain for the ordering to
+// help, so what is priced here is the permutation FL_ORDER forces. See
+// InterleavedPforOrder below for the three variants.
 //
-//   kFileOrder  per-block frame-of-reference subtract, then bit-pack with the
-//               interleaved container in input order. This is Building Block
-//               1 alone -- lane_delta.h and transposed_delta.h are Building
-//               Block 1 applied to a delta chain; this file applies it to
-//               plain PFOR, which has no chain to break. Decode returns
-//               values in file order with no permutation, matching the note
-//               in fastlanes_kernels_internal.h.
-//
-//   kFlOrder    the same, but the residuals are placed with the paper's lane
-//               assignment (reused from transposed_delta.h's Transpose32x32:
-//               lane l holds the contiguous run [32l, 32l+32)) before
-//               packing, and gathered back to file order after unpacking.
-//               PFOR has no chain for this ordering to help, so this arm
-//               exists to price the gather it forces rather than to recommend
-//               it -- see fastlanes_kernels_internal.h's header comment.
-//
-// Both orders are otherwise identical: same per-block FOR, same bit width
-// choice, same container. That makes the difference between them the value
-// ordering and nothing else, which is the one question this file answers.
-//
-// THIS CODE HAS NO EXCEPTION HANDLING. There is no patch list on the wire and
-// no patch pass in the decoder, because a bit width wide enough for the block's
-// largest residual is always chosen. Arrow's production PFOR does carry
+// There is no exception handling here: no patch list on the wire and no patch
+// pass in the decoder, because a bit width wide enough for the block's largest
+// residual is always chosen. Arrow's production PFOR does carry
 // exceptions and does patch them, so a ratio taken between anything here and a
-// production arm charges one side for work the other never does, and the
+// production decoder charges one side for work the other never does, and the
 // difference is not the layout. Compare kFileOrder against kFlOrder/kFlOrderRaw
-// here; for sequential against interleaved, use the two production arms that
+// here; for sequential against interleaved, use the two production paths that
 // differ only in PackingMode.
 //
-// The container also appears in production as PackingMode::kForBitPackInterleaved,
-// which is what a Parquet reader would use. This file is not that code and does
-// not share its wire format: the production format has no lane-assignment mode,
-// so the ordering question has nowhere else to be asked.
-//
-// A caveat on what "the same columns" means, because an earlier version of this
-// comment overstated it: the benchmark corpus is SYNTHETIC. Its columns are
-// generators shaped after distributions seen in ClickBench, TPC-DS, TPC-H and
-// the NYC taxi set -- they are not records loaded from those datasets, and the
-// only file the harness opens is the CSV it writes. Bit-unpacking throughput is
-// data-independent at a fixed width, so that substitution is harmless for the
-// timing arms. It is NOT harmless for any claim about how wide a column packs,
-// since the generator's autocorrelation is chosen rather than observed.
+// The container also appears in production as
+// PackingMode::kForBitPackInterleaved, which is what a Parquet reader would
+// use. This file is not that code and does not share its wire format: the
+// production format has no lane-assignment mode, so the ordering question has
+// nowhere else to be asked.
 //
-// A second caveat, on register width. UnpackBlock in
-// fastlanes_kernels_internal.h contains no intrinsics: it is portable C++ that
-// the compiler auto-vectorizes, so its register width is whatever the
-// translation unit's compile-time flags permit. It has NO runtime SIMD dispatch,
-// which means ARROW_USER_SIMD_LEVEL does not reach it and ARROW_SIMD_LEVEL
-// (default: SSE4_2 on x86) decides it. On a default build this kernel compiles
-// to XMM while the sequential comparand dispatches to a hand-written AVX2 body
-// at runtime, so a layout comparison from a default build is measuring register
-// width and not layout. Build with -DARROW_SIMD_LEVEL=AVX2 or better before
-// comparing, or give these kernels real dispatch.
+// On register width: UnpackBlock in fastlanes_kernels_internal.h contains no
+// intrinsics, so its register width and its optimization level are whatever the
+// translation unit that compiled it was given. The production path in
+// pfor/pfor.cc picks its instruction set at runtime; the code here deliberately
+// does not, instantiating the template into the benchmark's own translation
+// unit so that every measurement is built at one known set of flags. The cost
+// is that it answers to ARROW_SIMD_LEVEL rather than ARROW_USER_SIMD_LEVEL, and
+// that a default x86 build (SSE4_2) runs it in XMM registers. Build with
+// -DARROW_SIMD_LEVEL=AVX2 or better before comparing against a dispatched
+// decoder, and state the level with the figure.
 //
 // Wire layout for n values (n a multiple of 1024; any tail is stored raw):
 //
diff --git a/cpp/src/arrow/util/fastlanes/interleaved_pfor_baseline.cc b/cpp/src/arrow/util/fastlanes/interleaved_pfor_baseline.cc
new file mode 100644
index 000000000000..caee977cc63f
--- /dev/null
+++ b/cpp/src/arrow/util/fastlanes/interleaved_pfor_baseline.cc
@@ -0,0 +1,41 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+// The baseline leg of the interleaved kernel dispatch. This translation unit
+// carries no instruction-set flags of its own, so it compiles at whatever the
+// build's flags name; DynamicDispatch falls back to it when no vector leg is
+// available.
+
+#include "arrow/util/fastlanes/interleaved_dispatch_internal.h"
+#include "arrow/util/fastlanes/interleaved_kernel_table_internal.h"
+
+namespace arrow {
+namespace util {
+namespace fastlanes {
+
+void InterleavedPackBlockBaseline(uint8_t bit_width, const uint32_t* in, uint32_t* out) {
+  return PackLeg<>(bit_width, in, out);
+}
+
+void InterleavedUnpackBlockBaseline(uint8_t bit_width, const uint32_t* packed,
+                                    uint32_t* out, uint32_t bias) {
+  return UnpackLeg<>(bit_width, packed, out, bias);
+}
+
+}  // namespace fastlanes
+}  // namespace util
+}  // namespace arrow
diff --git a/cpp/src/arrow/util/fastlanes/interleaved_pfor_simd.cc b/cpp/src/arrow/util/fastlanes/interleaved_pfor_simd.cc
new file mode 100644
index 000000000000..15303952c38c
--- /dev/null
+++ b/cpp/src/arrow/util/fastlanes/interleaved_pfor_simd.cc
@@ -0,0 +1,57 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+// A vector leg of the interleaved kernel dispatch, compiled once per
+// instruction set the build can target with that set's flags applied per-file
+// by CMake. The names below are selected by the same condition CMake tests
+// before adding the file, so only one branch is ever live in a given build.
+// util/bpacking_simd_256.cc is registered twice the same way.
+
+#if defined(ARROW_HAVE_RUNTIME_SVE128)
+#  define ILV_PACK_PLATFORM InterleavedPackBlockSve128
+#  define ILV_UNPACK_PLATFORM InterleavedUnpackBlockSve128
+#elif defined(ARROW_HAVE_RUNTIME_AVX2)
+#  define ILV_PACK_PLATFORM InterleavedPackBlockAvx2
+#  define ILV_UNPACK_PLATFORM InterleavedUnpackBlockAvx2
+#endif
+
+#if !defined(ILV_PACK_PLATFORM)
+#  error "This file must be compiled with a known SIMD micro architecture"
+#endif
+
+#include "arrow/util/fastlanes/interleaved_dispatch_internal.h"
+#include "arrow/util/fastlanes/interleaved_kernel_table_internal.h"
+
+namespace arrow {
+namespace util {
+namespace fastlanes {
+
+void ILV_PACK_PLATFORM(uint8_t bit_width, const uint32_t* in, uint32_t* out) {
+  return PackLeg<>(bit_width, in, out);
+}
+
+void ILV_UNPACK_PLATFORM(uint8_t bit_width, const uint32_t* packed, uint32_t* out,
+                         uint32_t bias) {
+  return UnpackLeg<>(bit_width, packed, out, bias);
+}
+
+}  // namespace fastlanes
+}  // namespace util
+}  // namespace arrow
+
+#undef ILV_PACK_PLATFORM
+#undef ILV_UNPACK_PLATFORM
diff --git a/cpp/src/arrow/util/pfor/pfor.cc b/cpp/src/arrow/util/pfor/pfor.cc
index d0aa6028bb98..5104b2e43dee 100644
--- a/cpp/src/arrow/util/pfor/pfor.cc
+++ b/cpp/src/arrow/util/pfor/pfor.cc
@@ -31,13 +31,14 @@
 #include <cstring>
 #include <limits>
 #include <span>
-#include <utility>
 
 #include "arrow/util/bit_stream_utils_internal.h"
 #include "arrow/util/bit_util.h"
 #include "arrow/util/bpacking_internal.h"
+#include "arrow/util/dispatch_internal.h"
 #include "arrow/util/endian.h"
 #include "arrow/util/fastlanes/fastlanes_kernels_internal.h"
+#include "arrow/util/fastlanes/interleaved_dispatch_internal.h"
 #include "arrow/util/logging.h"
 #include "arrow/util/macros.h"
 #include "arrow/util/ubsan.h"
@@ -90,34 +91,46 @@ static_assert(PforConstants::kPforVectorSize ==
 // reached when InterleavedApplies<T>() holds, so the width is in [1, 32] and
 // the block is a full 1024 values.
 //
-// A table of function pointers rather than a switch over 32 cases, because the
-// table keeps each width's body out of line. Folding all 32 into one dispatch
-// function is not free: doing exactly that to Arrow's NEON unpacker cost
-// between 1.2x and 2.1x, the compiler having lost the register allocation it
-// finds for a body it compiles on its own. One indirect call per 1024 values
-// is not measurable against that.
-using InterleavedPackFn = void (*)(const uint32_t*, uint32_t*);
-using InterleavedUnpackFn = void (*)(const uint32_t*, uint32_t*, uint32_t);
-
-// Index by bit width: entry w handles width w, and entry 0 is never called
-// because a vector of width 0 is constant and never reaches a kernel.
-template <size_t... W>
-constexpr std::array<InterleavedPackFn, 33> MakePackTable(std::index_sequence<W...>) {
-  return {nullptr, &fastlanes::PackBlock<W + 1>...};
-}
+// The kernels contain no intrinsics: they are portable C++ whose register width
+// is fixed by the flags of the translation unit that compiled them. So the
+// choice of instruction set is a choice of translation unit, made here at
+// runtime the same way every other Arrow SIMD kernel makes it. Each leg named
+// below is one compilation of the same kernel source at one instruction set;
+// interleaved_dispatch_internal.h says which legs exist and why, and
+// interleaved_kernel_table_internal.h holds the per-width table each one builds.
+//
+// Without this the kernels had no dispatch at all, and ARROW_SIMD_LEVEL alone
+// decided their width -- which on a default x86 build is SSE4_2, so the
+// interleaved kernel ran in XMM registers while the sequential unpacker it is
+// compared against dispatched to AVX2 at runtime.
+struct InterleavedPackDynamicFunction {
+  using FunctionType = decltype(&fastlanes::InterleavedPackBlockBaseline);
+
+  static constexpr auto targets() {
+    return std::array{
+        ARROW_DISPATCH_TARGET_NONE(&fastlanes::InterleavedPackBlockBaseline)  //
+        ARROW_DISPATCH_TARGET_SVE128(&fastlanes::InterleavedPackBlockSve128)  //
+        ARROW_DISPATCH_TARGET_AVX2(&fastlanes::InterleavedPackBlockAvx2)      //
+    };
+  }
+};
 
-template <bool kHasBias, size_t... W>
-constexpr std::array<InterleavedUnpackFn, 33> MakeUnpackTable(std::index_sequence<W...>) {
-  return {nullptr, &fastlanes::UnpackBlock<W + 1, kHasBias>...};
-}
+struct InterleavedUnpackDynamicFunction {
+  using FunctionType = decltype(&fastlanes::InterleavedUnpackBlockBaseline);
 
-constexpr auto kPackTable = MakePackTable(std::make_index_sequence<32>{});
-constexpr auto kUnpackTable = MakeUnpackTable<false>(std::make_index_sequence<32>{});
-constexpr auto kUnpackBiasTable = MakeUnpackTable<true>(std::make_index_sequence<32>{});
+  static constexpr auto targets() {
+    return std::array{
+        ARROW_DISPATCH_TARGET_NONE(&fastlanes::InterleavedUnpackBlockBaseline)  //
+        ARROW_DISPATCH_TARGET_SVE128(&fastlanes::InterleavedUnpackBlockSve128)  //
+        ARROW_DISPATCH_TARGET_AVX2(&fastlanes::InterleavedUnpackBlockAvx2)      //
+    };
+  }
+};
 
 inline void InterleavedPackBlock(uint8_t bit_width, const uint32_t* in, uint32_t* out) {
   ARROW_DCHECK(bit_width >= 1 && bit_width <= 32);
-  kPackTable[bit_width](in, out);
+  static const arrow::internal::DynamicDispatch<InterleavedPackDynamicFunction> dispatch;
+  return dispatch(bit_width, in, out);
 }
 
 // The frame of reference is folded into the kernel's own store, so a non-zero
@@ -125,11 +138,9 @@ inline void InterleavedPackBlock(uint8_t bit_width, const uint32_t* in, uint32_t
 inline void InterleavedUnpackBlock(uint8_t bit_width, const uint32_t* packed,
                                    uint32_t* out, uint32_t bias) {
   ARROW_DCHECK(bit_width >= 1 && bit_width <= 32);
-  if (bias == 0) {
-    kUnpackTable[bit_width](packed, out, 0);
-  } else {
-    kUnpackBiasTable[bit_width](packed, out, bias);
-  }
+  static const arrow::internal::DynamicDispatch<InterleavedUnpackDynamicFunction>
+      dispatch;
+  return dispatch(bit_width, packed, out, bias);
 }
 
 }  // namespace

From e0c5250f9a4184ea064fb2533e681d5f5fd269a1 Mon Sep 17 00:00:00 2001
From: Prateek Gaur <prateek.gaur@snowflake.com>
Date: Sat, 19 Sep 2026 05:20:15 +0000
Subject: [PATCH 23/27] Share one column corpus across PFOR benchmarks

Moves the synthetic column generators out of the comparison benchmark
into a header that the other benchmarks include, so every benchmark
reads the same columns. The moved code drops boxed headings and
benchmark slang in its comments. No codec behavior changes.
---
 cpp/src/parquet/pfor_comparison_benchmark.cc | 774 ++-----------------
 cpp/src/parquet/pfor_corpus_internal.h       | 661 ++++++++++++++++
 2 files changed, 737 insertions(+), 698 deletions(-)
 create mode 100644 cpp/src/parquet/pfor_corpus_internal.h

diff --git a/cpp/src/parquet/pfor_comparison_benchmark.cc b/cpp/src/parquet/pfor_comparison_benchmark.cc
index dd8c39f714b6..488815dc38d9 100644
--- a/cpp/src/parquet/pfor_comparison_benchmark.cc
+++ b/cpp/src/parquet/pfor_comparison_benchmark.cc
@@ -18,11 +18,9 @@
 // Comparison benchmark: PFOR vs DeltaBitPack vs ZSTD vs RleBitPackHybrid
 //                       vs ByteStreamSplit+ZSTD vs ByteStreamSplit+LZ4
 //
-// All throughput is reported as uncompressed_size / time (MB/s).
-// Data generators mimic ClickBench and TPC-DS column distributions. A second
-// group covers columns with structure between neighbouring values, or with a
-// cluster the minimum is not part of; those are the ones on which PFOR's delta
-// mode and DELTA_BINARY_PACKED make different choices.
+// All throughput is reported as uncompressed_size / time (MB/s). The columns are
+// generated by pfor_corpus_internal.h, which also says what they are and are
+// not.
 
 #include <algorithm>
 #include <bit>
@@ -51,6 +49,7 @@
 #include "arrow/util/rle_encoding_internal.h"
 
 #include "parquet/encoding.h"
+#include "parquet/pfor_corpus_internal.h"
 #include "parquet/platform.h"
 #include "parquet/schema.h"
 #include "parquet/types.h"
@@ -61,8 +60,8 @@ using ::arrow::util::Codec;
 namespace parquet {
 namespace {
 
-// ----------------------------------------------------------------------
-// Data generators: ClickBench-like columns
+// The columns themselves are in pfor_corpus_internal.h.
+namespace delta_shapes = corpus::delta_shapes;
 
 // Generator pointer type, parameterized on the column value type.
 template <typename T>
@@ -91,624 +90,6 @@ struct PqTraits<int64_t> {
   static constexpr Type::type kPhysicalType = Type::INT64;
 };
 
-std::vector<int32_t> GenClientIP(int64_t n) {
-  std::vector<int32_t> v(n);
-  std::mt19937 rng(101);
-  std::uniform_int_distribution<uint32_t> dist(0x0A000000, 0xDFFFFFFF);
-  for (auto& x : v) x = static_cast<int32_t>(dist(rng));
-  return v;
-}
-
-std::vector<int32_t> GenUrlRegionID(int64_t n) {
-  std::vector<int32_t> v(n);
-  std::mt19937 rng(102);
-  // Zipf-like over ~1000 values
-  std::uniform_real_distribution<double> uni(0.0, 1.0);
-  for (auto& x : v) {
-    double u = uni(rng);
-    x = static_cast<int32_t>(std::pow(u, 2.0) * 1000) + 1;
-  }
-  return v;
-}
-
-std::vector<int32_t> GenCounterID(int64_t n) {
-  std::vector<int32_t> v(n);
-  std::mt19937 rng(103);
-  std::uniform_int_distribution<int32_t> jitter(0, 3);
-  int32_t counter = 100000;
-  for (auto& x : v) {
-    counter += 1 + jitter(rng);
-    x = counter;
-  }
-  return v;
-}
-
-std::vector<int32_t> GenEventDate(int64_t n) {
-  std::vector<int32_t> v(n);
-  std::mt19937 rng(104);
-  const int32_t dates[] = {19691, 19692, 19693, 19694, 19695};
-  std::uniform_int_distribution<int> idx(0, 4);
-  for (auto& x : v) x = dates[idx(rng)];
-  return v;
-}
-
-std::vector<int32_t> GenEventTime(int64_t n) {
-  std::vector<int32_t> v(n);
-  std::mt19937 rng(105);
-  const int32_t base = 1704067200;  // 2024-01-01
-  std::uniform_int_distribution<int32_t> offset(0, 86399);
-  for (auto& x : v) x = base + offset(rng);
-  return v;
-}
-
-std::vector<int32_t> GenGoodEvent(int64_t n) {
-  std::vector<int32_t> v(n);
-  std::mt19937 rng(106);
-  std::uniform_int_distribution<int> dist(0, 99);
-  for (auto& x : v) x = (dist(rng) < 95) ? 1 : 0;
-  return v;
-}
-
-std::vector<int32_t> GenHID(int64_t n) {
-  std::vector<int32_t> v(n);
-  std::mt19937 rng(107);
-  std::uniform_int_distribution<int32_t> dist(std::numeric_limits<int32_t>::min(),
-                                              std::numeric_limits<int32_t>::max());
-  for (auto& x : v) x = dist(rng);
-  return v;
-}
-
-std::vector<int32_t> GenHitColor(int64_t n) {
-  std::vector<int32_t> v(n);
-  std::mt19937 rng(108);
-  const int32_t colors[] = {1, 2, 3, 4, 5};
-  std::uniform_int_distribution<int> idx(0, 4);
-  for (auto& x : v) x = colors[idx(rng)];
-  return v;
-}
-
-std::vector<int32_t> GenIPNetworkID(int64_t n) {
-  std::vector<int32_t> v(n);
-  std::mt19937 rng(109);
-  std::uniform_int_distribution<int32_t> dist(1, 10000);
-  for (auto& x : v) x = dist(rng);
-  return v;
-}
-
-std::vector<int32_t> GenJavaEnable(int64_t n) {
-  std::vector<int32_t> v(n);
-  std::mt19937 rng(110);
-  std::uniform_int_distribution<int> dist(0, 99);
-  for (auto& x : v) x = (dist(rng) < 85) ? 1 : 0;
-  return v;
-}
-
-std::vector<int32_t> GenOS(int64_t n) {
-  std::vector<int32_t> v(n);
-  std::mt19937 rng(111);
-  std::uniform_int_distribution<int32_t> dist(1, 20);
-  for (auto& x : v) x = dist(rng);
-  return v;
-}
-
-std::vector<int32_t> GenResolution(int64_t n) {
-  std::vector<int32_t> v(n);
-  std::mt19937 rng(112);
-  const int32_t resolutions[] = {360,  480,  600,  720,  768,  800,  900,
-                                 1024, 1050, 1080, 1200, 1440, 1600, 2160};
-  std::uniform_int_distribution<int> idx(0, 13);
-  for (auto& x : v) x = resolutions[idx(rng)];
-  return v;
-}
-
-std::vector<int32_t> GenTrafficSourceID(int64_t n) {
-  std::vector<int32_t> v(n);
-  std::mt19937 rng(113);
-  std::uniform_int_distribution<int32_t> dist(0, 10);
-  for (auto& x : v) x = dist(rng);
-  return v;
-}
-
-std::vector<int32_t> GenUserAgent(int64_t n) {
-  std::vector<int32_t> v(n);
-  std::mt19937 rng(114);
-  // Zipf-like over ~100 user agents
-  std::uniform_real_distribution<double> uni(0.0, 1.0);
-  for (auto& x : v) {
-    double u = uni(rng);
-    x = static_cast<int32_t>(std::pow(u, 1.5) * 100) + 1;
-  }
-  return v;
-}
-
-// ----------------------------------------------------------------------
-// Data generators: the four most queried TPC-DS store_sales columns
-
-std::vector<int32_t> GenTpcdsSoldDateSk(int64_t n) {
-  std::vector<int32_t> v(n);
-  const int32_t kBase = 2450815;
-  std::mt19937 rng(201);
-  std::uniform_int_distribution<int32_t> dist(0, 1820);
-  for (auto& x : v) x = kBase + dist(rng);
-  return v;
-}
-
-std::vector<int32_t> GenTpcdsStoreSk(int64_t n) {
-  std::vector<int32_t> v(n);
-  std::mt19937 rng(202);
-  std::uniform_int_distribution<int32_t> dist(1, 1000);
-  for (auto& x : v) x = dist(rng);
-  return v;
-}
-
-std::vector<int32_t> GenTpcdsItemSk(int64_t n) {
-  std::vector<int32_t> v(n);
-  const int32_t kMax = 100000;
-  std::mt19937 rng(203);
-  std::exponential_distribution<double> exp_dist(0.00005);
-  for (auto& x : v) {
-    int32_t val = static_cast<int32_t>(exp_dist(rng));
-    x = std::min(val + 1, kMax);
-  }
-  return v;
-}
-
-std::vector<int32_t> GenTpcdsQuantity(int64_t n) {
-  std::vector<int32_t> v(n);
-  std::mt19937 rng(204);
-  std::uniform_int_distribution<int32_t> small_dist(1, 10);
-  std::uniform_int_distribution<int32_t> large_dist(11, 100);
-  std::uniform_int_distribution<int> chance(0, 99);
-  for (auto& x : v) {
-    x = (chance(rng) < 90) ? small_dist(rng) : large_dist(rng);
-  }
-  return v;
-}
-
-// --- TPC-H (lineitem) top-queried numeric columns (Q1/Q3/Q5/Q6) ------------
-// l_quantity: integer [1, 50], uniform. Small range, min 1.
-std::vector<int32_t> GenTpchLQuantity(int64_t n) {
-  std::vector<int32_t> v(n);
-  std::mt19937 rng(301);
-  std::uniform_int_distribution<int32_t> dist(1, 50);
-  for (auto& x : v) x = dist(rng);
-  return v;
-}
-
-// l_extendedprice (cents): l_quantity * p_retailprice. p_retailprice spans
-// ~$900.00..$2099.00, so cents in [90000, 10495000]. Wide range, nonzero min.
-std::vector<int32_t> GenTpchLExtendedPrice(int64_t n) {
-  std::vector<int32_t> v(n);
-  std::mt19937 rng(302);
-  std::uniform_int_distribution<int32_t> qty(1, 50);
-  std::uniform_int_distribution<int32_t> retail_cents(90000, 209900);
-  for (auto& x : v) x = qty(rng) * retail_cents(rng);
-  return v;
-}
-
-// l_discount (x100): integer [0, 10] i.e. 0.00..0.10. Includes 0 (0%
-// discount is a real value), so this one starts at 0.
-std::vector<int32_t> GenTpchLDiscount(int64_t n) {
-  std::vector<int32_t> v(n);
-  std::mt19937 rng(303);
-  std::uniform_int_distribution<int32_t> dist(0, 10);
-  for (auto& x : v) x = dist(rng);
-  return v;
-}
-
-// l_shipdate (days since 1970-01-01): 1992-01-01..1998-12 span. Base 8036,
-// range ~7 years. Large nonzero min -> exercises frame-of-reference.
-std::vector<int32_t> GenTpchLShipDate(int64_t n) {
-  std::vector<int32_t> v(n);
-  const int32_t kBase = 8036;  // days since epoch for 1992-01-01
-  std::mt19937 rng(304);
-  std::uniform_int_distribution<int32_t> dist(0, 2557);
-  for (auto& x : v) x = kBase + dist(rng);
-  return v;
-}
-
-// --- TPC-DS (store_sales / date_dim) further top-queried numeric columns ---
-// ss_customer_sk: surrogate key, uniform [1, 2,000,000]. Big range, min 1.
-std::vector<int32_t> GenTpcdsCustomerSk(int64_t n) {
-  std::vector<int32_t> v(n);
-  std::mt19937 rng(311);
-  std::uniform_int_distribution<int32_t> dist(1, 2000000);
-  for (auto& x : v) x = dist(rng);
-  return v;
-}
-
-// ss_ext_sales_price (cents): skewed price, exponential mean ~$50, floored at
-// $1.00 (a sale has a nonzero price), capped at $20,000. Long tail -> patches.
-std::vector<int32_t> GenTpcdsExtSalesPrice(int64_t n) {
-  std::vector<int32_t> v(n);
-  const int32_t kMin = 100, kMax = 2000000;
-  std::mt19937 rng(312);
-  std::exponential_distribution<double> exp_dist(1.0 / 5000.0);
-  for (auto& x : v) {
-    int32_t val = kMin + static_cast<int32_t>(exp_dist(rng));
-    x = std::min(val, kMax);
-  }
-  return v;
-}
-
-// ss_net_profit (cents): usually a small profit, sometimes a loss -> negative
-// values, so the frame of reference is negative (not zero).
-std::vector<int32_t> GenTpcdsNetProfit(int64_t n) {
-  std::vector<int32_t> v(n);
-  std::mt19937 rng(313);
-  std::uniform_int_distribution<int32_t> dist(-10000, 300000);
-  for (auto& x : v) x = dist(rng);
-  return v;
-}
-
-// d_year: queried date_dim year range [1998, 2003]. Low cardinality, min 1998.
-std::vector<int32_t> GenTpcdsDYear(int64_t n) {
-  std::vector<int32_t> v(n);
-  std::mt19937 rng(314);
-  std::uniform_int_distribution<int32_t> dist(1998, 2003);
-  for (auto& x : v) x = dist(rng);
-  return v;
-}
-
-// --- NYC yellow-taxi trip numeric columns ----------------------------------
-// pickup timestamp (unix seconds): 2015-01, base 1,420,070,400 + ~31 days.
-// Very large min -> frame-of-reference is essential.
-std::vector<int32_t> GenTaxiPickupUnixTime(int64_t n) {
-  std::vector<int32_t> v(n);
-  const int32_t kBase = 1420070400;  // 2015-01-01 UTC
-  std::mt19937 rng(321);
-  std::uniform_int_distribution<int32_t> dist(0, 2678400);  // ~31 days
-  for (auto& x : v) x = kBase + dist(rng);
-  return v;
-}
-
-// trip_distance (x100 miles): exponential mean ~1.8 mi, floored at 0.10 mi
-// (no zero-distance trips), capped at 100 mi. Long tail -> patches.
-std::vector<int32_t> GenTaxiTripDistanceX100(int64_t n) {
-  std::vector<int32_t> v(n);
-  const int32_t kMin = 10, kMax = 10000;
-  std::mt19937 rng(322);
-  std::exponential_distribution<double> exp_dist(1.0 / 180.0);
-  for (auto& x : v) {
-    int32_t val = kMin + static_cast<int32_t>(exp_dist(rng));
-    x = std::min(val, kMax);
-  }
-  return v;
-}
-
-// fare_amount (cents): $2.50 base + exponential mean ~$10, capped at $150.
-// Nonzero floor at the base fare, skewed with a long tail.
-std::vector<int32_t> GenTaxiFareCents(int64_t n) {
-  std::vector<int32_t> v(n);
-  const int32_t kBase = 250, kMax = 15000;
-  std::mt19937 rng(323);
-  std::exponential_distribution<double> exp_dist(1.0 / 1000.0);
-  for (auto& x : v) {
-    int32_t val = kBase + static_cast<int32_t>(exp_dist(rng));
-    x = std::min(val, kMax);
-  }
-  return v;
-}
-
-// ----------------------------------------------------------------------
-// Data generators: int64 columns whose values exceed the int32 range. Covers the common
-// 64-bit analytic cases: nanosecond timestamps, large surrogate keys, scaled-decimal
-// money, monotone IDs, and wide counters.
-
-// Nanosecond epoch timestamp (Parquet TIMESTAMP(NANOS)): 2024-01-01 base plus
-// up to ~1 day of jitter. Min ~1.70e18 -> very large frame of reference; raw
-// values need ~61 bits.
-std::vector<int64_t> GenTsNanos(int64_t n) {
-  std::vector<int64_t> v(n);
-  const int64_t kBase = 1704067200000000000LL;  // 2024-01-01T00:00:00Z in ns
-  std::mt19937_64 rng(401);
-  std::uniform_int_distribution<int64_t> off(0, 86399999999999LL);  // ~1 day
-  for (auto& x : v) x = kBase + off(rng);
-  return v;
-}
-
-// BIGINT surrogate / order key, uniform over [1, 10 billion] (exceeds 2^32).
-std::vector<int64_t> GenOrderKey(int64_t n) {
-  std::vector<int64_t> v(n);
-  std::mt19937_64 rng(402);
-  std::uniform_int_distribution<int64_t> dist(1, 10000000000LL);
-  for (auto& x : v) x = dist(rng);
-  return v;
-}
-
-// Money as int64 scaled decimal (micro-units): $0.01 .. ~$100k, skewed, with a
-// nonzero floor at one cent.
-std::vector<int64_t> GenPriceMicros(int64_t n) {
-  std::vector<int64_t> v(n);
-  const int64_t kMin = 10000, kMax = 100000000000LL;  // $0.01 .. $100,000
-  std::mt19937_64 rng(403);
-  std::exponential_distribution<double> exp_dist(1.0 / 5000000.0);  // mean ~$5
-  for (auto& x : v) {
-    int64_t val = kMin + static_cast<int64_t>(exp_dist(rng));
-    x = std::min(val, kMax);
-  }
-  return v;
-}
-
-// ============================================================================
-// Data generators: sorted and near-sorted
-//
-// The generators above draw independently around a base, which is the case
-// delta encoding is not for: subtracting two i.i.d. values spans the whole
-// range whichever two you pick, so the distance between them does not matter
-// and every delta variant lands within a bit or two of frame of reference.
-// Comparing delta schemes needs columns whose value depends on the previous
-// one. These cover the shapes that occur in practice: a clustered timestamp
-// column, a sorted key with duplicates, an exact counter, and a column that
-// is sorted apart from a few late arrivals.
-// ============================================================================
-
-// Event timestamps in seconds, arriving a few seconds apart. The common case
-// for a table clustered or sorted on time.
-std::vector<int32_t> GenSortedUnixTime(int64_t n) {
-  std::vector<int32_t> v(n);
-  std::mt19937 rng(401);
-  std::uniform_int_distribution<int32_t> gap(0, 7);
-  int32_t t = 1700000000;
-  for (auto& x : v) {
-    t += gap(rng);
-    x = t;
-  }
-  return v;
-}
-
-// A sorted surrogate key with runs of duplicates, as produced by a join key or
-// a dictionary-sorted column: most steps are 0, some are 1.
-std::vector<int32_t> GenSortedKeyDups(int64_t n) {
-  std::vector<int32_t> v(n);
-  std::mt19937 rng(402);
-  std::uniform_int_distribution<int32_t> step(0, 1);
-  int32_t k = 5000000;
-  for (auto& x : v) {
-    k += step(rng);
-    x = k;
-  }
-  return v;
-}
-
-// An exact +1 row id. The best case for any delta scheme, and the case where
-// stride-1 and lane-parallel delta differ most.
-std::vector<int32_t> GenMonotoneRowId(int64_t n) {
-  std::vector<int32_t> v(n);
-  int32_t k = 1;
-  for (auto& x : v) x = k++;
-  return v;
-}
-
-// Sorted except that 2% of rows arrive late, so a few deltas are large and
-// negative. Tests whether one bit width per block survives outliers.
-std::vector<int32_t> GenNearSortedUnixTime(int64_t n) {
-  std::vector<int32_t> v = GenSortedUnixTime(n);
-  std::mt19937 rng(403);
-  std::uniform_int_distribution<int> pick(0, 49);
-  std::uniform_int_distribution<int32_t> late(1, 3600);
-  for (auto& x : v) {
-    if (pick(rng) == 0) x -= late(rng);
-  }
-  return v;
-}
-
-// Snowflake-style monotone ID: large base + jittered per-row increments.
-// Monotone -> ideal for DELTA_BINARY_PACKED; huge min -> ideal for PFOR's FOR.
-std::vector<int64_t> GenSnowflakeId(int64_t n) {
-  std::vector<int64_t> v(n);
-  std::mt19937_64 rng(404);
-  std::uniform_int_distribution<int64_t> step(1, 4096);
-  int64_t id = 1500000000000000000LL;
-  for (auto& x : v) {
-    id += step(rng);
-    x = id;
-  }
-  return v;
-}
-
-// Wide cumulative byte counts, uniform [1024, 5 trillion] (wide 64-bit range).
-std::vector<int64_t> GenByteCount(int64_t n) {
-  std::vector<int64_t> v(n);
-  std::mt19937_64 rng(405);
-  std::uniform_int_distribution<int64_t> dist(1024, 5000000000000LL);
-  for (auto& x : v) x = dist(rng);
-  return v;
-}
-
-// ----------------------------------------------------------------------
-// Data generators: structure between neighboring values
-
-// The generators above are all either unordered or perfectly regular, so none
-// of them separates an encoding that differences neighbouring values from one
-// that packs them, and none of them puts a frame of reference anywhere but the
-// minimum. These do. They are the columns on which PFOR's delta mode and
-// DELTA_BINARY_PACKED make different choices, so they are what this file needs
-// in order to compare the two.
-//
-// Unlike the generators above, these are templates rather than a pair of
-// per-width functions: it keeps the two widths of every REGISTER_DELTA_SHAPE
-// below on provably the same distribution, which two hand-written copies would
-// not. They live in their own namespace because two of them build on base
-// distributions whose names are already taken in this file by columns drawn
-// from different seeds -- keeping them separate is what makes these figures
-// comparable with pfor_benchmark.cc, which uses the same shapes.
-namespace delta_shapes {
-
-template <typename T>
-std::vector<T> GenSmallRange(int64_t n) {
-  std::vector<T> v(n);
-  std::mt19937_64 rng(12345);
-  std::uniform_int_distribution<T> dist(100000, 200000);
-  for (auto& x : v) x = dist(rng);
-  return v;
-}
-
-template <typename T>
-std::vector<T> GenTpcdsItemSk(int64_t n) {
-  std::vector<T> v(n);
-  const T kMax = 100000;
-  std::mt19937_64 rng(12345);
-  std::exponential_distribution<double> exp_dist(0.00005);
-  for (auto& x : v) {
-    T val = static_cast<T>(exp_dist(rng));
-    x = std::min(static_cast<T>(val + 1), kMax);
-  }
-  return v;
-}
-
-/// A timestamp column with a fixed sampling interval and jitter: the
-/// differences cluster tightly around the interval, the values do not.
-template <typename T>
-std::vector<T> GenTrendJitter(int64_t n) {
-  std::vector<T> v(n);
-  std::mt19937_64 rng(7);
-  std::normal_distribution<double> jitter(0.0, 40.0);
-  double t = 1704067200.0;
-  for (auto& x : v) {
-    t += 3.0;
-    x = static_cast<T>(t + jitter(rng));
-  }
-  return v;
-}
-
-/// A TCP congestion window: a linear climb cut by a sharp halving. Almost
-/// every difference is the same small number and a few are large and
-/// negative, which is the shape a two-sided frame plus patching handles at
-/// close to no cost and a one-sided one cannot.
-template <typename T>
-std::vector<T> GenSawtooth(int64_t n) {
-  std::vector<T> v(n);
-  T cur = 1000;
-  for (int64_t i = 0; i < n; ++i) {
-    if (i % 200 == 199) {
-      cur /= 2;
-    } else {
-      cur += 12;
-    }
-    v[i] = cur;
-  }
-  return v;
-}
-
-/// A continuous quantity sampled over time, so the rate of change is bounded
-/// but the level wanders: differencing wins, though not by much.
-template <typename T>
-std::vector<T> GenMeasurement(int64_t n) {
-  std::vector<T> v(n);
-  std::mt19937_64 rng(11);
-  std::normal_distribution<double> noise(0.0, 1.0);
-  double level = 0.0;
-  double rate = 0.0;
-  for (int64_t i = 0; i < n; ++i) {
-    rate = 0.95 * rate + noise(rng);
-    level += rate;
-    v[i] = static_cast<T>(4000.0 * level / 50.0) + static_cast<T>(500000);
-  }
-  return v;
-}
-
-/// A sorted surrogate key column, which is what a clustered index or a
-/// sorted-by-key file produces.
-template <typename T>
-std::vector<T> GenSortedKeys(int64_t n) {
-  auto v = GenTpcdsItemSk<T>(n);
-  std::sort(v.begin(), v.end());
-  return v;
-}
-
-/// A measurement series punctuated by a low sentinel standing in for "no
-/// reading". The sentinel sits far below the cluster, so a frame pinned to
-/// the minimum has to widen to reach it and no value can ever be patched.
-template <typename T>
-std::vector<T> GenSensorDropouts(int64_t n) {
-  auto v = GenMeasurement<T>(n);
-  std::mt19937_64 rng(3);
-  std::uniform_int_distribution<int64_t> pos(0, n - 1);
-  for (int64_t i = 0; i < std::max<int64_t>(1, n / 200); ++i) {
-    v[pos(rng)] = static_cast<T>(-999999);
-  }
-  return v;
-}
-
-/// Monotonic ids with occasional large jumps, as a sequence shared between
-/// writers or restarted produces.
-template <typename T>
-std::vector<T> GenIdsWithGaps(int64_t n) {
-  std::vector<T> v(n);
-  std::mt19937_64 rng(5);
-  std::uniform_int_distribution<int> step(1, 6);
-  std::uniform_int_distribution<int> jump(0, 199);
-  T cur = 1000000;
-  for (auto& x : v) {
-    cur += static_cast<T>(step(rng));
-    if (jump(rng) == 0) cur += 100000;
-    x = cur;
-  }
-  return v;
-}
-
-/// Prices on a random walk: small signed steps around a high base, and no
-/// trend for the differences to line up on.
-template <typename T>
-std::vector<T> GenRandomWalk(int64_t n) {
-  std::vector<T> v(n);
-  std::mt19937_64 rng(13);
-  std::uniform_int_distribution<int> step(-25, 25);
-  T cur = 1500000;
-  for (auto& x : v) {
-    cur += static_cast<T>(step(rng));
-    x = cur;
-  }
-  return v;
-}
-
-/// Event arrival times in milliseconds since the epoch, bursty, so the gaps
-/// are skewed rather than clustered.
-template <typename T>
-std::vector<T> GenEventMillis(int64_t n) {
-  std::vector<T> v(n);
-  std::mt19937_64 rng(17);
-  std::exponential_distribution<double> gap(0.4);
-  double t = 1704067200.0;
-  for (auto& x : v) {
-    t += gap(rng);
-    x = static_cast<T>(t);
-  }
-  return v;
-}
-
-/// A tight unordered cluster with a low "missing" sentinel: the frame cannot
-/// sit at the minimum and differencing has nothing to exploit either, so
-/// this is the column that has to come out no worse than before.
-template <typename T>
-std::vector<T> GenLowSentinel(int64_t n) {
-  auto v = GenSmallRange<T>(n);
-  std::mt19937_64 rng(23);
-  std::uniform_int_distribution<int64_t> pos(0, n - 1);
-  for (int64_t i = 0; i < std::max<int64_t>(1, n / 200); ++i) {
-    v[pos(rng)] = static_cast<T>(-1000);
-  }
-  return v;
-}
-
-/// Two interleaved clusters far apart, so no single window covers the vector
-/// and the cheaper cluster is worth framing on its own.
-template <typename T>
-std::vector<T> GenBimodal(int64_t n) {
-  std::vector<T> v(n);
-  std::mt19937_64 rng(19);
-  std::uniform_int_distribution<T> lo(1000, 1100);
-  std::uniform_int_distribution<T> hi(900000, 900100);
-  std::uniform_int_distribution<int> pick(0, 9);
-  for (auto& x : v) {
-    x = pick(rng) < 8 ? lo(rng) : hi(rng);
-  }
-  return v;
-}
-
-}  // namespace delta_shapes
-
 // ----------------------------------------------------------------------
 // Helpers
 
@@ -772,13 +153,13 @@ static void PforEncodeImpl(benchmark::State& state, GenT<T> gen,
 }
 
 // ---------------------------------------------------------------------------
-// One process-wide, 4096-aligned output buffer shared by every decode arm.
+// One process-wide, 4096-aligned output buffer shared by every decode benchmark.
 //
 // Output-buffer placement can affect decoder measurements. Sharing one aligned
 // buffer ensures that every variant writes to the same addresses, isolating
 // differences in decoder code.
 //
-// Safe to share: benchmarks in a process run one at a time, and every arm
+// Safe to share: benchmarks in a process run one at a time, and each one
 // overwrites the whole buffer before reading it back.
 // ---------------------------------------------------------------------------
 template <typename T>
@@ -832,7 +213,7 @@ static void PforDecodeImpl(benchmark::State& state, GenT<T> gen,
     ARROW_CHECK_OK(status);
     benchmark::ClobberMemory();
   }
-  // The interleaved arms assert their round trip; this one did not, so a plan
+  // The interleaved benchmarks assert their round trip; this one did not, so a plan
   // change silently producing wrong values would have read as a speedup.
   ARROW_CHECK(std::equal(decoded, decoded + num_values, values.begin()))
       << "pfor round trip failed";
@@ -979,11 +360,11 @@ static void BM_PforDbpDelta64Decode(benchmark::State& state, Gen64 gen) {
 
 // ----------------------------------------------------------------------
 
-// The two arms below hold the delta decision fixed so that the bit-packed
+// The two benchmarks below hold the delta decision fixed so that the bit-packed
 // layout is the only thing separating them. BM_PforDecode above is the shipping
 // default, which lets the planner difference a vector whenever its cost model
 // prefers that; on a sorted or correlated column it does, and the decode then
-// also pays a serial prefix sum. A ratio taken against a layout arm that never
+// also pays a serial prefix sum. A ratio taken against a benchmark that never
 // deltas therefore measures two decisions at once, not the layout. These two
 // decline delta on both sides, so the ratio between them is a layout result,
 // and it is valid on every column rather than only the ones the planner leaves
@@ -1401,15 +782,14 @@ static void BM_BssLz464Decode(benchmark::State& state, Gen64 gen) {
 
 // ----------------------------------------------------------------------
 // DELTA_BINARY_PACKED cost decomposition
-// ----------------------------------------------------------------------
 //
 // Splits the cost of decoding a DELTA_BINARY_PACKED page into three parts:
 // per-block header parsing, the call into the bit unpacker, and the serial
-// prefix sum. Each ablated arm reads the same stream and calls the same
+// prefix sum. Each ablation reads the same stream and calls the same
 // out-of-line `arrow::internal::unpack` in libarrow, so only the surrounding
 // loop is recompiled here. `kFull` exists to be cross-checked against the
-// in-tree BM_DeltaBitPackDecode arm; if the two disagree, none of the ablated
-// arms mean anything.
+// in-tree BM_DeltaBitPackDecode; if the two disagree, none of the ablations
+// mean anything.
 
 enum class DbpAblate {
   kFull,        // headers + unpack + prefix sum
@@ -1766,7 +1146,7 @@ int DbpDirectDecode(const uint8_t* data, int len, T* out) {
 // Mean values per unpack call a coalescing reader achieves on this stream.
 // Without coalescing it is always values_per_mini_block, so the ratio of the two
 // is the granularity gain available on this column, and it bounds what the
-// kCoalesce arm can show.
+// kCoalesce benchmark can show.
 template <typename T>
 double DbpMeanValuesPerUnpackCall(const uint8_t* data, int len) {
   ::arrow::bit_util::BitReader reader(data, len);
@@ -1861,7 +1241,7 @@ static void DbpAblateImpl(benchmark::State& state, GenT<T> gen, uint32_t values_
   }
 }
 
-// Ablation arms, all at Arrow's default int32 geometry (128 values per block,
+// Ablations, all at Arrow's default int32 geometry (128 values per block,
 // 4 miniblocks, so 32 values per unpack call).
 static void BM_DbpAbFull(benchmark::State& state, Gen32 gen) {
   DbpAblateImpl<int32_t, DbpAblate::kFull>(state, gen, 128, 4);
@@ -1882,7 +1262,7 @@ static void BM_DbpAbFullHeapReader(benchmark::State& state, Gen32 gen) {
   DbpAblateImpl<int32_t, DbpAblate::kFull, /*kHeapReader=*/true>(state, gen, 128, 4);
 }
 
-// Reader-side arms, at Arrow's default 128/4 geometry so they are directly
+// Reader-side benchmarks, at Arrow's default 128/4 geometry so they are directly
 // comparable with BM_DbpAbFull.
 static void BM_DbpRsCoalesce(benchmark::State& state, Gen32 gen) {
   DbpAblateImpl<int32_t, DbpAblate::kCoalesce>(state, gen, 128, 4);
@@ -1915,7 +1295,7 @@ static void BM_DbpGeom1024x1(benchmark::State& state, Gen32 gen) {
 
 // ----------------------------------------------------------------------
 // Lane-parallel delta: the +32 stride against the paper's lane assignment
-// ----------------------------------------------------------------------
+
 //
 // Both replace DELTA_BINARY_PACKED's 1024-long dependency chain with 32
 // independent chains of 32. They differ only in which value a lane's chain
@@ -1930,8 +1310,8 @@ static void BM_DbpGeom1024x1(benchmark::State& state, Gen32 gen) {
 //
 // Tpose comes in two base codings (32 entry points per block stored raw, or
 // delta-coded across lanes) and, for the decode side, with and without the
-// transpose back to file order. Only the repairing arm is a conforming decoder;
-// the other one isolates what the transpose costs.
+// transpose back to file order. Only the repairing one is a conforming decoder;
+// the other isolates what the transpose costs.
 
 using ::arrow::util::fastlanes::TransposedBaseCoding;
 using ::arrow::util::fastlanes::TransposedRepair;
@@ -1963,14 +1343,13 @@ static void BM_LaneDeltaDecode(benchmark::State& state, Gen32 gen) {
       static_cast<double>(uncompressed_size) / static_cast<double>(comp_size);
 }
 
-// ============================================================================
+// ----------------------------------------------------------------------
 // Lane-parallel delta through the decoder interface
-// ============================================================================
 //
 // BM_TposeFusedDecode below measures the kernel: it is handed a payload and told
-// how many values it holds. These two arms go through the encoder and decoder
-// the library registers for the encoding, which is the same layout, base coding
-// and repair that arm uses, so they pay for page framing, for SetData, and for
+// how many values it holds. These two go through the encoder and decoder the
+// library registers for the encoding, which is the same layout, base coding and
+// repair the kernel benchmark uses, so they pay for page framing, for SetData, and for
 // reading the value count out of the page. That makes them comparable with
 // BM_DeltaBitPackEncode / BM_DeltaBitPackDecode, which is the pair libparquet
 // ships, and it is the comparison a margin should be quoted over -- decoder
@@ -2099,16 +1478,15 @@ static void BM_TposeRawNoRepairDecode(benchmark::State& state, Gen32 gen) {
   TposeDecodeImpl<TransposedBaseCoding::kRaw, TransposedRepair::kNone>(state, gen);
 }
 
-// ============================================================================
+// ----------------------------------------------------------------------
 // Interleaved-layout PFOR (no delta chain to break)
-// ============================================================================
 //
 // BM_PforDecode is Arrow's shipped sequential decoder -- the layout the
 // format specifies today. These two swap only the bit-unpack kernel for the
 // FastLanes container, keeping the same per-block frame-of-reference and the
 // same real dataset columns, so the margin against BM_PforDecode isolates
 // the layout question on data instead of on synthetic per-width residuals.
-// The second arm adds the paper's lane assignment and the gather needed to
+// The second adds the paper's lane assignment and the gather needed to
 // undo it, which fastlanes_kernels_internal.h's header comment argues plain
 // PFOR has nothing to buy with -- this prices that argument on real columns.
 
@@ -2128,8 +1506,8 @@ static void InterleavedPforDecodeImpl(benchmark::State& state, Gen32 gen) {
 
   // kFlOrderRaw deliberately returns the FastLanes order, so its expectation is
   // the permuted input rather than the input. Checking it against the same
-  // permutation the encoder applied is what keeps this arm honest: without it,
-  // an arm that skipped work entirely would also "pass".
+  // permutation the encoder applied matters: without that, a benchmark that
+  // skipped the work entirely would also "pass".
   std::vector<int32_t> expect = values;
   if constexpr (kOrder == InterleavedPforOrder::kFlOrderRaw) {
     const int64_t nblocks = num_values / 1024;
@@ -2158,22 +1536,22 @@ static void InterleavedPforDecodeImpl(benchmark::State& state, Gen32 gen) {
   state.counters["compression_ratio"] =
       static_cast<double>(uncompressed_size) / static_cast<double>(comp_size);
 }
-// The three arms below answer the value-ordering question and only that one.
+// The three benchmarks below answer the value-ordering question and only that.
 // They run arrow/util/fastlanes/interleaved_pfor.h, which has no exception
 // handling: no patch list on the wire, no patch pass in the decoder. Dividing
-// one of them by a production arm therefore charges the production side for work
+// one of them by a production benchmark therefore charges the production side
 // these never do, and the quotient is not the layout. The layout question has
 // its own pair above -- BM_PforPlainSeqDecode and BM_PforPlainInterleavedDecode,
 // same production encoder and decoder, differing only in PackingMode.
 // BM_InterleavedPforDecode is the file-order control the other two are read
-// against; it is not a second interleaved-layout arm.
+// against; it is not a second interleaved-layout result.
 static void BM_InterleavedPforDecode(benchmark::State& state, Gen32 gen) {
   InterleavedPforDecodeImpl<InterleavedPforOrder::kFileOrder>(state, gen);
 }
 // Same wire bytes as BM_InterleavedPforFlOrderDecode, but the FastLanes order is
 // handed to the caller unchanged. It runs the identical PackBlock/UnpackBlock
 // pair as BM_InterleavedPforDecode against a grid that was merely filled
-// differently at encode time, so it must measure equal to it -- the arm exists
+// differently at encode time, so it must measure equal to it -- it exists
 // to separate "FL_ORDER's bit-packing is cheaper" (it is not, it is identical)
 // from "FL_ORDER's permutation costs something" (it does).
 static void BM_InterleavedPforFlOrderRawDecode(benchmark::State& state, Gen32 gen) {
@@ -2222,18 +1600,18 @@ static void BM_TposePackedEncode(benchmark::State& state, Gen32 gen) {
 
 static void CustomArgs(benchmark::internal::Benchmark* b) { b->Arg(102400); }
 
-// The four layout-comparison arms sweep the working set; everything else stays
+// The four layout comparisons sweep the working set; everything else stays
 // at the single 102400 point so the suite does not get five times longer for no
-// gain. The four that sweep are the ones a layout verdict is read from:
+// gain. The four that sweep are the ones the layout question is read from:
 //
 //   BM_PforPlainSeqDecode              continuous layout, delta declined
-//                                        -- THE BASELINE
+//                                        -- the baseline
 //   BM_InterleavedPforDecode           interleaved grid, file order out
-//                                        -- CONTROL, not shippable
+//                                        -- control, not shippable
 //   BM_InterleavedPforFlOrderRawDecode FL_ORDER grid, permutation not charged
-//                                        -- CONTROL, not shippable
+//                                        -- control, not shippable
 //   BM_InterleavedPforFlOrderDecode    FL_ORDER grid -> file order, fused
-//                                        -- THE CANDIDATE
+//                                        -- the candidate
 //
 // All four must sweep together or the comparison is unreadable. Measured at one
 // working-set size the two controls and the candidate cannot be separated: the
@@ -2333,53 +1711,53 @@ static void LayoutArgs(benchmark::internal::Benchmark* b) {
   BENCHMARK_CAPTURE(BM_BssLz464Decode, Name, &GenFunc)->Apply(CustomArgs);
 
 // ClickBench datasets
-REGISTER_DATASET(ClientIP, GenClientIP)
-REGISTER_DATASET(UrlRegionID, GenUrlRegionID)
-REGISTER_DATASET(CounterID, GenCounterID)
-REGISTER_DATASET(EventDate, GenEventDate)
-REGISTER_DATASET(EventTime, GenEventTime)
-REGISTER_DATASET(GoodEvent, GenGoodEvent)
-REGISTER_DATASET(HID, GenHID)
-REGISTER_DATASET(HitColor, GenHitColor)
-REGISTER_DATASET(IPNetworkID, GenIPNetworkID)
-REGISTER_DATASET(JavaEnable, GenJavaEnable)
-REGISTER_DATASET(OS, GenOS)
-REGISTER_DATASET(Resolution, GenResolution)
-REGISTER_DATASET(TrafficSourceID, GenTrafficSourceID)
-REGISTER_DATASET(UserAgent, GenUserAgent)
+REGISTER_DATASET(ClientIP, corpus::GenClientIP)
+REGISTER_DATASET(UrlRegionID, corpus::GenUrlRegionID)
+REGISTER_DATASET(CounterID, corpus::GenCounterID)
+REGISTER_DATASET(EventDate, corpus::GenEventDate)
+REGISTER_DATASET(EventTime, corpus::GenEventTime)
+REGISTER_DATASET(GoodEvent, corpus::GenGoodEvent)
+REGISTER_DATASET(HID, corpus::GenHID)
+REGISTER_DATASET(HitColor, corpus::GenHitColor)
+REGISTER_DATASET(IPNetworkID, corpus::GenIPNetworkID)
+REGISTER_DATASET(JavaEnable, corpus::GenJavaEnable)
+REGISTER_DATASET(OS, corpus::GenOS)
+REGISTER_DATASET(Resolution, corpus::GenResolution)
+REGISTER_DATASET(TrafficSourceID, corpus::GenTrafficSourceID)
+REGISTER_DATASET(UserAgent, corpus::GenUserAgent)
 
 // TPC-DS datasets
-REGISTER_DATASET(TpcdsSoldDateSk, GenTpcdsSoldDateSk)
-REGISTER_DATASET(TpcdsStoreSk, GenTpcdsStoreSk)
-REGISTER_DATASET(TpcdsItemSk, GenTpcdsItemSk)
-REGISTER_DATASET(TpcdsQuantity, GenTpcdsQuantity)
-REGISTER_DATASET(TpcdsCustomerSk, GenTpcdsCustomerSk)
-REGISTER_DATASET(TpcdsExtSalesPrice, GenTpcdsExtSalesPrice)
-REGISTER_DATASET(TpcdsNetProfit, GenTpcdsNetProfit)
-REGISTER_DATASET(TpcdsDYear, GenTpcdsDYear)
+REGISTER_DATASET(TpcdsSoldDateSk, corpus::GenTpcdsSoldDateSk)
+REGISTER_DATASET(TpcdsStoreSk, corpus::GenTpcdsStoreSk)
+REGISTER_DATASET(TpcdsItemSk, corpus::GenTpcdsItemSk)
+REGISTER_DATASET(TpcdsQuantity, corpus::GenTpcdsQuantity)
+REGISTER_DATASET(TpcdsCustomerSk, corpus::GenTpcdsCustomerSk)
+REGISTER_DATASET(TpcdsExtSalesPrice, corpus::GenTpcdsExtSalesPrice)
+REGISTER_DATASET(TpcdsNetProfit, corpus::GenTpcdsNetProfit)
+REGISTER_DATASET(TpcdsDYear, corpus::GenTpcdsDYear)
 // TPC-H datasets
-REGISTER_DATASET(TpchLQuantity, GenTpchLQuantity)
-REGISTER_DATASET(TpchLExtendedPrice, GenTpchLExtendedPrice)
-REGISTER_DATASET(TpchLDiscount, GenTpchLDiscount)
-REGISTER_DATASET(TpchLShipDate, GenTpchLShipDate)
+REGISTER_DATASET(TpchLQuantity, corpus::GenTpchLQuantity)
+REGISTER_DATASET(TpchLExtendedPrice, corpus::GenTpchLExtendedPrice)
+REGISTER_DATASET(TpchLDiscount, corpus::GenTpchLDiscount)
+REGISTER_DATASET(TpchLShipDate, corpus::GenTpchLShipDate)
 // NYC taxi datasets
-REGISTER_DATASET(TaxiPickupUnixTime, GenTaxiPickupUnixTime)
-REGISTER_DATASET(TaxiTripDistanceX100, GenTaxiTripDistanceX100)
-REGISTER_DATASET(TaxiFareCents, GenTaxiFareCents)
+REGISTER_DATASET(TaxiPickupUnixTime, corpus::GenTaxiPickupUnixTime)
+REGISTER_DATASET(TaxiTripDistanceX100, corpus::GenTaxiTripDistanceX100)
+REGISTER_DATASET(TaxiFareCents, corpus::GenTaxiFareCents)
 
 // Correlated columns. DELTA_BINARY_PACKED is only used on data of this shape,
 // so any claim about its decode cost has to be measured here and not only on
 // the independently-drawn columns above.
-REGISTER_DATASET(SortedUnixTime, GenSortedUnixTime)
-REGISTER_DATASET(SortedKeyDups, GenSortedKeyDups)
-REGISTER_DATASET(MonotoneRowId, GenMonotoneRowId)
-REGISTER_DATASET(NearSortedUnixTime, GenNearSortedUnixTime)
+REGISTER_DATASET(SortedUnixTime, corpus::GenSortedUnixTime)
+REGISTER_DATASET(SortedKeyDups, corpus::GenSortedKeyDups)
+REGISTER_DATASET(MonotoneRowId, corpus::GenMonotoneRowId)
+REGISTER_DATASET(NearSortedUnixTime, corpus::GenNearSortedUnixTime)
 // int64 / BIGINT datasets (8-byte signed values)
-REGISTER_DATASET64(TsNanos, GenTsNanos)
-REGISTER_DATASET64(OrderKey, GenOrderKey)
-REGISTER_DATASET64(PriceMicros, GenPriceMicros)
-REGISTER_DATASET64(SnowflakeId, GenSnowflakeId)
-REGISTER_DATASET64(ByteCount, GenByteCount)
+REGISTER_DATASET64(TsNanos, corpus::GenTsNanos)
+REGISTER_DATASET64(OrderKey, corpus::GenOrderKey)
+REGISTER_DATASET64(PriceMicros, corpus::GenPriceMicros)
+REGISTER_DATASET64(SnowflakeId, corpus::GenSnowflakeId)
+REGISTER_DATASET64(ByteCount, corpus::GenByteCount)
 
 // Columns with structure between neighbouring values (see delta_shapes above),
 // registered at both widths from the same distribution.
diff --git a/cpp/src/parquet/pfor_corpus_internal.h b/cpp/src/parquet/pfor_corpus_internal.h
new file mode 100644
index 000000000000..ec3d5100cd18
--- /dev/null
+++ b/cpp/src/parquet/pfor_corpus_internal.h
@@ -0,0 +1,661 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+// The integer column corpus the PFOR comparison benchmarks generate: 43 int32
+// columns, a few int64 ones, and a group whose neighbouring values carry
+// structure. It lives in its own header so that every harness measuring
+// these columns reads one definition of them, rather than the benchmark file
+// carrying five hundred lines of generators inline. Nothing here
+// depends on anything but the standard library, so a harness that wants the
+// corpus does not have to pull in Parquet.
+//
+// The columns are synthetic. Each generator is shaped after a distribution seen
+// in ClickBench, TPC-DS, TPC-H or the NYC taxi set; none of them loads a record
+// from those datasets. Bit-unpacking throughput is data-independent at a fixed
+// width, so that substitution is harmless for a timing figure. It is not
+// harmless for any claim about how wide a column packs, since the generator's
+// autocorrelation is chosen rather than observed.
+
+#pragma once
+
+#include <algorithm>
+#include <cmath>
+#include <cstdint>
+#include <limits>
+#include <random>
+#include <vector>
+
+namespace parquet {
+namespace corpus {
+
+inline std::vector<int32_t> GenClientIP(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(101);
+  std::uniform_int_distribution<uint32_t> dist(0x0A000000, 0xDFFFFFFF);
+  for (auto& x : v) x = static_cast<int32_t>(dist(rng));
+  return v;
+}
+
+inline std::vector<int32_t> GenUrlRegionID(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(102);
+  // Zipf-like over ~1000 values
+  std::uniform_real_distribution<double> uni(0.0, 1.0);
+  for (auto& x : v) {
+    double u = uni(rng);
+    x = static_cast<int32_t>(std::pow(u, 2.0) * 1000) + 1;
+  }
+  return v;
+}
+
+inline std::vector<int32_t> GenCounterID(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(103);
+  std::uniform_int_distribution<int32_t> jitter(0, 3);
+  int32_t counter = 100000;
+  for (auto& x : v) {
+    counter += 1 + jitter(rng);
+    x = counter;
+  }
+  return v;
+}
+
+inline std::vector<int32_t> GenEventDate(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(104);
+  const int32_t dates[] = {19691, 19692, 19693, 19694, 19695};
+  std::uniform_int_distribution<int> idx(0, 4);
+  for (auto& x : v) x = dates[idx(rng)];
+  return v;
+}
+
+inline std::vector<int32_t> GenEventTime(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(105);
+  const int32_t base = 1704067200;  // 2024-01-01
+  std::uniform_int_distribution<int32_t> offset(0, 86399);
+  for (auto& x : v) x = base + offset(rng);
+  return v;
+}
+
+inline std::vector<int32_t> GenGoodEvent(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(106);
+  std::uniform_int_distribution<int> dist(0, 99);
+  for (auto& x : v) x = (dist(rng) < 95) ? 1 : 0;
+  return v;
+}
+
+inline std::vector<int32_t> GenHID(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(107);
+  std::uniform_int_distribution<int32_t> dist(std::numeric_limits<int32_t>::min(),
+                                              std::numeric_limits<int32_t>::max());
+  for (auto& x : v) x = dist(rng);
+  return v;
+}
+
+inline std::vector<int32_t> GenHitColor(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(108);
+  const int32_t colors[] = {1, 2, 3, 4, 5};
+  std::uniform_int_distribution<int> idx(0, 4);
+  for (auto& x : v) x = colors[idx(rng)];
+  return v;
+}
+
+inline std::vector<int32_t> GenIPNetworkID(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(109);
+  std::uniform_int_distribution<int32_t> dist(1, 10000);
+  for (auto& x : v) x = dist(rng);
+  return v;
+}
+
+inline std::vector<int32_t> GenJavaEnable(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(110);
+  std::uniform_int_distribution<int> dist(0, 99);
+  for (auto& x : v) x = (dist(rng) < 85) ? 1 : 0;
+  return v;
+}
+
+inline std::vector<int32_t> GenOS(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(111);
+  std::uniform_int_distribution<int32_t> dist(1, 20);
+  for (auto& x : v) x = dist(rng);
+  return v;
+}
+
+inline std::vector<int32_t> GenResolution(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(112);
+  const int32_t resolutions[] = {360,  480,  600,  720,  768,  800,  900,
+                                 1024, 1050, 1080, 1200, 1440, 1600, 2160};
+  std::uniform_int_distribution<int> idx(0, 13);
+  for (auto& x : v) x = resolutions[idx(rng)];
+  return v;
+}
+
+inline std::vector<int32_t> GenTrafficSourceID(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(113);
+  std::uniform_int_distribution<int32_t> dist(0, 10);
+  for (auto& x : v) x = dist(rng);
+  return v;
+}
+
+inline std::vector<int32_t> GenUserAgent(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(114);
+  // Zipf-like over ~100 user agents
+  std::uniform_real_distribution<double> uni(0.0, 1.0);
+  for (auto& x : v) {
+    double u = uni(rng);
+    x = static_cast<int32_t>(std::pow(u, 1.5) * 100) + 1;
+  }
+  return v;
+}
+
+// ----------------------------------------------------------------------
+// Data generators: the four most queried TPC-DS store_sales columns
+
+inline std::vector<int32_t> GenTpcdsSoldDateSk(int64_t n) {
+  std::vector<int32_t> v(n);
+  const int32_t kBase = 2450815;
+  std::mt19937 rng(201);
+  std::uniform_int_distribution<int32_t> dist(0, 1820);
+  for (auto& x : v) x = kBase + dist(rng);
+  return v;
+}
+
+inline std::vector<int32_t> GenTpcdsStoreSk(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(202);
+  std::uniform_int_distribution<int32_t> dist(1, 1000);
+  for (auto& x : v) x = dist(rng);
+  return v;
+}
+
+inline std::vector<int32_t> GenTpcdsItemSk(int64_t n) {
+  std::vector<int32_t> v(n);
+  const int32_t kMax = 100000;
+  std::mt19937 rng(203);
+  std::exponential_distribution<double> exp_dist(0.00005);
+  for (auto& x : v) {
+    int32_t val = static_cast<int32_t>(exp_dist(rng));
+    x = std::min(val + 1, kMax);
+  }
+  return v;
+}
+
+inline std::vector<int32_t> GenTpcdsQuantity(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(204);
+  std::uniform_int_distribution<int32_t> small_dist(1, 10);
+  std::uniform_int_distribution<int32_t> large_dist(11, 100);
+  std::uniform_int_distribution<int> chance(0, 99);
+  for (auto& x : v) {
+    x = (chance(rng) < 90) ? small_dist(rng) : large_dist(rng);
+  }
+  return v;
+}
+
+// --- TPC-H (lineitem) top-queried numeric columns (Q1/Q3/Q5/Q6) ------------
+// l_quantity: integer [1, 50], uniform. Small range, min 1.
+inline std::vector<int32_t> GenTpchLQuantity(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(301);
+  std::uniform_int_distribution<int32_t> dist(1, 50);
+  for (auto& x : v) x = dist(rng);
+  return v;
+}
+
+// l_extendedprice (cents): l_quantity * p_retailprice. p_retailprice spans
+// ~$900.00..$2099.00, so cents in [90000, 10495000]. Wide range, nonzero min.
+inline std::vector<int32_t> GenTpchLExtendedPrice(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(302);
+  std::uniform_int_distribution<int32_t> qty(1, 50);
+  std::uniform_int_distribution<int32_t> retail_cents(90000, 209900);
+  for (auto& x : v) x = qty(rng) * retail_cents(rng);
+  return v;
+}
+
+// l_discount (x100): integer [0, 10] i.e. 0.00..0.10. Includes 0 (0%
+// discount is a real value), so this one starts at 0.
+inline std::vector<int32_t> GenTpchLDiscount(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(303);
+  std::uniform_int_distribution<int32_t> dist(0, 10);
+  for (auto& x : v) x = dist(rng);
+  return v;
+}
+
+// l_shipdate (days since 1970-01-01): 1992-01-01..1998-12 span. Base 8036,
+// range ~7 years. Large nonzero min -> exercises frame-of-reference.
+inline std::vector<int32_t> GenTpchLShipDate(int64_t n) {
+  std::vector<int32_t> v(n);
+  const int32_t kBase = 8036;  // days since epoch for 1992-01-01
+  std::mt19937 rng(304);
+  std::uniform_int_distribution<int32_t> dist(0, 2557);
+  for (auto& x : v) x = kBase + dist(rng);
+  return v;
+}
+
+// --- TPC-DS (store_sales / date_dim) further top-queried numeric columns ---
+// ss_customer_sk: surrogate key, uniform [1, 2,000,000]. Big range, min 1.
+inline std::vector<int32_t> GenTpcdsCustomerSk(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(311);
+  std::uniform_int_distribution<int32_t> dist(1, 2000000);
+  for (auto& x : v) x = dist(rng);
+  return v;
+}
+
+// ss_ext_sales_price (cents): skewed price, exponential mean ~$50, floored at
+// $1.00 (a sale has a nonzero price), capped at $20,000. Long tail -> patches.
+inline std::vector<int32_t> GenTpcdsExtSalesPrice(int64_t n) {
+  std::vector<int32_t> v(n);
+  const int32_t kMin = 100, kMax = 2000000;
+  std::mt19937 rng(312);
+  std::exponential_distribution<double> exp_dist(1.0 / 5000.0);
+  for (auto& x : v) {
+    int32_t val = kMin + static_cast<int32_t>(exp_dist(rng));
+    x = std::min(val, kMax);
+  }
+  return v;
+}
+
+// ss_net_profit (cents): usually a small profit, sometimes a loss -> negative
+// values, so the frame of reference is negative (not zero).
+inline std::vector<int32_t> GenTpcdsNetProfit(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(313);
+  std::uniform_int_distribution<int32_t> dist(-10000, 300000);
+  for (auto& x : v) x = dist(rng);
+  return v;
+}
+
+// d_year: queried date_dim year range [1998, 2003]. Low cardinality, min 1998.
+inline std::vector<int32_t> GenTpcdsDYear(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(314);
+  std::uniform_int_distribution<int32_t> dist(1998, 2003);
+  for (auto& x : v) x = dist(rng);
+  return v;
+}
+
+// --- NYC yellow-taxi trip numeric columns ----------------------------------
+// pickup timestamp (unix seconds): 2015-01, base 1,420,070,400 + ~31 days.
+// Very large min -> frame-of-reference is essential.
+inline std::vector<int32_t> GenTaxiPickupUnixTime(int64_t n) {
+  std::vector<int32_t> v(n);
+  const int32_t kBase = 1420070400;  // 2015-01-01 UTC
+  std::mt19937 rng(321);
+  std::uniform_int_distribution<int32_t> dist(0, 2678400);  // ~31 days
+  for (auto& x : v) x = kBase + dist(rng);
+  return v;
+}
+
+// trip_distance (x100 miles): exponential mean ~1.8 mi, floored at 0.10 mi
+// (no zero-distance trips), capped at 100 mi. Long tail -> patches.
+inline std::vector<int32_t> GenTaxiTripDistanceX100(int64_t n) {
+  std::vector<int32_t> v(n);
+  const int32_t kMin = 10, kMax = 10000;
+  std::mt19937 rng(322);
+  std::exponential_distribution<double> exp_dist(1.0 / 180.0);
+  for (auto& x : v) {
+    int32_t val = kMin + static_cast<int32_t>(exp_dist(rng));
+    x = std::min(val, kMax);
+  }
+  return v;
+}
+
+// fare_amount (cents): $2.50 base + exponential mean ~$10, capped at $150.
+// Nonzero floor at the base fare, skewed with a long tail.
+inline std::vector<int32_t> GenTaxiFareCents(int64_t n) {
+  std::vector<int32_t> v(n);
+  const int32_t kBase = 250, kMax = 15000;
+  std::mt19937 rng(323);
+  std::exponential_distribution<double> exp_dist(1.0 / 1000.0);
+  for (auto& x : v) {
+    int32_t val = kBase + static_cast<int32_t>(exp_dist(rng));
+    x = std::min(val, kMax);
+  }
+  return v;
+}
+
+// ----------------------------------------------------------------------
+// Data generators: int64 columns whose values exceed the int32 range. Covers the common
+// 64-bit analytic cases: nanosecond timestamps, large surrogate keys, scaled-decimal
+// money, monotone IDs, and wide counters.
+
+// Nanosecond epoch timestamp (Parquet TIMESTAMP(NANOS)): 2024-01-01 base plus
+// up to ~1 day of jitter. Min ~1.70e18 -> very large frame of reference; raw
+// values need ~61 bits.
+inline std::vector<int64_t> GenTsNanos(int64_t n) {
+  std::vector<int64_t> v(n);
+  const int64_t kBase = 1704067200000000000LL;  // 2024-01-01T00:00:00Z in ns
+  std::mt19937_64 rng(401);
+  std::uniform_int_distribution<int64_t> off(0, 86399999999999LL);  // ~1 day
+  for (auto& x : v) x = kBase + off(rng);
+  return v;
+}
+
+// BIGINT surrogate / order key, uniform over [1, 10 billion] (exceeds 2^32).
+inline std::vector<int64_t> GenOrderKey(int64_t n) {
+  std::vector<int64_t> v(n);
+  std::mt19937_64 rng(402);
+  std::uniform_int_distribution<int64_t> dist(1, 10000000000LL);
+  for (auto& x : v) x = dist(rng);
+  return v;
+}
+
+// Money as int64 scaled decimal (micro-units): $0.01 .. ~$100k, skewed, with a
+// nonzero floor at one cent.
+inline std::vector<int64_t> GenPriceMicros(int64_t n) {
+  std::vector<int64_t> v(n);
+  const int64_t kMin = 10000, kMax = 100000000000LL;  // $0.01 .. $100,000
+  std::mt19937_64 rng(403);
+  std::exponential_distribution<double> exp_dist(1.0 / 5000000.0);  // mean ~$5
+  for (auto& x : v) {
+    int64_t val = kMin + static_cast<int64_t>(exp_dist(rng));
+    x = std::min(val, kMax);
+  }
+  return v;
+}
+
+// ----------------------------------------------------------------------
+// Data generators: sorted and near-sorted
+//
+// The generators above draw independently around a base, which is the case
+// delta encoding is not for: subtracting two i.i.d. values spans the whole
+// range whichever two you pick, so the distance between them does not matter
+// and every delta variant lands within a bit or two of frame of reference.
+// Comparing delta schemes needs columns whose value depends on the previous
+// one. These cover the shapes that occur in practice: a clustered timestamp
+// column, a sorted key with duplicates, an exact counter, and a column that
+// is sorted apart from a few late arrivals.
+
+// Event timestamps in seconds, arriving a few seconds apart. The common case
+// for a table clustered or sorted on time.
+inline std::vector<int32_t> GenSortedUnixTime(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(401);
+  std::uniform_int_distribution<int32_t> gap(0, 7);
+  int32_t t = 1700000000;
+  for (auto& x : v) {
+    t += gap(rng);
+    x = t;
+  }
+  return v;
+}
+
+// A sorted surrogate key with runs of duplicates, as produced by a join key or
+// a dictionary-sorted column: most steps are 0, some are 1.
+inline std::vector<int32_t> GenSortedKeyDups(int64_t n) {
+  std::vector<int32_t> v(n);
+  std::mt19937 rng(402);
+  std::uniform_int_distribution<int32_t> step(0, 1);
+  int32_t k = 5000000;
+  for (auto& x : v) {
+    k += step(rng);
+    x = k;
+  }
+  return v;
+}
+
+// An exact +1 row id. The best case for any delta scheme, and the case where
+// stride-1 and lane-parallel delta differ most.
+inline std::vector<int32_t> GenMonotoneRowId(int64_t n) {
+  std::vector<int32_t> v(n);
+  int32_t k = 1;
+  for (auto& x : v) x = k++;
+  return v;
+}
+
+// Sorted except that 2% of rows arrive late, so a few deltas are large and
+// negative. Tests whether one bit width per block survives outliers.
+inline std::vector<int32_t> GenNearSortedUnixTime(int64_t n) {
+  std::vector<int32_t> v = GenSortedUnixTime(n);
+  std::mt19937 rng(403);
+  std::uniform_int_distribution<int> pick(0, 49);
+  std::uniform_int_distribution<int32_t> late(1, 3600);
+  for (auto& x : v) {
+    if (pick(rng) == 0) x -= late(rng);
+  }
+  return v;
+}
+
+// Snowflake-style monotone ID: large base + jittered per-row increments.
+// Monotone -> ideal for DELTA_BINARY_PACKED; huge min -> ideal for PFOR's FOR.
+inline std::vector<int64_t> GenSnowflakeId(int64_t n) {
+  std::vector<int64_t> v(n);
+  std::mt19937_64 rng(404);
+  std::uniform_int_distribution<int64_t> step(1, 4096);
+  int64_t id = 1500000000000000000LL;
+  for (auto& x : v) {
+    id += step(rng);
+    x = id;
+  }
+  return v;
+}
+
+// Wide cumulative byte counts, uniform [1024, 5 trillion] (wide 64-bit range).
+inline std::vector<int64_t> GenByteCount(int64_t n) {
+  std::vector<int64_t> v(n);
+  std::mt19937_64 rng(405);
+  std::uniform_int_distribution<int64_t> dist(1024, 5000000000000LL);
+  for (auto& x : v) x = dist(rng);
+  return v;
+}
+
+// ----------------------------------------------------------------------
+// Data generators: structure between neighboring values
+
+// The generators above are all either unordered or perfectly regular, so none
+// of them separates an encoding that differences neighbouring values from one
+// that packs them, and none of them puts a frame of reference anywhere but the
+// minimum. These do: they are the columns on which PFOR's delta mode and
+// DELTA_BINARY_PACKED make different choices.
+//
+// They are templates rather than a pair of per-width functions, which keeps a
+// column's int32 and int64 registration on provably the same distribution. They
+// live in their own namespace because two of them build on base distributions
+// whose names are already taken above by columns drawn from different seeds --
+// keeping them separate is what makes these figures comparable with
+// pfor_benchmark.cc, which uses the same shapes.
+namespace delta_shapes {
+
+template <typename T>
+std::vector<T> GenSmallRange(int64_t n) {
+  std::vector<T> v(n);
+  std::mt19937_64 rng(12345);
+  std::uniform_int_distribution<T> dist(100000, 200000);
+  for (auto& x : v) x = dist(rng);
+  return v;
+}
+
+template <typename T>
+std::vector<T> GenTpcdsItemSk(int64_t n) {
+  std::vector<T> v(n);
+  const T kMax = 100000;
+  std::mt19937_64 rng(12345);
+  std::exponential_distribution<double> exp_dist(0.00005);
+  for (auto& x : v) {
+    T val = static_cast<T>(exp_dist(rng));
+    x = std::min(static_cast<T>(val + 1), kMax);
+  }
+  return v;
+}
+
+/// A timestamp column with a fixed sampling interval and jitter: the
+/// differences cluster tightly around the interval, the values do not.
+template <typename T>
+std::vector<T> GenTrendJitter(int64_t n) {
+  std::vector<T> v(n);
+  std::mt19937_64 rng(7);
+  std::normal_distribution<double> jitter(0.0, 40.0);
+  double t = 1704067200.0;
+  for (auto& x : v) {
+    t += 3.0;
+    x = static_cast<T>(t + jitter(rng));
+  }
+  return v;
+}
+
+/// A TCP congestion window: a linear climb cut by a sharp halving. Almost
+/// every difference is the same small number and a few are large and
+/// negative, which is the shape a two-sided frame plus patching handles at
+/// close to no cost and a one-sided one cannot.
+template <typename T>
+std::vector<T> GenSawtooth(int64_t n) {
+  std::vector<T> v(n);
+  T cur = 1000;
+  for (int64_t i = 0; i < n; ++i) {
+    if (i % 200 == 199) {
+      cur /= 2;
+    } else {
+      cur += 12;
+    }
+    v[i] = cur;
+  }
+  return v;
+}
+
+/// A continuous quantity sampled over time, so the rate of change is bounded
+/// but the level wanders: differencing wins, though not by much.
+template <typename T>
+std::vector<T> GenMeasurement(int64_t n) {
+  std::vector<T> v(n);
+  std::mt19937_64 rng(11);
+  std::normal_distribution<double> noise(0.0, 1.0);
+  double level = 0.0;
+  double rate = 0.0;
+  for (int64_t i = 0; i < n; ++i) {
+    rate = 0.95 * rate + noise(rng);
+    level += rate;
+    v[i] = static_cast<T>(4000.0 * level / 50.0) + static_cast<T>(500000);
+  }
+  return v;
+}
+
+/// A sorted surrogate key column, which is what a clustered index or a
+/// sorted-by-key file produces.
+template <typename T>
+std::vector<T> GenSortedKeys(int64_t n) {
+  auto v = GenTpcdsItemSk<T>(n);
+  std::sort(v.begin(), v.end());
+  return v;
+}
+
+/// A measurement series punctuated by a low sentinel standing in for "no
+/// reading". The sentinel sits far below the cluster, so a frame pinned to
+/// the minimum has to widen to reach it and no value can ever be patched.
+template <typename T>
+std::vector<T> GenSensorDropouts(int64_t n) {
+  auto v = GenMeasurement<T>(n);
+  std::mt19937_64 rng(3);
+  std::uniform_int_distribution<int64_t> pos(0, n - 1);
+  for (int64_t i = 0; i < std::max<int64_t>(1, n / 200); ++i) {
+    v[pos(rng)] = static_cast<T>(-999999);
+  }
+  return v;
+}
+
+/// Monotonic ids with occasional large jumps, as a sequence shared between
+/// writers or restarted produces.
+template <typename T>
+std::vector<T> GenIdsWithGaps(int64_t n) {
+  std::vector<T> v(n);
+  std::mt19937_64 rng(5);
+  std::uniform_int_distribution<int> step(1, 6);
+  std::uniform_int_distribution<int> jump(0, 199);
+  T cur = 1000000;
+  for (auto& x : v) {
+    cur += static_cast<T>(step(rng));
+    if (jump(rng) == 0) cur += 100000;
+    x = cur;
+  }
+  return v;
+}
+
+/// Prices on a random walk: small signed steps around a high base, and no
+/// trend for the differences to line up on.
+template <typename T>
+std::vector<T> GenRandomWalk(int64_t n) {
+  std::vector<T> v(n);
+  std::mt19937_64 rng(13);
+  std::uniform_int_distribution<int> step(-25, 25);
+  T cur = 1500000;
+  for (auto& x : v) {
+    cur += static_cast<T>(step(rng));
+    x = cur;
+  }
+  return v;
+}
+
+/// Event arrival times in milliseconds since the epoch, bursty, so the gaps
+/// are skewed rather than clustered.
+template <typename T>
+std::vector<T> GenEventMillis(int64_t n) {
+  std::vector<T> v(n);
+  std::mt19937_64 rng(17);
+  std::exponential_distribution<double> gap(0.4);
+  double t = 1704067200.0;
+  for (auto& x : v) {
+    t += gap(rng);
+    x = static_cast<T>(t);
+  }
+  return v;
+}
+
+/// A tight unordered cluster with a low "missing" sentinel: the frame cannot
+/// sit at the minimum and differencing has nothing to exploit either, so
+/// this is the column that has to come out no worse than before.
+template <typename T>
+std::vector<T> GenLowSentinel(int64_t n) {
+  auto v = GenSmallRange<T>(n);
+  std::mt19937_64 rng(23);
+  std::uniform_int_distribution<int64_t> pos(0, n - 1);
+  for (int64_t i = 0; i < std::max<int64_t>(1, n / 200); ++i) {
+    v[pos(rng)] = static_cast<T>(-1000);
+  }
+  return v;
+}
+
+/// Two interleaved clusters far apart, so no single window covers the vector
+/// and the cheaper cluster is worth framing on its own.
+template <typename T>
+std::vector<T> GenBimodal(int64_t n) {
+  std::vector<T> v(n);
+  std::mt19937_64 rng(19);
+  std::uniform_int_distribution<T> lo(1000, 1100);
+  std::uniform_int_distribution<T> hi(900000, 900100);
+  std::uniform_int_distribution<int> pick(0, 9);
+  for (auto& x : v) {
+    x = pick(rng) < 8 ? lo(rng) : hi(rng);
+  }
+  return v;
+}
+
+}  // namespace delta_shapes
+
+}  // namespace corpus
+}  // namespace parquet

From 7f697e0052ad7517e6e188854aac43feebaa44e2 Mon Sep 17 00:00:00 2001
From: Prateek Gaur <prateek.gaur@snowflake.com>
Date: Sun, 20 Sep 2026 04:46:42 +0000
Subject: [PATCH 24/27] Transpose FL_ORDER blocks in NEON registers

Arm had only the portable scratch-grid path for FL_ORDER. A four-lane
NEON transpose now writes file order directly. Every packed width is
checked with and without a frame bias.
---
 .../arrow/util/fastlanes/interleaved_pfor.h   | 69 +++++++++++++++++++
 .../arrow/util/fastlanes/transposed_delta.h   | 39 +++++++++++
 2 files changed, 108 insertions(+)

diff --git a/cpp/src/arrow/util/fastlanes/interleaved_pfor.h b/cpp/src/arrow/util/fastlanes/interleaved_pfor.h
index 0dba63a319fe..bee2ed1bf60b 100644
--- a/cpp/src/arrow/util/fastlanes/interleaved_pfor.h
+++ b/cpp/src/arrow/util/fastlanes/interleaved_pfor.h
@@ -251,6 +251,75 @@ inline void UnpackBlockFlToFileOrder(const uint32_t* ARROW_RESTRICT packed,
 
 #endif  // ARROW_TRANSPOSED_DELTA_AVX2
 
+#if !defined(ARROW_FASTLANES_FUSED_FL_UNPACK) && defined(ARROW_TRANSPOSED_DELTA_NEON)
+
+namespace internal {
+
+// One 4x4 tile, the NEON counterpart of FlUnpackTile: unpack four rows' worth of
+// a 4-lane slice, transpose in registers, store across four output rows. The
+// shuffle sequence is the one Transpose32x32Neon uses; only the source of
+// r0..r3 differs.
+// Four-wide rather than eight-wide because that is the register width, which
+// costs four times as many tiles per block but the same number of loads and
+// stores -- a 16-byte store of four output values either way.
+template <uint32_t w, bool kHasBias, uint32_t rb>
+ARROW_FORCE_INLINE void FlUnpackTileNeon(const uint32_t* ARROW_RESTRICT packed,
+                                         int32_t* ARROW_RESTRICT out, size_t lb,
+                                         uint32x4_t vmask, uint32x4_t vbias) {
+  const uint32x4_t r0 =
+      FlUnpackRowSliceNeon<w, kHasBias, rb + 0>(packed, lb, vmask, vbias);
+  const uint32x4_t r1 =
+      FlUnpackRowSliceNeon<w, kHasBias, rb + 1>(packed, lb, vmask, vbias);
+  const uint32x4_t r2 =
+      FlUnpackRowSliceNeon<w, kHasBias, rb + 2>(packed, lb, vmask, vbias);
+  const uint32x4_t r3 =
+      FlUnpackRowSliceNeon<w, kHasBias, rb + 3>(packed, lb, vmask, vbias);
+
+  const uint32x4x2_t a = vtrnq_u32(r0, r1);
+  const uint32x4x2_t c = vtrnq_u32(r2, r3);
+
+  uint32_t* dst = reinterpret_cast<uint32_t*>(out) + lb * kRowsPerBlock + rb;
+  vst1q_u32(dst, vcombine_u32(vget_low_u32(a.val[0]), vget_low_u32(c.val[0])));
+  dst += kRowsPerBlock;
+  vst1q_u32(dst, vcombine_u32(vget_low_u32(a.val[1]), vget_low_u32(c.val[1])));
+  dst += kRowsPerBlock;
+  vst1q_u32(dst, vcombine_u32(vget_high_u32(a.val[0]), vget_high_u32(c.val[0])));
+  dst += kRowsPerBlock;
+  vst1q_u32(dst, vcombine_u32(vget_high_u32(a.val[1]), vget_high_u32(c.val[1])));
+}
+
+}  // namespace internal
+
+#  define ARROW_FASTLANES_FUSED_FL_UNPACK 1
+
+// Unpacks a block that was packed in FL_ORDER and writes it in file order,
+// adding `bias` on the way through. Equivalent to UnpackBlock<w, true> into a
+// scratch grid followed by Transpose32x32, without the grid.
+template <uint32_t w, bool kHasBias>
+inline void UnpackBlockFlToFileOrder(const uint32_t* ARROW_RESTRICT packed,
+                                     int32_t* ARROW_RESTRICT out, uint32_t bias = 0) {
+  static_assert(w >= 1 && w <= 32);
+  constexpr uint32_t kMask = (w == 32) ? 0xFFFFFFFFu : ((1u << w) - 1);
+  const uint32x4_t vmask = vdupq_n_u32(kMask);
+  const uint32x4_t vbias = vdupq_n_u32(bias);
+
+  // lb outer for the same reason as the x86 kernel: a fixed lb writes one
+  // contiguous 512-byte run of the output, where rb outer would stride 128 bytes
+  // across the whole 4 KiB block.
+  for (size_t lb = 0; lb < kLanes; lb += 4) {
+    internal::FlUnpackTileNeon<w, kHasBias, 0>(packed, out, lb, vmask, vbias);
+    internal::FlUnpackTileNeon<w, kHasBias, 4>(packed, out, lb, vmask, vbias);
+    internal::FlUnpackTileNeon<w, kHasBias, 8>(packed, out, lb, vmask, vbias);
+    internal::FlUnpackTileNeon<w, kHasBias, 12>(packed, out, lb, vmask, vbias);
+    internal::FlUnpackTileNeon<w, kHasBias, 16>(packed, out, lb, vmask, vbias);
+    internal::FlUnpackTileNeon<w, kHasBias, 20>(packed, out, lb, vmask, vbias);
+    internal::FlUnpackTileNeon<w, kHasBias, 24>(packed, out, lb, vmask, vbias);
+    internal::FlUnpackTileNeon<w, kHasBias, 28>(packed, out, lb, vmask, vbias);
+  }
+}
+
+#endif  // NEON fused FL_ORDER unpack
+
 // Returns bytes written, or 0 if some block's span exceeds 32 bits (it never
 // does for plain int32 values: max - min fits in 32 bits unconditionally).
 template <InterleavedPforOrder kOrder>
diff --git a/cpp/src/arrow/util/fastlanes/transposed_delta.h b/cpp/src/arrow/util/fastlanes/transposed_delta.h
index 46c3cc309a84..327cc71aed61 100644
--- a/cpp/src/arrow/util/fastlanes/transposed_delta.h
+++ b/cpp/src/arrow/util/fastlanes/transposed_delta.h
@@ -129,6 +129,45 @@ ARROW_FORCE_INLINE __m256i FlUnpackRowSlice(const uint32_t* ARROW_RESTRICT packe
 }  // namespace internal
 #endif
 
+#ifdef ARROW_TRANSPOSED_DELTA_NEON
+namespace internal {
+
+// One 4-lane slice of one row, unpacked in registers: the NEON counterpart of
+// FlUnpackRowSlice above, and the same reason for `row` being a template
+// parameter -- vshrq_n_u32 takes an immediate, so the word index, the shift
+// amounts and the straddle test all have to be compile-time constants.
+template <uint32_t w, bool kHasBias, uint32_t row>
+ARROW_FORCE_INLINE uint32x4_t FlUnpackRowSliceNeon(const uint32_t* ARROW_RESTRICT packed,
+                                                   size_t lb, uint32x4_t vmask,
+                                                   uint32x4_t vbias) {
+  constexpr uint32_t kT = 32;
+  constexpr uint32_t kStartBit = row * w;
+  constexpr uint32_t kWord = kStartBit / kT;
+  constexpr uint32_t kShift = kStartBit % kT;
+  constexpr uint32_t kEndWord = (kStartBit + w - 1) / kT;
+
+  uint32x4_t v = vld1q_u32(packed + kWord * kLanes + lb);
+  if constexpr (kShift != 0) {
+    v = vshrq_n_u32(v, kShift);
+  }
+  if constexpr (kWord != kEndWord) {
+    // A value that straddles two words has to start partway into the first, so
+    // kShift is nonzero here and the left shift below is never by 32.
+    const uint32x4_t hi = vld1q_u32(packed + kEndWord * kLanes + lb);
+    v = vorrq_u32(v, vshlq_n_u32(hi, kT - kShift));
+  }
+  if constexpr (w != 32) {
+    v = vandq_u32(v, vmask);
+  }
+  if constexpr (kHasBias) {
+    v = vaddq_u32(v, vbias);
+  }
+  return v;
+}
+
+}  // namespace internal
+#endif
+
 enum class TransposedBaseCoding { kRaw, kPacked };
 
 // How a decoder gets back to file order. kNone is not a conforming decoder and

From e27369f5f1e102aa4e5b0ba9384e84965690cc20 Mon Sep 17 00:00:00 2001
From: Prateek Gaur <prateek.gaur@snowflake.com>
Date: Sun, 4 Oct 2026 20:56:28 +0000
Subject: [PATCH 25/27] Generalize block kernels over element width

The interleaved block kernels only wrote uint32_t, so three-bit values
could not decode into a byte even though nothing about the layout needs
32 bits. BlockGeometry<T> derives the grid from the element: a
1024-value block is 8 rows of 128 lanes for uint8_t and 16 rows of 64
lanes for uint16_t. The packed payload stays 128 * w bytes at every
element width, the same as the sequential layout. kLanes and
kRowsPerBlock still name the 32-bit grid, so the delta and PFOR formats
built on it are unchanged.

The round-trip tests cover every bit width for all three element types,
with and without a bias. They pack into a buffer that already holds
another block, because a page encoder relies on each kernel fully
defining its own payload, and they check that a lane reads as an
ordinary sequentially packed stream.
---
 cpp/src/arrow/util/CMakeLists.txt             |   3 +
 .../fastlanes/fastlanes_kernels_internal.h    | 226 ++++++++++-------
 .../util/fastlanes/fastlanes_kernels_test.cc  | 239 ++++++++++++++++++
 .../interleaved_kernel_table_internal.h       |   4 +-
 .../arrow/util/fastlanes/interleaved_pfor.h   |  22 +-
 cpp/src/arrow/util/fastlanes/lane_delta.h     |  12 +-
 .../arrow/util/fastlanes/transposed_delta.h   |  12 +-
 7 files changed, 401 insertions(+), 117 deletions(-)
 create mode 100644 cpp/src/arrow/util/fastlanes/fastlanes_kernels_test.cc

diff --git a/cpp/src/arrow/util/CMakeLists.txt b/cpp/src/arrow/util/CMakeLists.txt
index 9be9dbfa7188..eeda9dd7b0bd 100644
--- a/cpp/src/arrow/util/CMakeLists.txt
+++ b/cpp/src/arrow/util/CMakeLists.txt
@@ -118,6 +118,9 @@ add_arrow_test(threading-utility-test
                test_common.cc
                thread_pool_test.cc)
 
+add_arrow_test(fastlanes-kernels-test
+                SOURCES fastlanes/fastlanes_kernels_test.cc)
+
 add_arrow_test(pfor-test SOURCES pfor/pfor_test.cc)
 
 add_arrow_benchmark(pfor/pfor_benchmark)
diff --git a/cpp/src/arrow/util/fastlanes/fastlanes_kernels_internal.h b/cpp/src/arrow/util/fastlanes/fastlanes_kernels_internal.h
index ae531e04edf2..28a256923102 100644
--- a/cpp/src/arrow/util/fastlanes/fastlanes_kernels_internal.h
+++ b/cpp/src/arrow/util/fastlanes/fastlanes_kernels_internal.h
@@ -34,29 +34,31 @@
 // so nothing has to be permuted on the way out and exception positions stay
 // meaningful without translation.
 //
-// Within a 1024-value block (32 lanes x 32 rows for uint32_t), the packed
-// buffer holds w u32 rows of 32 u32 words, where w is the bit width. Row r,
-// lane l contributes to packed[word * 32 + l] at bit shift (r*w) % 32, where
-// word = (r*w) / 32, possibly straddling into packed[word * 32 + 32 + l].
-// (word == r only when w == 32.)
+// A block holds kBlockSize values whatever the element width, so the grid is
+// sizeof(T)*8 rows by kBlockSize/(sizeof(T)*8) lanes: 32 rows of 32 lanes for
+// uint32_t, 16 rows of 64 lanes for uint16_t, 8 rows of 128 lanes for uint8_t.
+// The packed buffer holds w rows of kLanes words. Row r, lane l contributes to
+// packed[word * kLanes + l] at bit shift (r*w) % kBits, where
+// word = (r*w) / kBits, possibly straddling into packed[endWord * kLanes + l].
+// (word == r only when w == kBits.) The payload is 128 * w bytes at every
+// element width, the same size the sequential layout needs for a full block.
 //
 // Bits are assembled exactly as sequential bit-packing assembles them: within
 // one lane, successive rows occupy successive bit positions LSB-first, and a
 // value that runs off the end of a word continues in the low bits of the next.
 // The two layouts differ only in which values land at adjacent bit positions --
 // successive rows of one lane here, successive values of the stream in
-// arrow::internal::unpack -- not in how the bits of a value are laid out. That
-// is why the shift and the straddle depend on the row and never on the lane,
-// and so why all 32 lanes do identical work. The payload is byte-identical in
-// size to the sequential layout for a full block: 128 * w bytes.
+// arrow::internal::unpack -- not in how the bits of a value are laid out. So
+// the shift and the straddle depend on the row and never on the lane, and all
+// lanes do identical work.
 //
 // Both kernels take an Arch type parameter their bodies never mention, so that
 // this one source compiled at two different instruction sets yields two
-// distinct symbols. Without it, PackBlock<16> compiled with NEON flags and
-// PackBlock<16> compiled with SVE flags share a mangled name, the linker keeps
-// one definition, and every caller silently gets whichever copy it kept --
-// undoing the per-instruction-set translation units of
-// interleaved_dispatch_internal.h with no diagnostic.
+// distinct symbols. Without it, PackBlock<uint32_t, 16> compiled with NEON
+// flags and the same instantiation compiled with SVE flags share a mangled
+// name, the linker keeps one definition, and every caller silently gets
+// whichever copy it kept -- undoing the per-instruction-set translation units
+// of interleaved_dispatch_internal.h with no diagnostic.
 // arrow::internal::bpacking carries the parameter for the same reason. A caller
 // that compiles exactly one copy of these kernels leaves it at its default and
 // is unaffected.
@@ -66,6 +68,7 @@
 #include <cstddef>
 #include <cstdint>
 #include <cstring>
+#include <type_traits>
 
 #include "arrow/util/macros.h"
 
@@ -74,112 +77,151 @@ namespace util {
 namespace fastlanes {
 
 constexpr size_t kBlockSize = 1024;
-constexpr size_t kLanes = 32;         // 1024 / sizeof(uint32_t) / 8
-constexpr size_t kRowsPerBlock = 32;  // 1024 / kLanes
 
-static_assert(kLanes * kRowsPerBlock == kBlockSize,
-              "every value of a block must land in exactly one lane and row");
+// Grid geometry for one block of T.
+template <typename T>
+struct BlockGeometry {
+  static_assert(std::is_unsigned_v<T> && !std::is_same_v<T, bool>,
+                "element type must be an unsigned integer wider than bool");
+  static constexpr size_t kBits = sizeof(T) * 8;
+  static constexpr size_t kRowsPerBlock = kBits;
+  static constexpr size_t kLanes = kBlockSize / kBits;
+
+  static_assert(kLanes * kRowsPerBlock == kBlockSize,
+                "every value of a block must land in exactly one lane and row");
+};
+
+// The 32-bit grid the PFOR and delta wire formats are written on. Those formats
+// hold these values in their payload arithmetic, so they keep an unqualified
+// name here; a codec at another element width asks BlockGeometry<T> instead.
+constexpr size_t kLanes = BlockGeometry<uint32_t>::kLanes;
+constexpr size_t kRowsPerBlock = BlockGeometry<uint32_t>::kRowsPerBlock;
+
+// Shifts and masks are evaluated in this type, which is unsigned and never
+// narrower than the element. uint8_t and uint16_t would otherwise promote to
+// int. A masked value below 2^w shifted by less than the element width cannot
+// reach 2^31, so the result is the same either way; naming the type keeps the
+// kernel bodies free of promotion concerns.
+template <typename T>
+using BlockWord = std::conditional_t<(sizeof(T) < sizeof(uint32_t)), uint32_t, T>;
+
+template <typename T, uint32_t w>
+constexpr BlockWord<T> BlockMask() {
+  using W = BlockWord<T>;
+  constexpr size_t kBits = BlockGeometry<T>::kBits;
+  // w == kBits would shift by the width of W when W is exactly T, so that case
+  // takes the all-ones form instead.
+  if constexpr (w >= kBits) {
+    return static_cast<W>(~W(0) >> (sizeof(W) * 8 - kBits));
+  } else {
+    return static_cast<W>((W(1) << w) - 1);
+  }
+}
 
 // ---------------------------------------------------------------------------
-// Pack: 1024 u32 inputs, in input order -> w*32 u32 packed words.
+// Pack: kBlockSize inputs, in input order -> w * kLanes packed words.
 // ---------------------------------------------------------------------------
-template <uint32_t w, typename Arch = void>
-inline void PackBlock(const uint32_t* ARROW_RESTRICT in, uint32_t* ARROW_RESTRICT out) {
-  static_assert(w >= 1 && w <= 32);
-  constexpr uint32_t kMask = (w == 32) ? 0xFFFFFFFFu : ((1u << w) - 1);
-
-  if constexpr (w == 32) {
-    std::memcpy(out, in, kBlockSize * sizeof(uint32_t));
+template <typename T, uint32_t w, typename Arch = void>
+inline void PackBlock(const T* ARROW_RESTRICT in, T* ARROW_RESTRICT out) {
+  using G = BlockGeometry<T>;
+  using W = BlockWord<T>;
+  static_assert(w >= 1 && w <= G::kBits);
+  constexpr W kMask = BlockMask<T, w>();
+  constexpr uint32_t kT = static_cast<uint32_t>(G::kBits);
+
+  if constexpr (w == G::kBits) {
+    std::memcpy(out, in, kBlockSize * sizeof(T));
     return;
-  }
-
-  std::memset(out, 0, w * kLanes * sizeof(uint32_t));
+  } else {
+    std::memset(out, 0, w * G::kLanes * sizeof(T));
 
 #pragma GCC unroll 32
-  for (uint32_t row = 0; row < kRowsPerBlock; ++row) {
-    constexpr uint32_t kT = 32;
-    const uint32_t startBit = row * w;
-    const uint32_t word = startBit / kT;
-    const uint32_t shift = startBit % kT;
-    const uint32_t endBit = startBit + w;
-    const uint32_t endWord = (endBit - 1) / kT;
-
-    if (word == endWord) {
-      for (uint32_t lane = 0; lane < kLanes; ++lane) {
-        const uint32_t v = in[row * kLanes + lane] & kMask;
-        out[word * kLanes + lane] |= (v << shift);
-      }
-    } else {
-      // shift is never 0 in this branch -- a value that straddles has to start
-      // partway into its word -- so the >> below is never a shift by 32.
-      const uint32_t lowBits = kT - shift;
-      for (uint32_t lane = 0; lane < kLanes; ++lane) {
-        const uint32_t v = in[row * kLanes + lane] & kMask;
-        out[word * kLanes + lane] |= (v << shift);
-        out[endWord * kLanes + lane] |= (v >> lowBits);
+    for (uint32_t row = 0; row < G::kRowsPerBlock; ++row) {
+      const uint32_t startBit = row * w;
+      const uint32_t word = startBit / kT;
+      const uint32_t shift = startBit % kT;
+      const uint32_t endBit = startBit + w;
+      const uint32_t endWord = (endBit - 1) / kT;
+
+      if (word == endWord) {
+        for (uint32_t lane = 0; lane < G::kLanes; ++lane) {
+          const W v = static_cast<W>(in[row * G::kLanes + lane]) & kMask;
+          out[word * G::kLanes + lane] |= static_cast<T>(v << shift);
+        }
+      } else {
+        // shift is never 0 in this branch -- a value that straddles has to
+        // start partway into its word -- so the >> below is never a shift by
+        // the full word width.
+        const uint32_t lowBits = kT - shift;
+        for (uint32_t lane = 0; lane < G::kLanes; ++lane) {
+          const W v = static_cast<W>(in[row * G::kLanes + lane]) & kMask;
+          out[word * G::kLanes + lane] |= static_cast<T>(v << shift);
+          out[endWord * G::kLanes + lane] |= static_cast<T>(v >> lowBits);
+        }
       }
     }
   }
 }
 
 // ---------------------------------------------------------------------------
-// Unpack: w*32 packed u32 words -> 1024 u32 outputs in input order.
+// Unpack: w * kLanes packed words -> kBlockSize outputs in input order.
 //
 // With kHasBias, `bias` is added to every value before it is stored, so a
 // frame-of-reference decoder does not need a second pass over the output to add
 // it. That pass costs 1.47x-2.40x of the unpack it follows, and a pass that
 // only copies costs the same as one that adds, so what is paid for is the
-// traversal rather than the arithmetic. The add is modular in uint32_t,
-// matching the encoder's subtraction. kHasBias is a template parameter rather
-// than a runtime argument so the no-bias instantiations carry no test in their
-// inner loop.
+// traversal rather than the arithmetic. The add is modular in T, matching the
+// encoder's subtraction. kHasBias is a template parameter rather than a runtime
+// argument so the no-bias instantiations carry no test in their inner loop.
 // ---------------------------------------------------------------------------
-template <uint32_t w, bool kHasBias = false, typename Arch = void>
-inline void UnpackBlock(const uint32_t* ARROW_RESTRICT packed,
-                        uint32_t* ARROW_RESTRICT out, uint32_t bias = 0) {
-  static_assert(w >= 1 && w <= 32);
-  constexpr uint32_t kMask = (w == 32) ? 0xFFFFFFFFu : ((1u << w) - 1);
-
-  if constexpr (w == 32) {
+template <typename T, uint32_t w, bool kHasBias = false, typename Arch = void>
+inline void UnpackBlock(const T* ARROW_RESTRICT packed, T* ARROW_RESTRICT out,
+                        T bias = 0) {
+  using G = BlockGeometry<T>;
+  using W = BlockWord<T>;
+  static_assert(w >= 1 && w <= G::kBits);
+  constexpr W kMask = BlockMask<T, w>();
+  constexpr uint32_t kT = static_cast<uint32_t>(G::kBits);
+
+  if constexpr (w == G::kBits) {
     if constexpr (kHasBias) {
-      // A loop, not memcpy-then-add: both pointers are restrict-qualified
-      // uint32_t*, so this vectorizes and stays a single traversal.
+      // A loop, not memcpy-then-add: both pointers are restrict-qualified T*,
+      // so this vectorizes and stays a single traversal.
       for (size_t i = 0; i < kBlockSize; ++i) {
-        out[i] = packed[i] + bias;
+        out[i] = static_cast<T>(packed[i] + bias);
       }
     } else {
-      std::memcpy(out, packed, kBlockSize * sizeof(uint32_t));
+      std::memcpy(out, packed, kBlockSize * sizeof(T));
     }
     return;
-  }
-
+  } else {
 #pragma GCC unroll 32
-  for (uint32_t row = 0; row < kRowsPerBlock; ++row) {
-    constexpr uint32_t kT = 32;
-    const uint32_t startBit = row * w;
-    const uint32_t word = startBit / kT;
-    const uint32_t shift = startBit % kT;
-    const uint32_t endBit = startBit + w;
-    const uint32_t endWord = (endBit - 1) / kT;
-
-    if (word == endWord) {
-      for (uint32_t lane = 0; lane < kLanes; ++lane) {
-        uint32_t v = (packed[word * kLanes + lane] >> shift) & kMask;
-        if constexpr (kHasBias) {
-          v += bias;
+    for (uint32_t row = 0; row < G::kRowsPerBlock; ++row) {
+      const uint32_t startBit = row * w;
+      const uint32_t word = startBit / kT;
+      const uint32_t shift = startBit % kT;
+      const uint32_t endBit = startBit + w;
+      const uint32_t endWord = (endBit - 1) / kT;
+
+      if (word == endWord) {
+        for (uint32_t lane = 0; lane < G::kLanes; ++lane) {
+          W v = (static_cast<W>(packed[word * G::kLanes + lane]) >> shift) & kMask;
+          if constexpr (kHasBias) {
+            v = static_cast<W>(v + static_cast<W>(bias));
+          }
+          out[row * G::kLanes + lane] = static_cast<T>(v);
         }
-        out[row * kLanes + lane] = v;
-      }
-    } else {
-      const uint32_t lowBits = kT - shift;
-      for (uint32_t lane = 0; lane < kLanes; ++lane) {
-        const uint32_t lo = packed[word * kLanes + lane] >> shift;
-        const uint32_t hi = packed[endWord * kLanes + lane] << lowBits;
-        uint32_t v = (lo | hi) & kMask;
-        if constexpr (kHasBias) {
-          v += bias;
+      } else {
+        const uint32_t lowBits = kT - shift;
+        for (uint32_t lane = 0; lane < G::kLanes; ++lane) {
+          const W lo = static_cast<W>(packed[word * G::kLanes + lane]) >> shift;
+          const W hi = static_cast<W>(packed[endWord * G::kLanes + lane]) << lowBits;
+          W v = (lo | hi) & kMask;
+          if constexpr (kHasBias) {
+            v = static_cast<W>(v + static_cast<W>(bias));
+          }
+          out[row * G::kLanes + lane] = static_cast<T>(v);
         }
-        out[row * kLanes + lane] = v;
       }
     }
   }
diff --git a/cpp/src/arrow/util/fastlanes/fastlanes_kernels_test.cc b/cpp/src/arrow/util/fastlanes/fastlanes_kernels_test.cc
new file mode 100644
index 000000000000..0f2c28ee1caf
--- /dev/null
+++ b/cpp/src/arrow/util/fastlanes/fastlanes_kernels_test.cc
@@ -0,0 +1,239 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include <gtest/gtest.h>
+
+#include <cstdint>
+#include <random>
+#include <utility>
+#include <vector>
+
+#include "arrow/util/fastlanes/fastlanes_kernels_internal.h"
+#include "arrow/util/fastlanes/interleaved_pfor.h"
+#include "arrow/util/fastlanes/transposed_delta.h"
+
+namespace arrow::util::fastlanes {
+
+namespace {
+
+// Applies `fn` to every bit width the element type can hold, as a compile-time
+// constant, so each width instantiates its own kernel the way a caller does.
+template <typename T, typename Fn, uint32_t... Ws>
+void ForEachWidthImpl(Fn&& fn, std::integer_sequence<uint32_t, Ws...>) {
+  (fn(std::integral_constant<uint32_t, Ws + 1>{}), ...);
+}
+
+template <typename T, typename Fn>
+void ForEachWidth(Fn&& fn) {
+  ForEachWidthImpl<T>(std::forward<Fn>(fn),
+                      std::make_integer_sequence<uint32_t, BlockGeometry<T>::kBits>{});
+}
+
+template <typename T>
+std::vector<T> RandomValues(uint32_t w, uint32_t seed) {
+  const auto mask =
+      static_cast<T>(BlockWord<T>(~BlockWord<T>(0)) >> (sizeof(BlockWord<T>) * 8 - w));
+  std::mt19937 rng(seed);
+  std::vector<T> in(kBlockSize);
+  for (auto& v : in) v = static_cast<T>(rng() & mask);
+  return in;
+}
+
+// A caller packs block after block into one page buffer, so a kernel that left
+// any of its payload untouched would read back whatever the previous block put
+// there. Tests hand it a buffer already full of this pattern rather than a
+// zeroed one, so clearing the payload stays load-bearing.
+template <typename T>
+constexpr T kDirty = static_cast<T>(0xACACACACu);
+
+// Reads `w` bits starting at `bit_offset` from one lane's own stream, which is
+// the words at packed[k * kLanes + lane] taken LSB-first.
+template <typename T>
+uint64_t ReadLaneBits(const T* packed, size_t lane, uint32_t bit_offset, uint32_t w) {
+  constexpr size_t kBits = BlockGeometry<T>::kBits;
+  constexpr size_t kLanesT = BlockGeometry<T>::kLanes;
+  uint64_t out = 0;
+  for (uint32_t i = 0; i < w; ++i) {
+    const uint32_t bit = bit_offset + i;
+    const uint64_t word = packed[(bit / kBits) * kLanesT + lane];
+    out |= ((word >> (bit % kBits)) & 1ULL) << i;
+  }
+  return out;
+}
+
+}  // namespace
+
+template <typename T>
+class FastlanesKernelsTest : public ::testing::Test {};
+
+using ElementTypes = ::testing::Types<uint8_t, uint16_t, uint32_t>;
+TYPED_TEST_SUITE(FastlanesKernelsTest, ElementTypes);
+
+// A block holds kBlockSize values at every element width, so a narrower element
+// trades rows for lanes.
+TYPED_TEST(FastlanesKernelsTest, GridCoversTheBlockExactly) {
+  using G = BlockGeometry<TypeParam>;
+  EXPECT_EQ(G::kLanes * G::kRowsPerBlock, kBlockSize);
+  EXPECT_EQ(G::kRowsPerBlock, sizeof(TypeParam) * 8);
+}
+
+// The packed payload is 128 * w bytes however wide the element is, which is the
+// size the sequential layout needs for the same full block.
+TYPED_TEST(FastlanesKernelsTest, PayloadSizeDoesNotDependOnElementWidth) {
+  using G = BlockGeometry<TypeParam>;
+  ForEachWidth<TypeParam>([](auto w_const) {
+    constexpr uint32_t w = decltype(w_const)::value;
+    EXPECT_EQ(w * G::kLanes * sizeof(TypeParam), 128u * w) << "w=" << w;
+  });
+}
+
+TYPED_TEST(FastlanesKernelsTest, RoundTripsEveryWidth) {
+  using G = BlockGeometry<TypeParam>;
+  ForEachWidth<TypeParam>([](auto w_const) {
+    constexpr uint32_t w = decltype(w_const)::value;
+    const auto in = RandomValues<TypeParam>(w, 1000u * w + sizeof(TypeParam));
+    std::vector<TypeParam> packed(w * G::kLanes, kDirty<TypeParam>);
+    std::vector<TypeParam> out(kBlockSize, 0);
+    PackBlock<TypeParam, w>(in.data(), packed.data());
+    UnpackBlock<TypeParam, w, false>(packed.data(), out.data());
+    EXPECT_EQ(in, out) << "w=" << w;
+  });
+}
+
+#ifdef ARROW_FASTLANES_FUSED_FL_UNPACK
+// UnpackBlockFlToFileOrder claims to equal an UnpackBlock into a scratch grid
+// followed by Transpose32x32, with the permutation done in registers instead.
+// That is the claim a caller depends on when it picks the fused kernel over the
+// grid, and the two are separate implementations of it, so comparing them is a
+// real check rather than a kernel agreeing with itself. 32-bit only, which is
+// why this is not one of the typed tests above.
+TEST(FastlanesFileOrderTest, MatchesTheGridAndTransposeAtEveryWidth) {
+  using G = BlockGeometry<uint32_t>;
+  ForEachWidth<uint32_t>([](auto w_const) {
+    constexpr uint32_t w = decltype(w_const)::value;
+    const auto in = RandomValues<uint32_t>(w, 311u * w + 7u);
+    std::vector<uint32_t> packed(w * G::kLanes, kDirty<uint32_t>);
+    PackBlock<uint32_t, w>(in.data(), packed.data());
+
+    std::vector<uint32_t> grid(kBlockSize, 0);
+    std::vector<int32_t> expected(kBlockSize, 0);
+    UnpackBlock<uint32_t, w, false>(packed.data(), grid.data());
+    Transpose32x32(grid.data(), expected.data());
+
+    std::vector<int32_t> actual(kBlockSize, 0);
+    UnpackBlockFlToFileOrder<w, false>(packed.data(), actual.data());
+
+    for (size_t i = 0; i < kBlockSize; ++i) {
+      ASSERT_EQ(actual[i], expected[i]) << "w=" << w << " i=" << i;
+    }
+  });
+}
+#endif
+
+// The bias is folded into the unpack so a frame-of-reference decoder needs no
+// second pass. It is modular in the element type, matching the subtraction the
+// encoder did.
+TYPED_TEST(FastlanesKernelsTest, FoldsBiasModuloTheElementWidth) {
+  using G = BlockGeometry<TypeParam>;
+  ForEachWidth<TypeParam>([](auto w_const) {
+    constexpr uint32_t w = decltype(w_const)::value;
+    const auto in = RandomValues<TypeParam>(w, 77u * w + sizeof(TypeParam));
+    // A bias large enough to wrap for every element width.
+    const auto bias = static_cast<TypeParam>(0xF1u);
+    std::vector<TypeParam> packed(w * G::kLanes, kDirty<TypeParam>);
+    std::vector<TypeParam> out(kBlockSize, 0);
+    PackBlock<TypeParam, w>(in.data(), packed.data());
+    UnpackBlock<TypeParam, w, true>(packed.data(), out.data(), bias);
+    for (size_t i = 0; i < kBlockSize; ++i) {
+      ASSERT_EQ(out[i], static_cast<TypeParam>(in[i] + bias)) << "w=" << w << " i=" << i;
+    }
+  });
+}
+
+// The payload is exactly w * kLanes words. A kernel that wrote past it would
+// corrupt the next block of a page.
+TYPED_TEST(FastlanesKernelsTest, PackWritesNothingPastThePayload) {
+  using G = BlockGeometry<TypeParam>;
+  ForEachWidth<TypeParam>([](auto w_const) {
+    constexpr uint32_t w = decltype(w_const)::value;
+    constexpr size_t kGuard = 16;
+    const auto in = RandomValues<TypeParam>(w, 5u * w + sizeof(TypeParam));
+    std::vector<TypeParam> packed(w * G::kLanes + kGuard, kDirty<TypeParam>);
+    PackBlock<TypeParam, w>(in.data(), packed.data());
+    // Still holding the pattern, so the kernel did not write here at all,
+    // rather than having written a zero that happened to look untouched.
+    for (size_t i = w * G::kLanes; i < packed.size(); ++i) {
+      ASSERT_EQ(packed[i], kDirty<TypeParam>) << "w=" << w << " guard index " << i;
+    }
+  });
+}
+
+// The layout contract: within one lane, successive rows occupy successive bit
+// positions LSB-first, exactly as sequential bit packing assembles them. The
+// shift and the straddle therefore depend on the row and never on the lane.
+TYPED_TEST(FastlanesKernelsTest, LaneBitsAreSequentialLsbFirst) {
+  using G = BlockGeometry<TypeParam>;
+  ForEachWidth<TypeParam>([](auto w_const) {
+    constexpr uint32_t w = decltype(w_const)::value;
+    const auto in = RandomValues<TypeParam>(w, 31u * w + sizeof(TypeParam));
+    std::vector<TypeParam> packed(w * G::kLanes, kDirty<TypeParam>);
+    PackBlock<TypeParam, w>(in.data(), packed.data());
+    // Checking two lanes is enough to show the bit positions do not depend on
+    // the lane, and keeps the test linear in the block size.
+    for (size_t lane : {size_t{0}, G::kLanes - 1}) {
+      for (uint32_t row = 0; row < G::kRowsPerBlock; ++row) {
+        const uint64_t got = ReadLaneBits<TypeParam>(packed.data(), lane, row * w, w);
+        ASSERT_EQ(got, static_cast<uint64_t>(in[row * G::kLanes + lane]))
+            << "w=" << w << " lane=" << lane << " row=" << row;
+      }
+    }
+  });
+}
+
+// Packing into a buffer a previous block wrote must leave none of that block
+// behind, which is the contract a page encoder relies on when it walks one
+// output buffer block by block.
+TYPED_TEST(FastlanesKernelsTest, PackOverwritesAnEarlierBlock) {
+  using G = BlockGeometry<TypeParam>;
+  ForEachWidth<TypeParam>([](auto w_const) {
+    constexpr uint32_t w = decltype(w_const)::value;
+    const auto first = RandomValues<TypeParam>(w, 400u * w + sizeof(TypeParam));
+    const auto second = RandomValues<TypeParam>(w, 900u * w + sizeof(TypeParam));
+    std::vector<TypeParam> packed(w * G::kLanes, 0);
+    std::vector<TypeParam> out(kBlockSize, 0);
+    PackBlock<TypeParam, w>(first.data(), packed.data());
+    PackBlock<TypeParam, w>(second.data(), packed.data());
+    UnpackBlock<TypeParam, w, false>(packed.data(), out.data());
+    EXPECT_EQ(second, out) << "w=" << w;
+  });
+}
+
+// At w == the element width there is nothing to pack, and the kernels degrade to
+// a copy. Callers rely on that staying a round trip rather than a special case
+// they have to avoid.
+TYPED_TEST(FastlanesKernelsTest, FullWidthIsACopy) {
+  constexpr uint32_t kFull = BlockGeometry<TypeParam>::kBits;
+  const auto in = RandomValues<TypeParam>(kFull, 9u);
+  std::vector<TypeParam> packed(kBlockSize, kDirty<TypeParam>);
+  std::vector<TypeParam> out(kBlockSize, 0);
+  PackBlock<TypeParam, kFull>(in.data(), packed.data());
+  EXPECT_EQ(in, packed);
+  UnpackBlock<TypeParam, kFull, false>(packed.data(), out.data());
+  EXPECT_EQ(in, out);
+}
+
+}  // namespace arrow::util::fastlanes
diff --git a/cpp/src/arrow/util/fastlanes/interleaved_kernel_table_internal.h b/cpp/src/arrow/util/fastlanes/interleaved_kernel_table_internal.h
index 5cceb32093b5..317547e10960 100644
--- a/cpp/src/arrow/util/fastlanes/interleaved_kernel_table_internal.h
+++ b/cpp/src/arrow/util/fastlanes/interleaved_kernel_table_internal.h
@@ -47,12 +47,12 @@ namespace fastlanes {
 // constant and never reaches a kernel.
 template <typename Arch, size_t... W>
 constexpr std::array<InterleavedPackFn, 33> MakePackTable(std::index_sequence<W...>) {
-  return {nullptr, &PackBlock<W + 1, Arch>...};
+  return {nullptr, &PackBlock<uint32_t, W + 1, Arch>...};
 }
 
 template <typename Arch, bool kHasBias, size_t... W>
 constexpr std::array<InterleavedUnpackFn, 33> MakeUnpackTable(std::index_sequence<W...>) {
-  return {nullptr, &UnpackBlock<W + 1, kHasBias, Arch>...};
+  return {nullptr, &UnpackBlock<uint32_t, W + 1, kHasBias, Arch>...};
 }
 
 // Arch defaults to the architecture xsimd derives from the including
diff --git a/cpp/src/arrow/util/fastlanes/interleaved_pfor.h b/cpp/src/arrow/util/fastlanes/interleaved_pfor.h
index bee2ed1bf60b..9e8aaad6d906 100644
--- a/cpp/src/arrow/util/fastlanes/interleaved_pfor.h
+++ b/cpp/src/arrow/util/fastlanes/interleaved_pfor.h
@@ -106,19 +106,19 @@ inline size_t InterleavedPforMaxEncodedSize(size_t n) {
          (n % kBlockSize) * sizeof(int32_t);
 }
 
-#define ILP_PACK_CASE(W)     \
-  case W:                    \
-    PackBlock<W>(grid, dst); \
+#define ILP_PACK_CASE(W)               \
+  case W:                              \
+    PackBlock<uint32_t, W>(grid, dst); \
     break;
 
-#define ILP_UNPACK_CASE(W)                \
-  case W:                                 \
-    UnpackBlock<W, true>(src, dst, bias); \
+#define ILP_UNPACK_CASE(W)                          \
+  case W:                                           \
+    UnpackBlock<uint32_t, W, true>(src, dst, bias); \
     break;
 
-#define ILP_UNPACK_SCRATCH_CASE(W)            \
-  case W:                                     \
-    UnpackBlock<W, true>(src, scratch, bias); \
+#define ILP_UNPACK_SCRATCH_CASE(W)                      \
+  case W:                                               \
+    UnpackBlock<uint32_t, W, true>(src, scratch, bias); \
     break;
 
 #define ILP_UNPACK_FUSED_CASE(W)                           \
@@ -231,7 +231,7 @@ ARROW_FORCE_INLINE void FlUnpackTile(const uint32_t* ARROW_RESTRICT packed,
 #  define ARROW_FASTLANES_FUSED_FL_UNPACK 1
 
 // Unpacks a block that was packed in FL_ORDER and writes it in file order,
-// adding `bias` on the way through. Equivalent to UnpackBlock<w, true> into a
+// adding `bias` on the way through. Equivalent to UnpackBlock<uint32_t, w, true> into a
 // scratch grid followed by Transpose32x32, without the grid.
 template <uint32_t w, bool kHasBias>
 inline void UnpackBlockFlToFileOrder(const uint32_t* ARROW_RESTRICT packed,
@@ -293,7 +293,7 @@ ARROW_FORCE_INLINE void FlUnpackTileNeon(const uint32_t* ARROW_RESTRICT packed,
 #  define ARROW_FASTLANES_FUSED_FL_UNPACK 1
 
 // Unpacks a block that was packed in FL_ORDER and writes it in file order,
-// adding `bias` on the way through. Equivalent to UnpackBlock<w, true> into a
+// adding `bias` on the way through. Equivalent to UnpackBlock<uint32_t, w, true> into a
 // scratch grid followed by Transpose32x32, without the grid.
 template <uint32_t w, bool kHasBias>
 inline void UnpackBlockFlToFileOrder(const uint32_t* ARROW_RESTRICT packed,
diff --git a/cpp/src/arrow/util/fastlanes/lane_delta.h b/cpp/src/arrow/util/fastlanes/lane_delta.h
index 764c7dfd2c22..fe91a95b59a2 100644
--- a/cpp/src/arrow/util/fastlanes/lane_delta.h
+++ b/cpp/src/arrow/util/fastlanes/lane_delta.h
@@ -89,14 +89,14 @@ inline size_t LaneDeltaMaxEncodedSize(size_t n) {
          (n % kBlockSize) * sizeof(int32_t);
 }
 
-#define LANE_DELTA_PACK_CASE(W) \
-  case W:                       \
-    PackBlock<W>(grid, dst);    \
+#define LANE_DELTA_PACK_CASE(W)        \
+  case W:                              \
+    PackBlock<uint32_t, W>(grid, dst); \
     break;
 
-#define LANE_DELTA_UNPACK_CASE(W)          \
-  case W:                                  \
-    UnpackBlock<W, true>(src, grid, bias); \
+#define LANE_DELTA_UNPACK_CASE(W)                    \
+  case W:                                            \
+    UnpackBlock<uint32_t, W, true>(src, grid, bias); \
     break;
 
 // clang-format off
diff --git a/cpp/src/arrow/util/fastlanes/transposed_delta.h b/cpp/src/arrow/util/fastlanes/transposed_delta.h
index 327cc71aed61..8cde66543151 100644
--- a/cpp/src/arrow/util/fastlanes/transposed_delta.h
+++ b/cpp/src/arrow/util/fastlanes/transposed_delta.h
@@ -264,14 +264,14 @@ inline size_t TransposedMaxEncodedSize(size_t n) {
          n * sizeof(uint32_t) + (n % kBlockSize) * sizeof(int32_t) + 8;
 }
 
-#define TPOSE_PACK_CASE(W)   \
-  case W:                    \
-    PackBlock<W>(grid, dst); \
+#define TPOSE_PACK_CASE(W)             \
+  case W:                              \
+    PackBlock<uint32_t, W>(grid, dst); \
     break;
 
-#define TPOSE_UNPACK_CASE(W)               \
-  case W:                                  \
-    UnpackBlock<W, true>(src, grid, bias); \
+#define TPOSE_UNPACK_CASE(W)                         \
+  case W:                                            \
+    UnpackBlock<uint32_t, W, true>(src, grid, bias); \
     break;
 
 #define TPOSE_FUSED_UNPACK_CASE(W)                                              \

From 36f08544ebd009caba1e5c4f4e27b52ee1e5db76 Mon Sep 17 00:00:00 2001
From: Prateek Gaur <prateek.gaur@snowflake.com>
Date: Mon, 5 Oct 2026 01:51:25 +0000
Subject: [PATCH 26/27] Add a bit-unpack width and footprint benchmark

Times the interleaved block decoder against Arrow's sequential
unpackers: the shipped dispatch entry point, the scalar kernel, and on
AVX2 builds the vector kernel pinned to AVX2. One sweep decodes 16 KiB
and moves the bit width from 1 to 32, decoding into the narrowest whole
byte. The other holds eight widths and moves the decoded size from 16
KiB to 4 MiB.

On 32-bit output the interleaved decoder also runs with the permutation
back to file order, through the fused kernel where there is one and a
scratch grid otherwise. A new test checks that the fused kernel and the
grid path produce the same values. The target links xsimd for the kernel
it names.
---
 cpp/src/arrow/util/CMakeLists.txt             |   5 +-
 .../fastlanes/fastlanes_kernels_benchmark.cc  | 380 ++++++++++++++++++
 2 files changed, 384 insertions(+), 1 deletion(-)
 create mode 100644 cpp/src/arrow/util/fastlanes/fastlanes_kernels_benchmark.cc

diff --git a/cpp/src/arrow/util/CMakeLists.txt b/cpp/src/arrow/util/CMakeLists.txt
index eeda9dd7b0bd..b58fe4e47acd 100644
--- a/cpp/src/arrow/util/CMakeLists.txt
+++ b/cpp/src/arrow/util/CMakeLists.txt
@@ -119,10 +119,13 @@ add_arrow_test(threading-utility-test
                thread_pool_test.cc)
 
 add_arrow_test(fastlanes-kernels-test
-                SOURCES fastlanes/fastlanes_kernels_test.cc)
+               SOURCES fastlanes/fastlanes_kernels_test.cc)
 
 add_arrow_test(pfor-test SOURCES pfor/pfor_test.cc)
 
+add_arrow_benchmark(fastlanes/fastlanes_kernels_benchmark EXTRA_LINK_LIBS
+                    ${ARROW_XSIMD})
+
 add_arrow_benchmark(pfor/pfor_benchmark)
 
 add_arrow_benchmark(bit_block_counter_benchmark)
diff --git a/cpp/src/arrow/util/fastlanes/fastlanes_kernels_benchmark.cc b/cpp/src/arrow/util/fastlanes/fastlanes_kernels_benchmark.cc
new file mode 100644
index 000000000000..7ef7911ac3d3
--- /dev/null
+++ b/cpp/src/arrow/util/fastlanes/fastlanes_kernels_benchmark.cc
@@ -0,0 +1,380 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include "benchmark/benchmark.h"
+
+#include <algorithm>
+#include <chrono>
+#include <cstdint>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <memory>
+#include <random>
+#include <string>
+#include <type_traits>
+#include <utility>
+
+#include <xsimd/xsimd.hpp>
+
+#include "arrow/util/bpacking_dispatch_internal.h"
+#include "arrow/util/bpacking_internal.h"
+#include "arrow/util/bpacking_scalar_internal.h"
+#include "arrow/util/bpacking_simd_kernel_internal.h"
+#include "arrow/util/fastlanes/fastlanes_kernels_internal.h"
+#include "arrow/util/fastlanes/interleaved_pfor.h"
+#include "arrow/util/fastlanes/transposed_delta.h"
+#include "arrow/util/macros.h"
+
+// Times the interleaved block decoder against Arrow's sequential bit-unpack
+// paths at a fixed decoded footprint. Both layouts read w bits per value and
+// write whole elements, so a block of 1024 values is 128 * w packed bytes in
+// either one and a ratio between two rows compares layouts, not data volume.
+// Values decode into the narrowest whole byte that holds w bits, as a reader
+// filling a fixed-width column would choose.
+
+namespace arrow::util::fastlanes {
+
+namespace {
+
+// Arrow's sequential decoders may read a whole word past the last value they
+// need, so every packed buffer carries this much slack past its last byte.
+constexpr size_t kPackedTailSlack = 64;
+
+// The narrowest whole-byte element that holds a w-bit value.
+template <uint32_t w>
+using NextWholeByte =
+    std::conditional_t<(w <= 8), uint8_t,
+                       std::conditional_t<(w <= 16), uint16_t, uint32_t>>;
+
+// Buffers are aligned the way Arrow aligns a column's buffers. The interleaved
+// decoder stores a whole register at a time, and on a destination that is not
+// register-aligned each store straddles two cache lines, which halves its
+// throughput and makes a row depend on earlier allocations.
+constexpr size_t kBufferAlignment = 64;
+
+template <typename T>
+struct AlignedFree {
+  void operator()(T* p) const { std::free(p); }
+};
+
+template <typename T>
+using AlignedArray = std::unique_ptr<T[], AlignedFree<T>>;
+
+template <typename T>
+AlignedArray<T> AllocateAligned(size_t num_elements) {
+  const size_t bytes = (num_elements * sizeof(T) + kBufferAlignment - 1) /
+                       kBufferAlignment * kBufferAlignment;
+  auto* p = static_cast<T*>(std::aligned_alloc(kBufferAlignment, bytes));
+  if (p == nullptr) std::abort();
+  return AlignedArray<T>(p);
+}
+
+// Packed bytes are random: both decoders are data-independent at a fixed
+// width, and round trips are covered by fastlanes_kernels_test.cc.
+template <typename T>
+void RandomFill(T* data, size_t n) {
+  std::mt19937_64 rng(42);
+  auto* bytes = reinterpret_cast<uint8_t*>(data);
+  const size_t total = n * sizeof(T);
+  size_t i = 0;
+  for (; i + sizeof(uint64_t) <= total; i += sizeof(uint64_t)) {
+    const uint64_t v = rng();
+    std::memcpy(bytes + i, &v, sizeof(v));
+  }
+  for (; i < total; ++i) bytes[i] = static_cast<uint8_t>(rng());
+}
+
+// The sequential decoders are called once per 16384 values rather than once
+// over the footprint, because batch_size is an int that the unpacker multiplies
+// by the bit width. At 16384 values a call runs at 0.95x to 1.00x of a single
+// call over the same data, against 0.58x at 1024 values, so the page size does
+// not handicap the sequential side.
+constexpr size_t kSequentialPageValues = 16384;
+
+// Kept out of line for the same reason as DecodePage below.
+template <typename T, uint32_t w, typename Fn>
+ARROW_NOINLINE void DecodePagesSequential(const uint8_t* packed, T* out,
+                                          size_t num_values, size_t page_values,
+                                          Fn&& decode) {
+  // The last page is short when the footprint is not a whole number of pages.
+  ::arrow::internal::UnpackOptions opts{.batch_size = static_cast<int>(page_values),
+                                        .bit_width = static_cast<int>(w)};
+  for (size_t v = 0; v < num_values; v += page_values) {
+    const size_t n = std::min(page_values, num_values - v);
+    opts.batch_size = static_cast<int>(n);
+    decode(packed + v * w / 8, out + v, opts);
+  }
+}
+
+// The dispatched entry point libarrow ships.
+template <typename T, uint32_t w>
+void BM_Sequential(benchmark::State& state, size_t out_bytes) {
+  const size_t num_values = out_bytes / sizeof(T) / kBlockSize * kBlockSize;
+  const size_t page_values = std::min(kSequentialPageValues, num_values);
+  const size_t packed_bytes = num_values * w / 8;
+  auto packed = AllocateAligned<uint8_t>(packed_bytes + kPackedTailSlack);
+  RandomFill(packed.get(), packed_bytes + kPackedTailSlack);
+  auto out = AllocateAligned<T>(num_values);
+  const auto decode = [](const uint8_t* src, T* dst,
+                         const ::arrow::internal::UnpackOptions& o) {
+    ::arrow::internal::unpack<T>(src, dst, o);
+  };
+
+  for (auto _ : state) {
+    DecodePagesSequential<T, w>(packed.get(), out.get(), num_values, page_values, decode);
+    benchmark::DoNotOptimize(out[0]);
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(static_cast<int64_t>(num_values * sizeof(T)) *
+                          state.iterations());
+  state.SetItemsProcessed(static_cast<int64_t>(num_values) * state.iterations());
+}
+
+#if defined(ARROW_HAVE_AVX2)
+// Arrow's vector kernel compiled in this file with the instruction set pinned
+// to AVX2. Under ARROW_SIMD_LEVEL=AVX512 the dispatched entry point is built
+// with AVX-512 flags even in bpacking_simd_256.cc, and that code assembles
+// vectors a byte at a time, which bpacking.cc already gives as its reason not
+// to dispatch to AVX-512. The pin keeps that cost out of a layout comparison.
+// It does not cover the code the compiler vectorizes around the kernel, which
+// still follows this file's flags.
+template <typename T, int w>
+using Avx2Kernel = ::arrow::internal::bpacking::Kernel<T, w, xsimd::avx2>;
+
+template <typename T, uint32_t w>
+void BM_SequentialSimd(benchmark::State& state, size_t out_bytes) {
+  const size_t num_values = out_bytes / sizeof(T) / kBlockSize * kBlockSize;
+  const size_t page_values = std::min(kSequentialPageValues, num_values);
+  const size_t packed_bytes = num_values * w / 8;
+  auto packed = AllocateAligned<uint8_t>(packed_bytes + kPackedTailSlack);
+  RandomFill(packed.get(), packed_bytes + kPackedTailSlack);
+  auto out = AllocateAligned<T>(num_values);
+  const auto decode = [](const uint8_t* src, T* dst,
+                         const ::arrow::internal::UnpackOptions& o) {
+    ::arrow::internal::bpacking::unpack_width<w, Avx2Kernel, false>(
+        src, dst, o.batch_size, o.bit_offset, o.max_read_bytes, T{});
+  };
+
+  for (auto _ : state) {
+    DecodePagesSequential<T, w>(packed.get(), out.get(), num_values, page_values, decode);
+    benchmark::DoNotOptimize(out[0]);
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(static_cast<int64_t>(num_values * sizeof(T)) *
+                          state.iterations());
+  state.SetItemsProcessed(static_cast<int64_t>(num_values) * state.iterations());
+}
+#endif  // ARROW_HAVE_AVX2
+
+// The scalar kernel, called directly. At some bit widths the dispatched kernel
+// is slower than this one.
+template <typename T, uint32_t w>
+void BM_SequentialScalar(benchmark::State& state, size_t out_bytes) {
+  const size_t num_values = out_bytes / sizeof(T) / kBlockSize * kBlockSize;
+  const size_t page_values = std::min(kSequentialPageValues, num_values);
+  const size_t packed_bytes = num_values * w / 8;
+  auto packed = AllocateAligned<uint8_t>(packed_bytes + kPackedTailSlack);
+  RandomFill(packed.get(), packed_bytes + kPackedTailSlack);
+  auto out = AllocateAligned<T>(num_values);
+  const auto decode = [](const uint8_t* src, T* dst,
+                         const ::arrow::internal::UnpackOptions& o) {
+    ::arrow::internal::bpacking::unpack_scalar<T>(src, dst, o);
+  };
+
+  for (auto _ : state) {
+    DecodePagesSequential<T, w>(packed.get(), out.get(), num_values, page_values, decode);
+    benchmark::DoNotOptimize(out[0]);
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(static_cast<int64_t>(num_values * sizeof(T)) *
+                          state.iterations());
+  state.SetItemsProcessed(static_cast<int64_t>(num_values) * state.iterations());
+}
+
+// The decode loop gets its own out-of-line function per element and bit width.
+// Left inside the registered lambdas, the loops share one inlining budget, and
+// the widths registered last compile to a partly scalar loop several times
+// slower than the same kernel on its own. The cost is one call per page, which
+// the sequential decoder pays as well.
+template <typename T, uint32_t w>
+ARROW_NOINLINE void DecodePage(const T* packed, T* out, size_t num_blocks) {
+  using G = BlockGeometry<T>;
+  for (size_t b = 0; b < num_blocks; ++b) {
+    UnpackBlock<T, w, false>(packed + b * w * G::kLanes, out + b * kBlockSize);
+  }
+}
+
+// The same block permuted from the FastLanes lane assignment (kFlOrderRaw) back
+// to file order. Only data packed with that assignment, such as transposed
+// delta, pays this; a grid filled in input order (kFileOrder, and the
+// kForBitPackInterleaved page mode) already decodes in file order. The fused
+// kernel permutes in registers, and the fallback goes through a scratch grid as
+// InterleavedPforDecode does. Both are 32-bit only.
+template <uint32_t w>
+ARROW_NOINLINE void DecodePageFileOrder(const uint32_t* packed, int32_t* out,
+                                        size_t num_blocks) {
+  using G = BlockGeometry<uint32_t>;
+#ifdef ARROW_FASTLANES_FUSED_FL_UNPACK
+  for (size_t b = 0; b < num_blocks; ++b) {
+    UnpackBlockFlToFileOrder<w, false>(packed + b * w * G::kLanes, out + b * kBlockSize);
+  }
+#else
+  uint32_t scratch[kBlockSize];
+  for (size_t b = 0; b < num_blocks; ++b) {
+    UnpackBlock<uint32_t, w, false>(packed + b * w * G::kLanes, scratch);
+    Transpose32x32(scratch, out + b * kBlockSize);
+  }
+#endif
+}
+
+template <typename T, uint32_t w>
+void BM_Interleaved(benchmark::State& state, size_t out_bytes) {
+  using G = BlockGeometry<T>;
+  const size_t num_values = out_bytes / sizeof(T);
+  const size_t num_blocks = num_values / kBlockSize;
+  const size_t packed_elements = num_blocks * w * G::kLanes;
+  auto packed = AllocateAligned<T>(packed_elements);
+  RandomFill(packed.get(), packed_elements);
+  auto out = AllocateAligned<T>(num_values);
+
+  for (auto _ : state) {
+    DecodePage<T, w>(packed.get(), out.get(), num_blocks);
+    benchmark::DoNotOptimize(out[0]);
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(static_cast<int64_t>(out_bytes) * state.iterations());
+  state.SetItemsProcessed(static_cast<int64_t>(num_values) * state.iterations());
+}
+
+template <uint32_t w>
+void BM_InterleavedFileOrder(benchmark::State& state, size_t out_bytes) {
+  using G = BlockGeometry<uint32_t>;
+  const size_t num_values = out_bytes / sizeof(uint32_t);
+  const size_t num_blocks = num_values / kBlockSize;
+  const size_t packed_elements = num_blocks * w * G::kLanes;
+  auto packed = AllocateAligned<uint32_t>(packed_elements);
+  RandomFill(packed.get(), packed_elements);
+  auto out = AllocateAligned<int32_t>(num_values);
+
+  for (auto _ : state) {
+    DecodePageFileOrder<w>(packed.get(), out.get(), num_blocks);
+    benchmark::DoNotOptimize(out[0]);
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(static_cast<int64_t>(out_bytes) * state.iterations());
+  state.SetItemsProcessed(static_cast<int64_t>(num_values) * state.iterations());
+}
+
+std::string Label(const char* decoder, uint32_t w, size_t element_bits,
+                  const char* pinned, size_t pinned_kib) {
+  return std::string("bitunpack/") + decoder + "/w=" + std::to_string(w) + "/u" +
+         std::to_string(element_bits) + "/" + pinned + "=" + std::to_string(pinned_kib) +
+         "KiB";
+}
+
+// A width needs one registration per decoder, and w has to be a constant for
+// the interleaved kernel, so the widths are walked at compile time.
+template <uint32_t w>
+void RegisterWidth(size_t out_bytes, const char* pinned, size_t pinned_kib) {
+  using T = NextWholeByte<w>;
+  constexpr size_t kBits = sizeof(T) * 8;
+  // A block is the decode unit, so a footprint below one block of this element
+  // width has nothing to measure.
+  if (out_bytes / sizeof(T) < kBlockSize) return;
+
+#if defined(ARROW_HAVE_AVX2)
+  benchmark::RegisterBenchmark(
+      Label("seq_simd", w, kBits, pinned, pinned_kib),
+      [out_bytes](benchmark::State& st) { BM_SequentialSimd<T, w>(st, out_bytes); });
+#endif
+  benchmark::RegisterBenchmark(
+      Label("seq_lib", w, kBits, pinned, pinned_kib),
+      [out_bytes](benchmark::State& st) { BM_Sequential<T, w>(st, out_bytes); });
+  benchmark::RegisterBenchmark(
+      Label("seq_scal", w, kBits, pinned, pinned_kib),
+      [out_bytes](benchmark::State& st) { BM_SequentialScalar<T, w>(st, out_bytes); });
+  if constexpr (std::is_same_v<T, uint32_t>) {
+    benchmark::RegisterBenchmark(
+        Label("interleaved_file_order", w, kBits, pinned, pinned_kib),
+        [out_bytes](benchmark::State& st) { BM_InterleavedFileOrder<w>(st, out_bytes); });
+  }
+  benchmark::RegisterBenchmark(
+      Label("interleaved_fl_order", w, kBits, pinned, pinned_kib),
+      [out_bytes](benchmark::State& st) { BM_Interleaved<T, w>(st, out_bytes); });
+}
+
+template <uint32_t... Ws>
+void RegisterAllWidths(size_t out_bytes, std::integer_sequence<uint32_t, Ws...>) {
+  (RegisterWidth<Ws + 1>(out_bytes, "out", out_bytes / 1024), ...);
+}
+
+// The width sweep decodes 16 KiB, so destination plus packed source stays under
+// 32 KiB at every width and fits in a 48 KiB L1 data cache.
+constexpr size_t kWidthSweepOutBytes = 16 * 1024;
+
+// Decoded sizes for the footprint sweep, from inside L1 to 4 MiB, which is
+// already larger than a Parquet page. They are not labelled by cache level
+// because the packed source adds w bits per value on top, so the level a row
+// reaches depends on the width as well.
+constexpr size_t kFootprintKiB[] = {16, 32, 48, 64, 128, 256, 512, 1024, 2048, 4096};
+
+template <uint32_t... Ws>
+void RegisterFootprintWidths(size_t out_bytes, size_t kib) {
+  (RegisterWidth<Ws>(out_bytes, "out", kib), ...);
+}
+
+// The widths the footprint sweep uses, and the column each one stands for. Each
+// output size gets a width where Arrow's sequential kernel is fast and, for u8
+// and u16, one where it is slow, so a row is not mistaken for a property of the
+// element size.
+//
+//    3 -> u8    a status enum, or a dictionary of eight or fewer values
+//    4 -> u8    the same column at a width the sequential kernel handles well
+//    7 -> u8    a dictionary of up to 128 values
+//   11 -> u16   a dictionary of a couple of thousand values
+//   12 -> u16   the same column at a width the sequential kernel handles well
+//   14 -> u16   a date held as a day offset, or a dictionary near 16k
+//   18 -> u32   a key offset by its row group minimum
+//   21 -> u32   the same column three bits wider
+//
+// No width equals its output width, where the decode is a copy, not an unpack.
+void RegisterFootprintSweep() {
+  for (size_t kib : kFootprintKiB) {
+    // The width sweep already registers this size under the same names.
+    if (kib * 1024 == kWidthSweepOutBytes) continue;
+    RegisterFootprintWidths<3, 4, 7, 11, 12, 14, 18, 21>(kib * 1024, kib);
+  }
+}
+
+void RegisterBenchmarks() {
+  RegisterAllWidths(kWidthSweepOutBytes, std::make_integer_sequence<uint32_t, 32>{});
+  RegisterFootprintSweep();
+}
+
+}  // namespace
+
+}  // namespace arrow::util::fastlanes
+
+int main(int argc, char** argv) {
+  arrow::util::fastlanes::RegisterBenchmarks();
+  benchmark::Initialize(&argc, argv);
+  if (benchmark::ReportUnrecognizedArguments(argc, argv)) return 1;
+  benchmark::RunSpecifiedBenchmarks();
+  benchmark::Shutdown();
+  return 0;
+}

From 37104b8f2b631e59872fc4fae1ffd8d7c693eac8 Mon Sep 17 00:00:00 2001
From: Prateek Gaur <prateek.gaur@snowflake.com>
Date: Mon, 5 Oct 2026 16:50:02 +0000
Subject: [PATCH 27/27] Shift narrow lanes in place on AVX2

The large kernel shifts the high part of each value left by a per-lane
amount. AVX2 has that shift for 32- and 64-bit lanes only, so for byte
and short output xsimd widened, shifted and narrowed again.
right_shift_by_excess already avoids this for the right shift by
shifting pairs of narrow lanes as one wider lane and masking them apart.
left_shift_by_excess does the same for the left shift. Byte output on
AVX2 now also goes through the medium kernel on shorts, as it already
did on SSE4.2, since a byte needs two rounds of widening where a short
needs one.

This affects packed widths whose remainder modulo eight is 3, 5, 6 or 7.
In L1, those widths now run 4.23x to 4.28x as fast as before at short
output and 2.02x to 2.13x as fast at byte output. Other widths stay
within 0.94x to 1.06x, and 32-bit output is unchanged. AVX-512 keeps the
old routing, because there the route through shorts runs 0.16x to 0.23x
as fast. Checked against the scalar reference for every kernel x86
builds, all four output sizes and widths 1 to 63, on SSE4.2, AVX2 and
AVX-512, with and without a bias.
---
 .../util/bpacking_simd_kernel_internal.h      | 52 +++++++++++++++++--
 1 file changed, 49 insertions(+), 3 deletions(-)

diff --git a/cpp/src/arrow/util/bpacking_simd_kernel_internal.h b/cpp/src/arrow/util/bpacking_simd_kernel_internal.h
index 33cddfe0ef79..3b58043aa1c0 100644
--- a/cpp/src/arrow/util/bpacking_simd_kernel_internal.h
+++ b/cpp/src/arrow/util/bpacking_simd_kernel_internal.h
@@ -209,6 +209,46 @@ ARROW_FORCE_INLINE auto right_shift_by_excess(
   return batch >> shifts;
 }
 
+/// Fallback for variable shift left.
+///
+/// The mirror of `right_shift_by_excess` for the other direction. On AVX2 there is a
+/// variable shift for 32 and 64 bit lanes but none for the narrower ones, so a batch of
+/// bytes or shorts is shifted as the next integer size up. The even lanes are masked
+/// out of the way, shifted, and masked again because a left shift can carry bits into
+/// the neighbouring lane; the odd lanes only need the first mask, since what they carry
+/// leaves the wider lane entirely. Shifting bytes recurses once more, bytes to shorts to
+/// 32 bit lanes, as both narrow sizes take the same route.
+///
+/// Without this, xsimd widens and narrows around its own shift, which costs a lane
+/// extract and a pack on either side of every shift. That cost falls only on the large
+/// kernel, the one place a variable left shift is needed, and so only on the packed
+/// widths that reach it.
+template <typename Arch, typename Int, Int... kShifts>
+ARROW_FORCE_INLINE auto left_shift_by_excess(
+    const xsimd::batch<Int, Arch>& batch,
+    xsimd::batch_constant<Int, Arch, kShifts...> shifts) {
+  constexpr auto IntSize = sizeof(Int);
+
+  if constexpr (IsAvx2<Arch> &&
+                (IntSize == sizeof(uint8_t) || IntSize == sizeof(uint16_t))) {
+    using twice_uint = SizedUint<2 * IntSize>;
+
+    const auto batch2 = xsimd::bitwise_cast<twice_uint>(batch);
+
+    constexpr auto kShifts0 = select_stride<twice_uint, 0>(shifts);
+    constexpr auto kMask0 = bit_util::LeastSignificantBitMask<twice_uint>(8 * IntSize);
+    const auto shifted0 = left_shift_by_excess(batch2 & kMask0, kShifts0) & kMask0;
+
+    constexpr auto kShifts1 = select_stride<twice_uint, 1>(shifts);
+    constexpr auto kMask1 = static_cast<twice_uint>(kMask0 << (8 * IntSize));
+    const auto shifted1 = left_shift_by_excess(batch2 & kMask1, kShifts1);
+
+    return xsimd::bitwise_cast<Int>(shifted0 | shifted1);
+  }
+
+  return batch << shifts;
+}
+
 /****************************
  *  Properties of a kernel  *
  ****************************/
@@ -982,7 +1022,7 @@ struct LargeKernel {
 
     const auto high_swizzled = xsimd::swizzle(bytes, kHighSwizzles);
     const auto high_words = xsimd::bitwise_cast<unpacked_type>(high_swizzled);
-    const auto high_shifted = high_words << kHighLShifts;
+    const auto high_shifted = left_shift_by_excess(high_words, kHighLShifts);
 
     // We can have a single mask and apply it after OR because the shifts will ensure that
     // there are zeros where the high/low values are incomplete.
@@ -1086,10 +1126,16 @@ constexpr bool kMediumShouldUseUint32 =
     (KerTraits::kShape.packed_bit_size() < 32) &&
     KernelTraitsWithUnpackUint<KerTraits, uint32_t>::kShape.is_medium();
 
-// Benchmarking show large unpack to uint8_t is underperforming on SSE4.2
+// Benchmarking show large unpack to uint8_t is underperforming on SSE4.2, and on AVX2
+// as well: a byte needs two rounds of the widening in `right_shift_by_excess` and
+// `left_shift_by_excess` on each of the two shifts, where a short needs one. With both
+// buffers in L1, routing through the medium kernel on shorts runs 2.02x to 2.13x as fast
+// as the large kernel at the four byte widths that reach it. AVX-512 is left out
+// because the same route runs 0.16x to 0.23x as fast there.
 template <typename KerTraits, typename Arch = typename KerTraits::arch_type>
 constexpr bool kLargeShouldUseUint16 =
-    IsSse2<Arch> && (KerTraits::kShape.unpacked_byte_size() == sizeof(uint8_t));
+    (IsSse2<Arch> || IsAvx2<Arch>) &&
+    (KerTraits::kShape.unpacked_byte_size() == sizeof(uint8_t));
 
 // A ``std::enable_if`` that works on MSVC
 template <typename KerTraits>