mirror of
https://github.com/ceres-solver/ceres-solver.git
synced 2026-08-30 00:50:37 +08:00
Alexander Karatarakis
51945e0619
Run on (20 X 4300 MHz CPU s) CPU Caches: L1 Data 32 KiB (x10) L1 Instruction 32 KiB (x10) L2 Unified 1024 KiB (x10) L3 Unified 14080 KiB (x1) Load Average: 2.37, 3.00, 3.08 ----------------------------------------------------------------------------- Benchmark Time CPU Iterations ----------------------------------------------------------------------------- Addition<3>/1000 2872 ns 2872 ns 240449 Addition<10>/1000 5304 ns 5304 ns 100000 Addition<15>/1000 8211 ns 8210 ns 78742 Addition<25>/1000 14214 ns 14213 ns 46762 Addition<32>/1000 13746 ns 13746 ns 50892 Addition<200>/160 41228 ns 41228 ns 17183 AdditionScalar<3>/1000 2514 ns 2514 ns 273996 AdditionScalar<10>/1000 2733 ns 2733 ns 255508 AdditionScalar<15>/1000 2622 ns 2622 ns 264291 AdditionScalar<25>/1000 3753 ns 3753 ns 183508 AdditionScalar<32>/1000 4254 ns 4254 ns 167016 AdditionScalar<200>/160 18314 ns 18314 ns 38116 Subtraction<3>/1000 3241 ns 3241 ns 206370 Subtraction<10>/1000 5023 ns 5023 ns 139271 Subtraction<15>/1000 8387 ns 8386 ns 89927 Subtraction<25>/1000 14951 ns 14950 ns 48756 Subtraction<32>/1000 14587 ns 14587 ns 47056 Subtraction<200>/160 47175 ns 47175 ns 15574 SubtractionScalar<3>/1000 2572 ns 2572 ns 264468 SubtractionScalar<10>/1000 2713 ns 2713 ns 257920 SubtractionScalar<15>/1000 2621 ns 2621 ns 265289 SubtractionScalar<25>/1000 3593 ns 3593 ns 192266 SubtractionScalar<32>/1000 4255 ns 4255 ns 163738 SubtractionScalar<200>/160 19906 ns 19906 ns 35295 Multiplication<3>/1000 6058 ns 6058 ns 114067 Multiplication<10>/1000 11999 ns 11999 ns 58492 Multiplication<15>/1000 17906 ns 17905 ns 39565 Multiplication<25>/1000 27361 ns 27360 ns 25335 Multiplication<32>/1000 33074 ns 33074 ns 20875 Multiplication<200>/160 61364 ns 61362 ns 11542 MultiplicationLeftScalar<3>/1000 3104 ns 3104 ns 223720 MultiplicationLeftScalar<10>/1000 4549 ns 4549 ns 154366 MultiplicationLeftScalar<15>/1000 5921 ns 5921 ns 119294 MultiplicationLeftScalar<25>/1000 11429 ns 11428 ns 61685 MultiplicationLeftScalar<32>/1000 14094 ns 14094 ns 49941 MultiplicationLeftScalar<200>/160 28186 ns 28185 ns 24484 MultiplicationRightScalar<3>/1000 3110 ns 3110 ns 223333 MultiplicationRightScalar<10>/1000 4655 ns 4655 ns 150534 MultiplicationRightScalar<15>/1000 5890 ns 5890 ns 119746 MultiplicationRightScalar<25>/1000 11464 ns 11464 ns 61483 MultiplicationRightScalar<32>/1000 14243 ns 14242 ns 49492 MultiplicationRightScalar<200>/160 28282 ns 28281 ns 24604 Division<3>/1000 9128 ns 9128 ns 77846 Division<10>/1000 14811 ns 14811 ns 47682 Division<15>/1000 23293 ns 23292 ns 30091 Division<25>/1000 37313 ns 37313 ns 18608 Division<32>/1000 41229 ns 41229 ns 16982 Division<200>/160 44802 ns 44802 ns 15573 DivisionLeftScalar<3>/1000 6720 ns 6720 ns 104747 DivisionLeftScalar<10>/1000 9403 ns 9402 ns 75216 DivisionLeftScalar<15>/1000 12313 ns 12313 ns 57366 DivisionLeftScalar<25>/1000 22739 ns 22739 ns 30421 DivisionLeftScalar<32>/1000 20321 ns 20321 ns 34191 DivisionLeftScalar<200>/160 29018 ns 29017 ns 23908 DivisionRightScalar<3>/1000 3815 ns 3815 ns 182333 DivisionRightScalar<10>/1000 5750 ns 5750 ns 121691 DivisionRightScalar<15>/1000 7574 ns 7574 ns 92994 DivisionRightScalar<25>/1000 13953 ns 13953 ns 49250 DivisionRightScalar<32>/1000 16892 ns 16892 ns 41668 DivisionRightScalar<200>/160 28663 ns 28662 ns 24226 MultiplyAndAdd<3>/1000 4399 ns 4399 ns 158635 MultiplyAndAdd<10>/1000 10453 ns 10453 ns 68112 MultiplyAndAdd<15>/1000 11830 ns 11830 ns 59598 MultiplyAndAdd<25>/1000 19624 ns 19624 ns 36240 MultiplyAndAdd<32>/1000 25539 ns 25538 ns 29066 MultiplyAndAdd<200>/160 65362 ns 65358 ns 11086 Change-Id: Ie62492b3fd19ff9d3394f90bd00f0aa01522fc2a
290 lines
11 KiB
C++
290 lines
11 KiB
C++
// Ceres Solver - A fast non-linear least squares minimizer
|
|
// Copyright 2021 Google Inc. All rights reserved.
|
|
// http://ceres-solver.org/
|
|
//
|
|
// Redistribution and use in source and binary forms, with or without
|
|
// modification, are permitted provided that the following conditions are met:
|
|
//
|
|
// * Redistributions of source code must retain the above copyright notice,
|
|
// this list of conditions and the following disclaimer.
|
|
// * Redistributions in binary form must reproduce the above copyright notice,
|
|
// this list of conditions and the following disclaimer in the documentation
|
|
// and/or other materials provided with the distribution.
|
|
// * Neither the name of Google Inc. nor the names of its contributors may be
|
|
// used to endorse or promote products derived from this software without
|
|
// specific prior written permission.
|
|
//
|
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
|
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
// POSSIBILITY OF SUCH DAMAGE.
|
|
//
|
|
// Author: alex@karatarakis.com (Alexander Karatarakis)
|
|
|
|
#include <array>
|
|
|
|
#include "benchmark/benchmark.h"
|
|
#include "ceres/jet.h"
|
|
|
|
namespace ceres {
|
|
|
|
// Cycle the Jets to avoid caching effects in the benchmark.
|
|
template <class JetType>
|
|
class JetInputData {
|
|
using T = typename JetType::Scalar;
|
|
static constexpr std::size_t SIZE = 20;
|
|
|
|
public:
|
|
JetInputData() : index_{0}, a_{}, b_{}, c_{}, d_{}, e_{} {
|
|
for (int i = 0; i < static_cast<int>(SIZE); i++) {
|
|
const T ti = static_cast<T>(i + 1);
|
|
|
|
a_[i].a = T(1.1) * ti;
|
|
a_[i].v.setRandom();
|
|
|
|
b_[i].a = T(2.2) * ti;
|
|
b_[i].v.setRandom();
|
|
|
|
c_[i].a = T(3.3) * ti;
|
|
c_[i].v.setRandom();
|
|
|
|
d_[i].a = T(4.4) * ti;
|
|
d_[i].v.setRandom();
|
|
|
|
e_[i].a = T(5.5) * ti;
|
|
e_[i].v.setRandom();
|
|
|
|
scalar_a_[i] = T(1.1) * ti;
|
|
scalar_b_[i] = T(2.2) * ti;
|
|
scalar_c_[i] = T(3.3) * ti;
|
|
scalar_d_[i] = T(4.4) * ti;
|
|
scalar_e_[i] = T(5.5) * ti;
|
|
}
|
|
}
|
|
|
|
void advance() { index_ = (index_ + 1) % SIZE; }
|
|
|
|
const JetType& a() const { return a_[index_]; }
|
|
const JetType& b() const { return b_[index_]; }
|
|
const JetType& c() const { return c_[index_]; }
|
|
const JetType& d() const { return d_[index_]; }
|
|
const JetType& e() const { return e_[index_]; }
|
|
T scalar_a() const { return scalar_a_[index_]; }
|
|
T scalar_b() const { return scalar_b_[index_]; }
|
|
T scalar_c() const { return scalar_c_[index_]; }
|
|
T scalar_d() const { return scalar_d_[index_]; }
|
|
T scalar_e() const { return scalar_e_[index_]; }
|
|
|
|
private:
|
|
std::size_t index_;
|
|
std::array<JetType, SIZE> a_;
|
|
std::array<JetType, SIZE> b_;
|
|
std::array<JetType, SIZE> c_;
|
|
std::array<JetType, SIZE> d_;
|
|
std::array<JetType, SIZE> e_;
|
|
std::array<T, SIZE> scalar_a_;
|
|
std::array<T, SIZE> scalar_b_;
|
|
std::array<T, SIZE> scalar_c_;
|
|
std::array<T, SIZE> scalar_d_;
|
|
std::array<T, SIZE> scalar_e_;
|
|
};
|
|
|
|
template <std::size_t JET_SIZE, class Function>
|
|
static void JetBenchmarkHelper(benchmark::State& state, const Function& func) {
|
|
using JetType = Jet<double, JET_SIZE>;
|
|
JetInputData<JetType> data{};
|
|
JetType out{};
|
|
const int iterations = static_cast<int>(state.range(0));
|
|
for (auto _ : state) {
|
|
for (int i = 0; i < iterations; i++) {
|
|
func(data, out);
|
|
data.advance();
|
|
}
|
|
}
|
|
benchmark::DoNotOptimize(out);
|
|
}
|
|
|
|
template <std::size_t JET_SIZE>
|
|
static void Addition(benchmark::State& state) {
|
|
using JetType = Jet<double, JET_SIZE>;
|
|
JetBenchmarkHelper<JET_SIZE>(
|
|
state, [](const JetInputData<JetType>& d, JetType& out) {
|
|
out += +d.a() + d.b() + d.c() + d.d() + d.e();
|
|
});
|
|
}
|
|
BENCHMARK_TEMPLATE(Addition, 3)->Arg(1000);
|
|
BENCHMARK_TEMPLATE(Addition, 10)->Arg(1000);
|
|
BENCHMARK_TEMPLATE(Addition, 15)->Arg(1000);
|
|
BENCHMARK_TEMPLATE(Addition, 25)->Arg(1000);
|
|
BENCHMARK_TEMPLATE(Addition, 32)->Arg(1000);
|
|
BENCHMARK_TEMPLATE(Addition, 200)->Arg(160);
|
|
|
|
template <std::size_t JET_SIZE>
|
|
static void AdditionScalar(benchmark::State& state) {
|
|
using JetType = Jet<double, JET_SIZE>;
|
|
JetBenchmarkHelper<JET_SIZE>(
|
|
state, [](const JetInputData<JetType>& d, JetType& out) {
|
|
out +=
|
|
d.scalar_a() + d.scalar_b() + d.c() + d.scalar_d() + d.scalar_e();
|
|
});
|
|
}
|
|
BENCHMARK_TEMPLATE(AdditionScalar, 3)->Arg(1000);
|
|
BENCHMARK_TEMPLATE(AdditionScalar, 10)->Arg(1000);
|
|
BENCHMARK_TEMPLATE(AdditionScalar, 15)->Arg(1000);
|
|
BENCHMARK_TEMPLATE(AdditionScalar, 25)->Arg(1000);
|
|
BENCHMARK_TEMPLATE(AdditionScalar, 32)->Arg(1000);
|
|
BENCHMARK_TEMPLATE(AdditionScalar, 200)->Arg(160);
|
|
|
|
template <std::size_t JET_SIZE>
|
|
static void Subtraction(benchmark::State& state) {
|
|
using JetType = Jet<double, JET_SIZE>;
|
|
JetBenchmarkHelper<JET_SIZE>(
|
|
state, [](const JetInputData<JetType>& d, JetType& out) {
|
|
out -= -d.a() - d.b() - d.c() - d.d() - d.e();
|
|
});
|
|
}
|
|
BENCHMARK_TEMPLATE(Subtraction, 3)->Arg(1000);
|
|
BENCHMARK_TEMPLATE(Subtraction, 10)->Arg(1000);
|
|
BENCHMARK_TEMPLATE(Subtraction, 15)->Arg(1000);
|
|
BENCHMARK_TEMPLATE(Subtraction, 25)->Arg(1000);
|
|
BENCHMARK_TEMPLATE(Subtraction, 32)->Arg(1000);
|
|
BENCHMARK_TEMPLATE(Subtraction, 200)->Arg(160);
|
|
|
|
template <std::size_t JET_SIZE>
|
|
static void SubtractionScalar(benchmark::State& state) {
|
|
using JetType = Jet<double, JET_SIZE>;
|
|
JetBenchmarkHelper<JET_SIZE>(
|
|
state, [](const JetInputData<JetType>& d, JetType& out) {
|
|
out -=
|
|
-d.scalar_a() - d.scalar_b() - d.c() - d.scalar_d() - d.scalar_e();
|
|
});
|
|
}
|
|
BENCHMARK_TEMPLATE(SubtractionScalar, 3)->Arg(1000);
|
|
BENCHMARK_TEMPLATE(SubtractionScalar, 10)->Arg(1000);
|
|
BENCHMARK_TEMPLATE(SubtractionScalar, 15)->Arg(1000);
|
|
BENCHMARK_TEMPLATE(SubtractionScalar, 25)->Arg(1000);
|
|
BENCHMARK_TEMPLATE(SubtractionScalar, 32)->Arg(1000);
|
|
BENCHMARK_TEMPLATE(SubtractionScalar, 200)->Arg(160);
|
|
|
|
template <std::size_t JET_SIZE>
|
|
static void Multiplication(benchmark::State& state) {
|
|
using JetType = Jet<double, JET_SIZE>;
|
|
JetBenchmarkHelper<JET_SIZE>(
|
|
state, [](const JetInputData<JetType>& d, JetType& out) {
|
|
out *= d.a() * d.b() * d.c() * d.d() * d.e();
|
|
});
|
|
}
|
|
BENCHMARK_TEMPLATE(Multiplication, 3)->Arg(1000);
|
|
BENCHMARK_TEMPLATE(Multiplication, 10)->Arg(1000);
|
|
BENCHMARK_TEMPLATE(Multiplication, 15)->Arg(1000);
|
|
BENCHMARK_TEMPLATE(Multiplication, 25)->Arg(1000);
|
|
BENCHMARK_TEMPLATE(Multiplication, 32)->Arg(1000);
|
|
BENCHMARK_TEMPLATE(Multiplication, 200)->Arg(160);
|
|
|
|
template <std::size_t JET_SIZE>
|
|
static void MultiplicationLeftScalar(benchmark::State& state) {
|
|
using JetType = Jet<double, JET_SIZE>;
|
|
JetBenchmarkHelper<JET_SIZE>(
|
|
state, [](const JetInputData<JetType>& d, JetType& out) {
|
|
out += d.scalar_a() *
|
|
(d.scalar_b() * (d.scalar_c() * (d.scalar_d() * d.e())));
|
|
});
|
|
}
|
|
BENCHMARK_TEMPLATE(MultiplicationLeftScalar, 3)->Arg(1000);
|
|
BENCHMARK_TEMPLATE(MultiplicationLeftScalar, 10)->Arg(1000);
|
|
BENCHMARK_TEMPLATE(MultiplicationLeftScalar, 15)->Arg(1000);
|
|
BENCHMARK_TEMPLATE(MultiplicationLeftScalar, 25)->Arg(1000);
|
|
BENCHMARK_TEMPLATE(MultiplicationLeftScalar, 32)->Arg(1000);
|
|
BENCHMARK_TEMPLATE(MultiplicationLeftScalar, 200)->Arg(160);
|
|
|
|
template <std::size_t JET_SIZE>
|
|
static void MultiplicationRightScalar(benchmark::State& state) {
|
|
using JetType = Jet<double, JET_SIZE>;
|
|
JetBenchmarkHelper<JET_SIZE>(
|
|
state, [](const JetInputData<JetType>& d, JetType& out) {
|
|
out += (((d.a() * d.scalar_b()) * d.scalar_c()) * d.scalar_d()) *
|
|
d.scalar_e();
|
|
});
|
|
}
|
|
BENCHMARK_TEMPLATE(MultiplicationRightScalar, 3)->Arg(1000);
|
|
BENCHMARK_TEMPLATE(MultiplicationRightScalar, 10)->Arg(1000);
|
|
BENCHMARK_TEMPLATE(MultiplicationRightScalar, 15)->Arg(1000);
|
|
BENCHMARK_TEMPLATE(MultiplicationRightScalar, 25)->Arg(1000);
|
|
BENCHMARK_TEMPLATE(MultiplicationRightScalar, 32)->Arg(1000);
|
|
BENCHMARK_TEMPLATE(MultiplicationRightScalar, 200)->Arg(160);
|
|
|
|
template <std::size_t JET_SIZE>
|
|
static void Division(benchmark::State& state) {
|
|
using JetType = Jet<double, JET_SIZE>;
|
|
JetBenchmarkHelper<JET_SIZE>(
|
|
state, [](const JetInputData<JetType>& d, JetType& out) {
|
|
out /= d.a() / d.b() / d.c() / d.d() / d.e();
|
|
});
|
|
}
|
|
BENCHMARK_TEMPLATE(Division, 3)->Arg(1000);
|
|
BENCHMARK_TEMPLATE(Division, 10)->Arg(1000);
|
|
BENCHMARK_TEMPLATE(Division, 15)->Arg(1000);
|
|
BENCHMARK_TEMPLATE(Division, 25)->Arg(1000);
|
|
BENCHMARK_TEMPLATE(Division, 32)->Arg(1000);
|
|
BENCHMARK_TEMPLATE(Division, 200)->Arg(160);
|
|
|
|
template <std::size_t JET_SIZE>
|
|
static void DivisionLeftScalar(benchmark::State& state) {
|
|
using JetType = Jet<double, JET_SIZE>;
|
|
JetBenchmarkHelper<JET_SIZE>(
|
|
state, [](const JetInputData<JetType>& d, JetType& out) {
|
|
out += d.scalar_a() /
|
|
(d.scalar_b() / (d.scalar_c() / (d.scalar_d() / d.e())));
|
|
});
|
|
}
|
|
BENCHMARK_TEMPLATE(DivisionLeftScalar, 3)->Arg(1000);
|
|
BENCHMARK_TEMPLATE(DivisionLeftScalar, 10)->Arg(1000);
|
|
BENCHMARK_TEMPLATE(DivisionLeftScalar, 15)->Arg(1000);
|
|
BENCHMARK_TEMPLATE(DivisionLeftScalar, 25)->Arg(1000);
|
|
BENCHMARK_TEMPLATE(DivisionLeftScalar, 32)->Arg(1000);
|
|
BENCHMARK_TEMPLATE(DivisionLeftScalar, 200)->Arg(160);
|
|
|
|
template <std::size_t JET_SIZE>
|
|
static void DivisionRightScalar(benchmark::State& state) {
|
|
using JetType = Jet<double, JET_SIZE>;
|
|
JetBenchmarkHelper<JET_SIZE>(
|
|
state, [](const JetInputData<JetType>& d, JetType& out) {
|
|
out += (((d.a() / d.scalar_b()) / d.scalar_c()) / d.scalar_d()) /
|
|
d.scalar_e();
|
|
});
|
|
}
|
|
BENCHMARK_TEMPLATE(DivisionRightScalar, 3)->Arg(1000);
|
|
BENCHMARK_TEMPLATE(DivisionRightScalar, 10)->Arg(1000);
|
|
BENCHMARK_TEMPLATE(DivisionRightScalar, 15)->Arg(1000);
|
|
BENCHMARK_TEMPLATE(DivisionRightScalar, 25)->Arg(1000);
|
|
BENCHMARK_TEMPLATE(DivisionRightScalar, 32)->Arg(1000);
|
|
BENCHMARK_TEMPLATE(DivisionRightScalar, 200)->Arg(160);
|
|
|
|
template <std::size_t JET_SIZE>
|
|
static void MultiplyAndAdd(benchmark::State& state) {
|
|
using JetType = Jet<double, JET_SIZE>;
|
|
JetBenchmarkHelper<JET_SIZE>(
|
|
state, [](const JetInputData<JetType>& d, JetType& out) {
|
|
out += d.scalar_a() * d.a() + d.scalar_b() * d.b() +
|
|
d.scalar_c() * d.c() + d.scalar_d() * d.d() +
|
|
d.scalar_e() * d.e();
|
|
});
|
|
}
|
|
BENCHMARK_TEMPLATE(MultiplyAndAdd, 3)->Arg(1000);
|
|
BENCHMARK_TEMPLATE(MultiplyAndAdd, 10)->Arg(1000);
|
|
BENCHMARK_TEMPLATE(MultiplyAndAdd, 15)->Arg(1000);
|
|
BENCHMARK_TEMPLATE(MultiplyAndAdd, 25)->Arg(1000);
|
|
BENCHMARK_TEMPLATE(MultiplyAndAdd, 32)->Arg(1000);
|
|
BENCHMARK_TEMPLATE(MultiplyAndAdd, 200)->Arg(160);
|
|
|
|
} // namespace ceres
|
|
|
|
BENCHMARK_MAIN();
|