kc3-lang/angle/src/tests/perf_tests/VulkanPipelineCachePerf.cpp

• Show log

  Commit

• Hash : 7d461b21
  Author :
  Date : 2024-07-10T14:11:53
  

  Revert "Vulkan: Use VK_KHR_dynamic_rendering[_local_read]"
  
  This reverts commit c379ff48043a47e444c388c45270db40d3172d50.
  
  Reason for revert: Regresses CPU perf and memory when _not_ using DR
  
  Original change's description:
  > Vulkan: Use VK_KHR_dynamic_rendering[_local_read]
  >
  > Bug: angleproject:42267038
  > Change-Id: I1f4eb0f309992a9c1c287a69520dadf5eff23b26
  > Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/5637155
  > Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
  > Reviewed-by: Amirali Abdolrashidi <abdolrashidi@google.com>
  > Reviewed-by: Charlie Lao <cclao@google.com>
  
  Bug: angleproject:42267038
  Change-Id: I3865f0d86813f0eeb9085a92875a33bd449b907f
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/5691337
  Bot-Commit: Rubber Stamper <rubber-stamper@appspot.gserviceaccount.com>
  Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
  

Download

• src/tests/perf_tests/VulkanPipelineCachePerf.cpp

• //
  // Copyright 2018 The ANGLE Project Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style license that can be
  // found in the LICENSE file.
  //
  // VulkanPipelineCachePerf:
  //   Performance benchmark for the Vulkan Pipeline cache.
  
  #include "ANGLEPerfTest.h"
  
  #include "libANGLE/renderer/vulkan/vk_cache_utils.h"
  #include "libANGLE/renderer/vulkan/vk_helpers.h"
  #include "libANGLE/renderer/vulkan/vk_renderer.h"
  #include "util/random_utils.h"
  
  using namespace rx;
  
  namespace
  {
  constexpr unsigned int kIterationsPerStep = 100;
  
  struct Params
  {
      bool withDynamicState = false;
  };
  
  class VulkanPipelineCachePerfTest : public ANGLEPerfTest,
                                      public ::testing::WithParamInterface<Params>
  {
    public:
      VulkanPipelineCachePerfTest();
      ~VulkanPipelineCachePerfTest();
  
      void SetUp() override;
      void step() override;
  
      GraphicsPipelineCache<GraphicsPipelineDescCompleteHash> mCache;
      angle::RNG mRNG;
  
      std::vector<vk::GraphicsPipelineDesc> mCacheHits;
      std::vector<vk::GraphicsPipelineDesc> mCacheMisses;
      size_t mMissIndex = 0;
  
    private:
      void randomizeDesc(vk::GraphicsPipelineDesc *desc);
  };
  
  VulkanPipelineCachePerfTest::VulkanPipelineCachePerfTest()
      : ANGLEPerfTest("VulkanPipelineCachePerf", "", "", kIterationsPerStep), mRNG(0x12345678u)
  {}
  
  VulkanPipelineCachePerfTest::~VulkanPipelineCachePerfTest()
  {
      mCache.reset();
  }
  
  void VulkanPipelineCachePerfTest::SetUp()
  {
      ANGLEPerfTest::SetUp();
  
      // Insert a number of random pipeline states.
      for (int pipelineCount = 0; pipelineCount < 100; ++pipelineCount)
      {
          vk::Pipeline pipeline;
          vk::GraphicsPipelineDesc desc;
          randomizeDesc(&desc);
  
          if (pipelineCount < 10)
          {
              mCacheHits.push_back(desc);
          }
          mCache.populate(desc, std::move(pipeline), nullptr);
      }
  
      for (int missCount = 0; missCount < 10000; ++missCount)
      {
          vk::GraphicsPipelineDesc desc;
          randomizeDesc(&desc);
          mCacheMisses.push_back(desc);
      }
  }
  
  void VulkanPipelineCachePerfTest::randomizeDesc(vk::GraphicsPipelineDesc *desc)
  {
      std::vector<uint8_t> bytes(sizeof(vk::GraphicsPipelineDesc));
      FillVectorWithRandomUBytes(&mRNG, &bytes);
      memcpy(desc, bytes.data(), sizeof(vk::GraphicsPipelineDesc));
  
      desc->setSupportsDynamicStateForTest(GetParam().withDynamicState);
  }
  
  void VulkanPipelineCachePerfTest::step()
  {
      vk::RenderPass rp;
      vk::PipelineLayout pl;
      vk::PipelineCache pc;
      vk::PipelineCacheAccess spc;
      vk::RefCounted<vk::ShaderModule> vsRefCounted;
      vk::RefCounted<vk::ShaderModule> fsRefCounted;
      vk::ShaderModuleMap ssm;
      const vk::GraphicsPipelineDesc *desc = nullptr;
      vk::PipelineHelper *result           = nullptr;
  
      // The Vulkan handle types are difficult to cast to without #ifdefs.
      VkShaderModule vs = (VkShaderModule)1;
      VkShaderModule fs = (VkShaderModule)2;
  
      vsRefCounted.get().setHandle(vs);
      fsRefCounted.get().setHandle(fs);
  
      ssm[gl::ShaderType::Vertex].set(&vsRefCounted);
      ssm[gl::ShaderType::Fragment].set(&fsRefCounted);
  
      spc.init(&pc, nullptr);
  
      vk::SpecializationConstants defaultSpecConsts{};
  
      for (unsigned int iteration = 0; iteration < kIterationsPerStep; ++iteration)
      {
          for (const auto &hit : mCacheHits)
          {
              if (!mCache.getPipeline(hit, &desc, &result))
              {
                  (void)mCache.createPipeline(VK_NULL_HANDLE, &spc, rp, pl, ssm, defaultSpecConsts,
                                              PipelineSource::Draw, hit, &desc, &result);
              }
          }
      }
  
      for (int missCount = 0; missCount < 20 && mMissIndex < mCacheMisses.size();
           ++missCount, ++mMissIndex)
      {
          const auto &miss = mCacheMisses[mMissIndex];
          if (!mCache.getPipeline(miss, &desc, &result))
          {
              (void)mCache.createPipeline(VK_NULL_HANDLE, &spc, rp, pl, ssm, defaultSpecConsts,
                                          PipelineSource::Draw, miss, &desc, &result);
          }
      }
  
      vsRefCounted.get().setHandle(VK_NULL_HANDLE);
      fsRefCounted.get().setHandle(VK_NULL_HANDLE);
  }
  
  }  // anonymous namespace
  
  // Test performance of pipeline hash and look up in Vulkan
  TEST_P(VulkanPipelineCachePerfTest, Run)
  {
      run();
  }
  
  INSTANTIATE_TEST_SUITE_P(,
                           VulkanPipelineCachePerfTest,
                           ::testing::ValuesIn(std::vector<Params>{{Params{false}, Params{true}}}));
  

Download