add a util function to compute blit, and update examples_tests (pipelien barriers written)

Author: devsh

examples_tests

@@ -134,10 +134,15 @@ class CComputeBlit : public core::IReferenceCounted
 			// the absolute minimum needed to store a single pixel of a worst case format (precise, all 4 channels)
 			constexpr auto singlePixelStorage = 4*sizeof(hlsl::float32_t);
 			constexpr auto ratio = singlePixelStorage/sizeof(uint16_t);
-			const auto paddedAlphaBinCount = core::min(core::roundUp(baseBucketCount,workgroupSize),workgroupSize*ratio);
+			// atomicAdd gets performed on MSB or LSB of a single DWORD
+			const auto paddedAlphaBinCount = core::min(core::roundUp<uint16_t>(baseBucketCount,workgroupSize*2),workgroupSize*ratio);
 			return paddedAlphaBinCount*layersToBlit;
 		}
-
+		
+		static inline uint32_t getNormalizationByteSize(const uint16_t workgroupSize, const asset::E_FORMAT intermediateAlpha, const uint32_t layersToBlit)
+		{
+			return getAlphaBinCount(workgroupSize,intermediateAlpha,layersToBlit)*sizeof(uint16_t)+sizeof(uint32_t)+sizeof(uint32_t);
+		}
 #if 0
 
 		//! Returns the number of output texels produced by one workgroup, deciding factor is `m_availableSharedMemory`.
@@ -337,19 +342,14 @@ class CComputeBlit : public core::IReferenceCounted
 			{
 				dispatch_info_t dispatchInfo;
 				buildAlphaTestDispatchInfo(dispatchInfo, inImageExtent, inImageType, layersToBlit);
-
-				cmdbuf->bindDescriptorSets(asset::EPBP_COMPUTE, alphaTestPipeline->getLayout(), 0u, 1u, &alphaTestDS);
-				cmdbuf->bindComputePipeline(alphaTestPipeline);
+// bind omitted
 				dispatchHelper(cmdbuf, alphaTestPipeline->getLayout(), pushConstants, dispatchInfo);
 			}
 
 			{
 				dispatch_info_t dispatchInfo;
 				buildBlitDispatchInfo<BlitUtilities>(dispatchInfo, inImageExtent, outImageExtent, inImageFormat, inImageType, kernels, workgroupSize, layersToBlit);
-
-				video::IGPUDescriptorSet* ds_raw[] = { blitDS, blitWeightsDS };
-				cmdbuf->bindDescriptorSets(asset::EPBP_COMPUTE, blitPipeline->getLayout(), 0, 2, ds_raw);
-				cmdbuf->bindComputePipeline(blitPipeline);
+// bind omitted
 				dispatchHelper(cmdbuf, blitPipeline->getLayout(), pushConstants, dispatchInfo);
 			}
 
@@ -359,39 +359,6 @@ class CComputeBlit : public core::IReferenceCounted
 				dispatch_info_t dispatchInfo;
 				buildNormalizationDispatchInfo(dispatchInfo, outImageExtent, inImageType, layersToBlit);
 
