First real GPU audio node: FFT-based (overlap-add) convolution of the input with a fixed impulse response, computed on the GPU via render::GpuCompute on the transport's non-RT worker. More...

#include <gpu_convolver.hpp>

Public Types
enum class	ProviderPolicy : std::uint8_t { Auto , StagedOnly , SharedRequired , StagedBlocking }
	Host-thread selection for the provider used during the next prepare(). More...

Public Member Functions
	GpuConvolver (uint32_t channels, uint32_t block_size, uint32_t sample_rate, std::vector< float > impulse_response)
	GpuConvolver (uint32_t channels, uint32_t block_size, uint32_t sample_rate, std::vector< float > impulse_response, uint32_t latency_blocks)
	~GpuConvolver () override
bool	set_provider_policy (ProviderPolicy policy) noexcept
	Select the provider policy for the next prepare().
ProviderPolicy	provider_policy () const noexcept
bool	configure_trace (const GpuConvolverTraceConfig &config) noexcept
	Enable bounded shared-I/O tracing for the next prepare().
bool	configure_staged_breaker (const GpuConvolverStagedBreaker &config) noexcept
	Set the staged-path circuit breaker for the next prepare().
GpuConvolverStagedBreaker	staged_breaker () const noexcept
GpuAudioNodeDescriptor	descriptor () const override
bool	prepare () override
	Non-RT. Allocate/compile/upload static data here.
bool	cpu_fallback_prepared () const noexcept override
	Host-thread witness that the realtime CPU fallback is already built before prepare() returns.
void	process_block (const audio::BufferView< const float > &input, audio::BufferView< float > &output, uint32_t n) override
	Non-RT worker context. Process exactly one block (n == block_size).
void	prime_fallback (const audio::BufferView< const float > &input, uint32_t n) noexcept override
	RT-safe.
void	process_cpu_fallback (const audio::BufferView< const float > &, audio::BufferView< float > &output, uint32_t n) noexcept override
	RT-safe miss substitute: emit the latency-aligned block that prime_fallback() already computed for this timeline slot.
bool	gpu_available () const
	True if the GPU compute device initialized (process_block uses the GPU).
std::string	backend () const
	The live native compute backend ("Metal"/"D3D12"/"Vulkan"), or "" if CPU-only.
uint32_t	fft_size () const
GpuAudioStatus	status_snapshot () const noexcept override
	Allocation-free provider-neutral lifecycle projection, safe to call from a host or UI thread while a transport runs this node (not concurrently with prepare()).
bool	bind_realtime_path (detail::RealtimeGpuNodeBinding &binding) noexcept override
	Private transport hook, not for node authors: a node that the GPU audio transport drives through a stamped realtime path describes that path here.
GpuAudioRecoveryReason	recovery_reason () const noexcept
	First latched recovery cause, or None. Same snapshot as status_snapshot().
bool	fenced () const noexcept
	True before preparation, or once GPU delivery was fenced or its provider lost.
std::uint64_t	sanitized_input_samples () const noexcept
	Non-finite input samples (NaN, +/-Inf) replaced with zero before they reached the GPU, on the shared realtime path or the staged path, since prepare().
virtual bool	release_bounded (std::uint64_t) noexcept
	Host thread, audio stopped.

Static Public Attributes
static constexpr uint32_t	kLatencyBlocks = 2
	Default worker/round-trip latency, in host blocks.
static constexpr uint32_t	kMaxLatencyBlocks = 64
static constexpr uint32_t	kSharedIoSlots = 16

Protected Member Functions
void	init_fallback ()
	Allocate + load the CPU fallback machinery (both the RT miss fallback and the no-GPU worker fallback) and the latency-alignment delay ring.
void	render_worker_fallback (const audio::BufferView< const float > &input, audio::BufferView< float > &output, uint32_t n) noexcept
	No-GPU worker path: run the (continuously-fed) worker fallback for every prepared channel into output, zeroing anything else.
