Function unpack_width

cpp/src/arrow/util/bpacking_dispatch_internal.h:194–252

template <int kPackedBitWidth, template <typename, int> typename Unpacker,
          typename UnpackedUInt>
void unpack_width(const uint8_t* in, UnpackedUInt* out, int batch_size, int bit_offset,
                  int max_read_bytes) {
  if constexpr (kPackedBitWidth == 0) {
    // Easy case to handle, simply setting memory to zero.
    return unpack_null(in, out, batch_size);
  } else {
    // Number of bytes to read according to batch_size.
    const int bytes_batch = static_cast<int>(
        bit_util::BytesForBits(batch_size * kPackedBitWidth + bit_offset));
    // If specified, max_read_bytes must be greater that the bytes needed to extract the
    // number of desired values.
    ARROW_DCHECK(max_read_bytes < 0 || bytes_batch <= max_read_bytes);
    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);
    // 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));
    batch_size -= extracted;
    ARROW_DCHECK_GE(batch_size, 0);
    in += start_bit / 8;
    out += extracted;

    if constexpr (kPackedBitWidth == 8 * sizeof(UnpackedUInt)) {
      // Only memcpy / static_cast
      return unpack_full(in, out, batch_size);
    } else {
      using UnpackerForWidth = Unpacker<UnpackedUInt, kPackedBitWidth>;
      // Number of values extracted by one iteration of the kernel
      constexpr auto kValuesUnpacked = UnpackerForWidth::kValuesUnpacked;
      // Number of bytes read, but not necessarily unpacked, by one iteration of the
      // kernel. This constant prevent reading past buffer end.
      constexpr auto kBytesRead = UnpackerForWidth::kBytesRead;

      if constexpr (kValuesUnpacked > 0) {
        const uint8_t* in_last = in_end - kBytesRead;
        // Running the optimized kernel for batch extraction
        while ((batch_size >= kValuesUnpacked) && (in <= in_last)) {
          in = UnpackerForWidth::unpack(in, out);
          out += kValuesUnpacked;
          batch_size -= kValuesUnpacked;
        }

        // Performance check making sure we ran the kernel loop as much as possible:
        // Either we ran out because we could not pack enough values, or because we would
        // overread.
        ARROW_DCHECK((batch_size < kValuesUnpacked) || (in_end - in) < kBytesRead);
      }

      // 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);
    }
  }