kate/BadFish
1
0
Fork 0
mirror of https://github.com/sockspls/badfish synced 2025-04-30 16:53:09 +00:00
Code Issues Releases Wiki Activity

Use exceptions to stop the search

Browse source 
Instead of classical flags, throw an
exception when we want to immediately halt
the search. Currently only one type
is used for both UCI stop and threads
cut off.

No functional change.
This commit is contained in:
Marco Costalba 2013-08-14 08:29:57 +02:00
parent bd8f463b7e
commit 11b1a76f35
2 changed files with 30 additions and 24 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/Makefile
View file

@ -232,7 +232,7 @@ ifeq ($(COMP),clang)
endif endif
### 3.2 General compiler settings ### 3.2 General compiler settings
CXXFLAGS = -Wall -Wcast-qual -fno-exceptions -fno-rtti $(EXTRACXXFLAGS) CXXFLAGS = -Wall -Wcast-qual -fno-rtti $(EXTRACXXFLAGS)
ifeq ($(comp),gcc) ifeq ($(comp),gcc)
CXXFLAGS += -ansi -pedantic -Wno-long-long -Wextra -Wshadow CXXFLAGS += -ansi -pedantic -Wno-long-long -Wextra -Wshadow

52
src/search.cpp
View file

@ -21,6 +21,7 @@
#include <cassert> #include <cassert>
#include <cmath> #include <cmath>
#include <cstring> #include <cstring>
#include <exception>
#include <iostream> #include <iostream>
#include <sstream> #include <sstream>
@ -104,6 +105,8 @@ namespace {
bool refutes(const Position& pos, Move first, Move second); bool refutes(const Position& pos, Move first, Move second);
string uci_pv(const Position& pos, int depth, Value alpha, Value beta); string uci_pv(const Position& pos, int depth, Value alpha, Value beta);
class stop : public std::exception {};
struct Skill { struct Skill {
Skill(int l) : level(l), best(MOVE_NONE) {} Skill(int l) : level(l), best(MOVE_NONE) {}
~Skill() { ~Skill() {
@ -356,7 +359,9 @@ namespace {
// research with bigger window until not failing high/low anymore. // research with bigger window until not failing high/low anymore.
while (true) 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 // Bring to front the best move. It is critical that sorting is
// done with a stable algorithm because all the values but the first // done with a stable algorithm because all the values but the first
@ -541,10 +546,13 @@ namespace {
if (PvNode && thisThread->maxPly < ss->ply) if (PvNode && thisThread->maxPly < ss->ply)
thisThread->maxPly = ss->ply; thisThread->maxPly = ss->ply;
if (Signals.stop || thisThread->cutoff_occurred())
throw stop();
if (!RootNode) if (!RootNode)
{ {
// Step 2. Check for aborted search and immediate draw // 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()]; return DrawValue[pos.side_to_move()];
// Step 3. Mate distance pruning. Even if we mate at the next move our score // Step 3. Mate distance pruning. Even if we mate at the next move our score
@ -999,13 +1007,6 @@ moves_loop: // When in check and at SpNode search starts from here
alpha = splitPoint->alpha; 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) if (RootNode)
{ {
RootMove& rm = *std::find(RootMoves.begin(), RootMoves.end(), move); RootMove& rm = *std::find(RootMoves.begin(), RootMoves.end(), move);
@ -1696,21 +1697,26 @@ void Thread::idle_loop() {
activePosition = &pos; activePosition = &pos;
switch (sp->nodeType) { try {
case Root: switch (sp->nodeType) {
search<SplitPointRoot>(pos, ss, sp->alpha, sp->beta, sp->depth, sp->cutNode); case Root:
break; search<SplitPointRoot>(pos, ss, sp->alpha, sp->beta, sp->depth, sp->cutNode);
case PV: break;
search<SplitPointPV>(pos, ss, sp->alpha, sp->beta, sp->depth, sp->cutNode); case PV:
break; search<SplitPointPV>(pos, ss, sp->alpha, sp->beta, sp->depth, sp->cutNode);
case NonPV: break;
search<SplitPointNonPV>(pos, ss, sp->alpha, sp->beta, sp->depth, sp->cutNode); case NonPV:
break; search<SplitPointNonPV>(pos, ss, sp->alpha, sp->beta, sp->depth, sp->cutNode);
default: break;
assert(false); default:
} assert(false);
}
assert(searching); assert(searching);
}
catch (stop&) {
sp->mutex.lock(); // Exception is thrown out of lock
}
searching = false; searching = false;
activePosition = NULL; activePosition = NULL;