Remove events code and refactor things that used it to use alternative mechanisms (#971)

Author: purvisa-at-google-com

cmd/gapit/commands.go

@@ -60,6 +60,7 @@ func (verb *commandsVerb) Run(ctx context.Context, flags flag.FlagSet) error {
 		return log.Err(ctx, err, "Failed to build the CommandFilter")
 	}
 	filter.OnlyExecutedDraws = verb.OnlyExecutedDraws
+	filter.OnlyEndOfFrames = verb.OnlyEndOfFrames
 
 	treePath := capture.CommandTree(filter)
 	treePath.GroupByApi = verb.GroupByAPI

cmd/gapit/common.go

@@ -359,14 +359,6 @@ func getADBDevice(ctx context.Context, pattern string) (adb.Device, error) {
 	return matchingDevices[0], nil
 }
 
-func getEvents(ctx context.Context, client service.Service, p *path.Events) ([]*service.Event, error) {
-	b, err := client.Get(ctx, p.Path(), nil)
-	if err != nil {
-		return nil, log.Errf(ctx, err, "Couldn't get events at: %v", p)
-	}
-	return b.(*service.Events).List, nil
-}
-
 func getCommand(ctx context.Context, client service.Service, p *path.Command) (*api.Command, error) {
 	boxedCmd, err := client.Get(ctx, p.Path(), nil)
 	if err != nil {

cmd/gapit/dump_fbo.go

@@ -78,42 +78,37 @@ func (verb *dumpFBOVerb) frameSource(ctx context.Context, client client.Client,
 	if err != nil {
 		return nil, log.Err(ctx, err, "Couldn't get filter")
 	}
+	filter.OnlyFramebufferObservations = true
 
-	return func(ch chan<- image.Image) error {
-		// Get the draw call and end-of-frame events.
-		events, err := getEvents(ctx, client, &path.Events{
-			Capture:                 capture,
-			LastInFrame:             true,
-			FramebufferObservations: true,
-			Filter:                  filter,
-		})
-		if err != nil {
-			return log.Err(ctx, err, "Couldn't get events")
+	treePath := capture.CommandTree(filter)
+
+	boxedTree, err := client.Get(ctx, treePath.Path(), nil)
+	if err != nil {
+		return nil, log.Err(ctx, err, "Failed to load the command tree")
+	}
+
+	tree := boxedTree.(*service.CommandTree)
+
+	var allFBOCommands []*path.Command
+	traverseCommandTree(ctx, client, tree.Root, func(n *service.CommandTreeNode, prefix string) error {
+		if n.Group != "" {
+			return nil
 		}
+		allFBOCommands = append(allFBOCommands, n.Commands.First())
+		return nil
+	}, "", true)
 
-		var lastFrameEvent *path.Command
-		for _, e := range events {
-			switch e.Kind {
-			case service.EventKind_FramebufferObservation:
-				// Find FBO for all presents.
-				if lastFrameEvent == nil {
-					continue
-				}
-				lastFrameEvent = nil
-
-				fbo, err := getFBO(ctx, client, e.Command)
-				if err != nil {
-					return err
-				}
-
-				ch <- flipImg(&image.NRGBA{
-					Pix:    fbo.Bytes,
-					Stride: int(fbo.Width) * 4,
-					Rect:   image.Rect(0, 0, int(fbo.Width), int(fbo.Height)),
-				})
-			case service.EventKind_LastInFrame:
-				lastFrameEvent = e.Command
+	return func(ch chan<- image.Image) error {
+		for _, cmd := range allFBOCommands {
+			fbo, err := getFBO(ctx, client, cmd)
+			if err != nil {
+				return err
 			}
+			ch <- flipImg(&image.NRGBA{
+				Pix:    fbo.Bytes,
+				Stride: int(fbo.Width) * 4,
+				Rect:   image.Rect(0, 0, int(fbo.Width), int(fbo.Height)),
+			})
 		}
 
 		return nil

cmd/gapit/export_replay.go

@@ -113,22 +113,29 @@ func (verb *exportReplayVerb) Run(ctx context.Context, flags flag.FlagSet) error
 		if err != nil {
 			return log.Err(ctx, err, "Couldn't get filter")
 		}
+		filter.OnlyEndOfFrames = true
 
-		requestEvents := gapidPath.Events{
-			Capture:     capturePath,
-			LastInFrame: true,
-			Filter:      filter,
-		}
+		treePath := capturePath.CommandTree(filter)
 
-		// Get the end-of-frame events.
-		eofEvents, err := getEvents(ctx, client, &requestEvents)
+		boxedTree, err := client.Get(ctx, treePath.Path(), nil)
 		if err != nil {
-			return log.Err(ctx, err, "Couldn't get frame events")
+			return log.Err(ctx, err, "Failed to load the command tree")
 		}
 
-		for _, e := range eofEvents {
+		tree := boxedTree.(*service.CommandTree)
+
+		var allEOFCommands []*gapidPath.Command
+		traverseCommandTree(ctx, client, tree.Root, func(n *service.CommandTreeNode, prefix string) error {
+			if n.Group != "" {
+				return nil
+			}
+			allEOFCommands = append(allEOFCommands, n.Commands.First())
+			return nil
+		}, "", true)
+
+		for _, e := range allEOFCommands {
 			fbreqs = append(fbreqs, &gapidPath.FramebufferAttachment{
-				After:          e.Command,
+				After:          e,
 				Index:          0,
 				RenderSettings: &gapidPath.RenderSettings{DisableReplayOptimization: true},
 				Hints:          nil,

cmd/gapit/flags.go

@@ -255,6 +255,7 @@ type (
 		GroupBySubmission    bool   `help:"Group commands by submissions"`
 		AllowIncompleteFrame bool   `help:"_Make a group for incomplete frames"`
 		OnlyExecutedDraws    bool   `help:"Only show executed draw calls from within command buffers"`
+		OnlyEndOfFrames      bool   `help:"Only end of frame commands"`
 		Observations         ObservationFlags
 		CommandFilterFlags
 		CaptureFileFlags

cmd/gapit/screenshot.go

@@ -20,6 +20,7 @@ import (
 	"fmt"
 	"image"
 	"image/png"
+	"math"
 	"os"
 	"strconv"
 	"strings"
@@ -203,62 +204,73 @@ func (verb *screenshotVerb) getSingleFrame(ctx context.Context, cmd *path.Comman
 	}, nil
 }
 
-func (verb *screenshotVerb) frameCommands(ctx context.Context, capture *path.Capture, client service.Service) ([]*path.Command, error) {
+func (verb *screenshotVerb) frameCommands(ctx context.Context, capture *path.Capture, client client.Client) ([]*path.Command, error) {
 	filter, err := verb.CommandFilterFlags.commandFilter(ctx, client, capture)
 	if err != nil {
 		return nil, log.Err(ctx, err, "Couldn't get filter")
 	}
+	filter.OnlyEndOfFrames = true
 
-	requestEvents := path.Events{
-		Capture:     capture,
-		LastInFrame: true,
-		DrawCalls:   verb.Draws,
-		Filter:      filter,
-	}
+	treePath := capture.CommandTree(filter)
 
-	// Get the end-of-frame and possibly draw call events.
-	events, err := getEvents(ctx, client, &requestEvents)
+	boxedTree, err := client.Get(ctx, treePath.Path(), nil)
 	if err != nil {
-		return nil, log.Err(ctx, err, "Couldn't get frame events")
+		return nil, log.Err(ctx, err, "Failed to load the command tree")
 	}
 
-	// Compute an index of frame to event idx.
-	frameIdx := map[int]int{}
-	lastFrame := 0
-	for i, e := range events {
-		if e.Kind == service.EventKind_LastInFrame {
-			lastFrame++
-			frameIdx[lastFrame] = i
+	tree := boxedTree.(*service.CommandTree)
+
+	var allEOFCommands []*path.Command
+	traverseCommandTree(ctx, client, tree.Root, func(n *service.CommandTreeNode, prefix string) error {
+		if n.Group != "" {
+			return nil
 		}
-	}
+		allEOFCommands = append(allEOFCommands, n.Commands.First())
+		return nil
+	}, "", true)
 
 	if len(verb.Frame) == 0 {
-		verb.Frame = []int{lastFrame}
+		verb.Frame = []int{len(allEOFCommands) - 1}
 	}
 
-	var commands []*path.Command
+	var retCommands []*path.Command
 	for _, frame := range verb.Frame {
-		last, ok := frameIdx[frame]
-		if !ok {
-			return nil, fmt.Errorf("Invalid frame number %d (last frame is %d)", frame, lastFrame)
+
+		if frame < 0 || frame >= len(allEOFCommands) {
+			return nil, fmt.Errorf("Invalid frame number %d (last frame is %d)", frame, len(allEOFCommands))
 		}
 
-		first := last
 		if verb.Draws {
-			if frame == 1 {
-				first = 0
-			} else {
-				first = frameIdx[frame-1]
+
+			firstFrameCommand := uint64(0)
+			if frame > 0 {
+				firstFrameCommand = allEOFCommands[frame-1].Indices[0]
 			}
-		}
-		for idx := first; idx <= last; idx++ {
-			commands = append(commands, events[idx].Command)
+
+			lastFrameCommand := uint64(math.MaxUint64)
+			if frame < len(allEOFCommands) {
+				lastFrameCommand = allEOFCommands[frame].Indices[0]
+			}
+
+			drawCommands, err := verb.doExecutedDrawCommands(ctx, capture, client, math.MaxInt, firstFrameCommand, lastFrameCommand)
+			if err != nil {
+				return nil, fmt.Errorf("Error getting draw calls for frame")
+			}
+
+			retCommands = append(retCommands, drawCommands...)
+		} else {
+			retCommands = append(retCommands, allEOFCommands[frame])
 		}
 	}
-	return commands, nil
+
+	return retCommands, nil
 }
 
 func (verb *screenshotVerb) executedDrawCommands(ctx context.Context, capture *path.Capture, client client.Client, maxAmount int) ([]*path.Command, error) {
+	return verb.doExecutedDrawCommands(ctx, capture, client, maxAmount, 0, math.MaxUint64)
+}
+
+func (verb *screenshotVerb) doExecutedDrawCommands(ctx context.Context, capture *path.Capture, client client.Client, maxAmount int, after uint64, before uint64) ([]*path.Command, error) {
 	filter, err := verb.CommandFilterFlags.commandFilter(ctx, client, capture)
 	if err != nil {
 		return nil, log.Err(ctx, err, "Couldn't get filter")
@@ -280,7 +292,9 @@ func (verb *screenshotVerb) executedDrawCommands(ctx context.Context, capture *p
 		if n.Group != "" || n.NumChildren > 0 || len(n.Commands.First().Indices) == 1 {
 			return nil
 		}
-		allDrawCommands = append(allDrawCommands, n.Commands.First())
+		if n.Commands.First().Indices[0] >= after && n.Commands.First().Indices[0] < before {
+			allDrawCommands = append(allDrawCommands, n.Commands.First())
+		}
 		return nil
 	}, "", true)