Simplified performance tests by using a common template.

1 files changed, 38 insertions, 80 deletions

diff --git a/source/blender/blenkernel/intern/curves_constraints_test.cc b/source/blender/blenkernel/intern/curves_constraints_test.cc
index 5ae6850c98b..0a872614829 100644
--- a/source/blender/blenkernel/intern/curves_constraints_test.cc
+++ b/source/blender/blenkernel/intern/curves_constraints_test.cc
@@ -253,28 +253,33 @@ static void print_test_stats(const CurvesGeometry &curves, const ConstraintSolve
             << " ms, solve: " << result.timing.solve_constraints * 1000.0f << " ms" << std::endl;
 }
 
-class SolverIterationsTestSuite : public CurveConstraintSolverPerfTestSuite,
-                                  public testing::WithParamInterface<int>
-{
+template <typename ParamType>
+class SolverPerfTestSuite : public CurveConstraintSolverPerfTestSuite,
+                            public testing::WithParamInterface<ParamType> {
  public:
   struct TestResult {
-    int param;
+    ParamType param;
     ConstraintSolver::Result solver_result;
   };
-  static Vector<TestResult> results_;
+
+  static Vector<TestResult> &results()
+  {
+    static Vector<TestResult> results_;
+    return results_;
+  }
 
   static void SetUpTestSuite()
   {
     CurveConstraintSolverPerfTestSuite::SetUpTestSuite();
 
-    results_.clear();
+    results().clear();
   }
 
   static void TearDownTestSuite()
   {
     /* CSV printout for simple data import */
-    std::cout << "Max Iterations,RMS Error,Max Error,Collision Detection (ms),Solve Time (ms)" << std::endl;
-    for (const TestResult &result : results_) {
+    std::cout << "Parameter,RMS Error,Max Error,Collision Detection (ms),Solve Time (ms)" << std::endl;
+    for (const TestResult &result : results()) {
       std::cout << result.param << "," << result.solver_result.rms_residual << ","
                 << sqrtf(result.solver_result.max_error_squared) << ","
                 << result.solver_result.timing.find_contacts << ","
@@ -283,34 +288,37 @@ class SolverIterationsTestSuite : public CurveConstraintSolverPerfTestSuite,
 
     CurveConstraintSolverPerfTestSuite::TearDownTestSuite();
   }
-};
 
-Vector<SolverIterationsTestSuite::TestResult> SolverIterationsTestSuite::results_;
+  void randomized_test(const ParamType &test_param, const ConstraintSolver::Params &solver_params)
+  {
+    CurvesGeometry curves = create_randomized_curves(10000, 4, 50, 0.1f, 0.2f);
+    const CurvesSurfaceTransforms transforms = create_curves_surface_transforms();
 
-TEST_P(SolverIterationsTestSuite, RandomizedTest)
-{
-  CurvesGeometry curves = create_randomized_curves(10000, 4, 50, 0.1f, 0.2f);
-  const CurvesSurfaceTransforms transforms = create_curves_surface_transforms();
+    Mesh *surface = create_noise_grid();
 
-  Mesh *surface = create_noise_grid();
+    ConstraintSolver solver;
+    solver.initialize(solver_params, curves, curves.curves_range());
 
-  ConstraintSolver solver;
-  ConstraintSolver::Params params;
-  params.max_solver_iterations = GetParam();
+    const VArray<int> changed_curves = VArray<int>::ForFunc(curves.curves_num(),
+                                                            [](int64_t i) { return (int)i; });
+    const Array<float3> orig_positions = curves.positions();
+    randomized_point_offset(curves, changed_curves, 0.0f, 1.0f);
+    solver.step_curves(curves, surface, transforms, orig_positions, changed_curves);
 
-  solver.initialize(params, curves, curves.curves_range());
+    BKE_id_free(nullptr, surface);
 
-  const VArray<int> changed_curves = VArray<int>::ForFunc(curves.curves_num(),
-                                                    [](int64_t i) { return (int)i; });
-  const Array<float3> orig_positions = curves.positions();
-  randomized_point_offset(curves, changed_curves, 0.0f, 1.0f);
-  solver.step_curves(curves, surface, transforms, orig_positions, changed_curves);
+    results().append(TestResult{test_param, solver.result()});
+  }
+};
+
+using SolverIterationsTestSuite = SolverPerfTestSuite<int>;
 
-  BKE_id_free(nullptr, surface);
+TEST_P(SolverIterationsTestSuite, RandomizedTest)
+{
+  ConstraintSolver::Params params;
+  params.max_solver_iterations = GetParam();
 
-  print_test_stats(curves, solver.result());
-  SolverIterationsTestSuite::results_.append(
-      SolverIterationsTestSuite::TestResult{GetParam(), solver.result()});
+  randomized_test(GetParam(), params);
 }
 
 INSTANTIATE_TEST_SUITE_P(SolverIterationsTests,
@@ -322,64 +330,14 @@ INSTANTIATE_TEST_SUITE_P(SolverIterationsTests,
                            return ss.str();
                          });
 
-class BVHBranchingFactorTestSuite : public CurveConstraintSolverPerfTestSuite,
-                                    public testing::WithParamInterface<int> {
- public:
-  struct TestResult {
-    int param;
-    ConstraintSolver::Result solver_result;
-  };
-  static Vector<TestResult> results_;
-
-  static void SetUpTestSuite()
-  {
-    CurveConstraintSolverPerfTestSuite::SetUpTestSuite();
-
-    results_.clear();
-  }
-
-  static void TearDownTestSuite()
-  {
-    /* CSV printout for simple data import */
-    std::cout << "BVH Branching Factor,RMS Error,Max Error,Collision Detection (ms),Solve Time (ms)"
-              << std::endl;
-    for (const TestResult &result : results_) {
-      std::cout << result.param << "," << result.solver_result.rms_residual << ","
-                << sqrtf(result.solver_result.max_error_squared) << ","
-                << result.solver_result.timing.find_contacts << ","
-                << result.solver_result.timing.solve_constraints << std::endl;
-    }
-
-    CurveConstraintSolverPerfTestSuite::TearDownTestSuite();
-  }
-};
-
-Vector<BVHBranchingFactorTestSuite::TestResult> BVHBranchingFactorTestSuite::results_;
+using BVHBranchingFactorTestSuite = SolverPerfTestSuite<int>;
 
 TEST_P(BVHBranchingFactorTestSuite, RandomizedTest)
 {
-  CurvesGeometry curves = create_randomized_curves(10000, 4, 50, 0.1f, 0.2f);
-  const CurvesSurfaceTransforms transforms = create_curves_surface_transforms();
-
-  Mesh *surface = create_noise_grid();
-
-  ConstraintSolver solver;
   ConstraintSolver::Params params;
   params.bvh_branching_factor = GetParam();
 
-  solver.initialize(params, curves, curves.curves_range());
-
-  const VArray<int> changed_curves = VArray<int>::ForFunc(curves.curves_num(),
-                                                          [](int64_t i) { return (int)i; });
-  const Array<float3> orig_positions = curves.positions();
-  randomized_point_offset(curves, changed_curves, 0.0f, 1.0f);
-  solver.step_curves(curves, surface, transforms, orig_positions, changed_curves);
-
-  BKE_id_free(nullptr, surface);
-
-  print_test_stats(curves, solver.result());
-  BVHBranchingFactorTestSuite::results_.append(
-      BVHBranchingFactorTestSuite::TestResult{GetParam(), solver.result()});
+  randomized_test(GetParam(), params);
 }
 
 INSTANTIATE_TEST_SUITE_P(BVHBranchingFactorTests,