Introduce preference order for solver.

Installables that appear earlier in a dependency constraint have
higher preference than those appearing later in the same constraint,
and the dependencies of Installables that appear earlier in the input
have higher preference than the dependencies of those appearing later
in the input.

Author: benluddy

pkg/controller/registry/resolver/sat/solve.go

@@ -1,15 +1,13 @@
-package sat
+package solver
 
 import (
 	"context"
 	"math/rand"
 	"strconv"
 	"testing"
-
-	"github.com/irifrance/gini"
 )
 
-func generateInput() []Installable {
+var BenchmarkInput = func() []Installable {
 	const (
 		length      = 256
 		seed        = 9
@@ -18,8 +16,6 @@ func generateInput() []Installable {
 		nDependency = 6
 		pConflict   = .05
 		nConflict   = 3
-		pWeight     = 0
-		nWeight     = 4
 	)
 
 	id := func(i int) Identifier {
@@ -53,10 +49,6 @@ func generateInput() []Installable {
 				c = append(c, Conflict(id(y)))
 			}
 		}
-		if rand.Float64() < pWeight {
-			n := rand.Intn(nWeight-1) + 1
-			c = append(c, Weight(n))
-		}
 		return TestInstallable{
 			identifier:  id(i),
 			constraints: c,
@@ -69,23 +61,14 @@ func generateInput() []Installable {
 		result[i] = installable(i)
 	}
 	return result
-}
-
-func BenchmarkCompileDict(b *testing.B) {
-	input := generateInput()
-
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		compileDict(input)
-	}
-}
+}()
 
-func BenchmarkDictSolve(b *testing.B) {
-	d := compileDict(generateInput())
-
-	b.ResetTimer()
+func BenchmarkSolve(b *testing.B) {
 	for i := 0; i < b.N; i++ {
-		g := gini.New()
-		d.Solve(context.Background(), g)
+		s, err := New(WithInput(BenchmarkInput))
+		if err != nil {
+			b.Fatalf("failed to initialize solver: %s", err)
+		}
+		s.Solve(context.Background())
 	}
 }

pkg/controller/registry/resolver/sat/bench_test.go renamed to pkg/controller/registry/resolver/solver/bench_test.go

@@ -1,4 +1,4 @@
-package sat
+package solver
 
 import (
 	"fmt"
@@ -10,6 +10,7 @@ import (
 type Constraint interface {
 	String(subject Identifier) string
 	apply(x constrainer, subject Identifier)
+	order() []Identifier
 }
 
 // AppliedConstraint values compose a single Constraint with the
@@ -35,9 +36,6 @@ type constrainer interface {
 	// the given Identifier to the clause representing a
 	// Constraint.
 	AddNot(Identifier)
-	// Weight sets an additional weight to add to the constrained
-	// Installable. Calls with negative arguments are ignored.
-	Weight(int)
 }
 
 type mandatory struct{}
@@ -50,6 +48,10 @@ func (c mandatory) apply(x constrainer, subject Identifier) {
 	x.Add(subject)
 }
 
+func (c mandatory) order() []Identifier {
+	return nil
+}
+
 // Mandatory returns a Constraint that will permit only solutions that
 // contain a particular Installable.
 func Mandatory() Constraint {
@@ -66,6 +68,10 @@ func (c prohibited) apply(x constrainer, subject Identifier) {
 	x.AddNot(subject)
 }
 
+func (c prohibited) order() []Identifier {
+	return nil
+}
+
 // Prohibited returns a Constraint that will reject any solution that
 // contains a particular Installable. Callers may also decide to omit
 // an Installable from input to Solve rather than apply such a
@@ -94,10 +100,15 @@ func (c dependency) apply(x constrainer, subject Identifier) {
 	}
 }
 
+func (c dependency) order() []Identifier {
+	return []Identifier(c)
+}
+
 // Dependency returns a Constraint that will only permit solutions
 // containing a given Installable on the condition that at least one
 // of the Installables identified by the given Identifiers also
-// appears in the solution.
+// appears in the solution. Identifiers appearing earlier in the
+// argument list have higher preference than those appearing later.
 func Dependency(ids ...Identifier) Constraint {
 	return dependency(ids)
 }
@@ -113,25 +124,13 @@ func (c conflict) apply(x constrainer, subject Identifier) {
 	x.AddNot(Identifier(c))
 }
 
+func (c conflict) order() []Identifier {
+	return nil
+}
+
 // Conflict returns a Constraint that will permit solutions containing
 // either the constrained Installable, the Installable identified by
 // the given Identifier, or neither, but not both.
 func Conflict(id Identifier) Constraint {
 	return conflict(id)
 }
-
-type weight int
-
-func (c weight) String(subject Identifier) string {
-	return fmt.Sprintf("%s has weight %d", subject, c)
-}
-
-func (c weight) apply(x constrainer, subject Identifier) {
-	x.Weight(int(c))
-}
-
-// Weight returns a Constraint that increases the weight of the
-// constrainted Installable by the given (non-negative) amount.
-func Weight(w int) Constraint {
-	return weight(w)
-}

pkg/controller/registry/resolver/sat/constraints.go renamed to pkg/controller/registry/resolver/solver/constraints.go

@@ -1,4 +1,4 @@
-package sat
+package solver
 
 import (
 	"sort"
@@ -64,20 +64,6 @@ func TestConstraints(t *testing.T) {
 				neg: []Identifier{"a", "b"},
 			},
 		},
-		{
-			Name:       "negative weight",
-			Constraint: Weight(-1),
-			Subject:    "a",
-			Expected:   cstate{},
-		},
-		{
-			Name:       "weight",
-			Constraint: Weight(5),
-			Subject:    "a",
-			Expected: cstate{
-				weight: 5,
-			},
-		},
 	} {
 		t.Run(tt.Name, func(t *testing.T) {
 			var x cstate
@@ -95,3 +81,35 @@ func TestConstraints(t *testing.T) {
 		})
 	}
 }
+
+func TestOrder(t *testing.T) {
+	type tc struct {
+		Name       string
+		Constraint Constraint
+		Expected   []Identifier
+	}
+
+	for _, tt := range []tc{
+		{
+			Name:       "mandatory",
+			Constraint: Mandatory(),
+		},
+		{
+			Name:       "prohibited",
+			Constraint: Prohibited(),
+		},
+		{
+			Name:       "dependency",
+			Constraint: Dependency("a", "b", "c"),
+			Expected:   []Identifier{"a", "b", "c"},
+		},
+		{
+			Name:       "conflict",
+			Constraint: Conflict("a"),
+		},
+	} {
+		t.Run(tt.Name, func(t *testing.T) {
+			assert.Equal(t, tt.Expected, tt.Constraint.order())
+		})
+	}
+}