1 files changed, 29 insertions, 16 deletions

diff --git a/Source/Core/VideoBackends/Vulkan/VKPerfQuery.cpp b/Source/Core/VideoBackends/Vulkan/VKPerfQuery.cpp
index c8fcd05842..d4f442c54d 100644
--- a/Source/Core/VideoBackends/Vulkan/VKPerfQuery.cpp
+++ b/Source/Core/VideoBackends/Vulkan/VKPerfQuery.cpp
@@ -43,8 +43,9 @@ void PerfQuery::EnableQuery(PerfQueryGroup type)
 {
   // Block if there are no free slots.
   // Otherwise, try to keep half of them available.
-  if (m_query_count > m_query_buffer.size() / 2)
-    PartialFlush(m_query_count == PERF_QUERY_BUFFER_SIZE);
+  const u32 query_count = m_query_count.load(std::memory_order_relaxed);
+  if (query_count > m_query_buffer.size() / 2)
+    PartialFlush(query_count == PERF_QUERY_BUFFER_SIZE);
 
   // Ensure command buffer is ready to go before beginning the query, that way we don't submit
   // a buffer with open queries.
@@ -73,16 +74,17 @@ void PerfQuery::DisableQuery(PerfQueryGroup type)
   {
     vkCmdEndQuery(g_command_buffer_mgr->GetCurrentCommandBuffer(), m_query_pool, m_query_next_pos);
     m_query_next_pos = (m_query_next_pos + 1) % PERF_QUERY_BUFFER_SIZE;
-    m_query_count++;
+    m_query_count.fetch_add(1, std::memory_order_relaxed);
   }
 }
 
 void PerfQuery::ResetQuery()
 {
-  m_query_count = 0;
+  m_query_count.store(0, std::memory_order_relaxed);
   m_query_readback_pos = 0;
   m_query_next_pos = 0;
-  std::fill(std::begin(m_results), std::end(m_results), 0);
+  for (size_t i = 0; i < m_results.size(); ++i)
+    m_results[i].store(0, std::memory_order_relaxed);
 
   // Reset entire query pool, ensuring all queries are ready to write to.
   StateTracker::GetInstance()->EndRenderPass();
@@ -96,13 +98,22 @@ u32 PerfQuery::GetQueryResult(PerfQueryType type)
 {
   u32 result = 0;
   if (type == PQ_ZCOMP_INPUT_ZCOMPLOC || type == PQ_ZCOMP_OUTPUT_ZCOMPLOC)
-    result = m_results[PQG_ZCOMP_ZCOMPLOC];
+  {
+    result = m_results[PQG_ZCOMP_ZCOMPLOC].load(std::memory_order_relaxed);
+  }
   else if (type == PQ_ZCOMP_INPUT || type == PQ_ZCOMP_OUTPUT)
-    result = m_results[PQG_ZCOMP];
+  {
+    result = m_results[PQG_ZCOMP].load(std::memory_order_relaxed);
+  }
   else if (type == PQ_BLEND_INPUT)
-    result = m_results[PQG_ZCOMP] + m_results[PQG_ZCOMP_ZCOMPLOC];
+  {
+    result = m_results[PQG_ZCOMP].load(std::memory_order_relaxed) +
+             m_results[PQG_ZCOMP_ZCOMPLOC].load(std::memory_order_relaxed);
+  }
   else if (type == PQ_EFB_COPY_CLOCKS)
-    result = m_results[PQG_EFB_COPY_CLOCKS];
+  {
+    result = m_results[PQG_EFB_COPY_CLOCKS].load(std::memory_order_relaxed);
+  }
 
   return result / 4;
 }
@@ -115,7 +126,7 @@ void PerfQuery::FlushResults()
 
 bool PerfQuery::IsFlushed() const
 {
-  return m_query_count == 0;
+  return m_query_count.load(std::memory_order_relaxed) == 0;
 }
 
 bool PerfQuery::CreateQueryPool()
@@ -144,7 +155,7 @@ void PerfQuery::ReadbackQueries()
   const u64 completed_fence_counter = g_command_buffer_mgr->GetCompletedFenceCounter();
 
   // Need to save these since ProcessResults will modify them.
-  const u32 outstanding_queries = m_query_count;
+  const u32 outstanding_queries = m_query_count.load(std::memory_order_relaxed);
   u32 readback_count = 0;
   for (u32 i = 0; i < outstanding_queries; i++)
   {
@@ -171,7 +182,7 @@ void PerfQuery::ReadbackQueries()
 void PerfQuery::ReadbackQueries(u32 query_count)
 {
   // Should be at maximum query_count queries pending.
-  ASSERT(query_count <= m_query_count &&
+  ASSERT(query_count <= m_query_count.load(std::memory_order_relaxed) &&
          (m_query_readback_pos + query_count) <= PERF_QUERY_BUFFER_SIZE);
 
   // Read back from the GPU.
@@ -194,13 +205,15 @@ void PerfQuery::ReadbackQueries(u32 query_count)
     entry.has_value = false;
 
     // NOTE: Reported pixel metrics should be referenced to native resolution
-    m_results[entry.query_type] +=
-        static_cast<u32>(static_cast<u64>(m_query_result_buffer[i]) * EFB_WIDTH /
-                         g_renderer->GetTargetWidth() * EFB_HEIGHT / g_renderer->GetTargetHeight());
+    const u64 native_res_result = static_cast<u64>(m_query_result_buffer[i]) * EFB_WIDTH /
+                                  g_renderer->GetTargetWidth() * EFB_HEIGHT /
+                                  g_renderer->GetTargetHeight();
+    m_results[entry.query_type].fetch_add(static_cast<u32>(native_res_result),
+                                          std::memory_order_relaxed);
   }
 
   m_query_readback_pos = (m_query_readback_pos + query_count) % PERF_QUERY_BUFFER_SIZE;
-  m_query_count -= query_count;
+  m_query_count.fetch_sub(query_count, std::memory_order_relaxed);
 }
 
 void PerfQuery::PartialFlush(bool blocking)