GpuAudioRecoveryReason	staged_recovery_reason () const noexcept
bool	has_realtime_shared_io () const noexcept
detail::SharedIoProviderIdentity	provider_identity_for_diagnostics () const noexcept
bool	wait_staged_readback (StagedReadbackState &staged, float *dest)
void	submit_staged_readback (StagedReadbackState &staged, std::size_t slot_index)
void	configure_staged_pipeline ()
std::uint32_t	staged_pipeline_depth () const noexcept
void	latch_staged_recovery (GpuAudioRecoveryReason reason) noexcept
void	update_staged_breaker (StagedReadbackState &staged, bool on_time) noexcept
std::uint64_t	staged_cpu_blocks () const noexcept
std::uint64_t	staged_gpu_blocks () const noexcept
std::uint64_t	staged_breaker_trips () const noexcept
GpuAudioRecoveryReason	staged_latched_reason () const noexcept

Static Protected Member Functions
static std::uint8_t	process_realtime_shared_io (void *self, const audio::BufferView< const float > &input, audio::BufferView< float > &output, std::uint32_t n, std::uint64_t sequence, bool input_valid, std::uint64_t callback_start_ns) noexcept
static std::uint32_t	service_realtime_shared_io (void *self, std::uint64_t now_ns) noexcept
static bool	fence_realtime_shared_io (void *self) noexcept
static void	complete_realtime_shared_io (void *, std::uint64_t, std::uint8_t, std::uint64_t callback_end_ns, std::uint64_t result_visible_ns) noexcept
static std::uint64_t	next_realtime_shared_io_sequence (void *) noexcept
static bool	realtime_shared_io_health (const void *self, detail::RealtimeGpuHealth &) noexcept
static bool	set_realtime_shared_io_notifier (void *self, detail::SharedIoCompletionNotifier) noexcept
static bool	set_staged_pipeline_hosting (void *self, bool hosted) noexcept

Protected Attributes
uint32_t	channels_
uint32_t	block_
uint32_t	sample_rate_
uint32_t	latency_blocks_ = kLatencyBlocks
ProviderPolicy	provider_policy_ = ProviderPolicy::Auto
std::vector< float >	ir_
uint32_t	fft_size_ = 0
std::uint8_t	trial_requested_path_ = 0
std::uint64_t	trial_generation_ = 1
bool	trial_configured_ = false
bool	trial_enable_trace_ = false
bool	trial_capture_admissions_ = false
bool	trial_capture_callback_timing_ = false
bool	trial_staged_sync_reference_ = false
std::uint32_t	trial_success_stride_ = 1
std::uint8_t	trial_completion_policy_ = 0
std::uint64_t	trial_completion_wait_ns_ = 0
std::unique_ptr< render::GpuCompute >	gpu_
std::unique_ptr< SharedIoState >	shared_io_
std::unique_ptr< detail::StagedAsyncTrialState >	staged_trial_
std::vector< detail::SharedIoTraceRecord >	staged_sync_records_
std::uint64_t	staged_sequence_ = 0
std::vector< float >	ir_spec_
std::vector< std::vector< float > >	carry_
std::vector< float >	in_pad_
std::vector< float >	time_
std::vector< signal::FixedIrConvolver >	fallback_
std::vector< signal::FixedIrConvolver >	worker_fallback_
uint32_t	fallback_delay_blocks_ = 0
uint32_t	fb_delay_idx_ = 0
std::vector< float >	fb_delay_
std::vector< float >	fb_out_
bool	prepared_ = false
std::unique_ptr< StagedReadbackState >	staged_readback_

Friends
struct	detail::GpuConvolverTestAccess
bool	detail::configure_gpu_convolver_trial (GpuConvolver &, const detail::GpuConvolverTrialConfig &) noexcept
bool	detail::drain_gpu_convolver_trial_records (GpuConvolver &, std::vector< detail::SharedIoTraceRecord > &) noexcept
bool	detail::drain_gpu_convolver_trial_admissions (GpuConvolver &, std::vector< detail::SharedIoTraceAdmission > &) noexcept
std::uint64_t	detail::gpu_convolver_trial_engine_id (const GpuConvolver &) noexcept

Detailed Description

First real GPU audio node: FFT-based (overlap-add) convolution of the input with a fixed impulse response, computed on the GPU via render::GpuCompute on the transport's non-RT worker.

