#include <cassert>
#include <cmath>
#include <cstring>
+#include <exception>
#include <iostream>
#include <sstream>
bool refutes(const Position& pos, Move first, Move second);
string uci_pv(const Position& pos, int depth, Value alpha, Value beta);
+ class stop : public std::exception {};
+
struct Skill {
Skill(int l) : level(l), best(MOVE_NONE) {}
~Skill() {
// research with bigger window until not failing high/low anymore.
while (true)
{
- bestValue = search<Root>(pos, ss, alpha, beta, depth * ONE_PLY, false);
+ try {
+ bestValue = search<Root>(pos, ss, alpha, beta, depth * ONE_PLY, false);
+ } catch (stop&) {}
// Bring to front the best move. It is critical that sorting is
// done with a stable algorithm because all the values but the first
if (PvNode && thisThread->maxPly < ss->ply)
thisThread->maxPly = ss->ply;
+ if (Signals.stop || thisThread->cutoff_occurred())
+ throw stop();
+
if (!RootNode)
{
// Step 2. Check for aborted search and immediate draw
- if (Signals.stop || pos.is_draw() || ss->ply > MAX_PLY)
+ if (pos.is_draw() || ss->ply > MAX_PLY)
return DrawValue[pos.side_to_move()];
// Step 3. Mate distance pruning. Even if we mate at the next move our score
alpha = splitPoint->alpha;
}
- // Finished searching the move. If Signals.stop is true, the search
- // was aborted because the user interrupted the search or because we
- // ran out of time. In this case, the return value of the search cannot
- // be trusted, and we don't update the best move and/or PV.
- if (Signals.stop || thisThread->cutoff_occurred())
- return value; // To avoid returning VALUE_INFINITE
-
if (RootNode)
{
RootMove& rm = *std::find(RootMoves.begin(), RootMoves.end(), move);
activePosition = &pos;
- switch (sp->nodeType) {
- case Root:
- search<SplitPointRoot>(pos, ss, sp->alpha, sp->beta, sp->depth, sp->cutNode);
- break;
- case PV:
- search<SplitPointPV>(pos, ss, sp->alpha, sp->beta, sp->depth, sp->cutNode);
- break;
- case NonPV:
- search<SplitPointNonPV>(pos, ss, sp->alpha, sp->beta, sp->depth, sp->cutNode);
- break;
- default:
- assert(false);
- }
+ try {
+ switch (sp->nodeType) {
+ case Root:
+ search<SplitPointRoot>(pos, ss, sp->alpha, sp->beta, sp->depth, sp->cutNode);
+ break;
+ case PV:
+ search<SplitPointPV>(pos, ss, sp->alpha, sp->beta, sp->depth, sp->cutNode);
+ break;
+ case NonPV:
+ search<SplitPointNonPV>(pos, ss, sp->alpha, sp->beta, sp->depth, sp->cutNode);
+ break;
+ default:
+ assert(false);
+ }
- assert(searching);
+ assert(searching);
+ }
+ catch (stop&) {
+ sp->mutex.lock(); // Exception is thrown out of lock
+ }
searching = false;
activePosition = NULL;