快速将1D阵列复制到cpp中的3D阵列

Question

Is it possible copy from 1D array to 3D with some function as memcpy?

Now I am using a slow method :

for(int loop1 = 0; loop1 < numberAgents; loop1++)
    for(int loop2 = 0; loop2 < fieldWidth; loop2++)
        for(int loop3 = 0; loop3 < fieldWidth; loop3++)
            potentialField[loop1][loop2][loop3] = cpuPotentialField[loop1 * fieldWidth * fieldWidth + loop2 * fieldWidth + loop3];

This doesn't work :

memPotentialField = numberAgents * fieldWidth * fieldWidth * sizeof(float);
memcpy(potentialField, cpuPotentialField, memPotentialField);

Answer 1

Multi-dimensional arrays are stored row-wise (§ 8.3.4/9), so essentially your approach with memcpy is fine (because floats are PODs).

memcpy(&potentialField[0][0][0], cpuPotentialField,
       sizeof(potentialField)/sizeof(***potentialField));

Using std::copy is better, since it works for non-PODS too. So I would write

std::copy(&potentialField[0][0][0],
          &potentialField[0][0][0] + sizeof(potentialField)/sizeof(potentialField[0][0][0]),
          cpuPotentialField);

Answer 2

Unless you have a particularly bad compiler or you've forgotten to turn on optimisation (eg -O3 ) then the first method should be fine performance-wise. However you may be able to optimise it a little by hoisting some of the multiplies:

for (int loop1 = 0; loop1 < numberAgents; loop1++)
{
    const int index1 = loop1 * fieldWidth * fieldwidth;

    for (int loop2 = 0; loop2 < fieldWidth; loop2++)
    {
        const int index2 = index1 + loop2 * fieldWidth;

        for (int loop3 = 0; loop3 < fieldWidth; loop3++)
        {
            potentialField[loop1][loop2][loop3] = cpuPotentialField[index2 + loop3];
        }
    }
}

Answer 3

You may be able to get some performance by unrolling the loop. In some processors, branch or jump instructions cause the instruction pipeline to be reloaded, wasting time.

//...
unsigned int items_remaining = fieldWidth;
for (unsigned int loop3 = 0; loop3 < fieldWidth; ++loop3)
{
    unsigned int copy_count = 4 - (items_remaining % 4);
    switch (copy_count)
    {
        // The fall-through of these cases is intentional.
        case 4:
          potentialField[loop1][loop2][loop3] = cpuPotentialField[loop1 * fieldWidth * fieldWidth + loop2 * fieldWidth + loop3];
          ++loop3;
          --items_remaining;
        case 3:
          potentialField[loop1][loop2][loop3] = cpuPotentialField[loop1 * fieldWidth * fieldWidth + loop2 * fieldWidth + loop3];
          ++loop3;
          --items_remaining;
        case 2:
          potentialField[loop1][loop2][loop3] = cpuPotentialField[loop1 * fieldWidth * fieldWidth + loop2 * fieldWidth + loop3];
          ++loop3;
          --items_remaining;
        case 1:
          potentialField[loop1][loop2][loop3] = cpuPotentialField[loop1 * fieldWidth * fieldWidth + loop2 * fieldWidth + loop3];
          ++loop3;
          --items_remaining;
    } // End: switch
} // End: for  

This is only unrolled for 4 items. The more items in the loop, the more efficient the loop. As Paul R said, precomputing some of the indices would also help.

Some processors may have specialized copy instructions that the compiler can take advantage of, depending on the compiler.