Files
o3de/Gems/Atom/RHI/Vulkan/Code/Source/RHI/ImagePool.cpp
T

132 lines
5.3 KiB
C++

/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#include "Atom_RHI_Vulkan_precompiled.h"
#include <Atom/RHI/RHISystemInterface.h>
#include <Atom/RHI.Reflect/PlatformLimitsDescriptor.h>
#include <Atom/RHI.Reflect/ImageDescriptor.h>
#include <RHI/Device.h>
#include <RHI/Image.h>
#include <RHI/ImagePool.h>
#include <RHI/ImagePoolResolver.h>
namespace AZ
{
namespace Vulkan
{
RHI::Ptr<ImagePool> ImagePool::Create()
{
return aznew ImagePool();
}
void ImagePool::GarbageCollect()
{
m_memoryAllocator.GarbageCollect();
}
void ImagePool::OnFrameEnd()
{
GarbageCollect();
Base::OnFrameEnd();
}
RHI::ResultCode ImagePool::InitInternal(RHI::Device& deviceBase, const RHI::ImagePoolDescriptor& descriptorBase)
{
auto& device = static_cast<Device&>(deviceBase);
VkDeviceSize imagePageSizeInBytes = RHI::RHISystemInterface::Get()->GetPlatformLimitsDescriptor()->m_platformDefaultValues.m_imagePoolPageSizeInBytes;
RHI::HeapMemoryLevel heapMemoryLevel = RHI::HeapMemoryLevel::Device;
if (const auto* descriptor = azrtti_cast<const ImagePoolDescriptor*>(&descriptorBase))
{
imagePageSizeInBytes = descriptor->m_imagePageSizeInBytes;
heapMemoryLevel = descriptor->m_heapMemoryLevel;
}
uint32_t memoryTypeBits = 0;
{
// Use an image descriptor of size 1x1 to get the memory requirements.
RHI::ImageDescriptor imageDescriptor = RHI::ImageDescriptor::Create2D(descriptorBase.m_bindFlags, 1, 1, RHI::Format::R8G8B8A8_UNORM);
VkMemoryRequirements memRequirements = device.GetImageMemoryRequirements(imageDescriptor);
memoryTypeBits = memRequirements.memoryTypeBits;
}
RHI::HeapMemoryUsage& heapMemoryUsage = m_memoryUsage.GetHeapMemoryUsage(heapMemoryLevel);
MemoryAllocator::Descriptor memoryAllocDescriptor;
memoryAllocDescriptor.m_device = &device;
memoryAllocDescriptor.m_pageSizeInBytes = static_cast<size_t>(imagePageSizeInBytes);
memoryAllocDescriptor.m_heapMemoryLevel = heapMemoryLevel;
memoryAllocDescriptor.m_memoryTypeBits = memoryTypeBits;
memoryAllocDescriptor.m_getHeapMemoryUsageFunction = [&]() { return &heapMemoryUsage; };
memoryAllocDescriptor.m_recycleOnCollect = true;
memoryAllocDescriptor.m_collectLatency = RHI::Limits::Device::FrameCountMax;
m_memoryAllocator.Init(memoryAllocDescriptor);
SetResolver(AZStd::make_unique<ImagePoolResolver>(static_cast<Device&>(device)));
return RHI::ResultCode::Success;
}
RHI::ResultCode ImagePool::InitImageInternal(const RHI::ImageInitRequest& request)
{
auto& device = static_cast<Device&>(GetDevice());
Image* image = static_cast<Image*>(request.m_image);
AZ_Assert(image, "Null image during initialization.");
RHI::ImageDescriptor imageDescriptor = request.m_descriptor;
// Add copy write flag since images can be copy into or clear using a command list.
imageDescriptor.m_bindFlags |= RHI::ImageBindFlags::CopyWrite;
RHI::ResultCode result = image->Init(device, imageDescriptor);
RETURN_RESULT_IF_UNSUCCESSFUL(result);
MemoryView memoryView = m_memoryAllocator.Allocate(image->m_memoryRequirements.size, image->m_memoryRequirements.alignment);
result = image->BindMemoryView(
memoryView,
m_memoryAllocator.GetDescriptor().m_heapMemoryLevel);
RETURN_RESULT_IF_UNSUCCESSFUL(result);
image->SetResidentSizeInBytes(memoryView.GetSize());
return result;
}
RHI::ResultCode ImagePool::UpdateImageContentsInternal(const RHI::ImageUpdateRequest& request)
{
size_t bytesTransferred = 0;
RHI::ResultCode resultCode = static_cast<ImagePoolResolver*>(GetResolver())->UpdateImage(request, bytesTransferred);
if (resultCode == RHI::ResultCode::Success)
{
m_memoryUsage.m_transferPull.m_bytesPerFrame += bytesTransferred;
}
return resultCode;
}
void ImagePool::ShutdownInternal()
{
m_memoryAllocator.Shutdown();
}
void ImagePool::ShutdownResourceInternal(RHI::Resource& resourceBase)
{
auto& image = static_cast<Image&>(resourceBase);
m_memoryAllocator.DeAllocate(image.m_memoryView);
image.m_memoryView = MemoryView();
image.Invalidate();
}
void ImagePool::SetNameInternal(const AZStd::string_view& name)
{
m_memoryAllocator.SetName(AZ::Name{ name });
}
}
}