21   : main_player(player), 
 
   36                                      dynamic_cast<SearchPlayer*>(main_player->clone()));
 
   42   speculative->setMaxThreads(new_max_threads);
 
   48   main_player->pushMove(m);
 
   51     if (previous_state.get() && speculative_search_allowed)
 
   59         previous_state->pushMove(m);
 
   60         speculative->startSpeculative(previous_state, *main_player);
 
   62       catch (std::exception& e)
 
   64         std::cerr << e.what() << 
" in SpeculativeSearchPlayer::pushMove\n";
 
   65         speculative->clearResource();
 
   67       NonBlockDelete::reset(previous_state);
 
   72     if (speculative_search_allowed)
 
   73       speculative->stopOtherThan(m);
 
   80   main_player->popMove();
 
   81   previous_state.reset();
 
   82   speculative->stopAll();
 
   88   return main_player->stopSearchNow();
 
   95   if (result.
standard.value() > 2000) {
 
   97     result.
max = result.
max - MilliSeconds::Interval(500);
 
  108   const time_t start_time = time(0);
 
  112   const HashKey search_key(speculative->searchState());
 
  114   const bool consistent = (search_key == now_key);
 
  117     ? standardSearchSeconds(state, limit, elapsed, byoyomi)
 
  121     result = speculative->waitResult(last_move, wait_for, *main_player,
 
  124   const time_t now = time(0);
 
  126   if (! consistent && result.move.isNormal())
 
  127     std::cerr << 
"note: the current position differs from the one which previous prediction search ran on\n";
 
  128   if (result.move.isNormal() && consistent) {
 
  129 #ifdef DEBUG_SPECULATIVE_EXECUTION 
  131               << 
" " << 
ctime_r(&now, ctime_buf);
 
  133     selectBestMoveCleanUp(state);
 
  134     main_player->saveSearchResult(state, result);
 
  137   std::cerr << 
"search again " << 
ctime_r(&now, ctime_buf);
 
  138   selectBestMoveCleanUp(state);
 
  143   const int consumed = (now - start_time);
 
  144   if (byoyomi && (limit <= elapsed+consumed))
 
  145     byoyomi = 
std::max(1, byoyomi - (elapsed+consumed-limit));
 
  147   result = main_player->selectBestMove(state, limit, 
std::min(limit-1, elapsed+consumed), byoyomi);
 
  156     previous_state = state.
clone();
 
  158   catch (std::exception& e)
 
  160     std::cerr << e.what() << std::endl;
 
  161     previous_state.reset();
 
  163   speculative->selectBestMoveCleanUp();