Each block issues ONE batched GPU convolution — forward FFT, complex multiply by the resident IR spectrum, and inverse FFT for every channel, fused into a single submit with a single readback. The per-call GPU round-trip (~0.5 ms of map latency) is therefore paid once per block rather than once per channel.

Staged readback (Auto / StagedOnly). The worker never waits on the GPU: it submits block N with GpuCompute::convolve_batch_async and returns, and the result counts only if it has landed by the time block N is due, latency_blocks - 1 calls later (descriptor().worker_pipeline_blocks; 1 at the default lead of 2). That pipeline sits inside the reported latency, so total latency and PDC are unchanged. A late result is discarded. Every block's input lands in exactly one place: the GPU overlap-add carry when its result is on time, otherwise the worker's zero-latency CPU convolution. The output is the carry plus whatever the CPU convolution still owes, so a late, failed, non-finite or device-lost block is the exact continuation, never silence. The CPU convolution runs only for a missed block and the IR-length tail after it; a GPU hit costs none. A run of misses trips the breaker (GpuConvolverStagedBreaker): the worker stops submitting, runs on the CPU, and probes the GPU periodically until it is on time again. A node prepared with a one-block lead cannot pipeline and waits, bounded, inside the block instead.

Lifetime: while a GpuAudioTransport hosts a pipelining GpuConvolver (descriptor().worker_pipeline_blocks > 0), the transport's release() opts the node back out of pipelining. A node destroyed first detaches itself from the transport, so release() then touches nothing; a non-pipelining node is never touched by release(). Destroying it first is safe only once neither pump() nor process() runs on its transport: the audio callback's process() calls the node's CPU fallback, and a transport running its own worker (Config::run_worker_thread) pumps the node until release() joins it. Otherwise release that transport before destroying the node.

CPU fallback (MissPolicy::CpuFallback). The fallback is a zero-latency signal::FixedIrConvolver per channel that the transport keeps CONTINUOUSLY fed via prime_fallback() — one direct-FIR or partitioned block each audio block, not only on misses. A fallback fed only on misses would have gaps in its history, so a substituted block would not continue the convolution (its IR tail energy from the preceding audio would be missing): an audible discontinuity, not merely lower precision. Because the priming path is zero-latency but the transport reports latency_blocks of PDC for the GPU pipeline, the fallback's output is pushed through a matching latency_blocks-deep delay so a miss substitute equals the wet block the worker ring would have returned (input(t-L) convolved) — the seam is sample-aligned, never a dry glitch and never a block early/late.

process_block still waits (bounded) on the GPU readback, which is why it runs on the transport's non-RT worker and never on the audio thread. Live use at small block sizes should still prefer the CPU fallback: a prepared CPU convolution costs microseconds, and no amount of batching beats a map round-trip for a single stereo pair.

Member Enumeration Documentation

◆ ProviderPolicy

enum class pulp::gpu_audio::GpuConvolver::ProviderPolicy : std::uint8_t

strong

Host-thread selection for the provider used during the next prepare().

Auto preserves staged/CPU execution even when shared support is compiled, using the deadline-bounded staged readback described above. StagedOnly is the same staged path, named explicitly. SharedRequired explicitly opts into the authenticated shared Dawn path. StagedBlocking keeps the earlier unbounded GpuCompute::convolve_batch readback for callers that depend on its timing; it still fills failed or device-lost blocks from the CPU continuation. StagedBlocking is a transition escape hatch and is planned for removal in the next minor release. Selection is immutable while prepared and never changes from the audio callback.

Enumerator
Auto
StagedOnly
SharedRequired
StagedBlocking

Constructor & Destructor Documentation

◆ GpuConvolver() [1/2]

pulp::gpu_audio::GpuConvolver::GpuConvolver	(	uint32_t	channels,
		uint32_t	block_size,
		uint32_t	sample_rate,
		std::vector< float >	impulse_response )

◆ GpuConvolver() [2/2]

pulp::gpu_audio::GpuConvolver::GpuConvolver	(	uint32_t	channels,
		uint32_t	block_size,
		uint32_t	sample_rate,
		std::vector< float >	impulse_response,
		uint32_t	latency_blocks )

