We consider the problem of key establishment over a wireless radio channel in the presence of a communication jammer, initially introduced in [13]. The communicating nodes are not assumed to pre-share any secret. The established key can later be used by a conventional spread-spectrum communication system. We introduce new communication concepts called intractable forward-decoding and efficient backward-decoding. Decoding under our mechanism requires at most twice the computation cost of the conventional SS decoding and one packet worth of signal storage. We introduce techniques that apply a key schedule to packet spreading and develop a provably optimal key schedule to minimize the bit-despreading cost. We also use efficient FFT-based algorithms for packet detection. We evaluate our techniques and show that they are efficient both in terms of resiliency against jammers and computation. Finally, our technique has additional features such as the inability to detect packet transmission until the last few bits are being transmitted, and transmissions being destination-specific. To the best of our knowledge, this is the first solution that is optimal in terms of communication energy cost with very little storage and computation overhead.

Paper available at ACM.

Abstract:
The optimization of Fast Fourier Transfer (FFT) problems that can fit into GPU memory has been studied extensively. Such on-card FFT libraries like CUFFT can generally achieve much better performance than their counterparts on a CPU, as the data transfer between CPU and GPU is usually not counted in their performance. This high performance, however, is limited by the GPU memory size. When the FFT problem size increases, the data transfer between system and GPU memory can comprise a substantial part of the overall execution time. Therefore, optimizations for FFT problems that outgrow the GPU memory can not bypass the tuning of data transfer between CPU and GPU. However, no prior study has attacked this problem. This paper is the first effort of using GPUs to efficiently compute large FFTs in the CPU memory of a single compute node.

In this paper, the performance of the PCI bus during the transfer of a batch of FFT subarrays is studied and a blocked buffer algorithm is proposed to improve the effective bandwidth. More importantly, several FFT decomposition algorithms are proposed so as to increase the data locality, further improve the PCI bus efficiency and balance computation between kernels. By integrating the above two methods, we demonstrate an out-of-card FFT optimization strategy and develop an FFT library that efficiently computes large 1D, 2D and 3D FFTs that can not fit into the GPU‘s memory. On three of the latest GPUs, our large FFT library achieves much better double precision performance than two of the most efficient CPU based libraries, FFTW and Intel MKL. On average, our large FFTs on a single GeForce GTX480 are 46% faster than FFTW and 57% faster than MKL with multiple threads running on a four-core Intel i7 CPU. The speedup on a Tesla C2070 is 1.93x and 2.11x over FFTW and MKL. A peak performance of 21GFLOPS is achieved for a 2D FFT of size 2048x65536 on C2070 with double precision.

Paper available at ACM.

View-reconstruction and display is an important part of many applications in digital holography such as computer
vision and microscopy. Thus far, this has been an offline procedure for megapixel sized holograms. This paper introduces
an implementation of real-time view-reconstruction using programmable graphics hardware. The theory of Fresnel-based
view-reconstruction is introduced, after which an implementation using stream programming is presented. Two different fast
Fourier transform (FFT)-based reconstruction methods are implemented, as well as two different FFT strategies. The efficiency
of the methods is evaluated and compared to a CPU-based implementation, providing over 100 times speedup for a hologram
size of 2048 × 2048. 

Abstract

The use of image denoising techniques is an important part of many medical imaging applications. One common application is
to improve the image quality of low-dose, i.e. noisy, computed tomography (CT) data. The medical imaging domain has seen a
tremendous development during the last decades. It is now possible to collect time resolved volumes, i.e. 4D data, with a number of
modalities (e.g. ultrasound (US), CT, magnetic resonance imaging (MRI)). While 3D image denoising previously has been applied
to several volumes independently, there has not been much work done on true 4D image denoising, where the algorithm considers
several volumes at the same time (and not a single volume at a time). By using all the dimensions, it is for example possible
to remove some of the time varying reconstruction artefacts that exist in CT volumes. The problem with 4D image denoising,
compared to 2D and 3D denoising, is that the computational complexity increases exponentially.
In this paper we describe a novel algorithm for true 4D image denoising, based on local adaptive filtering, and how to implement
it on the graphics processing unit (GPU). The algorithm was applied to a 4D CT heart dataset of the resolution 512 x 512 x 445 x 20.
The result is that the GPU can complete the denoising in about 25 minutes if spatial filtering is used and in about 8 minutes if FFT
based filtering is used. The CPU implementation requires several days of processing time for spatial filtering and about 50 minutes
for FFT based filtering. Fast spatial filtering makes it possible to apply the denoising algorithm to larger datasets (compared to if
FFT based filtering is used). The short processing time increases the clinical value of true 4D image denoising significantly.

Youtube video

http://www.youtube.com/watch?v=wflbt2sV34M

 Abstract:

 The Fourier transform is a well known and widely used tool in many scientific and engineering fields. The Fourier transform is essential for many image processing techniques, including filtering, manipulation, correction, and compression. As such, the computer graphics community could benefit greatly from such a tool if it were part of the graphics pipeline. As of late, computer graphics hardware has become amazingly cheap, powerful, and flexible. This paper describes how to utilize the current generation of cards to perform the fast Fourier transform (FFT) directly on the cards. We demonstrate a system that can synthesize an image by conventional means, perform the FFT, filter the image, and finally apply the inverse FFT in well under 1 second for a 512 by 512 image. This work paves the way for performing complicated, real-time image processing as part of the rendering pipeline.