Question

Solution 1:
If i have a class like,

class car{ public: int a; string b; bool c;};

i can build a vector of 200 cars:

std::vector<car>   allcas;  
allcars.resize(200)

at runtime, i just do:

this_car=allcars[102];

then ….

Solution 2:

i have

std::vector<int> a; a.resize(200);
std::vector<string>b; b.resize(200);
std::vector<bool> c; c.resize(200);

this_car_a = a[102];
this_car_b = b[102];
this_car_c = c[102];

Question:
Which one is faster?

Does anyone have an idea? thanks a lot in advance!

Answer 1

A “struct of vectors” has a couple of advantages over a “vector of structs”:

• If your inner loop doesn’t use every element of the struct, then struct-of-vectors can save on memory bandwidth, as unused element vectors will not be loaded into cache.
• It is easier to vectorize. A struct-of-vectors may enable you to use the vector processing instructions of your processor (through assembly, intrinsics, or clever compilers) to speed up your inner loops.

On the other hand, premature optimization is the root of all evil:

• Using a struct-of-vectors is more difficult, awkward, and obscure.
• You generally don’t know where your performance bottlenecks are until you’ve got your code up and running. Is it worth making your code more verbose, fragile, and difficult? You won’t know until you actually profile it.
• The benefits of struct-of-vectors programming vary on a case by case basis. It doesn’t always yield a speedup; you could actually end up with worse performance.
• In particular, if your access pattern is random (as opposed to sequential or otherwise localized) a struct-of-vectors organization could end up loading much more useless data from memory, if each cache line includes elements from multiple nearby objects…

So, my recommendation is to use vector-of-structs by default, but keep struct-of-vectors in mind as an alternative (i.e., make sure you can switch later, if you expect sequential/local access patterns and it doesn’t cost much effort up front). Once your program is running, you can profile it to see where the performance-critical sections are, and try out struct-of-vector and vectorized operations where they’ll do the most good.