◆ ~GpuConvolver()

pulp::gpu_audio::GpuConvolver::~GpuConvolver ( )

override

Member Function Documentation

◆ backend()

std::string pulp::gpu_audio::GpuConvolver::backend ( ) const

The live native compute backend ("Metal"/"D3D12"/"Vulkan"), or "" if CPU-only.

On the shared path this names Dawn's underlying Metal backend; use the transport capability report when the provider identity itself matters.

◆ bind_realtime_path()

bool pulp::gpu_audio::GpuConvolver::bind_realtime_path ( detail::RealtimeGpuNodeBinding & )

overridevirtualnoexcept

Private transport hook, not for node authors: a node that the GPU audio transport drives through a stamped realtime path describes that path here.

Returns false for a node the transport drives through its staged worker path, which is the default.

Reimplemented from pulp::gpu_audio::GpuAudioNode.

◆ complete_realtime_shared_io()

void pulp::gpu_audio::GpuConvolver::complete_realtime_shared_io	(	void *	,
		std::uint64_t	,
		std::uint8_t	,
		std::uint64_t	callback_end_ns,
		std::uint64_t	result_visible_ns )

staticprotectednoexcept

◆ configure_staged_breaker()

bool pulp::gpu_audio::GpuConvolver::configure_staged_breaker ( const GpuConvolverStagedBreaker & config )

noexcept

Set the staged-path circuit breaker for the next prepare().

Returns false while prepared or for a zero field.

◆ configure_staged_pipeline()

void pulp::gpu_audio::GpuConvolver::configure_staged_pipeline ( )

protected

◆ configure_trace()

bool pulp::gpu_audio::GpuConvolver::configure_trace ( const GpuConvolverTraceConfig & config )

noexcept

Enable bounded shared-I/O tracing for the next prepare().

This is a host-thread operation and fails after preparation. The transport worker remains the sole live queue consumer; final close drains any remainder.

◆ cpu_fallback_prepared()

bool pulp::gpu_audio::GpuConvolver::cpu_fallback_prepared ( ) const

inlineoverridevirtualnoexcept

Host-thread witness that the realtime CPU fallback is already built before prepare() returns.

A descriptor's supports_cpu_fallback bit is only a declaration; the transport admits MissPolicy::CpuFallback after both the declaration and this prepared witness are true. Nodes with no verified fallback remain fail-closed and must use silence on a miss.

Reimplemented from pulp::gpu_audio::GpuAudioNode.

◆ descriptor()

GpuAudioNodeDescriptor pulp::gpu_audio::GpuConvolver::descriptor ( ) const

overridevirtual

Implements pulp::gpu_audio::GpuAudioNode.

◆ fence_realtime_shared_io()

bool pulp::gpu_audio::GpuConvolver::fence_realtime_shared_io ( void * self )

staticprotectednoexcept

◆ fenced()

bool pulp::gpu_audio::GpuConvolver::fenced ( ) const

noexcept

True before preparation, or once GPU delivery was fenced or its provider lost.

A diagnostic snapshot, not a promise about the next block.

◆ fft_size()

uint32_t pulp::gpu_audio::GpuConvolver::fft_size ( ) const

inline

◆ gpu_available()

bool pulp::gpu_audio::GpuConvolver::gpu_available ( ) const

True if the GPU compute device initialized (process_block uses the GPU).

◆ has_realtime_shared_io()

bool pulp::gpu_audio::GpuConvolver::has_realtime_shared_io ( ) const

protectednoexcept

◆ init_fallback()

void pulp::gpu_audio::GpuConvolver::init_fallback ( )

inlineprotected

Allocate + load the CPU fallback machinery (both the RT miss fallback and the no-GPU worker fallback) and the latency-alignment delay ring.

Shared by the render and no-render prepare() paths so they can never drift.

◆ latch_staged_recovery()

void pulp::gpu_audio::GpuConvolver::latch_staged_recovery ( GpuAudioRecoveryReason reason )

protectednoexcept

◆ next_realtime_shared_io_sequence()

