Optimizing C++ Vector for Search

Question

With my current project, I did my best to adhere to the principle that premature optimization is the root of all evil. However, now the code is tested, and it is time for optimization. I did some profiling, and it turns out my code spends almost 20% of its time in a function where it finds all possible children, puts them in a vector, and returns them. As a note, I am optimizing for speed, memory limitations are not a factor.

Right now the function looks like this:

void Board::GetBoardChildren(std::vector<Board> &children)
{
    children.reserve(open_columns_.size()); // only reserve max number of children

    UpdateOpenColumns();

    for (auto i : open_columns_)
    {
        short position_adding_to = ColumnToPosition(i);
        MakeMove(position_adding_to); // make the possible move
        children.push_back(*this); // add to vector of children
        ReverseMove(); // undo move
    }
}

According to the profiling, my code spends about 40% of the time just on the line children.push_back(*this); I am calling the function like this:

std::vector<Board> current_children;
current_state.GetBoardChildren(current_children);

I was thinking since the maximum number of possible children is small (7), would it be better to just use an array? Or is there not a ton I can do to optimize this function?

Answer 1

From your responses to my comments, it seems very likely that most of the time is spent copying the board in

children.push_back(*this);

You need to find a way to avoid making all those copies, or a way to make them cheaper.

Simply changing the vector into an array or a list will likely not make any difference to performance.

Answer 2

The most important question is: Do you really need all States at once inside current_state? If you just iterate over them once or twice in the default order, then there is no need for a vector, just generate them on demand.

If you really need it, here is the next step. Since Board is expensive for copying, a DifferenceBoard that keeps only track of the difference may be better. Pseudocode:

struct DifferenceBoard { // or maybe inherit from Board that a DifferenceBoard
                         // can be built from another DifferenceBoard
  Board *original;
  int fromposition, toposition;
  State state_at_position;

  State get(int y, int x) const {
    if ((x,y) == fromposition) return Empty;
    if ((x,y) == toposition  ) return state_at_position;
    return original->get();
  }
};