-				assert(coverageAdjustmentScratchBuffer);
-				IGPUCommandBuffer::SPipelineBarrierDependencyInfo depInfo;
-				// Memory dependency to ensure the alpha test pass has finished writing to alphaTestCounterBuffer
-				video::IGPUCommandBuffer::SPipelineBarrierDependencyInfo::buffer_barrier_t alphaTestBarrier = {};
-				alphaTestBarrier.barrier.dep.srcStageMask = asset::PIPELINE_STAGE_FLAGS::COMPUTE_SHADER_BIT;
-				alphaTestBarrier.barrier.dep.srcAccessMask = asset::ACCESS_FLAGS::SHADER_WRITE_BITS;
-				alphaTestBarrier.barrier.dep.dstStageMask = asset::PIPELINE_STAGE_FLAGS::COMPUTE_SHADER_BIT;
-				alphaTestBarrier.barrier.dep.dstAccessMask = asset::ACCESS_FLAGS::SHADER_READ_BITS;
-				alphaTestBarrier.range.buffer = coverageAdjustmentScratchBuffer;
-				alphaTestBarrier.range.size = coverageAdjustmentScratchBuffer->getSize();
-				alphaTestBarrier.range.offset = 0;
-
-				// Memory dependency to ensure that the previous compute pass has finished writing to the output image,
-				// also transitions the layout of said image: GENERAL -> SHADER_READ_ONLY_OPTIMAL
-				video::IGPUCommandBuffer::SPipelineBarrierDependencyInfo::image_barrier_t readyForNorm = {};
-				readyForNorm.barrier.dep.srcStageMask = asset::PIPELINE_STAGE_FLAGS::COMPUTE_SHADER_BIT;
-				readyForNorm.barrier.dep.srcAccessMask = asset::ACCESS_FLAGS::SHADER_WRITE_BITS;
-				readyForNorm.barrier.dep.dstStageMask = asset::PIPELINE_STAGE_FLAGS::COMPUTE_SHADER_BIT;
-				readyForNorm.barrier.dep.dstAccessMask = asset::ACCESS_FLAGS::SHADER_READ_BITS;
-				readyForNorm.oldLayout = video::IGPUImage::LAYOUT::GENERAL;
-				readyForNorm.newLayout = video::IGPUImage::LAYOUT::READ_ONLY_OPTIMAL;
-				readyForNorm.image = normalizationInImage.get();
-				readyForNorm.subresourceRange.aspectMask = asset::IImage::EAF_COLOR_BIT;
-				readyForNorm.subresourceRange.levelCount = 1u;
-				readyForNorm.subresourceRange.layerCount = normalizationInImage->getCreationParameters().arrayLayers;
-
-				depInfo.bufBarriers = { &alphaTestBarrier, &alphaTestBarrier + 1 };
-				depInfo.imgBarriers = { &readyForNorm, &readyForNorm + 1 };
-
-				cmdbuf->pipelineBarrier(asset::E_DEPENDENCY_FLAGS::EDF_NONE, depInfo);
-
-				cmdbuf->bindDescriptorSets(asset::EPBP_COMPUTE, normalizationPipeline->getLayout(), 0u, 1u, &normalizationDS);
-				cmdbuf->bindComputePipeline(normalizationPipeline);
 				dispatchHelper(cmdbuf, normalizationPipeline->getLayout(), pushConstants, dispatchInfo);
 			}
 		}

include/nbl/video/utilities/CComputeBlit.h

@@ -50,12 +50,12 @@ using namespace nbl::hlsl;
 
 struct ConstevalParameters
 {
-NBL_CONSTEXPR_STATIC_INLINE uint32_t WorkGroupSize = )===" << retval.workgroupSize << R"===(;
-using kernel_weight_binding_t = )===" << layout->getBindingInfoForHLSL({.binding=info.kernelWeights,.requiredStages=IShader::E_SHADER_STAGE::ESS_COMPUTE}) << R"===(;
-using input_sampler_binding_t = )===" << layout->getBindingInfoForHLSL({.binding=info.samplers,.requiredStages=IShader::E_SHADER_STAGE::ESS_COMPUTE}) << R"===(;
-using input_image_binding_t = )===" << layout->getBindingInfoForHLSL({.binding=info.inputs,.requiredStages=IShader::E_SHADER_STAGE::ESS_COMPUTE}) << R"===(;
-using output_binding_t = )===" << layout->getBindingInfoForHLSL({.binding=info.outputs,.requiredStages=IShader::E_SHADER_STAGE::ESS_COMPUTE}) << R"===(;
-NBL_CONSTEXPR_STATIC_INLINE uint32_t SharedMemoryDWORDs = )===" << (sharedMemoryPerInvocation* retval.workgroupSize)/sizeof(uint32_t) << R"===(;
+	NBL_CONSTEXPR_STATIC_INLINE uint32_t WorkGroupSize = )===" << retval.workgroupSize << R"===(;
+	using kernel_weight_binding_t = )===" << layout->getBindingInfoForHLSL({.binding=info.kernelWeights,.requiredStages=IShader::E_SHADER_STAGE::ESS_COMPUTE}) << R"===(;
+	using input_sampler_binding_t = )===" << layout->getBindingInfoForHLSL({.binding=info.samplers,.requiredStages=IShader::E_SHADER_STAGE::ESS_COMPUTE}) << R"===(;
+	using input_image_binding_t = )===" << layout->getBindingInfoForHLSL({.binding=info.inputs,.requiredStages=IShader::E_SHADER_STAGE::ESS_COMPUTE}) << R"===(;
+	using output_binding_t = )===" << layout->getBindingInfoForHLSL({.binding=info.outputs,.requiredStages=IShader::E_SHADER_STAGE::ESS_COMPUTE}) << R"===(;
+	NBL_CONSTEXPR_STATIC_INLINE uint32_t SharedMemoryDWORDs = )===" << (sharedMemoryPerInvocation* retval.workgroupSize)/sizeof(uint32_t) << R"===(;
 };
 )===";
 		return tmp.str();