std::uint64_t pulp::gpu_audio::GpuConvolver::next_realtime_shared_io_sequence ( void * )

staticprotectednoexcept

◆ prepare()

bool pulp::gpu_audio::GpuConvolver::prepare ( )

overridevirtual

Non-RT. Allocate/compile/upload static data here.

Implements pulp::gpu_audio::GpuAudioNode.

◆ prime_fallback()

void pulp::gpu_audio::GpuConvolver::prime_fallback	(	const audio::BufferView< const float > &	input,
		uint32_t	n )

overridevirtualnoexcept

RT-safe.

Feed the continuously-fed CPU fallback one block so its history stays current, and stage the latency-aligned substitute for a possible miss this block. Called by the transport on every block (hit or miss). Non-finite samples enter as zero, as on the GPU paths, so the substitute keeps the IR tail and matches the GPU output it stands in for.

Reimplemented from pulp::gpu_audio::GpuAudioNode.

◆ process_block()

void pulp::gpu_audio::GpuConvolver::process_block	(	const audio::BufferView< const float > &	input,
		audio::BufferView< float > &	output,
		uint32_t	n )

overridevirtual

Non-RT worker context. Process exactly one block (n == block_size).

Implements pulp::gpu_audio::GpuAudioNode.

◆ process_cpu_fallback()

void pulp::gpu_audio::GpuConvolver::process_cpu_fallback	(	const audio::BufferView< const float > &	,
		audio::BufferView< float > &	output,
		uint32_t	n )

inlineoverridevirtualnoexcept

RT-safe miss substitute: emit the latency-aligned block that prime_fallback() already computed for this timeline slot.

Reimplemented from pulp::gpu_audio::GpuAudioNode.

◆ process_realtime_shared_io()

std::uint8_t pulp::gpu_audio::GpuConvolver::process_realtime_shared_io	(	void *	self,
		const audio::BufferView< const float > &	input,
		audio::BufferView< float > &	output,
		std::uint32_t	n,
		std::uint64_t	sequence,
		bool	input_valid,
		std::uint64_t	callback_start_ns )

staticprotectednoexcept

◆ provider_identity_for_diagnostics()

detail::SharedIoProviderIdentity pulp::gpu_audio::GpuConvolver::provider_identity_for_diagnostics ( ) const

protectednoexcept

◆ provider_policy()

ProviderPolicy pulp::gpu_audio::GpuConvolver::provider_policy ( ) const

inlinenoexcept

◆ realtime_shared_io_health()

bool pulp::gpu_audio::GpuConvolver::realtime_shared_io_health	(	const void *	self,
		detail::RealtimeGpuHealth &	)

staticprotectednoexcept

◆ recovery_reason()

GpuAudioRecoveryReason pulp::gpu_audio::GpuConvolver::recovery_reason ( ) const

noexcept

First latched recovery cause, or None. Same snapshot as status_snapshot().

◆ release_bounded()

virtual bool pulp::gpu_audio::GpuAudioNode::release_bounded ( std::uint64_t )

inlinevirtualnoexceptinherited

Host thread, audio stopped.

Release provider resources within budget_ns, returning false if teardown had to be abandoned to stay in budget. The default holds nothing to release.

Reimplemented in pulp::gpu_audio::GpuWaveNetRealtimeNode.

◆ render_worker_fallback()

void pulp::gpu_audio::GpuConvolver::render_worker_fallback	(	const audio::BufferView< const float > &	input,
		audio::BufferView< float > &	output,
		uint32_t	n )

inlineprotectednoexcept

No-GPU worker path: run the (continuously-fed) worker fallback for every prepared channel into output, zeroing anything else.

Both selected engines are zero-latency, so the fallback matches the GPU path's algorithmic timing.

This is the SOLE audio path when the device fails to init (the !gpu_ branch of process_block) and in the no-render build, so it carries its own non-finite-input guard: a single NaN/Inf would otherwise poison worker_fallback_'s history for the whole IR tail (the IR length, plus one block on the FFT engine). On a poisoned block we reset the convolver and emit silence for that channel; it self-heals on the next finite block instead of dying for the tail. The staged GPU path hands it input already sanitized, so the guard never fires there.

