Only run workers on traces with matching packages.

It is not scalable to run report and replay on every historical trace
every time a new package shows up. Eventually Golden Traces will be used
to run report and replay no matter the package, but for now lock the
workers to only use the same package for all actions. Also remove the
tracePackage dimension.

Author: baldwinn860

test/robot/monitor/trace.go

@@ -36,6 +36,17 @@ func (t *Traces) All() []*Trace {
 	return t.entries
 }
 
+// MatchPackage returns the set of Trace objects that were traced with a specific package.
+func (t *Traces) MatchPackage(p *Package) []*Trace {
+	result := []*Trace{}
+	for _, trace := range t.entries {
+		if trace.Input.Package == p.Id {
+			result = append(result, trace)
+		}
+	}
+	return result
+}
+
 func (o *DataOwner) updateTrace(ctx context.Context, action *trace.Action) error {
 	o.Write(func(data *Data) {
 		entry, _ := data.Traces.FindOrCreate(ctx, action)

test/robot/scheduler/replay.go

@@ -37,7 +37,7 @@ func (s schedule) doReplay(ctx context.Context, t *monitor.Trace, tools *build.T
 		Gapir:                tools.Host.Gapir,
 		VirtualSwapChainLib:  tools.Host.VirtualSwapChainLib,
 		VirtualSwapChainJson: tools.Host.VirtualSwapChainJson,
-		Package:                s.pkg.Id,
+		Package:              s.pkg.Id,
 	}
 	action := &replay.Action{
 		Input:  input,

test/robot/scheduler/scheduler.go

@@ -49,27 +49,31 @@ func Tick(ctx context.Context, managers *monitor.Managers, data *monitor.Data) [
 		s.pkg = pkg
 		for _, w := range data.Workers.All() {
 			s.worker = w
-			if tools := s.getHostTools(ctx); tools != nil {
-				for _, subj := range data.Subjects.All() {
-					if android_tools := s.getAndroidTools(ctx, subj); android_tools != nil {
-						if err := s.doTrace(ctx, subj, tools, android_tools); err != nil {
-							errs = append(errs, err)
-						}
-					}
+			tools := s.getHostTools(ctx)
+			if tools == nil {
+				continue
+			}
+			for _, subj := range data.Subjects.All() {
+				androidTools := s.getAndroidTools(ctx, subj)
+				if androidTools == nil {
+					continue
+				}
+				if err := s.doTrace(ctx, subj, tools, androidTools); err != nil {
+					errs = append(errs, err)
+				}
+			}
+			for _, t := range data.Traces.MatchPackage(s.pkg) {
+				if t.Status != job.Succeeded {
+					continue
+				}
+				if t.Output == nil {
+					continue
+				}
+				if err := s.doReport(ctx, t, tools); err != nil {
+					errs = append(errs, err)
 				}
-				for _, t := range data.Traces.All() {
-					if t.Status != job.Succeeded {
-						continue
-					}
-					if t.Output == nil {
-						continue
-					}
-					if err := s.doReport(ctx, t, tools); err != nil {
-						errs = append(errs, err)
-					}
-					if err := s.doReplay(ctx, t, tools); err != nil {
-						errs = append(errs, err)
-					}
+				if err := s.doReplay(ctx, t, tools); err != nil {
+					errs = append(errs, err)
 				}
 			}
 		}

test/robot/web/client/client.go

@@ -26,7 +26,6 @@ import (
 
 type traceInfo struct {
 	target  Item
-	pkg     Item
 	subject Item
 }
 
@@ -46,7 +45,6 @@ func (t *task) Representation() interface{} {
 	tr := map[string]interface{}{}
 	tr["trace target"] = t.trace.target.Underlying()
 	tr["trace subject"] = t.trace.subject.Underlying()
-	tr["trace package"] = t.trace.pkg.Underlying()
 	tr["host"] = t.host.Underlying()
 	tr["package"] = t.pkg.Underlying()
 	return []interface{}{tr, t.underlying}

test/robot/web/client/data.go

@@ -170,7 +170,7 @@ func clearDimensionData() {
 func newTask(entry map[string]interface{}, kind Item) *task {
 	t := &task{
 		underlying: entry,
-		trace:      traceInfo{target: nilItem, pkg: nilItem, subject: nilItem},
+		trace:      traceInfo{target: nilItem, subject: nilItem},
 		kind:       kind,
 		host:       nilItem,
 		pkg:        nilItem,