#include "evaluate.h"
#include "movegen.h"
#include "movepick.h"
-#include "notation.h"
#include "rkiss.h"
#include "search.h"
#include "timeman.h"
#include "thread.h"
#include "tt.h"
-#include "ucioption.h"
+#include "uci.h"
namespace Search {
// Init futility move count array
for (d = 0; d < 32; ++d)
{
- FutilityMoveCounts[0][d] = int(2.4 + 0.222 * pow(d * 2 + 0.00, 1.8));
- FutilityMoveCounts[1][d] = int(3.0 + 0.300 * pow(d * 2 + 0.98, 1.8));
+ FutilityMoveCounts[0][d] = int(2.4 + 0.773 * pow(d + 0.00, 1.8));
+ FutilityMoveCounts[1][d] = int(2.9 + 1.045 * pow(d + 0.49, 1.8));
}
}
pos.undo_move(*it);
}
if (Root)
- sync_cout << move_to_uci(*it, pos.is_chess960()) << ": " << cnt << sync_endl;
+ sync_cout << UCI::format_move(*it, pos.is_chess960()) << ": " << cnt << sync_endl;
}
return nodes;
}
{
RootMoves.push_back(MOVE_NONE);
sync_cout << "info depth 0 score "
- << score_to_uci(RootPos.checkers() ? -VALUE_MATE : VALUE_DRAW)
+ << UCI::format_value(RootPos.checkers() ? -VALUE_MATE : VALUE_DRAW)
<< sync_endl;
goto finalize;
}
// Best move could be MOVE_NONE when searching on a stalemate position
- sync_cout << "bestmove " << move_to_uci(RootMoves[0].pv[0], RootPos.is_chess960())
- << " ponder " << move_to_uci(RootMoves[0].pv[1], RootPos.is_chess960())
+ sync_cout << "bestmove " << UCI::format_move(RootMoves[0].pv[0], RootPos.is_chess960())
+ << " ponder " << UCI::format_move(RootMoves[0].pv[1], RootPos.is_chess960())
<< sync_endl;
}
void id_loop(Position& pos) {
- Stack stack[MAX_PLY_PLUS_6], *ss = stack+2; // To allow referencing (ss-2)
+ Stack stack[MAX_PLY+4], *ss = stack+2; // To allow referencing (ss-2) and (ss+2)
int depth;
Value bestValue, alpha, beta, delta;
multiPV = std::max(multiPV, skill.candidates_size());
// Iterative deepening loop until requested to stop or target depth reached
- while (++depth <= MAX_PLY && !Signals.stop && (!Limits.depth || depth <= Limits.depth))
+ while (++depth < MAX_PLY && !Signals.stop && (!Limits.depth || depth <= Limits.depth))
{
// Age out PV variability metric
BestMoveChanges *= 0.5;
// Sort the PV lines searched so far and update the GUI
std::stable_sort(RootMoves.begin(), RootMoves.begin() + PVIdx + 1);
- if (PVIdx + 1 == std::min(multiPV, RootMoves.size()) || Time::now() - SearchTime > 3000)
+ if ( !Signals.stop
+ && ( PVIdx + 1 == std::min(multiPV, RootMoves.size())
+ || Time::now() - SearchTime > 3000))
sync_cout << uci_pv(pos, depth, alpha, beta) << sync_endl;
}
moveCount = quietCount = 0;
bestValue = -VALUE_INFINITE;
- ss->currentMove = ss->ttMove = (ss+1)->excludedMove = bestMove = MOVE_NONE;
ss->ply = (ss-1)->ply + 1;
- (ss+1)->skipNullMove = false; (ss+1)->reduction = DEPTH_ZERO;
- (ss+2)->killers[0] = (ss+2)->killers[1] = MOVE_NONE;
// Used to send selDepth info to GUI
if (PvNode && thisThread->maxPly < ss->ply)
if (!RootNode)
{
// Step 2. Check for aborted search and immediate draw
- if (Signals.stop || pos.is_draw() || ss->ply > MAX_PLY)
- return ss->ply > MAX_PLY && !inCheck ? evaluate(pos) : DrawValue[pos.side_to_move()];
+ if (Signals.stop || pos.is_draw() || ss->ply >= MAX_PLY)
+ return ss->ply >= MAX_PLY && !inCheck ? evaluate(pos) : DrawValue[pos.side_to_move()];
// Step 3. Mate distance pruning. Even if we mate at the next move our score
// would be at best mate_in(ss->ply+1), but if alpha is already bigger because
return alpha;
}
+ assert(0 <= ss->ply && ss->ply < MAX_PLY);
+
+ ss->currentMove = ss->ttMove = (ss+1)->excludedMove = bestMove = MOVE_NONE;
+ (ss+1)->skipNullMove = false; (ss+1)->reduction = DEPTH_ZERO;
+ (ss+2)->killers[0] = (ss+2)->killers[1] = MOVE_NONE;
+
// Step 4. Transposition table lookup
// We don't want the score of a partial search to overwrite a previous full search
// TT value, so we use a different position key in case of an excluded move.
if (thisThread == Threads.main() && Time::now() - SearchTime > 3000)
sync_cout << "info depth " << depth
- << " currmove " << move_to_uci(move, pos.is_chess960())
+ << " currmove " << UCI::format_move(move, pos.is_chess960())
<< " currmovenumber " << moveCount + PVIdx << sync_endl;
}
}
}
- // Speculative prefetch
- prefetch((char*)TT.first_entry(pos.hash_after_move(move)));
+ // Speculative prefetch as early as possible
+ prefetch((char*)TT.first_entry(pos.key_after(move)));
// Check for legality just before making the move
if (!RootNode && !SpNode && !pos.legal(move, ci.pinned))
ss->ply = (ss-1)->ply + 1;
// Check for an instant draw or if the maximum ply has been reached
- if (pos.is_draw() || ss->ply > MAX_PLY)
- return ss->ply > MAX_PLY && !InCheck ? evaluate(pos) : DrawValue[pos.side_to_move()];
+ if (pos.is_draw() || ss->ply >= MAX_PLY)
+ return ss->ply >= MAX_PLY && !InCheck ? evaluate(pos) : DrawValue[pos.side_to_move()];
+
+ assert(0 <= ss->ply && ss->ply < MAX_PLY);
// Decide whether or not to include checks: this fixes also the type of
// TT entry depth that we are going to use. Note that in qsearch we use
&& pos.see_sign(move) < VALUE_ZERO)
continue;
- // Speculative prefetch
- prefetch((char*)TT.first_entry(pos.hash_after_move(move)));
+ // Speculative prefetch as early as possible
+ prefetch((char*)TT.first_entry(pos.key_after(move)));
// Check for legality just before making the move
if (!pos.legal(move, ci.pinned))
ss << "info depth " << d
<< " seldepth " << selDepth
- << " score " << (i == PVIdx ? score_to_uci(v, alpha, beta) : score_to_uci(v))
+ << " multipv " << i + 1
+ << " score " << (i == PVIdx ? UCI::format_value(v, alpha, beta) : UCI::format_value(v))
<< " nodes " << pos.nodes_searched()
<< " nps " << pos.nodes_searched() * 1000 / elapsed
<< " time " << elapsed
- << " multipv " << i + 1
<< " pv";
for (size_t j = 0; RootMoves[i].pv[j] != MOVE_NONE; ++j)
- ss << " " << move_to_uci(RootMoves[i].pv[j], pos.is_chess960());
+ ss << " " << UCI::format_move(RootMoves[i].pv[j], pos.is_chess960());
}
return ss.str();
void RootMove::extract_pv_from_tt(Position& pos) {
- StateInfo state[MAX_PLY_PLUS_6], *st = state;
+ StateInfo state[MAX_PLY], *st = state;
const TTEntry* tte;
int ply = 1; // At root ply is 1...
Move m = pv[0]; // ...instead pv[] array starts from 0
void RootMove::insert_pv_in_tt(Position& pos) {
- StateInfo state[MAX_PLY_PLUS_6], *st = state;
+ StateInfo state[MAX_PLY], *st = state;
const TTEntry* tte;
int idx = 0; // Ply starts from 1, we need to start from 0
Threads.mutex.unlock();
- Stack stack[MAX_PLY_PLUS_6], *ss = stack+2; // To allow referencing (ss-2)
+ Stack stack[MAX_PLY+4], *ss = stack+2; // To allow referencing (ss-2) and (ss+2)
Position pos(*sp->pos, this);
std::memcpy(ss-2, sp->ss-2, 5 * sizeof(Stack));
void check_time() {
static Time::point lastInfoTime = Time::now();
- int64_t nodes = 0; // Workaround silly 'uninitialized' gcc warning
+ Time::point elapsed = Time::now() - SearchTime;
if (Time::now() - lastInfoTime >= 1000)
{
dbg_print();
}
- if (Limits.ponder)
- return;
+ if (Limits.use_time_management() && !Limits.ponder)
+ {
+ bool stillAtFirstMove = Signals.firstRootMove
+ && !Signals.failedLowAtRoot
+ && elapsed > TimeMgr.available_time() * 75 / 100;
+
+ if ( stillAtFirstMove
+ || elapsed > TimeMgr.maximum_time() - 2 * TimerThread::Resolution)
+ Signals.stop = true;
+ }
+ else if (Limits.movetime && elapsed >= Limits.movetime)
+ Signals.stop = true;
- if (Limits.nodes)
+ else if (Limits.nodes)
{
Threads.mutex.lock();
- nodes = RootPos.nodes_searched();
+ int64_t nodes = RootPos.nodes_searched();
// Loop across all split points and sum accumulated SplitPoint nodes plus
// all the currently active positions nodes.
}
Threads.mutex.unlock();
- }
- Time::point elapsed = Time::now() - SearchTime;
- bool stillAtFirstMove = Signals.firstRootMove
- && !Signals.failedLowAtRoot
- && elapsed > TimeMgr.available_time() * 75 / 100;
-
- bool noMoreTime = elapsed > TimeMgr.maximum_time() - 2 * TimerThread::Resolution
- || stillAtFirstMove;
-
- if ( (Limits.use_time_management() && noMoreTime)
- || (Limits.movetime && elapsed >= Limits.movetime)
- || (Limits.nodes && nodes >= Limits.nodes))
- Signals.stop = true;
+ if (nodes >= Limits.nodes)
+ Signals.stop = true;
+ }
}