/*
Stockfish, a UCI chess playing engine derived from Glaurung 2.1
Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
- Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+ Copyright (C) 2008-2013 Marco Costalba, Joona Kiiski, Tord Romstad
Stockfish is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
#include <algorithm> // For std::count
#include <cassert>
-#include <cstring> // For memset
#include <iostream>
#include "movegen.h"
searching = exit = false;
maxPly = splitPointsSize = 0;
activeSplitPoint = NULL;
+ activePosition = NULL;
idx = Threads.size();
if (!thread_create(handle, start_routine, this))
sp.cutoff = false;
sp.ss = ss;
- memset(sp.slavesPositions, 0, sizeof(sp.slavesPositions));
-
// Try to allocate available threads and ask them to start searching setting
// 'searching' flag. This must be done under lock protection to avoid concurrent
// allocation of the same slave by another master.
splitPointsSize++;
activeSplitPoint = &sp;
+ activePosition = NULL;
size_t slavesCnt = 1; // This thread is always included
Thread* slave;
slave->notify_one(); // Could be sleeping
}
- sp.mutex.unlock();
- Threads.mutex.unlock();
-
// Everything is set up. The master thread enters the idle loop, from which
// it will instantly launch a search, because its 'searching' flag is set.
// The thread will return from the idle loop when all slaves have finished
// their work at this split point.
if (slavesCnt > 1 || Fake)
{
+ sp.mutex.unlock();
+ Threads.mutex.unlock();
+
Thread::idle_loop(); // Force a call to base class idle_loop()
// In helpful master concept a master can help only a sub-tree of its split
// point, and because here is all finished is not possible master is booked.
assert(!searching);
- }
+ assert(!activePosition);
- // We have returned from the idle loop, which means that all threads are
- // finished. Note that setting 'searching' and decreasing splitPointsSize is
- // done under lock protection to avoid a race with Thread::is_available_to().
- Threads.mutex.lock();
- sp.mutex.lock();
+ // We have returned from the idle loop, which means that all threads are
+ // finished. Note that setting 'searching' and decreasing splitPointsSize is
+ // done under lock protection to avoid a race with Thread::is_available_to().
+ Threads.mutex.lock();
+ sp.mutex.lock();
+ }
searching = true;
splitPointsSize--;
activeSplitPoint = sp.parentSplitPoint;
+ activePosition = &pos;
pos.set_nodes_searched(pos.nodes_searched() + sp.nodes);
*bestMove = sp.bestMove;
*bestValue = sp.bestValue;
// start_thinking() wakes up the main thread sleeping in MainThread::idle_loop()
// so to start a new search, then returns immediately.
-void ThreadPool::start_thinking(const Position& pos, const LimitsType& limits,
- const std::vector<Move>& searchMoves, StateStackPtr& states) {
+void ThreadPool::start_thinking(const Position& pos, const LimitsType& limits, const std::vector<Move>& searchMoves,
+ StateStackPtr& setupStates, MovesVectPtr& setupMoves) {
wait_for_think_finished();
SearchTime = Time::now(); // As early as possible
RootPos = pos;
Limits = limits;
- SetupStates = states; // Ownership transfer here
+ SetupStates = setupStates; // Ownership transfer here
+ SetupMoves = setupMoves; // Ownership transfer here
RootMoves.clear();
for (MoveList<LEGAL> ml(pos); !ml.end(); ++ml)