Add instruction cache

cache/instructioncache/cache.go

@@ -0,0 +1,112 @@
+package instructioncache
+
+import (
+	"github.com/boltdb/bolt"
+	"github.com/moby/buildkit/cache"
+	"github.com/moby/buildkit/cache/metadata"
+	"github.com/pkg/errors"
+	"golang.org/x/net/context"
+)
+
+const cacheKey = "buildkit.instructioncache"
+
+type cacheGroup struct {
+	Snapshots []string `json:"snapshots"`
+}
+
+type LocalStore struct {
+	MetadataStore *metadata.Store
+	Cache         cache.Accessor
+}
+
+func (ls *LocalStore) Set(key string, refsAny []interface{}) error {
+	refs, err := toReferenceArray(refsAny)
+	if err != nil {
+		return err
+	}
+	cg := cacheGroup{}
+	for _, r := range refs {
+		cg.Snapshots = append(cg.Snapshots, r.ID())
+	}
+	v, err := metadata.NewValue(cg)
+	if err != nil {
+		return err
+	}
+	v.Index = index(key)
+	for _, r := range refs {
+		si, _ := ls.MetadataStore.Get(r.ID())
+		if err := si.Update(func(b *bolt.Bucket) error { // TODO: should share transaction
+			return si.SetValue(b, index(key), *v)
+		}); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (ls *LocalStore) Lookup(ctx context.Context, key string) ([]interface{}, error) {
+	snaps, err := ls.MetadataStore.Search(index(key))
+	if err != nil {
+		return nil, err
+	}
+	refs := make([]cache.ImmutableRef, 0)
+	var retErr error
+loop0:
+	for _, s := range snaps {
+		retErr = nil
+		for _, r := range refs {
+			r.Release(context.TODO())
+		}
+		refs = nil
+
+		v := s.Get(index(key))
+		if v != nil {
+			var cg cacheGroup
+			if err = v.Unmarshal(&cg); err != nil {
+				retErr = err
+				continue
+			}
+			for _, id := range cg.Snapshots {
+				r, err := ls.Cache.Get(ctx, id)
+				if err != nil {
+					retErr = err
+					continue loop0
+				}
+				refs = append(refs, r)
+			}
+			retErr = nil
+			break
+		}
+	}
+	if retErr != nil {
+		for _, r := range refs {
+			r.Release(context.TODO())
+		}
+		refs = nil
+	}
+	return toAny(refs), retErr
+}
+
+func index(k string) string {
+	return cacheKey + "::" + k
+}
+
+func toReferenceArray(in []interface{}) ([]cache.ImmutableRef, error) {
+	out := make([]cache.ImmutableRef, 0, len(in))
+	for _, i := range in {
+		r, ok := i.(cache.ImmutableRef)
+		if !ok {
+			return nil, errors.Errorf("invalid reference")
+		}
+		out = append(out, r)
+	}
+	return out, nil
+}
+
+func toAny(in []cache.ImmutableRef) []interface{} {
+	out := make([]interface{}, 0, len(in))
+	for _, i := range in {
+		out = append(out, i)
+	}
+	return out
+}

cache/metadata/metadata.go

@@ -210,6 +210,14 @@ func (s *StorageItem) Update(fn func(b *bolt.Bucket) error) error {
 	return s.storage.Update(s.id, fn)
 }
 
+func (s *StorageItem) Keys() []string {
+	keys := make([]string, 0, len(s.values))
+	for k := range s.values {
+		keys = append(keys, k)
+	}
+	return keys
+}
+
 func (s *StorageItem) Get(k string) *Value {
 	return s.values[k]
 }

client/solve.go

@@ -69,6 +69,7 @@ func (c *Client) Solve(ctx context.Context, r io.Reader, statusChan chan *SolveS
 					Started:   v.Started,
 					Completed: v.Completed,
 					Error:     v.Error,
+					Cached:    v.Cached,
 				})
 			}
 			for _, v := range resp.Statuses {

control/control.go

@@ -15,10 +15,11 @@ import (
 )
 
 type Opt struct {
-	Snapshotter   snapshot.Snapshotter
-	CacheManager  cache.Manager
-	Worker        worker.Worker
-	SourceManager *source.Manager
+	Snapshotter      snapshot.Snapshotter
+	CacheManager     cache.Manager
+	Worker           worker.Worker
+	SourceManager    *source.Manager
+	InstructionCache solver.InstructionCache
 }
 
 type Controller struct { // TODO: ControlService
@@ -30,9 +31,10 @@ func NewController(opt Opt) (*Controller, error) {
 	c := &Controller{
 		opt: opt,
 		solver: solver.NewLLBSolver(solver.LLBOpt{
-			SourceManager: opt.SourceManager,
-			CacheManager:  opt.CacheManager,
-			Worker:        opt.Worker,
+			SourceManager:    opt.SourceManager,
+			CacheManager:     opt.CacheManager,
+			Worker:           opt.Worker,
+			InstructionCache: opt.InstructionCache,
 		}),
 	}
 	return c, nil
@@ -98,6 +100,7 @@ func (c *Controller) Status(req *controlapi.StatusRequest, stream controlapi.Con
 						Started:   v.Started,
 						Completed: v.Completed,
 						Error:     v.Error,
+						Cached:    v.Cached,
 					})
 				}
 				for _, v := range ss.Statuses {

control/control_default.go

@@ -9,6 +9,7 @@ import (
 	"github.com/containerd/containerd/rootfs"
 	ctdsnapshot "github.com/containerd/containerd/snapshot"
 	"github.com/moby/buildkit/cache"
+	"github.com/moby/buildkit/cache/instructioncache"
 	"github.com/moby/buildkit/cache/metadata"
 	"github.com/moby/buildkit/snapshot/blobmapping"
 	"github.com/moby/buildkit/source"
@@ -44,6 +45,11 @@ func defaultControllerOpts(root string, pd pullDeps) (*Opt, error) {
 		return nil, err
 	}
 
+	ic := &instructioncache.LocalStore{
+		MetadataStore: md,
+		Cache:         cm,
+	}
+
 	sm, err := source.NewManager()
 	if err != nil {
 		return nil, err
@@ -62,8 +68,9 @@ func defaultControllerOpts(root string, pd pullDeps) (*Opt, error) {
 	sm.Register(is)
 
 	return &Opt{
-		Snapshotter:   snapshotter,
-		CacheManager:  cm,
-		SourceManager: sm,
+		Snapshotter:      snapshotter,
+		CacheManager:     cm,
+		SourceManager:    sm,
+		InstructionCache: ic,
 	}, nil
 }

control/control_standalone_test.go

@@ -65,7 +65,10 @@ func TestControl(t *testing.T) {
 	img, err := source.NewImageIdentifier("docker.io/library/busybox:latest")
 	assert.NoError(t, err)
 
-	snap, err := sm.Pull(ctx, img)
+	src, err := sm.Resolve(ctx, img)
+	assert.NoError(t, err)
+
+	snap, err := src.Snapshot(ctx)
 	assert.NoError(t, err)
 
 	mounts, err := snap.Mount(ctx)

solver/exec.go

@@ -1,6 +1,7 @@
 package solver
 
 import (
+	"encoding/json"
 	"io"
 	"os"
 
@@ -10,24 +11,39 @@ import (
 	"github.com/moby/buildkit/solver/pb"
 	"github.com/moby/buildkit/util/progress"
 	"github.com/moby/buildkit/worker"
+	digest "github.com/opencontainers/go-digest"
 	"github.com/pkg/errors"
 	"golang.org/x/net/context"
 )
 
 type execOp struct {
-	op *pb.Op_Exec
+	op *pb.ExecOp
 	cm cache.Manager
 	w  worker.Worker
 }
 
 func newExecOp(op *pb.Op_Exec, cm cache.Manager, w worker.Worker) (Op, error) {
 	return &execOp{
-		op: op,
+		op: op.Exec,
 		cm: cm,
 		w:  w,
 	}, nil
 }
 
+func (e *execOp) CacheKey(ctx context.Context, inputs []string) (string, error) {
+	dt, err := json.Marshal(struct {
+		Inputs []string
+		Exec   *pb.ExecOp
+	}{
+		Inputs: inputs,
+		Exec:   e.op,
+	})
+	if err != nil {
+		return "", err
+	}
+	return digest.FromBytes(dt).String(), nil
+}
+
 func (e *execOp) Run(ctx context.Context, inputs []Reference) ([]Reference, error) {
 	mounts := make(map[string]cache.Mountable)
 
@@ -44,7 +60,7 @@ func (e *execOp) Run(ctx context.Context, inputs []Reference) ([]Reference, erro
 		}
 	}()
 
-	for _, m := range e.op.Exec.Mounts {
+	for _, m := range e.op.Mounts {
 		var mountable cache.Mountable
 		if int(m.Input) > len(inputs) {
 			return nil, errors.Errorf("missing input %d", m.Input)
@@ -72,9 +88,9 @@ func (e *execOp) Run(ctx context.Context, inputs []Reference) ([]Reference, erro
 	}
 
 	meta := worker.Meta{
-		Args: e.op.Exec.Meta.Args,
-		Env:  e.op.Exec.Meta.Env,
-		Cwd:  e.op.Exec.Meta.Cwd,
+		Args: e.op.Meta.Args,
+		Env:  e.op.Meta.Env,
+		Cwd:  e.op.Meta.Cwd,
 	}
 
 	stdout := newStreamWriter(ctx, 1)