vk: adding logs just for debugging [DO NOT COMMIT]

filament/backend/src/vulkan/VulkanBufferCache.cpp

@@ -106,6 +106,12 @@ void VulkanBufferCache::gc() noexcept {
         }
     }
 
+    size_t totalBuffers = 0;
+    for (auto& bufferPool : mGpuBufferPools) {
+        totalBuffers += bufferPool.size();
+    }
+    FVK_LOGD << "VulkanBufferCache sizes: buffers=" << totalBuffers;
+
     FVK_SYSTRACE_END();
 }
 
@@ -157,6 +163,10 @@ VulkanGpuBuffer const* VulkanBufferCache::allocate(VulkanBufferBinding binding,
     UTILS_UNUSED_IN_RELEASE VkResult result = vmaCreateBuffer(mAllocator, &bufferInfo, &allocInfo,
             &gpuBuffer->vkbuffer, &gpuBuffer->vmaAllocation, &gpuBuffer->allocationInfo);
 
+    FVK_LOGD << "VulkanBufferCache - allocated a vkBuffer " << gpuBuffer->vkbuffer
+             << " of size " << numBytes << " and binding = " << static_cast<int>(binding)
+             << " result=" << (int)result;
+
 #if FVK_ENABLED(FVK_DEBUG_VULKAN_BUFFER_CACHE)
     if (result != VK_SUCCESS) {
         FVK_LOGE << "VulkanBufferCache - failed to allocate a new vkBuffer of size " << numBytes
@@ -173,6 +183,7 @@ VulkanGpuBuffer const* VulkanBufferCache::allocate(VulkanBufferBinding binding,
 }
 
 void VulkanBufferCache::destroy(VulkanGpuBuffer const* gpuBuffer) noexcept {
+    FVK_LOGD << "VulkanBufferCache - Destroying vkBuffer " << gpuBuffer->vkbuffer;
     vmaDestroyBuffer(mAllocator, gpuBuffer->vkbuffer, gpuBuffer->vmaAllocation);
     delete gpuBuffer;
     gpuBuffer = nullptr;

filament/backend/src/vulkan/VulkanCommands.cpp

@@ -194,6 +194,7 @@ void VulkanCommandBuffer::begin() noexcept {
 }
 
 fvkmemory::resource_ptr<VulkanSemaphore> VulkanCommandBuffer::submit() {
+    FVK_LOGD << "Submitting VulkanCommandBuffer: " << mBuffer << " (age=" << age() << ")";
     while (mMarkerCount > 0) {
         popMarker();
     }

filament/backend/src/vulkan/VulkanFboCache.cpp

@@ -24,7 +24,7 @@
 
 // If any VkRenderPass or VkFramebuffer is unused for more than TIME_BEFORE_EVICTION frames, it
 // is evicted from the cache.
-static constexpr uint32_t TIME_BEFORE_EVICTION = FVK_MAX_COMMAND_BUFFERS;
+static constexpr uint32_t TIME_BEFORE_EVICTION = 3;
 
 using namespace bluevk;
 
@@ -120,6 +120,8 @@ fvkmemory::resource_ptr<VulkanFramebuffer> VulkanFboCache::getFramebuffer(FboKey
     VkResult error = vkCreateFramebuffer(mDevice, &info, VKALLOC, &framebuffer);
     FILAMENT_CHECK_POSTCONDITION(error == VK_SUCCESS) << "Unable to create framebuffer."
                                                      << " error=" << static_cast<int32_t>(error);
+    FVK_LOGD << "VulkanFboCache - Created VkFramebuffer " << framebuffer << " for renderTarget " << renderTarget.get()
+             << " size=" << config.width << "x" << config.height;
     fvkmemory::resource_ptr<VulkanFramebuffer> fbh =
             fvkmemory::resource_ptr<VulkanFramebuffer>::construct(resManager, mDevice, framebuffer,
                     renderTarget);
@@ -404,6 +406,8 @@ void VulkanFboCache::gc() noexcept {
         }
     }
 
+    FVK_LOGD << "VulkanFboCache sizes: framebuffers=" << mFramebufferCache.size() << " renderpasses=" << mRenderPassCache.size();
+
     FVK_SYSTRACE_END();
 }
 

filament/backend/src/vulkan/VulkanHandles.cpp

@@ -403,10 +403,13 @@ VulkanRenderTarget::VulkanRenderTarget()
       mOffscreen(false),
       mProtected(false),
       mInfo(std::make_unique<Auxiliary>()) {
+    FVK_LOGD << "Creating default VulkanRenderTarget: " << this;
     mInfo->rpkey.samples = mInfo->fbkey.samples = 1;
 }
 
-VulkanRenderTarget::~VulkanRenderTarget() = default;
+VulkanRenderTarget::~VulkanRenderTarget() {
+    FVK_LOGD << "Destroying VulkanRenderTarget: " << this << " (offscreen=" << mOffscreen << ")";
+}
 
 void VulkanRenderTarget::bindSwapChain(fvkmemory::resource_ptr<VulkanSwapChain> swapchain) {
     assert_invariant(!mOffscreen);
@@ -443,9 +446,12 @@ void VulkanRenderTarget::bindSwapChain(fvkmemory::resource_ptr<VulkanSwapChain>
         fbkey.depth = VK_NULL_HANDLE;
     }
     mInfo->colors.set(0);
+    FVK_LOGD << "bindSwapChain: target=" << this << ", swapchain=" << swapchain.get()
+             << ", size=" << width << "x" << height;
 }
 
 void VulkanRenderTarget::releaseSwapchain() {
+    FVK_LOGD << "releaseSwapchain: target=" << this;
     mInfo->colors = {};
     mInfo->attachments.clear();
 }
@@ -459,6 +465,7 @@ VulkanRenderTarget::VulkanRenderTarget(VkDevice device, VkPhysicalDevice physica
       mOffscreen(true),
       mProtected(false),
       mInfo(std::make_unique<Auxiliary>()) {
+    FVK_LOGD << "Creating offscreen VulkanRenderTarget: " << this << ", size=" << width << "x" << height << ", samples=" << (int)samples;
     auto& depth = depthStencil[0];
 
     // Constrain the sample count according to both kinds of sample count masks obtained from
@@ -719,9 +726,13 @@ VulkanFramebuffer::VulkanFramebuffer(VkDevice device, VkFramebuffer framebuffer,
         fvkmemory::resource_ptr<VulkanRenderTarget> renderTarget)
         : mDevice(device),
           mFramebuffer(framebuffer),
-          mRenderTarget(renderTarget) {}
+          mRenderTarget(renderTarget) {
+    FVK_LOGD << "Creating VulkanFramebuffer: " << framebuffer
+             << ", target=" << renderTarget.get();
+}
 
 VulkanFramebuffer::~VulkanFramebuffer() {
+    FVK_LOGD << "Destroying VulkanFramebuffer: " << mFramebuffer;
     vkDestroyFramebuffer(mDevice, mFramebuffer, VKALLOC);
 }
 

filament/backend/src/vulkan/VulkanPipelineCache.cpp

@@ -534,6 +534,8 @@ void VulkanPipelineCache::gc() noexcept {
            ++iter;
        }
    }
+
+   FVK_LOGD << "VulkanPipelineCache sizes: pipelines=" << mPipelines.size();
 }
 
 bool VulkanPipelineCache::PipelineEqual::operator()(const PipelineKey& k1,

filament/backend/src/vulkan/VulkanStagePool.cpp

@@ -271,6 +271,8 @@ void VulkanStagePool::gc() noexcept {
         }
     }
 
+    FVK_LOGD << "VulkanStagePool sizes: stages=" << mStages.size() << " freeImages=" << mFreeImages.size();
+
     FVK_SYSTRACE_END();
 }
 

filament/backend/src/vulkan/VulkanSwapChain.cpp

@@ -46,6 +46,7 @@ VulkanSwapChain::VulkanSwapChain(VulkanPlatform* platform, VulkanContext const&
       mCurrentSwapIndex(0),
       mAcquired(false),
       mIsFirstRenderPass(true) {
+    FVK_LOGD << "Creating VulkanSwapChain: " << this << ", window=" << nativeWindow << ", size=" << extent.width << "x" << extent.height;
     swapChain = mPlatform->createSwapChain(nativeWindow, flags, extent);
     FILAMENT_CHECK_POSTCONDITION(swapChain) << "Unable to create swapchain";
 
@@ -53,6 +54,7 @@ VulkanSwapChain::VulkanSwapChain(VulkanPlatform* platform, VulkanContext const&
 }
 
 VulkanSwapChain::~VulkanSwapChain() {
+    FVK_LOGD << "Destroying VulkanSwapChain: " << this;
     // Must wait for the inflight command buffers to finish since they might contain the images
     // we're about to destroy.
     mCommands->flush();
@@ -68,6 +70,7 @@ VulkanSwapChain::~VulkanSwapChain() {
 }
 
 void VulkanSwapChain::update() {
+    FVK_LOGD << "VulkanSwapChain::update: " << this;
     mColors.clear();
 
     auto const bundle = mPlatform->getSwapChainBundle(swapChain);
@@ -89,6 +92,7 @@ void VulkanSwapChain::update() {
         colorUsage |= TextureUsage::PROTECTED;
     }
     for (auto const color: bundle.colors) {
+        FVK_LOGD << "VulkanSwapChain::update: Adding color image=" << color << " to swapchain " << this;
         auto colorTexture = fvkmemory::resource_ptr<VulkanTexture>::construct(mResourceManager,
                 mContext, device, mAllocator, mResourceManager, mCommands, color, VK_NULL_HANDLE,
                 bundle.colorFormat, VK_NULL_HANDLE /*ycrcb */, 1, bundle.extent.width,
@@ -157,6 +161,7 @@ void VulkanSwapChain::acquire(bool& resized) {
 
     // Check if the swapchain should be resized.
     if ((resized = mPlatform->hasResized(swapChain))) {
+        FVK_LOGD << "VulkanSwapChain::acquire: Resizing " << this;
         if (mFlushAndWaitOnResize) {
             mCommands->flush();
             mCommands->wait();
@@ -176,6 +181,7 @@ void VulkanSwapChain::acquire(bool& resized) {
 
     mCurrentSwapIndex = imageSyncData.imageIndex;
     assert_invariant(mCurrentSwapIndex < mFinishedDrawing.size());
+    FVK_LOGD << "VulkanSwapChain::acquire: " << this << ", index=" << mCurrentSwapIndex << ", image=" << mColors[mCurrentSwapIndex]->getVkImage();
     mFinishedDrawing[mCurrentSwapIndex] = {};
     FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS || result == VK_SUBOPTIMAL_KHR)
             << "Cannot acquire in swapchain. error=" << static_cast<int32_t>(result);

filament/backend/src/vulkan/VulkanTexture.cpp

@@ -294,9 +294,19 @@ VulkanTextureState::VulkanTextureState(VulkanStagePool& stagePool, VulkanCommand
       mYcbcr{ ycbcrConversion },
       mDefaultLayout(getDefaultLayoutImpl(usage)),
       mUsage(usage),
-      mIsProtected(isProtected) {}
+      mIsProtected(isProtected) {
+    FVK_LOGD << "Creating VulkanTextureState: image=" << image
+             << ", memory=" << deviceMemory
+             << ", format=" << format
+             << ", viewType=" << viewType
+             << ", levels=" << (int)levels
+             << ", layers=" << (int)layerCount
+             << ", usage=" << usage;
+}
 
 VulkanTextureState::~VulkanTextureState() {
+    FVK_LOGD << "Destroying VulkanTextureState: image=" << mTextureImage
+             << ", memory=" << mTextureImageMemory;
     clearCachedImageViews();
     if (mTextureImageMemory != VK_NULL_HANDLE) {
         vkDestroyImage(mDevice, mTextureImage, VKALLOC);
@@ -512,6 +522,12 @@ VulkanTexture::VulkanTexture(VkDevice device, VkPhysicalDevice physicalDevice,
 
 void VulkanTexture::updateImage(const PixelBufferDescriptor& data, uint32_t width, uint32_t height,
         uint32_t depth, uint32_t xoffset, uint32_t yoffset, uint32_t zoffset, uint32_t miplevel) {
+    FVK_LOGD << "updateImage: texture=" << mState->mTextureImage
+             << ", format=" << (int)data.format
+             << ", type=" << (int)data.type
+             << ", size=" << width << "x" << height << "x" << depth
+             << ", offset=" << xoffset << "," << yoffset << "," << zoffset
+             << ", mip=" << miplevel;
     assert_invariant(width <= this->width && height <= this->height);
     assert_invariant(depth <= this->depth * ((target == SamplerType::SAMPLER_CUBEMAP ||
                         target == SamplerType::SAMPLER_CUBEMAP_ARRAY) ? 6 : 1));
@@ -616,6 +632,11 @@ void VulkanTexture::updateImage(const PixelBufferDescriptor& data, uint32_t widt
 
 void VulkanTexture::updateImageWithBlit(const PixelBufferDescriptor& data, uint32_t width,
         uint32_t height, uint32_t depth, uint32_t miplevel) {
+    FVK_LOGD << "updateImageWithBlit: texture=" << mState->mTextureImage
+             << ", format=" << (int)data.format
+             << ", type=" << (int)data.type
+             << ", size=" << width << "x" << height << "x" << depth
+             << ", mip=" << miplevel;
     // Otherwise, use vkCmdCopyBufferToImage.
     size_t const bpp = PixelBufferDescriptor::computeDataSize(data.format, data.type, 1, 1, 1);
     // Note: if bpp = 0, we're dealing with a compressed format; we should fall
@@ -755,10 +776,14 @@ bool VulkanTexture::transitionLayout(VkCommandBuffer cmdbuf, VkImageSubresourceR
     setLayout(range, newLayout);
 
     if (hasTransitions) {
+        FVK_LOGD << "transition texture=" << mState->mTextureImage << " (" << range.baseArrayLayer
+                 << "," << range.baseMipLevel << ")" << " count=(" << range.layerCount << ","
+                 << range.levelCount << ")" << " from=" << (int)oldLayout << " to=" << (int)newLayout
+                 << " format=" << mState->mVkFormat;
 #if FVK_ENABLED(FVK_DEBUG_LAYOUT_TRANSITION)
         FVK_LOGD << "transition texture=" << mState->mTextureImage << " (" << range.baseArrayLayer
                  << "," << range.baseMipLevel << ")" << " count=(" << range.layerCount << ","
-                 << range.levelCount << ")" << " from=" << oldLayout << " to=" << newLayout
+                 << range.levelCount << ")" << " from=" << (int)oldLayout << " to=" << (int)newLayout
                  << " format=" << mState->mVkFormat << " depth="
                  << fvkutils::isVkDepthFormat(mState->mVkFormat)
                  << " slice-by-slice=" << transitionSliceBySlice;
@@ -767,7 +792,7 @@ bool VulkanTexture::transitionLayout(VkCommandBuffer cmdbuf, VkImageSubresourceR
 #if FVK_ENABLED(FVK_DEBUG_LAYOUT_TRANSITION)
         FVK_LOGD << "transition texture=" << mState->mTextureImage << " (" << range.baseArrayLayer
                  << "," << range.baseMipLevel << ")" << " count=(" << range.layerCount << ","
-                 << range.levelCount << ")" << " to=" << newLayout
+                 << range.levelCount << ")" << " to=" << (int)newLayout
                  << " is skipped because of no change in layout";
 #endif
     }
@@ -878,7 +903,7 @@ void VulkanTexture::print() const {
                 level >= mPrimaryViewRange.baseMipLevel &&
                 level < (mPrimaryViewRange.baseMipLevel + mPrimaryViewRange.levelCount);
             FVK_LOGD << "[" << mState->mTextureImage << "]: (" << layer << "," << level
-                          << ")=" << getLayout(layer, level)
+                          << ")=" << (int)getLayout(layer, level)
                           << " primary=" << primary;
         }
     }