A nanobenchmark for Hermite3.

Author: pleroy

nanobenchmarks/hermite3_nanobenchmark.cpp

@@ -0,0 +1,79 @@
+#include "geometry/frame.hpp"
+#include "geometry/grassmann.hpp"
+#include "geometry/instant.hpp"
+#include "geometry/space.hpp"
+#include "nanobenchmarks/nanobenchmark.hpp"  // 🧙 For NANOBENCHMARK_*.
+#include "numerics/hermite3.hpp"
+#include "quantities/si.hpp"
+
+namespace principia {
+namespace nanobenchmarks {
+
+using namespace principia::geometry::_frame;
+using namespace principia::geometry::_grassmann;
+using namespace principia::geometry::_instant;
+using namespace principia::geometry::_space;
+using namespace principia::nanobenchmarks::_nanobenchmark;
+using namespace principia::numerics::_hermite3;
+using namespace principia::quantities::_si;
+
+using World = Frame<serialization::Frame::TestTag,
+                    Inertial,
+                    Handedness::Right,
+                    serialization::Frame::TEST>;
+
+class Hermite3Nanobenchmark : public Nanobenchmark {
+ protected:
+  using H = Hermite3<Displacement<World>, Instant>;
+
+  Hermite3Nanobenchmark()
+      : t0_(Instant() + 0.3 * Second),
+        t1_(Instant() + 3 * Second),
+        d0_({0 * Metre, 0 * Metre, 1 * Metre}),
+        d1_({1 * Metre, 3 * Metre, 1 * Metre}),
+        v0_({0 * Metre / Second, 1 * Metre / Second, 0 * Metre / Second}),
+        v1_({0 * Metre / Second, 3 * Metre / Second, 3 * Metre / Second}),
+        h_({t0_, t1_}, {d0_, d1_}, {v0_, v1_}) {};
+
+  static double ToDouble(Displacement<World> const& displacement) {
+    auto const& coordinates = displacement.coordinates();
+    return _mm_cvtsd_f64(
+        _mm_and_pd(_mm_set_pd(coordinates.x / Metre, coordinates.y / Metre),
+                   _mm_set_sd(coordinates.z / Metre)));
+  }
+
+  static double ToDouble(Displacement<World> const& displacement,
+                         Velocity<World> const& velocity) {
+    auto const& d = displacement.coordinates();
+    auto const& v = velocity.coordinates();
+    return _mm_cvtsd_f64(
+        _mm_and_pd(_mm_and_pd(_mm_set_pd(d.x / Metre, d.y / Metre),
+                              _mm_set_pd(d.z / Metre, v.x / (Metre / Second))),
+                   _mm_set_pd(v.y / (Metre / Second), v.z / (Metre / Second))));
+  }
+
+  Instant const t0_;
+  Instant const t1_;
+  Displacement<World> const d0_;
+  Displacement<World> const d1_;
+  Velocity<World> const v0_;
+  Velocity<World> const v1_;
+  H const h_;
+};
+
+NANOBENCHMARK_FIXTURE(Hermite3Nanobenchmark, ConstructionAndValue) {
+  H const h({t0_, t1_ + x * Second}, {d0_, d1_}, {v0_, v1_});
+  return ToDouble(h.Evaluate(t0_));
+}
+
+NANOBENCHMARK_FIXTURE(Hermite3Nanobenchmark, Value) {
+  return ToDouble(h_.Evaluate(t0_ + x * Second));
+}
+
+NANOBENCHMARK_FIXTURE(Hermite3Nanobenchmark, ValueAndDerivative) {
+  Instant const t = t0_ + x * Second;
+  return ToDouble(h_.Evaluate(t), h_.EvaluateDerivative(t));
+}
+
+}  // namespace nanobenchmarks
+}  // namespace principia

nanobenchmarks/nanobenchmarks.vcxproj

@@ -18,6 +18,7 @@
     <ClCompile Include="elementary_functions_nanobenchmark.cpp" />
     <ClCompile Include="examples_nanobenchmark.cpp" />
     <ClCompile Include="flag_parsing.cpp" />
+    <ClCompile Include="hermite3_nanobenchmark.cpp" />
     <ClCompile Include="latency_distribution_table.cpp" />
     <ClCompile Include="main.cpp" />
     <ClCompile Include="nanobenchmark.cpp" />

nanobenchmarks/nanobenchmarks.vcxproj.filters

@@ -42,6 +42,9 @@
     <ClCompile Include="nanobenchmark.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="hermite3_nanobenchmark.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="performance_settings_controller.hpp">