Add Radeon GPU Analyzer support

AnKi/Importer/ImageImporter.cpp

@@ -134,30 +134,6 @@ public:
 	Array<U8, 3> m_dimZ;
 };
 
-/// Simple class to delete a file when it goes out of scope.
-class CleanupFile
-{
-public:
-	StringRaii m_fileToDelete;
-
-	CleanupFile(BaseMemoryPool* pool, CString filename)
-		: m_fileToDelete(pool, filename)
-	{
-	}
-
-	~CleanupFile()
-	{
-		if(!m_fileToDelete.isEmpty())
-		{
-			const Error err = removeFile(m_fileToDelete);
-			if(!err)
-			{
-				ANKI_IMPORTER_LOGV("Deleted %s", m_fileToDelete.cstr());
-			}
-		}
-	}
-};
-
 } // namespace
 
 static Error checkConfig(const ImageImporterConfig& config)

AnKi/ShaderCompiler/Dxc.cpp

@@ -11,33 +11,6 @@
 
 namespace anki {
 
-namespace {
-
-class CleanupFile
-{
-public:
-	StringRaii m_fileToDelete;
-
-	CleanupFile(BaseMemoryPool* pool, CString filename)
-		: m_fileToDelete(pool, filename)
-	{
-	}
-
-	~CleanupFile()
-	{
-		if(!m_fileToDelete.isEmpty() && fileExists(m_fileToDelete))
-		{
-			// Loop until success because Windows antivirus may be keeping the file in use
-			while(std::remove(m_fileToDelete.cstr()))
-			{
-				HighRezTimer::sleep(1.0_ms);
-			}
-		}
-	}
-};
-
-} // end anonymous namespace
-
 static CString profile(ShaderType shaderType)
 {
 	switch(shaderType)

AnKi/ShaderCompiler/MaliOfflineCompiler.cpp

@@ -13,31 +13,31 @@ namespace anki {
 
 static MaliOfflineCompilerHwUnit strToHwUnit(CString str)
 {
-	MaliOfflineCompilerHwUnit out = MaliOfflineCompilerHwUnit::NONE;
+	MaliOfflineCompilerHwUnit out = MaliOfflineCompilerHwUnit::kNone;
 
 	if(str.find("FMA") == 0)
 	{
-		out = MaliOfflineCompilerHwUnit::FMA;
+		out = MaliOfflineCompilerHwUnit::kFma;
 	}
 	else if(str.find("CVT") == 0)
 	{
-		out = MaliOfflineCompilerHwUnit::CVT;
+		out = MaliOfflineCompilerHwUnit::kCvt;
 	}
 	else if(str.find("SFU") == 0)
 	{
-		out = MaliOfflineCompilerHwUnit::SFU;
+		out = MaliOfflineCompilerHwUnit::kSfu;
 	}
 	else if(str.find("LS") == 0)
 	{
-		out = MaliOfflineCompilerHwUnit::LOAD_STORE;
+		out = MaliOfflineCompilerHwUnit::kLoadStore;
 	}
 	else if(str.find("V") == 0)
 	{
-		out = MaliOfflineCompilerHwUnit::VARYING;
+		out = MaliOfflineCompilerHwUnit::kVarying;
 	}
 	else if(str.find("T") == 0)
 	{
-		out = MaliOfflineCompilerHwUnit::TEXTURE;
+		out = MaliOfflineCompilerHwUnit::kTexture;
 	}
 	else
 	{
@@ -52,22 +52,22 @@ static CString hwUnitToStr(MaliOfflineCompilerHwUnit u)
 	CString out;
 	switch(u)
 	{
-	case MaliOfflineCompilerHwUnit::FMA:
+	case MaliOfflineCompilerHwUnit::kFma:
 		out = "FMA";
 		break;
-	case MaliOfflineCompilerHwUnit::CVT:
+	case MaliOfflineCompilerHwUnit::kCvt:
 		out = "CVT";
 		break;
-	case MaliOfflineCompilerHwUnit::SFU:
+	case MaliOfflineCompilerHwUnit::kSfu:
 		out = "SFU";
 		break;
-	case MaliOfflineCompilerHwUnit::LOAD_STORE:
+	case MaliOfflineCompilerHwUnit::kLoadStore:
 		out = "LS";
 		break;
-	case MaliOfflineCompilerHwUnit::VARYING:
+	case MaliOfflineCompilerHwUnit::kVarying:
 		out = "VAR";
 		break;
-	case MaliOfflineCompilerHwUnit::TEXTURE:
+	case MaliOfflineCompilerHwUnit::kTexture:
 		out = "TEX";
 		break;
 	default:
@@ -312,7 +312,7 @@ Error runMaliOfflineCompiler(CString maliocExecutable, ConstWeakArray<U8> spirv,
 	StringRaii tmpDir(&tmpPool);
 	ANKI_CHECK(getTempDirectory(tmpDir));
 	StringRaii spirvFilename(&tmpPool);
-	spirvFilename.sprintf("%s/AnKiMaliocTmpSpirv_%" PRIu64 ".spv", tmpDir.cstr(), getRandom());
+	spirvFilename.sprintf("%s/AnKiMaliocInput_%" PRIu64 ".spv", tmpDir.cstr(), getRandom());
 
 	File spirvFile;
 	ANKI_CHECK(spirvFile.open(spirvFilename, FileOpenFlag::kWrite | FileOpenFlag::kBinary));

AnKi/ShaderCompiler/MaliOfflineCompiler.h

@@ -15,13 +15,13 @@ namespace anki {
 
 enum class MaliOfflineCompilerHwUnit : U8
 {
-	NONE,
-	FMA,
-	CVT,
-	SFU,
-	LOAD_STORE,
-	VARYING,
-	TEXTURE
+	kNone,
+	kFma,
+	kCvt,
+	kSfu,
+	kLoadStore,
+	kVarying,
+	kTexture
 };
 
 /// Mali offline compiler output.
@@ -35,7 +35,7 @@ public:
 	F32 m_loadStore = -1.0f;
 	F32 m_varying = -1.0f;
 	F32 m_texture = -1.0f;
-	MaliOfflineCompilerHwUnit m_boundUnit = MaliOfflineCompilerHwUnit::NONE;
+	MaliOfflineCompilerHwUnit m_boundUnit = MaliOfflineCompilerHwUnit::kNone;
 
 	U32 m_workRegisters = kMaxU32;
 	U32 m_spilling = 0;

AnKi/ShaderCompiler/RadeonGpuAnalyzer.cpp

@@ -0,0 +1,148 @@
+// Copyright (C) 2009-2022, Panagiotis Christopoulos Charitos and contributors.
+// All rights reserved.
+// Code licensed under the BSD License.
+// http://www.anki3d.org/LICENSE
+
+#include <AnKi/ShaderCompiler/RadeonGpuAnalyzer.h>
+#include <AnKi/Util/File.h>
+#include <AnKi/Util/Filesystem.h>
+#include <AnKi/Util/Process.h>
+#include <AnKi/Util/StringList.h>
+
+namespace anki {
+
+static CString getPipelineStageString(ShaderType shaderType)
+{
+	CString out;
+	switch(shaderType)
+	{
+	case ShaderType::kVertex:
+		out = "vert";
+		break;
+	case ShaderType::kFragment:
+		out = "frag";
+		break;
+	case ShaderType::kCompute:
+		out = "comp";
+		break;
+	default:
+		ANKI_ASSERT(!"TODO");
+	}
+
+	return out;
+}
+
+Error runRadeonGpuAnalyzer(CString rgaExecutable, ConstWeakArray<U8> spirv, ShaderType shaderType,
+						   BaseMemoryPool& tmpPool, RgaOutput& out)
+{
+	ANKI_ASSERT(spirv.getSize() > 0);
+	const U64 rand = getRandom();
+
+	// Store SPIRV
+	StringRaii tmpDir(&tmpPool);
+	ANKI_CHECK(getTempDirectory(tmpDir));
+	StringRaii spvFilename(&tmpPool);
+	spvFilename.sprintf("%s/AnKiRgaInput_%llu.spv", tmpDir.cstr(), rand);
+	File spvFile;
+	ANKI_CHECK(spvFile.open(spvFilename, FileOpenFlag::kWrite | FileOpenFlag::kBinary));
+	ANKI_CHECK(spvFile.write(&spirv[0], spirv.getSizeInBytes()));
+	spvFile.close();
+	CleanupFile spvFileCleanup(spvFilename);
+
+	// Call RGA
+	StringRaii analysisFilename(&tmpPool);
+	analysisFilename.sprintf("%s/AnKiRgaOutAnalysis_%llu.csv", tmpDir.cstr(), rand);
+
+	DynamicArrayRaii<StringRaii> args(&tmpPool);
+	args.emplaceBack(&tmpPool, "-s");
+	args.emplaceBack(&tmpPool, "vk-spv-offline");
+	args.emplaceBack(&tmpPool, "-c");
+	args.emplaceBack(&tmpPool, "gfx1030"); // Target RDNA2
+	args.emplaceBack(&tmpPool, "-a");
+	args.emplaceBack(&tmpPool, analysisFilename);
+	args.emplaceBack(&tmpPool, spvFilename);
+
+	{
+		Process proc;
+		ANKI_CHECK(proc.start(rgaExecutable, args, DynamicArrayRaii<StringRaii>(&tmpPool)));
+
+		ProcessStatus status;
+		I32 exitCode;
+		ANKI_CHECK(proc.wait(-1.0, &status, &exitCode));
+
+		if(exitCode != 0)
+		{
+			StringRaii stderre(&tmpPool);
+			const Error err = proc.readFromStderr(stderre);
+			ANKI_SHADER_COMPILER_LOGE("RGA failed with exit code %d. Stderr: %s", exitCode,
+									  (err || stderre.isEmpty()) ? "<no text>" : stderre.cstr());
+			return Error::kFunctionFailed;
+		}
+	}
+
+	// Construct the output filename
+	StringRaii outFilename(&tmpPool);
+	outFilename.sprintf("%s/gfx1030_AnKiRgaOutAnalysis_%llu_%s.csv", tmpDir.cstr(), rand,
+						getPipelineStageString(shaderType).cstr());
+
+	CleanupFile rgaFileCleanup(outFilename);
+
+	// Read the file
+	File analysisFile;
+	ANKI_CHECK(analysisFile.open(outFilename, FileOpenFlag::kRead));
+	StringRaii analysisText(&tmpPool);
+	ANKI_CHECK(analysisFile.readAllText(analysisText));
+
+	// Parse the text
+	StringListRaii lines(&tmpPool);
+	lines.splitString(analysisText, '\n');
+	if(lines.getSize() != 2)
+	{
+		ANKI_SHADER_COMPILER_LOGE("Error parsing RGA analysis file");
+		return Error::kFunctionFailed;
+	}
+
+	StringListRaii tokens(&tmpPool);
+	tokens.splitString(lines.getFront(), ',');
+
+	StringListRaii values(&tmpPool);
+	values.splitString(*(lines.getBegin() + 1), ',');
+
+	if(tokens.getSize() != tokens.getSize())
+	{
+		ANKI_SHADER_COMPILER_LOGE("Error parsing RGA analysis file");
+		return Error::kFunctionFailed;
+	}
+
+	out.m_vgprCount = kMaxU32;
+	out.m_sgprCount = kMaxU32;
+	out.m_isaSize = kMaxU32;
+	auto valuesIt = values.getBegin();
+	for(const String& token : tokens)
+	{
+		if(token.find("USED_VGPRs") != String::kNpos)
+		{
+			ANKI_CHECK((*valuesIt).toNumber(out.m_vgprCount));
+		}
+		else if(token.find("USED_SGPRs") != String::kNpos)
+		{
+			ANKI_CHECK((*valuesIt).toNumber(out.m_sgprCount));
+		}
+		else if(token.find("ISA_SIZE") != String::kNpos)
+		{
+			ANKI_CHECK((*valuesIt).toNumber(out.m_isaSize));
+		}
+
+		++valuesIt;
+	}
+
+	if(out.m_vgprCount == kMaxU32 || out.m_sgprCount == kMaxU32 || out.m_isaSize == kMaxU32)
+	{
+		ANKI_SHADER_COMPILER_LOGE("Error parsing RGA analysis file");
+		return Error::kFunctionFailed;
+	}
+
+	return Error::kNone;
+}
+
+} // end namespace anki

AnKi/ShaderCompiler/RadeonGpuAnalyzer.h

@@ -0,0 +1,32 @@
+// Copyright (C) 2009-2022, Panagiotis Christopoulos Charitos and contributors.
+// All rights reserved.
+// Code licensed under the BSD License.
+// http://www.anki3d.org/LICENSE
+
+#pragma once
+
+#include <AnKi/ShaderCompiler/Common.h>
+#include <AnKi/Util/WeakArray.h>
+
+namespace anki {
+
+/// @addtogroup shader_compiler
+/// @{
+
+/// RGA output.
+class RgaOutput
+{
+public:
+	U32 m_vgprCount;
+	U32 m_sgprCount;
+	U32 m_isaSize;
+
+	void toString(StringRaii& str) const;
+};
+
+/// Run the mali offline compiler and get some info back.
+Error runRadeonGpuAnalyzer(CString rgaExecutable, ConstWeakArray<U8> spirv, ShaderType shaderType,
+						   BaseMemoryPool& tmpPool, RgaOutput& out);
+/// @}
+
+} // end namespace anki

AnKi/Shaders/Functions.glsl

@@ -744,6 +744,7 @@ F32 fastCos(F32 x)
 	return fastSin(x + kPi / 2.0);
 }
 
+/// Transform using a 3x4 matrix. mat is row major.
 Vec3 transform(Vec4 mat[3u], Vec4 v)
 {
 	const F32 a = dot(mat[0], v);
@@ -751,3 +752,12 @@ Vec3 transform(Vec4 mat[3u], Vec4 v)
 	const F32 c = dot(mat[2], v);
 	return Vec3(a, b, c);
 }
+
+/// Rotate using a 3x3 matrix. mat is row major.
+Vec3 rotate(Vec3 mat[3u], Vec3 v)
+{
+	const F32 a = dot(mat[0], v);
+	const F32 b = dot(mat[1], v);
+	const F32 c = dot(mat[2], v);
+	return Vec3(a, b, c);
+}

AnKi/Shaders/Functions.hlsl

@@ -694,6 +694,7 @@ F32 fastCos(F32 x)
 	return fastSin(x + kPi / 2.0);
 }
 
+/// Transform using a 3x4 matrix. mat is row major.
 Vec3 transform(Vec4 mat[3u], Vec4 v)
 {
 	const F32 a = dot(mat[0], v);
@@ -701,3 +702,20 @@ Vec3 transform(Vec4 mat[3u], Vec4 v)
 	const F32 c = dot(mat[2], v);
 	return Vec3(a, b, c);
 }
+
+/// Rotate using a 3x3 matrix. mat is row major.
+Vec3 rotate(Vec3 mat[3u], Vec3 v)
+{
+	const F32 a = dot(mat[0], v);
+	const F32 b = dot(mat[1], v);
+	const F32 c = dot(mat[2], v);
+	return Vec3(a, b, c);
+}
+
+RVec3 rotate(RVec3 mat[3u], RVec3 v)
+{
+	const RF32 a = dot(mat[0], v);
+	const RF32 b = dot(mat[1], v);
+	const RF32 c = dot(mat[2], v);
+	return RVec3(a, b, c);
+}

AnKi/Shaders/GBufferGeneric.ankiprog

@@ -304,9 +304,11 @@ ANKI_RP Vec3 readNormalFromTexture(ANKI_RP texture2D map, sampler sampl, highp V
 	const ANKI_RP Vec3 t = normalize(in_tangent);
 	const ANKI_RP Vec3 b = normalize(in_bitangent);
 
-	const ANKI_RP Mat3 tbnMat = Mat3(t, b, n);
-
-	return tbnMat * nAtTangentspace;
+	ANKI_RP Vec3 tbnMat[3u];
+	tbnMat[0] = Vec3(t.x, b.x, n.x);
+	tbnMat[1] = Vec3(t.y, b.y, n.y);
+	tbnMat[2] = Vec3(t.z, b.z, n.z);
+	return rotate(tbnMat, nAtTangentspace);
 }
 #endif
 

AnKi/Shaders/GBufferGeneric2.ankiprog

@@ -268,9 +268,12 @@ RVec3 readNormalFromTexture(VertOut input, Texture2D<RVec4> map, SamplerState sa
 	const RVec3 t = normalize(input.m_tangent);
 	const RVec3 b = normalize(input.m_bitangent);
 
-	const RMat3 tbnMat = Mat3(t, b, n);
+	RVec3 tbnMat[3u];
+	tbnMat[0] = RVec3(t.x, b.x, n.x);
+	tbnMat[1] = RVec3(t.y, b.y, n.y);
+	tbnMat[2] = RVec3(t.z, b.z, n.z);
 
-	return mul(tbnMat, nAtTangentspace);
+	return rotate(tbnMat, nAtTangentspace);
 }
 
 FragOut main(VertOut input)

AnKi/Util/Filesystem.cpp

@@ -4,6 +4,7 @@
 // http://www.anki3d.org/LICENSE
 
 #include <AnKi/Util/Filesystem.h>
+#include <AnKi/Util/HighRezTimer.h>
 
 namespace anki {
 
@@ -82,4 +83,17 @@ Error removeFile(const CString& filename)
 	return Error::kNone;
 }
 
+CleanupFile::~CleanupFile()
+{
+	if(!m_fileToDelete.isEmpty() && fileExists(m_fileToDelete))
+	{
+		// Loop until success because Windows antivirus may be keeping the file in use
+		while(std::remove(m_fileToDelete.cstr()) && m_tries > 0)
+		{
+			HighRezTimer::sleep(m_seepTimeBeforeNextTry);
+			--m_tries;
+		}
+	}
+}
+
 } // end namespace anki

AnKi/Util/Filesystem.h

@@ -75,6 +75,29 @@ Error getFileModificationTime(CString filename, U32& year, U32& month, U32& day,
 
 /// Get the path+filename of the currently running executable.
 Error getApplicationPath(StringRaii& path);
+
+/// A convenience class to delete a file when it goes out of scope. It tries multiple times because of Windows
+/// antivirus sometimes keeping a lock to the file.
+class CleanupFile
+{
+public:
+	StringRaii m_fileToDelete;
+	U32 m_tries = 3 * 1000; ///< Number of times to try delete the file.
+	Second m_seepTimeBeforeNextTry = 1.0_ms; ///< Time before the next try.
+
+	CleanupFile(BaseMemoryPool* pool, CString filename)
+		: m_fileToDelete(pool, filename)
+	{
+	}
+
+	CleanupFile(const StringRaii& filename)
+		: m_fileToDelete(filename)
+	{
+	}
+
+	/// Deletes the file.
+	~CleanupFile();
+};
 /// @}
 
 } // end namespace anki

AnKi/Util/Process.cpp

@@ -34,15 +34,37 @@ void Process::destroy()
 #endif
 }
 
+Error Process::start(CString executable, const DynamicArray<StringRaii>& arguments,
+					 const DynamicArray<StringRaii>& environment, ProcessOptions options)
+{
+	// Set args and env
+	Array<const Char*, kMaxArgs> args;
+	Array<const Char*, kMaxEnv> env;
+
+	args[0] = executable.cstr();
+	for(U32 i = 0; i < arguments.getSize(); ++i)
+	{
+		args[i + 1] = arguments[i].cstr();
+		ANKI_ASSERT(args[i + 1]);
+	}
+	args[arguments.getSize() + 1] = nullptr;
+
+	for(U32 i = 0; i < environment.getSize(); ++i)
+	{
+		env[i] = environment[i].cstr();
+		ANKI_ASSERT(env[i]);
+	}
+	env[environment.getSize()] = nullptr;
+
+	return startInternal(&args[0], &env[0], options);
+}
+
 Error Process::start(CString executable, ConstWeakArray<CString> arguments, ConstWeakArray<CString> environment,
 					 ProcessOptions options)
 {
-#if !ANKI_OS_ANDROID
-	ANKI_ASSERT(m_handle == nullptr && "Already started");
-
 	// Set args and env
-	Array<const Char*, 64> args;
-	Array<const Char*, 32> env;
+	Array<const Char*, kMaxArgs> args;
+	Array<const Char*, kMaxEnv> env;
 
 	args[0] = executable.cstr();
 	for(U32 i = 0; i < arguments.getSize(); ++i)
@@ -59,13 +81,21 @@ Error Process::start(CString executable, ConstWeakArray<CString> arguments, Cons
 	}
 	env[environment.getSize()] = nullptr;
 
+	return startInternal(&args[0], &env[0], options);
+}
+
+Error Process::startInternal(const Char* args[], const Char* env[], ProcessOptions options)
+{
+#if !ANKI_OS_ANDROID
+	ANKI_ASSERT(m_handle == nullptr && "Already started");
+
 	// Start process
 	m_handle = reproc_new();
 
 	reproc_options reprocOptions = {};
 
 	reprocOptions.env.behavior = REPROC_ENV_EXTEND;
-	if(environment.getSize())
+	if(env[0] != nullptr)
 	{
 		reprocOptions.env.extra = &env[0];
 	}

AnKi/Util/Process.h

@@ -60,6 +60,11 @@ public:
 	Error start(CString executable, ConstWeakArray<CString> arguments = {}, ConstWeakArray<CString> environment = {},
 				ProcessOptions options = ProcessOptions::kOpenStderr | ProcessOptions::kOpenStdout);
 
+	/// Same as the other start().
+	Error start(CString executable, const DynamicArray<StringRaii>& arguments,
+				const DynamicArray<StringRaii>& environment,
+				ProcessOptions options = ProcessOptions::kOpenStderr | ProcessOptions::kOpenStdout);
+
 	/// Wait for the process to finish.
 	/// @param timeout The time to wait. If it's negative wait forever.
 	/// @param[out] status The exit status
@@ -92,9 +97,14 @@ public:
 							 StringRaii* stdErr, I32& exitCode);
 
 private:
+	static constexpr U32 kMaxArgs = 64;
+	static constexpr U32 kMaxEnv = 32;
+
 	reproc_t* m_handle = nullptr;
 
 	Error readCommon(I32 reprocStream, StringRaii& text);
+
+	Error startInternal(const Char* arguments[], const Char* environment[], ProcessOptions options);
 };
 /// @}
 

ThirdParty/Bin/Windows64/RadeonGpuAnalyzer/License.txt

@@ -0,0 +1,19 @@
+Copyright (c) 2022 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.

ThirdParty/Bin/Windows64/RadeonGpuAnalyzer/README.md

@@ -0,0 +1,166 @@
+# RGA (Radeon™ GPU Analyzer) #
+
+Radeon GPU Analyzer is a compiler and code analysis tool for Vulkan®, DirectX®, OpenGL® and OpenCL™. Using this product, you can compile high-level source code for a variety of AMD GPU and APU architectures,
+independent of the type of GPU/APU that is physically installed on your system.
+
+You can use RGA to produce the following output:
+* RDNA™ and GCN ISA disassembly
+* Intermediate language disassembly: AMDIL, DXIL and DXBC for DirectX, SPIR-V for Vulkan, LLVM IR for Offline OpenCL
+* Hardware resource usage statistics, such as register consumption, static memory allocation and more
+* Compiled binaries
+* Live register analysis (see http://gpuopen.com/live-vgpr-analysis-radeon-gpu-analyzer/ for more info)
+* Control flow graphs
+* Build errors and warnings
+
+The RGA package contains both a GUI app and a command-line executable.
+
+The supported modes by the **GUI app** are:
+* Vulkan - GLSL/SPIR-V as input, together with the Vulkan pipeline state; compiled through AMD's Vulkan driver
+* OpenCL - AMD's LLVM-based Lightning Compiler for OpenCL
+
+The supported modes by the **command-line tool** are:
+* DX12 (see https://gpuopen.com/radeon-gpu-analyzer-2-2-direct3d12-compute/ and https://gpuopen.com/radeon-gpu-analyzer-2-3-direct3d-12-graphics/ for more details)
+* DX11
+* DXR
+* Vulkan - compilation of GLSL/SPIR-V together with the API's pipeline state, using AMD's Vulkan driver
+* Vulkan Offline - using a static compiler, accepts GLSL/SPIR-V as input. Note: to ensure that the results that RGA provides are accurate and reflect the real-world case, please use the new Vulkan live driver mode (which is also supported in the GUI application).
+* OpenCL - AMD's LLVM-based Lightning Compiler for Offline OpenCL
+* OpenGL
+* AMDIL
+
+## System Requirements ##
+
+* Windows: 10, 64-bit. Visual Studio 2015 or later.
+* Linux: Ubuntu 20.04. Build with gcc 4.7.2 or later.
+* Vulkan SDK 1.1.97.0 or later. To download the Vulkan SDK, visit https://vulkan.lunarg.com/
+
+To run the tool, you would need to have the AMD Radeon Adrenalin Software (Windows) or amdgpu-pro driver (Linux) installed for all modes, except for the following "offline" modes, which are independent of the driver and hardware:
+* Vulkan offline mode
+* OpenCL offline mode
+
+For the non-offline modes, it is strongly recommended to run with the latest drivers so that the latest compiler is used and the latest architectures can be targeted.
+
+A specific note for Vulkan mode users:
+
+RGA releases are packaged with the AMD Vulkan driver to enable users who run on machines without an AMD GPU or driver. This is not the case if you build the tool yourself. To enable a custom RGA build on a non-AMD machine, copy the "amdvlk" folder from an RGA release archive
+to your build output folder (make sure to place the folder in the same folder hierarchy as in the release archive). Please note that this is a workaround and not the recommended configuration.
+
+## Build Instructions ##
+
+### Building on Windows ###
+As a preliminary step, make sure that you have the following installed on your system:
+* CMake 3.10 or above. For auto-detecting the Vulkan SDK version 3.7 or above is required.
+* Python 2.7 or above
+* Qt (in case that you are interested in building the GUI app; you can build the command line executable without Qt). Qt 5.15.2 is recommended.
+
+cd to the build sub-folder, and run:
+
+prebuild.bat --qt <path of Qt's msvc2017_64 folder> --vs 2017
+
+Where <path to Qt's msvc2017_64 folder> is the path to the Qt msvc2017_64 folder, such as C:\Qt\Qt5.15.2\msvc2017_64.
+
+Running the prebuild script will fetch all the dependencies and generate the solution file for Visual Studio.
+After successfully running the preuild script, open RGA.sln from build\windows\vs2019 (or vs2017), and build:
+* RadeonGPUAnalyzerCLI project for the command line executable
+* RadeonGPUAnalyzerGUI project for the GUI app
+
+Some useful options of the prebuild script:
+* --vs <VS version>: generate the solution files for a specific Visual Studio version. For example, to target VS 2019, add --vs 2019 to the command.
+* --qt <path>: full path to the folder from where you would like the Qt binaries to be retrieved. By default, CMake would try to auto-detect Qt on the system.
+* --vk-include and --vk-lib: full paths to where the Vulkan SDK include and Vulkan lib folders. By default, CMake would try to auto-detect the Vulkan SDK on the system.
+* --cli-only: only build the command line tool (do not build the GUI app)
+* --no-fetch: do not attempt to update the third-party repositories
+
+If you are intending to analyze DirectX 11 shaders using RGA, copy the x64 version of Microsoft's D3D compiler to a subdirectory
+named "utils" under the RGA executable's directory (for example, D3DCompiler_47.dll).
+
+-=-
+
+If for some reason you do not want to use the prebuild.bat script, you can also manually fetch the dependencies and generate the solution and project files:
+Start by running the FetchDependencies.py script to fetch the solution's dependencies.
+To generate the solution file for VS 2017 in x64 configuration, use:
+
+  cmake.exe -G "Visual Studio 15 2017 Win64" <full path to the RGA repo directory>
+
+If you are intending to analyze DirectX shaders using RGA, copy the x64 version of Microsoft's D3D compiler to a subdirectory
+named "utils" under the RGA executable's directory (for example, D3DCompiler_47.dll).
+
+### Building on Ubuntu ###
+* One time setup:
+  * Install the Vulkan SDK (version 1.1.97.0 or above). To download the Vulkan SDK, visit https://vulkan.lunarg.com/
+  * sudo apt-get install libboost-all-dev
+  * sudo apt-get install gcc-multilib g++-multilib
+  * sudo apt-get install libglu1-mesa-dev mesa-common-dev libgtk2.0-dev
+  * sudo apt-get install zlib1g-dev libx11-dev:i386
+  * Install CMake 3.10 or above. For auto-detecting the Vulkan SDK version 3.7 or above is required.
+  * Install python 3.6 (or above)
+  * To build the GUI app, you should also have Qt installed
+
+* Build:
+
+   cd to the Build sub-folder
+
+   On Linux, it is recommended to explicitly pass to CMake the location of the Vulkan SDK include and lib directories as well as the location of Qt. For example:
+
+   ./prebuild.sh --qt ~/Qt-5.15.2/5.15.2/gcc_64 --vk-include ~/work/vulkan-sdk/1.1.97.0/x86_64/include/ --vk-lib ~/work/vulkan-sdk/1.1.97.0/x86_64/lib/
+
+   This will fetch all the dependencies and generate the make files.
+
+   Then, cd to the auto-generated subfolder build/linux/make and run make.
+
+   -=-
+
+   If for some reason you do not want to use the prebuild.sh script, you can also manually fetch the dependencies and generate the makefiles:
+
+  * run: python3 fetch_dependencies.py
+  * run: cmake –DCMAKE_BUILD_TYPE=Release (or: Debug) <full or relative path to the RGA repo directory>
+
+    It is recommended to create a directory to hold all build files, and launch cmake from that directory.
+
+    For example:
+    * cd to the RGA repo directory
+    * mkdir _build
+    * cd _build
+    * cmake –DCMAKE_BUILD_TYPE=Release ../
+  * run: make
+
+## Running ##
+### GUI App ###
+Run the RadeonGPUAnalyzerGUI executable. The app provides a quickstart guide and a help manual under Help.
+
+### Command Line Executable ###
+
+Run the rga executable.
+
+* Usage:
+  * General: rga -h
+  * DirectX 12: rga -s dx12 -h
+  * DirectX 11: rga -s dx11 -h
+  * DirectX Raytracing: rga -s dxr -h
+
+    Note: RGA's DX11 mode requires Microsoft's D3D Compiler DLL in runtime. If you copy the relevant D3D Compiler DLL to the utils
+    subdirectory under the executable's directory, RGA will use that DLL in runtime. The default D3D compiler that RGA public releases ship with
+    is d3dcompiler_47.dll.
+  * OpenGL:  rga -s opengl -h
+  * OpenCL offline:  rga -s opencl -h
+  * Vulkan live-driver:  rga -s vulkan -h
+  * Vulkan offline - glsl:  rga -s vk-offline -h
+  * Vulkan offline - SPIR-V binary input:  rga -s vk-offline-spv -h
+  * Vulkan offline - SPIRV-V textual input:  rga -s vk-offline-spv-txt -h
+  * AMD IL: rga -s amdil -h
+
+## Support ##
+For support, please visit the RGA repository github page: https://github.com/GPUOpen-Tools/RGA
+
+## Style and Format Change ##
+The source code of this product is being reformatted to follow the Google C++ Style Guide https://google.github.io/styleguide/cppguide.html
+
+In the interim you may encounter a mix of both an older C++ coding style, as well as the newer Google C++ Style.
+
+Please refer to the _clang-format file in the root directory of the product for additional style information.
+
+## License ##
+Radeon GPU Analyzer is licensed under the MIT license. See the License.txt file for complete license information.
+
+## Copyright information ##
+Please see RGA_NOTICES.txt for copyright and third party license information.

ThirdParty/Bin/Windows64/RadeonGpuAnalyzer/RGA_NOTICES.txt

@@ -0,0 +1,424 @@
+Third-party licenses, acknowledgements
+======================================
+
+Radeon™ GPU Analyzer (RGA) uses the following third-party software:
+
+**Boost**
+
+Copyright Beman Dawes, 2003.
+
+**TinyXML**
+
+TinyXML is released under the zlib license
+Files: *
+Copyright: 2000-2007, Lee Thomason, 2002-2004, Yves Berquin
+Files: tinystr.*
+Copyright: 2000-2007, Lee Thomason, 2002-2004, Yves Berquin, 2005, Tyge Lovset
+
+**TinyXML-2**
+
+TinyXML-2 is released under the zlib license:
+
+This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software.
+
+Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions:
+
+The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+This notice may not be removed or altered from any source distribution.
+
+**glew**
+
+The OpenGL Extension Wrangler Library
+Copyright (C) 2002-2007, Milan Ikits <milan ikits@ieee org>
+Copyright (C) 2002-2007, Marcelo E. Magallon <mmagallo@debian org>
+Copyright (C) 2002, Lev Povalahev
+All rights reserved.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+THE POSSIBILITY OF SUCH DAMAGE.
+
+**OpenCL**
+
+Copyright (c) 2008-2015 The Khronos Group Inc.
+
+**RSA Data Security, Inc.**
+
+Copyright (C) 1990, RSA Data Security, Inc. All rights reserved.
+License to copy and use this software is granted provided that
+it is identified as the "RSA Data Security, Inc. MD5 Message
+Digest Algorithm" in all material mentioning or referencing this
+software or this function.
+License is also granted to make and use derivative works
+provided that such works are identified as "derived from the RSA
+Data Security, Inc. MD5 Message Digest Algorithm" in all
+material mentioning or referencing the derived work.
+
+RSA Data Security, Inc. makes no representations concerning
+either the merchantability of this software or the suitability
+of this software for any particular purpose.  It is provided "as
+is" without express or implied warranty of any kind.
+
+These notices must be retained in any copies of any part of this
+documentation and/or software.
+
+**Glslang**
+
+Copyright (C) 2002-2005 3Dlabs Inc. Ltd.
+Copyright (C) 2012-2013 LunarG, Inc.
+
+**yaml-cpp**
+
+Copyright (c) 2008-2015 Jesse Beder.
+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.
+
+**Qt**
+
+Qt libraries are being used by this product, and are subject to the LGPL 3.0 license:
+
+ GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.
+
+For 3 years the source code, including modifications we have made, is available to users for a charge that is no more than the cost of performing the distribution of our software.
+
+**spdlog**
+
+The MIT License (MIT)
+
+Copyright (c) 2016 Gabi Melman.
+
+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.
+
+**cxxopts**
+
+Copyright (c) 2014 Jarryd Beck
+
+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.
+
+**rapidjson**
+
+Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.  All rights reserved.
+rapidjson is used by Fossilize and is therefore indirectly used by RGA.
+
+**nlohmann/json**
+
+Copyright © 2013-2018 Niels Lohmann
+
+**LLVM**
+
+University of Illinois/NCSA
+Open Source License
+
+Copyright (c) 2003-2017 University of Illinois at Urbana-Champaign.
+All rights reserved.
+
+Developed by:
+
+    LLVM Team
+
+    University of Illinois at Urbana-Champaign
+
+    http://llvm.org
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal with
+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:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimers.
+
+    * Redistributions in binary form must reproduce the above copyright notice,
+      this list of conditions and the following disclaimers in the
+      documentation and/or other materials provided with the distribution.
+
+    * Neither the names of the LLVM Team, University of Illinois at
+      Urbana-Champaign, nor the names of its contributors may be used to
+      endorse or promote products derived from this Software without specific
+      prior written permission.
+
+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
+CONTRIBUTORS 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 WITH THE
+SOFTWARE.
+
+**ROCm-Device-Libs**
+
+University of Illinois/NCSA
+Open Source License
+
+Copyright (c) 2014-2016, Advanced Micro Devices, Inc.
+All rights reserved.
+
+Developed by:
+
+AMD Research and AMD HSA Software Development
+
+Advanced Micro Devices, Inc.
+
+www.amd.com
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal with
+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:
+
+* Redistributions of source code must retain the above copyright notice,
+this list of conditions and the following disclaimers.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+this list of conditions and the following disclaimers in the
+documentation and/or other materials provided with the distribution.
+
+* Neither the names of the LLVM Team, University of Illinois at
+Urbana-Champaign, nor the names of its contributors may be used to
+endorse or promote products derived from this Software without specific
+prior written permission.
+
+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
+CONTRIBUTORS 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 WITH THE
+SOFTWARE.
+
+**SPIRV-Reflect**
+Copyright 2017-2018 Google Inc.
+
+**SPIRV-Tools**
+Copyright (c) 2015-2016 The Khronos Group Inc.
+
+**volk**
+Copyright (c) 2018 Arseny Kapoulkine
+
+**libtinfo.so.5.9**
+Ncurses is a part of the GNU Project. It is one of the few GNU files not distributed
+under the GNU GPL or LGPL; it is distributed under a permissive free software licence,
+similar to the MIT License.[15] This is due to the agreement made with the Free Software
+Foundation at the time the developers assigned their copyright.
+
+When the agreement was made to pass on the rights to the FSF, there was a clause that stated:[15]
+
+The Foundation promises that all distribution of the Package, or of any work "based on the
+Package", that takes place under the control of the Foundation or its agents or assignees,
+shall be on terms that explicitly and perpetually permit anyone possessing a copy of the
+work to which the terms apply, and possessing accurate notice of these terms, to redistribute
+copies of the work to anyone on the same terms.

ThirdParty/Bin/Windows64/RadeonGpuAnalyzer/RGA_RELEASE_NOTES.txt

@@ -0,0 +1,230 @@
+Radeon� GPU Analyzer 2.6.2 � Release Notes
+==========================================
+Highlights
+==========
+-	OpenGL mode is now an offline mode (-s opengl):
+    o Compile OpenGL shaders for any supported target, independently of the installed graphics card and driver.
+    o You can now generate static hardware resource usage information support for OpenGL shaders.
+-	Support for legacy targets (GFX8 and older) was removed.
+
+Note: on Ubuntu, the minimum required OS version is Ubuntu 20.04.
+
+Known Issues
+============
+Vulkan Live Driver Mode 
+-----------------------
+-	Source to disassembly correlation is not supported by AMD's shader compiler and is therefore not supported in the UI.
+-	Keyboard navigation is not supported from some views in the GUI application.
+-	The RGA layer is a beta feature. It fails to extract the shaders and pipeline state from certain Vulkan apps.
+-	Notifications about the fact that modified SPIR-V binary does not match the disassembly will not appear for loaded projects (in case that you changed the SPIR-V code, did not build and re-loaded the project).
+-	Cycle estimate for certain VALU instructions appears as �Varies� instead of 4.
+
+Offline OpenCL Mode
+-------------------
+-	OpenCL C++ kernels are not yet supported by the Lightning Compiler.
+-	Cycle estimate for certain VALU instructions appears as �Varies� instead of 4.
+
+DirectX 12 Mode
+---------------
+-	Live register analysis & CFG generation require using the --isa option to generate ISA disassembly. 
+-	On Windows 11, Hull shader AMDIL disassembly contains a trail of a few garbage characters.
+
+Vulkan Offline Modes (vk-offline, vk-spv-offline, vk-spv-txt-offline)
+---------------------------------------------------------------------
+SPIR-V support limitations:  
+a. The Vulkan Offline modes currently only support the following SPIR-V capabilities:
+CapabilityMatrix
+CapabilityShader
+CapabilityGeometry
+CapabilityTessellation
+CapabilityFloat16
+CapabilityFloat64
+CapabilityInt64
+CapabilityInt64Atomics
+CapabilityGroups
+CapabilityAtomicStorage
+CapabilityInt16
+CapabilityTessellationPointSize
+CapabilityGeometryPointSize
+CapabilityImageGatherExtended
+CapabilityStorageImageMultisample
+CapabilityUniformBufferArrayDynamicIndexing
+CapabilitySampledImageArrayDynamicIndexing
+CapabilityStorageBufferArrayDynamicIndexing
+CapabilityStorageImageArrayDynamicIndexing
+CapabilityClipDistance
+CapabilityCullDistance
+CapabilityImageCubeArray
+CapabilitySampleRateShading
+CapabilityImageRect
+CapabilitySampledRect
+CapabilityInt8
+CapabilityInputAttachment
+CapabilitySparseResidency
+CapabilityMinLod
+CapabilitySampled1D
+CapabilityImage1D
+CapabilitySampledCubeArray
+CapabilitySampledBuffer
+CapabilityImageBuffer
+CapabilityImageMSArray
+CapabilityStorageImageExtendedFormats
+CapabilityImageQuery
+CapabilityDerivativeControl
+CapabilityInterpolationFunction
+CapabilityTransformFeedback
+CapabilityGeometryStreams
+CapabilityStorageImageReadWithoutFormat
+CapabilityStorageImageWriteWithoutFormat
+CapabilityMultiViewport
+CapabilitySubgroupDispatch
+CapabilityNamedBarrier
+CapabilityPipeStorage
+CapabilityGroupNonUniform
+CapabilityGroupNonUniformVote
+CapabilityGroupNonUniformArithmetic
+CapabilityGroupNonUniformBallot
+CapabilityGroupNonUniformShuffle
+CapabilityGroupNonUniformShuffleRelative
+CapabilityGroupNonUniformClustered
+CapabilityGroupNonUniformQuad
+CapabilitySubgroupBallotKHR
+CapabilityDrawParameters
+CapabilitySubgroupVoteKHR
+CapabilityStorageBuffer16BitAccess
+CapabilityStorageUniformBufferBlock16
+CapabilityStorageUniform16
+CapabilityUniformAndStorageBuffer16BitAccess
+CapabilityStorageInputOutput16
+CapabilityDeviceGroup
+CapabilityMultiView
+CapabilityVariablePointersStorageBuffer
+CapabilityVariablePointers
+CapabilitySampleMaskPostDepthCoverage
+CapabilityStorageBuffer8BitAccess
+CapabilityUniformAndStorageBuffer8BitAccess
+CapabilityDenormPreserve
+CapabilityDenormFlushToZero
+CapabilitySignedZeroInfNanPreserve
+CapabilityRoundingModeRTE
+CapabilityRoundingModeRTZ
+CapabilityFloat16ImageAMD
+CapabilityImageGatherBiasLodAMD
+CapabilityFragmentMaskAMD
+CapabilityStencilExportEXT
+CapabilityImageReadWriteLodAMD
+CapabilityInt64ImageEXT
+CapabilityShaderClockKHR
+CapabilityShaderViewportIndexLayerEXT
+CapabilityFragmentShadingRateKHR
+CapabilityFragmentDensityEXT
+CapabilityShaderNonUniformEXT
+CapabilityRuntimeDescriptorArrayEXT
+CapabilityInputAttachmentArrayDynamicIndexingEXT
+CapabilityUniformTexelBufferArrayDynamicIndexingEXT
+CapabilityStorageTexelBufferArrayDynamicIndexingEXT
+CapabilityUniformBufferArrayNonUniformIndexingEXT
+CapabilitySampledImageArrayNonUniformIndexingEXT
+CapabilityStorageBufferArrayNonUniformIndexingEXT
+CapabilityStorageImageArrayNonUniformIndexingEXT
+CapabilityUniformTexelBufferArrayNonUniformIndexingEXT
+CapabilityStorageTexelBufferArrayNonUniformIndexingEXT
+CapabilityVulkanMemoryModel
+CapabilityVulkanMemoryModelKHR
+CapabilityVulkanMemoryModelDeviceScope
+CapabilityVulkanMemoryModelDeviceScopeKHR
+CapabilityPhysicalStorageBufferAddresses
+CapabilityPhysicalStorageBufferAddressesEXT
+CapabilityDemoteToHelperInvocationEXT
+CapabilityAtomicFloat32MinMaxEXT
+CapabilityAtomicFloat64MinMaxEXT
+
+
+b. The Vulkan Offline modes currently only support the following extensions:  
+SPV_KHR_shader_ballot
+SPV_KHR_subgroup_vote
+SPV_KHR_device_group
+SPV_KHR_multiview
+SPV_KHR_shader_draw_parameters
+SPV_KHR_16bit_storage
+SPV_KHR_storage_buffer_storage_class
+SPV_KHR_8bit_storage
+SPV_KHR_variable_pointers
+SPV_KHR_float_controls
+SPV_KHR_shader_clock
+SPV_KHR_vulkan_memory_model
+SPV_KHR_post_depth_coverage
+SPV_KHR_non_semantic_info
+SPV_KHR_physical_storage_buffer
+SPV_KHR_terminate_invocation
+SPV_KHR_FRAGMENT_SHADING_RATE
+SPV_EXT_nonuniform_qualifier
+SPV_EXT_shader_stencil_export
+SPV_EXT_shader_viewport_index_layer
+SPV_EXT_demote_to_helper_invocation
+SPV_EXT_shader_image_atomic_int64
+SPV_AMD_shader_ballot
+SPV_AMD_shader_trinary_minmax
+SPV_AMD_shader_explicit_vertex_parameter
+SPV_AMD_gcn_shader
+SPV_AMD_gpu_shader_half_float
+SPV_AMD_texture_gather_bias_lod
+SPV_AMD_gpu_shader_int16
+SPV_AMD_shader_fragment_mask
+SPV_AMD_shader_image_load_store_lod
+SPV_AMD_shader_texel_buffer_explicit_format
+SPV_AMD_property_id_attachment
+SPV_AMD_anisotropic_lod_compensation
+SPV_ARB_shader_ballot
+SPV_GOOGLE_decorate_string
+SPV_GOOGLE_hlsl_functionality1
+SPV_GOOGLE_user_type
+
+
+-	In Vulkan offline mode, in the case where no output file name is provided and post-processing (live register analysis or control-flow graph generation) is enabled, a false error message is printed.
+
+GUI Application
+---------------
+-	VGPR Pressure feature: certain instructions (image_* in particular) may report more live registers than actually used.
+-	�Correlation Disabled� notification in the source code editor is not being saved for projects after they were closed.
+-	Certain SALU instructions are being misclassified as VALU instructions. 
+-	Certain GDS instructions are being misclassified as SALU.
+-	Changing disassembly columns can be sluggish on certain systems in projects with multiple .cl files.
+-	On systems with default Unicode path for the RGA projects folder, the tool will not be able to save files. A workaround has been provided in version 2.6.1 (allowing the user to change the folder in which projects are saved).
+-	Cannot rename source files whose file name contains a whitespace character.
+
+Notes for OpenCL Mode Users 
+===========================
+The Offline OpenCL mode uses the Lightning Compiler package that ships with RGA, which is based on clang. 
+As of version 2.0, RGA allows developers to replace the Lightning Compiler package that ships with the product with a user-provided LLVM-based package. For more information, see the Radeon GPU Analyzer GUI app's help manual, or run the command line tool with �s opencl �h as arguments (look for the �Alternative OpenCL Lightning Compiler� section).
+
+Notes for DirectX 11 Mode Users
+===============================
+RGA's DirectX 11 (-s dx11) mode will use the driver that is associated with the primary display adapter, by default. If your primary display adapter is not an AMD GPU, or if you would like RGA to use a driver that is associated with a different display adapter that is installed on your system, use the --adapters and --set-adapter <id> command line switches to instruct RGA to use the relevant driver.
+
+System Requirements
+===================
+It is generally recommended to use RGA with the latest Radeon Software version. Specifically, to target the RDNA architecture, the latest Radeon Software version is required (except the Offline Vulkan, OpenGL and OpenCL modes, which are independent of the driver).
+
+Vulkan Mode
+-----------
+To use the installed driver in Vulkan mode:
+a.	Vulkan SDK 1.1.97.0 or later is required.
+b.	Latest Adrenalin or amdgpu-pro driver is required.
+
+Vulkan Offline Modes (vk-offline, vk-spv-offline, vk-spv-txt-offline)
+---------------------------------------------------------------------
+All Vulkan offline modes (vk-offline, vk-spv-offline and vk-spv-txt-offline) are independent of the installed driver and graphics hardware and should work on any x86-based system. 
+
+OpenGL Offline Mode (opengl)
+----------------------------
+The new OpenGL mode (introduced in RGA 2.6.2) is independent of the installed driver and graphics hardware and should work on any x86-based system. 
+
+DirectX 12 and DirectX 11 Modes
+-------------------------------
+It is recommended to use the latest Adrenalin drivers for the best experience in DirectX 12 and DirectX 11 modes.
+
+Offline OpenCL Mode
+-------------------
+Offline OpenCL mode (-s opencl) is independent of the installed driver and graphics hardware and should work on any x86-based system. 
+

ThirdParty/Bin/Windows64/RadeonGpuAnalyzer/docs/help/rga/html/_sources/help_manual.rst.txt

@@ -0,0 +1,901 @@
+.. Radeon GPU Analyzer Quickstart
+
+Help Manual
+===========
+
+Installing and Running RGA
+--------------------------
+The tool is available for download on the `RGA GitHub releases page <https://github.com/GPUOpen-Tools/RGA/releases>`_.
+
+- **Windows**: use the .msi installer or .zip archive. For Vulkan®, the installer would also install the RGA Layer and hence is the recommended option.
+- **Linux**: use the .tgz archive.
+
+To run the app, run the RadeonGPUAnalyzerGUI executable.
+
+Startup dialog
+^^^^^^^^^^^^^^
+
+The graphical user interface has been extended to support more than a single API, so you will now be prompted to select your default API of choice on startup.
+You can check the “Do not ask me again” check box to always launch the app in the desired mode.
+
+.. image:: images/2_1/startup_page_vulkan.png
+
+Vulkan® Mode
+------------
+
+The Home Page
+^^^^^^^^^^^^^
+At the top of the home page, you will find two tabs:
+
+.. image:: images/2_1/home_page_tabs_vulkan.png
+
+Start Tab
+`````````
+From the Start tab, you can create a new project or load an existing project.
+
+Creating an RGA Vulkan® Project
+"""""""""""""""""""""""""""""""
+The new RGA Vulkan® mode compiles Vulkan® pipelines, which are comprised of shaders and state. The shaders can come in the form of SPIR-V™ binaries or, alternatively,
+you can provide RGA GLSL source code, and the tool would pass the shaders through the front-end compiler (glslang) to generate the SPIR-V™ binaries for you.
+
+To handle the state, we defined a JSON representation of the Vulkan® pipeline state:
+
+* .gpso file format for VkGraphicsPipelineCreateInfo, for Vulkan® graphics pipeline state
+* .cpso file format for VkComputePipelineCreateInfo, for Vulkan® compute pipeline state
+
+You can think of those files as a “recipe” for creating the Vulkan® pipeline state in runtime. To compile your pipeline, RGA would spawn a separate
+process (named VulkanBackend), which would create the Vulkan® instance, configure the pipeline state according to the recipe, and create the VkShaderModule objects from your shaders.
+
+When you create a project within the app, a default .gpso / .cpso file would be generated for you with a default state. The default state is just enough for compiling very basic shaders, however, for most practical use cases, you would have to edit the state to match your shaders (please see the "Pipeline State Editor" section for more details). In the case that the pipeline creation for your shaders fails, the compilation process would fall back to using the offline Vulkan® mode (-s vk-offline-spv). The following warning indicator is displayed in the bottom right corner of the application if this occurs.
+
+.. image:: images/2_1/vk_spv_offline_indicator.png
+
+The offline mode produces less accurate ISA disassembly and resource usage statistics, and therefore it is highly recommended to adjust the pipeline state to match your shaders so that the compilation can go through the driver and produce the best results.
+
+In the Start tab for Vulkan® mode, you have two options:
+
+- Create a graphics pipeline
+- Create a compute pipeline
+
+.. image:: images/2_1/home_page_vulkan.png
+
+* **Graphics pipeline projects**
+
+	* May contain a shader for every stage of the graphics pipeline: Vertex, Tessellation Control, Tessellation Evaluation, Geometry, and Fragment.
+	* A Vertex shader is required at minimum to successfully build the pipeline.
+	* Within the graphics pipeline project, you would be able to configure the Vulkan® graphics pipeline state in the UI
+
+* **Compute pipeline projects**
+
+	* May contain a single Compute shader stage.
+	* Within the compute pipeline project, you would be able to configure the Vulkan® compute pipeline state in the UI
+
+You can also create a compute or graphics pipeline through the File menu by:
+
+* Clicking on File -> "Create new Vulkan® graphics pipeline" (Ctrl+Alt+G)
+* Clicking on File -> "Create new Vulkan® compute pipeline" (Ctrl+Alt+C)
+
+.. image:: images/2_1/file_menu_create_pipeline_vulkan.png
+
+You will then be prompted for an optional rename of your pipeline project:
+
+.. image:: images/2_1/create_project_vulkan.png
+
+RGA will use a yymmdd-hhmmss date-time string as a default name. Check the "Always use auto-generated project names" check box to instruct RGA to always use the default name without prompting for renaming.
+
+Loading a Project
+"""""""""""""""""
+You can load an existing project (.rga file) using the Ctrl+Alt+O shortcut or by clicking on an item on the Recent menu in the home page (note that the project type can be seen in the symbol to the right of the recent project link):
+
+.. image:: images/2_1/load_existing_project_vulkan.png
+
+It is also possible to load a project from the File -> "Open existing RGA project..." menu item:
+
+.. image:: images/2_1/open_existing_project_vulkan.png
+
+Settings Tab
+````````````
+From the Settings tab, you can control the global settings:
+
+Application settings
+""""""""""""""""""""
+The Application settings view is used to configure global application settings that aren't associated with a single API mode:
+
+.. image:: images/2_1/app_settings_vulkan.png
+
+* **General**
+
+	* Log file location: The folder in which RGA would generate log files. Upon startup RGA will clean up the log files that are older than 3 days.
+
+	* Project file location: The folder in which RGA would generate project files.
+
+	* Always use auto-generated project names: If checked, RGA will always use the auto-generated project name, without prompting for a rename when creating a new project.
+
+	* Default API on startup: RGA will always enter the selected API Mode upon startup.
+
+* **Disassembly View**
+
+	* Disassembly view columns: The set of disassembly view columns which will be visible by default.
+
+* **Source code editor**
+
+	* Font & Font Size: Configure the default font style and size settings used in the shader source code editor.
+	* Open include files with: Select the default text editor application that's launched when opening include files.
+
+* **Input files**
+
+	* Associate file extension association: Choose the set of file extensions used to associate RGA with various shader input source files.
+
+Default Vulkan® Build Settings
+""""""""""""""""""""""""""""""
+
+.. image:: images/2_1/build_settings_vulkan.png
+
+* **General**
+
+	* **Target GPUs:**
+
+		These are the target architectures that the code would be built for. You can click the "..." button near this item to open RGA's target GPUs dialog. When looking at the target devices, we need to consider 3 terms:
+
+			* Architecture: the name of the GPU HW architecture, such as Vega.
+			* Compute capability: the name of the architecture variant. From the compiler's point of view, GPUs with the same compute capability are identical. Therefore, RGA treats all of the product names that share the same compute capability as a single Target GPU.
+			* Product name: this is the public name of the GPU product, such as "Radeon Instinct MI25" or "Radeon RX Vega".
+
+	* **Predefined macros:**
+
+		Preprocessor directives which can come in two forms:
+
+				* X, for example _WIN32 or _DEBUG
+				* X=Y, for example "RT_NUM=3"
+
+		You can either enter the values manually with a ";" between each directive, or use the dedicated view (click the "..." button to show it).
+		In case that a directive contains whitespace characters, make sure to wrap the directive with "".
+
+	* **Additional include directories:**
+
+		Additional paths which the compiler would use when searching for source files.
+
+		You can either enter the values manually with a ";" between each path, or use the dedicated view (click the "..." button to show it).
+		In case that a path contains whitespace characters, make sure to wrap the path with "".
+
+* **Vulkan® Options**
+
+	* **ICD location:**
+
+		Full path to a Vulkan® ICD. If given, RGA would load the given ICD explicitly instead of the Vulkan® loader. This setting is useful if you want RGA to use an older or newer AMD Vulkan® driver (amdvlk64.dll/.so) to compile your pipeline. You can just browse for the file here, and RGA would make sure to use that file instead of the system's default.
+
+	* **Enable validation layers:**
+
+		Enable Vulkan® validation layers. This feature is useful when the build process fails at or around the pipeline creation stage. If your compilation failed at the front-end stage (GLSL -> SPIR-V™ or SPIR-V™ text to SPIR-V™ binary), then you will probably get a meaningful error message in the build output from the front-end compiler (glslang). However, if the build failure fails deeper in the stack, there will be very limited error messages, since AMD's shader compiler does not provide error messages. Enabling the validation layers can help shed light on the specific pipeline settings that was not configured properly or did not match your shaders.
+
+	* **Additional glslang options:**
+
+	    Additional options to be passed to glslang for Vulkan® front-end compilation (for example, "--target-env vulkan1.1 --suppress-warnings"). You can pass any options that are accepted by glslang here, and rga would pass those through to glslang when compiling your GLSL code or reassembling your SPIR-V™ binaries.
+
+	* **Use alternative front-end compiler package:**
+
+	    Path to alternative compiler's binaries folder. The following executables are expected to be in this folder: glslangValidator, spirv-as, spirv-dis. If given, this package would be used instead of the glslang package that is bundled with RGA to compile GLSL to SPIR-V, disassemble SPIR-V™ binaries, reassemble SPIR-V™ binaries, etc.
+
+	* **Name of output binary:**
+
+	    The file name which will be used for the generated pipeline binary ELF file.
+
+	* **Settings command line**
+
+	    The command string which will be passed to the RGA backend when it is invoked. This command string is dynamically populated from the values that you set in the UI.
+
+The Build View
+^^^^^^^^^^^^^^
+
+After you add or create a new file, RGA will create a project for you and switch to the Build View.
+To learn how to create a project, please visit RGA's Quickstart documentation.
+
+The build view consists of 4 views:
+- File Menu
+- Source Code View
+- Disassembly View
+- Build Output View
+
+File Menu
+`````````
+Using the File Menu you can:
+
+	* Create a template GLSL shader source file by clicking on "Create template GLSL file".
+	* Add an existing SPIR-V™ binary or GLSL source file to your project by clicking on "Add existing GLSL/SPIR-V file".
+	* Open the pipeline state editor by clicking on "Pipeline state", or using the F9 shortcut.
+	* Open the project-specific build settings by clicking on "Build settings", or using the F8 shortcut. For more details about the build settings view, please see the Build Settings section.
+
+.. image:: images/2_1/file_menu_vulkan.png
+
+Clicking on a shader stage file item will switch focus to that file, and display the file's contents in the Source View and Disassembly View (if any content is available for that file). The current item is highlighted in yellow.
+
+The user can add an existing shader file or create a new one by clicking on the "+" button in each stage.
+
+.. image:: images/2_1/create_file_vulkan.png
+
+The user can remove an existing file from a pipeline's shader stage by hovering on the item and clicking on the remove button.
+
+.. image:: images/2_1/remove_shader_stage_vulkan.png
+
+Pipeline State Editor
+`````````````````````
+
+The pipeline state editor provides a tree representation of the Vulkan® pipeline state, allowing the user to edit a graphics or compute pipeline's creation parameters. It is important to configure a project's pipeline state to match the required shader inputs & outputs or the pipeline may fail to compile successfully.
+
+.. image:: images/2_1/pipeline_state_vulkan.png
+
+The Pipeline State editor can be opened by clicking on the "Pipeline state" button within the file menu, or by using the F9 keyboard shortcut.
+
+.. image:: images/2_1/pipeline_state_button_vulkan.png
+
+Several create info structures are available to be configured within this view depending on the project's pipeline type:
+
+- Graphics pipeline
+
+	- VkGraphicsPipelineCreateInfo
+	- VkPipelineLayoutCreateInfo
+	- VkDescriptorSetLayoutCreateInfo array
+	- VkRenderPassCreateInfo
+
+- Compute pipeline
+
+	- VkComputePipelineCreateInfo
+	- VkPipelineLayoutCreateInfo
+	- VkDescriptorSetLayoutCreateInfo array
+
+The pipeline state parameters can be searched using structure names or values. You can use the Ctrl+F (Edit -> Find) to open the search widget within the state tree:
+
+.. image:: images/2_1/pipeline_state_search_vulkan.png
+
+If search results are found, the state tree will automatically scroll to the first occurrence. All search results are highlighted in orange, while the currently selected occurrence is highlighted with light gray.
+
+.. image:: images/2_1/pipeline_state_search_results_vulkan.png
+
+Use the "Find Previous" and "Find Next" arrow buttons, or the F3 and Shift+F3 hotkeys, to step through all matches sequentially.
+
+.. image:: images/2_1/pipeline_state_search_vulkan_previous_next.png
+
+It is also possible to use the filter option while searching:
+
+.. image:: images/2_1/pipeline_state_search_viewport_vulkan.png
+
+Searching with this option on will filter the state tree to display only the relevant sections:
+
+.. image:: images/2_1/pipeline_state_search_results_filter_vulkan.png
+
+The pipeline state can be loaded from an RGA pipeline state file. RGA stores the Vulkan® pipeline state in a JSON file:
+
+- .gpso file for graphics pipelines, with a representation of VkGraphicsPipelineCreateInfo
+- .cpso file for compute pipelines, with a representation of VkComputePipelineCreateInfo
+
+These files can be serialized from your Vulkan® app in runtime using the RGA layer, a beta feature that ships with RGA. For more info about this feature, see the "Use the RGA Layer" section.
+
+Source Code View
+````````````````
+The Source Code View shows the source code for the currently selected item in the file menu.
+
+On the left side of the Source Code View, you will find running line numbers.
+
+You can use the Ctrl+F (Edit -> Find) and Ctrl+G (Edit -> Go to...) to search for a string or jump to a specific line.
+
+.. image:: images/013_build_view_source_view.png
+
+After a successful build, when the disassembly view becomes visible alongside the Source Code View,
+you can double-click on the view's black title bar to maximize it.
+You can also click on the resize icon at the top right corner to maximize/minimize the view:
+
+.. image:: images/013_build_view_title_bar.png
+
+Build Output View
+`````````````````
+When a build is triggered, the RGA command line app is being launched to execute the build. Its output would be streamed into the Build Output View.
+
+.. image:: images/014_build_view_build_output.png
+
+Double-clicking on the top black title bar (or clicking on the resize button at its right corner) would maximize/minimize the Build Output View.
+
+The Clear button at the top right corner will clear the text from the view.
+
+Disassembly View
+````````````````
+The disassembly for the selected shader stage will be displayed in the disassembly view on the right:
+
+.. image:: images/2_1/disassembly_view_vulkan.png
+
+* Memory instructions are colored in red to help you identify spots with high memory pressure
+* The Columns drop-down menu at the top can be used to customize the presented columns
+* If more than one GPU was targeted, use the drop-down on the top left corner to switch devices
+
+The resource usage section under the disassembly table shows the GPU resources that are consumed by the ISA. The information found in the view is displayed as follows:
+
+	* VGPR consumption: <used>/<available>
+	* SGPR consumption: <used>/<available>
+	* VGPR spills (if occurred, otherwise - not shown)
+	* SGPR spills (if occurred, otherwise - not shown)
+	* LDS consumption: <used>/<available>
+	* Scratch memory usage
+	* Instruction cache usage
+
+.. image:: images/2_1/resource_usage_view_vulkan.png
+
+In cases where performance hazards are detected due to the usage of a GPU resource, RGA will display a warning icon and highlight the relevant resources in yellow:
+
+.. image:: images/015_build_view_disassembly_resource_usage_hazard.png
+
+Resource hazards that may require the developer's attention are defined as:
+
+	* VGPR/SGPR hazard: there were register spills, or, <used> == <available>.
+	* LDS hazard: <used> == <available> in LDS.
+	* Scratch memory hazard: scratch memory is used.
+	* Instruction cache hazard: code size is larger than the instruction cache.
+
+VGPR Pressure Visualization
+
+After successfully building your code, you will notice a new column in the disassembly view named “VGPR pressure”.
+This column is shown by default and can be hidden using the "Columns" dropdown.
+Below is a screenshot showing this column.
+
+.. image:: images/027_live_vgpr_pressure_column.png
+
+The column header text format is “VGPR pressure (used x; allocated: y/256)”, which provides a summary for the entire shader, where ‘x’ gives the total VGPRs used by the current shader and ‘y’ gives the total number of VGPRs allocated.
+Hovering over any of the column’s cells, will show a tooltip with a summary of the live VGPR at that specific instruction, with a hint about how many VGPRs need to be reduced to save a VGPR block at that instruction.
+Note that VGPRs are allocated in blocks, which vary in size. The VGPR block size is determined by the target GPU and, in certain cases, by specific characteristics of the shader, such as the wave size it was compiled for. The hint indicates how many VGPRs need to be freed to free up an entire block of VGPRs at that point of the shader:
+
+.. image:: images/026_live_vgpr_tooltip.png
+
+Note that, when generating the hint, the tool will take into account the target GPU and the relevant shader characteristics for determining the VGPR allocation block size for you.
+When examining the VGPR pressure column cells, in addition to the numerical value, which gives the number of live VGPRs at that instruction, you would notice a utilization bar that visualizes the VGPR usage and the VGPR block utilization. The emptier the utilization bar is, the less of the allocated VGPR block is being utilized, which means that less VGPRs would need to be reduced to free up that block:
+
+.. image:: images/029_live_vgpr_allocation_block.png
+
+In the above screenshot, we have a shader with a VGPR allocation block size of 8 VGPRs. You can see that different lines have different colors
+in their visualization bar. The bar’s color would be greener as the live VGPR value at that instruction gets closer to 0 and redder as the value
+gets closer to 256. The lines where the visualization bar is full (where the VGPR usage value is a multiple of 8, like 104, 96, 88 etc.)
+show points in the shader where the VGPR allocation block is fully utilized. However, in lines where the bar is partially empty, not all allocated VGPRs
+are being used. The tooltip hint that we mentioned earlier will let you know how many VGPRs need to be reduced to free up that VGPR allocation block.
+
+If the register pressure details of any instruction could not be generated, there will be a red hazard symbol as shown in the image below.
+The instructions that could not be parsed will have "N/A" in the VGPR pressure column.
+Hovering over the hazard symbol provides the count of instructions that could not be parsed in the form of a tooltip.
+
+.. image:: images/025_live_vgpr_NA_Error.png
+
+In case the number of VGPRs used hits the max on any instruction, there will be a yellow hazard symbol as shown in the image below.
+
+.. image:: images/028_live_vgpr_yellow_hazard.png
+
+As mentioned earlier, a visualization bar’s color would be greener as the live VGPR value at that instruction gets closer to 0 and redder as the value gets closer to 256.
+To calculate the color for each instruction's visualization bar, we break down the 0-256 VGPR range into 8 ranges, each of which covers 32 VGPRs (0-32, 32-64 etc.).
+Each range is assigned a unique color starting with light green for the first range to dark red for the last range. Below is a screenshot showing various color ranges:
+
+.. image:: images/024_live_vgpr_range_colors.png
+
+OpenCL™ Offline Mode
+--------------------
+
+The Home Page
+^^^^^^^^^^^^^
+At the top of the home page, you will find two tabs:
+
+.. image:: images/007_home_page_b_tabs.png
+
+Start Tab
+`````````
+From the Start tab, you can create a new project or load an existing project.
+
+Creating a Project
+""""""""""""""""""
+RGA Project is a vehicle that can contain any number of OpenCL™ source files (.cl), together with a set of build settings.
+When you build the project, the OpenCL™ source files are being compiled and linked together into a single HSA Code Object binary.
+
+RGA will automatically create for you the project when you add or create a file in the Home Page.
+
+To add an existing .cl source file, use Ctrl+O or click on "Open existing .cl file" under the Start section:
+
+.. image:: images/001_open_file_link_button.png
+
+You can also do this by clicking on File -> "Open existing .cl file":
+
+.. image:: images/001_open_file_menu_bar.png
+
+In a similar way, you can create a project by creating an empty .cl file. Use the Ctrl+N shortcut or click on "Create new .cl file".
+
+You will then be prompted for an optional rename of your project:
+
+.. image:: images/002_rename_project.png
+
+RGA will use a yymmdd-hhmmss date-time string as a default name. Check the "Always use auto-generated project names" check box to instruct RGA to always use the default name without prompting for renaming.
+
+Loading a Project
+"""""""""""""""""
+You can load an existing project (.rga file) using the Ctrl+Alt+O shortcut or by clicking on an item on the Recent menu in the home page:
+
+.. image:: images/007_home_page_b_recent.png
+
+It is also possible to load a project from the File -> "Open existing RGA project..." menu item:
+
+.. image:: images/008_home_page_b_open_project.png
+
+Settings Tab
+````````````
+From the Settings tab, you can control the global settings:
+
+Application settings
+""""""""""""""""""""
+The Application settings view is used to configure global application settings that aren't associated with a single API mode:
+
+.. image:: images/010_home_page_b_settings_app.png
+
+* **General**
+
+	* Log file location: The folder in which RGA would generate log files. Upon startup RGA will clean up the log files that are older than 3 days.
+
+	* Project file location: The folder in which RGA would generate project files.
+
+	* Always use auto-generated project names: If checked, RGA will always use the auto-generated project name, without prompting for a rename when creating a new project.
+
+	* Default API on startup: RGA will always enter the selected API Mode upon startup.
+
+* **Disassembly View**
+
+	* Disassembly view columns: The set of disassembly view columns which will be visible by default.
+
+* **Source code editor**
+
+	* Font & Font Size: Configure the default font style and size settings used in the shader source code editor.
+	* Open include files with: Select the default text editor application that's launched when opening include files.
+
+* **Input files**
+
+	* Associate file extension association: Choose the set of file extensions used to associate RGA with various shader input source files.
+
+
+Default OpenCL™ Build Settings
+""""""""""""""""""""""""""""""
+
+.. image:: images/011_home_page_b_settings_build_cl.png
+
+This section allows you to configure the default build settings that RGA would use. Any subsequent project that you create would be configured to use that set of default
+OpenCL™ build settings. You can then change the project-specific project settings. For example, if you would always like your projects to have MAD instructions enabled,
+check the "Enable MAD instructions" checkbox in the global OpenCL™ build settings. Any project that you create from that point would have MAD instructions enabled.
+
+* **General**
+
+	* **Target GPUs:**
+
+		These are the target architectures that the code would be built for. You can click the "..." button near this item to open RGA's target GPUs dialog. When looking at the target devices, we need to consider 3 terms:
+
+			* Architecture: the name of the GPU HW architecture, such as Vega.
+			* Compute capability: the name of the architecture variant. From the compiler's point of view, GPUs with the same compute capability are identical. Therefore, RGA treats all of the product names that share the same compute capability as a single Target GPU.
+			* Product name: this is the public name of the GPU product, such as "Radeon Instinct MI25" or "Radeon RX Vega".
+
+	* **Predefined macros:**
+
+		Preprocessor directives which can come in two forms:
+
+				* X, for example _WIN32 or _DEBUG
+				* X=Y, for example "RT_NUM=3"
+
+		You can either enter the values manually with a ";" between each directive, or use the dedicated view (click the "..." button to show it).
+		In case that a directive contains whitespace characters, make sure to wrap the directive with "".
+
+	* **Additional include directories:**
+
+		Additional paths which the compiler would use when searching for source files.
+
+		You can either enter the values manually with a ";" between each path, or use the dedicated view (click the "..." button to show it).
+		In case that a path contains whitespace characters, make sure to wrap the path with "".
+
+* **OpenCL™ Options**
+
+	This section includes a set of OpenCL™ options that can be passed to the compiler.
+
+	* **Treat double floating-point as single (-cl-single-precision-constant):**
+
+		Treat double precision floating-point constant as single precision constant.
+
+	* **Flush denormalized floating-point numbers as zeros (-cl-denorms-are-zero):**
+
+		This option controls how single precision and double precision denormalized numbers are handled. If specified as a build option, the single precision denormalized numbers may be flushed to zero and if the optional extension for double precision is supported, double precision denormalized numbers may also be flushed to zero. This is intended to be a performance hint and the OpenCL™ compiler can choose not to flush denorms to zero if the device supports single precision (or double precision) denormalized numbers. This option is ignored for single precision numbers if the device does not support single precision denormalized numbers i.e. CL_FP_DENORM bit is not set in CL_DEVICE_SINGLE_FP_CONFIG. This option is ignored for double precision numbers if the device does not support double precision or if it does support double precision but not double precision denormalized numbers i.e. CL_FP_DENORM bit is not set in CL_DEVICE_DOUBLE_FP_CONFIG. This flag only applies for scalar and vector single precision floating-point variables and computations on these floating-point variables inside a program. It does not apply to reading from or writing to image objects.
+
+	* **Correctly round single-precision floating-point divide and sqrt (-cl-fp32-correctly-rounded-divide-sqrt):**
+
+		Specifies that single precision floating-point divide (x/y and 1/x) and sqrt used in the program source are correctly rounded. If this option is not specified, the minimum numerical accuracy of single precision floating-point divide and sqrt are as defined in section 7.4 of the OpenCL™ specification. This build option can only be specified if the CL_FP_CORRECTLY_ROUNDED_DIVIDE_SQRT is set in CL_DEVICE_SINGLE_FP_CONFIG (as defined in in the table of allowed values for param_name for clGetDeviceInfo) for devices that the program is being build. clBuildProgram or clCompileProgram will fail to compile the program for a device if the -cl-fp32-correctly-rounded-divide-sqrt option is specified and CL_FP_CORRECTLY_ROUNDED_DIVIDE_SQRT is not set for the device.
+
+	* **Assume strict aliasing rules (-cl-strict-aliasing):**
+
+		Allow the compiler to assume the most strict aliasing rules. This option is deprecated and added for compatibility with OpenCL™ 1.0.
+
+	* **Enable MAD instructions (-cl-mad-enable):**
+
+		Allow a * b + c to be replaced by a mad. The mad computes a * b + c with reduced accuracy. For example, some OpenCL™ devices implement mad as truncate the result of a * b before adding it to c.
+
+	* **Ignore the signedness of zeros (-cl-no-signed-zeros):**
+
+		Allow optimizations for floating-point arithmetic that ignore the signedness of zero. IEEE 754 arithmetic specifies the behavior of distinct +0.0 and -0.0 values, which then prohibits simplification of expressions such as x+0.0 or 0.0*x (even with -clfinite-math only). This option implies that the sign of a zero result isn't significant.
+
+	* **Allow unsafe optimizations (-cl-unsafe-math-optimizations):**
+
+		Allow optimizations for floating-point arithmetic that (a) assume that arguments and results are valid, (b) may violate IEEE 754 standard and (c) may violate the OpenCL™ numerical compliance requirements as defined in section 7.4 for single-precision and double-precision floating-point, and edge case behavior in section 7.5. This option includes the -cl-no-signed-zeros and -cl-mad-enable options.
+
+	* **Assume no NaN nor infinite (-cl-finite-math-only):**
+
+		Allow optimizations for floating-point arithmetic that assume that arguments and results are not NaNs or +/- infinity. This option may violate the OpenCL™ numerical compliance requirements defined in in section 7.4 for single-precision floating-point, section 9.3.9 for double-precision floating-point, and edge case behavior in section 7.5.
+
+	* **Aggressive math optimizations (-cl-fast-relaxed-math):**
+
+		Sets the optimization options -cl-finite-math-only and -cl-unsafe-math-optimizations. This allows optimizations for floating-point arithmetic that may violate the IEEE 754 standard and the OpenCL™ numerical compliance requirements defined in the specification in section 7.4 for single-precision and double-precision floating-point, and edge case behavior in section 7.5. This option causes the preprocessor macro __FAST_RELAXED_MATH__ to be defined in the OpenCL™ program.
+
+	* **Correctly round single-precision floating-point divide and sqrt (-cl-fp32-correctly-rounded-divide-sqrt):**
+
+		Specifies that single precision floating-point divide (x/y and 1/x) and sqrt used in the program source are correctly rounded. If this option is not specified, the minimum numerical accuracy of single precision floating-point divide and sqrt are as defined in section 7.4 of the OpenCL™ specification. This build option can only be specified if the CL_FP_CORRECTLY_ROUNDED_DIVIDE_SQRT is set in CL_DEVICE_SINGLE_FP_CONFIG (as defined in in the table of allowed values for param_name for clGetDeviceInfo) for devices that the program is being build. clBuildProgram or clCompileProgram will fail to compile the program for a device if the -cl-fp32-correctly-rounded-divide-sqrt option is specified and CL_FP_CORRECTLY_ROUNDED_DIVIDE_SQRT is not set for the device.
+
+	* **Optimization level:**
+
+		Sets the OpenCL™ compiler's optimization level:
+
+			* Default: the compiler default optimization level
+			* --O0: disable optimization
+			* --O1: enable minimal optimization
+			* --O2: optimize for speed
+			* --O3: apply full optimization
+
+* **Alternative compiler**
+
+	By default, RGA will use the compiler that is bundled with the package. To use an alternative compiler, provide the following paths:
+
+		* **Binaries folder:**
+
+			Path to alternative compiler's binaries folder. The following executables are expected to be in this folder: clang, lld, llvm-objdump, llvm-readobj.
+
+		* **Includes folder:**
+			Path to alternative compiler's headers folder. The specified folder is expected to contain opencl-c.h header file.
+
+		* **Libraries folder:**
+			Path to alternative compiler's OpenCL™ device libraries folder. The following bitcode files are expected to be in the specified folder: irif.amdgcn.bc, ockl.amdgcn.bc, oclc_correctly_rounded_sqrt_off.amdgcn.bc, oclc_correctly_rounded_sqrt_on.amdgcn.bc, oclc_daz_opt_off.amdgcn.bc, oclc_daz_opt_on.amdgcn.bc, oclc_finite_only_off.amdgcn.bc, oclc_finite_only_on.amdgcn.bc, oclc_isa_version_900.amdgcn.bc, oclc_isa_version_901.amdgcn.bc, oclc_isa_version_902.amdgcn.bc, oclc_unsafe_math_off.amdgcn.bc, oclc_unsafe_math_on.amdgcn.bc, ocml.amdgcn.bc, opencl.amdgcn.bc
+
+* **Settings command line**
+
+	The command string which will be passed to the RGA backend when it is invoked. This command string is dynamically populated from the values that you set in the UI.
+
+* **Additional clang options**
+
+	Additional options for the clang compiler. For example, use -Weverything to enable all diagnostics.
+
+The Build View
+^^^^^^^^^^^^^^
+
+After you add or create a new file, RGA will create a project for you and switch to the Build View.
+To learn how to create a project, please visit RGA's Quickstart documentation.
+
+The build view consists of 4 views:
+- File Menu
+- Source Code View
+- Disassembly View
+- Build Output View
+
+File Menu
+`````````
+Using the File Menu you can:
+
+	* Add an existing source file to your project by clicking on "Add file", or using the Ctrl+O shortcut
+	* Create a new source file by clicking on "Create file", or using the Ctrl+N shortcut
+	* Open the project-specific build settings by clicking on "Build settings", or using the F8 shortcut. For more details about the build settings view, please see the Build Settings section.
+
+.. image:: images/012_build_view_file_menu.png
+
+When you have more than a single file item in the menu, clicking on a file item will switch focus to that file,
+and display the file's contents in the Source View and Disassembly View (if any content is available for that file). The
+current item is highlighted in yellow.
+
+The user can remove an existing file within the project by hovering on the item and clicking on the remove button.
+
+.. image:: images/022_remove_source_file.png
+
+Source Code View
+````````````````
+The Source Code View shows the source code for the currently selected item in the file menu.
+
+On the left side of the Source Code View, you will find running line numbers.
+
+You can use the Ctrl+F (Edit -> Find) and Ctrl+G (Edit -> Go to...) to search for a string or jump to a specific line.
+
+.. image:: images/013_build_view_source_view_opencl.png
+
+After a successful build, when the disassembly view becomes visible alongside the Source Code View,
+you can double-click on the view's black title bar to maximize it.
+You can also click on the resize icon at the top right corner to maximize/minimize the view:
+
+.. image:: images/013_build_view_title_bar_opencl.png
+
+Build Output View
+`````````````````
+When a build is triggered, the RGA command line app is being launched to execute the build. Its output would be streamed into the Build Output View.
+
+.. image:: images/014_build_view_build_output_opencl.png
+
+Double-clicking on the top black title bar (or clicking on the resize button at its right corner) would maximize/minimize the Build Output View.
+
+The Clear button at the top right corner will clear the text from the view.
+
+Disassembly View
+````````````````
+The disassembly for the relevant kernel will be displayed in the disassembly view on the right:
+
+.. image:: images/023_disassembly_view_opencl.png
+
+* Highlighted rows are correlated to the current line in the source code view on the left
+* Memory instructions are colored in red to help you identify spots with high memory pressure
+* The Columns drop-down menu at the top can be used to customize the presented columns
+* If more than one GPU was targeted, use the drop-down on the top left corner to switch devices
+* The resource usage line shows the GPU resources that are consumed by the presented code
+
+The resource usage section under the disassembly table shows the GPU resources that are consumed by the ISA. The information found in the view is displayed as follows:
+
+	* VGPR consumption: <used>/<available>
+	* SGPR consumption: <used>/<available>
+	* VGPR spills (if occurred, otherwise - not shown)
+	* SGPR spills (if occurred, otherwise - not shown)
+	* LDS consumption: <used>/<available>
+	* Scratch memory usage
+	* Instruction cache usage
+
+.. image:: images/resource_usage_view_opencl.png
+
+In cases where performance hazards are detected due to the usage of a GPU resource, RGA will display a warning icon and highlight the relevant resources in yellow:
+
+.. image:: images/015_build_view_disassembly_resource_usage_hazard.png
+
+Resource hazards that may require the developer's attention are defined as:
+
+	* VGPR/SGPR hazard: there were register spills, or, <used> == <available>.
+	* LDS hazard: <used> == <available> in LDS.
+	* Scratch memory hazard: scratch memory is used.
+	* Instruction cache hazard: code size is larger than the instruction cache.
+
+How To...
+---------
+See App Version Info & Check for Updates
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Use the Ctrl+F1 shortcut or click on the Help -> About menu item.
+This will display the About dialog.
+
+.. image:: images/016_about_dialog.png
+
+In addition to the version number and build date of the RGA app, the About dialog displays the version and build date of the
+RGA command line executable which resides at the GUI app's folder. This allows you to see the details of the RGA command line executable
+that is being used by the GUI app. In the future, you may want to replace the command line executable before running
+the GUI application in a plug-and-play fashion (this is allowed as long as your RGA command line executable is of version 2.0. or above).
+
+To update RGA, click on "Check for updates" button and follow the instructions to get the latest update.
+
+Switch the API Mode
+^^^^^^^^^^^^^^^^^^^
+
+The API mode switch is used to toggle the GUI between operating in OpenCL™ and Vulkan® mode. The current mode is displayed within the RGA title bar and is also indicated by the color scheme of the application views and status bar (Green = OpenCL™ mode & Red = Vulkan® mode).
+
+.. image:: images/2_1/display_current_mode.png
+
+The selected API mode will be automatically switched to the required mode when loading an existing RGA project file. The API mode can also be toggled manually from within the GUI in the following locations:
+
+- The Mode Switch control in the bottom left of the main window when no project is loaded.
+
+	.. image:: images/2_1/switch_mode_from_start_page.png
+
+- Within the application's Settings Tab view under the General section.
+
+	.. image:: images/2_1/switch_mode_from_settings.png
+
+Find Project Files and Output Folder
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+The RGA project (.rga) files and the build artifacts are generated in a folder named "RadeonGPUAnalyzer" under the Operating System's native Documents folder
+for the current user.
+
+Build the Project
+^^^^^^^^^^^^^^^^^
+To build an already loaded project, select Build->Build project from the file menu.
+Alternatively, the keyboard shortcut Ctrl+Shift+B can also be used.
+
+Load existing Project
+^^^^^^^^^^^^^^^^^^^^^
+There are five possible ways to load an existing project:
+
+1.	From Start tab, locate your project under “Recent” list and click on it.
+
+.. image:: images/019_start_tab_recent_list.png
+
+2.	From Start tab, under Recent section, click on “Open .rga file from explorer…” and select a project file.
+
+.. image:: images/018_start_tab_open_project.png
+
+3.	Use the keyboard shortcut Ctrl+Alt+O.
+
+.. image:: images/020_file_menu_open_project.png
+
+4.	Select File->Open existing RGA project.
+
+.. image:: images/020_file_menu_open_project.png
+
+5.	Drag and drop an existing RGA project file (.rga) onto the RGA window on start page.
+
+.. image:: images/021_drag_n_drop_project.png
+
+Change Project's Build Settings
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Open the project-specific build settings by clicking on "Build settings", or using the F8 shortcut. For more details about the build settings options, please see the "Default OpenCL™ Build Settings" section.
+
+.. image:: images/012_build_view_file_menu_build_settings.png
+
+Rename a Project
+^^^^^^^^^^^^^^^^
+Double click on the project name at the top of the file menu (the left panel).
+
+.. image:: images/012_build_view_file_menu_rename_project.png
+
+Vulkan® Mode
+^^^^^^^^^^^^
+
+Edit Pipeline State
+```````````````````
+Clicking on "Pipeline state" button brings up the pipeline state editor.
+
+.. image:: images/2_1/pipeline_state_vulkan.png
+
+Enable Validation Layers
+````````````````````````
+Clicking on "Build settings" button brings up the build settings.
+Then checking "Enable validation layers" enables the validation layers.
+
+.. image:: images/2_1/enable_validation_layers_vulkan.png
+
+Use an alternative front-end compiler
+`````````````````````````````````````
+Clicking on "Build settings" button brings up the build settings.
+The location of the alternative front-end compiler can then be
+added in the text box, or be searched in the file system using the
+browse button next to the text box.
+
+.. image:: images/2_1/use_alternative_compiler_vulkan.png
+
+Use the RGA Layer (Beta Feature)
+````````````````````````````````
+
+The RGA Vulkan® layer, or, in its full name, "VK_LAYER_RGA_pipeline_extraction", is an implicit Vulkan® layer. This means that you can enable it without having to change your Vulkan® application's source code. To use the RGA layer, follow these steps:
+
+Installation
+""""""""""""
+To install the RGA Vulkan® layer on your machine:
+
+- Windows: Download and run the RGA .msi installer and follow the steps - this will install the entire RGA package on your machine: GUI application, command line tool and the RGA layer.
+- Linux: Download and extract the .tgz archive (tar -zxvf <archive name>). To install the layer, cd to the layer sub-folder and run the rga_layer_install script.
+
+Using the layer
+"""""""""""""""
+#. Set the following environment variables:
+
+    - **RGA_LAYER_OUTPUT_PATH**
+
+	This environment variable defines the output folder where the RGA layer would dump its output files (make sure that the folder exists).
+	Example (Windows):
+	SET RGA_LAYER_OUTPUT_PATH=C:\\RGALayerOutput\\bloom
+
+    - **RGA_LAYER_SPECIFIC_PIPELINE** (optional)
+
+	This environment variable provides a semicolon-separated list of strings representing the names of the pipelines that should be serialized (names can be set using the Vulkan® VK_EXT_debug_marker extension). If this environment variable is defined, the layer will only serialize pipelines whose name is included in the list, skipping any pipeline whose name is not in the list.
+	Example (Windows):
+	SET RGA_LAYER_SPECIFIC_PIPELINE=blurVert;blurHorz
+
+	In this case, the layer would only serialize pipelines that are named either "blurVert" or "blurHorz". All other pipelines would be ignored.
+
+    - **ENABLE_RGA_PIPELINE_EXTRACTION_LAYER=1**
+
+	This environment variable, when set to 1, activates the RGA layer. If this environment variable is not defined or its value is not 1, the RGA layer is ignored by the Vulkan® loader.
+
+#. Run your Vulkan® application with the above environment variables set. After you close your application, the layer will generate the output files in RGA_LAYER_OUTPUT_PATH. The output files will have the following naming convention:
+
+	- .gpso files: JSON file that contains the pipeline state for a Vulkan® graphics pipeline
+
+	- .cpso files: JSON file that contains the pipeline state for a Vulkan® compute pipeline
+
+	- .spv files: SPIR-V™ binary that was linked to the pipeline
+
+	The intercepted pipelines are enumerated from 1 to N by the order that they were written to the disk. The SPIR-V™ files and the pipeline state of each pipeline share the same prefix:
+
+	.. image:: images/2_1/layer_output_vulkan.png
+
+#. Now you have all you need in order to load your Vulkan® application's pipelines in RGA and analyze them to see what really happens on AMD GPUs when they run.
+
+Troubleshooting the RGA Layer
+"""""""""""""""""""""""""""""
+#. The RGA Layer supports the following optional environment variables to assist debugging and troubleshooting:
+
+	- **RGA_LAYER_LOG_ENABLE=1**
+
+		When this environment variable is set to 1, the RGA Layer will write a log file to RGA_LAYER_OUTPUT_PATH.
+
+#. If you could not get the RGA layer to generate any output file on your machine, go through the following check-list:
+
+	- **RGA_LAYER_OUTPUT_PATH** is defined, and the folder exists and is valid.
+
+	- **RGA_LAYER_LOG_ENABLE** is defined and is set to 1.
+
+	- **Windows**: Open regedit and make sure that the full path to RGA's manifest file is listed under Computer\HKEY_LOCAL_MACHINE\SOFTWARE\Khronos\Vulkan\ImplicitLayers. Also, make sure that the path contains both the layer's manifest (JSON) as well as the layer's .dll.
+
+	- **Linux**: Ensure sure that the layer's manifest (JSON) file and .so file are found in /usr/share/vulkan/implicit_layer.d. If this is not the case, run the rga_layer_install script.
+
+Using the RGA Layer Launcher (Windows Only)
+"""""""""""""""""""""""""""""""""""""""""""
+The RGA Layer Launcher is a Windows-only application that can be used to simplify enabling the RGA when launching a Vulkan® application.
+
+#.	Launch the RGA Layer Launcher app, and provide the target Vulkan® application's details.
+
+#.	Configure the layer settings:
+
+	- Output directory is where the layer would write its output files
+
+	- Pipeline names [optional]: provide a semicolon-separated list of strings representing the names of the pipelines that should be serialized (names can be set using the Vulkan® VK_EXT_debug_marker extension). If this environment variable is defined, the layer would only serialize the pipelines whose name is included in the list, skipping any pipeline whose name is not on the list.
+
+	Example #1: blurVert;blurHorz (would only intercept pipelines if they're named blurVert or blurHorz, and would ignore all other pipelines)
+
+	Example #2: blurVert (would only intercept pipelines if they're named blurVert, and would ignore all other pipelines)
+
+	.. image:: images/2_1/layer_launcher_vulkan.png
+
+OpenCL™ Offline Mode
+^^^^^^^^^^^^^^^^^^^^
+
+Find Code Object Binary and Build Artifacts
+```````````````````````````````````````````
+Right click on the disassembly view and click on "Show disassembly file in explorer".
+
+.. image:: images/017_disassembly_view_context_menu_opencl.png
+
+Use an Alternative Compiler
+```````````````````````````
+By default, RGA will use the compiler that is bundled with the package. You can use an alternative LLVM-based OpenCL™ compiler which supports the AMDGPU target by providing the following paths in the build settings:
+
+	* **Binaries folder:**
+		Path to alternative compiler's binaries folder. The following executables are expected to be in this folder: clang, lld, llvm-objdump, llvm-readobj.
+
+	* **Includes folder:**
+		Path to alternative compiler's headers folder. The specified folder is expected to contain opencl-c.h header file.
+
+	* **Libraries folder:**
+		Path to alternative compiler's OpenCL™ device libraries folder. The following bitcode files are expected to be in the specified folder: irif.amdgcn.bc, ockl.amdgcn.bc, oclc_correctly_rounded_sqrt_off.amdgcn.bc, oclc_correctly_rounded_sqrt_on.amdgcn.bc, oclc_daz_opt_off.amdgcn.bc, oclc_daz_opt_on.amdgcn.bc, oclc_finite_only_off.amdgcn.bc, oclc_finite_only_on.amdgcn.bc, oclc_isa_version_900.amdgcn.bc, oclc_isa_version_901.amdgcn.bc, oclc_isa_version_902.amdgcn.bc, oclc_unsafe_math_off.amdgcn.bc, oclc_unsafe_math_on.amdgcn.bc, ocml.amdgcn.bc, opencl.amdgcn.bc
+
+Keyboard Shortcuts
+------------------
+RGA provides several keyboard shortcuts to facilitate mouse-free usage.
+
+========================================   =========================
+Action                                     Shortcut
+========================================   =========================
+**General**
+Exit RGA                                   Alt+F4
+About                                      Ctrl+F1
+Back to home page                          Ctrl+Alt+H
+Open existing RGA project                  Ctrl+Alt+O
+Help manual                                F1
+Find Next & Find Previous                  F3 & Shift+F3
+Build settings                             F8
+Pipeline state                             F9
+Navigate between home page tabs            Ctrl+Tab & Ctrl+Shift+Tab
+Navigate Settings tab views                Ctrl+up/down arrow
+**Build view**
+Find                                       Ctrl+F
+Go to (source line)                        Ctrl+G
+Maximize/minimize views in build view      Ctrl+R
+Save file                                  Ctrl+S
+Build project                              Ctrl+Shift+B
+Cancel build                               Ctrl+Shift+X
+Cycle thru various views in build view     Ctrl+Tab & Ctrl+Shift+Tab
+Cycle thru various widgets in build view   Tab & Shift+Tab
+**Settings view**
+Restore default settings                   Ctrl+R
+**Vulkan® mode**
+Create new Vulkan® compute pipeline        Ctrl+Alt+C
+Create new Vulkan® graphics pipeline       Ctrl+Alt+G
+**OpenCL™ mode**
+Create new .cl file                        Ctrl+N
+Open existing .cl file                     Ctrl+O
+========================================   =========================

ThirdParty/Bin/Windows64/RadeonGpuAnalyzer/docs/help/rga/html/_sources/index.rst.txt

@@ -0,0 +1,35 @@
+Radeon GPU Analyzer (RGA)
+=========================
+Radeon GPU Analyzer (RGA) GUI application is a compiler and code analysis tool.
+
+The GUI application works on top of the RGA command line tool, which supports a rich set of APIs including Vulkan™, DirectX11® and OpenGL®.
+
+This documentation will focus on the GUI application, which currently supports:
+
+- Vulkan™ live-driver mode
+- OpenCL™ Offline, on top of AMD's LLVM-based Lightning compiler
+
+More information about the RGA command line tool can be found in its help manual ("-h" option), or on the `RGA Github page <https://github.com/GPUOpen-Tools/RGA>`_.
+
+.. toctree::
+   :maxdepth: 2
+   :caption: Contents:
+
+   quickstart.rst
+   help_manual.rst
+
+DISCLAIMER
+----------
+The information contained herein is for informational purposes only, and is subject to change without notice. While every
+precaution has been taken in the preparation of this document, it may contain technical inaccuracies, omissions and typographical
+errors, and AMD is under no obligation to update or otherwise correct this information. Advanced Micro Devices, Inc. makes no
+representations or warranties with respect to the accuracy or completeness of the contents of this document, and assumes no
+liability of any kind, including the implied warranties of noninfringement, merchantability or fitness for particular purposes, with
+respect to the operation or use of AMD hardware, software or other products described herein. No license, including implied or
+arising by estoppel, to any intellectual property rights is granted by this document. Terms and limitations applicable to the purchase
+or use of AMD’s products are as set forth in a signed agreement between the parties or in AMD's Standard Terms and Conditions
+of Sale.
+
+AMD, the AMD Arrow logo, Radeon, Ryzen, CrossFire, RDNA and combinations thereof are trademarks of Advanced Micro Devices, Inc. Other product names used in
+this publication are for identification purposes only and may be trademarks of their respective companies.
+© 2022 Advanced Micro Devices, Inc. All rights reserved.

ThirdParty/Bin/Windows64/RadeonGpuAnalyzer/docs/help/rga/html/_sources/quickstart.rst.txt

@@ -0,0 +1,200 @@
+.. Radeon GPU Analyzer Quickstart
+
+Quickstart
+==========
+
+Installing and Running RGA
+--------------------------
+The tool is available for download on the `RGA GitHub releases page <https://github.com/GPUOpen-Tools/RGA/releases>`_.
+
+- Windows: use the .msi installer or .zip archive from. For Vulkan®, the installer would also install the RGA Layer and hence is the recommended option.
+- Linux: use the .tgz archive.
+
+To run the app, run the RadeonGPUAnalyzerGUI executable.
+
+Startup dialog
+^^^^^^^^^^^^^^
+
+The graphical user interface has been extended to support more than a single API, so you will now be prompted to select your default API of choice on startup.
+You can check the “Do not ask me again” check box to always launch the app in the desired mode.
+
+.. image:: images/2_1/startup_page_vulkan.png
+
+Vulkan® Mode
+------------
+
+The Home Page
+^^^^^^^^^^^^^
+
+Select Vulkan® as the API of choice on startup. Then, in the home page, we have two options for a start:
+
+- Create a graphics pipeline
+- Create a compute pipeline
+
+Creating a Project
+^^^^^^^^^^^^^^^^^^
+
+.. image:: images/2_1/home_page_vulkan.png
+
+Let's start by creating a graphics pipeline.
+
+You will then be prompted for an optional rename of your project:
+
+.. image:: images/2_1/create_project_vulkan.png
+
+After the project is created, you can use this menu to add your shaders:
+
+.. image:: images/2_1/file_menu_vulkan.png
+
+When adding a shader file, you have two options:
+
+- Create a template GLSL file, auto-generated by RGA. This is a good option if you are interested in rapid prototyping and just want something that compiles to use as a base line.
+- Add an existing SPIR-V binary or GLSL source file.
+
+Let's create template vertex and fragment shaders:
+
+.. image:: images/2_1/create_file_vulkan.png
+
+After creating/adding a file, you can edit the source code in the editor. This is true not only to GLSL textual code. It is possible to load a SPIR-V binary in RGA. If you do that, the binary would be disassembled, and you will be able to edit it as textual code. Upon compilation, RGA would reassemble the SPIR-V binary for you.
+
+.. image:: images/2_1/new_file_vulkan.png
+
+After we edited our shader source code, SPIR-V binaries or mix thereof, let's make sure that the pipeline state matches our shaders. Clicking on Pipeline state would open the RGA's pipeline state editor:
+
+.. image:: images/2_1/pipeline_state_vulkan.png
+
+The editor provides a tree representation of the Vulkan® pipeline state, allowing the user to edit a graphics or compute pipeline's creation parameters.
+Different sections are available to be configured within this view depending on the project's pipeline type:
+
+- Graphics pipeline
+
+	- VkGraphicsPipelineCreateInfo
+	- VkPipelineLayoutCreateInfo
+	- VkDescriptorSetLayoutCreateInfo array
+	- VkRenderPassCreateInfo
+
+- Compute pipeline
+
+	- VkComputePipelineCreateInfo
+	- VkPipelineLayoutCreateInfo
+	- VkDescriptorSetLayoutCreateInfo array
+
+One nice thing about this view is that it allows you to visually see the create info structure relationships within the Vulkan® pipeline state, which is sometimes hard to do from just looking at the flat Vulkan® spec.
+
+You can use Ctrl+F to search the state:
+
+.. image:: images/2_1/pipeline_state_search_vulkan.png
+
+which would also scroll to the relevant occurrence:
+
+.. image:: images/2_1/pipeline_state_search_results_vulkan.png
+
+It is also possible to use the filter option while searching:
+
+.. image:: images/2_1/pipeline_state_search_viewport_vulkan.png
+
+Searching with this option on would only show the relevant parts of the tree:
+
+.. image:: images/2_1/pipeline_state_search_results_filter_vulkan.png
+
+Another useful option is loading the pipeline state file. RGA stores the Vulkan® pipeline state in a JSON file:
+
+- .gpso file for graphics pipelines, with a representation of VkGraphicsPipelineCreateInfo
+- .cpso file for compute pipelines, with a representation of VkComputePipelineCreateInfo
+
+These files can be serialized from your Vulkan® app in runtime using the RGA layer, a beta feature that ships with RGA. For more info about this feature, see the Vulkan® Help Manual section.
+
+When you build your project with RGA, the tool spawns a Vulkan® app that accepts the JSON representation of your state (based on the values in the UI),
+
+Generating Disassembly
+^^^^^^^^^^^^^^^^^^^^^^
+
+After the pipeline state matches our shaders, let's build the project:
+
+.. image:: images/2_1/build_project_vulkan.png
+
+The compiler output can be viewed at the Build output pane at the bottom:
+
+.. image:: images/2_1/build_project_output_vulkan.png
+
+And, in case of a successful build, the disassembly and HW resource usage info would be shown on the right:
+
+.. image:: images/2_1/disassembly_view_vulkan.png
+
+That's it - we got our first Vulkan® pipeline built with RGA.
+
+OpenCL™ Offline Mode
+--------------------
+
+The Home Page
+^^^^^^^^^^^^^
+
+Creating a Project
+^^^^^^^^^^^^^^^^^^
+RGA Project is a vehicle that can contain any number of OpenCL™ source files (.cl), together with a set of build settings.
+When you build the project, the OpenCL™ source files are being compiled and linked together into a single HSA Code Object binary.
+
+RGA will automatically create for you the project when you add or create a file in the Home Page.
+
+To add an existing .cl source file, use Ctrl+O or click on "Open existing .cl file" under the Start section:
+
+.. image:: images/001_open_file_link_button.png
+
+You can also do this by clicking on File -> "Open existing c.l file":
+
+.. image:: images/001_open_file_menu_bar.png
+
+In a similar way, you can create a project by creating an empty .cl file. Use the Ctrl+N shortcut or click on "Create new .cl file".
+
+You will then be prompted for an optional rename of your project:
+
+.. image:: images/002_rename_project.png
+
+RGA will use a yymmdd-hhmmss date-time string as a default name. Check the "Always use auto-generated project names" check box to instruct RGA to always use the default name without prompting for renaming.
+
+Generating Disassembly
+^^^^^^^^^^^^^^^^^^^^^^
+To build your project and generate the disassembly, use the Ctrl+Shift+B shortcut.
+Alternatively, you can use the Build -> Build project menu item:
+
+.. image:: images/003_build_project.png
+
+When a build is triggered, the rga command line tool will be invoked.
+The "Build output" window at the bottom will display the invocation command for the RGA command line tool, as well its output.
+
+In case of a build success, the list of kernels in each file would be shown underneath each entry in the file menu on the left side.
+
+Use that list to control which kernel is in focus (highlighted in yellow):
+
+.. image:: images/005_project_file_menu.png
+
+The disassembly for the relevant kernel will be displayed in the disassembly view on the right:
+
+.. image:: images/023_disassembly_view_opencl.png
+
+* Highlighted rows are correlated to the current line in the source code view on the left
+* Memory instructions are colored in red to help you identify spots with high memory pressure
+* The Columns drop-down menu at the top can be used to customize the presented columns
+* If more than one GPU was targeted, use the drop-down on the top left corner to switch devices
+* The resource usage line shows the GPU resources that are consumed by the presented code
+
+The disassembly view also shows the VGPR pressure throughout the shader's instructions. 
+The "VGPR Pressure" column's header shows the total number of VGPRs used by the shader and the total number of VGPRs allocated for the shader. 
+The cells of this column visualize the VGPR allocation and the utilization at each instruction. 
+Since VGPRs are allocated in blocks, reducing just a few VGPRs can save an entire block from being allocated. 
+Hovering over any of the VGPR Pressure cells would show a hint that takes into account the VGPR allocation block size for the specific shader and calculates 
+how many VGPRs need to be freed in order to save a single VGPR block at that point of the program. 
+Note that the VGPR allocation block size is dependent on the target GPU as well as on certain characteristics of the shader, 
+such as the wave size it was compiled for (if applicable).
+
+In case of a performance hazard due to the usage of a GPU resource, RGA will display a warning icon and highlight the relevant resources:
+
+.. image:: images/015_build_view_disassembly_resource_usage_hazard.png
+
+The possible hazards are:
+
+	* VGPR spills
+	* SGPR spills
+	* LDS usage exceeds the recommended limit (based on the target GPU's HW features)
+	* Scratch memory usage is non-zero
+	* The size of the code is larger than the instruction cache

ThirdParty/Bin/Windows64/RadeonGpuAnalyzer/docs/help/rga/html/_static/basic.css

@@ -0,0 +1,906 @@
+/*
+ * basic.css
+ * ~~~~~~~~~
+ *
+ * Sphinx stylesheet -- basic theme.
+ *
+ * :copyright: Copyright 2007-2022 by the Sphinx team, see AUTHORS.
+ * :license: BSD, see LICENSE for details.
+ *
+ */
+
+/* -- main layout ----------------------------------------------------------- */
+
+div.clearer {
+    clear: both;
+}
+
+div.section::after {
+    display: block;
+    content: '';
+    clear: left;
+}
+
+/* -- relbar ---------------------------------------------------------------- */
+
+div.related {
+    width: 100%;
+    font-size: 90%;
+}
+
+div.related h3 {
+    display: none;
+}
+
+div.related ul {
+    margin: 0;
+    padding: 0 0 0 10px;
+    list-style: none;
+}
+
+div.related li {
+    display: inline;
+}
+
+div.related li.right {
+    float: right;
+    margin-right: 5px;
+}
+
+/* -- sidebar --------------------------------------------------------------- */
+
+div.sphinxsidebarwrapper {
+    padding: 10px 5px 0 10px;
+}
+
+div.sphinxsidebar {
+    float: left;
+    width: 230px;
+    margin-left: -100%;
+    font-size: 90%;
+    word-wrap: break-word;
+    overflow-wrap : break-word;
+}
+
+div.sphinxsidebar ul {
+    list-style: none;
+}
+
+div.sphinxsidebar ul ul,
+div.sphinxsidebar ul.want-points {
+    margin-left: 20px;
+    list-style: square;
+}
+
+div.sphinxsidebar ul ul {
+    margin-top: 0;
+    margin-bottom: 0;
+}
+
+div.sphinxsidebar form {
+    margin-top: 10px;
+}
+
+div.sphinxsidebar input {
+    border: 1px solid #98dbcc;
+    font-family: sans-serif;
+    font-size: 1em;
+}
+
+div.sphinxsidebar #searchbox form.search {
+    overflow: hidden;
+}
+
+div.sphinxsidebar #searchbox input[type="text"] {
+    float: left;
+    width: 80%;
+    padding: 0.25em;
+    box-sizing: border-box;
+}
+
+div.sphinxsidebar #searchbox input[type="submit"] {
+    float: left;
+    width: 20%;
+    border-left: none;
+    padding: 0.25em;
+    box-sizing: border-box;
+}
+
+
+img {
+    border: 0;
+    max-width: 100%;
+}
+
+/* -- search page ----------------------------------------------------------- */
+
+ul.search {
+    margin: 10px 0 0 20px;
+    padding: 0;
+}
+
+ul.search li {
+    padding: 5px 0 5px 20px;
+    background-image: url(file.png);
+    background-repeat: no-repeat;
+    background-position: 0 7px;
+}
+
+ul.search li a {
+    font-weight: bold;
+}
+
+ul.search li p.context {
+    color: #888;
+    margin: 2px 0 0 30px;
+    text-align: left;
+}
+
+ul.keywordmatches li.goodmatch a {
+    font-weight: bold;
+}
+
+/* -- index page ------------------------------------------------------------ */
+
+table.contentstable {
+    width: 90%;
+    margin-left: auto;
+    margin-right: auto;
+}
+
+table.contentstable p.biglink {
+    line-height: 150%;
+}
+
+a.biglink {
+    font-size: 1.3em;
+}
+
+span.linkdescr {
+    font-style: italic;
+    padding-top: 5px;
+    font-size: 90%;
+}
+
+/* -- general index --------------------------------------------------------- */
+
+table.indextable {
+    width: 100%;
+}
+
+table.indextable td {
+    text-align: left;
+    vertical-align: top;
+}
+
+table.indextable ul {
+    margin-top: 0;
+    margin-bottom: 0;
+    list-style-type: none;
+}
+
+table.indextable > tbody > tr > td > ul {
+    padding-left: 0em;
+}
+
+table.indextable tr.pcap {
+    height: 10px;
+}
+
+table.indextable tr.cap {
+    margin-top: 10px;
+    background-color: #f2f2f2;
+}
+
+img.toggler {
+    margin-right: 3px;
+    margin-top: 3px;
+    cursor: pointer;
+}
+
+div.modindex-jumpbox {
+    border-top: 1px solid #ddd;
+    border-bottom: 1px solid #ddd;
+    margin: 1em 0 1em 0;
+    padding: 0.4em;
+}
+
+div.genindex-jumpbox {
+    border-top: 1px solid #ddd;
+    border-bottom: 1px solid #ddd;
+    margin: 1em 0 1em 0;
+    padding: 0.4em;
+}
+
+/* -- domain module index --------------------------------------------------- */
+
+table.modindextable td {
+    padding: 2px;
+    border-collapse: collapse;
+}
+
+/* -- general body styles --------------------------------------------------- */
+
+div.body {
+    min-width: 450px;
+    max-width: 800px;
+}
+
+div.body p, div.body dd, div.body li, div.body blockquote {
+    -moz-hyphens: auto;
+    -ms-hyphens: auto;
+    -webkit-hyphens: auto;
+    hyphens: auto;
+}
+
+a.headerlink {
+    visibility: hidden;
+}
+
+a.brackets:before,
+span.brackets > a:before{
+    content: "[";
+}
+
+a.brackets:after,
+span.brackets > a:after {
+    content: "]";
+}
+
+h1:hover > a.headerlink,
+h2:hover > a.headerlink,
+h3:hover > a.headerlink,
+h4:hover > a.headerlink,
+h5:hover > a.headerlink,
+h6:hover > a.headerlink,
+dt:hover > a.headerlink,
+caption:hover > a.headerlink,
+p.caption:hover > a.headerlink,
+div.code-block-caption:hover > a.headerlink {
+    visibility: visible;
+}
+
+div.body p.caption {
+    text-align: inherit;
+}
+
+div.body td {
+    text-align: left;
+}
+
+.first {
+    margin-top: 0 !important;
+}
+
+p.rubric {
+    margin-top: 30px;
+    font-weight: bold;
+}
+
+img.align-left, figure.align-left, .figure.align-left, object.align-left {
+    clear: left;
+    float: left;
+    margin-right: 1em;
+}
+
+img.align-right, figure.align-right, .figure.align-right, object.align-right {
+    clear: right;
+    float: right;
+    margin-left: 1em;
+}
+
+img.align-center, figure.align-center, .figure.align-center, object.align-center {
+  display: block;
+  margin-left: auto;
+  margin-right: auto;
+}
+
+img.align-default, figure.align-default, .figure.align-default {
+  display: block;
+  margin-left: auto;
+  margin-right: auto;
+}
+
+.align-left {
+    text-align: left;
+}
+
+.align-center {
+    text-align: center;
+}
+
+.align-default {
+    text-align: center;
+}
+
+.align-right {
+    text-align: right;
+}
+
+/* -- sidebars -------------------------------------------------------------- */
+
+div.sidebar,
+aside.sidebar {
+    margin: 0 0 0.5em 1em;
+    border: 1px solid #ddb;
+    padding: 7px;
+    background-color: #ffe;
+    width: 40%;
+    float: right;
+    clear: right;
+    overflow-x: auto;
+}
+
+p.sidebar-title {
+    font-weight: bold;
+}
+
+div.admonition, div.topic, blockquote {
+    clear: left;
+}
+
+/* -- topics ---------------------------------------------------------------- */
+
+div.topic {
+    border: 1px solid #ccc;
+    padding: 7px;
+    margin: 10px 0 10px 0;
+}
+
+p.topic-title {
+    font-size: 1.1em;
+    font-weight: bold;
+    margin-top: 10px;
+}
+
+/* -- admonitions ----------------------------------------------------------- */
+
+div.admonition {
+    margin-top: 10px;
+    margin-bottom: 10px;
+    padding: 7px;
+}
+
+div.admonition dt {
+    font-weight: bold;
+}
+
+p.admonition-title {
+    margin: 0px 10px 5px 0px;
+    font-weight: bold;
+}
+
+div.body p.centered {
+    text-align: center;
+    margin-top: 25px;
+}
+
+/* -- content of sidebars/topics/admonitions -------------------------------- */
+
+div.sidebar > :last-child,
+aside.sidebar > :last-child,
+div.topic > :last-child,
+div.admonition > :last-child {
+    margin-bottom: 0;
+}
+
+div.sidebar::after,
+aside.sidebar::after,
+div.topic::after,
+div.admonition::after,
+blockquote::after {
+    display: block;
+    content: '';
+    clear: both;
+}
+
+/* -- tables ---------------------------------------------------------------- */
+
+table.docutils {
+    margin-top: 10px;
+    margin-bottom: 10px;
+    border: 0;
+    border-collapse: collapse;
+}
+
+table.align-center {
+    margin-left: auto;
+    margin-right: auto;
+}
+
+table.align-default {
+    margin-left: auto;
+    margin-right: auto;
+}
+
+table caption span.caption-number {
+    font-style: italic;
+}
+
+table caption span.caption-text {
+}
+
+table.docutils td, table.docutils th {
+    padding: 1px 8px 1px 5px;
+    border-top: 0;
+    border-left: 0;
+    border-right: 0;
+    border-bottom: 1px solid #aaa;
+}
+
+table.footnote td, table.footnote th {
+    border: 0 !important;
+}
+
+th {
+    text-align: left;
+    padding-right: 5px;
+}
+
+table.citation {
+    border-left: solid 1px gray;
+    margin-left: 1px;
+}
+
+table.citation td {
+    border-bottom: none;
+}
+
+th > :first-child,
+td > :first-child {
+    margin-top: 0px;
+}
+
+th > :last-child,
+td > :last-child {
+    margin-bottom: 0px;
+}
+
+/* -- figures --------------------------------------------------------------- */
+
+div.figure, figure {
+    margin: 0.5em;
+    padding: 0.5em;
+}
+
+div.figure p.caption, figcaption {
+    padding: 0.3em;
+}
+
+div.figure p.caption span.caption-number,
+figcaption span.caption-number {
+    font-style: italic;
+}
+
+div.figure p.caption span.caption-text,
+figcaption span.caption-text {
+}
+
+/* -- field list styles ----------------------------------------------------- */
+
+table.field-list td, table.field-list th {
+    border: 0 !important;
+}
+
+.field-list ul {
+    margin: 0;
+    padding-left: 1em;
+}
+
+.field-list p {
+    margin: 0;
+}
+
+.field-name {
+    -moz-hyphens: manual;
+    -ms-hyphens: manual;
+    -webkit-hyphens: manual;
+    hyphens: manual;
+}
+
+/* -- hlist styles ---------------------------------------------------------- */
+
+table.hlist {
+    margin: 1em 0;
+}
+
+table.hlist td {
+    vertical-align: top;
+}
+
+/* -- object description styles --------------------------------------------- */
+
+.sig {
+	font-family: 'Consolas', 'Menlo', 'DejaVu Sans Mono', 'Bitstream Vera Sans Mono', monospace;
+}
+
+.sig-name, code.descname {
+    background-color: transparent;
+    font-weight: bold;
+}
+
+.sig-name {
+	font-size: 1.1em;
+}
+
+code.descname {
+    font-size: 1.2em;
+}
+
+.sig-prename, code.descclassname {
+    background-color: transparent;
+}
+
+.optional {
+    font-size: 1.3em;
+}
+
+.sig-paren {
+    font-size: larger;
+}
+
+.sig-param.n {
+	font-style: italic;
+}
+
+/* C++ specific styling */
+
+.sig-inline.c-texpr,
+.sig-inline.cpp-texpr {
+	font-family: unset;
+}
+
+.sig.c   .k, .sig.c   .kt,
+.sig.cpp .k, .sig.cpp .kt {
+	color: #0033B3;
+}
+
+.sig.c   .m,
+.sig.cpp .m {
+	color: #1750EB;
+}
+
+.sig.c   .s, .sig.c   .sc,
+.sig.cpp .s, .sig.cpp .sc {
+	color: #067D17;
+}
+
+
+/* -- other body styles ----------------------------------------------------- */
+
+ol.arabic {
+    list-style: decimal;
+}
+
+ol.loweralpha {
+    list-style: lower-alpha;
+}
+
+ol.upperalpha {
+    list-style: upper-alpha;
+}
+
+ol.lowerroman {
+    list-style: lower-roman;
+}
+
+ol.upperroman {
+    list-style: upper-roman;
+}
+
+:not(li) > ol > li:first-child > :first-child,
+:not(li) > ul > li:first-child > :first-child {
+    margin-top: 0px;
+}
+
+:not(li) > ol > li:last-child > :last-child,
+:not(li) > ul > li:last-child > :last-child {
+    margin-bottom: 0px;
+}
+
+ol.simple ol p,
+ol.simple ul p,
+ul.simple ol p,
+ul.simple ul p {
+    margin-top: 0;
+}
+
+ol.simple > li:not(:first-child) > p,
+ul.simple > li:not(:first-child) > p {
+    margin-top: 0;
+}
+
+ol.simple p,
+ul.simple p {
+    margin-bottom: 0;
+}
+
+dl.footnote > dt,
+dl.citation > dt {
+    float: left;
+    margin-right: 0.5em;
+}
+
+dl.footnote > dd,
+dl.citation > dd {
+    margin-bottom: 0em;
+}
+
+dl.footnote > dd:after,
+dl.citation > dd:after {
+    content: "";
+    clear: both;
+}
+
+dl.field-list {
+    display: grid;
+    grid-template-columns: fit-content(30%) auto;
+}
+
+dl.field-list > dt {
+    font-weight: bold;
+    word-break: break-word;
+    padding-left: 0.5em;
+    padding-right: 5px;
+}
+
+dl.field-list > dt:after {
+    content: ":";
+}
+
+dl.field-list > dd {
+    padding-left: 0.5em;
+    margin-top: 0em;
+    margin-left: 0em;
+    margin-bottom: 0em;
+}
+
+dl {
+    margin-bottom: 15px;
+}
+
+dd > :first-child {
+    margin-top: 0px;
+}
+
+dd ul, dd table {
+    margin-bottom: 10px;
+}
+
+dd {
+    margin-top: 3px;
+    margin-bottom: 10px;
+    margin-left: 30px;
+}
+
+dl > dd:last-child,
+dl > dd:last-child > :last-child {
+    margin-bottom: 0;
+}
+
+dt:target, span.highlighted {
+    background-color: #fbe54e;
+}
+
+rect.highlighted {
+    fill: #fbe54e;
+}
+
+dl.glossary dt {
+    font-weight: bold;
+    font-size: 1.1em;
+}
+
+.versionmodified {
+    font-style: italic;
+}
+
+.system-message {
+    background-color: #fda;
+    padding: 5px;
+    border: 3px solid red;
+}
+
+.footnote:target  {
+    background-color: #ffa;
+}
+
+.line-block {
+    display: block;
+    margin-top: 1em;
+    margin-bottom: 1em;
+}
+
+.line-block .line-block {
+    margin-top: 0;
+    margin-bottom: 0;
+    margin-left: 1.5em;
+}
+
+.guilabel, .menuselection {
+    font-family: sans-serif;
+}
+
+.accelerator {
+    text-decoration: underline;
+}
+
+.classifier {
+    font-style: oblique;
+}
+
+.classifier:before {
+    font-style: normal;
+    margin: 0 0.5em;
+    content: ":";
+    display: inline-block;
+}
+
+abbr, acronym {
+    border-bottom: dotted 1px;
+    cursor: help;
+}
+
+/* -- code displays --------------------------------------------------------- */
+
+pre {
+    overflow: auto;
+    overflow-y: hidden;  /* fixes display issues on Chrome browsers */
+}
+
+pre, div[class*="highlight-"] {
+    clear: both;
+}
+
+span.pre {
+    -moz-hyphens: none;
+    -ms-hyphens: none;
+    -webkit-hyphens: none;
+    hyphens: none;
+    white-space: nowrap;
+}
+
+div[class*="highlight-"] {
+    margin: 1em 0;
+}
+
+td.linenos pre {
+    border: 0;
+    background-color: transparent;
+    color: #aaa;
+}
+
+table.highlighttable {
+    display: block;
+}
+
+table.highlighttable tbody {
+    display: block;
+}
+
+table.highlighttable tr {
+    display: flex;
+}
+
+table.highlighttable td {
+    margin: 0;
+    padding: 0;
+}
+
+table.highlighttable td.linenos {
+    padding-right: 0.5em;
+}
+
+table.highlighttable td.code {
+    flex: 1;
+    overflow: hidden;
+}
+
+.highlight .hll {
+    display: block;
+}
+
+div.highlight pre,
+table.highlighttable pre {
+    margin: 0;
+}
+
+div.code-block-caption + div {
+    margin-top: 0;
+}
+
+div.code-block-caption {
+    margin-top: 1em;
+    padding: 2px 5px;
+    font-size: small;
+}
+
+div.code-block-caption code {
+    background-color: transparent;
+}
+
+table.highlighttable td.linenos,
+span.linenos,
+div.highlight span.gp {  /* gp: Generic.Prompt */
+  user-select: none;
+  -webkit-user-select: text; /* Safari fallback only */
+  -webkit-user-select: none; /* Chrome/Safari */
+  -moz-user-select: none; /* Firefox */
+  -ms-user-select: none; /* IE10+ */
+}
+
+div.code-block-caption span.caption-number {
+    padding: 0.1em 0.3em;
+    font-style: italic;
+}
+
+div.code-block-caption span.caption-text {
+}
+
+div.literal-block-wrapper {
+    margin: 1em 0;
+}
+
+code.xref, a code {
+    background-color: transparent;
+    font-weight: bold;
+}
+
+h1 code, h2 code, h3 code, h4 code, h5 code, h6 code {
+    background-color: transparent;
+}
+
+.viewcode-link {
+    float: right;
+}
+
+.viewcode-back {
+    float: right;
+    font-family: sans-serif;
+}
+
+div.viewcode-block:target {
+    margin: -1px -10px;
+    padding: 0 10px;
+}
+
+/* -- math display ---------------------------------------------------------- */
+
+img.math {
+    vertical-align: middle;
+}
+
+div.body div.math p {
+    text-align: center;
+}
+
+span.eqno {
+    float: right;
+}
+
+span.eqno a.headerlink {
+    position: absolute;
+    z-index: 1;
+}
+
+div.math:hover a.headerlink {
+    visibility: visible;
+}
+
+/* -- printout stylesheet --------------------------------------------------- */
+
+@media print {
+    div.document,
+    div.documentwrapper,
+    div.bodywrapper {
+        margin: 0 !important;
+        width: 100%;
+    }
+
+    div.sphinxsidebar,
+    div.related,
+    div.footer,
+    #top-link {
+        display: none;
+    }
+}