◆ sanitized_input_samples()

std::uint64_t pulp::gpu_audio::GpuConvolver::sanitized_input_samples ( ) const

noexcept

Non-finite input samples (NaN, +/-Inf) replaced with zero before they reached the GPU, on the shared realtime path or the staged path, since prepare().

One such sample would otherwise ring through the whole IR tail or fence the GPU on a non-finite readback. Counted, not latched. Always 0 without a GPU device.

◆ service_realtime_shared_io()

std::uint32_t pulp::gpu_audio::GpuConvolver::service_realtime_shared_io	(	void *	self,
		std::uint64_t	now_ns )

staticprotectednoexcept

◆ set_provider_policy()

bool pulp::gpu_audio::GpuConvolver::set_provider_policy ( ProviderPolicy policy )

noexcept

Select the provider policy for the next prepare().

Returns false when called after preparation; callers must quiesce and release the node before selecting a new policy. SharedRequired fails preparation unless the exact authenticated shared provider is available.

◆ set_realtime_shared_io_notifier()

bool pulp::gpu_audio::GpuConvolver::set_realtime_shared_io_notifier	(	void *	self,
		detail::SharedIoCompletionNotifier	)

staticprotectednoexcept

◆ set_staged_pipeline_hosting()

bool pulp::gpu_audio::GpuConvolver::set_staged_pipeline_hosting	(	void *	self,
		bool	hosted )

staticprotectednoexcept

◆ staged_breaker()

GpuConvolverStagedBreaker pulp::gpu_audio::GpuConvolver::staged_breaker ( ) const

noexcept

◆ staged_breaker_trips()

std::uint64_t pulp::gpu_audio::GpuConvolver::staged_breaker_trips ( ) const

protectednoexcept

◆ staged_cpu_blocks()

std::uint64_t pulp::gpu_audio::GpuConvolver::staged_cpu_blocks ( ) const

protectednoexcept

◆ staged_gpu_blocks()

std::uint64_t pulp::gpu_audio::GpuConvolver::staged_gpu_blocks ( ) const

protectednoexcept

◆ staged_latched_reason()

GpuAudioRecoveryReason pulp::gpu_audio::GpuConvolver::staged_latched_reason ( ) const

protectednoexcept

◆ staged_pipeline_depth()

std::uint32_t pulp::gpu_audio::GpuConvolver::staged_pipeline_depth ( ) const

protectednoexcept

◆ staged_recovery_reason()

GpuAudioRecoveryReason pulp::gpu_audio::GpuConvolver::staged_recovery_reason ( ) const

protectednoexcept

◆ status_snapshot()

GpuAudioStatus pulp::gpu_audio::GpuConvolver::status_snapshot ( ) const

overridevirtualnoexcept

Allocation-free provider-neutral lifecycle projection, safe to call from a host or UI thread while a transport runs this node (not concurrently with prepare()).

The authenticated shared path reports the health its transport last sampled after a service step: a fenced session is Degraded, a lost provider is Unavailable, each with the first latched recovery reason. The staged path reports what it can prove: provider and engine are Unknown while the staged GpuCompute device is live, the engine is Cpu when no device initialized, and a lost device is Unavailable with ProviderLost.

Reimplemented from pulp::gpu_audio::GpuAudioNode.

◆ submit_staged_readback()

void pulp::gpu_audio::GpuConvolver::submit_staged_readback	(	StagedReadbackState &	staged,
		std::size_t	slot_index )

protected

◆ update_staged_breaker()

void pulp::gpu_audio::GpuConvolver::update_staged_breaker	(	StagedReadbackState &	staged,
		bool	on_time )

protectednoexcept

◆ wait_staged_readback()

bool pulp::gpu_audio::GpuConvolver::wait_staged_readback	(	StagedReadbackState &	staged,
		float *	dest )

protected

◆ detail::configure_gpu_convolver_trial

bool detail::configure_gpu_convolver_trial	(	GpuConvolver &	,
		const detail::GpuConvolverTrialConfig &	)

friend

◆ detail::drain_gpu_convolver_trial_admissions

