mirror of
https://github.com/encounter/dawn-cmake.git
synced 2025-07-22 21:16:00 +00:00
0d20b2b2b7
Since the ZeroBuffer (4MB) is released in DestroyImpl, it sticks around in the resource allocation manager, along with a large amount of unneeded tracking data structures. To further reduce memory consumption after developers Destroy, we now delete the ResourceAllocationManager in DestroyImpl and ensure any remaining objects go through the same shutdown path as normal usage. Placed resources must be released before any heaps they reside in. Bug: chromium:1377789 Change-Id: I7a0f6ad2fdcc60bfe5a51586c8a620f4862c38a5 Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/111601 Reviewed-by: Austin Eng <enga@chromium.org> Reviewed-by: Corentin Wallez <cwallez@chromium.org> Commit-Queue: Rafael Cintron <rafael.cintron@microsoft.com> Kokoro: Kokoro <noreply+kokoro@google.com>
66 lines
2.1 KiB
C++
66 lines
2.1 KiB
C++
// Copyright 2020 The Dawn Authors
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
#include "dawn/native/PooledResourceMemoryAllocator.h"
|
|
|
|
#include <utility>
|
|
|
|
#include "dawn/native/Device.h"
|
|
|
|
namespace dawn::native {
|
|
|
|
PooledResourceMemoryAllocator::PooledResourceMemoryAllocator(ResourceHeapAllocator* heapAllocator)
|
|
: mHeapAllocator(heapAllocator) {}
|
|
|
|
PooledResourceMemoryAllocator::~PooledResourceMemoryAllocator() {
|
|
ASSERT(mPool.empty());
|
|
}
|
|
|
|
void PooledResourceMemoryAllocator::DestroyPool() {
|
|
for (auto& resourceHeap : mPool) {
|
|
ASSERT(resourceHeap != nullptr);
|
|
mHeapAllocator->DeallocateResourceHeap(std::move(resourceHeap));
|
|
}
|
|
|
|
mPool.clear();
|
|
}
|
|
|
|
ResultOrError<std::unique_ptr<ResourceHeapBase>>
|
|
PooledResourceMemoryAllocator::AllocateResourceHeap(uint64_t size) {
|
|
// Pooled memory is LIFO because memory can be evicted by LRU. However, this means
|
|
// pooling is disabled in-frame when the memory is still pending. For high in-frame
|
|
// memory users, FIFO might be preferable when memory consumption is a higher priority.
|
|
std::unique_ptr<ResourceHeapBase> memory;
|
|
if (!mPool.empty()) {
|
|
memory = std::move(mPool.front());
|
|
mPool.pop_front();
|
|
}
|
|
|
|
if (memory == nullptr) {
|
|
DAWN_TRY_ASSIGN(memory, mHeapAllocator->AllocateResourceHeap(size));
|
|
}
|
|
|
|
return std::move(memory);
|
|
}
|
|
|
|
void PooledResourceMemoryAllocator::DeallocateResourceHeap(
|
|
std::unique_ptr<ResourceHeapBase> allocation) {
|
|
mPool.push_front(std::move(allocation));
|
|
}
|
|
|
|
uint64_t PooledResourceMemoryAllocator::GetPoolSizeForTesting() const {
|
|
return mPool.size();
|
|
}
|
|
} // namespace dawn::native
|