import quincy 17.2.0

[ceph.git] / ceph / src / arrow / cpp / src / arrow / util / variant_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 "benchmark/benchmark.h"

#include <cstdint>
#include <memory>
#include <string>
#include <type_traits>
#include <vector>

#include "arrow/array.h"
#include "arrow/chunked_array.h"
#include "arrow/datum.h"
#include "arrow/status.h"
#include "arrow/testing/gtest_util.h"
#include "arrow/testing/random.h"
#include "arrow/type.h"
#include "arrow/util/checked_cast.h"
#include "arrow/util/variant.h"

namespace arrow {

using internal::checked_pointer_cast;

namespace util {

using TrivialVariant = arrow::util::Variant<int32_t, float>;

using NonTrivialVariant = arrow::util::Variant<int32_t, std::string>;

std::vector<int32_t> MakeInts(int64_t nitems) {
  auto rng = arrow::random::RandomArrayGenerator(42);
  auto array = checked_pointer_cast<Int32Array>(rng.Int32(nitems, 0, 1 << 30));
  std::vector<int32_t> items(nitems);
  for (int64_t i = 0; i < nitems; ++i) {
    items[i] = array->Value(i);
  }
  return items;
}

std::vector<float> MakeFloats(int64_t nitems) {
  auto rng = arrow::random::RandomArrayGenerator(42);
  auto array = checked_pointer_cast<FloatArray>(rng.Float32(nitems, 0.0, 1.0));
  std::vector<float> items(nitems);
  for (int64_t i = 0; i < nitems; ++i) {
    items[i] = array->Value(i);
  }
  return items;
}

std::vector<std::string> MakeStrings(int64_t nitems) {
  auto rng = arrow::random::RandomArrayGenerator(42);
  // Some std::string's will use short string optimization, but not all...
  auto array = checked_pointer_cast<StringArray>(rng.String(nitems, 5, 40));
  std::vector<std::string> items(nitems);
  for (int64_t i = 0; i < nitems; ++i) {
    items[i] = array->GetString(i);
  }
  return items;
}

static void ConstructTrivialVariant(benchmark::State& state) {
  const int64_t N = 10000;
  const auto ints = MakeInts(N);
  const auto floats = MakeFloats(N);

  for (auto _ : state) {
    for (int64_t i = 0; i < N; ++i) {
      // About type selection: we ensure 50% of each type, but try to avoid
      // branch mispredictions by creating runs of the same type.
      if (i & 0x10) {
        TrivialVariant v{ints[i]};
        const int32_t* val = &arrow::util::get<int32_t>(v);
        benchmark::DoNotOptimize(val);
      } else {
        TrivialVariant v{floats[i]};
        const float* val = &arrow::util::get<float>(v);
        benchmark::DoNotOptimize(val);
      }
    }
  }

  state.SetItemsProcessed(state.iterations() * N);
}

static void ConstructNonTrivialVariant(benchmark::State& state) {
  const int64_t N = 10000;
  const auto ints = MakeInts(N);
  const auto strings = MakeStrings(N);

  for (auto _ : state) {
    for (int64_t i = 0; i < N; ++i) {
      if (i & 0x10) {
        NonTrivialVariant v{ints[i]};
        const int32_t* val = &arrow::util::get<int32_t>(v);
        benchmark::DoNotOptimize(val);
      } else {
        NonTrivialVariant v{strings[i]};
        const std::string* val = &arrow::util::get<std::string>(v);
        benchmark::DoNotOptimize(val);
      }
    }
  }

  state.SetItemsProcessed(state.iterations() * N);
}

struct VariantVisitor {
  int64_t total = 0;

  void operator()(const int32_t& v) { total += v; }
  void operator()(const float& v) {
    // Avoid potentially costly float-to-int conversion
    int32_t x;
    memcpy(&x, &v, 4);
    total += x;
  }
  void operator()(const std::string& v) { total += static_cast<int64_t>(v.length()); }
};

template <typename VariantType>
static void VisitVariant(benchmark::State& state,
                         const std::vector<VariantType>& variants) {
  for (auto _ : state) {
    VariantVisitor visitor;
    for (const auto& v : variants) {
      visit(visitor, v);
    }
    benchmark::DoNotOptimize(visitor.total);
  }

  state.SetItemsProcessed(state.iterations() * variants.size());
}

static void VisitTrivialVariant(benchmark::State& state) {
  const int64_t N = 10000;
  const auto ints = MakeInts(N);
  const auto floats = MakeFloats(N);

  std::vector<TrivialVariant> variants;
  variants.reserve(N);
  for (int64_t i = 0; i < N; ++i) {
    if (i & 0x10) {
      variants.emplace_back(ints[i]);
    } else {
      variants.emplace_back(floats[i]);
    }
  }

  VisitVariant(state, variants);
}

static void VisitNonTrivialVariant(benchmark::State& state) {
  const int64_t N = 10000;
  const auto ints = MakeInts(N);
  const auto strings = MakeStrings(N);

  std::vector<NonTrivialVariant> variants;
  variants.reserve(N);
  for (int64_t i = 0; i < N; ++i) {
    if (i & 0x10) {
      variants.emplace_back(ints[i]);
    } else {
      variants.emplace_back(strings[i]);
    }
  }

  VisitVariant(state, variants);
}

static void ConstructDatum(benchmark::State& state) {
  const int64_t N = 10000;
  auto array = *MakeArrayOfNull(int8(), 100);
  auto chunked_array = std::make_shared<ChunkedArray>(ArrayVector{array, array});

  for (auto _ : state) {
    for (int64_t i = 0; i < N; ++i) {
      if (i & 0x10) {
        Datum datum{array};
        const ArrayData* val = datum.array().get();
        benchmark::DoNotOptimize(val);
      } else {
        Datum datum{chunked_array};
        const ChunkedArray* val = datum.chunked_array().get();
        benchmark::DoNotOptimize(val);
      }
    }
  }

  state.SetItemsProcessed(state.iterations() * N);
}

static void VisitDatum(benchmark::State& state) {
  const int64_t N = 10000;
  auto array = *MakeArrayOfNull(int8(), 100);
  auto chunked_array = std::make_shared<ChunkedArray>(ArrayVector{array, array});

  std::vector<Datum> datums;
  datums.reserve(N);
  for (int64_t i = 0; i < N; ++i) {
    if (i & 0x10) {
      datums.emplace_back(array);
    } else {
      datums.emplace_back(chunked_array);
    }
  }

  for (auto _ : state) {
    int64_t total = 0;
    for (const auto& datum : datums) {
      // The .is_XXX() methods are the usual idiom when visiting a Datum,
      // rather than the visit() function.
      if (datum.is_array()) {
        total += datum.array()->length;
      } else {
        total += datum.chunked_array()->length();
      }
    }
    benchmark::DoNotOptimize(total);
  }

  state.SetItemsProcessed(state.iterations() * datums.size());
}

BENCHMARK(ConstructTrivialVariant);
BENCHMARK(ConstructNonTrivialVariant);
BENCHMARK(VisitTrivialVariant);
BENCHMARK(VisitNonTrivialVariant);
BENCHMARK(ConstructDatum);
BENCHMARK(VisitDatum);

}  // namespace util
}  // namespace arrow