bool detail::drain_gpu_convolver_trial_admissions	(	GpuConvolver &	,
		std::vector< detail::SharedIoTraceAdmission > &	)

friend

◆ detail::drain_gpu_convolver_trial_records

bool detail::drain_gpu_convolver_trial_records	(	GpuConvolver &	,
		std::vector< detail::SharedIoTraceRecord > &	)

friend

◆ detail::gpu_convolver_trial_engine_id

std::uint64_t detail::gpu_convolver_trial_engine_id ( const GpuConvolver & )

friend

◆ detail::GpuConvolverTestAccess

friend struct detail::GpuConvolverTestAccess

friend

Member Data Documentation

◆ block_

uint32_t pulp::gpu_audio::GpuConvolver::block_

protected

◆ carry_

std::vector<std::vector<float> > pulp::gpu_audio::GpuConvolver::carry_

protected

◆ channels_

uint32_t pulp::gpu_audio::GpuConvolver::channels_

protected

◆ fallback_

std::vector<signal::FixedIrConvolver> pulp::gpu_audio::GpuConvolver::fallback_

protected

◆ fallback_delay_blocks_

uint32_t pulp::gpu_audio::GpuConvolver::fallback_delay_blocks_ = 0

protected

◆ fb_delay_

std::vector<float> pulp::gpu_audio::GpuConvolver::fb_delay_

protected

◆ fb_delay_idx_

uint32_t pulp::gpu_audio::GpuConvolver::fb_delay_idx_ = 0

protected

◆ fb_out_

std::vector<float> pulp::gpu_audio::GpuConvolver::fb_out_

protected

◆ fft_size_

uint32_t pulp::gpu_audio::GpuConvolver::fft_size_ = 0

protected

◆ gpu_

std::unique_ptr<render::GpuCompute> pulp::gpu_audio::GpuConvolver::gpu_

protected

◆ in_pad_

std::vector<float> pulp::gpu_audio::GpuConvolver::in_pad_

protected

◆ ir_

std::vector<float> pulp::gpu_audio::GpuConvolver::ir_

protected

◆ ir_spec_

std::vector<float> pulp::gpu_audio::GpuConvolver::ir_spec_

protected

◆ kLatencyBlocks

uint32_t pulp::gpu_audio::GpuConvolver::kLatencyBlocks = 2

staticconstexpr

Default worker/round-trip latency, in host blocks.

A constructed node may select another positive lead for a controlled campaign; the selected value is reported as PDC and shared by the bridge and CPU fallback.

◆ kMaxLatencyBlocks

uint32_t pulp::gpu_audio::GpuConvolver::kMaxLatencyBlocks = 64

staticconstexpr

◆ kSharedIoSlots

uint32_t pulp::gpu_audio::GpuConvolver::kSharedIoSlots = 16

staticconstexpr

◆ latency_blocks_

uint32_t pulp::gpu_audio::GpuConvolver::latency_blocks_ = kLatencyBlocks

protected

◆ prepared_

bool pulp::gpu_audio::GpuConvolver::prepared_ = false

protected

◆ provider_policy_

ProviderPolicy pulp::gpu_audio::GpuConvolver::provider_policy_ = ProviderPolicy::Auto

protected

◆ sample_rate_

uint32_t pulp::gpu_audio::GpuConvolver::sample_rate_

protected

◆ shared_io_

std::unique_ptr<SharedIoState> pulp::gpu_audio::GpuConvolver::shared_io_

protected

◆ staged_readback_

std::unique_ptr<StagedReadbackState> pulp::gpu_audio::GpuConvolver::staged_readback_

protected

◆ staged_sequence_

std::uint64_t pulp::gpu_audio::GpuConvolver::staged_sequence_ = 0

protected

◆ staged_sync_records_

std::vector<detail::SharedIoTraceRecord> pulp::gpu_audio::GpuConvolver::staged_sync_records_

protected

◆ staged_trial_

std::unique_ptr<detail::StagedAsyncTrialState> pulp::gpu_audio::GpuConvolver::staged_trial_

protected

◆ time_

std::vector<float> pulp::gpu_audio::GpuConvolver::time_

protected

◆ trial_capture_admissions_

