diff --git a/cpp/src/parquet/column_reader.cc b/cpp/src/parquet/column_reader.cc index 8594acb41d6..0e4bcd76ecd 100644 --- a/cpp/src/parquet/column_reader.cc +++ b/cpp/src/parquet/column_reader.cc @@ -47,6 +47,7 @@ #include "parquet/encryption/encryption_internal.h" #include "parquet/encryption/internal_file_decryptor.h" #include "parquet/exception.h" +#include "parquet/level_comparison.h" #include "parquet/level_conversion.h" #include "parquet/level_decoder_internal.h" #include "parquet/properties.h" @@ -1566,7 +1567,7 @@ class TypedColumnReaderImpl // cache-efficiency if fused with the level decoding. ARROW_DCHECK_LE(*num_def_levels, std::numeric_limits::max()); *non_null_values_to_read += static_cast( - std::count(def_levels, def_levels + *num_def_levels, this->max_def_level())); + internal::CountLevels(def_levels, *num_def_levels, this->max_def_level())); } else { // Required field, read all values if (num_def_levels != nullptr) { @@ -1981,8 +1982,8 @@ int64_t TypedRecordReader::SkipRecordsInBufferNonRepeated(int64_t num_re // we do not have a buffer, so we need to read them and throw them away. // First we need to figure out how many present/not-null values there are. const auto values_to_read = static_cast( - std::count(def_levels() + levels_position_, def_levels() + remaining_levels_pos, - this->max_def_level())); + CountLevels(def_levels() + levels_position_, + remaining_levels_pos - levels_position_, this->max_def_level())); // Now that we have figured out number of values to read, we do not need // these levels anymore. We will remove these values from the buffer. @@ -2147,9 +2148,7 @@ int64_t TypedRecordReader::DelimitRecords(int64_t num_records, const int64_t stride = std::min(levels_written() - levels_position_, num_records - records_read); const int64_t position_end = levels_position_ + stride; - for (int64_t i = levels_position_; i < position_end; ++i) { - records_read += rep_levels[i] == 0; - } + records_read += CountLevels(rep_levels + levels_position_, stride, 0); levels_position_ = position_end; if (records_read == num_records) { // Check last rep_level reaches the boundary and @@ -2163,8 +2162,8 @@ int64_t TypedRecordReader::DelimitRecords(int64_t num_records, } } // Scan definition levels to find number of physical values - *values_seen = std::count(def_levels + level, def_levels + levels_position_, - this->max_def_level()); + *values_seen = + CountLevels(def_levels + level, levels_position_ - level, this->max_def_level()); return records_read; } @@ -2253,8 +2252,9 @@ void TypedRecordReader::ReadDenseForOptionalInBuffer( // When reading dense we need to figure out number of values to read. const int16_t* def_levels = this->def_levels(); - *values_to_read += std::count(def_levels + start_levels_position, - def_levels + levels_position_, this->max_def_level()); + *values_to_read += + CountLevels(def_levels + start_levels_position, + levels_position_ - start_levels_position, this->max_def_level()); // This is only reading in the current page so this fits in an int32. value_sink_.ReadValuesDense(*this->current_decoder_.get(), clamp_to(*values_to_read)); diff --git a/cpp/src/parquet/column_writer.cc b/cpp/src/parquet/column_writer.cc index c899f5a9847..03d24646b36 100644 --- a/cpp/src/parquet/column_writer.cc +++ b/cpp/src/parquet/column_writer.cc @@ -55,6 +55,7 @@ #include "parquet/encoding.h" #include "parquet/encryption/encryption_internal.h" #include "parquet/encryption/internal_file_encryptor.h" +#include "parquet/level_comparison.h" #include "parquet/level_conversion.h" #include "parquet/metadata.h" #include "parquet/page_index.h" @@ -1698,11 +1699,8 @@ class TypedColumnWriterImpl : public ColumnWriterImpl, int64_t values_to_write = 0; // If the field is required and non-repeated, there are no definition levels if (descr_->max_definition_level() > 0) { - for (int64_t i = 0; i < num_levels; ++i) { - if (def_levels[i] == descr_->max_definition_level()) { - ++values_to_write; - } - } + values_to_write = + internal::CountLevels(def_levels, num_levels, descr_->max_definition_level()); WriteDefinitionLevels(num_levels, def_levels); } else { @@ -1714,12 +1712,9 @@ class TypedColumnWriterImpl : public ColumnWriterImpl, if (descr_->max_repetition_level() > 0) { // A row could include more than one value // Count the occasions where we start a new row - for (int64_t i = 0; i < num_levels; ++i) { - if (rep_levels[i] == 0) { - rows_written_++; - num_buffered_rows_++; - } - } + const int64_t records_written = internal::CountLevels(rep_levels, num_levels, 0); + rows_written_ += records_written; + num_buffered_rows_ += records_written; WriteRepetitionLevels(num_levels, rep_levels); } else { @@ -1749,11 +1744,10 @@ class TypedColumnWriterImpl : public ColumnWriterImpl, *out_spaced_values_to_write = batch_size; *null_count = 0; } else { - for (int x = 0; x < batch_size; x++) { - *out_values_to_write += def_levels[x] == level_info_.def_level ? 1 : 0; - *out_spaced_values_to_write += - def_levels[x] >= level_info_.repeated_ancestor_def_level ? 1 : 0; - } + *out_values_to_write += + internal::CountLevels(def_levels, batch_size, level_info_.def_level); + *out_spaced_values_to_write += internal::CountLevelsGreaterEqual( + def_levels, batch_size, level_info_.repeated_ancestor_def_level); *null_count = batch_size - *out_values_to_write; } return; @@ -1809,12 +1803,9 @@ class TypedColumnWriterImpl : public ColumnWriterImpl, if (descr_->max_repetition_level() > 0) { // A row could include more than one value // Count the occasions where we start a new row - for (int64_t i = 0; i < num_levels; ++i) { - if (rep_levels[i] == 0) { - rows_written_++; - num_buffered_rows_++; - } - } + const int64_t records_written = internal::CountLevels(rep_levels, num_levels, 0); + rows_written_ += records_written; + num_buffered_rows_ += records_written; WriteRepetitionLevels(num_levels, rep_levels); } else { // Each value is exactly one row diff --git a/cpp/src/parquet/file_reader.cc b/cpp/src/parquet/file_reader.cc index b93b1b764ba..c8fdb708469 100644 --- a/cpp/src/parquet/file_reader.cc +++ b/cpp/src/parquet/file_reader.cc @@ -44,6 +44,7 @@ #include "parquet/encryption/internal_file_decryptor.h" #include "parquet/exception.h" #include "parquet/file_writer.h" +#include "parquet/level_comparison.h" #include "parquet/metadata.h" #include "parquet/page_index.h" #include "parquet/platform.h" @@ -977,11 +978,7 @@ int64_t ScanFileContents(std::vector columns, const int32_t column_batch_si ScanAllValues(column_batch_size, def_levels.data(), rep_levels.data(), values.data(), &values_read, col_reader.get()); if (col_reader->descr()->max_repetition_level() > 0) { - for (size_t i = 0; i < static_cast(levels_read); i++) { - if (rep_levels[i] == 0) { - total_rows[col]++; - } - } + total_rows[col] += internal::CountLevels(rep_levels.data(), levels_read, 0); } else { total_rows[col] += levels_read; } diff --git a/cpp/src/parquet/level_comparison.h b/cpp/src/parquet/level_comparison.h index 966b21fad37..8b3235ae2bf 100644 --- a/cpp/src/parquet/level_comparison.h +++ b/cpp/src/parquet/level_comparison.h @@ -18,6 +18,8 @@ #include #include +#include +#include #include "parquet/platform.h" @@ -35,4 +37,55 @@ struct MinMax { MinMax PARQUET_EXPORT FindMinMax(const int16_t* levels, int64_t num_levels); +// Fallback for num_levels > uint16_t::max(), counting in chunks to avoid overflow. +template +ARROW_NOINLINE int64_t CountLevelsIfChunked(const int16_t* levels, int64_t num_levels, + Predicate&& pred) { + constexpr int64_t kMaxChunkSize = std::numeric_limits::max(); + int64_t total = 0; + while (num_levels > 0) { + const int64_t chunk_size = std::min(num_levels, kMaxChunkSize); + uint16_t chunk_count = 0; + for (int64_t i = 0; i < chunk_size; ++i) { + chunk_count += pred(levels[i]) ? 1 : 0; + } + total += chunk_count; + levels += chunk_size; + num_levels -= chunk_size; + } + return total; +} + +/// \brief Count the levels that satisfy `pred`. +/// +/// Accumulates matches in a `uint16_t` so the compiler can vectorize the loop +/// using 16-bit lanes without widening each comparison result to 64 bits. +/// Inputs longer than `uint16_t::max()` are counted in chunks to avoid overflow. +template +inline int64_t CountLevelsIf(const int16_t* levels, int64_t num_levels, + Predicate&& pred) { + constexpr int64_t kMaxChunkSize = std::numeric_limits::max(); + if (num_levels > kMaxChunkSize) { + return CountLevelsIfChunked(levels, num_levels, std::forward(pred)); + } + uint16_t count = 0; + for (int64_t i = 0; i < num_levels; ++i) { + count += pred(levels[i]) ? 1 : 0; + } + return count; +} + +/// \brief Count the levels equal to `value`. +inline int64_t CountLevels(const int16_t* levels, int64_t num_levels, int16_t value) { + return CountLevelsIf(levels, num_levels, + [value](int16_t level) { return level == value; }); +} + +/// \brief Count the levels greater than or equal to `min_level`. +inline int64_t CountLevelsGreaterEqual(const int16_t* levels, int64_t num_levels, + int16_t min_level) { + return CountLevelsIf(levels, num_levels, + [min_level](int16_t level) { return level >= min_level; }); +} + } // namespace parquet::internal diff --git a/cpp/src/parquet/level_conversion_test.cc b/cpp/src/parquet/level_conversion_test.cc index 4513573ef22..baecf4eaad4 100644 --- a/cpp/src/parquet/level_conversion_test.cc +++ b/cpp/src/parquet/level_conversion_test.cc @@ -23,6 +23,7 @@ #include #include +#include #include #include @@ -113,6 +114,49 @@ TEST(GreaterThanBitmap, GeneratesExpectedBitmasks) { } #endif +TEST(CountLevels, CountsMatchingLevels) { + const std::vector levels = {3, 1, 3, 0, 3, 2}; + auto is_odd = [](int16_t level) { return level % 2 != 0; }; + + EXPECT_EQ(CountLevels(levels.data(), /*num_levels=*/0, 3), 0); + EXPECT_EQ(CountLevels(levels.data(), /*num_levels=*/6, 3), 3); + EXPECT_EQ(CountLevels(levels.data(), /*num_levels=*/6, 0), 1); + EXPECT_EQ(CountLevelsGreaterEqual(levels.data(), /*num_levels=*/6, 1), 5); + EXPECT_EQ(CountLevelsGreaterEqual(levels.data(), /*num_levels=*/6, 3), 3); + EXPECT_EQ(CountLevelsIf(levels.data(), /*num_levels=*/6, is_odd), 4); + EXPECT_EQ(CountLevelsIf(levels.data(), /*num_levels=*/6, [](int16_t) { return false; }), + 0); + + // Cross-check various prefix lengths across vector and scalar tail boundaries. + std::vector longer_levels(/*count=*/100, 0); + for (size_t i = 0; i < longer_levels.size(); i += 3) { + longer_levels[i] = 3; + } + for (int64_t n = 0; n <= static_cast(longer_levels.size()); ++n) { + int64_t expected = 0; + for (int64_t i = 0; i < n; ++i) { + expected += longer_levels[i] == 3 ? 1 : 0; + } + EXPECT_EQ(CountLevels(longer_levels.data(), n, 3), expected) << "num_levels: " << n; + EXPECT_EQ(CountLevelsGreaterEqual(longer_levels.data(), n, 3), expected) + << "num_levels: " << n; + } +} + +TEST(CountLevels, HandlesChunkBoundaries) { + // Verify 16-bit accumulator does not overflow and chunk boundaries are exact. + constexpr int64_t kChunkSize = std::numeric_limits::max(); + std::vector levels(/*count=*/5 * kChunkSize, 1); + auto is_one = [](int16_t level) { return level == 1; }; + const std::vector num_levels = {kChunkSize - 1, kChunkSize, kChunkSize + 1, + 3 * kChunkSize, 5 * kChunkSize}; + for (const int64_t n : num_levels) { + EXPECT_EQ(CountLevels(levels.data(), n, 1), n) << "num_levels: " << n; + EXPECT_EQ(CountLevelsGreaterEqual(levels.data(), n, 1), n) << "num_levels: " << n; + EXPECT_EQ(CountLevelsIf(levels.data(), n, is_one), n) << "num_levels: " << n; + } +} + TEST(DefLevelsToBitmap, WithRepetitionLevelFiltersOutEmptyListValues) { std::vector validity_bitmap(/*count*/ 8, 0);