Update

Author: odow

.github/workflows/hipo.yml

@@ -39,7 +39,6 @@ jobs:
             -DMETIS_ROOT=installs \
             ..
           cmake --build . --parallel
-          ./bin/highs --solver=hipo ../check/instances/afiro.mps
           ctest --parallel --timeout 300 --output-on-failure --quiet --no-tests=error
   test-win:
     name: hipo windows-latest CMAKE_BUILD_TYPE=${{ matrix.build_type }} ALL_TESTS=${{ matrix.all_tests }}
@@ -63,6 +62,5 @@ jobs:
             -DCMAKE_TOOLCHAIN_FILE=C:/vcpkg/scripts/buildsystems/vcpkg.cmake `
             ..
           cmake --build . --parallel --config ${{ matrix.build_type }}
-          ./${{ matrix.build_type }}/bin/highs --solver=hipo ../check/instances/afiro.mps
-          ./${{ matrix.build_type }}/bin/unit_tests -d yes -a
-          ctest -C ${{ matrix.build_type }} --parallel --timeout 300 --output-on-failure --quiet  --no-tests=error
+          ./${{ matrix.build_type }}/bin/highs --solver=hipo ../check/instances/flugpl.mps
+          ctest -C ${{ matrix.build_type }} --parallel --timeout 300 --output-on-failure --quiet --no-tests=error

docs/src/parallel.md

@@ -5,9 +5,9 @@
 HiGHS currently has limited opportunities for exploiting parallel
 computing. When using a CPU, these are currently restricted to the
 dual simplex solver for LP, the factorisation-based interior point solver,
-and the MIP solver. Details of these and future plans are set out below. 
-HiGHS has an implementation of a first order method (PDLP) for solving LPs 
-that can exploit the availability of a [GPU](@ref highs-gpu).
+and the MIP solver. Details of these and future plans are set out below.
+HiGHS has an implementation of a first order method (PDLP) for solving LPs
+that can exploit the availability of a [GPU](@ref gpu).
 
 By default, when running in parallel, HiGHS will use half the
 available threads on a machine. This number can be modified by setting
@@ -49,18 +49,18 @@ performed regardless of the value of the [parallel](@ref) option.
 
 ## IPM
 
-The interior point solver HiPO uses multiple threads to process the 
+The interior point solver HiPO uses multiple threads to process the
 elimination tree during the multifrontal factorisation (_tree level_)
-and to perform the dense factorisation of the frontal matrices 
+and to perform the dense factorisation of the frontal matrices
 (_node level_).
 
-If the [parallel](@ref) option is set "on", the level of parallelism is 
-determined by the [hipo\_parallel\_type](@ref option-hipo-parallel) option, 
-which can be "tree" for tree level only, "node" for node level only, or 
+If the [parallel](@ref) option is set "on", the level of parallelism is
+determined by the [hipo\_parallel\_type](@ref option-hipo-parallel) option,
+which can be "tree" for tree level only, "node" for node level only, or
 "both" for both levels.
 
-If the [parallel](@ref) option is set "choose", the solver selects which 
-level to use based on a heuristic. When the [parallel](@ref) option is set 
+If the [parallel](@ref) option is set "choose", the solver selects which
+level to use based on a heuristic. When the [parallel](@ref) option is set
 "choose" or "off", the value of the hipo\_parallel\_type option is ignored.
 
 
@@ -71,7 +71,7 @@ work has started (Feb 2025), and it is hoped that a prototype solver
 will be available during 2025.
 
 Multi-threading within HiPO will be extended to other phases of the solver,
-including the solve phase of the factorisation and the process of assemblying 
+including the solve phase of the factorisation and the process of assemblying
 the matrices.
 
 First-order solvers for LP are still very much in their infancy, and