bool pulp::gpu_audio::GpuConvolver::trial_capture_admissions_ = false

protected

◆ trial_capture_callback_timing_

bool pulp::gpu_audio::GpuConvolver::trial_capture_callback_timing_ = false

protected

◆ trial_completion_policy_

std::uint8_t pulp::gpu_audio::GpuConvolver::trial_completion_policy_ = 0

protected

◆ trial_completion_wait_ns_

std::uint64_t pulp::gpu_audio::GpuConvolver::trial_completion_wait_ns_ = 0

protected

◆ trial_configured_

bool pulp::gpu_audio::GpuConvolver::trial_configured_ = false

protected

◆ trial_enable_trace_

bool pulp::gpu_audio::GpuConvolver::trial_enable_trace_ = false

protected

◆ trial_generation_

std::uint64_t pulp::gpu_audio::GpuConvolver::trial_generation_ = 1

protected

◆ trial_requested_path_

std::uint8_t pulp::gpu_audio::GpuConvolver::trial_requested_path_ = 0

protected

◆ trial_staged_sync_reference_

bool pulp::gpu_audio::GpuConvolver::trial_staged_sync_reference_ = false

protected

◆ trial_success_stride_

std::uint32_t pulp::gpu_audio::GpuConvolver::trial_success_stride_ = 1

protected

◆ worker_fallback_

std::vector<signal::FixedIrConvolver> pulp::gpu_audio::GpuConvolver::worker_fallback_

protected

The documentation for this class was generated from the following file:

/home/runner/work/pulp/pulp/core/gpu_audio/include/pulp/gpu_audio/gpu_convolver.hpp

Pulp 1.88.0 Cross-platform audio plugin framework

Public Types

Public Member Functions

Static Public Attributes

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Friends

Detailed Description

Member Enumeration Documentation

◆ ProviderPolicy

Constructor & Destructor Documentation

◆ GpuConvolver() [1/2]

◆ GpuConvolver() [2/2]

◆ ~GpuConvolver()

Member Function Documentation

◆ backend()

◆ bind_realtime_path()

◆ complete_realtime_shared_io()

◆ configure_staged_breaker()

◆ configure_staged_pipeline()

◆ configure_trace()

◆ cpu_fallback_prepared()

◆ descriptor()

◆ fence_realtime_shared_io()

◆ fenced()

◆ fft_size()

◆ gpu_available()

◆ has_realtime_shared_io()

◆ init_fallback()

◆ latch_staged_recovery()

◆ next_realtime_shared_io_sequence()

◆ prepare()

◆ prime_fallback()

◆ process_block()

◆ process_cpu_fallback()

◆ process_realtime_shared_io()

◆ provider_identity_for_diagnostics()

◆ provider_policy()

◆ realtime_shared_io_health()

◆ recovery_reason()

◆ release_bounded()

◆ render_worker_fallback()

◆ sanitized_input_samples()

◆ service_realtime_shared_io()

◆ set_provider_policy()

◆ set_realtime_shared_io_notifier()

◆ set_staged_pipeline_hosting()

◆ staged_breaker()

◆ staged_breaker_trips()

◆ staged_cpu_blocks()

◆ staged_gpu_blocks()

◆ staged_latched_reason()

◆ staged_pipeline_depth()

◆ staged_recovery_reason()

◆ status_snapshot()

◆ submit_staged_readback()

◆ update_staged_breaker()

◆ wait_staged_readback()

Friends And Related Symbol Documentation

◆ detail::configure_gpu_convolver_trial

◆ detail::drain_gpu_convolver_trial_admissions

◆ detail::drain_gpu_convolver_trial_records

◆ detail::gpu_convolver_trial_engine_id

◆ detail::GpuConvolverTestAccess

Member Data Documentation

◆ block_

◆ carry_

◆ channels_

◆ fallback_

◆ fallback_delay_blocks_

◆ fb_delay_

◆ fb_delay_idx_

◆ fb_out_

◆ fft_size_

◆ gpu_

◆ in_pad_

◆ ir_

◆ ir_spec_

◆ kLatencyBlocks

◆ kMaxLatencyBlocks