1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168
|
// Copyright 2017 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "gpu/command_buffer/client/client_transfer_cache.h"
namespace gpu {
ClientTransferCache::ClientTransferCache(Client* client) : client_(client) {}
ClientTransferCache::~ClientTransferCache() = default;
void* ClientTransferCache::MapEntry(MappedMemoryManager* mapped_memory,
uint32_t size) {
DCHECK(!mapped_ptr_);
DCHECK(!transfer_buffer_ptr_);
mapped_ptr_.emplace(size, client_->cmd_buffer_helper(), mapped_memory);
if (!mapped_ptr_->valid()) {
mapped_ptr_ = std::nullopt;
return nullptr;
}
return mapped_ptr_->address();
}
void* ClientTransferCache::MapTransferBufferEntry(
TransferBufferInterface* transfer_buffer,
uint32_t size) {
DCHECK(!mapped_ptr_);
DCHECK(!transfer_buffer_ptr_);
transfer_buffer_ptr_.emplace(size, client_->cmd_buffer_helper(),
transfer_buffer);
if (!transfer_buffer_ptr_->valid()) {
transfer_buffer_ptr_ = std::nullopt;
return nullptr;
}
return transfer_buffer_ptr_->address();
}
void ClientTransferCache::UnmapAndCreateEntry(uint32_t type, uint32_t id) {
EntryKey key(type, id);
base::AutoLock hold(lock_);
auto handle = CreateDiscardableHandle(key);
if (!handle.IsValid()) {
// Release any data pointers. Keeping these alive longer can lead to issues
// with transfer buffer reallocation.
mapped_ptr_ = std::nullopt;
transfer_buffer_ptr_ = std::nullopt;
return;
}
if (mapped_ptr_) {
DCHECK(!transfer_buffer_ptr_);
client_->IssueCreateTransferCacheEntry(
type, id, handle.shm_id(), handle.byte_offset(), mapped_ptr_->shm_id(),
mapped_ptr_->offset(), mapped_ptr_->size());
mapped_ptr_ = std::nullopt;
} else {
DCHECK(!mapped_ptr_);
client_->IssueCreateTransferCacheEntry(
type, id, handle.shm_id(), handle.byte_offset(),
transfer_buffer_ptr_->shm_id(), transfer_buffer_ptr_->offset(),
transfer_buffer_ptr_->size());
transfer_buffer_ptr_ = std::nullopt;
}
}
void ClientTransferCache::AddTransferCacheEntry(uint32_t type,
uint32_t id,
uint32_t shm_id,
uint32_t shm_offset,
uint32_t size) {
DCHECK(!mapped_ptr_);
EntryKey key(type, id);
base::AutoLock hold(lock_);
auto handle = CreateDiscardableHandle(key);
if (!handle.IsValid())
return;
client_->IssueCreateTransferCacheEntry(type, id, handle.shm_id(),
handle.byte_offset(), shm_id,
shm_offset, size);
}
void ClientTransferCache::StartTransferCacheEntry(
uint32_t type,
uint32_t id,
base::OnceCallback<void(ClientDiscardableHandle)> create_entry_cb) {
DCHECK(!mapped_ptr_);
EntryKey key(type, id);
base::AutoLock hold(lock_);
auto handle = CreateDiscardableHandle(key);
if (!handle.IsValid())
return;
// Call |create_entry_cb| while |lock_| is held so that in case another thread
// tries to lock the cache entry later, it can assume that the creation of the
// service-side cache entry has been triggered.
std::move(create_entry_cb).Run(handle);
}
ClientDiscardableHandle ClientTransferCache::CreateDiscardableHandle(
const EntryKey& key) {
ClientDiscardableHandle::Id discardable_handle_id =
discardable_manager_.CreateHandle(client_->command_buffer());
if (discardable_handle_id.is_null())
return ClientDiscardableHandle();
// We must have a valid handle here, since the id was generated above and
// should be in locked state.
ClientDiscardableHandle handle =
discardable_manager_.GetHandle(discardable_handle_id);
// Store the mapping from the given namespace/discardable_handle_id to the
// transfer cache discardable_handle_id.
DCHECK(FindDiscardableHandleId(key).is_null());
discardable_handle_id_map_.emplace(key, discardable_handle_id);
return handle;
}
bool ClientTransferCache::LockEntry(uint32_t type, uint32_t id) {
EntryKey key(type, id);
base::AutoLock hold(lock_);
auto discardable_handle_id = FindDiscardableHandleId(key);
if (discardable_handle_id.is_null())
return false;
if (discardable_manager_.LockHandle(discardable_handle_id))
return true;
// Could not lock. Entry is already deleted service side.
discardable_handle_id_map_.erase(key);
return false;
}
void ClientTransferCache::UnlockEntries(
const std::vector<std::pair<uint32_t, uint32_t>>& entries) {
base::AutoLock hold(lock_);
for (const auto& entry : entries) {
DCHECK(!FindDiscardableHandleId(entry).is_null());
client_->IssueUnlockTransferCacheEntry(entry.first, entry.second);
}
}
void ClientTransferCache::DeleteEntry(uint32_t type, uint32_t id) {
EntryKey key(type, id);
base::AutoLock hold(lock_);
auto discardable_handle_id = FindDiscardableHandleId(key);
if (discardable_handle_id.is_null())
return;
discardable_manager_.FreeHandle(discardable_handle_id);
client_->IssueDeleteTransferCacheEntry(type, id);
discardable_handle_id_map_.erase(key);
}
ClientDiscardableHandle::Id ClientTransferCache::FindDiscardableHandleId(
const EntryKey& key) {
auto id_map_it = discardable_handle_id_map_.find(key);
if (id_map_it == discardable_handle_id_map_.end())
return ClientDiscardableHandle::Id();
return id_map_it->second;
}
} // namespace gpu
|