DiscardableHandle Implementation

gpu/command_buffer/common/discardable_handle.cc

+// Copyright (c) 2017 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/common/discardable_handle.h"
+
+#include "base/atomicops.h"
+#include "gpu/command_buffer/common/buffer.h"
+
+namespace gpu {
+namespace {
+const int32_t kHandleDeleted = 0;
+const int32_t kHandleUnlocked = 1;
+const int32_t kHandleLockedStart = 2;
+
+}  // namespace
+
+DiscardableHandleBase::DiscardableHandleBase(scoped_refptr<Buffer> buffer,
+                                             uint32_t byte_offset,
+                                             int32_t shm_id)
+    : buffer_(std::move(buffer)), byte_offset_(byte_offset), shm_id_(shm_id) {}
+
+DiscardableHandleBase::DiscardableHandleBase(
+    const DiscardableHandleBase& other) = default;
+DiscardableHandleBase::DiscardableHandleBase(DiscardableHandleBase&& other) =
+    default;
+DiscardableHandleBase::~DiscardableHandleBase() = default;
+DiscardableHandleBase& DiscardableHandleBase::operator=(
+    const DiscardableHandleBase& other) = default;
+DiscardableHandleBase& DiscardableHandleBase::operator=(
+    DiscardableHandleBase&& other) = default;
+
+bool DiscardableHandleBase::IsLockedForTesting() {
+  return kHandleLockedStart <= base::subtle::NoBarrier_Load(AsAtomic());
+}
+
+bool DiscardableHandleBase::IsDeletedForTesting() {
+  return kHandleDeleted == base::subtle::NoBarrier_Load(AsAtomic());
+}
+
+volatile base::subtle::Atomic32* DiscardableHandleBase::AsAtomic() const {
+  return reinterpret_cast<volatile base::subtle::Atomic32*>(
+      buffer_->GetDataAddress(byte_offset_, sizeof(base::subtle::Atomic32)));
+}
+
+ClientDiscardableHandle::ClientDiscardableHandle(scoped_refptr<Buffer> buffer,
+                                                 uint32_t byte_offset,
+                                                 int32_t shm_id)
+    : DiscardableHandleBase(std::move(buffer), byte_offset, shm_id) {
+  // Handle always starts locked.
+  base::subtle::NoBarrier_Store(AsAtomic(), kHandleLockedStart);
+}
+
+ClientDiscardableHandle::ClientDiscardableHandle(
+    const ClientDiscardableHandle& other) = default;
+ClientDiscardableHandle::ClientDiscardableHandle(
+    ClientDiscardableHandle&& other) = default;
+ClientDiscardableHandle& ClientDiscardableHandle::operator=(
+    const ClientDiscardableHandle& other) = default;
+ClientDiscardableHandle& ClientDiscardableHandle::operator=(
+    ClientDiscardableHandle&& other) = default;
+
+bool ClientDiscardableHandle::Lock() {
+  while (true) {
+    base::subtle::Atomic32 current_value =
+        base::subtle::NoBarrier_Load(AsAtomic());
+    if (current_value == kHandleDeleted) {
+      // Once a handle is deleted, it cannot be modified further.
+      return false;
+    }
+    base::subtle::Atomic32 new_value = current_value + 1;
+    // No barrier is needed, as any commands which depend on this operation
+    // will flow over the command buffer, which ensures a memory barrier
+    // between here and where these commands are executed on the GPU process.
+    base::subtle::Atomic32 previous_value =
+        base::subtle::NoBarrier_CompareAndSwap(AsAtomic(), current_value,
+                                               new_value);
+    if (current_value == previous_value) {
+      return true;
+    }
+  }
+}
+
+bool ClientDiscardableHandle::CanBeReUsed() const {
+  return kHandleDeleted == base::subtle::Acquire_Load(AsAtomic());
+}
+
+ServiceDiscardableHandle::ServiceDiscardableHandle(scoped_refptr<Buffer> buffer,
+                                                   uint32_t byte_offset,
+                                                   int32_t shm_id)
+    : DiscardableHandleBase(std::move(buffer), byte_offset, shm_id) {}
+
+ServiceDiscardableHandle::ServiceDiscardableHandle(
+    const ServiceDiscardableHandle& other) = default;
+ServiceDiscardableHandle::ServiceDiscardableHandle(
+    ServiceDiscardableHandle&& other) = default;
+ServiceDiscardableHandle& ServiceDiscardableHandle::operator=(
+    const ServiceDiscardableHandle& other) = default;
+ServiceDiscardableHandle& ServiceDiscardableHandle::operator=(
+    ServiceDiscardableHandle&& other) = default;
+
+void ServiceDiscardableHandle::Unlock() {
+  // No barrier is needed as all GPU process access happens on a single thread,
+  // and communication of dependent data between the GPU process and the
+  // renderer process happens across the command buffer and includes barriers.
+  base::subtle::NoBarrier_AtomicIncrement(AsAtomic(), -1);
+}
+
+bool ServiceDiscardableHandle::Delete() {
+  // No barrier is needed as all GPU process access happens on a single thread,
+  // and communication of dependent data between the GPU process and the
+  // renderer process happens across the command buffer and includes barriers.
+  return kHandleUnlocked == base::subtle::NoBarrier_CompareAndSwap(
+                                AsAtomic(), kHandleUnlocked, kHandleDeleted);
+}
+
+}  // namespace gpu