refactor openmp task-based internal use + add policy interface to factorization

[PierreMarchand20]

Summary

Improve the OpenMP task-based HMatrix build and factorizations: an execution policy interface for the LU, Cholesky and LDLt factorizations, a task-based LDLt, and several fixes to omp_task_policy, including a use of freed blocks in task-based factorizations with unbalanced cluster trees.

Changes

Execution policies for factorizations

• lu_factorization, cholesky_factorization and ldlt_factorization accept seq, par and omp_task_policy. The overloads without a policy use seq, so existing callers (including the DDM local solvers) are unchanged.
• omp_task_policy stores the L0 used as task dependencies in HMatrixTaskDependencies. A factorization keeps it if it is a cut of the block tree of the factorized HMatrix (e.g. the L0 set by its build, or one assigned directly), and recomputes it otherwise.
• Called in a parallel region, build and factorizations only create their tasks, so that successive calls overlap through their dependencies. The contract is documented in omp_task_policy.
• When L0 is reduced to the root, they run sequentially.
• The default L0 size stays at 64 nodes (TODO: adaptive default, see follow-ups).

Task-based LDLt

• task_based_ldlt_factorization, following sequential_ldlt_factorization. The copies W(q) used by the Schur complement are created with their block tree, filled by tasks, and freed per pivot step.
• task_based_internal_triangular_ldlt_hmatrix_hmatrix_solve, sharing the recursion of the task-based triangular solve.
• task_based_internal_apply_ldlt_diagonal.
• HMatrix::set_low_rank_data, counterpart of set_dense_data.

Python

• Remove the HTOOL_WITH_PYTHON_INTERFACE macro, so that threading is available through the Python interface.

Fixes

• Use of freed blocks in task-based factorizations with unbalanced cluster trees (e.g. GeometricSplitting on unevenly distributed points), also affecting task-based Cholesky on main. The triangular HMatrix-HMatrix solves densified a hierarchical right-hand side whose triangular matrix is a dense block, inside a task, while the thread creating the tasks still used its children. They now solve its children with the dense block, which keeps the block structure and the compression. Densification only remains for block trees that are not consistent.
• omp_task_policy factorizations no longer reuse the L0 of another HMatrix. In a parallel region, pending tasks are completed before L0 is recomputed.
• Task-based build tasks only use values captured when they are created, so another build with the same builder or policy can start before they complete.
• Workaround for GCC 12.2 (Debian 12), which destroys a shared_ptr data member of a class template given to firstprivate in a task while tasks still use it. Fixed in GCC 12.3.

API changes

• Added: policy overload of ldlt_factorization, HMatrix::set_low_rank_data.
• Removed: HMatrixTreeBuilder::get_false_positive. The number of false positives is now computed from the HMatrix information (get_hmatrix_information, get_distributed_hmatrix_information): number of admissible blocks stored by the build minus number of low-rank blocks. This makes it right for task-based builds too.
• Removed: HTOOL_WITH_PYTHON_INTERFACE macro.

Tests

• Task-based factorization tests: LU, Cholesky and LDLt with omp_task_policy (double, complex symmetric and Hermitian, both triangles, full and symmetric storage), including the trivial n1 = 10 case (root made of dense blocks).
• Full build→factorization tests in a parallel region: policy reused for another HMatrix, two builds in a row, L0 reduced to the root, L0 assigned directly or recomputed after a build, LDLt, false positives.
• Task-based LDLt triangular solve.
• Factorizations with an unbalanced cluster tree (double and complex). They catch the use of freed blocks under AddressSanitizer.

CI

• Leak detection is disabled for the task-based factorization tests (ASAN_OPTIONS=detect_leaks=0), as it already was for the task-based build tests. LeakSanitizer intermittently reports allocations made by libgomp in GOMP_task for tasks with dependencies, with any GCC from 11 to 15 and without htool code involved. Address errors are still checked, and leaks are still checked by the sequential tests.

Follow-ups

• Python bindings for ldlt_factorization with and without a policy (htool_python).
• Bump docs/htool in htool_documentation, whose C++ pages already document LDLt and omp_task_policy.
• omp_task_policy for the HMatrix-vector and HMatrix-matrix products, task-based solves, and a policy interface for the DDM local solvers.
• Adaptive default for max_number_of_nodes. First measurements give about 256 nodes as the best value for LDLt and Cholesky on 8 threads.

🤖 Generated with Claude Code

[codecov]

Codecov Report

❌ Patch coverage is 97.47368% with 12 lines in your changes missing coverage. Please review.
✅ Project coverage is 98.26%. Comparing base (658d8f0) to head (f56d3f0).
⚠️ Report is 69 commits behind head on main.

Files with missing lines	Patch %	Lines
...matrix/linalg/triangular_hmatrix_hmatrix_solve.hpp	58.33%	5 Missing ⚠️
...x/linalg/triangular_ldlt_hmatrix_hmatrix_solve.hpp	58.33%	5 Missing ⚠️
...ed/test_task_based_hmatrix_full_complex_double.cpp	93.75%	1 Missing ⚠️
...task_based/test_task_based_hmatrix_full_double.cpp	93.33%	1 Missing ⚠️

Additional details and impacted files

@@            Coverage Diff             @@
##             main      #86      +/-   ##
==========================================
+ Coverage   97.19%   98.26%   +1.06%     
==========================================
  Files          80      191     +111     
  Lines        5132    11457    +6325     
==========================================
+ Hits         4988    11258    +6270     
- Misses        144      199      +55     

☔ View full report in Codecov by Harness.
📢 Have feedback on the report? Share it here.

🚀 New features to boost your workflow:

• ❄️ Test Analytics: Detect flaky tests, report on failures, and find test suite problems.