From 05b17a2441c8a298d8660106a1c458b25577a56c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kriszti=C3=A1n=20Sz=C5=B1cs?= Date: Fri, 12 Jun 2020 13:40:10 +0200 Subject: [PATCH 1/3] Add benchmark --- cpp/src/arrow/compute/kernels/CMakeLists.txt | 1 + .../compute/kernels/scalar_arithmetic.cc | 2 - .../kernels/scalar_arithmetic_benchmark.cc | 92 +++++++++++++++++++ 3 files changed, 93 insertions(+), 2 deletions(-) create mode 100644 cpp/src/arrow/compute/kernels/scalar_arithmetic_benchmark.cc diff --git a/cpp/src/arrow/compute/kernels/CMakeLists.txt b/cpp/src/arrow/compute/kernels/CMakeLists.txt index 93b03e7871c..e3fa987fdaf 100644 --- a/cpp/src/arrow/compute/kernels/CMakeLists.txt +++ b/cpp/src/arrow/compute/kernels/CMakeLists.txt @@ -28,6 +28,7 @@ add_arrow_compute_test(scalar_test scalar_string_test.cc test_util.cc) +add_arrow_benchmark(scalar_arithmetic_benchmark PREFIX "arrow-compute") add_arrow_benchmark(scalar_compare_benchmark PREFIX "arrow-compute") add_arrow_benchmark(scalar_string_benchmark PREFIX "arrow-compute") diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc index de05900f7c1..4459e4ffa35 100644 --- a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc +++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc @@ -83,9 +83,7 @@ struct Multiply { static_assert(std::is_same::value, ""); static_assert(std::is_same::value, ""); static_assert(std::is_same::value, ""); - static_assert(std::is_same::value, ""); - static_assert(std::is_same::value, ""); static_assert(std::is_same::value, ""); diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic_benchmark.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic_benchmark.cc new file mode 100644 index 00000000000..8c24a8588bc --- /dev/null +++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic_benchmark.cc @@ -0,0 +1,92 @@ +// 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 + +#include "arrow/compute/api_scalar.h" +#include "arrow/compute/benchmark_util.h" +#include "arrow/compute/kernels/test_util.h" +#include "arrow/testing/gtest_util.h" +#include "arrow/testing/random.h" + +namespace arrow { +namespace compute { + +constexpr auto kSeed = 0x94378165; + +template +static void AddArrayScalarKernel(benchmark::State& state) { + RegressionArgs args(state); + + const int64_t array_size = args.size / sizeof(CType); + auto min = std::numeric_limits::lowest(); + auto max = std::numeric_limits::max(); + + auto rand = random::RandomArrayGenerator(kSeed); + auto lhs = std::static_pointer_cast>( + rand.Numeric(array_size, min, max, args.null_proportion)); + + for (auto _ : state) { + ABORT_NOT_OK(Add(lhs, Datum(CType(15))).status()); + } +} + +template +static void AddArrayArrayKernel(benchmark::State& state) { + RegressionArgs args(state); + + const int64_t array_size = args.size / sizeof(CType); + auto min = std::numeric_limits::lowest(); + auto max = std::numeric_limits::max(); + + auto rand = random::RandomArrayGenerator(kSeed); + auto lhs = std::static_pointer_cast>( + rand.Numeric(array_size, min, max, args.null_proportion)); + auto rhs = std::static_pointer_cast>( + rand.Numeric(array_size, min, max, args.null_proportion)); + + for (auto _ : state) { + ABORT_NOT_OK(Add(lhs, rhs).status()); + } +} + +BENCHMARK_TEMPLATE(AddArrayArrayKernel, Int64Type)->Apply(RegressionSetArgs); +BENCHMARK_TEMPLATE(AddArrayArrayKernel, Int32Type)->Apply(RegressionSetArgs); +BENCHMARK_TEMPLATE(AddArrayArrayKernel, Int16Type)->Apply(RegressionSetArgs); +BENCHMARK_TEMPLATE(AddArrayArrayKernel, Int8Type)->Apply(RegressionSetArgs); +BENCHMARK_TEMPLATE(AddArrayArrayKernel, UInt64Type)->Apply(RegressionSetArgs); +BENCHMARK_TEMPLATE(AddArrayArrayKernel, UInt32Type)->Apply(RegressionSetArgs); +BENCHMARK_TEMPLATE(AddArrayArrayKernel, UInt16Type)->Apply(RegressionSetArgs); +BENCHMARK_TEMPLATE(AddArrayArrayKernel, UInt8Type)->Apply(RegressionSetArgs); +BENCHMARK_TEMPLATE(AddArrayArrayKernel, FloatType)->Apply(RegressionSetArgs); +BENCHMARK_TEMPLATE(AddArrayArrayKernel, DoubleType)->Apply(RegressionSetArgs); + +BENCHMARK_TEMPLATE(AddArrayScalarKernel, Int64Type)->Apply(RegressionSetArgs); +BENCHMARK_TEMPLATE(AddArrayScalarKernel, Int32Type)->Apply(RegressionSetArgs); +BENCHMARK_TEMPLATE(AddArrayScalarKernel, Int16Type)->Apply(RegressionSetArgs); +BENCHMARK_TEMPLATE(AddArrayScalarKernel, Int8Type)->Apply(RegressionSetArgs); +BENCHMARK_TEMPLATE(AddArrayScalarKernel, UInt64Type)->Apply(RegressionSetArgs); +BENCHMARK_TEMPLATE(AddArrayScalarKernel, UInt32Type)->Apply(RegressionSetArgs); +BENCHMARK_TEMPLATE(AddArrayScalarKernel, UInt16Type)->Apply(RegressionSetArgs); +BENCHMARK_TEMPLATE(AddArrayScalarKernel, UInt8Type)->Apply(RegressionSetArgs); +BENCHMARK_TEMPLATE(AddArrayScalarKernel, FloatType)->Apply(RegressionSetArgs); +BENCHMARK_TEMPLATE(AddArrayScalarKernel, DoubleType)->Apply(RegressionSetArgs); + +} // namespace compute +} // namespace arrow From e942aa7f26acce16a1b3e31ca02c636a77ea1a80 Mon Sep 17 00:00:00 2001 From: Benjamin Kietzman Date: Fri, 12 Jun 2020 14:43:35 -0400 Subject: [PATCH 2/3] template arithmetic benchmarks on op --- .../kernels/scalar_arithmetic_benchmark.cc | 117 ++++++++++++++---- 1 file changed, 90 insertions(+), 27 deletions(-) diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic_benchmark.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic_benchmark.cc index 8c24a8588bc..815d49e67b8 100644 --- a/cpp/src/arrow/compute/kernels/scalar_arithmetic_benchmark.cc +++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic_benchmark.cc @@ -30,8 +30,10 @@ namespace compute { constexpr auto kSeed = 0x94378165; -template -static void AddArrayScalarKernel(benchmark::State& state) { +using BinaryOp = Result(const Datum&, const Datum&, ExecContext*); + +template +static void ArrayScalarKernel(benchmark::State& state) { RegressionArgs args(state); const int64_t array_size = args.size / sizeof(CType); @@ -42,13 +44,14 @@ static void AddArrayScalarKernel(benchmark::State& state) { auto lhs = std::static_pointer_cast>( rand.Numeric(array_size, min, max, args.null_proportion)); + Datum fifteen(CType(15)); for (auto _ : state) { - ABORT_NOT_OK(Add(lhs, Datum(CType(15))).status()); + ABORT_NOT_OK(Op(lhs, fifteen, nullptr).status()); } } -template -static void AddArrayArrayKernel(benchmark::State& state) { +template +static void ArrayArrayKernel(benchmark::State& state) { RegressionArgs args(state); const int64_t array_size = args.size / sizeof(CType); @@ -62,31 +65,91 @@ static void AddArrayArrayKernel(benchmark::State& state) { rand.Numeric(array_size, min, max, args.null_proportion)); for (auto _ : state) { - ABORT_NOT_OK(Add(lhs, rhs).status()); + ABORT_NOT_OK(Op(lhs, rhs, nullptr).status()); + } +} + +void SetArgs(benchmark::internal::Benchmark* bench) { + bench->Unit(benchmark::kMicrosecond); + + for (const auto size : kMemorySizes) { + for (const auto inverse_null_proportion : std::vector({100, 0})) { + bench->Args({static_cast(size), inverse_null_proportion}); + } } } -BENCHMARK_TEMPLATE(AddArrayArrayKernel, Int64Type)->Apply(RegressionSetArgs); -BENCHMARK_TEMPLATE(AddArrayArrayKernel, Int32Type)->Apply(RegressionSetArgs); -BENCHMARK_TEMPLATE(AddArrayArrayKernel, Int16Type)->Apply(RegressionSetArgs); -BENCHMARK_TEMPLATE(AddArrayArrayKernel, Int8Type)->Apply(RegressionSetArgs); -BENCHMARK_TEMPLATE(AddArrayArrayKernel, UInt64Type)->Apply(RegressionSetArgs); -BENCHMARK_TEMPLATE(AddArrayArrayKernel, UInt32Type)->Apply(RegressionSetArgs); -BENCHMARK_TEMPLATE(AddArrayArrayKernel, UInt16Type)->Apply(RegressionSetArgs); -BENCHMARK_TEMPLATE(AddArrayArrayKernel, UInt8Type)->Apply(RegressionSetArgs); -BENCHMARK_TEMPLATE(AddArrayArrayKernel, FloatType)->Apply(RegressionSetArgs); -BENCHMARK_TEMPLATE(AddArrayArrayKernel, DoubleType)->Apply(RegressionSetArgs); - -BENCHMARK_TEMPLATE(AddArrayScalarKernel, Int64Type)->Apply(RegressionSetArgs); -BENCHMARK_TEMPLATE(AddArrayScalarKernel, Int32Type)->Apply(RegressionSetArgs); -BENCHMARK_TEMPLATE(AddArrayScalarKernel, Int16Type)->Apply(RegressionSetArgs); -BENCHMARK_TEMPLATE(AddArrayScalarKernel, Int8Type)->Apply(RegressionSetArgs); -BENCHMARK_TEMPLATE(AddArrayScalarKernel, UInt64Type)->Apply(RegressionSetArgs); -BENCHMARK_TEMPLATE(AddArrayScalarKernel, UInt32Type)->Apply(RegressionSetArgs); -BENCHMARK_TEMPLATE(AddArrayScalarKernel, UInt16Type)->Apply(RegressionSetArgs); -BENCHMARK_TEMPLATE(AddArrayScalarKernel, UInt8Type)->Apply(RegressionSetArgs); -BENCHMARK_TEMPLATE(AddArrayScalarKernel, FloatType)->Apply(RegressionSetArgs); -BENCHMARK_TEMPLATE(AddArrayScalarKernel, DoubleType)->Apply(RegressionSetArgs); +// Add (Array, Array) +BENCHMARK_TEMPLATE(ArrayArrayKernel, Add, Int64Type)->Apply(SetArgs); +BENCHMARK_TEMPLATE(ArrayArrayKernel, Add, Int32Type)->Apply(SetArgs); +BENCHMARK_TEMPLATE(ArrayArrayKernel, Add, Int16Type)->Apply(SetArgs); +BENCHMARK_TEMPLATE(ArrayArrayKernel, Add, Int8Type)->Apply(SetArgs); +BENCHMARK_TEMPLATE(ArrayArrayKernel, Add, UInt64Type)->Apply(SetArgs); +BENCHMARK_TEMPLATE(ArrayArrayKernel, Add, UInt32Type)->Apply(SetArgs); +BENCHMARK_TEMPLATE(ArrayArrayKernel, Add, UInt16Type)->Apply(SetArgs); +BENCHMARK_TEMPLATE(ArrayArrayKernel, Add, UInt8Type)->Apply(SetArgs); +BENCHMARK_TEMPLATE(ArrayArrayKernel, Add, FloatType)->Apply(SetArgs); +BENCHMARK_TEMPLATE(ArrayArrayKernel, Add, DoubleType)->Apply(SetArgs); + +// Add (Array, Scalar) +BENCHMARK_TEMPLATE(ArrayScalarKernel, Add, Int64Type)->Apply(SetArgs); +BENCHMARK_TEMPLATE(ArrayScalarKernel, Add, Int32Type)->Apply(SetArgs); +BENCHMARK_TEMPLATE(ArrayScalarKernel, Add, Int16Type)->Apply(SetArgs); +BENCHMARK_TEMPLATE(ArrayScalarKernel, Add, Int8Type)->Apply(SetArgs); +BENCHMARK_TEMPLATE(ArrayScalarKernel, Add, UInt64Type)->Apply(SetArgs); +BENCHMARK_TEMPLATE(ArrayScalarKernel, Add, UInt32Type)->Apply(SetArgs); +BENCHMARK_TEMPLATE(ArrayScalarKernel, Add, UInt16Type)->Apply(SetArgs); +BENCHMARK_TEMPLATE(ArrayScalarKernel, Add, UInt8Type)->Apply(SetArgs); +BENCHMARK_TEMPLATE(ArrayScalarKernel, Add, FloatType)->Apply(SetArgs); +BENCHMARK_TEMPLATE(ArrayScalarKernel, Add, DoubleType)->Apply(SetArgs); + +// Subtract (Array, Array) +BENCHMARK_TEMPLATE(ArrayArrayKernel, Subtract, Int64Type)->Apply(SetArgs); +BENCHMARK_TEMPLATE(ArrayArrayKernel, Subtract, Int32Type)->Apply(SetArgs); +BENCHMARK_TEMPLATE(ArrayArrayKernel, Subtract, Int16Type)->Apply(SetArgs); +BENCHMARK_TEMPLATE(ArrayArrayKernel, Subtract, Int8Type)->Apply(SetArgs); +BENCHMARK_TEMPLATE(ArrayArrayKernel, Subtract, UInt64Type)->Apply(SetArgs); +BENCHMARK_TEMPLATE(ArrayArrayKernel, Subtract, UInt32Type)->Apply(SetArgs); +BENCHMARK_TEMPLATE(ArrayArrayKernel, Subtract, UInt16Type)->Apply(SetArgs); +BENCHMARK_TEMPLATE(ArrayArrayKernel, Subtract, UInt8Type)->Apply(SetArgs); +BENCHMARK_TEMPLATE(ArrayArrayKernel, Subtract, FloatType)->Apply(SetArgs); +BENCHMARK_TEMPLATE(ArrayArrayKernel, Subtract, DoubleType)->Apply(SetArgs); + +// Subtract (Array, Scalar) +BENCHMARK_TEMPLATE(ArrayScalarKernel, Subtract, Int64Type)->Apply(SetArgs); +BENCHMARK_TEMPLATE(ArrayScalarKernel, Subtract, Int32Type)->Apply(SetArgs); +BENCHMARK_TEMPLATE(ArrayScalarKernel, Subtract, Int16Type)->Apply(SetArgs); +BENCHMARK_TEMPLATE(ArrayScalarKernel, Subtract, Int8Type)->Apply(SetArgs); +BENCHMARK_TEMPLATE(ArrayScalarKernel, Subtract, UInt64Type)->Apply(SetArgs); +BENCHMARK_TEMPLATE(ArrayScalarKernel, Subtract, UInt32Type)->Apply(SetArgs); +BENCHMARK_TEMPLATE(ArrayScalarKernel, Subtract, UInt16Type)->Apply(SetArgs); +BENCHMARK_TEMPLATE(ArrayScalarKernel, Subtract, UInt8Type)->Apply(SetArgs); +BENCHMARK_TEMPLATE(ArrayScalarKernel, Subtract, FloatType)->Apply(SetArgs); +BENCHMARK_TEMPLATE(ArrayScalarKernel, Subtract, DoubleType)->Apply(SetArgs); + +// Multiply (Array, Array) +BENCHMARK_TEMPLATE(ArrayArrayKernel, Multiply, Int64Type)->Apply(SetArgs); +BENCHMARK_TEMPLATE(ArrayArrayKernel, Multiply, Int32Type)->Apply(SetArgs); +BENCHMARK_TEMPLATE(ArrayArrayKernel, Multiply, Int16Type)->Apply(SetArgs); +BENCHMARK_TEMPLATE(ArrayArrayKernel, Multiply, Int8Type)->Apply(SetArgs); +BENCHMARK_TEMPLATE(ArrayArrayKernel, Multiply, UInt64Type)->Apply(SetArgs); +BENCHMARK_TEMPLATE(ArrayArrayKernel, Multiply, UInt32Type)->Apply(SetArgs); +BENCHMARK_TEMPLATE(ArrayArrayKernel, Multiply, UInt16Type)->Apply(SetArgs); +BENCHMARK_TEMPLATE(ArrayArrayKernel, Multiply, UInt8Type)->Apply(SetArgs); +BENCHMARK_TEMPLATE(ArrayArrayKernel, Multiply, FloatType)->Apply(SetArgs); +BENCHMARK_TEMPLATE(ArrayArrayKernel, Multiply, DoubleType)->Apply(SetArgs); + +// Multiply (Array, Scalar) +BENCHMARK_TEMPLATE(ArrayScalarKernel, Multiply, Int64Type)->Apply(SetArgs); +BENCHMARK_TEMPLATE(ArrayScalarKernel, Multiply, Int32Type)->Apply(SetArgs); +BENCHMARK_TEMPLATE(ArrayScalarKernel, Multiply, Int16Type)->Apply(SetArgs); +BENCHMARK_TEMPLATE(ArrayScalarKernel, Multiply, Int8Type)->Apply(SetArgs); +BENCHMARK_TEMPLATE(ArrayScalarKernel, Multiply, UInt64Type)->Apply(SetArgs); +BENCHMARK_TEMPLATE(ArrayScalarKernel, Multiply, UInt32Type)->Apply(SetArgs); +BENCHMARK_TEMPLATE(ArrayScalarKernel, Multiply, UInt16Type)->Apply(SetArgs); +BENCHMARK_TEMPLATE(ArrayScalarKernel, Multiply, UInt8Type)->Apply(SetArgs); +BENCHMARK_TEMPLATE(ArrayScalarKernel, Multiply, FloatType)->Apply(SetArgs); +BENCHMARK_TEMPLATE(ArrayScalarKernel, Multiply, DoubleType)->Apply(SetArgs); } // namespace compute } // namespace arrow From a279b9b7f6f4515c8cdedab1689c031c2f9d7c17 Mon Sep 17 00:00:00 2001 From: Wes McKinney Date: Sat, 13 Jun 2020 14:59:28 -0500 Subject: [PATCH 3/3] DRY improvements with macro. Do not randomly-generate 20-90M length arrays. Add items processed output --- .../kernels/scalar_arithmetic_benchmark.cc | 95 ++++--------------- 1 file changed, 21 insertions(+), 74 deletions(-) diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic_benchmark.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic_benchmark.cc index 815d49e67b8..34991b99819 100644 --- a/cpp/src/arrow/compute/kernels/scalar_arithmetic_benchmark.cc +++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic_benchmark.cc @@ -48,6 +48,7 @@ static void ArrayScalarKernel(benchmark::State& state) { for (auto _ : state) { ABORT_NOT_OK(Op(lhs, fifteen, nullptr).status()); } + state.SetItemsProcessed(state.iterations() * array_size); } template @@ -67,89 +68,35 @@ static void ArrayArrayKernel(benchmark::State& state) { for (auto _ : state) { ABORT_NOT_OK(Op(lhs, rhs, nullptr).status()); } + state.SetItemsProcessed(state.iterations() * array_size); } void SetArgs(benchmark::internal::Benchmark* bench) { - bench->Unit(benchmark::kMicrosecond); - - for (const auto size : kMemorySizes) { + for (const auto size : {kL1Size, kL2Size}) { for (const auto inverse_null_proportion : std::vector({100, 0})) { bench->Args({static_cast(size), inverse_null_proportion}); } } } -// Add (Array, Array) -BENCHMARK_TEMPLATE(ArrayArrayKernel, Add, Int64Type)->Apply(SetArgs); -BENCHMARK_TEMPLATE(ArrayArrayKernel, Add, Int32Type)->Apply(SetArgs); -BENCHMARK_TEMPLATE(ArrayArrayKernel, Add, Int16Type)->Apply(SetArgs); -BENCHMARK_TEMPLATE(ArrayArrayKernel, Add, Int8Type)->Apply(SetArgs); -BENCHMARK_TEMPLATE(ArrayArrayKernel, Add, UInt64Type)->Apply(SetArgs); -BENCHMARK_TEMPLATE(ArrayArrayKernel, Add, UInt32Type)->Apply(SetArgs); -BENCHMARK_TEMPLATE(ArrayArrayKernel, Add, UInt16Type)->Apply(SetArgs); -BENCHMARK_TEMPLATE(ArrayArrayKernel, Add, UInt8Type)->Apply(SetArgs); -BENCHMARK_TEMPLATE(ArrayArrayKernel, Add, FloatType)->Apply(SetArgs); -BENCHMARK_TEMPLATE(ArrayArrayKernel, Add, DoubleType)->Apply(SetArgs); - -// Add (Array, Scalar) -BENCHMARK_TEMPLATE(ArrayScalarKernel, Add, Int64Type)->Apply(SetArgs); -BENCHMARK_TEMPLATE(ArrayScalarKernel, Add, Int32Type)->Apply(SetArgs); -BENCHMARK_TEMPLATE(ArrayScalarKernel, Add, Int16Type)->Apply(SetArgs); -BENCHMARK_TEMPLATE(ArrayScalarKernel, Add, Int8Type)->Apply(SetArgs); -BENCHMARK_TEMPLATE(ArrayScalarKernel, Add, UInt64Type)->Apply(SetArgs); -BENCHMARK_TEMPLATE(ArrayScalarKernel, Add, UInt32Type)->Apply(SetArgs); -BENCHMARK_TEMPLATE(ArrayScalarKernel, Add, UInt16Type)->Apply(SetArgs); -BENCHMARK_TEMPLATE(ArrayScalarKernel, Add, UInt8Type)->Apply(SetArgs); -BENCHMARK_TEMPLATE(ArrayScalarKernel, Add, FloatType)->Apply(SetArgs); -BENCHMARK_TEMPLATE(ArrayScalarKernel, Add, DoubleType)->Apply(SetArgs); - -// Subtract (Array, Array) -BENCHMARK_TEMPLATE(ArrayArrayKernel, Subtract, Int64Type)->Apply(SetArgs); -BENCHMARK_TEMPLATE(ArrayArrayKernel, Subtract, Int32Type)->Apply(SetArgs); -BENCHMARK_TEMPLATE(ArrayArrayKernel, Subtract, Int16Type)->Apply(SetArgs); -BENCHMARK_TEMPLATE(ArrayArrayKernel, Subtract, Int8Type)->Apply(SetArgs); -BENCHMARK_TEMPLATE(ArrayArrayKernel, Subtract, UInt64Type)->Apply(SetArgs); -BENCHMARK_TEMPLATE(ArrayArrayKernel, Subtract, UInt32Type)->Apply(SetArgs); -BENCHMARK_TEMPLATE(ArrayArrayKernel, Subtract, UInt16Type)->Apply(SetArgs); -BENCHMARK_TEMPLATE(ArrayArrayKernel, Subtract, UInt8Type)->Apply(SetArgs); -BENCHMARK_TEMPLATE(ArrayArrayKernel, Subtract, FloatType)->Apply(SetArgs); -BENCHMARK_TEMPLATE(ArrayArrayKernel, Subtract, DoubleType)->Apply(SetArgs); - -// Subtract (Array, Scalar) -BENCHMARK_TEMPLATE(ArrayScalarKernel, Subtract, Int64Type)->Apply(SetArgs); -BENCHMARK_TEMPLATE(ArrayScalarKernel, Subtract, Int32Type)->Apply(SetArgs); -BENCHMARK_TEMPLATE(ArrayScalarKernel, Subtract, Int16Type)->Apply(SetArgs); -BENCHMARK_TEMPLATE(ArrayScalarKernel, Subtract, Int8Type)->Apply(SetArgs); -BENCHMARK_TEMPLATE(ArrayScalarKernel, Subtract, UInt64Type)->Apply(SetArgs); -BENCHMARK_TEMPLATE(ArrayScalarKernel, Subtract, UInt32Type)->Apply(SetArgs); -BENCHMARK_TEMPLATE(ArrayScalarKernel, Subtract, UInt16Type)->Apply(SetArgs); -BENCHMARK_TEMPLATE(ArrayScalarKernel, Subtract, UInt8Type)->Apply(SetArgs); -BENCHMARK_TEMPLATE(ArrayScalarKernel, Subtract, FloatType)->Apply(SetArgs); -BENCHMARK_TEMPLATE(ArrayScalarKernel, Subtract, DoubleType)->Apply(SetArgs); - -// Multiply (Array, Array) -BENCHMARK_TEMPLATE(ArrayArrayKernel, Multiply, Int64Type)->Apply(SetArgs); -BENCHMARK_TEMPLATE(ArrayArrayKernel, Multiply, Int32Type)->Apply(SetArgs); -BENCHMARK_TEMPLATE(ArrayArrayKernel, Multiply, Int16Type)->Apply(SetArgs); -BENCHMARK_TEMPLATE(ArrayArrayKernel, Multiply, Int8Type)->Apply(SetArgs); -BENCHMARK_TEMPLATE(ArrayArrayKernel, Multiply, UInt64Type)->Apply(SetArgs); -BENCHMARK_TEMPLATE(ArrayArrayKernel, Multiply, UInt32Type)->Apply(SetArgs); -BENCHMARK_TEMPLATE(ArrayArrayKernel, Multiply, UInt16Type)->Apply(SetArgs); -BENCHMARK_TEMPLATE(ArrayArrayKernel, Multiply, UInt8Type)->Apply(SetArgs); -BENCHMARK_TEMPLATE(ArrayArrayKernel, Multiply, FloatType)->Apply(SetArgs); -BENCHMARK_TEMPLATE(ArrayArrayKernel, Multiply, DoubleType)->Apply(SetArgs); - -// Multiply (Array, Scalar) -BENCHMARK_TEMPLATE(ArrayScalarKernel, Multiply, Int64Type)->Apply(SetArgs); -BENCHMARK_TEMPLATE(ArrayScalarKernel, Multiply, Int32Type)->Apply(SetArgs); -BENCHMARK_TEMPLATE(ArrayScalarKernel, Multiply, Int16Type)->Apply(SetArgs); -BENCHMARK_TEMPLATE(ArrayScalarKernel, Multiply, Int8Type)->Apply(SetArgs); -BENCHMARK_TEMPLATE(ArrayScalarKernel, Multiply, UInt64Type)->Apply(SetArgs); -BENCHMARK_TEMPLATE(ArrayScalarKernel, Multiply, UInt32Type)->Apply(SetArgs); -BENCHMARK_TEMPLATE(ArrayScalarKernel, Multiply, UInt16Type)->Apply(SetArgs); -BENCHMARK_TEMPLATE(ArrayScalarKernel, Multiply, UInt8Type)->Apply(SetArgs); -BENCHMARK_TEMPLATE(ArrayScalarKernel, Multiply, FloatType)->Apply(SetArgs); -BENCHMARK_TEMPLATE(ArrayScalarKernel, Multiply, DoubleType)->Apply(SetArgs); +#define DECLARE_ARITHMETIC_BENCHMARKS(BENCHMARK, OP) \ + BENCHMARK_TEMPLATE(BENCHMARK, OP, Int64Type)->Apply(SetArgs); \ + BENCHMARK_TEMPLATE(BENCHMARK, OP, Int32Type)->Apply(SetArgs); \ + BENCHMARK_TEMPLATE(BENCHMARK, OP, Int16Type)->Apply(SetArgs); \ + BENCHMARK_TEMPLATE(BENCHMARK, OP, Int8Type)->Apply(SetArgs); \ + BENCHMARK_TEMPLATE(BENCHMARK, OP, UInt64Type)->Apply(SetArgs); \ + BENCHMARK_TEMPLATE(BENCHMARK, OP, UInt32Type)->Apply(SetArgs); \ + BENCHMARK_TEMPLATE(BENCHMARK, OP, UInt16Type)->Apply(SetArgs); \ + BENCHMARK_TEMPLATE(BENCHMARK, OP, UInt8Type)->Apply(SetArgs); \ + BENCHMARK_TEMPLATE(BENCHMARK, OP, FloatType)->Apply(SetArgs); \ + BENCHMARK_TEMPLATE(BENCHMARK, OP, DoubleType)->Apply(SetArgs) + +DECLARE_ARITHMETIC_BENCHMARKS(ArrayArrayKernel, Add); +DECLARE_ARITHMETIC_BENCHMARKS(ArrayScalarKernel, Add); +DECLARE_ARITHMETIC_BENCHMARKS(ArrayArrayKernel, Subtract); +DECLARE_ARITHMETIC_BENCHMARKS(ArrayScalarKernel, Subtract); +DECLARE_ARITHMETIC_BENCHMARKS(ArrayArrayKernel, Multiply); +DECLARE_ARITHMETIC_BENCHMARKS(ArrayScalarKernel, Multiply); } // namespace compute } // namespace arrow