sleipnirgroup-jormungandr 0.6.7.dev67__tar.gz → 0.6.7.dev69__tar.gz

{sleipnirgroup_jormungandr-0.6.7.dev67 → sleipnirgroup_jormungandr-0.6.7.dev69}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sleipnirgroup-jormungandr
-Version: 0.6.7.dev67
+Version: 0.6.7.dev69
 Summary: Reverse mode autodiff library and NLP solver DSL
 License-Expression: BSD-3-Clause
 License-File: LICENSE.txt

{sleipnirgroup_jormungandr-0.6.7.dev67 → sleipnirgroup_jormungandr-0.6.7.dev69}/include/sleipnir/optimization/problem.hpp

@@ -35,12 +35,13 @@
 #include "sleipnir/optimization/solver/sqp_matrix_callbacks.hpp"
 #include "sleipnir/optimization/solver/util/bounds.hpp"
 #include "sleipnir/optimization/solver/util/problem_scaling.hpp"
+#include "sleipnir/optimization/solver/util/time_trace.hpp"
 #include "sleipnir/util/empty.hpp"
 #include "sleipnir/util/print.hpp"
 #include "sleipnir/util/print_diagnostics.hpp"
-#include "sleipnir/util/profiler.hpp"
 #include "sleipnir/util/spy.hpp"
 #include "sleipnir/util/symbol_exports.hpp"
