Question

I’m using a STL vector to store a large (~ 10^6) number of custom objects (sizeof() gives 368 bytes for one of these objects). The structure of my program requires me to make frequent backup copies of this vector as changes made in a certain step might need to be unrolled under certain conditions. Roughly this looks something like

std::vector<myClass> vecA( largeNumber );
std::vector<myClass> vecB;

do
{
  vecB = vecA;

  //do lots of stuff to vecA

  if ( restoreBackup ) { vecA = vecB; }

} while (someCondition)

Doing some profiling, the copy operation vecB = vecA is actually a considerable bottle neck. I really need to speed up this part. Which strategies would you suggest?

Remarks:

• For certain reasons I would like to keep the STL vector structure.
• I know that most of the times only a small fraction of the elements in vecA gets updated. So I could try to maintain an extra list of these elements and then only copy these elements back and forth by looping over this list. Would that be an adequate strategy?
• The question is certainly related to this question, however the solutions proposed there don’t really help.

Answer 1

Hm, this is not an trivial thing and I don’t think that you can avoid this copying, if you really need to use only (and one) std::vector.

The best solution would be to use Persistant Data Structure.

But this would be very helpful, if you need to store more than one version of your container.

If you need just the previous version..
The easies thing, that comes to my mind and it seems, that will work for you, is to backup only the elements, you’ll change. You could use a std::list (or std::vector ) with std::pair< int, myClass >. So, the first of the pair would be the index of the element, you’re changing and the second – the backed up version. So, in the end, if you need to restore the backup, you’ll just to go through this container and “revert” the old data.

The situation with deleting/adding elements will be more complicated, but not unsolvable. You’ll have to have more containers – one for deleted elements, one for added elements, one for changed elements and one for the sequence of the changes. So, this will give you the opportunity to perform “undo” steps.

Well, this sounds more complicated and kinda hard to implement (because of all possible cases), but will increase the performance (will reduce the copies).

Other thing, that comes to my mind – you could check the container size first. And if it’s small, make a whole copy. If it’s big – perform the “selective backup” or whatever this is called.

Note, that this is not the best solution (I guess), but just an idea, I got right now (I have never needed such thing)

Hope that helps, even-thought it sounds complicated and hard to implement.