@@ -135,30 +135,7 @@ core::smart_refctd_ptr<video::IGPUShader> createBlitSpecializedShader(
 	const uint32_t smemFloatCount = m_availableSharedMemory / (sizeof(float) * outChannelCount);
 	const uint32_t blitDimCount = static_cast<uint32_t>(imageType) + 1;
 
-
-	std::ostringstream shaderSourceStream;
-	shaderSourceStream
-		<< "#include \"nbl/builtin/hlsl/blit/common.hlsl\"\n"
-			"#include \"nbl/builtin/hlsl/blit/parameters.hlsl\"\n"
-			"#include \"nbl/builtin/hlsl/blit/compute_blit.hlsl\"\n";
-
-	shaderSourceStream
-		<< "typedef nbl::hlsl::blit::consteval_parameters_t<" << workgroupSize << ", 1, 1, " << smemFloatCount << ", "
-		<< outChannelCount << ", " << blitDimCount << ", " << paddedAlphaBinCount << "> ceval_params_t;\n";
-
-	shaderSourceStream
-		<< "[[vk::combinedImageSampler]] [[vk::binding(0, 0)]]\n"
-			"nbl::hlsl::blit::impl::dim_to_image_properties<ceval_params_t::BlitDimCount>::combined_sampler_t inCS;\n"
-			"[[vk::combinedImageSampler]] [[vk::binding(0, 0)]]\n"
-			"SamplerState inSamp;\n"
-
-			"[[vk::image_format(\""<< formatQualifier << "\")]]\n"
-			"[[vk::binding(1, 0)]]\n"
-			"nbl::hlsl::blit::impl::dim_to_image_properties<ceval_params_t::BlitDimCount>::image_t outImg;\n"
-
-			"[[vk::binding(0, 1)]] Buffer<float32_t4> kernelWeights;\n"
-			"[[vk::push_constant]] nbl::hlsl::blit::parameters_t params;"
-			"groupshared float32_t sMem[" << m_availableSharedMemory / sizeof(float) << "];\n";
+.......
 
 	if (alphaSemantic == asset::IBlitUtilities::EAS_REFERENCE_OR_COVERAGE)
 	{
@@ -184,58 +161,6 @@ core::smart_refctd_ptr<video::IGPUShader> createBlitSpecializedShader(
 			"    InCSAccessor inCSA; OutImgAccessor outImgA; KernelWeightsAccessor kwA; HistogramAccessor hA; SharedAccessor sA;\n"
 			"	blit.execute(inCSA, outImgA, kwA, hA, sA, workGroupID, localInvocationIndex);\n"
 			"}\n";
-
-	auto cpuShader = core::make_smart_refctd_ptr<asset::ICPUShader>(shaderSourceStream.str().c_str(), IGPUShader::E_SHADER_STAGE::ESS_COMPUTE, IGPUShader::E_SHADER_STAGE::E_CONTENT_TYPE::ECT_HLSL, "CComputeBlit::createBlitSpecializedShader");
-	auto gpuShader = m_device->createShader(std::move(cpuShader.get()));
-
-	return gpuShader;
-}
-
-template <typename BlitUtilities>
-core::smart_refctd_ptr<video::IGPUComputePipeline> getBlitPipeline(
-	const asset::E_FORMAT									outFormat,
-	const asset::IImage::E_TYPE								imageType,
-	const core::vectorSIMDu32& inExtent,
-	const core::vectorSIMDu32& outExtent,
-	const asset::IBlitUtilities::E_ALPHA_SEMANTIC			alphaSemantic,
-	const typename BlitUtilities::convolution_kernels_t& kernels,
-	const uint32_t											workgroupSize = 256,
-	const uint32_t											alphaBinCount = asset::IBlitUtilities::DefaultAlphaBinCount)
-{
-	const auto paddedAlphaBinCount = getPaddedAlphaBinCount(core::vectorSIMDu32(workgroupSize, 1, 1, 1), alphaBinCount);
-
-	const SBlitCacheKey key =
-	{
-		.wgSize = workgroupSize,
-		.imageType = imageType,
-		.alphaBinCount = paddedAlphaBinCount,
-		.outFormat = outFormat,
-		.smemSize = m_availableSharedMemory,
-		.coverageAdjustment = (alphaSemantic == asset::IBlitUtilities::EAS_REFERENCE_OR_COVERAGE)
-	};
-
-	if (m_blitPipelines.find(key) == m_blitPipelines.end())
-	{
-		const auto blitType = (alphaSemantic == asset::IBlitUtilities::EAS_REFERENCE_OR_COVERAGE) ? EBT_COVERAGE_ADJUSTMENT : EBT_REGULAR;
-
-		auto specShader = createBlitSpecializedShader<BlitUtilities>(
-			outFormat,
-			imageType,
-			inExtent,
-			outExtent,
-			alphaSemantic,
-			kernels,
-			workgroupSize,
-			paddedAlphaBinCount);
-
-		IGPUComputePipeline::SCreationParams creationParams;
-		creationParams.shader.shader = specShader.get();
-		creationParams.shader.entryPoint = "main";
-		creationParams.layout = m_blitPipelineLayout[blitType].get();
-		m_device->createComputePipelines(nullptr, { &creationParams, &creationParams + 1 }, &m_blitPipelines[key]);
-	}
-
-	return m_blitPipelines[key];
 }
 
 core::smart_refctd_ptr<video::IGPUShader> CComputeBlit::createAlphaTestSpecializedShader(const asset::IImage::E_TYPE imageType, const uint32_t alphaBinCount)
@@ -244,21 +169,7 @@ core::smart_refctd_ptr<video::IGPUShader> CComputeBlit::createAlphaTestSpecializ
 	const auto paddedAlphaBinCount = getPaddedAlphaBinCount(workgroupDims, alphaBinCount);
 	const uint32_t blitDimCount = static_cast<uint32_t>(imageType) + 1;
 
-	std::ostringstream shaderSourceStream;
-
-	shaderSourceStream
-		<< "#include \"nbl/builtin/hlsl/blit/common.hlsl\"\n"
-		   "#include \"nbl/builtin/hlsl/blit/parameters.hlsl\"\n"
-		   "#include \"nbl/builtin/hlsl/blit/alpha_test.hlsl\"\n"
-
-		   "typedef nbl::hlsl::blit::consteval_parameters_t<" << workgroupDims.x << ", " << workgroupDims.y << ", " << workgroupDims.z << ", "
-		   "0, 0, " << blitDimCount << ", " << paddedAlphaBinCount << "> ceval_params_t;\n"
-
-		   "[[vk::binding(0, 0)]]\n"
-		   "nbl::hlsl::blit::impl::dim_to_image_properties<ceval_params_t::BlitDimCount>::combined_sampler_t inCS;\n"
-
-		   "[[vk::binding(2 , 0)]] RWStructuredBuffer<uint32_t> statsBuff;\n"
-	       "[[vk::push_constant]] nbl::hlsl::blit::parameters_t params;"
+........
 
 		   "struct PassedPixelsAccessor { void atomicAdd(uint32_t wgID, uint32_t v) { InterlockedAdd(statsBuff[wgID * (ceval_params_t::AlphaBinCount + 1) + ceval_params_t::AlphaBinCount], v); } };\n"
 		   "struct InCSAccessor { float32_t4 get(int32_t3 c, uint32_t l) { return inCS[nbl::hlsl::blit::impl::dim_to_image_properties<ceval_params_t::BlitDimCount>::getIndexCoord<int32_t>(c, l)]; } };\n"
@@ -269,29 +180,6 @@ core::smart_refctd_ptr<video::IGPUShader> CComputeBlit::createAlphaTestSpecializ
 		   "    InCSAccessor inCSA;PassedPixelsAccessor ppA;\n"
 		   "	nbl::hlsl::blit::alpha_test(ppA, inCSA, params.inputDims, params.referenceAlpha, globalInvocationID, workGroupID);\n"
 		   "}\n";
-
-	auto cpuShader = core::make_smart_refctd_ptr<asset::ICPUShader>(shaderSourceStream.str().c_str(), IGPUShader::E_SHADER_STAGE::ESS_COMPUTE, IGPUShader::E_CONTENT_TYPE::ECT_HLSL, "CComputeBlitGLSLGLSL::createAlphaTestSpecializedShader");
-}
-
-core::smart_refctd_ptr<video::IGPUComputePipeline> getAlphaTestPipeline(const uint32_t alphaBinCount, const asset::IImage::E_TYPE imageType)
-{
-	const auto workgroupDims = getDefaultWorkgroupDims(imageType);
-	const auto paddedAlphaBinCount = getPaddedAlphaBinCount(workgroupDims, alphaBinCount);
-
-	assert(paddedAlphaBinCount >= asset::IBlitUtilities::MinAlphaBinCount);
-	const auto pipelineIndex = (paddedAlphaBinCount / asset::IBlitUtilities::MinAlphaBinCount) - 1;
-
-	if (m_alphaTestPipelines[pipelineIndex][imageType])
-		return m_alphaTestPipelines[pipelineIndex][imageType];
-
-	auto specShader = createAlphaTestSpecializedShader(imageType, paddedAlphaBinCount);
-	IGPUComputePipeline::SCreationParams creationParams;
-	creationParams.shader.shader = specShader.get();
-	creationParams.shader.entryPoint = "main";
-	creationParams.layout = m_blitPipelineLayout[EBT_COVERAGE_ADJUSTMENT].get();
-	assert(m_device->createComputePipelines(nullptr, { &creationParams, &creationParams + 1 }, &m_alphaTestPipelines[pipelineIndex][imageType]));
-
-	return m_alphaTestPipelines[pipelineIndex][imageType];
 }
 
 // @param `outFormat` dictates encoding.
@@ -301,22 +189,7 @@ core::smart_refctd_ptr<video::IGPUShader> CComputeBlit::createNormalizationSpeci
 	const auto paddedAlphaBinCount = getPaddedAlphaBinCount(workgroupDims, alphaBinCount);
 	const uint32_t blitDimCount = static_cast<uint32_t>(imageType) + 1;
 
-	std::ostringstream shaderSourceStream;
-
-	shaderSourceStream
-		<< "#include \"nbl/builtin/hlsl/blit/common.hlsl\"\n"
-		   "#include \"nbl/builtin/hlsl/blit/parameters.hlsl\"\n"
-		   "#include \"nbl/builtin/hlsl/blit/normalization.hlsl\"\n"
-
-		   "typedef nbl::hlsl::blit::consteval_parameters_t<" << workgroupDims.x << ", " << workgroupDims.y << ", " << workgroupDims.z << ", "
-		   "0, 0, " << blitDimCount << ", " << paddedAlphaBinCount << "> ceval_params_t;\n"
-
-		   "[[vk::binding(0, 0)]]\n"
-		   "nbl::hlsl::blit::impl::dim_to_image_properties<ceval_params_t::BlitDimCount>::combined_sampler_t inCS;\n"
-
-		   "[[vk::image_format(\"unknown\")]]\n"
-		   "[[vk::binding(1, 0)]]\n"
-		   "nbl::hlsl::blit::impl::dim_to_image_properties<ceval_params_t::BlitDimCount>::image_t outImg;\n"
+....
 
 		   "[[vk::binding(2 , 0)]] RWStructuredBuffer<uint32_t> statsBuff;\n"
 		   "[[vk::push_constant]] nbl::hlsl::blit::parameters_t params;"
@@ -335,27 +208,5 @@ core::smart_refctd_ptr<video::IGPUShader> CComputeBlit::createNormalizationSpeci
            "    InCSAccessor inCSA; OutImgAccessor outImgA; HistogramAccessor hA; PassedPixelsAccessor ppA; SharedAccessor sA;\n"
 		   "	blit.execute(inCSA, outImgA, hA, ppA, sA, workGroupID, globalInvocationID, localInvocationIndex);\n"
 		   "}\n";
-
-	auto cpuShader = core::make_smart_refctd_ptr<asset::ICPUShader>(shaderSourceStream.str().c_str(), IGPUShader::E_SHADER_STAGE::ESS_COMPUTE, IGPUShader::E_CONTENT_TYPE::ECT_HLSL, "CComputeBlitGLSL::createNormalizationSpecializedShader");
-}
-
-core::smart_refctd_ptr<video::IGPUComputePipeline> getNormalizationPipeline(const asset::IImage::E_TYPE imageType, const asset::E_FORMAT outFormat,
-	const uint32_t alphaBinCount = asset::IBlitUtilities::DefaultAlphaBinCount)
-{
-	const auto workgroupDims = getDefaultWorkgroupDims(imageType);
-	const uint32_t paddedAlphaBinCount = getPaddedAlphaBinCount(workgroupDims, alphaBinCount);
-	const SNormalizationCacheKey key = { imageType, paddedAlphaBinCount, outFormat };
-
-	if (m_normalizationPipelines.find(key) == m_normalizationPipelines.end())
-	{
-		auto specShader = createNormalizationSpecializedShader(imageType, outFormat, paddedAlphaBinCount);
-		IGPUComputePipeline::SCreationParams creationParams;
-		creationParams.shader.shader = specShader.get();
-		creationParams.shader.entryPoint = "main";
-		creationParams.layout = m_blitPipelineLayout[EBT_COVERAGE_ADJUSTMENT].get();
-		assert(m_device->createComputePipelines(nullptr, { &creationParams, &creationParams + 1 }, &m_normalizationPipelines[key]));
-	}
-
-	return m_normalizationPipelines[key];
 }
 #endif