+#include "sleipnir/util/time_tracer.hpp"
 
 namespace slp {
 
@@ -413,6 +414,7 @@ class Problem {
                           DenseVector& x) {
     using SparseMatrix = Eigen::SparseMatrix<Scalar>;
     using SparseVector = Eigen::SparseVector<Scalar>;
+    using enum SetupTimeTracerID;
 
     VariableMatrix<Scalar> x_ad{m_decision_variables};
 
@@ -430,27 +432,23 @@ class Problem {
       iteration_callbacks.emplace_back(callback);
     }
 
-    gch::small_vector<SetupProfiler> ad_setup_profilers;
-    ad_setup_profilers.emplace_back("setup");
-    ad_setup_profilers.emplace_back("↳ ∇f(x)");
-    ad_setup_profilers.emplace_back("↳ ∇²ₓₓL");
-
-    ad_setup_profilers[0].start();
+    TimeTracerTree<SetupTimeTracer, newton_setup_time_trace> ad_setup_tracers{
+        options.diagnostics};
+    ScopedTimeTracer setup_tracer{ad_setup_tracers[SETUP]};
 
     // Set up gradient autodiff
-    ad_setup_profilers[1].start();
+    PhaseTimeTracer phase_tracer{ad_setup_tracers[GRADIENT]};
     Gradient g{f, x_ad};
-    ad_setup_profilers[1].stop();
 
     // Set up Lagrangian Hessian autodiff
-    ad_setup_profilers[2].start();
+    phase_tracer.next(ad_setup_tracers[HESSIAN]);
     Hessian<Scalar, Eigen::Lower> H{f, x_ad};
-    ad_setup_profilers[2].stop();
 
-    ad_setup_profilers[0].stop();
+    phase_tracer.stop();
+    setup_tracer.stop();
 
     if (options.diagnostics) {
-      print_setup_diagnostics(ad_setup_profilers);
+      print_setup_diagnostics(ad_setup_tracers);
     }
 
 #ifndef SLEIPNIR_DISABLE_DIAGNOSTICS
@@ -498,6 +496,7 @@ class Problem {
                        DenseVector& x) {
     using SparseMatrix = Eigen::SparseMatrix<Scalar>;
     using SparseVector = Eigen::SparseVector<Scalar>;
+    using enum SetupTimeTracerID;
 
     VariableMatrix<Scalar> x_ad{m_decision_variables};
 
@@ -519,44 +518,35 @@ class Problem {
     VariableMatrix<Scalar> c_e_ad{m_equality_constraints};
     VariableMatrix<Scalar> y_ad(num_equality_constraints);
 
-    gch::small_vector<SetupProfiler> ad_setup_profilers;
-    ad_setup_profilers.emplace_back("setup");
-    ad_setup_profilers.emplace_back("↳ ∇f(x)");
-    ad_setup_profilers.emplace_back("↳ ∇²ₓₓL");
-    ad_setup_profilers.emplace_back("  ↳ ∇²ₓₓL_f");
-    ad_setup_profilers.emplace_back("  ↳ ∇²ₓₓL_c");
-    ad_setup_profilers.emplace_back("↳ ∂cₑ/∂x");
-
-    ad_setup_profilers[0].start();
+    TimeTracerTree<SetupTimeTracer, sqp_setup_time_trace> ad_setup_tracers{
+        options.diagnostics};
+    ScopedTimeTracer setup_tracer{ad_setup_tracers[SETUP]};
 
     // Set up gradient autodiff
-    ad_setup_profilers[1].start();
+    PhaseTimeTracer phase_tracer{ad_setup_tracers[GRADIENT]};
     Gradient g{f, x_ad};
-    ad_setup_profilers[1].stop();
 
-    ad_setup_profilers[2].start();
+    phase_tracer.next(ad_setup_tracers[HESSIAN]);
 
     // Set up cost part of Lagrangian Hessian autodiff
-    ad_setup_profilers[3].start();
+    PhaseTimeTracer hessian_phase_tracer{ad_setup_tracers[HESSIAN_COST]};
     Hessian<Scalar, Eigen::Lower> H_f{f, x_ad};
-    ad_setup_profilers[3].stop();
 
     // Set up constraint part of Lagrangian Hessian autodiff
-    ad_setup_profilers[4].start();
+    hessian_phase_tracer.next(ad_setup_tracers[HESSIAN_CONSTRAINTS]);
     Hessian<Scalar, Eigen::Lower> H_c{-y_ad.T() * c_e_ad, x_ad};
-    ad_setup_profilers[4].stop();
 
-    ad_setup_profilers[2].stop();
+    hessian_phase_tracer.stop();
 
     // Set up equality constraint Jacobian autodiff
-    ad_setup_profilers[5].start();
+    phase_tracer.next(ad_setup_tracers[EQUALITY_JACOBIAN]);
     Jacobian A_e{c_e_ad, x_ad};
-    ad_setup_profilers[5].stop();
 
-    ad_setup_profilers[0].stop();
+    phase_tracer.stop();
+    setup_tracer.stop();
 
     if (options.diagnostics) {
-      print_setup_diagnostics(ad_setup_profilers);
+      print_setup_diagnostics(ad_setup_tracers);
     }
 
 #ifndef SLEIPNIR_DISABLE_DIAGNOSTICS
@@ -626,6 +616,7 @@ class Problem {
                        DenseVector& x) {
     using SparseMatrix = Eigen::SparseMatrix<Scalar>;
     using SparseVector = Eigen::SparseVector<Scalar>;
+    using enum SetupTimeTracerID;
 
     VariableMatrix<Scalar> x_ad{m_decision_variables};
 
@@ -650,51 +641,40 @@ class Problem {
     VariableMatrix<Scalar> y_ad(num_equality_constraints);
     VariableMatrix<Scalar> z_ad(num_inequality_constraints);
 
-    gch::small_vector<SetupProfiler> ad_setup_profilers;
-    ad_setup_profilers.emplace_back("setup");
-    ad_setup_profilers.emplace_back("↳ ∇f(x)");
-    ad_setup_profilers.emplace_back("↳ ∇²ₓₓL");
-    ad_setup_profilers.emplace_back("  ↳ ∇²ₓₓL_f");
-    ad_setup_profilers.emplace_back("  ↳ ∇²ₓₓL_c");
-    ad_setup_profilers.emplace_back("↳ ∂cₑ/∂x");
-    ad_setup_profilers.emplace_back("↳ ∂cᵢ/∂x");
-
-    ad_setup_profilers[0].start();
+    TimeTracerTree<SetupTimeTracer, ipm_setup_time_trace> ad_setup_tracers{
+        options.diagnostics};
+    ScopedTimeTracer setup_tracer{ad_setup_tracers[SETUP]};
 
     // Set up gradient autodiff
-    ad_setup_profilers[1].start();
+    PhaseTimeTracer phase_tracer{ad_setup_tracers[GRADIENT]};
     Gradient g{f, x_ad};
-    ad_setup_profilers[1].stop();
 
-    ad_setup_profilers[2].start();
+    phase_tracer.next(ad_setup_tracers[HESSIAN]);
 
     // Set up cost part of Lagrangian Hessian autodiff
-    ad_setup_profilers[3].start();
+    PhaseTimeTracer hessian_phase_tracer{ad_setup_tracers[HESSIAN_COST]};
     Hessian<Scalar, Eigen::Lower> H_f{f, x_ad};
-    ad_setup_profilers[3].stop();
 
     // Set up constraint part of Lagrangian Hessian autodiff
-    ad_setup_profilers[4].start();
+    hessian_phase_tracer.next(ad_setup_tracers[HESSIAN_CONSTRAINTS]);
     Hessian<Scalar, Eigen::Lower> H_c{-y_ad.T() * c_e_ad - z_ad.T() * c_i_ad,
                                       x_ad};
-    ad_setup_profilers[4].stop();
 
-    ad_setup_profilers[2].stop();
+    hessian_phase_tracer.stop();
 
     // Set up equality constraint Jacobian autodiff
-    ad_setup_profilers[5].start();
+    phase_tracer.next(ad_setup_tracers[EQUALITY_JACOBIAN]);
     Jacobian A_e{c_e_ad, x_ad};
-    ad_setup_profilers[5].stop();
 
     // Set up inequality constraint Jacobian autodiff
-    ad_setup_profilers[6].start();
+    phase_tracer.next(ad_setup_tracers[INEQUALITY_JACOBIAN]);
     Jacobian A_i{c_i_ad, x_ad};
-    ad_setup_profilers[6].stop();
 
-    ad_setup_profilers[0].stop();
+    phase_tracer.stop();
+    setup_tracer.stop();
 
     if (options.diagnostics) {
-      print_setup_diagnostics(ad_setup_profilers);
+      print_setup_diagnostics(ad_setup_tracers);
     }
 
 #ifndef SLEIPNIR_DISABLE_DIAGNOSTICS

{sleipnirgroup_jormungandr-0.6.7.dev67 → sleipnirgroup_jormungandr-0.6.7.dev69}/include/sleipnir/optimization/solver/ipm.hpp

@@ -6,6 +6,7 @@
 #include <chrono>
 #include <cmath>
 #include <functional>
+#include <optional>
 #include <span>
 
 #include <Eigen/Core>
@@ -24,11 +25,12 @@
 #include "sleipnir/optimization/solver/util/fraction_to_the_boundary_rule.hpp"
 #include "sleipnir/optimization/solver/util/kkt_error.hpp"
 #include "sleipnir/optimization/solver/util/kkt_solver.hpp"
+#include "sleipnir/optimization/solver/util/time_trace.hpp"
 #include "sleipnir/util/assert.hpp"
 #include "sleipnir/util/print_diagnostics.hpp"
-#include "sleipnir/util/profiler.hpp"
 #include "sleipnir/util/scope_exit.hpp"
 #include "sleipnir/util/symbol_exports.hpp"
+#include "sleipnir/util/time_tracer.hpp"
 
 // See docs/algorithms.md#Works_cited for citation definitions.
 //
@@ -145,99 +147,62 @@ ExitStatus ipm(const IPMMatrixCallbacks<Scalar>& matrix_callbacks,
     DenseVector p_y;
     /// Inequality constraint dual step.
     DenseVector p_z;
+
+    /// Returns the infinity norm of the primal step.
+    ///
+    /// @return The infinity norm of the primal step.
+    Scalar primal_inf_norm() const {
+      return std::max(p_x.template lpNorm<Eigen::Infinity>(),
+                      p_s.template lpNorm<Eigen::Infinity>());
+    }
+
+    /// Returns the infinity norm of the dual step.
+    ///
+    /// @return The infinity norm of the dual step.
+    Scalar dual_inf_norm() const {
+      return std::max(p_y.template lpNorm<Eigen::Infinity>(),
+                      p_z.template lpNorm<Eigen::Infinity>());
+    }
   };
 
   using std::isfinite;
 
   const auto solve_start_time = std::chrono::steady_clock::now();
 
-  gch::small_vector<SolveProfiler> solve_profilers;
-  solve_profilers.emplace_back("solver");
-  solve_profilers.emplace_back("↳ setup");
-  solve_profilers.emplace_back("↳ iteration");
-  solve_profilers.emplace_back("  ↳ callbacks");
-  solve_profilers.emplace_back("  ↳ KKT matrix build");
-  solve_profilers.emplace_back("  ↳ KKT matrix decomp");
-  solve_profilers.emplace_back("  ↳ KKT system solve");
-  solve_profilers.emplace_back("  ↳ line search");
-  solve_profilers.emplace_back("    ↳ SOC");
-  solve_profilers.emplace_back("  ↳ feas. restoration");
-  solve_profilers.emplace_back("  ↳ f(x)");
-  solve_profilers.emplace_back("  ↳ ∇f(x)");
-  solve_profilers.emplace_back("  ↳ ∇²ₓₓL");
-  solve_profilers.emplace_back("  ↳ ∇²ₓₓL_c");
-  solve_profilers.emplace_back("  ↳ cₑ(x)");
-  solve_profilers.emplace_back("  ↳ ∂cₑ/∂x");
-  solve_profilers.emplace_back("  ↳ cᵢ(x)");
-  solve_profilers.emplace_back("  ↳ ∂cᵢ/∂x");
-
-  auto& solver_prof = solve_profilers[0];
-  auto& setup_prof = solve_profilers[1];
-  auto& inner_iter_prof = solve_profilers[2];
-  auto& iter_callbacks_prof = solve_profilers[3];
-  auto& kkt_matrix_build_prof = solve_profilers[4];
-  auto& kkt_matrix_decomp_prof = solve_profilers[5];
-  auto& kkt_system_solve_prof = solve_profilers[6];
-  auto& line_search_prof = solve_profilers[7];
-  auto& soc_prof = solve_profilers[8];
-  auto& feasibility_restoration_prof = solve_profilers[9];
-
-  // Set up profiled matrix callbacks
+  using enum SolveTimeTracerID;
+
+  // Prints final solver diagnostics when the solver exits
+  //
+  // Feasibility restoration still traces so its iterations can be printed, but
+  // the outer solver prints the final solver diagnostics.
+  SolveDiagnostics<ipm_time_trace> diagnostics{options.diagnostics,
+                                               !in_feasibility_restoration};
+
+  // Set up traced matrix callbacks if diagnostics are enabled. Feasibility
+  // restoration's callbacks call the outer solver's, which are already traced.
 #ifndef SLEIPNIR_DISABLE_DIAGNOSTICS
-  auto& f_prof = solve_profilers[10];
-  auto& g_prof = solve_profilers[11];
-  auto& H_prof = solve_profilers[12];
-  auto& H_c_prof = solve_profilers[13];
-  auto& c_e_prof = solve_profilers[14];
-  auto& A_e_prof = solve_profilers[15];
-  auto& c_i_prof = solve_profilers[16];
-  auto& A_i_prof = solve_profilers[17];
-
-  IPMMatrixCallbacks<Scalar> matrices{
-      matrix_callbacks.num_decision_variables,
-      matrix_callbacks.num_equality_constraints,
-      matrix_callbacks.num_inequality_constraints,
-      [&](const DenseVector& x) -> Scalar {
-        ScopedProfiler prof{f_prof};
-        return matrix_callbacks.f(x);
-      },
-      [&](const DenseVector& x) -> SparseVector {
-        ScopedProfiler prof{g_prof};
-        return matrix_callbacks.g(x);
-      },
-      [&](const DenseVector& x, const DenseVector& y,
-          const DenseVector& z) -> SparseMatrix {
-        ScopedProfiler prof{H_prof};
-        return matrix_callbacks.H(x, y, z);
-      },
-      [&](const DenseVector& x, const DenseVector& y,
-          const DenseVector& z) -> SparseMatrix {
-        ScopedProfiler prof{H_c_prof};
-        return matrix_callbacks.H_c(x, y, z);
-      },
-      [&](const DenseVector& x) -> DenseVector {
-        ScopedProfiler prof{c_e_prof};
-        return matrix_callbacks.c_e(x);
-      },
-      [&](const DenseVector& x) -> SparseMatrix {
-        ScopedProfiler prof{A_e_prof};
-        return matrix_callbacks.A_e(x);
-      },
-      [&](const DenseVector& x) -> DenseVector {
-        ScopedProfiler prof{c_i_prof};
-        return matrix_callbacks.c_i(x);
-      },
-      [&](const DenseVector& x) -> SparseMatrix {
-        ScopedProfiler prof{A_i_prof};
-        return matrix_callbacks.A_i(x);
-      },
-      matrix_callbacks.scaling};
+  std::optional<IPMMatrixCallbacks<Scalar>> traced_matrices;
+  if (options.diagnostics && !in_feasibility_restoration) {
+    traced_matrices.emplace(
+        matrix_callbacks.num_decision_variables,
+        matrix_callbacks.num_equality_constraints,
+        matrix_callbacks.num_inequality_constraints,
+        traced(diagnostics[COST], matrix_callbacks.f),
+        traced(diagnostics[GRADIENT], matrix_callbacks.g),
+        traced(diagnostics[HESSIAN], matrix_callbacks.H),
+        traced(diagnostics[HESSIAN_CONSTRAINTS], matrix_callbacks.H_c),
+        traced(diagnostics[EQUALITY_CONSTRAINTS], matrix_callbacks.c_e),
+        traced(diagnostics[EQUALITY_JACOBIAN], matrix_callbacks.A_e),
+        traced(diagnostics[INEQUALITY_CONSTRAINTS], matrix_callbacks.c_i),
+        traced(diagnostics[INEQUALITY_JACOBIAN], matrix_callbacks.A_i),
+        matrix_callbacks.scaling);
+  }
+  const auto& matrices = traced_matrices ? *traced_matrices : matrix_callbacks;
 #else
   const auto& matrices = matrix_callbacks;
 #endif
 
-  solver_prof.start();
-  setup_prof.start();
+  ScopedTimeTracer setup_tracer{diagnostics[SETUP]};
 
   Scalar f = matrices.f(x);
   SparseVector g = matrices.g(x);
@@ -359,32 +324,23 @@ ExitStatus ipm(const IPMMatrixCallbacks<Scalar>& matrix_callbacks,
   Scalar E_0 = unscaled_kkt_error<Scalar, KKTErrorType::INF_NORM_SCALED>(
       matrices.scaling, g, A_e, c_e, A_i, c_i, s, y, z, Scalar(0));
 
-  setup_prof.stop();
-
-  // Prints final solver diagnostics when the solver exits
-  scope_exit exit{[&] {
-    if (options.diagnostics) {
-      solver_prof.stop();
-
-      if (in_feasibility_restoration) {
-        return;
-      }
-
-      if (iterations > 0) {
-        print_bottom_iteration_diagnostics();
-      }
-      print_solver_diagnostics(solve_profilers);
-    }
-  }};
-
-  // Print initial iterate diagnostics
-  if (options.diagnostics) {
-    print_initial_iterate_diagnostics(E_0, f, constraint_violation(c_e, c_i, s),
-                                      s.dot(z), μ);
-  }
+  setup_tracer.stop();
+
+  // Prints initial iterate diagnostics now and closes the iterate diagnostics
+  // table when the solver exits.
+  //
+  // Feasibility restoration's iterations are printed in the outer solver's
+  // table, so it doesn't open its own.
+  IterateDiagnosticsTable table{
+      options.diagnostics && !in_feasibility_restoration,
+      E_0,
+      f,
+      constraint_violation(c_e, c_i, s),
+      s.dot(z),
+      μ};
 
   while (E_0 > Scalar(options.tolerance)) {
-    ScopedProfiler inner_iter_profiler{inner_iter_prof};
+    ScopedTimeTracer inner_iter_tracer{diagnostics[ITERATION]};
 
     // Check for diverging iterates
     if (x.template lpNorm<Eigen::Infinity>() > Scalar(1e10) || !x.allFinite() ||
@@ -392,7 +348,7 @@ ExitStatus ipm(const IPMMatrixCallbacks<Scalar>& matrix_callbacks,
       return ExitStatus::DIVERGING_ITERATES;
     }
 
-    ScopedProfiler iter_callbacks_profiler{iter_callbacks_prof};
+    PhaseTimeTracer phase_tracer{diagnostics[CALLBACKS]};
 
     // Call iteration callbacks
     for (const auto& callback : iteration_callbacks) {
@@ -401,8 +357,7 @@ ExitStatus ipm(const IPMMatrixCallbacks<Scalar>& matrix_callbacks,
       }
     }
 
-    iter_callbacks_profiler.stop();
-    ScopedProfiler kkt_matrix_build_profiler{kkt_matrix_build_prof};
+    phase_tracer.next(diagnostics[KKT_MATRIX_BUILD]);
 
     // S = diag(s)
     // Z = diag(z)
@@ -431,8 +386,7 @@ ExitStatus ipm(const IPMMatrixCallbacks<Scalar>& matrix_callbacks,
         A_i.transpose() * (-Σ * c_i + μ * s.cwiseInverse() + z);
     rhs.segment(x.rows(), y.rows()) = -c_e;
 
-    kkt_matrix_build_profiler.stop();
-    ScopedProfiler kkt_matrix_decomp_profiler{kkt_matrix_decomp_prof};
+    phase_tracer.next(diagnostics[KKT_MATRIX_DECOMP]);
 
     Step step;
     Scalar α_max(1);
@@ -448,8 +402,7 @@ ExitStatus ipm(const IPMMatrixCallbacks<Scalar>& matrix_callbacks,
       return ExitStatus::FACTORIZATION_FAILED;
     }
 
-    kkt_matrix_decomp_profiler.stop();
-    ScopedProfiler kkt_system_solve_profiler{kkt_system_solve_prof};
+    phase_tracer.next(diagnostics[KKT_SYSTEM_SOLVE]);
 
     auto compute_step = [&](Step& step, const DenseVector& c_i_minus_s) {
       // p = [ pˣ]
@@ -465,8 +418,7 @@ ExitStatus ipm(const IPMMatrixCallbacks<Scalar>& matrix_callbacks,
     };
     compute_step(step, c_i - s);
 
-    kkt_system_solve_profiler.stop();
-    ScopedProfiler line_search_profiler{line_search_prof};
+    phase_tracer.next(diagnostics[LINE_SEARCH]);
 
     // αᵐᵃˣ = max(α ∈ (0, 1] : sₖ + αpₖˢ ≥ (1−τⱼ)sₖ)
     α_max = fraction_to_the_boundary_rule<Scalar>(s, step.p_s, τ);
@@ -555,26 +507,23 @@ ExitStatus ipm(const IPMMatrixCallbacks<Scalar>& matrix_callbacks,
         bool step_acceptable = false;
         for (int soc_iteration = 0; soc_iteration < 5 && !step_acceptable;
              ++soc_iteration) {
-          ScopedProfiler soc_profiler{soc_prof};
+          ScopedTimeTracer soc_tracer{diagnostics[SOC]};
 
           scope_exit soc_exit{[&] {
-            soc_profiler.stop();
+            soc_tracer.stop();
 
             if (options.diagnostics && step_acceptable) {
-              print_iteration_diagnostics(
+              print_iterate_diagnostics(
                   iterations, IterationType::SECOND_ORDER_CORRECTION,
-                  soc_profiler.current_duration(),
+                  soc_tracer.current_duration(),
                   unscaled_kkt_error<Scalar, KKTErrorType::INF_NORM_SCALED>(
                       matrices.scaling, g, A_e, trial_c_e, A_i, trial_c_i,
                       trial_s, trial_y, trial_z, Scalar(0)),
                   trial_f, constraint_violation(trial_c_e, trial_c_i, trial_s),
                   trial_s.dot(trial_z), μ, solver.hessian_regularization(),
                   solver.constraint_jacobian_regularization(),
-                  std::max(soc_step.p_x.template lpNorm<Eigen::Infinity>(),
-                           soc_step.p_s.template lpNorm<Eigen::Infinity>()),
-                  std::max(soc_step.p_y.template lpNorm<Eigen::Infinity>(),
-                           soc_step.p_z.template lpNorm<Eigen::Infinity>()),
-                  α_soc, Scalar(1), α_reduction_factor, α_z_soc);
+                  soc_step.primal_inf_norm(), soc_step.dual_inf_norm(), α_soc,
+                  Scalar(1), α_reduction_factor, α_z_soc);
             }
           }};
 
@@ -696,7 +645,7 @@ ExitStatus ipm(const IPMMatrixCallbacks<Scalar>& matrix_callbacks,
       }
     }
 
-    line_search_profiler.stop();
+    phase_tracer.stop();
 
     // If solver stalled, invoke feasibility restoration
     if (!call_feasibility_restoration && !in_feasibility_restoration) {
@@ -708,8 +657,8 @@ ExitStatus ipm(const IPMMatrixCallbacks<Scalar>& matrix_callbacks,
     }
 
     if (call_feasibility_restoration) {
-      ScopedProfiler feasibility_restoration_profiler{
-          feasibility_restoration_prof};
+      ScopedTimeTracer feasibility_restoration_tracer{
+          diagnostics[FEASIBILITY_RESTORATION]};
 
       // If already in feasibility restoration mode, running it again won't help
       if (in_feasibility_restoration) {
@@ -821,22 +770,18 @@ ExitStatus ipm(const IPMMatrixCallbacks<Scalar>& matrix_callbacks,
       }
     }
 
-    inner_iter_profiler.stop();
+    inner_iter_tracer.stop();
 
     if (options.diagnostics) {
-      print_iteration_diagnostics(
+      print_iterate_diagnostics(
           iterations,
           in_feasibility_restoration ? IterationType::FEASIBILITY_RESTORATION
                                      : IterationType::NORMAL,
-          inner_iter_profiler.current_duration(), E_0, f,
+          inner_iter_tracer.current_duration(), E_0, f,
           constraint_violation(c_e, c_i, s), s.dot(z), μ,
           solver.hessian_regularization(),
-          solver.constraint_jacobian_regularization(),
-          std::max(step.p_x.template lpNorm<Eigen::Infinity>(),
-                   step.p_s.template lpNorm<Eigen::Infinity>()),
-          std::max(step.p_y.template lpNorm<Eigen::Infinity>(),
-                   step.p_z.template lpNorm<Eigen::Infinity>()),
-          α, α_max, α_reduction_factor, α_z);
+          solver.constraint_jacobian_regularization(), step.primal_inf_norm(),
+          step.dual_inf_norm(), α, α_max, α_reduction_factor, α_z);
     }
 
     ++iterations;