有效访问存储为1D阵列的3D阵列

Question

I have a 3D array which is stored as a 1D array in a columnwise fashion. For example,

for( int k = 0; k < nk; k++ ) // Loop through the height.
    for( int j = 0; j < nj; j++ ) // Loop through the rows.
        for( int i = 0; i < ni; i++ ) // Loop through the columns.
        {
            ijk = i + ni * j + ni * nj * k;
            my3Darray[ ijk ] = 1.0;
        }

For my application, I need to access all the rows/columns/height of my3Darray . By height, I mean the vectors in the third dimension of the array. I need this because I want to process the FFT of each vector and return the resulted vector. I would be thankful to have my friends's thoughts in stackoverflow, how I can efficiently access these vectors. Of course one trivial possibility, for example, for the height vectors is:

for( int i = 0; i < ni; i++ ) // Loop through the columns.
    for( int j = 0; j < nj; j++ ) // Loop through the rows.
    {
        for( int k = 0; k < nk; k++ ) // Loop through the heights.
        {
            ijk = i + ni * j + ni * nj * k;
            myvec[ k ] = my3Darray[ ijk ];
            fft( myvec, myvec_processed );
        }

        // Store the results in a new array, which is storing myvec_processed in my3Darray_fft_values.
        for( int k = 0; k < nk; k++ ) // Loop through the heights.
        {
            ijk = i + ni * j + ni * nj * k;
            my3Darray_fft_values[ ijk ] = myvec_processed[ k ];
        }
    }

Am I computing this efficiently? Is there a possibility of passing my3Darray directly to the function which processes the FFT of the vectors (instead of copying the vector to myvec )?

Answer 1

You can cut down on the multiplies by precomputing a stride like this:

...
for( int j = 0; j < nj; j++ ) // Loop through the rows.
{
    int stride = ni * nj;
    ijk = i + ni * j;
    for( int k = 0; k < nk; k++ ) // Loop through the heights.
    {
        myvec[ k ] = my3Darray[ ijk ];
        fft( myvec, myvec_processed );
        ijk += stride;
    }
}

But this will only speed things up a little. You will still have cache problems due to accessing my3Darray in a nonsequential fashion.

Answer 2

When everything gets reduced to its innermost bits and bytes, your 3-dimensional array gets stored, of course, in one dimensional memory. So, given array element's three dimensions, the compiler produces pretty much the same code to calculate the location of the array element as you are doing yourself. Surprise!

So, in other words, it's pretty much the same thing.

The only thing that might work in the compiler's favor, with explicit 3-dimensional arrays, is that the compiler knows the sizes of all the inner dimensions, and if the size of the innermost dimensional slice happens to be something convenient, like a power of 2, the compiler might replace some of the multiplications with equivalent left shifts, which would be slightly faster, I suppose, then a full blown multiply instruction. But I'd be surprised if it turns out to be a large difference in performance.

It's probably more important to pick the relative order of your dimensions, so that your typical access patterns, for your transformations, will be more CPU cache-friendly.