gpu: Use explicit atomics instead of assuming that 32bit read/writes are atomic.

gpu/command_buffer/service/query_manager.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "gpu/command_buffer/service/query_manager.h"
 
 #include "base/atomicops.h"
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/shared_memory.h"
 #include "base/synchronization/lock.h"
 #include "base/time/time.h"
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/command_buffer/service/async_pixel_transfer_manager.h"
 #include "gpu/command_buffer/service/error_state.h"
 #include "gpu/command_buffer/service/feature_info.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 
 namespace gpu {
 namespace gles2 {
 
 namespace {
 
 class AsyncPixelTransferCompletionObserverImpl
     : public AsyncPixelTransferCompletionObserver {
  public:
-  AsyncPixelTransferCompletionObserverImpl(uint32 submit_count)
-      : submit_count_(submit_count),
-        cancelled_(false) {}
+  AsyncPixelTransferCompletionObserverImpl(base::subtle::Atomic32 submit_count)
+      : submit_count_(submit_count), cancelled_(false) {}
 
   void Cancel() {
     base::AutoLock locked(lock_);
     cancelled_ = true;
   }
 
   virtual void DidComplete(const AsyncMemoryParams& mem_params) OVERRIDE {
     base::AutoLock locked(lock_);
     if (!cancelled_) {
       DCHECK(mem_params.shared_memory);
       DCHECK(mem_params.shared_memory->memory());
       void* data = static_cast<int8*>(mem_params.shared_memory->memory()) +
                    mem_params.shm_data_offset;
       QuerySync* sync = static_cast<QuerySync*>(data);
 
-      // Need a MemoryBarrier here to ensure that upload completed before
-      // submit_count was written to sync->process_count.
-      base::subtle::MemoryBarrier();
-      sync->process_count = submit_count_;
+      base::subtle::Release_Store(&sync->process_count, submit_count_);
     }
   }
 
  private:
   virtual ~AsyncPixelTransferCompletionObserverImpl() {}
 
-  uint32 submit_count_;
+  base::subtle::Atomic32 submit_count_;
 
   base::Lock lock_;
   bool cancelled_;
 
   DISALLOW_COPY_AND_ASSIGN(AsyncPixelTransferCompletionObserverImpl);
 };
 
 class AsyncPixelTransfersCompletedQuery
     : public QueryManager::Query,
       public base::SupportsWeakPtr<AsyncPixelTransfersCompletedQuery> {
  public:
   AsyncPixelTransfersCompletedQuery(
       QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset);
 
   virtual bool Begin() OVERRIDE;
-  virtual bool End(uint32 submit_count) OVERRIDE;
+  virtual bool End(base::subtle::Atomic32 submit_count) OVERRIDE;
   virtual bool Process() OVERRIDE;
   virtual void Destroy(bool have_context) OVERRIDE;
 
  protected:
   virtual ~AsyncPixelTransfersCompletedQuery();
 
   scoped_refptr<AsyncPixelTransferCompletionObserverImpl> observer_;
 };
 
 AsyncPixelTransfersCompletedQuery::AsyncPixelTransfersCompletedQuery(
     QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset)
     : Query(manager, target, shm_id, shm_offset) {
 }
 
 bool AsyncPixelTransfersCompletedQuery::Begin() {
   return true;
 }
 
-bool AsyncPixelTransfersCompletedQuery::End(uint32 submit_count) {
+bool AsyncPixelTransfersCompletedQuery::End(
+    base::subtle::Atomic32 submit_count) {
   AsyncMemoryParams mem_params;
   // Get the real shared memory since it might need to be duped to prevent
   // use-after-free of the memory.
   Buffer buffer = manager()->decoder()->GetSharedMemoryBuffer(shm_id());
   if (!buffer.shared_memory)
     return false;
   mem_params.shared_memory = buffer.shared_memory;
   mem_params.shm_size = buffer.size;
   mem_params.shm_data_offset = shm_offset();
   mem_params.shm_data_size = sizeof(QuerySync);
@@ skipping 11 matching lines @@
 
 bool AsyncPixelTransfersCompletedQuery::Process() {
   QuerySync* sync = manager()->decoder()->GetSharedMemoryAs<QuerySync*>(
       shm_id(), shm_offset(), sizeof(*sync));
   if (!sync)
     return false;
 
   // Check if completion callback has been run. sync->process_count atomicity
   // is guaranteed as this is already used to notify client of a completed
   // query.
-  if (sync->process_count != submit_count())
+  if (base::subtle::Acquire_Load(&sync->process_count) != submit_count())
     return true;
 
   UnmarkAsPending();
   return true;
 }
 
 void AsyncPixelTransfersCompletedQuery::Destroy(bool /* have_context */) {
   if (!IsDeleted()) {
     MarkAsDeleted();
   }
 }
 
 AsyncPixelTransfersCompletedQuery::~AsyncPixelTransfersCompletedQuery() {
   if (observer_)
     observer_->Cancel();
 }
 
 }  // namespace
 
 class AllSamplesPassedQuery : public QueryManager::Query {
  public:
   AllSamplesPassedQuery(
       QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset,
       GLuint service_id);
   virtual bool Begin() OVERRIDE;
-  virtual bool End(uint32 submit_count) OVERRIDE;
+  virtual bool End(base::subtle::Atomic32 submit_count) OVERRIDE;
   virtual bool Process() OVERRIDE;
   virtual void Destroy(bool have_context) OVERRIDE;
 
  protected:
   virtual ~AllSamplesPassedQuery();
 
  private:
   // Service side query id.
   GLuint service_id_;
 };
 
 AllSamplesPassedQuery::AllSamplesPassedQuery(
     QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset,
     GLuint service_id)
     : Query(manager, target, shm_id, shm_offset),
       service_id_(service_id) {
 }
 
 bool AllSamplesPassedQuery::Begin() {
   BeginQueryHelper(target(), service_id_);
   return true;
 }
 
-bool AllSamplesPassedQuery::End(uint32 submit_count) {
+bool AllSamplesPassedQuery::End(base::subtle::Atomic32 submit_count) {
   EndQueryHelper(target());
   return AddToPendingQueue(submit_count);
 }
 
 bool AllSamplesPassedQuery::Process() {
   GLuint available = 0;
   glGetQueryObjectuivARB(
       service_id_, GL_QUERY_RESULT_AVAILABLE_EXT, &available);
   if (!available) {
     return true;
@@ skipping 14 matching lines @@
 
 AllSamplesPassedQuery::~AllSamplesPassedQuery() {
 }
 
 class CommandsIssuedQuery : public QueryManager::Query {
  public:
   CommandsIssuedQuery(
       QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset);
 
   virtual bool Begin() OVERRIDE;
-  virtual bool End(uint32 submit_count) OVERRIDE;
+  virtual bool End(base::subtle::Atomic32 submit_count) OVERRIDE;
   virtual bool Process() OVERRIDE;
   virtual void Destroy(bool have_context) OVERRIDE;
 
  protected:
   virtual ~CommandsIssuedQuery();
 
  private:
   base::TimeTicks begin_time_;
 };
 
 CommandsIssuedQuery::CommandsIssuedQuery(
       QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset)
     : Query(manager, target, shm_id, shm_offset) {
 }
 
 bool CommandsIssuedQuery::Begin() {
   begin_time_ = base::TimeTicks::HighResNow();
   return true;
 }
 
-bool CommandsIssuedQuery::End(uint32 submit_count) {
+bool CommandsIssuedQuery::End(base::subtle::Atomic32 submit_count) {
   base::TimeDelta elapsed = base::TimeTicks::HighResNow() - begin_time_;
   MarkAsPending(submit_count);
   return MarkAsCompleted(elapsed.InMicroseconds());
 }
 
 bool CommandsIssuedQuery::Process() {
   NOTREACHED();
   return true;
 }
 
 void CommandsIssuedQuery::Destroy(bool /* have_context */) {
   if (!IsDeleted()) {
     MarkAsDeleted();
   }
 }
 
 CommandsIssuedQuery::~CommandsIssuedQuery() {
 }
 
 class CommandLatencyQuery : public QueryManager::Query {
  public:
   CommandLatencyQuery(
       QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset);
 
   virtual bool Begin() OVERRIDE;
-  virtual bool End(uint32 submit_count) OVERRIDE;
+  virtual bool End(base::subtle::Atomic32 submit_count) OVERRIDE;
   virtual bool Process() OVERRIDE;
   virtual void Destroy(bool have_context) OVERRIDE;
 
  protected:
   virtual ~CommandLatencyQuery();
 };
 
 CommandLatencyQuery::CommandLatencyQuery(
       QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset)
     : Query(manager, target, shm_id, shm_offset) {
 }
 
 bool CommandLatencyQuery::Begin() {
     return true;
 }
 
-bool CommandLatencyQuery::End(uint32 submit_count) {
+bool CommandLatencyQuery::End(base::subtle::Atomic32 submit_count) {
     base::TimeDelta now = base::TimeTicks::HighResNow() - base::TimeTicks();
     MarkAsPending(submit_count);
     return MarkAsCompleted(now.InMicroseconds());
 }
 
 bool CommandLatencyQuery::Process() {
   NOTREACHED();
   return true;
 }
 
 void CommandLatencyQuery::Destroy(bool /* have_context */) {
   if (!IsDeleted()) {
     MarkAsDeleted();
   }
 }
 
 CommandLatencyQuery::~CommandLatencyQuery() {
 }
 
 
 class AsyncReadPixelsCompletedQuery
     : public QueryManager::Query,
       public base::SupportsWeakPtr<AsyncReadPixelsCompletedQuery> {
  public:
   AsyncReadPixelsCompletedQuery(
       QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset);
 
   virtual bool Begin() OVERRIDE;
-  virtual bool End(uint32 submit_count) OVERRIDE;
+  virtual bool End(base::subtle::Atomic32 submit_count) OVERRIDE;
   virtual bool Process() OVERRIDE;
   virtual void Destroy(bool have_context) OVERRIDE;
 
  protected:
   void Complete();
   virtual ~AsyncReadPixelsCompletedQuery();
 };
 
 AsyncReadPixelsCompletedQuery::AsyncReadPixelsCompletedQuery(
     QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset)
     : Query(manager, target, shm_id, shm_offset) {
 }
 
 bool AsyncReadPixelsCompletedQuery::Begin() {
   return true;
 }
 
-bool AsyncReadPixelsCompletedQuery::End(uint32 submit_count) {
+bool AsyncReadPixelsCompletedQuery::End(base::subtle::Atomic32 submit_count) {
   if (!AddToPendingQueue(submit_count)) {
     return false;
   }
   manager()->decoder()->WaitForReadPixels(
       base::Bind(&AsyncReadPixelsCompletedQuery::Complete,
                  AsWeakPtr()));
 
   return true;
 }
 
@@ skipping 14 matching lines @@
 AsyncReadPixelsCompletedQuery::~AsyncReadPixelsCompletedQuery() {
 }
 
 
 class GetErrorQuery : public QueryManager::Query {
  public:
   GetErrorQuery(
       QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset);
 
   virtual bool Begin() OVERRIDE;
-  virtual bool End(uint32 submit_count) OVERRIDE;
+  virtual bool End(base::subtle::Atomic32 submit_count) OVERRIDE;
   virtual bool Process() OVERRIDE;
   virtual void Destroy(bool have_context) OVERRIDE;
 
  protected:
   virtual ~GetErrorQuery();
 
  private:
 };
 
 GetErrorQuery::GetErrorQuery(
       QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset)
     : Query(manager, target, shm_id, shm_offset) {
 }
 
 bool GetErrorQuery::Begin() {
   return true;
 }
 
-bool GetErrorQuery::End(uint32 submit_count) {
+bool GetErrorQuery::End(base::subtle::Atomic32 submit_count) {
   MarkAsPending(submit_count);
   return MarkAsCompleted(manager()->decoder()->GetErrorState()->GetGLError());
 }
 
 bool GetErrorQuery::Process() {
   NOTREACHED();
   return true;
 }
 
 void GetErrorQuery::Destroy(bool /* have_context */) {
@@ skipping 173 matching lines @@
 bool QueryManager::Query::MarkAsCompleted(uint64 result) {
   DCHECK(pending_);
   QuerySync* sync = manager_->decoder_->GetSharedMemoryAs<QuerySync*>(
       shm_id_, shm_offset_, sizeof(*sync));
   if (!sync) {
     return false;
   }
 
   pending_ = false;
   sync->result = result;
-  // Need a MemoryBarrier here so that sync->result is written before
-  // sync->process_count.
-  base::subtle::MemoryBarrier();
-  sync->process_count = submit_count_;
+  base::subtle::Release_Store(&sync->process_count, submit_count_);
 
   return true;
 }
 
 bool QueryManager::ProcessPendingQueries() {
   while (!pending_queries_.empty()) {
     Query* query = pending_queries_.front().get();
     if (!query->Process()) {
       return false;
     }
@@ skipping 24 matching lines @@
     pending_transfer_queries_.pop_front();
   }
 
   return true;
 }
 
 bool QueryManager::HavePendingTransferQueries() {
   return !pending_transfer_queries_.empty();
 }
 
-bool QueryManager::AddPendingQuery(Query* query, uint32 submit_count) {
+bool QueryManager::AddPendingQuery(Query* query,
+                                   base::subtle::Atomic32 submit_count) {
   DCHECK(query);
   DCHECK(!query->IsDeleted());
   if (!RemovePendingQuery(query)) {
     return false;
   }
   query->MarkAsPending(submit_count);
   pending_queries_.push_back(query);
   return true;
 }
 
-bool QueryManager::AddPendingTransferQuery(Query* query, uint32 submit_count) {
+bool QueryManager::AddPendingTransferQuery(
+    Query* query,
+    base::subtle::Atomic32 submit_count) {
   DCHECK(query);
   DCHECK(!query->IsDeleted());
   if (!RemovePendingQuery(query)) {
     return false;
   }
   query->MarkAsPending(submit_count);
   pending_transfer_queries_.push_back(query);
   return true;
 }
 
@@ skipping 25 matching lines @@
 }
 
 bool QueryManager::BeginQuery(Query* query) {
   DCHECK(query);
   if (!RemovePendingQuery(query)) {
     return false;
   }
   return query->Begin();
 }
 
-bool QueryManager::EndQuery(Query* query, uint32 submit_count) {
+bool QueryManager::EndQuery(Query* query, base::subtle::Atomic32 submit_count) {
   DCHECK(query);
   if (!RemovePendingQuery(query)) {
     return false;
   }
   return query->End(submit_count);
 }
 
 }  // namespace gles2
 }  // namespace gpu