Merge pull request #1440 from benluddy/sat

Add initial SAT solver package.

Author: benluddy

go.mod

@@ -11,6 +11,7 @@ require (
 	github.com/go-bindata/go-bindata/v3 v3.1.3
 	github.com/go-openapi/spec v0.19.4
 	github.com/golang/mock v1.3.1
+	github.com/irifrance/gini v1.0.1
 	github.com/maxbrunsfeld/counterfeiter/v6 v6.2.2
 	github.com/mikefarah/yq/v2 v2.4.1
 	github.com/mitchellh/hashstructure v1.0.0

go.sum

@@ -372,6 +372,8 @@ github.com/imdario/mergo v0.3.7 h1:Y+UAYTZ7gDEuOfhxKWy+dvb5dRQ6rJjFSdX2HZY1/gI=
 github.com/imdario/mergo v0.3.7/go.mod h1:2EnlNZ0deacrJVfApfmtdGgDfMuh/nq6Ok1EcJh5FfA=
 github.com/inconshreveable/mousetrap v1.0.0 h1:Z8tu5sraLXCXIcARxBp/8cbvlwVa7Z1NHg9XEKhtSvM=
 github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8=
+github.com/irifrance/gini v1.0.1 h1:oTABiARLoRsnTmda0uY2u2e5kfm8e6meBZB19lf5xhE=
+github.com/irifrance/gini v1.0.1/go.mod h1:swH5OTtiG/X/YrU06r288qZwq6I1agpbuXQOB55xqGU=
 github.com/jackc/fake v0.0.0-20150926172116-812a484cc733/go.mod h1:WrMFNQdiFJ80sQsxDoMokWK1W5TQtxBFNpzWTD84ibQ=
 github.com/jackc/pgx v3.2.0+incompatible/go.mod h1:0ZGrqGqkRlliWnWB4zKnWtjbSWbGkVEFm4TeybAXq+I=
 github.com/jmespath/go-jmespath v0.0.0-20160202185014-0b12d6b521d8/go.mod h1:Nht3zPeWKUH0NzdCt2Blrr5ys8VGpn0CEB0cQHVjt7k=

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

@@ -0,0 +1,91 @@
+package sat
+
+import (
+	"context"
+	"math/rand"
+	"strconv"
+	"testing"
+
+	"github.com/irifrance/gini"
+)
+
+func generateInput() []Installable {
+	const (
+		length      = 256
+		seed        = 9
+		pMandatory  = .1
+		pDependency = .15
+		nDependency = 6
+		pConflict   = .05
+		nConflict   = 3
+		pWeight     = 0
+		nWeight     = 4
+	)
+
+	id := func(i int) Identifier {
+		return Identifier(strconv.Itoa(i))
+	}
+
+	installable := func(i int) TestInstallable {
+		var c []Constraint
+		if rand.Float64() < pMandatory {
+			c = append(c, Mandatory())
+		}
+		if rand.Float64() < pDependency {
+			n := rand.Intn(nDependency-1) + 1
+			var d []Identifier
+			for x := 0; x < n; x++ {
+				y := i
+				for y == i {
+					y = rand.Intn(length)
+				}
+				d = append(d, id(y))
+			}
+			c = append(c, Dependency(d...))
+		}
+		if rand.Float64() < pConflict {
+			n := rand.Intn(nConflict-1) + 1
+			for x := 0; x < n; x++ {
+				y := i
+				for y == i {
+					y = rand.Intn(length)
+				}
+				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,
+		}
+	}
+
+	rand.Seed(seed)
+	result := make([]Installable, length)
+	for i := range result {
+		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()
+	for i := 0; i < b.N; i++ {
+		g := gini.New()
+		d.Solve(context.Background(), g)
+	}
+}

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

@@ -0,0 +1,137 @@
+package sat
+
+import (
+	"fmt"
+	"strings"
+)
+
+// Constraint implementations limit the circumstances under which a
+// particular Installable can appear in a solution.
+type Constraint interface {
+	String(subject Identifier) string
+	apply(x constrainer, subject Identifier)
+}
+
+// AppliedConstraint values compose a single Constraint with the
+// Installable it applies to.
+type AppliedConstraint struct {
+	Installable Installable
+	Constraint  Constraint
+}
+
+// String implements fmt.Stringer and returns a human-readable message
+// representing the receiver.
+func (a AppliedConstraint) String() string {
+	return a.Constraint.String(a.Installable.Identifier())
+}
+
+// constrainer is the set of operations available to Constraint
+// implementations.
+type constrainer interface {
+	// Add appends the Installable identified by the given
+	// Identifier to the clause representing a Constraint.
+	Add(Identifier)
+	// Add appends the negation of the Installable identified by
+	// 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{}
+
+func (c mandatory) String(subject Identifier) string {
+	return fmt.Sprintf("%s is mandatory", subject)
+}
+
+func (c mandatory) apply(x constrainer, subject Identifier) {
+	x.Add(subject)
+}
+
+// Mandatory returns a Constraint that will permit only solutions that
+// contain a particular Installable.
+func Mandatory() Constraint {
+	return mandatory{}
+}
+
+type prohibited struct{}
+
+func (c prohibited) String(subject Identifier) string {
+	return fmt.Sprintf("%s is prohibited", subject)
+}
+
+func (c prohibited) apply(x constrainer, subject Identifier) {
+	x.AddNot(subject)
+}
+
+// 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
+// Constraint.
+func Prohibited() Constraint {
+	return prohibited{}
+}
+
+type dependency []Identifier
+
+func (c dependency) String(subject Identifier) string {
+	s := make([]string, len(c))
+	for i, each := range c {
+		s[i] = string(each)
+	}
+	return fmt.Sprintf("%s requires at least one of %s", subject, strings.Join(s, ", "))
+}
+
+func (c dependency) apply(x constrainer, subject Identifier) {
+	if len(c) == 0 {
+		return
+	}
+	x.AddNot(subject)
+	for _, each := range c {
+		x.Add(each)
+	}
+}
+
+// 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.
+func Dependency(ids ...Identifier) Constraint {
+	return dependency(ids)
+}
+
+type conflict Identifier
+
+func (c conflict) String(subject Identifier) string {
+	return fmt.Sprintf("%s conflicts with %s", subject, c)
+}
+
+func (c conflict) apply(x constrainer, subject Identifier) {
+	x.AddNot(subject)
+	x.AddNot(Identifier(c))
+}
+
+// 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_test.go

@@ -0,0 +1,97 @@
+package sat
+
+import (
+	"sort"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestConstraints(t *testing.T) {
+	type tc struct {
+		Name       string
+		Constraint Constraint
+		Subject    Identifier
+		Expected   cstate
+	}
+
+	for _, tt := range []tc{
+		{
+			Name:       "mandatory",
+			Constraint: Mandatory(),
+			Subject:    "a",
+			Expected: cstate{
+				pos: []Identifier{"a"},
+			},
+		},
+		{
+			Name:       "prohibited",
+			Constraint: Prohibited(),
+			Subject:    "a",
+			Expected: cstate{
+				neg: []Identifier{"a"},
+			},
+		},
+		{
+			Name:       "empty dependency",
+			Constraint: Dependency(),
+			Subject:    "a",
+			Expected:   cstate{},
+		},
+		{
+			Name:       "single dependency",
+			Constraint: Dependency("b"),
+			Subject:    "a",
+			Expected: cstate{
+				pos: []Identifier{"b"},
+				neg: []Identifier{"a"},
+			},
+		},
+		{
+			Name:       "multiple dependency",
+			Constraint: Dependency("x", "y", "z"),
+			Subject:    "a",
+			Expected: cstate{
+				pos: []Identifier{"x", "y", "z"},
+				neg: []Identifier{"a"},
+			},
+		},
+		{
+			Name:       "conflict",
+			Constraint: Conflict("b"),
+			Subject:    "a",
+			Expected: cstate{
+				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
+			tt.Constraint.apply(&x, tt.Subject)
+
+			// Literals in lexically increasing order:
+			sort.Slice(x.pos, func(i, j int) bool {
+				return x.pos[i] < x.pos[j]
+			})
+			sort.Slice(x.neg, func(i, j int) bool {
+				return x.neg[i] < x.neg[j]
+			})
+
+			assert.Equal(t, tt.Expected, x)
+		})
+	}
+}