CGBull haolange

Note: This is for my own educational purpose only(WIP)

Many people have already posted different kinds of microbenchmarking method for testing the size limits of various structures(e.g ROB, PRF). I recommend you to look at Henry Wong's blog post and also Maynard Handley's PDFs first. I got my idea from them and many others!

I found a slightly different variant based on them

Get the tools ready

Testing on Apple platform is always a hassle, and for my method we have to have a way to access the Performance counters directly in our microbenchmark. Dougall made a Kext for this purpose, basically what it does is to provide access to the configuration registers and so we can set the PMCs available for userspace access. And to make my life easier, I made a kext to pin the microbenchmark to

GPU Optimization for GameDev

Graphics Pipeline / GPU Architecture Overview

2011 - A trip through the Graphics Pipeline 2011
2013 - Performance Optimization Guidelines and the GPU Architecture behind them
2015 - Life of a triangle - NVIDIA's logical pipeline
2015 - Render Hell 2.0
2016 - How bad are small triangles on GPU and why?
2017 - GPU Performance for Game Artists
2019 - Understanding the anatomy of GPUs using Pokémon

Writing a modern rendering engine

Designing a Modern GPU Interface by @BrookeHodgman
Optimizing the Graphics Pipeline with Compute by @gwihlidal
GPU Driven Rendering Pipelines by @SebAaltonen
Destiny’s Multi-threaded Renderer Architecture by @Mirror2Mask
Stingray Renderer Walkthrough by @tobias_persson

	#include "EditorUtilityWidgetBlueprint.h"
	#include "EditorUtilitySubsystem.h"

	UObject * Blueprint = UEditorAssetLibrary::LoadAsset(FString(TEXT("EditorUtilityWidgetBlueprint'/Game/EditorUtilities/MyWidget.MyWidget'")));
	if(IsValid(Blueprint)) {
	UEditorUtilityWidgetBlueprint* EditorWidget = Cast<UEditorUtilityWidgetBlueprint>(Blueprint);
	if (IsValid(EditorWidget)) {
	UEditorUtilitySubsystem* EditorUtilitySubsystem = GEditor->GetEditorSubsystem<UEditorUtilitySubsystem>();
	EditorUtilitySubsystem->SpawnAndRegisterTab(EditorWidget);
	}

	MarchingCubesGPU.cs:
	...
	// DrawProceduralIndirect
	ComputeBuffer argsBuffer;
	[StructLayout(LayoutKind.Sequential)]
	struct DrawCallArgBuffer
	{
	public const int size =
	sizeof(int) +
	sizeof(int) +

	Shader "Hidden/Bloom"
	{
	Properties
	{
	_MainTex ("Texture", 2D) = "white" {}
	}
	HLSLINCLUDE
	#include "Packages/com.unity.render-pipelines.lightweight/ShaderLibrary/Core.hlsl"

	struct appdata

	using System;
	using System.Collections.Concurrent;
	using System.Collections.Generic;
	using System.Runtime.CompilerServices;
	using System.Threading;
	using System.Threading.Tasks;
	using Unity.Jobs;

	public static class JobHelper
	{

	struct CpuGpuTimestampInfo {
	VkDevice device;
	VkQueue queue;
	uint32_t queue_family_index;
	float timestamp_period; // Copy from VkPhysicalDeviceLimits::timestampPeriod
	uint32_t timestamp_valid_bits; // Copy from VkQueueFamilyProperties::timestampValidBits
	};
	VkResult GetCpuGpuTimestamp(const CpuGpuTimestampInfo *info,
	std::chrono::high_resolution_clock::time_point out_cpu_time, uint64_t out_gpu_time) {
	if (info->timestamp_valid_bits == 0) {

	// When creating shaders for Universal Render Pipeline you can you the ShaderGraph which is super AWESOME!
	// However, if you want to author shaders in shading language you can use this teamplate as a base.
	// Please note, this shader does not necessarily match perfomance of the built-in URP Lit shader.
	// This shader works with URP 7.1.x and above
	Shader "Universal Render Pipeline/Custom/Physically Based Example"
	{
	Properties
	{
	// Specular vs Metallic workflow
	[HideInInspector] _WorkflowMode("WorkflowMode", Float) = 1.0

	using System;
	using System.Collections.Generic;

	internal static class MergeSort<T> {

	public static void Sort (List<T> list, Comparison<T> comparison) {
	if (list.Count <= 1)
	return;

	var mid = list.Count / 2;