Merge pull request #243 from Simple-Robotics/topic/gar-optimizations

Add memory allocator support for LQ subproblem types, merge `gar` into main aligator library, slight refactor of `DenseRiccatiSolver`

Author: ManifoldFR

CHANGELOG.md

@@ -11,11 +11,30 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Add CMake macro `aligator_create_python_extension()` to export ([#298](https://github.com/Simple-Robotics/aligator/pull/298))
 - Add `LqrProblemTpl::isApprox()` and helper `lqrKnotsSameDim`, check dimensions in `LqrKnotTpl::isApprox()` ([#300](https://github.com/Simple-Robotics/aligator/pull/300))
+- Add class `aligator::polymorphic_allocator` leveraging C++17 memory resources
+- Add memory allocator support for `LqrKnot` and `LqrProblem`
+- Add class `DenseKernel` for the stagewise-dense Riccati algo -- rework `DenseRiccatiSolver` class
 - Add `gar/fwd.hpp` header ([#301](https://github.com/Simple-Robotics/aligator/pull/301/))
 
 ### Changed
 
 - Rename `{ riccati-impl.hpp => riccati-kernel }` (and associated files) ([#301](https://github.com/Simple-Robotics/aligator/pull/301/))
+- Rename `LQRKnotTpl` (C++)/`LqrKnot` (Python) to `LqrKnot(Tpl)`
+- Move `HistoryCallbackTpl` to `aligator/core`
+- Move headers `results-base`, `solver-util`, `value-function`, `workspace-base` to `aligator/core`
+- Rename `LQRProblemTpl` (C++)/`LQRProblem` (Python) to `LqrProblem(Tpl)`
+- `fwd.hpp`: do not include `<pinocchio/config.hpp>` header anymore
+- `blk-matrix.hpp`: remove protected ctors, add conversion ops
+- Headers `aligator/gar/*.hpp` merged into main library
+- CMake: rework declaration of examples & benchmarks (applying liberal use of `cmake_parse_arguments()`)
+- CMake: add `bench/CMakeLists.txt` to gersemi defs, apply formatting
+- CMake: apply compile definitions to `aligator` target directly (reduce use of global compile definitions)
+
+### Removed
+
+- Removed `gar` as a separate CMake target and shared library, merge into main library
+- Remove subdirectory `aligator/helpers` from include dir
+- Remove function `allocate_shared_eigen_aligned()`
 
 ## [0.13.0] - 2025-04-26
 
@@ -44,6 +63,22 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Changed
 
+- Only link against needed pinocchio libraries ([#260](https://github.com/Simple-Robotics/aligator/pull/260))
+- Use Pinocchio instantiated functions ([#261](https://github.com/Simple-Robotics/aligator/pull/261))
+- Rename `LQRKnotTpl` (C++)/`LqrKnot` (Python) to `LqrKnot(Tpl)`
+- Move `HistoryCallbackTpl` to `aligator/core`
+- Move headers `results-base`, `solver-util`, `value-function`, `workspace-base` to `aligator/core`
+- Rename `LQRProblemTpl` (C++)/`LQRProblem` (Python) to `LqrProblem(Tpl)`
+- Add class `aligator::polymorphic_allocator` leveraging C++17 memory resources
+- Add memory allocator support for `LqrKnot` and `LqrProblem`
+- `fwd.hpp`: do not include `<pinocchio/config.hpp>` header anymore
+- `blk-matrix.hpp`: remove protected ctors, add conversion ops
+- Headers `aligator/gar/*.hpp` merged into main library
+- Add class `DenseKernel` for the stagewise-dense Riccati algo -- rework `DenseRiccatiSolver` class
+- CMake: rework declaration of examples & benchmarks (applying liberal use of `cmake_parse_arguments()`)
+- CMake: add `bench/CMakeLists.txt` to gersemi defs, apply formatting
+- CMake: apply compile definitions to `aligator` target directly (reduce use of global compile definitions)
+- Add `LqrProblemTpl::isApprox()`
 - Only link against needed pinocchio libraries ([#260](https://github.com/Simple-Robotics/aligator/pull/260))
 - Use Pinocchio instantiated functions ([#261](https://github.com/Simple-Robotics/aligator/pull/261))
 - Link to pinocchio collision

CMakeLists.txt

@@ -239,12 +239,12 @@ if(BUILD_WITH_PINOCCHIO_SUPPORT)
       "If you didn't build proxsuite-nlp yourself, please contact the maintainer for the distribution you used."
     )
   endif()
-  add_compile_definitions(ALIGATOR_WITH_PINOCCHIO)
-  list(APPEND CFLAGS_DEPENDENCIES "-DALIGATOR_WITH_PINOCCHIO")
-  set(PINOCCHIO_V3 ${pinocchio_VERSION} VERSION_GREATER "3.0.0")
-  if(PINOCCHIO_V3)
-    add_compile_definitions(ALIGATOR_PINOCCHIO_V3)
+
+  if(${pinocchio_VERSION} VERSION_GREATER "3.0.0")
+    set(PINOCCHIO_V3 TRUE)
   endif()
+
+  list(APPEND CFLAGS_DEPENDENCIES "-DALIGATOR_WITH_PINOCCHIO")
 elseif(PROXSUITE_NLP_WITH_PINOCCHIO_SUPPORT)
   message(
     WARNING
@@ -255,7 +255,6 @@ endif()
 
 if(BUILD_CROCODDYL_COMPAT)
   message(STATUS "Building with Crocoddyl support.")
-  add_compile_definitions(ALIGATOR_WITH_CROCODDYL_COMPAT)
   list(APPEND CFLAGS_DEPENDENCIES "-DALIGATOR_WITH_CROCODDYL_COMPAT")
 endif()
 
@@ -270,7 +269,6 @@ if(BUILD_WITH_CHOLMOD_SUPPORT)
     STATUS
     "Build with CHOLMOD support (LGPL). See CHOLMOD/Doc/License.txt for further details."
   )
-  add_compile_definitions(ALIGATOR_WITH_CHOLMOD)
 endif()
 
 if(BUILD_PYTHON_INTERFACE)
@@ -285,6 +283,7 @@ if(BUILD_PYTHON_INTERFACE)
   set(${PYLIB_NAME}_INSTALL_DIR ${PYTHON_SITELIB}/${PROJECT_NAME})
 endif()
 
+# Without template instantiation, library only compiles exceptions and logging.
 set(LIB_SOURCES src/utils/exceptions.cpp src/utils/logger.cpp)
 
 file(
@@ -299,8 +298,8 @@ if(ENABLE_TEMPLATE_INSTANTIATION)
     GLOB_RECURSE LIB_TEMPLATE_SOURCES
     CONFIGURE_DEPENDS
     ${PROJECT_SOURCE_DIR}/src/core/*.cpp
-    ${PROJECT_SOURCE_DIR}/src/solvers/fddp/*.cpp
-    ${PROJECT_SOURCE_DIR}/src/solvers/proxddp/*.cpp
+    ${PROJECT_SOURCE_DIR}/src/gar/*.cpp
+    ${PROJECT_SOURCE_DIR}/src/solvers/*.cpp
     ${PROJECT_SOURCE_DIR}/src/modelling/*.cpp
   )
   file(
@@ -367,8 +366,6 @@ elseif(ALIGATOR_TRACY_ENABLE)
   endif()
 endif()
 
-add_subdirectory(gar)
-
 # Create the main shared library.
 function(create_library)
   add_library(${PROJECT_NAME} SHARED ${LIB_HEADERS} ${LIB_SOURCES})
@@ -382,7 +379,6 @@ function(create_library)
   )
   set_standard_output_directory(${PROJECT_NAME})
 
-  target_link_libraries(${PROJECT_NAME} PUBLIC aligator::gar)
   # Extract the compile definitions of the project for export
   get_directory_property(CURRENT_COMPILE_DEFINITIONS COMPILE_DEFINITIONS)
   target_compile_definitions(
@@ -395,6 +391,15 @@ function(create_library)
       ${PROJECT_NAME}
       PUBLIC pinocchio::pinocchio_default pinocchio::pinocchio_collision
     )
+    target_compile_definitions(${PROJECT_NAME} PUBLIC ALIGATOR_WITH_PINOCCHIO)
+    if(PINOCCHIO_V3)
+      target_compile_definitions(${PROJECT_NAME} PUBLIC ALIGATOR_PINOCCHIO_V3)
+    endif()
+  endif()
+
+  if(BUILD_WITH_CHOLMOD_SUPPORT)
+    target_link_libraries(${PROJECT_NAME} PUBLIC CHOLMOD::CHOLMOD)
+    target_compile_definitions(${PROJECT_NAME} PUBLIC ALIGATOR_WITH_CHOLMOD)
   endif()
 
   if(BUILD_WITH_OPENMP_SUPPORT)
@@ -463,29 +468,37 @@ add_subdirectory(bindings)
 
 # benchmarks, examples, and tests
 
-macro(create_ex_or_bench is_bench exfile exname)
+macro(create_ex_or_bench exfile exname)
+  cmake_parse_arguments(arg_ex "BENCHMARK" "" "DEPENDENCIES" ${ARGN})
+
   add_executable(${exname} ${exfile})
-  if(${is_bench})
-    set(ex_type "bench")
+  if(${arg_ex_BENCHMARK})
+    set(ex_type "benchmark")
   else()
     set(ex_type "example")
   endif()
-  message(STATUS "Adding cpp ${ex_type} ${exname}")
+  message(STATUS "Adding cpp ${ex_type} ${exname} (${exfile})")
   set_target_properties(${exname} PROPERTIES LINKER_LANGUAGE CXX)
   set_standard_output_directory(${exname})
   target_include_directories(${exname} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
 
-  target_link_libraries(${exname} PUBLIC ${PROJECT_NAME})
+  target_link_libraries(
+    ${exname}
+    PRIVATE ${PROJECT_NAME} ${arg_ex_DEPENDENCIES}
+  )
+  if(${arg_ex_BENCHMARK})
+    target_link_libraries(${exname} PRIVATE benchmark::benchmark)
+  endif()
+  if(DEFINED arg_ex_DEPENDENCIES)
+    message("   Dependencies:")
+    foreach(_dep ${arg_ex_DEPENDENCIES})
+      message("     ${_dep}")
+    endforeach()
+  endif()
 endmacro()
 
 if(BUILD_WITH_PINOCCHIO_SUPPORT AND (BUILD_EXAMPLES OR BUILD_BENCHMARKS))
   ADD_PROJECT_PRIVATE_DEPENDENCY(example-robot-data 4.0.9 REQUIRED)
-  macro(target_add_example_robot_data target_name)
-    target_link_libraries(
-      ${target_name}
-      PRIVATE example-robot-data::example-robot-data
-    )
-  endmacro()
 endif()
 
 # create an utility library to avoid recompiling crocoddyl talos arm problem
@@ -503,10 +516,13 @@ if(BUILD_CROCODDYL_COMPAT AND (BUILD_EXAMPLES OR BUILD_BENCHMARKS))
   )
   target_link_libraries(
     croc_talos_arm_utils
-    PUBLIC ${PROJECT_NAME} Boost::boost crocoddyl::crocoddyl
+    PUBLIC
+      ${PROJECT_NAME}
+      Boost::boost
+      crocoddyl::crocoddyl
+      example-robot-data::example-robot-data
   )
   set_standard_output_directory(croc_talos_arm_utils)
-  target_add_example_robot_data(croc_talos_arm_utils)
 endif()
 
 if(BUILD_BENCHMARKS OR BUILD_TESTING)
@@ -515,7 +531,7 @@ if(BUILD_BENCHMARKS OR BUILD_TESTING)
     STATIC
     ${PROJECT_SOURCE_DIR}/tests/gar/test_util.cpp
   )
-  target_link_libraries(gar_test_utils PRIVATE aligator::gar)
+  target_link_libraries(gar_test_utils PRIVATE ${PROJECT_NAME})
   set_standard_output_directory(gar_test_utils)
 endif()
 
@@ -531,14 +547,13 @@ if(PINOCCHIO_V3 AND (BUILD_EXAMPLES OR BUILD_BENCHMARKS))
     PUBLIC ${PROJECT_SOURCE_DIR}/examples
   )
   set_standard_output_directory(talos_walk_utils)
-  target_link_libraries(talos_walk_utils PUBLIC ${PROJECT_NAME})
-  target_add_example_robot_data(talos_walk_utils)
-  function(target_add_talos_walk target)
-    target_link_libraries(
-      ${target}
-      PRIVATE talos_walk_utils pinocchio::pinocchio_parsers
-    )
-  endfunction()
+  target_link_libraries(
+    talos_walk_utils
+    PUBLIC
+      ${PROJECT_NAME}
+      pinocchio::pinocchio_parsers
+      example-robot-data::example-robot-data
+  )
 endif()
 
 if(BUILD_EXAMPLES)

bench/CMakeLists.txt

@@ -3,47 +3,35 @@
 #
 
 # Create a benchmark
-function(create_bench exfile croc)
-  get_filename_component(exname ${exfile} NAME_WE)
-  set(exname "bench-${exname}")
-  create_ex_or_bench(TRUE ${exfile} ${exname})
+function(create_bench exfile)
+  cmake_parse_arguments(arg_ex "CROC" "" "DEPENDENCIES" ${ARGN})
+  set(dependencies ${arg_ex_DEPENDENCIES})
 
-  target_include_directories(${exname} PRIVATE ../examples)
-  target_link_libraries(${exname} PRIVATE benchmark::benchmark)
-  if(croc)
-    target_link_libraries(
-      ${exname}
-      PRIVATE aligator::croc_compat croc_talos_arm_utils
-    )
+  get_filename_component(_exname ${exfile} NAME_WE)
+  set(_exname "bench-${_exname}")
+  if(${arg_ex_CROC})
+    list(APPEND dependencies aligator::croc_compat croc_talos_arm_utils)
   endif()
+  create_ex_or_bench(
+    ${exfile}
+    ${_exname}
+    BENCHMARK
+    DEPENDENCIES ${dependencies}
+  )
+  target_include_directories(${_exname} PRIVATE ../examples)
 endfunction()
 
 function(create_gar_bench exfile)
-  get_filename_component(exname ${exfile} NAME_WE)
-  set(exname "bench-${exname}")
-  add_executable(${exname} ${exfile})
-  message(STATUS "Adding cpp bench ${exname}")
-  set_target_properties(${exname} PROPERTIES LINKER_LANGUAGE CXX)
-  set_standard_output_directory(${exname})
-  target_include_directories(${exname} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})
-
-  target_link_libraries(
-    ${exname}
-    PRIVATE aligator::gar benchmark::benchmark gar_test_utils
-  )
+  create_bench(${exfile} DEPENDENCIES gar_test_utils)
 endfunction()
 
-create_bench("lqr.cpp" FALSE)
-create_bench("se2-car.cpp" FALSE)
+create_bench(lqr.cpp)
+create_bench(se2-car.cpp)
 if(BUILD_CROCODDYL_COMPAT)
-  create_bench("croc-talos-arm.cpp" TRUE)
-  target_add_example_robot_data(bench-croc-talos-arm)
+  create_bench(croc-talos-arm.cpp CROC)
 endif()
 if(PINOCCHIO_V3)
-  create_bench("talos-walk.cpp" FALSE)
-  target_add_example_robot_data(bench-talos-walk)
-  target_add_talos_walk(bench-talos-walk)
+  create_bench(talos-walk.cpp DEPENDENCIES talos_walk_utils)
 endif()
 
-create_gar_bench("gar-riccati.cpp")
-create_gar_bench("gar-impl-multithread.cpp")
+create_gar_bench(gar-riccati.cpp)

bench/gar-impl-multithread.cpp

@@ -1,6 +1,6 @@
 /// @copyright Copyright (C) 2022-2023 LAAS-CNRS, INRIA
 #include "aligator/python/callbacks.hpp"
-#include "aligator/helpers/history-callback.hpp"
+#include "aligator/core/history-callback.hpp"
 
 #include "aligator/solvers/proxddp/solver-proxddp.hpp"
 #include "aligator/solvers/fddp/solver-fddp.hpp"

bindings/python/src/expose-callbacks.cpp

@@ -1,8 +1,8 @@
 #include "aligator/python/fwd.hpp"
 #include "aligator/python/visitors.hpp"
 
-#include "aligator/solvers/proxddp/results.hpp"
-#include "aligator/core/workspace-base.hpp"
+#include "aligator/solvers/results-base.hpp"
+#include "aligator/solvers/workspace-base.hpp"
 
 namespace aligator {
 namespace python {

bindings/python/src/expose-solvers-base.cpp

@@ -59,8 +59,9 @@ void exposeGAR() {
   exposeBlockMatrices();
 
   bp::class_<knot_t>("LqrKnot", bp::no_init)
-      .def(bp::init<uint, uint, uint>(("nx"_a, "nu", "nc")))
-      .def(bp::init<uint, uint, uint, uint>(("nx"_a, "nu", "nc", "nx2")))
+      .def(bp::init<uint, uint, uint>(("self"_a, "nx", "nu", "nc")))
+      .def(bp::init<uint, uint, uint, uint, uint>(
+          ("self"_a, "nx"_a, "nu", "nc", "nx2", "nth"_a = 0)))
       .def_readonly("nx", &knot_t::nx)
       .def_readonly("nu", &knot_t::nu)
       .def_readonly("nc", &knot_t::nc)
@@ -95,7 +96,7 @@ void exposeGAR() {
 
   StdVectorPythonVisitor<knot_vec_t, false>::expose("StdVec_LqrKnot");
 
-  bp::class_<lqr_t>("LqrProblem", bp::no_init)
+  bp::class_<lqr_t, boost::noncopyable>("LqrProblem", bp::no_init)
       .def(bp::init<const knot_vec_t &, long>(("self"_a, "stages", "nc0")))
       .def_readwrite("stages", &lqr_t::stages)
       .add_property("horizon", &lqr_t::horizon)
@@ -110,8 +111,7 @@ void exposeGAR() {
       .add_property("ntheta", &lqr_t::ntheta)
       .def("evaluate", &lqr_t::evaluate,
            ("self"_a, "xs", "us", "theta"_a = std::nullopt),
-           "Evaluate the problem objective.")
-      .def(CopyableVisitor<lqr_t>());
+           "Evaluate the problem objective.");
 
   bp::class_<riccati_base_t, boost::noncopyable>("RiccatiSolverBase",
                                                  bp::no_init)