Remove all remaining volatile qualifiers

1 files changed, 29 insertions, 16 deletions

diff --git a/Source/Core/VideoBackends/D3D12/D3D12PerfQuery.cpp b/Source/Core/VideoBackends/D3D12/D3D12PerfQuery.cpp
index d6b6b6a193..69c78bd850 100644
--- a/Source/Core/VideoBackends/D3D12/D3D12PerfQuery.cpp
+++ b/Source/Core/VideoBackends/D3D12/D3D12PerfQuery.cpp
@@ -52,10 +52,11 @@ 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)
+  const u32 query_count = m_query_count.load(std::memory_order_relaxed);
+  if (query_count > m_query_buffer.size() / 2)
   {
     const bool do_resolve = m_unresolved_queries > m_query_buffer.size() / 2;
-    const bool blocking = m_query_count == PERF_QUERY_BUFFER_SIZE;
+    const bool blocking = query_count == PERF_QUERY_BUFFER_SIZE;
     PartialFlush(do_resolve, blocking);
   }
 
@@ -83,19 +84,20 @@ void PerfQuery::DisableQuery(PerfQueryGroup type)
     g_dx_context->GetCommandList()->EndQuery(m_query_heap.Get(), D3D12_QUERY_TYPE_OCCLUSION,
                                              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);
     m_unresolved_queries++;
   }
 }
 
 void PerfQuery::ResetQuery()
 {
-  m_query_count = 0;
+  m_query_count.store(0, std::memory_order_relaxed);
   m_unresolved_queries = 0;
   m_query_resolve_pos = 0;
   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);
   for (auto& entry : m_query_buffer)
   {
     entry.fence_value = 0;
@@ -108,13 +110,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;
 }
@@ -127,7 +138,7 @@ void PerfQuery::FlushResults()
 
 bool PerfQuery::IsFlushed() const
 {
-  return m_query_count == 0;
+  return m_query_count.load(std::memory_order_relaxed) == 0;
 }
 
 void PerfQuery::ResolveQueries()
@@ -165,7 +176,7 @@ void PerfQuery::ReadbackQueries(bool blocking)
   u64 completed_fence_counter = g_dx_context->GetCompletedFenceValue();
 
   // 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++)
   {
@@ -203,7 +214,7 @@ void PerfQuery::ReadbackQueries(bool blocking)
 void PerfQuery::AccumulateQueriesFromBuffer(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);
 
   const D3D12_RANGE read_range = {m_query_readback_pos * sizeof(PerfQueryDataType),
@@ -231,16 +242,18 @@ void PerfQuery::AccumulateQueriesFromBuffer(u32 query_count)
     std::memcpy(&result, mapped_ptr + (index * sizeof(PerfQueryDataType)), sizeof(result));
 
     // NOTE: Reported pixel metrics should be referenced to native resolution
-    m_results[entry.query_type] +=
-        static_cast<u32>(static_cast<u64>(result) * EFB_WIDTH / g_renderer->GetTargetWidth() *
-                         EFB_HEIGHT / g_renderer->GetTargetHeight());
+    const u64 native_res_result = static_cast<u64>(result) * 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);
   }
 
   constexpr D3D12_RANGE write_range = {0, 0};
   m_query_readback_buffer->Unmap(0, &write_range);
 
   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 resolve, bool blocking)