These last days I’ve been working on an application for testing the PThreading – Paradise Threading – library, the core of Paradise Engine and all our tools,  in different systems by just downloading/executing a little application – which will be soon available for download -. But… what to test? At really… it could seem to be something easy to decide, but I can swore that it isn’t! It must to be something parallelizable and useful for us in a future, so… what better than a complete, efficient and smart 2D FFT/DFT – and inverses – implementation?

Good, so… let’s go. In this post I’ll talk about the DFT implementation, not the FFT this time, but almost all – at really, all – results can be extrapolated to the FFT case, just taking account that the FFT is orders of magnitude faster than the DFT calculation.

In a practical implementation of the two dimensional DFT , we explote the fact that the 2D DFT of a MxN matrix could be calculated by performing the one dimensional DFT of the M rows, and then the 1D DFT of the N columns. For more information visit this and this links.

Well, now that I’ve written a – very - little 2D DFT introduction, it’s time to talk about the practical implementation. In this post I’ll talk about two methods, from now labeled as A and B.
In this post I’ll assume that the MxN matrix data type is stored in a simple array of size M*N where each A(m,n) element one-dimensional index is given by the formula: Index = m*N+n, so rows elements are stored in contiguous memory addresses and the last elements of the K row is contiguous to the first elements of the K+1 row.

A: row-column decomposition:

The row-column 2D DFT decomposition consists on calculating, in a first step, the 1D DFT of all rows and then, in a second step, the 1D DFT of all columns of the first step results.

In an ideal situation, this approach could be considerated the faster method to perform a 2D DFT, but since computers aren’t perfect the fact is that even if this method is considerably faster than calculating the 2D DFT by the definition, it’s not the faster one.

Why? Simply, because of the acces to contiguous memory addresses is considerably faster than random – or further, in this case – addresses location acces.
So, in this approach, the DFT calculation of each row is efficient, but the DFT calculation of each column is not efficient since only row elements are located in contiguous memory. For more information visit this link.

B: row-transpose-row-transpose decomposition:

Okey, so… one time I’ve talked about the row-column decomposition method it’s time to talk about a more efficient way.
The idea – and, at start, the implementation – is simple: calculating the 1D DFT of all rows, transpose the matrix, re-calculate the 1D DFT of all rows(that at really are our columns) and finally transpose the result matrix to obtain our 2D DFT.

So, well, but… what’s the most efficient(faster) implementation of this method in a micro-threading environment?
After a lot of tests and implementation variants, the way I get the best performance is:

1. Create two temporal MxN matrices(arrays of M*N size) which will be used in the following parallelizable tasks.
2. Perform the 1D DFT in packages of K rows in parallel – in different ‘tasks’ -, using one of the temporal matrices to store calculated values and finally, in the same task, copy the K calculated rows to the K correspondent columns in the other temporal matrix – which is the ‘transposed’ matrix – So now, one time all tasks have been performed, we have the transposed matrix of the 1D DFT of the original matrix rows stored in one of our temporal matrices, calculated in a micro-threaded smart way -
3. Perform the 1D DFT in parallelizable packages of L rows – as we’ve done in the second point – of the temporal matrix which stores the transposed results, using the other temporal matrix to store calculated values and finally, in the same task, copy the L calculated rows to the L correspondent columns in the original matrix.

Some considerations:

• The purposed method is fully parallelizable, no locks are needed since the way the shared data is used- the 3 shared matrices – is thread safe.
• K and L define the grain size. – Number of 1D DFT executed per task -
• DFT and Inverse DFT – IDFT - are almost equivalent.

And for finishing, some numbers:

Here is the DFT execution results of a 512×512, 4 bytes per channel (float data type), RGB image using the two proposed methods:

About results

• Micro-threading results are just orientative since tests have been performed on an -old- Intel Core Duo laptop CPU.
• Method A: rows DFT are considerably faster than columns DFT, as expected.
• Method B: first and second step times are almost equivalent, as expected – ideally, they should be the same -
• Method B is faster than method A, as expected.
• All results are from the average times of 5 executions, no modifications have been done - just rounded to two decimal numbers -.

Just to make a little informal presentation in this first blog entry, the Paradise Studios team consists on 3 guys: one 3D artist, Marcus Feital (despadas) who is a passionate 3D artist (and Sound Designer) and had worked on a recent commercial title; an excellent web designer and 2D artist, Josep Viciana (emmgfx), who has several years of experience in his field and works in a web development company; and finally me, Xavier Verguín (Xavyiy), well, it’s hard for me to define myself, but I think of myself as someone who loves programming, specially 3D development, and, like my team partners, have been developing some well-know projects in my field these last years, like Hydrax and SkyX.

In this blog we’ll write about our current work in the Paradise Studios projects and miscellaneous development-related topics. We hope to write interesting stuff for developers and curious people, something that we would like to read too.

From Paradise Studios we want to announce that we’ll contribute with some Open Source projects, like Ogre3D, releasing as Open Source new and improved Hydrax and SkyX versions, and maybe some other plug-ins in the future.

Thanks for visiting us,
The Paradise Studios team.