Default vs. Strict Concretizer for Complex Dependency Resolution

Answer to the Core Question

In Spack, the --strict concretizer will only accept a concrete spec if every user‑supplied constraint can be satisfied by the same set of package versions and variants. The default concretizer, by contrast, expands the search space: it may relax or reorder constraints, or pick different versions, to find a globally compatible solution.

Will strict concretizer always fail where default succeeds?

No. --strict fails only when the constraints you explicitly declare are mutually incompatible or when a required version/variant is excluded by those constraints. If a solution exists that respects every user‑given spec, both concretizers will succeed. The default concretizer will succeed only when it can find a permutation that satisfies all constraints, even if that permutation requires picking a different version than the one you first specified.

Impact on resolution stability across Spack releases

The strict algorithm is deterministic and has not changed in recent Spack releases, so its success/failure behavior is stable. The default concretizer receives periodic heuristic and caching improvements that can alter its success rate, but those changes are independent of the strict concretizer’s logic.

Practical Verification Steps

1. Create a reproducible environment with a known conflict, for example:

   spack env create conflict-test
   cd conflict-test
   spack spec -d \
     "pkgA@1.0+foo" \
     "pkgB@2.0+bar" \
     "shared@1.2"
   

2. Concretize with the default concretizer:

   spack concretize
   

   Observe whether a concrete spec is produced.

3. Repeat with the strict concretizer:

   spack concretize --strict
   

   Compare success/failure. If the default succeeds but strict fails, the conflict lies in constraints that strict refuses to relax.

4. Optional: Run the same test on two different Spack releases (e.g., v0.19 and v0.21) to confirm that strict behavior is unchanged.

What to Check If Strict Fails

• Is a particular variant incompatible with a required dependency version?
• Does any package have a depends_on with a when clause that conflicts with another package’s constraints?
• Have you added any custom repositories that introduce new version constraints?

Fixing the conflict usually involves relaxing or correcting the offending constraint.

When to Prefer Strict Concretizer

• When reproducibility is paramount and you want a deterministic, user‑controlled build plan.
• When you need quick resolution times in large environments with many packages.
• When you are confident that your constraints are complete and correctly expressed.

When to Stick with Default

• When you have highly constrained specs that may be over‑restrictive.
• When you need the algorithm to explore alternative versions or variants to find a solution.
• When you are debugging a dependency conflict and want the full search space.