I/O Utility Blocks

Relevant source files

The following files were used as context for generating this wiki page:

• include/gnuradio/cuda/null_source.h
• include/gnuradio/cuda/null_sink.h
• include/gnuradio/cuda/probe_rate.h
• include/gnuradio/cuda/load.h
• include/gnuradio/cuda/tee.h
• lib/null_source_impl.h
• grc/cuda_null_source.block.yml

I/O Utility Blocks within the gr-cuda project serve as the foundational infrastructure for data origination, termination, and flow management in the CUDA memory domain. These blocks are part of the "batteries included" suite that enables developers to build complex GPU-accelerated signal processing pipelines without manually managing host-to-device transfers.

The primary purpose of these blocks is to provide standard GNU Radio functionalities (like null sources/sinks, rate probing, and stream splitting) while maintaining compatibility with the cuda_buffer architecture. This ensures that data remains on the GPU whenever possible, utilizing the zero-copy pipeline and CUDA Virtual Memory Management (VMM).

Sources: README.md:16-20, grc/cuda_null_source.block.yml:1-5

Core Data Sources and Sinks

The utility suite includes high-performance implementations of null sources and sinks designed specifically for the CUDA domain. Unlike standard GNU Radio blocks, these interact directly with device pointers to minimize CPU overhead.

Null Source (CUDA)

The null_source block generates a stream of data in the CUDA domain. It is often used for testing throughput or providing "dummy" inputs to multi-input blocks. The implementation supports multi-channel output and optional zero-filling via memset.

• Logic: The null_source_impl inherits from both null_source and cuda_block. It manages an internal d_itemsize and d_num_outputs to correctly allocate and signal GPU buffers.
• Zero-fill Optimization: If the memset parameter is true, the block clears the output buffer using CUDA memory operations, ensuring predictable data states for downstream consumers.

Sources: include/gnuradio/cuda/null_source.h:24-40, lib/null_source_impl.h:18-35, grc/cuda_null_source.block.yml:10-25

Null Sink (CUDA)

The null_sink block serves as a high-speed terminator for CUDA data streams. It accepts input items in the CUDA domain and discards them, effectively acting as a data "black hole" while maintaining the synchronization requirements of the CUDA pipeline.

Sources: include/gnuradio/cuda/null_sink.h:24-41

Stream and Flow Management

Effective GPU pipelines require the ability to duplicate streams or simulate computational stress for profiling.

Tee Block

The tee block provides the capability to split a single input stream into multiple identical output streams. It supports both CPU and GPU modes. In GPU mode, it leverages the cuda_buffer infrastructure to distribute data across multiple downstream consumers with minimal latency.

Sources: include/gnuradio/cuda/tee.h:24-41, python/cuda/qa_tee.py:38-45

Load Block

The load block is a specialized utility for hypothetical profiling. It allows developers to "load down" GPU processing by introducing a configurable number of iterations (a for-loop inside the kernel). This is used to simulate heavy computational tasks and observe how data transfer performance impacts overall system throughput.

Sources: include/gnuradio/cuda/load.h:35-42

Diagnostic and Profiling Blocks

Probe Rate

The probe_rate block is used to measure the throughput of the CUDA pipeline. It tracks the number of items passing through it over time, providing insights into the real-world performance of GPU kernels and memory synchronization.

Sources: include/gnuradio/cuda/probe_rate.h:24-41

Architectural Relationships

The following diagram illustrates the relationship between the utility blocks and the base cuda_block class, highlighting how these utilities integrate into the managed CUDA stream environment.

The diagram shows that specific utility implementations like null_source_impl inherit from both their functional interface and the cuda_block base, granting them access to CUDA stream management and synchronization helpers.

Sources: lib/null_source_impl.h:18-20, include/gnuradio/cuda/null_source.h:24, include/gnuradio/cuda/load.h:24

Component Summary Table

Block Name	Purpose	Key Parameters	Domain
null_source	Generates empty/constant GPU data	itemsize, num_outputs, memset	CUDA
null_sink	Terminates GPU data streams	itemsize, num_inputs	CUDA
probe_rate	Measures stream throughput	itemsize	CUDA
load	Simulates GPU compute stress	iterations, itemsize, use_cb	CUDA
tee	Duplicates streams	itemsize, gpu (bool)	Mixed/CUDA

Sources: grc/cuda_null_source.block.yml:7-22, include/gnuradio/cuda/load.h:42, include/gnuradio/cuda/tee.h:40

Implementation Example: Null Source

The null_source_impl demonstrates how I/O utilities are structured to handle the underlying CUDA stream:

// From lib/null_source_impl.h
class null_source_impl : public null_source, public cuda_block
{
private:
    size_t d_itemsize;
    size_t d_num_outputs;
    bool d_memset;

public:
    null_source_impl(size_t sizeof_stream_item, size_t num_outputs, bool memset);
    int work(int noutput_items,
             gr_vector_const_void_star& input_items,
             gr_vector_void_star& output_items) override;
};

Sources: lib/null_source_impl.h:18-35

Conclusion

The I/O Utility Blocks in gr-cuda are essential for building robust GPU-accelerated flowgraphs. By providing standardized tools like null_source, null_sink, and tee that are native to the CUDA domain, the project enables seamless data flow and accurate performance profiling. These blocks effectively bridge the gap between high-level GNU Radio logic and low-level CUDA memory management.