/usr/local/lib64/python3.6/site-packages/pyarrow/include/arrow/util
Edit: /usr/local/lib64/python3.6/site-packages/pyarrow/include/arrow/util/bitmap_visit.h (3460B)
// 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.
#pragma once
#include
#include "arrow/util/bit_util.h"
#include "arrow/util/bitmap_reader.h"
namespace arrow {
namespace internal {
// A function that visits each bit in a bitmap and calls a visitor function with a
// boolean representation of that bit. This is intended to be analogous to
// GenerateBits.
template
void VisitBits(const uint8_t* bitmap, int64_t start_offset, int64_t length,
Visitor&& visit) {
BitmapReader reader(bitmap, start_offset, length);
for (int64_t index = 0; index < length; ++index) {
visit(reader.IsSet());
reader.Next();
}
}
// Like VisitBits(), but unrolls its main loop for better performance.
template
void VisitBitsUnrolled(const uint8_t* bitmap, int64_t start_offset, int64_t length,
Visitor&& visit) {
if (length == 0) {
return;
}
// Start by visiting any bits preceding the first full byte.
int64_t num_bits_before_full_bytes =
BitUtil::RoundUpToMultipleOf8(start_offset) - start_offset;
// Truncate num_bits_before_full_bytes if it is greater than length.
if (num_bits_before_full_bytes > length) {
num_bits_before_full_bytes = length;
}
// Use the non loop-unrolled VisitBits since we don't want to add branches
VisitBits(bitmap, start_offset, num_bits_before_full_bytes, visit);
// Shift the start pointer to the first full byte and compute the
// number of full bytes to be read.
const uint8_t* first_full_byte = bitmap + BitUtil::CeilDiv(start_offset, 8);
const int64_t num_full_bytes = (length - num_bits_before_full_bytes) / 8;
// Iterate over each full byte of the input bitmap and call the visitor in
// a loop-unrolled manner.
for (int64_t byte_index = 0; byte_index < num_full_bytes; ++byte_index) {
// Get the current bit-packed byte value from the bitmap.
const uint8_t byte = *(first_full_byte + byte_index);
// Execute the visitor function on each bit of the current byte.
visit(BitUtil::GetBitFromByte(byte, 0));
visit(BitUtil::GetBitFromByte(byte, 1));
visit(BitUtil::GetBitFromByte(byte, 2));
visit(BitUtil::GetBitFromByte(byte, 3));
visit(BitUtil::GetBitFromByte(byte, 4));
visit(BitUtil::GetBitFromByte(byte, 5));
visit(BitUtil::GetBitFromByte(byte, 6));
visit(BitUtil::GetBitFromByte(byte, 7));
}
// Write any leftover bits in the last byte.
const int64_t num_bits_after_full_bytes = (length - num_bits_before_full_bytes) % 8;
VisitBits(first_full_byte + num_full_bytes, 0, num_bits_after_full_bytes,
visit);
}
} // namespace internal
} // namespace arrow