MiniZinc error: Memory violation detected (segmentation fault).

[gdalle]

The last test run of SparseMatrixColorings turned up a strange error, of which the log is here:

[8](https://github.com/gdalle/SparseMatrixColorings.jl/actions/runs/22137035250/job/63991297101#step:7:331)
  Got exception outside of a @test
  The model was not solved correctly. Here is the output of `solution_summary` to help debug why this happened:
  
  solution_summary(; result = 1, verbose = false)
  ├ solver_name          : MiniZinc
  ├ Termination
  │ ├ termination_status : OTHER_ERROR
  │ ├ result_count       : 0
  │ └ raw_status         : =====ERROR=====
  MiniZinc error: Memory violation detected (segmentation fault).
  This is a bug. Please file a bug report using the MiniZinc bug tracker.
  
  ├ Solution (result = 1)
  │ ├ primal_status        : NO_SOLUTION
  │ └ dual_status          : NO_SOLUTION
  └ Work counters
    └ solve_time (sec)   : 1.70588e+00

Full CI report: https://github.com/gdalle/SparseMatrixColorings.jl/actions/runs/22137035250/job/63991297101

I assume it is related to one of MiniZinc.jl's latest releases

[odow]

Reproducible example?

[gdalle]

I'll get you one tomorrow, sorry

[gdalle]

Actually, this should be minimal enough:

https://github.com/gdalle/SparseMatrixColorings.jl/blob/main/test/optimal.jl

[odow]

I can't reproduce on macOS:

julia> using SparseArrays

julia> using SparseMatrixColorings

julia> using StableRNGs

julia> using Test

julia> using JuMP

julia> using MiniZinc

julia> using HiGHS

julia> rng = StableRNG(0)
StableRNGs.LehmerRNG(state=0x00000000000000000000000000000001)

julia> asymmetric_params = vcat(
           [(10, 20, p) for p in (0.0:0.1:0.5)], [(20, 10, p) for p in (0.0:0.1:0.5)]
       )
12-element Vector{Tuple{Int64, Int64, Float64}}:
 (10, 20, 0.0)
 (10, 20, 0.1)
 (10, 20, 0.2)
 (10, 20, 0.3)
 (10, 20, 0.4)
 (10, 20, 0.5)
 (20, 10, 0.0)
 (20, 10, 0.1)
 (20, 10, 0.2)
 (20, 10, 0.3)
 (20, 10, 0.4)
 (20, 10, 0.5)

julia> algo = GreedyColoringAlgorithm()
GreedyColoringAlgorithm{:direct, 1, Tuple{NaturalOrder}}((NaturalOrder(),), false)

julia> optalgo = OptimalColoringAlgorithm(() -> MiniZinc.Optimizer{Float64}("highs"); silent=false)
OptimalColoringAlgorithm{var"#8#9"}(var"#8#9"(), false, true)

julia> @testset "Column coloring" begin
           problem = ColoringProblem(; structure=:nonsymmetric, partition=:column)
           for (m, n, p) in asymmetric_params
               A = sprand(rng, m, n, p)
               result = coloring(A, problem, algo)
               optresult = coloring(A, problem, optalgo)
               @test ncolors(result) >= ncolors(optresult)
           end
       end
Test Summary:   | Pass  Total  Time
Column coloring |   12     12  4.6s
Test.DefaultTestSet("Column coloring", Any[], 12, false, false, true, 1.771453264557771e9, 1.771453269137735e9, false, "REPL[13]", Random.Xoshiro(0xc67e50490bdd14bb, 0x98c360e819874212, 0xa5c281b2cd962899, 0x7c76644470aa4a90, 0x34d1b95e7109afde))

julia> @testset "Row coloring" begin
           problem = ColoringProblem(; structure=:nonsymmetric, partition=:row)
           for (m, n, p) in asymmetric_params
               A = sprand(rng, m, n, p)
               result = coloring(A, problem, algo)
               optresult = coloring(A, problem, optalgo)
               @test ncolors(result) >= ncolors(optresult)
           end
       end
Test Summary: | Pass  Total  Time
Row coloring  |   12     12  1.0s
Test.DefaultTestSet("Row coloring", Any[], 12, false, false, true, 1.771453269277474e9, 1.771453270253397e9, false, "REPL[14]", Random.Xoshiro(0xc67e50490bdd14bb, 0x98c360e819874212, 0xa5c281b2cd962899, 0x7c76644470aa4a90, 0x34d1b95e7109afde))

julia> @testset "Too big" begin
           A = sprand(rng, Bool, 100, 100, 0.1)
           optalgo_timelimit = OptimalColoringAlgorithm(
               optimizer_with_attributes(HiGHS.Optimizer, "time_limit" => 10.0); # 1 second
               silent=false,
               assert_solved=false,
           )
           @test_throws AssertionError coloring(A, ColoringProblem(), optalgo_timelimit)
       end
Running HiGHS 1.13.1 (git hash: 1d267d97c): Copyright (c) 2026 under Apache 2.0 license terms
Using BLAS: blastrampoline 
MIP has 20711 rows; 66167 cols; 255886 nonzeros; 66067 integer variables (65966 binary)
Coefficient ranges:
  Matrix  [1e+00, 1e+02]
  Cost    [1e+00, 1e+00]
  Bound   [1e+00, 1e+02]
  RHS     [1e+00, 1e+00]
Presolving model
20622 rows, 66004 cols, 255032 nonzeros  0s
18853 rows, 65121 cols, 250376 nonzeros  0s
Presolve reductions: rows 18853(-1858); columns 65121(-1046); nonzeros 250376(-5510) 
Objective function is integral with scale 1

Solving MIP model with:
   18853 rows
   65121 cols (65023 binary, 98 integer, 0 implied int., 0 continuous, 0 domain fixed)
   250376 nonzeros

Src: B => Branching; C => Central rounding; F => Feasibility pump; H => Heuristic;
     I => Shifting; J => Feasibility jump; L => Sub-MIP; P => Empty MIP; R => Randomized rounding;
     S => Solve LP; T => Evaluate node; U => Unbounded; X => User solution; Y => HiGHS solution;
     Z => ZI Round; l => Trivial lower; p => Trivial point; u => Trivial upper; z => Trivial zero

        Nodes      |    B&B Tree     |            Objective Bounds              |  Dynamic Constraints |       Work      
Src  Proc. InQueue |  Leaves   Expl. | BestBound       BestSol              Gap |   Cuts   InLp Confl. | LpIters     Time

         0       0         0   0.00%   1               inf                  inf        0      0      0         0     1.7s
         0       0         0   0.00%   1               inf                  inf        0      0      2     29386    10.0s

Solving report
  Status            Time limit reached
  Primal bound      inf
  Dual bound        1
  Gap               inf
  P-D integral      0
  Solution status   -
  Timing            10.01
  Max sub-MIP depth 0
  Nodes             0
  Repair LPs        0
  LP iterations     29386
                    0 (strong br.)
                    0 (separation)
                    0 (heuristics)
Test Summary: | Pass  Total   Time
Too big       |    1      1  12.6s
Test.DefaultTestSet("Too big", Any[], 1, false, false, true, 1.771453271136068e9, 1.771453283714357e9, false, "REPL[15]", Random.Xoshiro(0xc67e50490bdd14bb, 0x98c360e819874212, 0xa5c281b2cd962899, 0x7c76644470aa4a90, 0x34d1b95e7109afde))

[gdalle]

Me neither but that's what seems to happen on GitHub's Ubuntu runners. I'll try to duplicate once I get my hands on a linux server