gpu/command_buffer/client/mapped_memory.cc - chromium/src - Git at Google

 // Copyright 2011 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/mapped_memory.h"

 #include <stddef.h>
 #include <stdint.h>

 #include <functional>
 #include <utility>

 #include "base/atomic_sequence_num.h"
 #include "base/check.h"
 #include "base/memory/ptr_util.h"
 #include "base/notreached.h"
 #include "base/numerics/checked_math.h"
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/memory_dump_manager.h"
 #include "base/trace_event/trace_event.h"
 #include "gpu/command_buffer/client/cmd_buffer_helper.h"
 #include "gpu/command_buffer/client/shared_memory_limits.h"
 #include "gpu/command_buffer/common/buffer.h"

 namespace gpu {
 namespace {

 // Generates process-unique IDs to use for tracing a MappedMemoryManager's
 // chunks.
 base::AtomicSequenceNumber g_next_mapped_memory_manager_tracing_id;

 }  // namespace

 MemoryChunk::MemoryChunk(int32_t shm_id,
                          scoped_refptr<gpu::Buffer> shm,
                          CommandBufferHelper* helper)
     : shm_id_(shm_id),
       shm_(shm),
       allocator_(shm->size(), helper, shm->as_byte_span()) {}

 MemoryChunk::~MemoryChunk() = default;

 MappedMemoryManager::MappedMemoryManager(CommandBufferHelper* helper,
                                          size_t unused_memory_reclaim_limit)
     : chunk_size_multiple_(FencedAllocator::kAllocAlignment),
       helper_(helper),
       allocated_memory_(0),
       max_free_bytes_(unused_memory_reclaim_limit),
       max_allocated_bytes_(SharedMemoryLimits::kNoLimit),
       dedicated_memory_for_testing_(0),
       max_dedicated_bytes_(SharedMemoryLimits::kNoLimit),
       tracing_id_(g_next_mapped_memory_manager_tracing_id.GetNext()) {}

 MappedMemoryManager::~MappedMemoryManager() {
   // Outstanding ScopedDedicatedChunk instances hold a raw pointer back to
   // this manager; destroying it first would leave them dangling.
   DCHECK(dedicated_chunks_.empty());
   helper_->OrderingBarrier();
   CommandBuffer* cmd_buf = helper_->command_buffer();
   for (auto& chunk : chunks_) {
     cmd_buf->DestroyTransferBuffer(chunk->shm_id());
   }
 }

 base::span<uint8_t> MappedMemoryManager::Alloc(
     unsigned int size,
     int32_t* shm_id,
     unsigned int* shm_offset,
     TransferBufferAllocationOption option) {
   DCHECK(shm_id);
   DCHECK(shm_offset);
   if (size <= allocated_memory_) {
     size_t total_bytes_in_use = 0;
     // See if any of the chunks can satisfy this request.
     for (auto& chunk : chunks_) {
       chunk->FreeUnused();
       total_bytes_in_use += chunk->bytes_in_use();
       if (chunk->GetLargestFreeSizeWithoutWaiting() >= size) {
         auto span = chunk->Alloc(size);
         DCHECK(!span.empty());
         *shm_id = chunk->shm_id();
         *shm_offset = chunk->GetOffset(span.data());
         return span;
       }
     }

     // If there is a memory limit being enforced and total free
     // memory (allocated_memory_ - total_bytes_in_use) is larger than
     // the limit try waiting.
     if (max_free_bytes_ != SharedMemoryLimits::kNoLimit &&
         (allocated_memory_ - total_bytes_in_use) >= max_free_bytes_) {
       TRACE_EVENT0("gpu", "MappedMemoryManager::Alloc::wait");
       for (auto& chunk : chunks_) {
         if (chunk->GetLargestFreeSizeWithWaiting() >= size) {
           auto span = chunk->Alloc(size);
           DCHECK(!span.empty());
           *shm_id = chunk->shm_id();
           *shm_offset = chunk->GetOffset(span.data());
           return span;
         }
       }
     }
   }

   if (max_allocated_bytes_ != SharedMemoryLimits::kNoLimit &&
       (allocated_memory_ + size) > max_allocated_bytes_) {
     return {};
   }

   // Make a new chunk to satisfy the request.
   CommandBuffer* cmd_buf = helper_->command_buffer();
   base::CheckedNumeric<uint32_t> chunk_size = size;
   chunk_size = (size + chunk_size_multiple_ - 1) & ~(chunk_size_multiple_ - 1);
   uint32_t safe_chunk_size = 0;
   if (!chunk_size.AssignIfValid(&safe_chunk_size)) {
     return {};
   }

   int32_t id = -1;
   scoped_refptr<gpu::Buffer> shm = cmd_buf->CreateTransferBuffer(
       safe_chunk_size, &id, /* alignment */ 0, option);
   if (id < 0) {
     return {};
   }
   DCHECK(shm.get());
   MemoryChunk* mc = new MemoryChunk(id, shm, helper_);
   allocated_memory_ += mc->GetSize();
   chunks_.push_back(base::WrapUnique(mc));
   auto span = mc->Alloc(size);
   DCHECK(!span.empty());
   *shm_id = mc->shm_id();
   *shm_offset = mc->GetOffset(span.data());
   return span;
 }

 ScopedDedicatedChunk MappedMemoryManager::AllocDedicatedChunk(uint32_t size) {
   if (max_allocated_bytes_ != SharedMemoryLimits::kNoLimit &&
       (size > max_allocated_bytes_ - allocated_memory_)) {
     return {};
   }

   if (max_dedicated_bytes_ != SharedMemoryLimits::kNoLimit &&
       (size > max_dedicated_bytes_ - dedicated_memory_for_testing_)) {
     return {};
   }

   // Make a new chunk to guarantee offset 0.
   CommandBuffer* cmd_buf = helper_->command_buffer();
   int32_t id = -1;
   scoped_refptr<gpu::Buffer> shm = cmd_buf->CreateTransferBuffer(
       size, &id, /* alignment */ 0,
       TransferBufferAllocationOption::kReturnNullOnOOM);
   if (id < 0) {
     return {};
   }
   DCHECK(shm.get());
   base::span<uint8_t> span = shm->as_byte_span();
   allocated_memory_ += shm->size();
   dedicated_memory_for_testing_ += shm->size();
   dedicated_chunks_.emplace(id, std::move(shm));
   return ScopedDedicatedChunk(span.first(size), id, this);
 }

 void MappedMemoryManager::Free(void* pointer) {
   for (auto& chunk : chunks_) {
     if (chunk->IsInChunk(pointer)) {
       chunk->Free(pointer);
       return;
     }
   }
   NOTREACHED();
 }

 void MappedMemoryManager::RemoveDedicatedChunk(int32_t shm_id) {
   auto iter = dedicated_chunks_.find(shm_id);
   CHECK(iter != dedicated_chunks_.end());
   // DestroyTransferBuffer is sent out-of-band, so it would otherwise reach the
   // service before the commands referencing `shm_id` that are still sitting in
   // the command buffer.
   helper_->OrderingBarrier();
   helper_->command_buffer()->DestroyTransferBuffer(shm_id);
   allocated_memory_ -= iter->second->size();
   dedicated_memory_for_testing_ -= iter->second->size();
   dedicated_chunks_.erase(iter);
 }

 void MappedMemoryManager::FreePendingToken(void* pointer, int32_t token) {
   for (auto& chunk : chunks_) {
     if (chunk->IsInChunk(pointer)) {
       chunk->FreePendingToken(pointer, token);
       return;
     }
   }
   NOTREACHED();
 }

 void MappedMemoryManager::FreeUnused() {
   CommandBuffer* cmd_buf = helper_->command_buffer();
   MemoryChunkVector::iterator iter = chunks_.begin();
   while (iter != chunks_.end()) {
     MemoryChunk* chunk = (*iter).get();
     chunk->FreeUnused();
     if (chunk->bytes_in_use() == 0u) {
       if (chunk->InUseOrFreePending())
         helper_->OrderingBarrier();
       cmd_buf->DestroyTransferBuffer(chunk->shm_id());
       allocated_memory_ -= chunk->GetSize();
       iter = chunks_.erase(iter);
     } else {
       ++iter;
     }
   }
 }

 bool MappedMemoryManager::OnMemoryDump(
     const base::trace_event::MemoryDumpArgs& args,
     base::trace_event::ProcessMemoryDump* pmd) {
   using base::trace_event::MemoryAllocatorDump;
   using base::trace_event::MemoryDumpLevelOfDetail;

   if (args.level_of_detail == MemoryDumpLevelOfDetail::kBackground) {
     std::string dump_name =
         base::StringPrintf("gpu/mapped_memory/manager_0x%x", tracing_id_);
     MemoryAllocatorDump* dump = pmd->CreateAllocatorDump(dump_name);
     dump->AddScalar(MemoryAllocatorDump::kNameSize,
                     MemoryAllocatorDump::kUnitsBytes, allocated_memory_);

     // Early out, no need for more detail in a BACKGROUND dump.
     return true;
   }

   const uint64_t tracing_process_id =
       base::trace_event::MemoryDumpManager::GetInstance()
           ->GetTracingProcessId();
   auto dump_chunk = [&](int32_t shm_id, uint32_t size, uint32_t free_size,
                         gpu::Buffer* shared_memory) {
     std::string dump_name = base::StringPrintf(
         "gpu/mapped_memory/manager_0x%x/chunk_0x%x", tracing_id_, shm_id);
     MemoryAllocatorDump* dump = pmd->CreateAllocatorDump(dump_name);

     dump->AddScalar(MemoryAllocatorDump::kNameSize,
                     MemoryAllocatorDump::kUnitsBytes, size);
     dump->AddScalar("free_size", MemoryAllocatorDump::kUnitsBytes, free_size);

     auto shared_memory_guid = shared_memory->backing()->GetGUID();
     const int kImportance = 2;
     if (!shared_memory_guid.is_empty()) {
       pmd->CreateSharedMemoryOwnershipEdge(dump->guid(), shared_memory_guid,
                                            kImportance);
     } else {
       auto guid = GetBufferGUIDForTracing(tracing_process_id, shm_id);
       pmd->CreateSharedGlobalAllocatorDump(guid);
       pmd->AddOwnershipEdge(dump->guid(), guid, kImportance);
     }
   };
   for (const auto& chunk : chunks_) {
     dump_chunk(chunk->shm_id(), chunk->GetSize(), chunk->GetFreeSize(),
                chunk->shared_memory());
   }
   for (const auto& entry : dedicated_chunks_) {
     dump_chunk(entry.first, entry.second->size(), /*free_size=*/0u,
                entry.second.get());
   }

   return true;
 }

 FencedAllocator::State MappedMemoryManager::GetPointerStatusForTest(
     void* pointer,
     int32_t* token_if_pending) {
   for (auto& chunk : chunks_) {
     if (chunk->IsInChunk(pointer)) {
       return chunk->GetPointerStatusForTest(pointer, token_if_pending);
     }
   }
   return FencedAllocator::FREE;
 }

 ScopedDedicatedChunk::ScopedDedicatedChunk() = default;

 ScopedDedicatedChunk::ScopedDedicatedChunk(base::span<uint8_t> span,
                                            int32_t shm_id,
                                            MappedMemoryManager* manager)
     : span_(span), shm_id_(shm_id), manager_(manager) {}

 ScopedDedicatedChunk::ScopedDedicatedChunk(ScopedDedicatedChunk&& other)
     : span_(std::exchange(other.span_, base::raw_span<uint8_t>())),
       shm_id_(std::exchange(other.shm_id_, -1)),
       manager_(std::exchange(other.manager_, nullptr)) {}

 ScopedDedicatedChunk& ScopedDedicatedChunk::operator=(
     ScopedDedicatedChunk&& other) {
   if (this != &other) {
     Reset();
     std::swap(span_, other.span_);
     std::swap(shm_id_, other.shm_id_);
     std::swap(manager_, other.manager_);
   }
   return *this;
 }

 ScopedDedicatedChunk::~ScopedDedicatedChunk() {
   Reset();
 }

 void ScopedDedicatedChunk::Reset() {
   if (manager_) {
     span_ = {};
     manager_->RemoveDedicatedChunk(shm_id_);
     shm_id_ = -1;
     manager_ = nullptr;
   }
 }

 void ScopedMappedMemoryPtr::Release() {
   if (valid()) {
     mapped_memory_manager_->FreePendingToken(buffer_.data(),
                                              helper_->InsertToken());
     buffer_ = {};
     shm_id_ = 0;
     shm_offset_ = 0;

     if (flush_after_release_) {
       helper_->CommandBufferHelper::Flush();
     }
   }
 }

 void ScopedMappedMemoryPtr::Reset(uint32_t new_size) {
   Release();

   if (new_size) {
     buffer_ = mapped_memory_manager_->Alloc(new_size, &shm_id_, &shm_offset_);
   }
 }

 }  // namespace gpu
	// Copyright 2011 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/mapped_memory.h"

	#include <stddef.h>
	#include <stdint.h>

	#include <functional>
	#include <utility>

	#include "base/atomic_sequence_num.h"
	#include "base/check.h"
	#include "base/memory/ptr_util.h"
	#include "base/notreached.h"
	#include "base/numerics/checked_math.h"
	#include "base/strings/stringprintf.h"
	#include "base/trace_event/memory_dump_manager.h"
	#include "base/trace_event/trace_event.h"
	#include "gpu/command_buffer/client/cmd_buffer_helper.h"
	#include "gpu/command_buffer/client/shared_memory_limits.h"
	#include "gpu/command_buffer/common/buffer.h"

	namespace gpu {
	namespace {

	// Generates process-unique IDs to use for tracing a MappedMemoryManager's
	// chunks.
	base::AtomicSequenceNumber g_next_mapped_memory_manager_tracing_id;

	} // namespace

	MemoryChunk::MemoryChunk(int32_t shm_id,
	scoped_refptr<gpu::Buffer> shm,
	CommandBufferHelper* helper)
	: shm_id_(shm_id),
	shm_(shm),
	allocator_(shm->size(), helper, shm->as_byte_span()) {}

	MemoryChunk::~MemoryChunk() = default;

	MappedMemoryManager::MappedMemoryManager(CommandBufferHelper* helper,
	size_t unused_memory_reclaim_limit)
	: chunk_size_multiple_(FencedAllocator::kAllocAlignment),
	helper_(helper),
	allocated_memory_(0),
	max_free_bytes_(unused_memory_reclaim_limit),
	max_allocated_bytes_(SharedMemoryLimits::kNoLimit),
	dedicated_memory_for_testing_(0),
	max_dedicated_bytes_(SharedMemoryLimits::kNoLimit),
	tracing_id_(g_next_mapped_memory_manager_tracing_id.GetNext()) {}

	MappedMemoryManager::~MappedMemoryManager() {
	// Outstanding ScopedDedicatedChunk instances hold a raw pointer back to
	// this manager; destroying it first would leave them dangling.
	DCHECK(dedicated_chunks_.empty());
	helper_->OrderingBarrier();
	CommandBuffer* cmd_buf = helper_->command_buffer();
	for (auto& chunk : chunks_) {
	cmd_buf->DestroyTransferBuffer(chunk->shm_id());
	}
	}

	base::span<uint8_t> MappedMemoryManager::Alloc(
	unsigned int size,
	int32_t* shm_id,
	unsigned int* shm_offset,
	TransferBufferAllocationOption option) {
	DCHECK(shm_id);
	DCHECK(shm_offset);
	if (size <= allocated_memory_) {
	size_t total_bytes_in_use = 0;
	// See if any of the chunks can satisfy this request.
	for (auto& chunk : chunks_) {
	chunk->FreeUnused();
	total_bytes_in_use += chunk->bytes_in_use();
	if (chunk->GetLargestFreeSizeWithoutWaiting() >= size) {
	auto span = chunk->Alloc(size);
	DCHECK(!span.empty());
	*shm_id = chunk->shm_id();
	*shm_offset = chunk->GetOffset(span.data());
	return span;
	}
	}

	// If there is a memory limit being enforced and total free
	// memory (allocated_memory_ - total_bytes_in_use) is larger than
	// the limit try waiting.
	if (max_free_bytes_ != SharedMemoryLimits::kNoLimit &&
	(allocated_memory_ - total_bytes_in_use) >= max_free_bytes_) {
	TRACE_EVENT0("gpu", "MappedMemoryManager::Alloc::wait");
	for (auto& chunk : chunks_) {
	if (chunk->GetLargestFreeSizeWithWaiting() >= size) {
	auto span = chunk->Alloc(size);
	DCHECK(!span.empty());
	*shm_id = chunk->shm_id();
	*shm_offset = chunk->GetOffset(span.data());
	return span;
	}
	}
	}
	}

	if (max_allocated_bytes_ != SharedMemoryLimits::kNoLimit &&
	(allocated_memory_ + size) > max_allocated_bytes_) {
	return {};
	}

	// Make a new chunk to satisfy the request.
	CommandBuffer* cmd_buf = helper_->command_buffer();
	base::CheckedNumeric<uint32_t> chunk_size = size;
	chunk_size = (size + chunk_size_multiple_ - 1) & ~(chunk_size_multiple_ - 1);
	uint32_t safe_chunk_size = 0;
	if (!chunk_size.AssignIfValid(&safe_chunk_size)) {
	return {};
	}

	int32_t id = -1;
	scoped_refptr<gpu::Buffer> shm = cmd_buf->CreateTransferBuffer(
	safe_chunk_size, &id, /* alignment */ 0, option);
	if (id < 0) {
	return {};
	}
	DCHECK(shm.get());
	MemoryChunk* mc = new MemoryChunk(id, shm, helper_);
	allocated_memory_ += mc->GetSize();
	chunks_.push_back(base::WrapUnique(mc));
	auto span = mc->Alloc(size);
	DCHECK(!span.empty());
	*shm_id = mc->shm_id();
	*shm_offset = mc->GetOffset(span.data());
	return span;
	}

	ScopedDedicatedChunk MappedMemoryManager::AllocDedicatedChunk(uint32_t size) {
	if (max_allocated_bytes_ != SharedMemoryLimits::kNoLimit &&
	(size > max_allocated_bytes_ - allocated_memory_)) {
	return {};
	}

	if (max_dedicated_bytes_ != SharedMemoryLimits::kNoLimit &&
	(size > max_dedicated_bytes_ - dedicated_memory_for_testing_)) {
	return {};
	}

	// Make a new chunk to guarantee offset 0.
	CommandBuffer* cmd_buf = helper_->command_buffer();
	int32_t id = -1;
	scoped_refptr<gpu::Buffer> shm = cmd_buf->CreateTransferBuffer(
	size, &id, /* alignment */ 0,
	TransferBufferAllocationOption::kReturnNullOnOOM);
	if (id < 0) {
	return {};
	}
	DCHECK(shm.get());
	base::span<uint8_t> span = shm->as_byte_span();
	allocated_memory_ += shm->size();
	dedicated_memory_for_testing_ += shm->size();
	dedicated_chunks_.emplace(id, std::move(shm));
	return ScopedDedicatedChunk(span.first(size), id, this);
	}

	void MappedMemoryManager::Free(void* pointer) {
	for (auto& chunk : chunks_) {
	if (chunk->IsInChunk(pointer)) {
	chunk->Free(pointer);
	return;
	}
	}
	NOTREACHED();
	}

	void MappedMemoryManager::RemoveDedicatedChunk(int32_t shm_id) {
	auto iter = dedicated_chunks_.find(shm_id);
	CHECK(iter != dedicated_chunks_.end());
	// DestroyTransferBuffer is sent out-of-band, so it would otherwise reach the
	// service before the commands referencing `shm_id` that are still sitting in
	// the command buffer.
	helper_->OrderingBarrier();
	helper_->command_buffer()->DestroyTransferBuffer(shm_id);
	allocated_memory_ -= iter->second->size();
	dedicated_memory_for_testing_ -= iter->second->size();
	dedicated_chunks_.erase(iter);
	}

	void MappedMemoryManager::FreePendingToken(void* pointer, int32_t token) {
	for (auto& chunk : chunks_) {
	if (chunk->IsInChunk(pointer)) {
	chunk->FreePendingToken(pointer, token);
	return;
	}
	}
	NOTREACHED();
	}

	void MappedMemoryManager::FreeUnused() {
	CommandBuffer* cmd_buf = helper_->command_buffer();
	MemoryChunkVector::iterator iter = chunks_.begin();
	while (iter != chunks_.end()) {
	MemoryChunk* chunk = (*iter).get();
	chunk->FreeUnused();
	if (chunk->bytes_in_use() == 0u) {
	if (chunk->InUseOrFreePending())
	helper_->OrderingBarrier();
	cmd_buf->DestroyTransferBuffer(chunk->shm_id());
	allocated_memory_ -= chunk->GetSize();
	iter = chunks_.erase(iter);
	} else {
	++iter;
	}
	}
	}

	bool MappedMemoryManager::OnMemoryDump(
	const base::trace_event::MemoryDumpArgs& args,
	base::trace_event::ProcessMemoryDump* pmd) {
	using base::trace_event::MemoryAllocatorDump;
	using base::trace_event::MemoryDumpLevelOfDetail;

	if (args.level_of_detail == MemoryDumpLevelOfDetail::kBackground) {
	std::string dump_name =
	base::StringPrintf("gpu/mapped_memory/manager_0x%x", tracing_id_);
	MemoryAllocatorDump* dump = pmd->CreateAllocatorDump(dump_name);
	dump->AddScalar(MemoryAllocatorDump::kNameSize,
	MemoryAllocatorDump::kUnitsBytes, allocated_memory_);

	// Early out, no need for more detail in a BACKGROUND dump.
	return true;
	}

	const uint64_t tracing_process_id =
	base::trace_event::MemoryDumpManager::GetInstance()
	->GetTracingProcessId();
	auto dump_chunk = [&](int32_t shm_id, uint32_t size, uint32_t free_size,
	gpu::Buffer* shared_memory) {
	std::string dump_name = base::StringPrintf(
	"gpu/mapped_memory/manager_0x%x/chunk_0x%x", tracing_id_, shm_id);
	MemoryAllocatorDump* dump = pmd->CreateAllocatorDump(dump_name);

	dump->AddScalar(MemoryAllocatorDump::kNameSize,
	MemoryAllocatorDump::kUnitsBytes, size);
	dump->AddScalar("free_size", MemoryAllocatorDump::kUnitsBytes, free_size);

	auto shared_memory_guid = shared_memory->backing()->GetGUID();
	const int kImportance = 2;
	if (!shared_memory_guid.is_empty()) {
	pmd->CreateSharedMemoryOwnershipEdge(dump->guid(), shared_memory_guid,
	kImportance);
	} else {
	auto guid = GetBufferGUIDForTracing(tracing_process_id, shm_id);
	pmd->CreateSharedGlobalAllocatorDump(guid);
	pmd->AddOwnershipEdge(dump->guid(), guid, kImportance);
	}
	};
	for (const auto& chunk : chunks_) {
	dump_chunk(chunk->shm_id(), chunk->GetSize(), chunk->GetFreeSize(),
	chunk->shared_memory());
	}
	for (const auto& entry : dedicated_chunks_) {
	dump_chunk(entry.first, entry.second->size(), /free_size=/0u,
	entry.second.get());
	}

	return true;
	}

	FencedAllocator::State MappedMemoryManager::GetPointerStatusForTest(
	void* pointer,
	int32_t* token_if_pending) {
	for (auto& chunk : chunks_) {
	if (chunk->IsInChunk(pointer)) {
	return chunk->GetPointerStatusForTest(pointer, token_if_pending);
	}
	}
	return FencedAllocator::FREE;
	}

	ScopedDedicatedChunk::ScopedDedicatedChunk() = default;

	ScopedDedicatedChunk::ScopedDedicatedChunk(base::span<uint8_t> span,
	int32_t shm_id,
	MappedMemoryManager* manager)
	: span_(span), shm_id_(shm_id), manager_(manager) {}

	ScopedDedicatedChunk::ScopedDedicatedChunk(ScopedDedicatedChunk&& other)
	: span_(std::exchange(other.span_, base::raw_span<uint8_t>())),
	shm_id_(std::exchange(other.shm_id_, -1)),
	manager_(std::exchange(other.manager_, nullptr)) {}

	ScopedDedicatedChunk& ScopedDedicatedChunk::operator=(
	ScopedDedicatedChunk&& other) {
	if (this != &other) {
	Reset();
	std::swap(span_, other.span_);
	std::swap(shm_id_, other.shm_id_);
	std::swap(manager_, other.manager_);
	}
	return *this;
	}

	ScopedDedicatedChunk::~ScopedDedicatedChunk() {
	Reset();
	}

	void ScopedDedicatedChunk::Reset() {
	if (manager_) {
	span_ = {};
	manager_->RemoveDedicatedChunk(shm_id_);
	shm_id_ = -1;
	manager_ = nullptr;
	}
	}

	void ScopedMappedMemoryPtr::Release() {
	if (valid()) {
	mapped_memory_manager_->FreePendingToken(buffer_.data(),
	helper_->InsertToken());
	buffer_ = {};
	shm_id_ = 0;
	shm_offset_ = 0;

	if (flush_after_release_) {
	helper_->CommandBufferHelper::Flush();
	}
	}
	}

	void ScopedMappedMemoryPtr::Reset(uint32_t new_size) {
	Release();

	if (new_size) {
	buffer_ = mapped_memory_manager_->Alloc(new_size, &shm_id_, &shm_offset_);
	}
	}

	} // namespace gpu