Vector memory allocation skill

Question

Let's say I need to iterate over a potentially very large vector of numbers and copy the even and odd elements into new, separate vectors. (The source source may have any proportion of the coefficients, which may be all the same, all the coefficients or somewhere in between.)

For simplicity, push_back often used for these kinds of things:

 for (std::size_t Index; Index < Source.size(); Index++) { if (Source[Index] % 2) Odds.push_back(Source[Index]); else Evens.push_back(Source[Index]); } 

However, I am concerned that this will be inefficient and harmful if it is used as part of an implementation for something like a sorting algorithm where performance is paramount. For example, QuickSort includes splitting items like this.

You can use reserve() to allocate memory before you need it, only one allocation, but then you need to repeat across the entire source vector twice - once to calculate how many elements will need to be sorted, and once more for the actual copy.

You could, of course, allocate the same space as the size of the original vector, since no new vector should contain more than this, but this seems somewhat wasteful.

Is there a better method that I am missing? Is push_back() generally trusted to manage this kind of thing for a programmer, or can it become burdensome for sensitive algorithms?

Answer 1

I am going to answer a question that I think you really wanted to ask, "should push_back() be avoided in internal loops of heavy algorithms?" and not what others seem to have read in your post that "does it matter if I call push_back before doing an unrelated view on a large vector?" In addition, I’m going to answer from my own experience, and not waste time chasing citations and peer-reviewed articles.

Your example basically does two things that come down to the total cost of the CPU: it reads and works with the elements in the input vector, and then it must insert the elements into the output vector. You are worried about the cost of inserting elements because:

• push_back () - constant time (instant, really) when the vector has enough space previously reserved for an additional element, but slow when you have exhausted the reserved space.
• Allocating memory is expensive ( malloc() just slow , even when pedants pretend that new is something else)
• Copying vector data from one region to another after redistribution is also slow : when push_back () finds that it does not have enough space, it must go and select a large vector, and then copy all the elements . (Theoretically, for vectors, which are numerous OS pages, the magic of the STL implementation can use VMMs to move them in the virtual address space without copying and in practice I have never seen one that could .
• Overfulfillment of output vectors causes problems: it causes fragmentation, which slows down future distributions; it burns the data cache, making it slower; if it is stable, it links limited free memory, leading to paging on PC to PC and crashing on embedded platforms.
• The unallocation of the output vectors causes problems, since the redistribution of the vector is an O (n) operation, therefore its redistribution m times is O (m × n). If the default STL allocator uses exponential redistribution (making the vector reserve twice its previous size each time it is recalculated), this makes your linear algorithm O (n + n log m).

Thus, your instinct is correct: there is always a predefined space for your vectors, where possible, not because push_back is slow, but because it can cause a slow redistribution. Also, if you look at the shrink_to_fit implementation, you will see that it also redistributes the copy, temporarily doubling the memory cost and causing further fragmentation.

Your problem is that you do not always know exactly how much space you will need for the output vectors; the usual answer is to use a heuristic and possibly custom allocator. Reserve n / 2 + k input sizes for each of your output vectors by default, where k is some margin of safety. Thus, you will usually have enough room for output if your input is reasonably balanced, and push_back can be redistributed in rare cases when it is absent. If you find that the exponential behavior of push_back is consuming too much memory (forcing you to reserve 2n elements when you really need n + 2), you can give it a special allocator that extends the vector size in smaller linear fragments - but of course this will be much slower when the vectors are really unbalanced and you end up making a lot of changes.

It is impossible to always reserve the exact amount of free space without missing input elements in advance; but if you know what the balance looks like, you can use heuristics to get a good idea about it, to get statistical performance over many iterations.

Answer 2

You could, of course, allocate as much space as the source size of the vector, since no new vector should contain more than this, but it seems somewhat wasteful.

Then execute it using shrink_to_fit call

However, I am worried that this will be inefficient and harm things like sorting algorithms .... Is push_back () usually trusted for managing this kind of thing for the programmer, or can it become burdensome for sensitive algorithms?

Yes, push_back is trusted. Although honestly, I do not understand what your concern is. Presumably, if you use algorithms for a vector, you already put the elements in the vector. What algorithm are you talking about where it matters, how would the vector elements appear, be it push_back or something else?

Answer 3

How about sorting the original vector with a custom predicate that puts all values ​​in front of all chances?

 bool EvenBeforeOdd(int a, int b) { if ((a - b) % 2 == 0) return a < b; return a % 2 == 0; } std::sort(v.begin(), v.end(), EvenBeforeOdd); 

Then you just need to find the largest even number you can make, for example. with upper_bound for a very large even number or something similar. Once you discover this, you can make very cheap copies of the ranges.

Update: As @Blastfurnace noted, it is much more efficient to use std::partition rather than sort , since we really don't need the elements ordered in each section:

 bool isEven(int a) { return 0 == a % 2; } std::vector<int>::const_iterator it = std::partition(v.begin(), v.end(), isEven); std::vector<int> evens, odds; evens.reserve(std::distance(v.begin(), it); odds.reserve(std::distance(it, v.end()); std::copy(v.begin(), it, std::back_inserter(evens)); std::copy(it, v.end(), std::back_inserter(odds)); 

Answer 4

If your objects are created dynamically, then vectors literally just keep pointers. This makes vectors much more efficient, especially when it comes to internal redistribution. It will also save memory if the same objects exist in several places.

 std::vector<YourObject*> Evens; 

Note. Do not click pointers from the context of the function, as this will lead to data corruption outside this frame. Instead, objects should be allocated dynamically.

This may not solve your problem, but it may be useful.

Answer 5

If your subvectors are exactly half (odd / even), just select 50% of the original vector for each. This will avoid losses and shrink_to_fit .