Subgroup2 Benchmark #190

devshgraphicsprogramming · 2025-04-09T20:43:43Z

No description provided.

73_ArithmeticBench/main.cpp

73_ArithmeticBench/app_resources/common.hlsl

devshgraphicsprogramming · 2025-04-09T21:11:54Z

73_ArithmeticBench/app_resources/common.hlsl

+template<typename T>
+struct bit_and : nbl::hlsl::bit_and<T>
+{
+    using base_t = nbl::hlsl::bit_and<T>;
+
+    NBL_CONSTEXPR_STATIC_INLINE uint16_t BindingIndex = 0;
+#ifndef __HLSL_VERSION
+    static inline constexpr const char* name = "bit_and";
+#endif
+};
+template<typename T>
+struct bit_or : nbl::hlsl::bit_or<T>
+{
+    using base_t = nbl::hlsl::bit_or<T>;
+
+    NBL_CONSTEXPR_STATIC_INLINE uint16_t BindingIndex = 1;
+#ifndef __HLSL_VERSION
+    static inline constexpr const char* name = "bit_xor";
+#endif
+};
+template<typename T>
+struct bit_xor : nbl::hlsl::bit_xor<T>
+{
+    using base_t = nbl::hlsl::bit_xor<T>;
+
+    NBL_CONSTEXPR_STATIC_INLINE uint16_t BindingIndex = 2;
+#ifndef __HLSL_VERSION
+    static inline constexpr const char* name = "bit_or";
+#endif
+};
+template<typename T>
+struct plus : nbl::hlsl::plus<T>
+{
+    using base_t = nbl::hlsl::plus<T>;
+
+    NBL_CONSTEXPR_STATIC_INLINE uint16_t BindingIndex = 3;
+#ifndef __HLSL_VERSION
+    static inline constexpr const char* name = "plus";
+#endif
+};
+template<typename T>
+struct multiplies : nbl::hlsl::multiplies<T>
+{
+    using base_t = nbl::hlsl::multiplies<T>;
+
+    NBL_CONSTEXPR_STATIC_INLINE uint16_t BindingIndex = 4;
+#ifndef __HLSL_VERSION
+    static inline constexpr const char* name = "multiplies";
+#endif
+};
+template<typename T>
+struct minimum : nbl::hlsl::minimum<T>
+{
+    using base_t = nbl::hlsl::minimum<T>;
+
+    NBL_CONSTEXPR_STATIC_INLINE uint16_t BindingIndex = 5;
+#ifndef __HLSL_VERSION
+    static inline constexpr const char* name = "minimum";
+#endif
+};
+template<typename T>
+struct maximum : nbl::hlsl::maximum<T>
+{
+    using base_t = nbl::hlsl::maximum<T>;
+
+    NBL_CONSTEXPR_STATIC_INLINE uint16_t BindingIndex = 6;
+#ifndef __HLSL_VERSION
+    static inline constexpr const char* name = "maximum";
+#endif
+};
+
+template<typename T>
+struct ballot : nbl::hlsl::plus<T>
+{
+    using base_t = nbl::hlsl::plus<T>;
+
+    NBL_CONSTEXPR_STATIC_INLINE uint16_t BindingIndex = 7;
+#ifndef __HLSL_VERSION
+    static inline constexpr const char* name = "bitcount";
+#endif
+};


for the benchmark lets only benchmark plus and ballot

73_ArithmeticBench/app_resources/benchmarkSubgroup.comp.hlsl

devshgraphicsprogramming · 2025-04-09T21:16:50Z

73_ArithmeticBench/app_resources/benchmarkSubgroup.comp.hlsl

