Index searching for sparse waveforms is now done on the GPU where possible

Author: azonenberg

src/ngscopeclient/WaveformArea.cpp

@@ -80,10 +80,6 @@ DisplayedChannel::DisplayedChannel(StreamDescriptor stream, Session& session)
 	m_rasterizedWaveform.SetCpuAccessHint(AcceleratorBuffer<float>::HINT_LIKELY);
 	m_rasterizedWaveform.SetGpuAccessHint(AcceleratorBuffer<float>::HINT_LIKELY);
 
-	//Use pinned memory for index buffer since it should only be read once
-	m_indexBuffer.SetCpuAccessHint(AcceleratorBuffer<uint32_t>::HINT_LIKELY);
-	m_indexBuffer.SetGpuAccessHint(AcceleratorBuffer<uint32_t>::HINT_UNLIKELY);
-
 	//Create tone map pipeline depending on waveform type
 	switch(m_stream.GetType())
 	{
@@ -111,6 +107,23 @@ DisplayedChannel::DisplayedChannel(StreamDescriptor stream, Session& session)
 			m_toneMapPipe = make_shared<ComputePipeline>(
 				"shaders/WaveformToneMap.spv", 1, sizeof(WaveformToneMapArgs), 1);
 	}
+
+	//If we have native int64 support we can do the index search for sparse waveforms on the GPU
+	if(g_hasShaderInt64)
+	{
+		m_indexSearchComputePipeline = make_shared<ComputePipeline>(
+				"shaders/IndexSearch.spv", 2, sizeof(IndexSearchConstants));
+
+		//Use GPU local memory for index buffer
+		m_indexBuffer.SetCpuAccessHint(AcceleratorBuffer<uint32_t>::HINT_LIKELY);
+		m_indexBuffer.SetGpuAccessHint(AcceleratorBuffer<uint32_t>::HINT_LIKELY);
+	}
+	else
+	{
+		//Use pinned memory for index buffer since it should only be read once
+		m_indexBuffer.SetCpuAccessHint(AcceleratorBuffer<uint32_t>::HINT_LIKELY);
+		m_indexBuffer.SetGpuAccessHint(AcceleratorBuffer<uint32_t>::HINT_UNLIKELY);
+	}
 }
 
 DisplayedChannel::~DisplayedChannel()
