c ++在3D矢量上最快的循环扫描

Question

I want to know what is the fastest way as possible to perform a method on each element of a 3D vector.

Suppose we have:

std::vector<vector<vector<CLS>>> myVec;

I want to do the following loops in the fastest way as possible:

 for(int cycle=0;cycle<10;cycle++) // do it 10 times
 {
    for(int i=0;i<myVec.size();i++)
    {
       for(int j=0;j<myVec[i][constant].size();j++)
       {
           foo(myVec[i][constant][j]);
       }

    } 
 }

It's well mentioning that the middle term index is always constant in my case. Is using std::vector fast enough or you suggest another type container?

Looking forward to your help.Thanks

Answer 1

The following would be faster:

for(int i=0, int vecSize = myVec.size();i<vecSize;i++)
{
   for(int j=0, int currentLineSize = myVec[i][constant].size();j<currentLineSize;j++)
   {
       foo(myVec[i][constant][j]);
       //copy-paste this 10 times instead of having the outer loop
   }
} 

If you know anything about the sizes, you can perform some more unrolling.

Answer 2

Usage of iterators should be faster (you don't have to look up through the whole array on every call of foo ).

typedef std::vector<CLS> v1;
typedef std::vector<v1> v2;
typedef std::vector<v2> v3;

for(int cycle=0;cycle<10;cycle++) // do it 10 times
{
    for(v3::const_iterator itOuter = myVec.begin(); itOuter != myVec.end(); ++itOuter)
    {
        const v1& vec = (*itOuter)[constant];
        for(v1::const_iterator itInner = vec.begin(); itInner != vec.end(); ++itInner)
            foo(*itInner);
    }
}

I didn't measure it, though (didn't even try to compile, so pardon any typos)

Answer 3

Probably the "fastest way possible" (and the least C++-ish way possible, although it's still valid C++) would be along these lines:

const unsigned dim1 = 10; //first dimension
const unsigned dim2 = 20; //second
const unsigned dim3 = 30; //third
const unsigned nElem = dim1 * dim2 * dim3;

CLS myVec[nElem];

CLS *p = myVec, *q = myVec + nElem;

while (p < q)
{ foo(*p);
  ++p;
}

This eliminates all the calculation of indices, since foo() seems to depend only on the value of the CLS element in question, not on its position in the array. Of course, accessing myVec in a 3D-ish way becomes more complex ( myVec[x * dim1 * dim2 + y * dim1 + z] and so on - just making explicit all the indexing calculations C++ normally does for you...).

Changing the loop around to "slice" the array so that one dimension is kept constant would make it a little more complicated (essentially make it a doubly nested loop that adds an additional offset to the pointer at the termination of the inner loop). A bit like this (although I may have the dimensions reversed):

while (p < q)
{ CLS *r = p + dim3;
  while (p < r)
  { foo(*p);
    ++p;
  }
  p += dim2;
}

Answer 4

You could create a recursive function object:

class Foo {
public:
    template<typename Container>
    void operator()(Container& container) {
        for_each(container.begin(), container.end(), *this);
    }
    void operator()(CLS cls) {
        // do what you want
    }
};

Foo foo;
foo(myVec);

Answer 5

Why would you do it in 3 loops if you want efficiency?

Here is in one 1

int cycle,
    i = 0,
    j = 0,
    counter;

for(cycle = 0, counter = 0; cycle < 10; counter++)
{
    j = counter % myVec[i][constant].size(); // It will go between 0 - myVec[i][constant].size()
    i += (!j) * !(!counter); // If j is reset (j =
    i %= myVec.size();
    foo(myVec[i][constant][j]); // Do your function
    cycle += (!i) * (!j) * !(!counter);
}

j = counter % myVec[i][constant].size() It will go between 0 to myVec[i][constant].size()

i += (!j) * !(!counter) If j is reset ( j is equal to 0 ) so make it 1 , but if counter is 0 so ( !(!0) = !1 = 0 ) and if it's bigger then 0 so 5 for example ( !(!5) = !0 = 1 ) so i being increasd by 1

i %= myVec.size() It Will Go between 0 to myVec.size() and start again ( i = 0 ) when reached myVec.size()

foo(myVec[i][constant][j]) Your function

cycle += (!i) * (!j) * !(!counter) If i is reset ( i is equal to 0 ) so make it 1 ,same for j but if counter is bigger then 0 , cycle being increasd by 1