+static void subbench(NBL_CONST_REF_ARG(type_t) sourceVal)
+{
+    using config_t = nbl::hlsl::subgroup::Configuration<SUBGROUP_SIZE_LOG2>;
+    using params_t = nbl::hlsl::subgroup2::ArithmeticParams<config_t, typename binop<T>::base_t, N, nbl::hlsl::jit::device_capabilities>;


make the "use-native" come from a define too

cause you want 2 different pipelines and 2 different test runs for each

73_ArithmeticBench/app_resources/benchmarkSubgroup.comp.hlsl

devshgraphicsprogramming · 2025-04-09T21:21:07Z

73_ArithmeticBench/app_resources/benchmarkSubgroup.comp.hlsl

+    [unroll]
+    for (uint32_t i = 0; i < ITEMS_PER_INVOCATION; i++)
+    {
+        sourceVal[i] = inputValue[idx + i];


eeh you've left perf on the table, your subgroup is now doing a heavily strided load

you need to load differently:

sourceVal[i] = nbl::hlsl::glsl::gl_WorkGroupID().x*WORKGROUP_SIZE*ITEMS_PER_INVOCATION+((SubgroupID*ITEMS_PER_INVOCATION+i)<<SubgroupSizeLog2)+SubgroupInvocationIndex;

so consecutive invocations load consecutive memory locations during a lock-step

or make the inputValue a ByteBuffer and do a templated Load from it of a whole type_t

devshgraphicsprogramming · 2025-04-09T21:22:49Z

73_ArithmeticBench/app_resources/benchmarkSubgroup.comp.hlsl

+    for (uint32_t i = 0; i < NUM_LOOPS; i++)
+        value = func(value);
+
+    output[binop<T>::BindingIndex].template Store<type_t>(sizeof(uint32_t) + sizeof(type_t) * globalIndex(), value);


you're storing to the wrong place, compute the index same way you compute for inputValue

and dont store whole vector store a scalar in aan unrolled loop same way you load input

devshgraphicsprogramming · 2025-04-09T21:35:22Z

73_ArithmeticBench/app_resources/benchmarkSubgroup.comp.hlsl

+    subbench<bit_and, uint32_t, ITEMS_PER_INVOCATION>(sourceVal);
+    subbench<bit_xor, uint32_t, ITEMS_PER_INVOCATION>(sourceVal);
+    subbench<bit_or, uint32_t, ITEMS_PER_INVOCATION>(sourceVal);
+    subbench<plus, uint32_t, ITEMS_PER_INVOCATION>(sourceVal);
+    subbench<multiplies, uint32_t, ITEMS_PER_INVOCATION>(sourceVal);
+    subbench<minimum, uint32_t, ITEMS_PER_INVOCATION>(sourceVal);
+    subbench<maximum, uint32_t, ITEMS_PER_INVOCATION>(sourceVal);


just bench the plus

devshgraphicsprogramming · 2025-04-09T21:39:25Z

73_ArithmeticBench/app_resources/shaderCommon.hlsl

+// because subgroups don't match `gl_LocalInvocationIndex` snake curve addressing, we also can't load inputs that way
+uint32_t globalIndex();


rename to globalFirstItemIndex to mean that its the first index to access by the invocation, and add a comment that to get next item one does not scroll by 1 but by SubgroupSize

73_ArithmeticBench/app_resources/shaderCommon.hlsl

73_ArithmeticBench/main.cpp

devshgraphicsprogramming · 2025-04-09T21:46:51Z

73_ArithmeticBench/main.cpp

+		// create dummy image
+		dummyImg = m_device->createImage({
+				{
+					.type = IGPUImage::ET_2D,
+					.samples = asset::ICPUImage::ESCF_1_BIT,
+					.format = asset::EF_R16G16B16A16_SFLOAT,
+					.extent = {WIN_W, WIN_H, 1},
+					.mipLevels = 1,
+					.arrayLayers = 1,
+					.flags = IImage::ECF_NONE,
+					.usage = core::bitflag(asset::IImage::EUF_STORAGE_BIT) | asset::IImage::EUF_TRANSFER_SRC_BIT
+				}
+			});
+		if (!dummyImg || !m_device->allocate(dummyImg->getMemoryReqs(), dummyImg.get()).isValid())
+			return logFail("Could not create HDR Image");


you don't need to create a dummy image to write into descriptor set, write the swapchain image instead

73_ArithmeticBench/main.cpp

devshgraphicsprogramming · 2025-04-09T22:02:15Z

73_ArithmeticBench/main.cpp

+
+	virtual bool onAppTerminated() override
+	{
+		delete[] inputData;


if you don't do testing, you can discard the input data as soon as input buffer is made, OR even better yet

Use a Hash from your path tracer / BxDF Math PR and skip having an input buffer entirely!

73_ArithmeticBench/main.cpp

devshgraphicsprogramming · 2025-04-09T22:19:25Z

73_ArithmeticBench/main.cpp

+		const uint32_t workgroupCount = elementCount / (set.workgroupSize * set.itemsPerInvocation);
+
+		cmdbuf->bindComputePipeline(set.pipeline.get());
+		cmdbuf->bindDescriptorSets(EPBP_COMPUTE, set.pipeline->getLayout(), 0u, 1u, &benchDs.get());


the set you can bind once at start of commandbuffer if you never change the layout

devshgraphicsprogramming · 2025-04-09T22:21:20Z

73_ArithmeticBench/main.cpp

+	template<template<class> class Arithmetic>
+	BenchmarkSet createBenchmarkPipelines(const smart_refctd_ptr<const ICPUShader>&source, const IGPUPipelineLayout* layout, const uint32_t elementCount, const uint8_t subgroupSizeLog2, const uint32_t workgroupSize, uint32_t itemsPerInvoc = 1u, uint32_t numLoops = 8u)
+	{
+		std::string arith_name = Arithmetic<bit_xor<uint32_t>>::name;	// TODO all operations


bump, plus and ballot are only ones needed, the benchmark wont change much for all other binops

devshgraphicsprogramming · 2025-04-09T22:26:37Z

73_ArithmeticBench/main.cpp

+		options.spirvOptimizer = nullptr;
+//#ifndef _NBL_DEBUG
+//		ISPIRVOptimizer::E_OPTIMIZER_PASS optPasses = ISPIRVOptimizer::EOP_STRIP_DEBUG_INFO;
+//		auto opt = make_smart_refctd_ptr<ISPIRVOptimizer>(std::span<ISPIRVOptimizer::E_OPTIMIZER_PASS>(&optPasses, 1));
+//		options.spirvOptimizer = opt.get();
+//#endif
+		options.debugInfoFlags |= IShaderCompiler::E_DEBUG_INFO_FLAGS::EDIF_LINE_BIT;


you must use zero debug flags and a SPIR-V optimizer to get representable perf, just ask @Fletterio about his FFT examples

It's in the createShader method in main.cpp of example 28, but to get a standard optimizer + strip debug info you just provide an optimizer with a single strip debug info flag to the compiler.

I don't remember exactly whether this invokes other optimizations or just the strip debug

It should invoke the standard passes specified in the SPIRV compiler repo when you run with -O, but in that regard I think the intent of the optimizer is busted (providing a custom optimizer likely is intended to disable all other passes by default)

@keptsecret you correctly optimize and strip bedug info in 23 the test, but not ex 29 the benchmark?

73_ArithmeticBench/main.cpp

devshgraphicsprogramming · 2025-04-09T22:37:07Z

73_ArithmeticBench/main.cpp

+		// bind dummy image
+		IGPUImageView::SCreationParams viewParams = {
+			.flags = IGPUImageView::ECF_NONE,
+			.subUsages = IGPUImage::E_USAGE_FLAGS::EUF_STORAGE_BIT,
+			.image = dummyImg,
+			.viewType = IGPUImageView::ET_2D,
+			.format = dummyImg->getCreationParameters().format
+		};
+		auto dummyImgView = m_device->createImageView(std::move(viewParams));


do not create an image view every frame

devshgraphicsprogramming · 2025-04-09T22:38:07Z

73_ArithmeticBench/main.cpp

+		// barrier transition to GENERAL
+		{
+			IGPUCommandBuffer::SPipelineBarrierDependencyInfo::image_barrier_t imageBarriers[1];
+			imageBarriers[0].barrier = {
+				   .dep = {
+					   .srcStageMask = PIPELINE_STAGE_FLAGS::NONE,
+					   .srcAccessMask = ACCESS_FLAGS::NONE,
+					   .dstStageMask = PIPELINE_STAGE_FLAGS::COMPUTE_SHADER_BIT,
+					   .dstAccessMask = ACCESS_FLAGS::SHADER_WRITE_BITS
+					}
+			};
+			imageBarriers[0].image = dummyImg.get();
+			imageBarriers[0].subresourceRange = {
+				.aspectMask = IImage::EAF_COLOR_BIT,
+				.baseMipLevel = 0u,
+				.levelCount = 1u,
+				.baseArrayLayer = 0u,
+				.layerCount = 1u
+			};
+			imageBarriers[0].oldLayout = IImage::LAYOUT::UNDEFINED;
+			imageBarriers[0].newLayout = IImage::LAYOUT::GENERAL;
+
+			cmdbuf->pipelineBarrier(E_DEPENDENCY_FLAGS::EDF_NONE, { .imgBarriers = imageBarriers });
+		}


if you don't actually touch the image, you don't need to transition it (you may need to transition right after creation / first frame so validation layer doesn't complain about it being in UNDEFINED layout)

devshgraphicsprogramming · 2025-04-09T22:38:33Z

73_ArithmeticBench/main.cpp

+		video::IGPUDescriptorSet::SDescriptorInfo dsInfo;
+		dsInfo.info.image.imageLayout = IImage::LAYOUT::GENERAL;
+		dsInfo.desc = dummyImgView;
+
+		IGPUDescriptorSet::SWriteDescriptorSet dsWrites[1u] =
+		{
+			{
+				.dstSet = benchDs.get(),
+				.binding = 2u,
+				.arrayElement = 0u,
+				.count = 1u,
+				.info = &dsInfo,
+			}
+		};
+		m_device->updateDescriptorSets(1u, dsWrites, 0u, nullptr);


don't write descriptor set every frame, and write the swapchain images instead

73_ArithmeticBench/main.cpp

devshgraphicsprogramming · 2025-04-09T22:39:45Z

73_ArithmeticBench/main.cpp

+		passed = runBenchmark<emulatedScanInclusive>(cmdbuf, benchSets[0], elementCount, SubgroupSizeLog2);
+		passed = runBenchmark<emulatedScanInclusive>(cmdbuf, benchSets[1], elementCount, SubgroupSizeLog2);
+		passed = runBenchmark<emulatedScanInclusive>(cmdbuf, benchSets[2], elementCount, SubgroupSizeLog2);


you don't need the CPU validator emulatedScanInclusive for anything, untemplate the method

devshgraphicsprogramming · 2025-04-09T22:40:05Z

73_ArithmeticBench/main.cpp

+		// blit
+		{
+			IGPUCommandBuffer::SPipelineBarrierDependencyInfo::image_barrier_t imageBarriers[2];
+			imageBarriers[0].barrier = {
+			   .dep = {
+				   .srcStageMask = PIPELINE_STAGE_FLAGS::COMPUTE_SHADER_BIT,
+				   .srcAccessMask = ACCESS_FLAGS::SHADER_WRITE_BITS,
+				   .dstStageMask = PIPELINE_STAGE_FLAGS::BLIT_BIT,
+				   .dstAccessMask = ACCESS_FLAGS::TRANSFER_WRITE_BIT
+				}
+			};
+			imageBarriers[0].image = dummyImg.get();
+			imageBarriers[0].subresourceRange = {
+				.aspectMask = IImage::EAF_COLOR_BIT,
+				.baseMipLevel = 0u,
+				.levelCount = 1u,
+				.baseArrayLayer = 0u,
+				.layerCount = 1u
+			};
+			imageBarriers[0].oldLayout = IImage::LAYOUT::UNDEFINED;
+			imageBarriers[0].newLayout = IImage::LAYOUT::TRANSFER_SRC_OPTIMAL;
+
+			imageBarriers[1].barrier = {
+			   .dep = {
+				   .srcStageMask = PIPELINE_STAGE_FLAGS::NONE,
+				   .srcAccessMask = ACCESS_FLAGS::NONE,
+				   .dstStageMask = PIPELINE_STAGE_FLAGS::BLIT_BIT,
+				   .dstAccessMask = ACCESS_FLAGS::TRANSFER_WRITE_BIT
+				}
+			};
+			imageBarriers[1].image = m_surface->getSwapchainResources()->getImage(m_currentImageAcquire.imageIndex);
+			imageBarriers[1].subresourceRange = {
+				.aspectMask = IImage::EAF_COLOR_BIT,
+				.baseMipLevel = 0u,
+				.levelCount = 1u,
+				.baseArrayLayer = 0u,
+				.layerCount = 1u
+			};
+			imageBarriers[1].oldLayout = IImage::LAYOUT::UNDEFINED;
+			imageBarriers[1].newLayout = IImage::LAYOUT::TRANSFER_DST_OPTIMAL;
+
+			cmdbuf->pipelineBarrier(E_DEPENDENCY_FLAGS::EDF_NONE, { .imgBarriers = imageBarriers });
+		}
+
+		{
+			IGPUCommandBuffer::SImageBlit regions[] = { {
+				.srcMinCoord = {0,0,0},
+				.srcMaxCoord = {WIN_W,WIN_H,1},
+				.dstMinCoord = {0,0,0},
+				.dstMaxCoord = {WIN_W,WIN_H,1},
+				.layerCount = 1,
+				.srcBaseLayer = 0,
+				.dstBaseLayer = 0,
+				.srcMipLevel = 0,
+				.dstMipLevel = 0,
+				.aspectMask = IGPUImage::E_ASPECT_FLAGS::EAF_COLOR_BIT
+			} };
+
+			auto srcImg = dummyImg.get();
+			auto scRes = static_cast<CDefaultSwapchainFramebuffers*>(m_surface->getSwapchainResources());
+			auto dstImg = scRes->getImage(m_currentImageAcquire.imageIndex);
+
+			cmdbuf->blitImage(srcImg, IImage::LAYOUT::TRANSFER_SRC_OPTIMAL, dstImg, IImage::LAYOUT::TRANSFER_DST_OPTIMAL, regions, ISampler::ETF_NEAREST);
+		}


blit is not needed

if you have the swapchain images bound and you layout transition them, Nsight should still consider them used, please remove the blit

devshgraphicsprogramming · 2025-04-09T22:40:21Z

73_ArithmeticBench/main.cpp

+		// barrier transition to PRESENT
+		{
+			IGPUCommandBuffer::SPipelineBarrierDependencyInfo::image_barrier_t imageBarriers[1];
+			imageBarriers[0].barrier = {
+				   .dep = {
+					   .srcStageMask = PIPELINE_STAGE_FLAGS::COMPUTE_SHADER_BIT,
+					   .srcAccessMask = ACCESS_FLAGS::SHADER_WRITE_BITS,
+					   .dstStageMask = PIPELINE_STAGE_FLAGS::NONE,
+					   .dstAccessMask = ACCESS_FLAGS::NONE
+					}
+			};
+			imageBarriers[0].image = m_surface->getSwapchainResources()->getImage(m_currentImageAcquire.imageIndex);
+			imageBarriers[0].subresourceRange = {
+				.aspectMask = IImage::EAF_COLOR_BIT,
+				.baseMipLevel = 0u,
+				.levelCount = 1u,
+				.baseArrayLayer = 0u,
+				.layerCount = 1u
+			};
+			imageBarriers[0].oldLayout = IImage::LAYOUT::TRANSFER_DST_OPTIMAL;
+			imageBarriers[0].newLayout = IImage::LAYOUT::PRESENT_SRC;
+
+			cmdbuf->pipelineBarrier(E_DEPENDENCY_FLAGS::EDF_NONE, { .imgBarriers = imageBarriers });
+		}


transition once to PRESENT and never touch later on

let me know if nsight needs some barrier usage of the swapchain in order to capture, I don't think it does

73_ArithmeticBench/main.cpp

73_ArithmeticBench/imgui.ini

keptsecret · 2025-05-07T08:13:49Z

Should close, replace with #192

keptsecret added 11 commits March 27, 2025 15:26

initial benchmark example copy

8090a2d

test subgroup2 funcs correct

3a2ff14

fix test

dd021a0

benchmarking shader + pipeline working

ca21941

begin adding fake frames for nsight profiler

0bb41db

merge master, fix conflicts

24a93bb

re-numbered example to avoid duplicate

17dda8e

fake frames for nsight

3d4e0f2

use correct shader, spirv line dbinfo for nsight

0192999

support for 1 item per invoc

8c9d55e

handle when items per invoc =1

07d6980