@@ -1339,7 +1352,6 @@ ImVec2 WaveformArea::ClosestPointOnLineSegment(ImVec2 lineA, ImVec2 lineB, ImVec
 void WaveformArea::RenderSpectrumPeaks(ImDrawList* list, shared_ptr<DisplayedChannel> channel)
 {
 	auto stream = channel->GetStream();
-	auto data = stream.GetData();
 	auto& peaks = dynamic_cast<PeakDetectionFilter*>(stream.m_channel)->GetPeaks();
 
 	//TODO: add a preference for peak circle color and size?
@@ -2107,38 +2119,72 @@ void WaveformArea::RasterizeAnalogOrDigitalWaveform(
 	}
 
 	//Bind input buffers
-	if(uadata)
-		comp->BindBufferNonblocking(1, uadata->m_samples, cmdbuf);
-	if(uddata)
-		comp->BindBufferNonblocking(1, uddata->m_samples, cmdbuf);
 	if(sdata)
 	{
+		//Calculate indexes for X axis
+		auto& ibuf = channel->GetIndexBuffer();
+
+		//FIXME: what still depends on m_offsets CPU side??
+		//If we don't copy this, nothing is drawn
+		sdata->m_offsets.PrepareForCpuAccessNonblocking(cmdbuf);
+
+		//If we have native int64, do this on the GPU
+		if(g_hasShaderInt64)
+		{
+			IndexSearchConstants cfg;
+			cfg.len = data->size();
+			cfg.w = w;
+			cfg.xscale = xscale;
+			cfg.offset_samples = offset_samples;
+
+			const uint32_t threadsPerBlock = 64;
+			const uint32_t numBlocks = (w | (threadsPerBlock - 1)) / threadsPerBlock;
+
+			auto ipipe = channel->GetIndexSearchPipeline();
+			ipipe->BindBufferNonblocking(0, sdata->m_offsets, cmdbuf);
+			ipipe->BindBufferNonblocking(1, ibuf, cmdbuf, true);
+			ipipe->Dispatch(cmdbuf, cfg, numBlocks);
+			ipipe->AddComputeMemoryBarrier(cmdbuf);
+			ibuf.MarkModifiedFromGpu();
+		}
+
+		//otherwise CPU fallback
+		else
+		{
+			ibuf.PrepareForCpuAccess();
+			sdata->m_offsets.PrepareForCpuAccess();
+			for(size_t i=0; i<w; i++)
+			{
+				int64_t target = floor(i / xscale) + offset_samples;
+				ibuf[i] = BinarySearchForGequal(
+					sdata->m_offsets.GetCpuPointer(),
+					data->size(),
+					target);
+
+				if(i < 16)
+					LogDebug("ibuf[%zu] = %d\n", i, ibuf[i]);
+			}
+			ibuf.MarkModifiedFromCpu();
+		}
+
+		//Bind the buffers
 		if(sadata)
 			comp->BindBufferNonblocking(1, sadata->m_samples, cmdbuf);
 		if(sddata)
 			comp->BindBufferNonblocking(1, sddata->m_samples, cmdbuf);
 
 		//Map offsets and, if requested, durations
 		comp->BindBufferNonblocking(2, sdata->m_offsets, cmdbuf);
+		comp->BindBufferNonblocking(3, ibuf, cmdbuf);
 		if(channel->ShouldMapDurations())
 			comp->BindBufferNonblocking(4, sdata->m_durations, cmdbuf);
-
-		//Calculate indexes for X axis
-		auto& ibuf = channel->GetIndexBuffer();
-		ibuf.PrepareForCpuAccess();
-		sdata->m_offsets.PrepareForCpuAccess();
-		for(size_t i=0; i<w; i++)
-		{
-			int64_t target = floor(i / xscale) + offset_samples;
-			ibuf[i] = BinarySearchForGequal(
-				sdata->m_offsets.GetCpuPointer(),
-				data->size(),
-				target);
-		}
-		ibuf.MarkModifiedFromCpu();
-		comp->BindBufferNonblocking(3, ibuf, cmdbuf);
 	}
 
+	if(uadata)
+		comp->BindBufferNonblocking(1, uadata->m_samples, cmdbuf);
+	if(uddata)
+		comp->BindBufferNonblocking(1, uddata->m_samples, cmdbuf);
+
 	//Bind output texture and bail if there's nothing there
 	auto& imgOut = channel->GetRasterizedWaveform();
 	if(imgOut.empty())

src/ngscopeclient/WaveformArea.h

@@ -145,6 +145,15 @@ struct ConfigPushConstants
 	float persistScale;
 };
 
+class IndexSearchConstants
+{
+public:
+	int64_t offset_samples;
+	float xscale;
+	uint32_t len;
+	uint32_t w;
+};
+
 /**
 	@brief State for a single peak label
 
@@ -335,6 +344,9 @@ class DisplayedChannel
 	std::shared_ptr<ComputePipeline> GetToneMapPipeline()
 	{ return m_toneMapPipe; }
 
+	std::shared_ptr<ComputePipeline> GetIndexSearchPipeline()
+	{ return m_indexSearchComputePipeline; }
+
 	bool ZeroHoldFlagSet()
 	{
 		return m_stream.GetFlags() & Stream::STREAM_DO_NOT_INTERPOLATE;
@@ -432,6 +444,9 @@ class DisplayedChannel
 	///@brief Compute pipeline for rendering sparse digital waveforms
 	std::shared_ptr<ComputePipeline> m_sparseDigitalComputePipeline;
 
+	///@brief Compute pipeline for index searching
+	std::shared_ptr<ComputePipeline> m_indexSearchComputePipeline;
+
 	///@brief Y axis position of our button within the view
 	float m_yButtonPos;
 

src/ngscopeclient/WaveformThread.cpp

@@ -128,6 +128,10 @@ void WaveformThread(Session* session, atomic<bool>* shuttingDown)
 		//Wait for data to be available from all scopes
 		if(!session->CheckForPendingWaveforms())
 		{
+			#ifdef HAVE_NVTX
+				nvtx3::scoped_range range2("No data ready");
+			#endif
+
 			this_thread::sleep_for(chrono::milliseconds(1));
 			continue;
 		}

src/ngscopeclient/shaders/CMakeLists.txt

@@ -31,6 +31,7 @@ add_compute_shaders(
 	SOURCES
 		ConstellationToneMap.glsl
 		EyeToneMap.glsl
+		IndexSearch.glsl
 		ScopeDeskewUniform4xRate.glsl
 		ScopeDeskewUniformUnequalRate.glsl
 		ScopeDeskewUniformEqualRate.glsl

src/ngscopeclient/shaders/IndexSearch.glsl

@@ -0,0 +1,112 @@
+/***********************************************************************************************************************
+*                                                                                                                      *
+* libscopehal                                                                                                          *
+*                                                                                                                      *
+* Copyright (c) 2012-2026 Andrew D. Zonenberg and contributors                                                         *
+* All rights reserved.                                                                                                 *
+*                                                                                                                      *
+* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the     *
+* following conditions are met:                                                                                        *
+*                                                                                                                      *
+*    * Redistributions of source code must retain the above copyright notice, this list of conditions, and the         *
+*      following disclaimer.                                                                                           *
+*                                                                                                                      *
+*    * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the       *
+*      following disclaimer in the documentation and/or other materials provided with the distribution.                *
+*                                                                                                                      *
+*    * Neither the name of the author nor the names of any contributors may be used to endorse or promote products     *
+*      derived from this software without specific prior written permission.                                           *
+*                                                                                                                      *
+* THIS SOFTWARE IS PROVIDED BY THE AUTHORS "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 AUTHORS BE HELD 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.                                                                                          *
+*                                                                                                                      *
+***********************************************************************************************************************/
+
+#version 430
+#pragma shader_stage(compute)
+#extension GL_ARB_gpu_shader_int64 : require
+
+layout(std430, binding=0) restrict readonly buffer buf_din
+{
+	int64_t din[];
+};
+
+layout(std430, binding=1) restrict writeonly buffer buf_results
+{
+	uint results[];
+};
+
+layout(std430, push_constant) uniform constants
+{
+	int64_t offset_samples;
+	float xscale;
+	uint len;
+	uint w;
+};
+
+layout(local_size_x=64, local_size_y=1, local_size_z=1) in;
+
+void main()
+{
+	//Get thread index and bounds check
+	if(gl_GlobalInvocationID.x >= w)
+		return;
+
+	//Get timestamp of the first sample in this thread's block
+	int64_t dx = int64_t(floor(float(gl_GlobalInvocationID.x) / xscale));
+	int64_t target = dx + offset_samples;
+
+	//Binary search for the first clock edge after this sample
+	uint pos = len/2;
+	uint last_lo = 0;
+	uint last_hi = len-1;
+	uint iclk = 0;
+	if(len > 0)
+	{
+		//Clip if out of range
+		if(din[0] >= target)
+			iclk = 0;
+		else if(din[last_hi] < target)
+			iclk = len-1;
+
+		//Main loop
+		else
+		{
+			while(true)
+			{
+				//Stop if we've bracketed the target
+				if( (last_hi - last_lo) <= 1)
+				{
+					iclk = last_lo;
+					break;
+				}
+
+				//Move down
+				if(din[pos] > target)
+				{
+					uint delta = pos - last_lo;
+					last_hi = pos;
+					pos = last_lo + delta/2;
+				}
+
+				//Move up
+				else
+				{
+					uint delta = last_hi - pos;
+					last_lo = pos;
+					pos = last_hi - delta/2;
+				}
+			}
+		}
+	}
+
+	//We want one before the target
+	iclk --;
+
+	results[gl_GlobalInvocationID.x] = iclk;
+}