Flax/FlaxEngine
3
0
Fork 0
Code Issues Pull Requests Releases Activity

Add D3D12MemoryAllocator for resource allocations on DX12

Browse Source 
v3.1.0
This commit is contained in:
Wojciech Figat
2026-04-23 17:12:26 +02:00
parent 84b53bb9c8
commit 33617a702a
14 changed files with 14028 additions and 73 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Source/Engine/GraphicsDevice/DirectX/DX12/GPUBufferDX12.cpp
+8 -17
View File
@@ -8,6 +8,7 @@
#include "Engine/Graphics/PixelFormatExtensions.h"
#include "Engine/Graphics/RenderTask.h"
#include "Engine/Graphics/Async/Tasks/GPUUploadBufferTask.h"
#include <ThirdParty/D3D12MemoryAllocator/D3D12MemAlloc.h>
void GPUBufferViewDX12::SetSRV(D3D12_SHADER_RESOURCE_VIEW_DESC& srvDesc)
{
@@ -115,34 +116,24 @@ bool GPUBufferDX12::OnInit()
resourceDesc.Flags |= D3D12XBOX_RESOURCE_FLAG_ALLOW_INDIRECT_BUFFER;
#endif
// Create allocation description
D3D12_HEAP_PROPERTIES heapProperties;
// Create resource
D3D12MA::ALLOCATION_DESC allocationDesc = {};
switch (_desc.Usage)
{
case GPUResourceUsage::StagingUpload:
case GPUResourceUsage::Staging:
heapProperties.Type = D3D12_HEAP_TYPE_UPLOAD;
allocationDesc.HeapType = D3D12_HEAP_TYPE_UPLOAD;
break;
case GPUResourceUsage::StagingReadback:
heapProperties.Type = D3D12_HEAP_TYPE_READBACK;
allocationDesc.HeapType = D3D12_HEAP_TYPE_READBACK;
break;
default:
heapProperties.Type = D3D12_HEAP_TYPE_DEFAULT;
allocationDesc.HeapType = D3D12_HEAP_TYPE_DEFAULT;
}
heapProperties.CPUPageProperty = D3D12_CPU_PAGE_PROPERTY_UNKNOWN;
heapProperties.MemoryPoolPreference = D3D12_MEMORY_POOL_UNKNOWN;
heapProperties.CreationNodeMask = 1;
heapProperties.VisibleNodeMask = 1;
// Create resource
ID3D12Resource* resource;
#if PLATFORM_WINDOWS
D3D12_HEAP_FLAGS heapFlags = EnumHasAnyFlags(_desc.Flags, GPUBufferFlags::VertexBuffer | GPUBufferFlags::IndexBuffer) || _desc.InitData ? D3D12_HEAP_FLAG_CREATE_NOT_ZEROED : D3D12_HEAP_FLAG_NONE;
#else
D3D12_HEAP_FLAGS heapFlags = D3D12_HEAP_FLAG_NONE;
#endif
D3D12_RESOURCE_STATES initialState = D3D12_RESOURCE_STATE_COMMON;
VALIDATE_DIRECTX_CALL(_device->GetDevice()->CreateCommittedResource(&heapProperties, heapFlags, &resourceDesc, initialState, nullptr, IID_PPV_ARGS(&resource)));
HRESULT result = _device->Allocator->CreateResource(&allocationDesc, &resourceDesc, initialState, nullptr, &_allocation, IID_PPV_ARGS(&resource));
LOG_DIRECTX_RESULT_WITH_RETURN(result, true);
// Set state
initResource(resource, initialState, 1);
Source/Engine/GraphicsDevice/DirectX/DX12/GPUContextDX12.cpp
+5
View File
@@ -310,6 +310,11 @@ void GPUContextDX12::Reset()
_commandList->IASetVertexBuffers(GPU_MAX_VB_BINDED, 1, &dummyVBView);
ForceRebindDescriptors();
// Discard resources not created during rendering
for (auto* resource : _device->PendingResourceDiscards)
_commandList->DiscardResource(resource, nullptr);
_device->PendingResourceDiscards.Clear();
}
uint64 GPUContextDX12::Execute(bool waitForCompletion)
Source/Engine/GraphicsDevice/DirectX/DX12/GPUDeviceDX12.cpp
+35 -5
View File
@@ -29,6 +29,10 @@
#include "Engine/Threading/Threading.h"
#include "CommandSignatureDX12.h"
// Inline into this module to leave it as a header-only
#include <ThirdParty/D3D12MemoryAllocator/D3D12MemAlloc.h>
#include <ThirdParty/D3D12MemoryAllocator/D3D12MemAlloc.cpp>
static bool CheckDX12Support(IDXGIAdapter* adapter)
{
#if PLATFORM_XBOX_SCARLETT || PLATFORM_XBOX_ONE
@@ -43,6 +47,17 @@ static bool CheckDX12Support(IDXGIAdapter* adapter)
#endif
}
void* D3D12MA_Allocate(size_t Size, size_t Alignment, void* pPrivateData)
{
PROFILE_MEM(GraphicsCommands);
return Platform::Allocate(Size, Alignment);
}
void D3D12MA_Free(void* pMemory, void* pPrivateData)
{
Platform::Free(pMemory);
}
GPUVertexLayoutDX12::GPUVertexLayoutDX12(GPUDeviceDX12* device, const Elements& elements, bool explicitOffsets)
: GPUResourceDX12<GPUVertexLayout>(device, StringView::Empty)
, InputElementsCount(elements.Count())
@@ -664,12 +679,13 @@ bool GPUDeviceDX12::Init()
// Create DirectX device
VALIDATE_DIRECTX_CALL(D3D12CreateDevice(adapter, D3D_FEATURE_LEVEL_11_0, IID_PPV_ARGS(&_device)));
HRESULT hr;
#if PLATFORM_WINDOWS
// Detect RenderDoc usage (UUID {A7AA6116-9C8D-4BBA-9083-B4D816B71B78})
IUnknown* unknown = nullptr;
const GUID uuidRenderDoc = { 0xa7aa6116, 0x9c8d, 0x4bba, { 0x90, 0x83, 0xb4, 0xd8, 0x16, 0xb7, 0x1b, 0x78 } };
HRESULT hr = _device->QueryInterface(uuidRenderDoc, (void**)&unknown);
hr = _device->QueryInterface(uuidRenderDoc, (void**)&unknown);
if (SUCCEEDED(hr) && unknown)
{
IsDebugToolAttached = true;
@@ -699,8 +715,8 @@ bool GPUDeviceDX12::Init()
// Debug Layer
#if GPU_ENABLE_DIAGNOSTICS
ComPtr<ID3D12InfoQueue> infoQueue;
HRESULT result = _device->QueryInterface(IID_PPV_ARGS(&infoQueue));
LOG_DIRECTX_RESULT(result);
hr = _device->QueryInterface(IID_PPV_ARGS(&infoQueue));
LOG_DIRECTX_RESULT(hr);
if (infoQueue)
{
D3D12_INFO_QUEUE_FILTER filter;
@@ -809,6 +825,16 @@ bool GPUDeviceDX12::Init()
#endif
// Setup resources
D3D12MA::ALLOCATION_CALLBACKS allocationCallbacks = {};
allocationCallbacks.pAllocate = &D3D12MA_Allocate;
allocationCallbacks.pFree = &D3D12MA_Free;
D3D12MA::ALLOCATOR_DESC allocatorDesc = {};
allocatorDesc.pDevice = _device;
allocatorDesc.pAdapter = adapter;
allocatorDesc.Flags = D3D12MA_RECOMMENDED_ALLOCATOR_FLAGS;
allocatorDesc.pAllocationCallbacks = &allocationCallbacks;
hr = D3D12MA::CreateAllocator(&allocatorDesc, &Allocator);
LOG_DIRECTX_RESULT_WITH_RETURN(hr, true);
_commandQueue = New<CommandQueueDX12>(this, D3D12_COMMAND_LIST_TYPE_DIRECT);
if (_commandQueue->Init())
return true;
@@ -1050,6 +1076,7 @@ void GPUDeviceDX12::Dispose()
SAFE_DELETE(DrawIndirectCommandSignature);
SAFE_DELETE(_mainContext);
SAFE_DELETE(_commandQueue);
SAFE_RELEASE(Allocator);
// Clear DirectX stuff
SAFE_DELETE(_adapter);
@@ -1140,16 +1167,17 @@ GPUConstantBuffer* GPUDeviceDX12::CreateConstantBuffer(uint32 size, const String
return New<GPUConstantBufferDX12>(this, size, name);
}
void GPUDeviceDX12::AddResourceToLateRelease(IGraphicsUnknown* resource, uint32 safeFrameCount)
void GPUDeviceDX12::AddResourceToLateRelease(IGraphicsUnknown* resource, D3D12MA::Allocation* allocation, uint32 safeFrameCount)
{
if (resource == nullptr)
return;
ScopeLock lock(_res2DisposeLock);
// Add to the list
DisposeResourceEntry entry;
entry.Resource = resource;
entry.Allocation = allocation;
entry.TargetFrame = Engine::FrameCount + safeFrameCount;
_res2Dispose.Add(entry);
}
@@ -1169,6 +1197,8 @@ void GPUDeviceDX12::updateRes2Dispose()
const DisposeResourceEntry& entry = _res2Dispose[i];
if (entry.TargetFrame <= currentFrame)
{
if (entry.Allocation)
entry.Allocation->Release();
auto refs = entry.Resource->Release();
if (refs != 0)
{
Source/Engine/GraphicsDevice/DirectX/DX12/GPUDeviceDX12.h
+14 -1
View File
@@ -25,6 +25,16 @@ class GPUSwapChainDX12;
class CommandQueueDX12;
class CommandSignatureDX12;
// D3D12MemoryAllocator config
namespace D3D12MA
{
class Allocator;
class Allocation;
};
#if !BUILD_DEBUG
#define D3D12MA_ASSERT(cond)
#endif
/// <summary>
/// Implementation of Graphics Device for DirectX 12 rendering system
/// </summary>
@@ -38,6 +48,7 @@ private:
struct DisposeResourceEntry
{
IGraphicsUnknown* Resource;
D3D12MA::Allocation* Allocation;
uint64 TargetFrame;
};
@@ -71,6 +82,7 @@ public:
~GPUDeviceDX12();
public:
D3D12MA::Allocator* Allocator = nullptr;
UploadBufferDX12 UploadBuffer;
bool AllowTearing = false;
CommandSignatureDX12* DispatchIndirectCommandSignature = nullptr;
@@ -78,6 +90,7 @@ public:
CommandSignatureDX12* DrawIndirectCommandSignature = nullptr;
GPUBuffer* DummyVB = nullptr;
Array<QueryHeapDX12*, InlinedAllocation<8>> QueryHeaps;
Array<ID3D12Resource*> PendingResourceDiscards;
D3D12_CPU_DESCRIPTOR_HANDLE NullSRV(D3D12_SRV_DIMENSION dimension) const;
D3D12_CPU_DESCRIPTOR_HANDLE NullUAV() const;
@@ -154,7 +167,7 @@ public:
public:
// Add resource to late release service (will be released after 'safeFrameCount' frames)
void AddResourceToLateRelease(IGraphicsUnknown* resource, uint32 safeFrameCount = DX12_RESOURCE_DELETE_SAFE_FRAMES_COUNT);
void AddResourceToLateRelease(IGraphicsUnknown* resource, D3D12MA::Allocation* allocation = nullptr, uint32 safeFrameCount = DX12_RESOURCE_DELETE_SAFE_FRAMES_COUNT);
static FORCE_INLINE uint32 GetMaxMSAAQuality(uint32 sampleCount)
{
Source/Engine/GraphicsDevice/DirectX/DX12/GPUTextureDX12.cpp
+21 -29
View File
@@ -3,9 +3,11 @@
#if GRAPHICS_API_DIRECTX12
#include "GPUTextureDX12.h"
#include "GPUContextDX12.h"
#include "Engine/GraphicsDevice/DirectX/RenderToolsDX.h"
#include "Engine/Graphics/PixelFormatExtensions.h"
#include "Engine/Graphics/Textures/TextureData.h"
#include <ThirdParty/D3D12MemoryAllocator/D3D12MemAlloc.h>
bool GPUTextureDX12::GetData(int32 arrayIndex, int32 mipMapIndex, TextureMipData& data, uint32 mipRowPitch)
{
@@ -48,8 +50,6 @@ bool GPUTextureDX12::GetData(int32 arrayIndex, int32 mipMapIndex, TextureMipData
bool GPUTextureDX12::OnInit()
{
ID3D12Resource* resource;
// Cache formats
const PixelFormat format = Format();
const PixelFormat typelessFormat = PixelFormatExtensions::MakeTypeless(format);
const DXGI_FORMAT dxgiFormat = RenderToolsDX::ToDxgiFormat(typelessFormat);
@@ -57,25 +57,17 @@ bool GPUTextureDX12::OnInit()
_dxgiFormatSRV = RenderToolsDX::ToDxgiFormat(PixelFormatExtensions::FindShaderResourceFormat(format, _sRGB));
_dxgiFormatRTV = _dxgiFormatSRV;
_dxgiFormatUAV = RenderToolsDX::ToDxgiFormat(PixelFormatExtensions::FindUnorderedAccessFormat(format));
// Cache properties
auto device = _device->GetDevice();
bool useSRV = IsShaderResource();
bool useDSV = IsDepthStencil();
bool useRTV = IsRenderTarget();
bool useUAV = IsUnorderedAccess();
int32 depthOrArraySize = IsVolume() ? Depth() : ArraySize();
D3D12MA::ALLOCATION_DESC allocationDesc = {};
if (IsStaging())
{
// Initialize as a buffer
const int32 totalSize = ComputeBufferTotalSize(D3D12_TEXTURE_DATA_PITCH_ALIGNMENT, D3D12_TEXTURE_DATA_PLACEMENT_ALIGNMENT);
D3D12_HEAP_PROPERTIES heapProperties;
heapProperties.Type = D3D12_HEAP_TYPE_READBACK;
heapProperties.CPUPageProperty = D3D12_CPU_PAGE_PROPERTY_UNKNOWN;
heapProperties.MemoryPoolPreference = D3D12_MEMORY_POOL_UNKNOWN;
heapProperties.CreationNodeMask = 1;
heapProperties.VisibleNodeMask = 1;
D3D12_RESOURCE_DESC resourceDesc;
resourceDesc.Dimension = D3D12_RESOURCE_DIMENSION_BUFFER;
resourceDesc.Alignment = 0;
@@ -88,7 +80,8 @@ bool GPUTextureDX12::OnInit()
resourceDesc.SampleDesc.Quality = 0;
resourceDesc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR;
resourceDesc.Flags = D3D12_RESOURCE_FLAG_NONE;
auto result = device->CreateCommittedResource(&heapProperties, D3D12_HEAP_FLAG_NONE, &resourceDesc, D3D12_RESOURCE_STATE_COPY_DEST, nullptr, IID_PPV_ARGS(&resource));
allocationDesc.HeapType = D3D12_HEAP_TYPE_READBACK;
HRESULT result = _device->Allocator->CreateResource(&allocationDesc, &resourceDesc, D3D12_RESOURCE_STATE_COPY_DEST, nullptr, &_allocation, IID_PPV_ARGS(&resource));
LOG_DIRECTX_RESULT_WITH_RETURN(result, true);
initResource(resource, D3D12_RESOURCE_STATE_COPY_DEST, 1);
DX_SET_DEBUG_NAME(_resource, GetName());
@@ -96,9 +89,8 @@ bool GPUTextureDX12::OnInit()
return false;
}
D3D12_RESOURCE_STATES initialState = D3D12_RESOURCE_STATE_COMMON;
// Create texture description
D3D12_RESOURCE_STATES initialState = D3D12_RESOURCE_STATE_COMMON;
D3D12_RESOURCE_DESC resourceDesc;
resourceDesc.MipLevels = _desc.MipLevels;
resourceDesc.Format = dxgiFormat;
@@ -128,16 +120,10 @@ bool GPUTextureDX12::OnInit()
if (useUAV)
{
resourceDesc.Flags |= D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS;
if (!useRTV && !useDSV)
initialState = D3D12_RESOURCE_STATE_UNORDERED_ACCESS;
}
// Create heap properties
D3D12_HEAP_PROPERTIES heapProperties;
heapProperties.Type = D3D12_HEAP_TYPE_DEFAULT;
heapProperties.CPUPageProperty = D3D12_CPU_PAGE_PROPERTY_UNKNOWN;
heapProperties.MemoryPoolPreference = D3D12_MEMORY_POOL_UNKNOWN;
heapProperties.CreationNodeMask = 1;
heapProperties.VisibleNodeMask = 1;
// Create clear value (used by render targets and depth stencil buffers)
D3D12_CLEAR_VALUE* clearValuePtr = nullptr;
D3D12_CLEAR_VALUE clearValue;
@@ -154,17 +140,12 @@ bool GPUTextureDX12::OnInit()
clearValue.DepthStencil.Stencil = 0;
clearValuePtr = &clearValue;
}
if (IsRegularTexture())
initialState = D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE | D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE;
// Create texture
#if PLATFORM_WINDOWS && 0
D3D12_HEAP_FLAGS heapFlags = useRTV || useDSV ? D3D12_HEAP_FLAG_CREATE_NOT_ZEROED : D3D12_HEAP_FLAG_NONE;
#else
D3D12_HEAP_FLAGS heapFlags = D3D12_HEAP_FLAG_NONE;
#endif
auto result = device->CreateCommittedResource(&heapProperties, heapFlags, &resourceDesc, initialState, clearValuePtr, IID_PPV_ARGS(&resource));
allocationDesc.HeapType = D3D12_HEAP_TYPE_DEFAULT;
HRESULT result = _device->Allocator->CreateResource(&allocationDesc, &resourceDesc, initialState, clearValuePtr, &_allocation, IID_PPV_ARGS(&resource));
LOG_DIRECTX_RESULT_WITH_RETURN(result, true);
// Set state
@@ -186,6 +167,17 @@ bool GPUTextureDX12::OnInit()
initHandles();
}
// Discard resource contents (allows using non-zero heap)
if (isWrite)
{
_device->Locker.Lock();
if (IsInMainThread() && _device->IsRendering())
_device->GetMainContextDX12()->GetCommandList()->DiscardResource(_resource, nullptr);
else
_device->PendingResourceDiscards.Add(_resource);
_device->Locker.Unlock();
}
return false;
}
Source/Engine/GraphicsDevice/DirectX/DX12/GraphicsDeviceDX12.Build.cs
+2
View File
@@ -42,5 +42,7 @@ public class GraphicsDeviceDX12 : GraphicsDeviceBaseModule
options.DependencyFiles.Add(Path.Combine(options.DepsFolder, "WinPixEventRuntime.dll"));
options.DelayLoadLibraries.Add("WinPixEventRuntime.dll");
}
options.PrivateDependencies.Add("D3D12MemoryAllocator");
}
}
Source/Engine/GraphicsDevice/DirectX/DX12/ResourceOwnerDX12.cpp
+4 -7
View File
@@ -22,16 +22,13 @@ void ResourceOwnerDX12::initResource(const D3D12_RESOURCE_STATES initialState, c
void ResourceOwnerDX12::releaseResource(uint32 safeFrameCount)
{
if (_resource)
auto resource = _resource;
if (resource)
{
OnRelease(this);
auto resource = _resource;
_resource = nullptr;
_subresourcesCount = 0;
State.Release();
((GPUDeviceDX12*)GPUDevice::Instance)->AddResourceToLateRelease(resource, safeFrameCount);
((GPUDeviceDX12*)GPUDevice::Instance)->AddResourceToLateRelease(resource, _allocation, safeFrameCount);
_allocation = nullptr;
}
}
Source/Engine/GraphicsDevice/DirectX/DX12/ResourceOwnerDX12.h
+7 -13
View File
@@ -8,6 +8,10 @@
#if GRAPHICS_API_DIRECTX12
namespace D3D12MA
{
class Allocation;
}
class GPUResource;
class GPUContextDX12;
class GPUAsyncContextDX12;
@@ -59,19 +63,9 @@ class ResourceOwnerDX12
friend GPUAsyncContextDX12;
protected:
ID3D12Resource* _resource;
uint32 _subresourcesCount;
ResourceOwnerDX12()
: _resource(nullptr)
, _subresourcesCount(0)
{
}
~ResourceOwnerDX12()
{
}
D3D12MA::Allocation* _allocation = nullptr;
ID3D12Resource* _resource = nullptr;
uint32 _subresourcesCount = 0;
public:
Source/Engine/GraphicsDevice/DirectX/IncludeDirectXHeaders.h
+1 -1
View File
@@ -18,7 +18,7 @@
#if PLATFORM_XBOX_SCARLETT || PLATFORM_XBOX_ONE
#if PLATFORM_XBOX_SCARLETT
#if PLATFORM_XBOX_SCARLETT
#include <Scarlett/d3d12_xs.h>
#else
#include <XboxOne/d3d12_x.h>
Source/ThirdParty/D3D12MemoryAllocator/D3D12MemAlloc.cpp
Vendored
+10219
View File
File diff suppressed because it is too large Load Diff
Source/ThirdParty/D3D12MemoryAllocator/D3D12MemAlloc.h
Vendored
+3614
View File
File diff suppressed because it is too large Load Diff
Source/ThirdParty/D3D12MemoryAllocator/D3D12MemAlloc.natvis
Vendored
+58
View File
@@ -0,0 +1,58 @@
<?xml version="1.0" encoding="utf-8"?>
<AutoVisualizer xmlns="http://schemas.microsoft.com/vstudio/debugger/natvis/2010">
<Type Name="D3D12MA::Vector&lt;*&gt;">
<DisplayString>{{ Count={m_Count} }}</DisplayString>
<Expand>
<Item Name="[Count]">m_Count</Item>
<Item Name="[Capacity]">m_Capacity</Item>
<ArrayItems>
<Size>m_Count</Size>
<ValuePointer>m_pArray</ValuePointer>
</ArrayItems>
</Expand>
</Type>
<Type Name="D3D12MA::List&lt;*&gt;">
<DisplayString>{{ Count={m_Count} }}</DisplayString>
<Expand>
<Item Name="[Count]">m_Count</Item>
<LinkedListItems>
<Size>m_Count</Size>
<HeadPointer>m_pFront</HeadPointer>
<NextPointer>pNext</NextPointer>
<ValueNode>Value</ValueNode>
</LinkedListItems>
</Expand>
</Type>
<!--
Due to custom way of accesing next items in
D3D12MA::IntrusiveLinkedList via methods in provided type traits,
every specialization must be manually added with
custom <NextPointer> field describing proper way of iterating the list.
-->
<Type Name="D3D12MA::IntrusiveLinkedList&lt;D3D12MA::CommittedAllocationListItemTraits&gt;">
<DisplayString>{{ Count={m_Count} }}</DisplayString>
<Expand>
<Item Name="[Count]">m_Count</Item>
<LinkedListItems>
<Size>m_Count</Size>
<HeadPointer>m_Front</HeadPointer>
<NextPointer>m_Committed.next</NextPointer>
<ValueNode>*this</ValueNode>
</LinkedListItems>
</Expand>
</Type>
<Type Name="D3D12MA::IntrusiveLinkedList&lt;D3D12MA::PoolListItemTraits&gt;">
<DisplayString>{{ Count={m_Count} }}</DisplayString>
<Expand>
<Item Name="[Count]">m_Count</Item>
<LinkedListItems>
<Size>m_Count</Size>
<HeadPointer>m_Front</HeadPointer>
<NextPointer>m_NextPool</NextPointer>
<ValueNode>*this</ValueNode>
</LinkedListItems>
</Expand>
</Type>
</AutoVisualizer>
Source/ThirdParty/D3D12MemoryAllocator/D3D12MemoryAllocator.Build.cs
Vendored
+21
View File
@@ -0,0 +1,21 @@
// Copyright (c) Wojciech Figat. All rights reserved.
using Flax.Build;
/// <summary>
/// https://github.com/GPUOpen-LibrariesAndSDKs/D3D12MemoryAllocator
/// </summary>
public class D3D12MemoryAllocator : HeaderOnlyModule
{
/// <inheritdoc />
public override void Init()
{
base.Init();
LicenseType = LicenseTypes.MIT;
LicenseFilePath = "LICENSE.txt";
// Merge third-party modules into engine binary
BinaryModuleName = "FlaxEngine";
}
}
Source/ThirdParty/D3D12MemoryAllocator/LICENSE.txt
Vendored
+19
View File
@@ -0,0 +1,19 @@
Copyright (c) 2019-2026 Advanced Micro Devices, Inc. All rights reserved.
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.