Add TypedBufferBuilder<bool> UnsafeAppend compile-time option to not track falses. Restore faster code from before this patch for appending C arrays and vector<bool>

Change-Id: I01d2d8e87db520a5c38f892a58e86d7a645e8877

Author: wesm

cpp/src/arrow/array/builder_primitive.cc

@@ -156,12 +156,24 @@ Status BooleanBuilder::FinishInternal(std::shared_ptr<ArrayData>* out) {
 
 Status BooleanBuilder::AppendValues(const uint8_t* values, int64_t length,
                                     const uint8_t* valid_bytes) {
-  return AppendValues(values, values + length, valid_bytes);
+  RETURN_NOT_OK(Reserve(length));
+
+  int64_t i = 0;
+  data_builder_.UnsafeAppend<false>(length,
+                                    [values, &i]() -> bool { return values[i++] != 0; });
+  ArrayBuilder::UnsafeAppendToBitmap(valid_bytes, length);
+  return Status::OK();
 }
 
 Status BooleanBuilder::AppendValues(const uint8_t* values, int64_t length,
                                     const std::vector<bool>& is_valid) {
-  return AppendValues(values, values + length, is_valid.begin());
+  RETURN_NOT_OK(Reserve(length));
+  DCHECK_EQ(length, static_cast<int64_t>(is_valid.size()));
+  int64_t i = 0;
+  data_builder_.UnsafeAppend<false>(length,
+                                    [values, &i]() -> bool { return values[i++]; });
+  ArrayBuilder::UnsafeAppendToBitmap(is_valid);
+  return Status::OK();
 }
 
 Status BooleanBuilder::AppendValues(const std::vector<uint8_t>& values,
@@ -175,11 +187,24 @@ Status BooleanBuilder::AppendValues(const std::vector<uint8_t>& values) {
 
 Status BooleanBuilder::AppendValues(const std::vector<bool>& values,
                                     const std::vector<bool>& is_valid) {
-  return AppendValues(values.begin(), values.end(), is_valid.begin());
+  const int64_t length = static_cast<int64_t>(values.size());
+  RETURN_NOT_OK(Reserve(length));
+  DCHECK_EQ(length, static_cast<int64_t>(is_valid.size()));
+  int64_t i = 0;
+  data_builder_.UnsafeAppend<false>(length,
+                                    [&values, &i]() -> bool { return values[i++]; });
+  ArrayBuilder::UnsafeAppendToBitmap(is_valid);
+  return Status::OK();
 }
 
 Status BooleanBuilder::AppendValues(const std::vector<bool>& values) {
-  return AppendValues(values.begin(), values.end());
+  const int64_t length = static_cast<int64_t>(values.size());
+  RETURN_NOT_OK(Reserve(length));
+  int64_t i = 0;
+  data_builder_.UnsafeAppend<false>(length,
+                                    [&values, &i]() -> bool { return values[i++]; });
+  ArrayBuilder::UnsafeSetNotNull(length);
+  return Status::OK();
 }
 
 }  // namespace arrow

cpp/src/arrow/array/builder_primitive.h

@@ -143,7 +143,7 @@ class ARROW_EXPORT NumericBuilder : public ArrayBuilder {
     int64_t length = static_cast<int64_t>(std::distance(values_begin, values_end));
     ARROW_RETURN_NOT_OK(Reserve(length));
     data_builder_.UnsafeAppend(values_begin, values_end);
-    null_bitmap_builder_.UnsafeAppend(
+    null_bitmap_builder_.UnsafeAppend<true>(
         length, [&valid_begin]() -> bool { return *valid_begin++; });
     length_ = null_bitmap_builder_.length();
     null_count_ = null_bitmap_builder_.false_count();
@@ -161,7 +161,7 @@ class ARROW_EXPORT NumericBuilder : public ArrayBuilder {
     if (valid_begin == NULLPTR) {
       UnsafeSetNotNull(length);
     } else {
-      null_bitmap_builder_.UnsafeAppend(
+      null_bitmap_builder_.UnsafeAppend<true>(
           length, [&valid_begin]() -> bool { return *valid_begin++; });
       length_ = null_bitmap_builder_.length();
       null_count_ = null_bitmap_builder_.false_count();
@@ -309,8 +309,8 @@ class ARROW_EXPORT BooleanBuilder : public ArrayBuilder {
   Status AppendValues(ValuesIter values_begin, ValuesIter values_end) {
     int64_t length = static_cast<int64_t>(std::distance(values_begin, values_end));
     ARROW_RETURN_NOT_OK(Reserve(length));
-    data_builder_.UnsafeAppend(length,
-                               [&values_begin]() -> bool { return *values_begin++; });
+    data_builder_.UnsafeAppend<false>(
+        length, [&values_begin]() -> bool { return *values_begin++; });
     // this updates length_
     UnsafeSetNotNull(length);
     return Status::OK();
@@ -331,9 +331,9 @@ class ARROW_EXPORT BooleanBuilder : public ArrayBuilder {
     int64_t length = static_cast<int64_t>(std::distance(values_begin, values_end));
     ARROW_RETURN_NOT_OK(Reserve(length));
 
-    data_builder_.UnsafeAppend(length,
-                               [&values_begin]() -> bool { return *values_begin++; });
-    null_bitmap_builder_.UnsafeAppend(
+    data_builder_.UnsafeAppend<false>(
+        length, [&values_begin]() -> bool { return *values_begin++; });
+    null_bitmap_builder_.UnsafeAppend<true>(
         length, [&valid_begin]() -> bool { return *valid_begin++; });
     length_ = null_bitmap_builder_.length();
     null_count_ = null_bitmap_builder_.false_count();
@@ -346,13 +346,13 @@ class ARROW_EXPORT BooleanBuilder : public ArrayBuilder {
       ValuesIter values_begin, ValuesIter values_end, ValidIter valid_begin) {
     int64_t length = static_cast<int64_t>(std::distance(values_begin, values_end));
     ARROW_RETURN_NOT_OK(Reserve(length));
-    data_builder_.UnsafeAppend(length,
-                               [&values_begin]() -> bool { return *values_begin++; });
+    data_builder_.UnsafeAppend<false>(
+        length, [&values_begin]() -> bool { return *values_begin++; });
 
     if (valid_begin == NULLPTR) {
       UnsafeSetNotNull(length);
     } else {
-      null_bitmap_builder_.UnsafeAppend(
+      null_bitmap_builder_.UnsafeAppend<true>(
           length, [&valid_begin]() -> bool { return *valid_begin++; });
     }
     length_ = null_bitmap_builder_.length();

cpp/src/arrow/buffer-builder.h

@@ -24,6 +24,7 @@
 #include <cstring>
 #include <memory>
 #include <string>
+#include <utility>
 
 #include "arrow/buffer.h"
 #include "arrow/status.h"
@@ -307,14 +308,20 @@ class TypedBufferBuilder<bool> {
     bit_length_ += num_copies;
   }
 
-  template <typename Generator>
+  template <bool count_falses, typename Generator>
   void UnsafeAppend(const int64_t num_elements, Generator&& gen) {
     if (num_elements == 0) return;
-    internal::GenerateBitsUnrolled(mutable_data(), bit_length_, num_elements, [&] {
-      bool value = gen();
-      false_count_ += !value;
-      return value;
-    });
+
+    if (count_falses) {
+      internal::GenerateBitsUnrolled(mutable_data(), bit_length_, num_elements, [&] {
+        bool value = gen();
+        false_count_ += !value;
+        return value;
+      });
+    } else {
+      internal::GenerateBitsUnrolled(mutable_data(), bit_length_, num_elements,
+                                     std::forward<Generator>(gen));
+    }
     bit_length_ += num_elements;
   }