Remove pseudo-commands for mid-execution capture.

CMakeProto.cmake

@@ -63,6 +63,7 @@ protoc_go("github.com/google/gapid/gapis/replay/protocol" "gapis/replay/protocol
 protoc_go("github.com/google/gapid/gapis/replay" "gapis/replay" "replay.proto")
 protoc_go("github.com/google/gapid/gapis/resolve" "gapis/resolve" "resolvables.proto")
 protoc_go("github.com/google/gapid/gapis/resolve/dependencygraph" "gapis/resolve/dependencygraph" "resolvables.proto")
+protoc_go("github.com/google/gapid/gapis/resolve/initialcmds" "gapis/resolve/initialcmds" "resolvables.proto")
 protoc_go("github.com/google/gapid/gapis/service/path" "gapis/service/path" "path.proto")
 protoc_java("gapis/service/path" "path.proto" "com/google/gapid/proto/service/path/Path")
 protoc_go("github.com/google/gapid/gapis/service/box" "gapis/service/box" "box.proto")

cmd/CMakeBuild.cmake

@@ -25,6 +25,7 @@ build_subdirectory(gapis)
 build_subdirectory(gapit)
 build_subdirectory(gopherjs)
 build_subdirectory(lingo)
+build_subdirectory(linearize_trace)
 build_subdirectory(make-debuggable)
 build_subdirectory(protoc-gen-go)
 build_subdirectory(pullapk)

cmd/linearize_trace/CMakeBuild.cmake

@@ -0,0 +1,15 @@
+# Copyright (C) 2017 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+go_install()

cmd/linearize_trace/CMakeFiles.cmake

@@ -0,0 +1,25 @@
+# Copyright (C) 2017 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Generated globbing source file
+# This file will be automatically regenerated if deleted, do not edit by hand.
+# If you add a new file to the directory, just delete this file, run any cmake
+# build and the file will be recreated, check in the new version.
+
+set(files
+    main.go
+)
+set(dirs
+
+)

cmd/linearize_trace/main.go

@@ -0,0 +1,90 @@
+// Copyright (C) 2017 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// The gapid command launches the GAPID UI. It looks for the JVM (bundled or
+// from the system), the GAPIC JAR (bundled or from the build output) and
+// launches GAPIC with the correct JVM flags and environment variables.
+package main
+
+import (
+	"context"
+	"flag"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+
+	"github.com/google/gapid/core/app"
+	log "github.com/google/gapid/core/log"
+	_ "github.com/google/gapid/gapis/api/gles"
+	_ "github.com/google/gapid/gapis/api/gvr"
+	_ "github.com/google/gapid/gapis/api/vulkan"
+	"github.com/google/gapid/gapis/capture"
+	"github.com/google/gapid/gapis/database"
+	"github.com/google/gapid/gapis/resolve/initialcmds"
+)
+
+var (
+	path   = flag.String("file", "capture.gfxtrace", "The capture file to linearize")
+	output = flag.String("out", "capture.linear.gfxtrace", "The output file")
+)
+
+func main() {
+	app.ShortHelp = "linearize_trace converts a mid-execution capture to a linear trace"
+	app.Name = "linearize_trace"
+	app.Run(run)
+}
+
+func run(ctx context.Context) error {
+
+	ctx = database.Put(ctx, database.NewInMemory(ctx))
+
+	name := filepath.Base(*path)
+	in, err := ioutil.ReadFile(*path)
+	if err != nil {
+		return err
+	}
+
+	p, err := capture.Import(ctx, name, in)
+	if err != nil {
+		return err
+	}
+	// Ensure the capture can be read by resolving it now.
+	capt, err := capture.ResolveFromPath(ctx, p)
+	if err != nil {
+		return err
+	}
+
+	initialCmds, _, err := initialcmds.InitialCommands(ctx, p)
+	if err != nil {
+		return err
+	}
+
+	log.I(ctx, "Generated %v initial commands", len(initialCmds))
+
+	capt.Commands = append(initialCmds, capt.Commands...)
+	capt.InitialState = nil
+
+	f, err := os.OpenFile(*output, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0666)
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+
+	if err = capt.Export(ctx, f); err != nil {
+		return err
+	}
+	log.I(ctx, "Capture written to: %v", *output)
+
+	return nil
+}

gapii/cc/chunk_writer.cpp

@@ -69,7 +69,8 @@ bool ChunkWriterImpl::write(std::string& s) {
 }
 
 void ChunkWriterImpl::flush() {
-    mStreamGood = mWriter->write(mBuffer.data(), mBuffer.size());
+    size_t bufferSize = mBuffer.size();
+    mStreamGood = mWriter->write(mBuffer.data(), mBuffer.size()) == bufferSize;
     mBuffer.clear();
 }
 

gapii/cc/pool.cpp

@@ -29,14 +29,23 @@ std::shared_ptr<Pool> Pool::create(uint32_t id, uint64_t size) {
     return std::shared_ptr<Pool>(new Pool(id, size));
 }
 
-Pool::Pool(uint32_t id, uint64_t size) : mId(id), mData(calloc(size,1)), mSize(size) {
+std::shared_ptr<Pool> Pool::create_virtual(uint32_t id, uint64_t size) {
+  return std::shared_ptr<Pool>(new Pool(Pool::virtual_pool{}, id, size));
+}
+
+Pool::Pool(uint32_t id, uint64_t size) : mId(id), mData(calloc(size,1)), mSize(size), mIsVirtual(false) {
   if (mData == nullptr) {
     GAPID_FATAL("Out of memory allocating 0x%" PRIx64 " bytes", size);
   }
 }
 
+Pool::Pool(virtual_pool, uint32_t id, uint64_t size) : mId(id), mData(nullptr), mSize(size), mIsVirtual(true) {
+}
+
 Pool::~Pool() {
-    free(mData);
+    if (mData) {
+      free(mData);
+    }
 }
 
 }  // namespace gapii

gapii/cc/pool.h

@@ -25,6 +25,9 @@ namespace gapii {
 class Pool {
 public:
     static std::shared_ptr<Pool> create(uint32_t id, uint64_t size);
+    // This creates a pool that can be serialized, but has no actual
+    // backing memory
+    static std::shared_ptr<Pool> create_virtual(uint32_t id, uint64_t size);
 
     ~Pool();
 
@@ -37,14 +40,18 @@ class Pool {
     // Pointer to first byte in the pool.
     inline void* base() const { return mData; }
 
+    const bool is_virtual() const { return mIsVirtual; }
 private:
+    struct virtual_pool {};
+    Pool(virtual_pool, uint32_t id, uint64_t size);
     Pool(uint32_t id, uint64_t size);
     Pool(const Pool&) = delete;
     Pool& operator=(const Pool&) = delete;
 
     uint32_t mId;
     void*    mData;
     uint64_t mSize;
+    bool mIsVirtual;
 };
 }  // namespace gapii
 

gapii/cc/slice.h

@@ -90,7 +90,10 @@ inline Slice<T>::Slice() : mBase(nullptr), mCount(0) {}
 template<typename T>
 inline Slice<T>::Slice(T* base, uint64_t count, const std::shared_ptr<Pool>& pool)
     : mBase(base), mCount(count), mPool(pool) {
-    GAPID_ASSERT(mBase != nullptr || count == 0 /* Slice: null pointer */);
+
+    if (!mPool || !mPool->is_virtual()) {
+        GAPID_ASSERT(mBase != nullptr || count == 0 /* Slice: null pointer */);
+    }
 }
 
 template<typename T>

gapii/cc/spy.cpp

@@ -34,6 +34,8 @@
 #include "gapis/api/gles/gles_pb/api.pb.h"
 #include "gapis/api/gles/gles_pb/extras.pb.h"
 
+#include "gapis/api/vulkan/vulkan_pb/api.pb.h"
+
 #include <cstdlib>
 #include <vector>
 #include <memory>
@@ -440,13 +442,14 @@ void Spy::onPreStartOfFrame(CallObserver* observer, uint8_t api) {
     mNumDrawsPerFrame = 0;
 }
 
-void Spy::saveInitialSate() {
-    GAPID_INFO("Saving initial GLES state");
-    auto encoder = this->getEncoder(GlesSpy::kApiIndex);
+void Spy::saveInitialState() {
+    GAPID_INFO("Saving initial state");
+    auto encoder = this->getEncoder(kAllAPIs);
+
+    capture::GlobalState global;
+    auto group = encoder->group(&global);
     if (should_trace(GlesSpy::kApiIndex)) {
       ToProtoContext pbCtx;
-      capture::GlobalState global;
-      auto group = encoder->group(&global);
       auto glesState = GlesSpy::serializeState(pbCtx);
       std::map<uint32_t, Pool*> seenPools;
       for (const auto& s : pbCtx.SeenSlices()) {
@@ -466,6 +469,30 @@ void Spy::saveInitialSate() {
       }
       group->object(glesState.get());
     }
+    if (should_trace(VulkanSpy::kApiIndex)) {
+        std::unordered_set<uint32_t> gpu_pools;
+        VulkanSpy::prepareGPUBuffers(group.get(), &gpu_pools);
+
+        ToProtoContext pbCtx;
+        auto vulkanState = VulkanSpy::serializeState(pbCtx);
+        std::map<uint32_t, Pool*> seenPools;
+        for (const auto& s : pbCtx.SeenSlices()) {
+          if (!s.isApplicationPool() && gpu_pools.find(s.poolID()) == gpu_pools.end()) {
+            seenPools.emplace(s.poolID(), s.pool().get());
+          }
+        }
+        for (const auto& kvp : seenPools) {
+          Pool* p = kvp.second;
+          auto resIndex = sendResource(VulkanSpy::kApiIndex, p->base(), p->size());
+          memory_pb::Observation observation;
+          observation.set_base(0);
+          observation.set_size(p->size());
+          observation.set_resindex(resIndex);
+          observation.set_pool(p->id());
+          group->object(&observation);
+        }
+        group->object(vulkanState.get());
+      }
     encoder->flush();
 }
 
@@ -482,16 +509,8 @@ void Spy::onPostFrameBoundary(bool isStartOfFrame) {
         if (is_suspended() && mSuspendCaptureFrames.fetch_sub(1) == 1) {
             exit();
             set_suspended(false);
-            saveInitialSate();
-            set_recording_state(true);
+            saveInitialState();
             auto spy_ctx = enter("RecreateState", 2);
-            if (!VulkanSpy::Devices.empty()) {
-                spy_ctx->enter(cmd::RecreateState{});
-                EnumerateVulkanResources(spy_ctx);
-                spy_ctx->exit();
-            }
-            set_recording_state(false);
-            // The outer call will handle the spy->exit() for us.
         }
     }
 }

gapii/cc/spy.h

@@ -99,8 +99,8 @@ class Spy : public GlesSpy, public GvrSpy, public VulkanSpy {
   // false if the dimensions could not be retrieved.
   bool getFramebufferAttachmentSize(CallObserver* observer, uint32_t& width, uint32_t& height);
 
-  // saveInitialSate serializes the current global state.
-  void saveInitialSate();
+  // saveInitialState serializes the current global state.
+  void saveInitialState();
 
   // onPostFrameBoundary is called from onPost{Start,End}OfFrame().
   void onPostFrameBoundary(bool isStartOfFrame);

gapii/cc/spy_base.h

@@ -48,6 +48,7 @@
 #include <unordered_map>
 
 namespace gapii {
+const uint8_t kAllAPIs = 0xFF;
 
 class SpyBase {
 public:
@@ -89,7 +90,7 @@ class SpyBase {
     void set_suspended(bool suspended) { mIsSuspended = suspended; }
 
     bool should_trace(uint8_t api) {
-        return !is_suspended() && (mWatchedApis & (1 << api)) != 0;
+        return !is_suspended() && (api == kAllAPIs || (mWatchedApis & (1 << api)) != 0);
     }
     void set_valid_apis(uint32_t apis) { mWatchedApis = apis; }
 

gapii/cc/vulkan_extras.inl

@@ -113,8 +113,7 @@ void SpyOverride_RecreateSemaphore(VkDevice, const VkSemaphoreCreateInfo*,
 void SpyOverride_RecreateFence(VkDevice, const VkFenceCreateInfo*, VkFence*) {}
 void SpyOverride_RecreateEvent(VkDevice, const VkEventCreateInfo*, VkBool32,
                                VkEvent*) {}
-void SpyOverride_RecreateCommandPool(VkDevice, const VkCommandPoolCreateInfo*,
-                                     VkCommandPool*) {}
+
 void SpyOverride_RecreatePipelineCache(VkDevice,
                                        const VkPipelineCacheCreateInfo*,
                                        VkPipelineCache*) {}
@@ -232,4 +231,10 @@ bool m_coherent_memory_tracking_enabled = false;
 
 #if TARGET_OS == GAPID_OS_ANDROID
 bool m_should_unset_debug_vulkan_layers = true;
-#endif // TARGET_OS == GAPID_OS_ANDROID
+#endif // TARGET_OS == GAPID_OS_ANDROID
+
+void SpyOverride_cacheImageSparseMemoryRequirements(
+    VkDevice device, VkImage image, uint32_t count,
+    VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
+
+void prepareGPUBuffers(PackEncoder* group, std::unordered_set<uint32_t>* gpu_pools);