/*
Stockfish, a UCI chess playing engine derived from Glaurung 2.1
Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
- Copyright (C) 2008-2013 Marco Costalba, Joona Kiiski, Tord Romstad
+ Copyright (C) 2008-2014 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
ThreadPool Threads; // Global object
+extern void check_time();
+
namespace {
// start_routine() is the C function which is called when a new thread
}
+// Thread::cutoff_occurred() checks whether a beta cutoff has occurred in the
+// current active split point, or in some ancestor of the split point.
+
+bool Thread::cutoff_occurred() const {
+
+ for (SplitPoint* sp = activeSplitPoint; sp; sp = sp->parentSplitPoint)
+ if (sp->cutoff)
+ return true;
+
+ return false;
+}
+
+
+// Thread::available_to() checks whether the thread is available to help the
+// thread 'master' at a split point. An obvious requirement is that thread must
+// be idle. With more than two threads, this is not sufficient: If the thread is
+// the master of some split point, it is only available as a slave to the slaves
+// which are busy searching the split point at the top of slave's split point
+// stack (the "helpful master concept" in YBWC terminology).
+
+bool Thread::available_to(const Thread* master) const {
+
+ if (searching)
+ return false;
+
+ // Make a local copy to be sure it doesn't become zero under our feet while
+ // testing next condition and so leading to an out of bounds access.
+ int size = splitPointsSize;
+
+ // No split points means that the thread is available as a slave for any
+ // other thread otherwise apply the "helpful master" concept if possible.
+ return !size || (splitPoints[size - 1].slavesMask & (1ULL << master->idx));
+}
+
+
// TimerThread::idle_loop() is where the timer thread waits msec milliseconds
// and then calls check_time(). If msec is 0 thread sleeps until it's woken up.
-extern void check_time();
void TimerThread::idle_loop() {
}
-// Thread::cutoff_occurred() checks whether a beta cutoff has occurred in the
-// current active split point, or in some ancestor of the split point.
-
-bool Thread::cutoff_occurred() const {
-
- for (SplitPoint* sp = activeSplitPoint; sp; sp = sp->parentSplitPoint)
- if (sp->cutoff)
- return true;
-
- return false;
-}
-
-
-// Thread::available_to() checks whether the thread is available to help the
-// thread 'master' at a split point. An obvious requirement is that thread must
-// be idle. With more than two threads, this is not sufficient: If the thread is
-// the master of some split point, it is only available as a slave to the slaves
-// which are busy searching the split point at the top of slave's split point
-// stack (the "helpful master concept" in YBWC terminology).
-
-bool Thread::available_to(const Thread* master) const {
-
- if (searching)
- return false;
-
- // Make a local copy to be sure it doesn't become zero under our feet while
- // testing next condition and so leading to an out of bounds access.
- int size = splitPointsSize;
-
- // No split points means that the thread is available as a slave for any
- // other thread otherwise apply the "helpful master" concept if possible.
- return !size || (splitPoints[size - 1].slavesMask & (1ULL << master->idx));
-}
-
-
// init() is called at startup to create and launch requested threads, that will
// go immediately to sleep due to 'sleepWhileIdle' set to true. We cannot use
// a c'tor because Threads is a static object and we need a fully initialized
template <bool Fake>
void Thread::split(Position& pos, const Stack* ss, Value alpha, Value beta, Value* bestValue,
- Move* bestMove, Depth depth, Move threatMove, int moveCount,
+ Move* bestMove, Depth depth, int moveCount,
MovePicker* movePicker, int nodeType, bool cutNode) {
assert(pos.pos_is_ok());
- assert(*bestValue <= alpha && alpha < beta && beta <= VALUE_INFINITE);
- assert(*bestValue > -VALUE_INFINITE);
+ assert(-VALUE_INFINITE < *bestValue && *bestValue <= alpha && alpha < beta && beta <= VALUE_INFINITE);
assert(depth >= Threads.minimumSplitDepth);
assert(searching);
assert(splitPointsSize < MAX_SPLITPOINTS_PER_THREAD);
sp.depth = depth;
sp.bestValue = *bestValue;
sp.bestMove = *bestMove;
- sp.threatMove = threatMove;
sp.alpha = alpha;
sp.beta = beta;
sp.nodeType = nodeType;
}
// Explicit template instantiations
-template void Thread::split<false>(Position&, const Stack*, Value, Value, Value*, Move*, Depth, Move, int, MovePicker*, int, bool);
-template void Thread::split< true>(Position&, const Stack*, Value, Value, Value*, Move*, Depth, Move, int, MovePicker*, int, bool);
+template void Thread::split<false>(Position&, const Stack*, Value, Value, Value*, Move*, Depth, int, MovePicker*, int, bool);
+template void Thread::split< true>(Position&, const Stack*, Value, Value, Value*, Move*, Depth, int, MovePicker*, int, bool);
// wait_for_think_finished() waits for main thread to go to sleep then returns
// 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, StateStackPtr& states) {
+
wait_for_think_finished();
SearchTime = Time::now(); // As early as possible
}
for (MoveList<LEGAL> it(pos); *it; ++it)
- if ( searchMoves.empty()
- || std::count(searchMoves.begin(), searchMoves.end(), *it))
+ if ( limits.searchmoves.empty()
+ || std::count(limits.searchmoves.begin(), limits.searchmoves.end(), *it))
RootMoves.push_back(RootMove(*it));
main()->thinking = true;