import quincy 17.2.0

[ceph.git] / ceph / src / arrow / cpp / src / arrow / compare_benchmark.cc

// 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 <memory>
#include <string>
#include <vector>

#include "benchmark/benchmark.h"

#include "arrow/array.h"
#include "arrow/compare.h"
#include "arrow/testing/gtest_util.h"
#include "arrow/testing/random.h"
#include "arrow/util/benchmark_util.h"
#include "arrow/util/logging.h"
#include "arrow/util/macros.h"

namespace arrow {

constexpr auto kSeed = 0x94378165;

static void BenchmarkArrayRangeEquals(const std::shared_ptr<Array>& array,
                                      benchmark::State& state) {
  const auto left_array = array;
  // Make sure pointer equality can't be used as a shortcut
  // (should we would deep-copy child_data and buffers?)
  const auto right_array =
      MakeArray(array->data()->Copy())->Slice(1, array->length() - 1);

  for (auto _ : state) {
    const bool are_ok = ArrayRangeEquals(*left_array, *right_array,
                                         /*left_start_idx=*/1,
                                         /*left_end_idx=*/array->length() - 2,
                                         /*right_start_idx=*/0);
    if (ARROW_PREDICT_FALSE(!are_ok)) {
      ARROW_LOG(FATAL) << "Arrays should have compared equal";
    }
  }
}

static void ArrayRangeEqualsInt32(benchmark::State& state) {
  RegressionArgs args(state, /*size_is_bytes=*/false);

  auto rng = random::RandomArrayGenerator(kSeed);
  auto array = rng.Int32(args.size, 0, 100, args.null_proportion);

  BenchmarkArrayRangeEquals(array, state);
}

static void ArrayRangeEqualsFloat32(benchmark::State& state) {
  RegressionArgs args(state, /*size_is_bytes=*/false);

  auto rng = random::RandomArrayGenerator(kSeed);
  auto array = rng.Float32(args.size, 0, 100, args.null_proportion);

  BenchmarkArrayRangeEquals(array, state);
}

static void ArrayRangeEqualsBoolean(benchmark::State& state) {
  RegressionArgs args(state, /*size_is_bytes=*/false);

  auto rng = random::RandomArrayGenerator(kSeed);
  auto array = rng.Boolean(args.size, /*true_probability=*/0.3, args.null_proportion);

  BenchmarkArrayRangeEquals(array, state);
}

static void ArrayRangeEqualsString(benchmark::State& state) {
  RegressionArgs args(state, /*size_is_bytes=*/false);

  auto rng = random::RandomArrayGenerator(kSeed);
  auto array =
      rng.String(args.size, /*min_length=*/0, /*max_length=*/15, args.null_proportion);

  BenchmarkArrayRangeEquals(array, state);
}

static void ArrayRangeEqualsFixedSizeBinary(benchmark::State& state) {
  RegressionArgs args(state, /*size_is_bytes=*/false);

  auto rng = random::RandomArrayGenerator(kSeed);
  auto array = rng.FixedSizeBinary(args.size, /*byte_width=*/8, args.null_proportion);

  BenchmarkArrayRangeEquals(array, state);
}

static void ArrayRangeEqualsListOfInt32(benchmark::State& state) {
  RegressionArgs args(state, /*size_is_bytes=*/false);

  auto rng = random::RandomArrayGenerator(kSeed);
  auto values = rng.Int32(args.size * 10, 0, 100, args.null_proportion);
  // Force empty list null entries, since it is overwhelmingly the common case.
  auto array = rng.List(*values, /*size=*/args.size, args.null_proportion,
                        /*force_empty_nulls=*/true);

  BenchmarkArrayRangeEquals(array, state);
}

static void ArrayRangeEqualsStruct(benchmark::State& state) {
  // struct<int32, utf8>
  RegressionArgs args(state, /*size_is_bytes=*/false);

  auto rng = random::RandomArrayGenerator(kSeed);
  auto values1 = rng.Int32(args.size, 0, 100, args.null_proportion);
  auto values2 =
      rng.String(args.size, /*min_length=*/0, /*max_length=*/15, args.null_proportion);
  auto null_bitmap = rng.NullBitmap(args.size, args.null_proportion);
  auto array = *StructArray::Make({values1, values2},
                                  std::vector<std::string>{"ints", "strs"}, null_bitmap);

  BenchmarkArrayRangeEquals(array, state);
}

static void ArrayRangeEqualsSparseUnion(benchmark::State& state) {
  // sparse_union<int32, utf8>
  RegressionArgs args(state, /*size_is_bytes=*/false);

  auto rng = random::RandomArrayGenerator(kSeed);
  auto values1 = rng.Int32(args.size, 0, 100, args.null_proportion);
  auto values2 =
      rng.String(args.size, /*min_length=*/0, /*max_length=*/15, args.null_proportion);
  auto array = rng.SparseUnion({values1, values2}, args.size);

  BenchmarkArrayRangeEquals(array, state);
}

static void ArrayRangeEqualsDenseUnion(benchmark::State& state) {
  // dense_union<int32, utf8>
  RegressionArgs args(state, /*size_is_bytes=*/false);

  auto rng = random::RandomArrayGenerator(kSeed);
  auto values1 = rng.Int32(args.size, 0, 100, args.null_proportion);
  auto values2 =
      rng.String(args.size, /*min_length=*/0, /*max_length=*/15, args.null_proportion);
  auto array = rng.DenseUnion({values1, values2}, args.size);

  BenchmarkArrayRangeEquals(array, state);
}

BENCHMARK(ArrayRangeEqualsInt32)->Apply(RegressionSetArgs);
BENCHMARK(ArrayRangeEqualsFloat32)->Apply(RegressionSetArgs);
BENCHMARK(ArrayRangeEqualsBoolean)->Apply(RegressionSetArgs);
BENCHMARK(ArrayRangeEqualsString)->Apply(RegressionSetArgs);
BENCHMARK(ArrayRangeEqualsFixedSizeBinary)->Apply(RegressionSetArgs);
BENCHMARK(ArrayRangeEqualsListOfInt32)->Apply(RegressionSetArgs);
BENCHMARK(ArrayRangeEqualsStruct)->Apply(RegressionSetArgs);
BENCHMARK(ArrayRangeEqualsSparseUnion)->Apply(RegressionSetArgs);
BENCHMARK(ArrayRangeEqualsDenseUnion)->Apply(RegressionSetArgs);

}  // namespace arrow