GPU signal processing

Hello, I'm interested in splitting the wideband signal into short channels, but I'm getting into a performance problem using PolyPhase Channelizer, which is part of GnuRadio for this purpose. I know that such operations (multiplication, working with vectors and floating-point numbers) fit well on gpgpu and fpga, which means that one single device can potentially cope with this task (as evidenced, for example, by this document [login to view URL] and other). In any case, it is more preferable to use gpu because of the availability of them "at hand", at least from my side at the moment. As an option, we think to work with OpenCL. FPGA can be a good option for the final product due to less than gpu power consumption. We work with radar systems, in this project the band is from 80 to 160 MHz with channels in 800 kHz at 4 GHz (100-200 channels). Also, I know about the existence of objectively too expensive Novator NC-10, and gr-theano / gr-clenabled projects, excellent gras, showing the ability to use gpu in signal processing. I'm interested in similar projects, and the development of a custom solution for my needs. Ideally, i need a well-configurable channelizer, with the ability to set all possible properties: channel width, transition width, number of kernels, amount of data per core, and so on, since it should be universal. Since the channels are always with the same width, it is intended to use the FFT / DFT Polyphase and / or their variations, at your discretion. The result of the work is accepted in the form of a C ++ library providing approximately such an API: /** * Channelizer arguments * @typedef channelizer_args {Object} * @property sample_rate - Sample-rate of wideband signal * @property channel_width - Width of channels * @property channel_map - List of channels to produce. Example: [4,7,8,12] * @property channel_map_size - Size of channel_map. * @property kernels_count - Kernels count for current channelizer * @property block_size - Count of samples per worker * @property device_id - Identifer of device which is used for (index of gpu device) */ struct channelizer_args { float sample_rate = 80e6; float channel_width = 800e3; int * channel_map; int channel_map_size; int kernels_count = 4095; int block_size = 32760; int device_id = 0; }; /** * @class Channelizer */ class ChannelizerImpl { public: /** * @constructor * @param args - Arguments * @return Created channelizer instance */ ChannelizerImpl(channelizer_args args){} /** * Pass data to process into channelizer. * Its blocking function. Frees up the process when it completes the data transfer to the video card. * @param buf - Input samples buffer with wideband signal. * I re-re-use the buffers that I pass here, bear in mind. * @param size - Его размер. */ virtual void pass( float * buf, int size ) = 0; /** * Got the result from channelizer. * In what form and how - as you prefer. As exeample, output samples can be interleaved or etc.. * I assume to get an array of buffers. * I remind you that the output does not need all channels, but only those that are specified in channel_map. */ virtual ? receive(?) = 0; }; Apparently, it is supposed to create several instances of the channelizer on different devices with different parameters. It would be great to get your opinion on the possible details of the development, methods (FFT/DFT or Digital Down Converter), thoughts on the overall implementation. Note: We are working with Linux. Thanks for reading, I hope for cooperation, Andrew.