gpu/command_buffer/service/transfer_buffer_manager.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "gpu/command_buffer/service/transfer_buffer_manager.h"
   6
   7 #include <limits>
   8
   9 #include "base/logging.h"
  10 #include "base/memory/scoped_ptr.h"
  11 #include "base/process/process_handle.h"
  12 #include "base/strings/stringprintf.h"
  13 #include "base/thread_task_runner_handle.h"
  14 #include "base/trace_event/memory_allocator_dump.h"
  15 #include "base/trace_event/memory_dump_manager.h"
  16 #include "base/trace_event/process_memory_dump.h"
  17 #include "base/trace_event/trace_event.h"
  18 #include "gpu/command_buffer/common/cmd_buffer_common.h"
  19 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
  20 #include "gpu/command_buffer/service/memory_tracking.h"
  21
  22 using ::base::SharedMemory;
  23
  24 namespace gpu {
  25
  26 TransferBufferManagerInterface::~TransferBufferManagerInterface() {
  27 }
  28
  29 TransferBufferManager::TransferBufferManager(
  30     gles2::MemoryTracker* memory_tracker)
  31     : shared_memory_bytes_allocated_(0), memory_tracker_(memory_tracker) {}
  32
  33 TransferBufferManager::~TransferBufferManager() {
  34   while (!registered_buffers_.empty()) {
  35     BufferMap::iterator it = registered_buffers_.begin();
  36     DCHECK(shared_memory_bytes_allocated_ >= it->second->size());
  37     shared_memory_bytes_allocated_ -= it->second->size();
  38     registered_buffers_.erase(it);
  39   }
  40   DCHECK(!shared_memory_bytes_allocated_);
  41
  42   base::trace_event::MemoryDumpManager::GetInstance()->UnregisterDumpProvider(
  43       this);
  44 }
  45
  46 bool TransferBufferManager::Initialize() {
  47   // When created from InProcessCommandBuffer, we won't have a |memory_tracker_|
  48   // so don't register a dump provider.
  49   if (memory_tracker_) {
  50     base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider(
  51         this, base::ThreadTaskRunnerHandle::Get());
  52   }
  53   return true;
  54 }
  55
  56 bool TransferBufferManager::RegisterTransferBuffer(
  57     int32 id,
  58     scoped_ptr<BufferBacking> buffer_backing) {
  59   if (id <= 0) {
  60     DVLOG(0) << "Cannot register transfer buffer with non-positive ID.";
  61     return false;
  62   }
  63
  64   // Fail if the ID is in use.
  65   if (registered_buffers_.find(id) != registered_buffers_.end()) {
  66     DVLOG(0) << "Buffer ID already in use.";
  67     return false;
  68   }
  69
  70   // Register the shared memory with the ID.
  71   scoped_refptr<Buffer> buffer(new gpu::Buffer(buffer_backing.Pass()));
  72
  73   // Check buffer alignment is sane.
  74   DCHECK(!(reinterpret_cast<uintptr_t>(buffer->memory()) &
  75            (kCommandBufferEntrySize - 1)));
  76
  77   shared_memory_bytes_allocated_ += buffer->size();
  78
  79   registered_buffers_[id] = buffer;
  80
  81   return true;
  82 }
  83
  84 void TransferBufferManager::DestroyTransferBuffer(int32 id) {
  85   BufferMap::iterator it = registered_buffers_.find(id);
  86   if (it == registered_buffers_.end()) {
  87     DVLOG(0) << "Transfer buffer ID was not registered.";
  88     return;
  89   }
  90
  91   DCHECK(shared_memory_bytes_allocated_ >= it->second->size());
  92   shared_memory_bytes_allocated_ -= it->second->size();
  93
  94   registered_buffers_.erase(it);
  95 }
  96
  97 scoped_refptr<Buffer> TransferBufferManager::GetTransferBuffer(int32 id) {
  98   if (id == 0)
  99     return NULL;
 100
 101   BufferMap::iterator it = registered_buffers_.find(id);
 102   if (it == registered_buffers_.end())
 103     return NULL;
 104
 105   return it->second;
 106 }
 107
 108 bool TransferBufferManager::OnMemoryDump(
 109     const base::trace_event::MemoryDumpArgs& args,
 110     base::trace_event::ProcessMemoryDump* pmd) {
 111   for (const auto& buffer_entry : registered_buffers_) {
 112     int32 buffer_id = buffer_entry.first;
 113     const Buffer* buffer = buffer_entry.second.get();
 114     std::string dump_name =
 115         base::StringPrintf("gpu/transfer_memory/client_%d/buffer_%d",
 116                            memory_tracker_->ClientId(), buffer_id);
 117     base::trace_event::MemoryAllocatorDump* dump =
 118         pmd->CreateAllocatorDump(dump_name);
 119     dump->AddScalar(base::trace_event::MemoryAllocatorDump::kNameSize,
 120                     base::trace_event::MemoryAllocatorDump::kUnitsBytes,
 121                     buffer->size());
 122     auto guid =
 123         GetBufferGUIDForTracing(memory_tracker_->ClientTracingId(), buffer_id);
 124     pmd->CreateSharedGlobalAllocatorDump(guid);
 125     pmd->AddOwnershipEdge(dump->guid(), guid);
 126   }
 127
 128   return true;
 129 }
 130
 131 }  // namespace gpu
 132