Marco Costalba
parent
55758344d3
commit
307a5a4f63
|
|
@ -1,4 +1,6 @@
|
|||
### Overview [](https://travis-ci.org/official-stockfish/Stockfish)
|
||||
### Overview
|
||||
|
||||
[](https://travis-ci.org/official-stockfish/Stockfish)
|
||||
|
||||
Stockfish is a free UCI chess engine derived from Glaurung 2.1. It is
|
||||
not a complete chess program and requires some UCI-compatible GUI
|
||||
|
|
|
|||
|
|
@ -171,8 +171,8 @@ namespace {
|
|||
|
||||
// PassedFile[File] contains a bonus according to the file of a passed pawn.
|
||||
const Score PassedFile[] = {
|
||||
S( 12, 10), S( 3, 10), S( 1, -8), S(-27, -12),
|
||||
S(-27, -12), S( 1, -8), S( 3, 10), S( 12, 10)
|
||||
S( 12, 10), S( 3, 10), S( 1, -8), S(-27, -12),
|
||||
S(-27, -12), S( 1, -8), S( 3, 10), S( 12, 10)
|
||||
};
|
||||
|
||||
const Score ThreatenedByHangingPawn = S(40, 60);
|
||||
|
|
@ -677,20 +677,18 @@ namespace {
|
|||
// evaluate_initiative() computes the initiative correction value for the
|
||||
// position, i.e. second order bonus/malus based on the known attacking/defending
|
||||
// status of the players.
|
||||
Score evaluate_initiative(const Position& pos, const EvalInfo& ei, const Score positional_score) {
|
||||
Score evaluate_initiative(const Position& pos, int asymmetry, Value eg) {
|
||||
|
||||
int king_separation = distance<File>(pos.square<KING>(WHITE), pos.square<KING>(BLACK));
|
||||
int pawns = pos.count<PAWN>(WHITE) + pos.count<PAWN>(BLACK);
|
||||
int asymmetry = ei.pi->pawn_asymmetry();
|
||||
int kingDistance = distance<File>(pos.square<KING>(WHITE), pos.square<KING>(BLACK));
|
||||
int pawns = pos.count<PAWN>(WHITE) + pos.count<PAWN>(BLACK);
|
||||
|
||||
// Compute the initiative bonus for the attacking side
|
||||
int attacker_bonus = 8 * (pawns + asymmetry + king_separation) - 120;
|
||||
int initiative = 8 * (pawns + asymmetry + kingDistance - 15);
|
||||
|
||||
// Now apply the bonus: note that we find the attacking side by extracting the sign
|
||||
// of the endgame value of "positional_score", and that we carefully cap the bonus so
|
||||
// that the endgame score with the correction will never be divided by more than two.
|
||||
int eg = eg_value(positional_score);
|
||||
int value = ((eg > 0) - (eg < 0)) * std::max(attacker_bonus, -abs(eg / 2));
|
||||
// Now apply the bonus: note that we find the attacking side by extracting
|
||||
// the sign of the endgame value, and that we carefully cap the bonus so
|
||||
// that the endgame score will never be divided by more than two.
|
||||
int value = ((eg > 0) - (eg < 0)) * std::max(initiative, -abs(eg / 2));
|
||||
|
||||
return make_score(0, value);
|
||||
}
|
||||
|
|
@ -777,8 +775,8 @@ Value Eval::evaluate(const Position& pos) {
|
|||
if (pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK) >= 12222)
|
||||
score += (evaluate_space<WHITE>(pos, ei) - evaluate_space<BLACK>(pos, ei)) * Weights[Space];
|
||||
|
||||
// Evaluate initiative
|
||||
score += evaluate_initiative(pos, ei, score);
|
||||
// Evaluate position potential for the winning side
|
||||
score += evaluate_initiative(pos, ei.pi->pawn_asymmetry(), eg_value(score));
|
||||
|
||||
// Scale winning side if position is more drawish than it appears
|
||||
Color strongSide = eg_value(score) > VALUE_DRAW ? WHITE : BLACK;
|
||||
|
|
|
|||
|
|
@ -68,8 +68,8 @@ namespace {
|
|||
/// ordering is at the current node.
|
||||
|
||||
MovePicker::MovePicker(const Position& p, Move ttm, Depth d, const HistoryStats& h,
|
||||
const CounterMovesHistoryStats& cmh, Move cm, Search::Stack* s)
|
||||
: pos(p), history(h), counterMovesHistory(cmh), ss(s), countermove(cm), depth(d) {
|
||||
const CounterMovesStats& cmh, Move cm, Search::Stack* s)
|
||||
: pos(p), history(h), counterMovesHistory(&cmh), ss(s), countermove(cm), depth(d) {
|
||||
|
||||
assert(d > DEPTH_ZERO);
|
||||
|
||||
|
|
@ -78,9 +78,9 @@ MovePicker::MovePicker(const Position& p, Move ttm, Depth d, const HistoryStats&
|
|||
endMoves += (ttMove != MOVE_NONE);
|
||||
}
|
||||
|
||||
MovePicker::MovePicker(const Position& p, Move ttm, Depth d, const HistoryStats& h,
|
||||
const CounterMovesHistoryStats& cmh, Square s)
|
||||
: pos(p), history(h), counterMovesHistory(cmh) {
|
||||
MovePicker::MovePicker(const Position& p, Move ttm, Depth d,
|
||||
const HistoryStats& h, Square s)
|
||||
: pos(p), history(h), counterMovesHistory(nullptr) {
|
||||
|
||||
assert(d <= DEPTH_ZERO);
|
||||
|
||||
|
|
@ -104,9 +104,8 @@ MovePicker::MovePicker(const Position& p, Move ttm, Depth d, const HistoryStats&
|
|||
endMoves += (ttMove != MOVE_NONE);
|
||||
}
|
||||
|
||||
MovePicker::MovePicker(const Position& p, Move ttm, const HistoryStats& h,
|
||||
const CounterMovesHistoryStats& cmh, Value th)
|
||||
: pos(p), history(h), counterMovesHistory(cmh), threshold(th) {
|
||||
MovePicker::MovePicker(const Position& p, Move ttm, const HistoryStats& h, Value th)
|
||||
: pos(p), history(h), counterMovesHistory(nullptr), threshold(th) {
|
||||
|
||||
assert(!pos.checkers());
|
||||
|
||||
|
|
@ -141,12 +140,9 @@ void MovePicker::score<CAPTURES>() {
|
|||
template<>
|
||||
void MovePicker::score<QUIETS>() {
|
||||
|
||||
Square prevSq = to_sq((ss-1)->currentMove);
|
||||
const HistoryStats& cmh = counterMovesHistory[pos.piece_on(prevSq)][prevSq];
|
||||
|
||||
for (auto& m : *this)
|
||||
m.value = history[pos.moved_piece(m)][to_sq(m)]
|
||||
+ cmh[pos.moved_piece(m)][to_sq(m)];
|
||||
+ (*counterMovesHistory)[pos.moved_piece(m)][to_sq(m)];
|
||||
}
|
||||
|
||||
template<>
|
||||
|
|
|
|||
|
|
@ -36,10 +36,10 @@
|
|||
/// Countermoves store the move that refute a previous one. Entries are stored
|
||||
/// using only the moving piece and destination square, hence two moves with
|
||||
/// different origin but same destination and piece will be considered identical.
|
||||
template<typename T>
|
||||
template<typename T, bool CM = false>
|
||||
struct Stats {
|
||||
|
||||
static const Value Max = Value(1<<28);
|
||||
static const Value Max = Value(1 << 28);
|
||||
|
||||
const T* operator[](Piece pc) const { return table[pc]; }
|
||||
T* operator[](Piece pc) { return table[pc]; }
|
||||
|
|
@ -51,29 +51,23 @@ struct Stats {
|
|||
table[pc][to] = m;
|
||||
}
|
||||
|
||||
void updateH(Piece pc, Square to, Value v) {
|
||||
void update(Piece pc, Square to, Value v) {
|
||||
|
||||
if (abs(int(v)) >= 324)
|
||||
if (abs(int(v)) >= 324)
|
||||
return;
|
||||
table[pc][to] -= table[pc][to] * abs(int(v)) / 324;
|
||||
table[pc][to] += int(v) * 32;
|
||||
}
|
||||
|
||||
void updateCMH(Piece pc, Square to, Value v) {
|
||||
|
||||
if (abs(int(v)) >= 324)
|
||||
return;
|
||||
table[pc][to] -= table[pc][to] * abs(int(v)) / 512;
|
||||
table[pc][to] += int(v) * 64;
|
||||
table[pc][to] -= table[pc][to] * abs(int(v)) / (CM ? 512 : 324);
|
||||
table[pc][to] += int(v) * (CM ? 64 : 32);
|
||||
}
|
||||
|
||||
private:
|
||||
T table[PIECE_NB][SQUARE_NB];
|
||||
};
|
||||
|
||||
typedef Stats<Value> HistoryStats;
|
||||
typedef Stats<Move> MovesStats;
|
||||
typedef Stats<HistoryStats> CounterMovesHistoryStats;
|
||||
typedef Stats<Value, false> HistoryStats;
|
||||
typedef Stats<Value, true> CounterMovesStats;
|
||||
typedef Stats<CounterMovesStats> CounterMovesHistoryStats;
|
||||
|
||||
|
||||
/// MovePicker class is used to pick one pseudo legal move at a time from the
|
||||
|
|
@ -88,9 +82,9 @@ public:
|
|||
MovePicker(const MovePicker&) = delete;
|
||||
MovePicker& operator=(const MovePicker&) = delete;
|
||||
|
||||
MovePicker(const Position&, Move, Depth, const HistoryStats&, const CounterMovesHistoryStats&, Square);
|
||||
MovePicker(const Position&, Move, const HistoryStats&, const CounterMovesHistoryStats&, Value);
|
||||
MovePicker(const Position&, Move, Depth, const HistoryStats&, const CounterMovesHistoryStats&, Move, Search::Stack*);
|
||||
MovePicker(const Position&, Move, Depth, const HistoryStats&, Square);
|
||||
MovePicker(const Position&, Move, const HistoryStats&, Value);
|
||||
MovePicker(const Position&, Move, Depth, const HistoryStats&, const CounterMovesStats&, Move, Search::Stack*);
|
||||
|
||||
Move next_move();
|
||||
|
||||
|
|
@ -102,7 +96,7 @@ private:
|
|||
|
||||
const Position& pos;
|
||||
const HistoryStats& history;
|
||||
const CounterMovesHistoryStats& counterMovesHistory;
|
||||
const CounterMovesStats* counterMovesHistory;
|
||||
Search::Stack* ss;
|
||||
Move countermove;
|
||||
Depth depth;
|
||||
|
|
|
|||
135
src/search.cpp
135
src/search.cpp
|
|
@ -64,7 +64,7 @@ namespace {
|
|||
enum NodeType { Root, PV, NonPV };
|
||||
|
||||
// Razoring and futility margin based on depth
|
||||
int razor_margin[4] = {483, 570, 603, 554};
|
||||
const int razor_margin[4] = { 483, 570, 603, 554 };
|
||||
Value futility_margin(Depth d) { return Value(200 * d); }
|
||||
|
||||
// Futility and reductions lookup tables, initialized at startup
|
||||
|
|
@ -183,8 +183,8 @@ void Search::reset () {
|
|||
|
||||
for (Thread* th : Threads)
|
||||
{
|
||||
th->History.clear();
|
||||
th->Countermoves.clear();
|
||||
th->history.clear();
|
||||
th->counterMoves.clear();
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -288,7 +288,7 @@ void MainThread::think() {
|
|||
for (Thread* th : Threads)
|
||||
{
|
||||
th->maxPly = 0;
|
||||
th->depth = DEPTH_ZERO;
|
||||
th->rootDepth = DEPTH_ZERO;
|
||||
th->searching = true;
|
||||
if (th != this)
|
||||
{
|
||||
|
|
@ -372,11 +372,11 @@ void Thread::search(bool isMainThread) {
|
|||
multiPV = std::min(multiPV, rootMoves.size());
|
||||
|
||||
// Iterative deepening loop until requested to stop or target depth reached
|
||||
while (++depth < DEPTH_MAX && !Signals.stop && (!Limits.depth || depth <= Limits.depth))
|
||||
while (++rootDepth < DEPTH_MAX && !Signals.stop && (!Limits.depth || rootDepth <= Limits.depth))
|
||||
{
|
||||
// Set up the new depth for the helper threads
|
||||
if (!isMainThread)
|
||||
depth = Threads.main()->depth + Depth(int(3 * log(1 + this->idx)));
|
||||
rootDepth = Threads.main()->rootDepth + Depth(int(3 * log(1 + this->idx)));
|
||||
|
||||
// Age out PV variability metric
|
||||
if (isMainThread)
|
||||
|
|
@ -391,7 +391,7 @@ void Thread::search(bool isMainThread) {
|
|||
for (PVIdx = 0; PVIdx < multiPV && !Signals.stop; ++PVIdx)
|
||||
{
|
||||
// Reset aspiration window starting size
|
||||
if (depth >= 5 * ONE_PLY)
|
||||
if (rootDepth >= 5 * ONE_PLY)
|
||||
{
|
||||
delta = Value(18);
|
||||
alpha = std::max(rootMoves[PVIdx].previousScore - delta,-VALUE_INFINITE);
|
||||
|
|
@ -403,7 +403,7 @@ void Thread::search(bool isMainThread) {
|
|||
// high/low anymore.
|
||||
while (true)
|
||||
{
|
||||
bestValue = ::search<Root>(rootPos, ss, alpha, beta, depth, false);
|
||||
bestValue = ::search<Root>(rootPos, ss, alpha, beta, rootDepth, false);
|
||||
|
||||
// Bring the best move to the front. It is critical that sorting
|
||||
// is done with a stable algorithm because all the values but the
|
||||
|
|
@ -430,7 +430,7 @@ void Thread::search(bool isMainThread) {
|
|||
&& multiPV == 1
|
||||
&& (bestValue <= alpha || bestValue >= beta)
|
||||
&& Time.elapsed() > 3000)
|
||||
sync_cout << UCI::pv(rootPos, depth, alpha, beta) << sync_endl;
|
||||
sync_cout << UCI::pv(rootPos, rootDepth, alpha, beta) << sync_endl;
|
||||
|
||||
// In case of failing low/high increase aspiration window and
|
||||
// re-search, otherwise exit the loop.
|
||||
|
|
@ -469,14 +469,14 @@ void Thread::search(bool isMainThread) {
|
|||
<< " time " << Time.elapsed() << sync_endl;
|
||||
|
||||
else if (PVIdx + 1 == multiPV || Time.elapsed() > 3000)
|
||||
sync_cout << UCI::pv(rootPos, depth, alpha, beta) << sync_endl;
|
||||
sync_cout << UCI::pv(rootPos, rootDepth, alpha, beta) << sync_endl;
|
||||
}
|
||||
|
||||
if (!isMainThread)
|
||||
continue;
|
||||
|
||||
// If skill level is enabled and time is up, pick a sub-optimal best move
|
||||
if (skill.enabled() && skill.time_to_pick(depth))
|
||||
if (skill.enabled() && skill.time_to_pick(rootDepth))
|
||||
skill.pick_best(multiPV);
|
||||
|
||||
// Have we found a "mate in x"?
|
||||
|
|
@ -491,7 +491,7 @@ void Thread::search(bool isMainThread) {
|
|||
if (!Signals.stop && !Signals.stopOnPonderhit)
|
||||
{
|
||||
// Take some extra time if the best move has changed
|
||||
if (depth > 4 * ONE_PLY && multiPV == 1)
|
||||
if (rootDepth > 4 * ONE_PLY && multiPV == 1)
|
||||
Time.pv_instability(BestMoveChanges);
|
||||
|
||||
// Stop the search if only one legal move is available or all
|
||||
|
|
@ -582,7 +582,8 @@ namespace {
|
|||
{
|
||||
// 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()];
|
||||
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
|
||||
|
|
@ -602,20 +603,21 @@ namespace {
|
|||
(ss+1)->skipEarlyPruning = 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.
|
||||
// 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.
|
||||
excludedMove = ss->excludedMove;
|
||||
posKey = excludedMove ? pos.exclusion_key() : pos.key();
|
||||
tte = TT.probe(posKey, ttHit);
|
||||
ss->ttMove = ttMove = RootNode ? thisThread->rootMoves[thisThread->PVIdx].pv[0] : ttHit ? tte->move() : MOVE_NONE;
|
||||
ttValue = ttHit ? value_from_tt(tte->value(), ss->ply) : VALUE_NONE;
|
||||
ss->ttMove = ttMove = RootNode ? thisThread->rootMoves[thisThread->PVIdx].pv[0]
|
||||
: ttHit ? tte->move() : MOVE_NONE;
|
||||
|
||||
// At non-PV nodes we check for a fail high/low. We don't prune at PV nodes
|
||||
// At non-PV nodes we check for an early TT cutoff
|
||||
if ( !PvNode
|
||||
&& ttHit
|
||||
&& tte->depth() >= depth
|
||||
&& ttValue != VALUE_NONE // Only in case of TT access race
|
||||
&& ttValue != VALUE_NONE // Possible in case of TT access race
|
||||
&& (ttValue >= beta ? (tte->bound() & BOUND_LOWER)
|
||||
: (tte->bound() & BOUND_UPPER)))
|
||||
{
|
||||
|
|
@ -679,9 +681,11 @@ namespace {
|
|||
else
|
||||
{
|
||||
eval = ss->staticEval =
|
||||
(ss-1)->currentMove != MOVE_NULL ? evaluate(pos) : -(ss-1)->staticEval + 2 * Eval::Tempo;
|
||||
(ss-1)->currentMove != MOVE_NULL ? evaluate(pos)
|
||||
: -(ss-1)->staticEval + 2 * Eval::Tempo;
|
||||
|
||||
tte->save(posKey, VALUE_NONE, BOUND_NONE, DEPTH_NONE, MOVE_NONE, ss->staticEval, TT.generation());
|
||||
tte->save(posKey, VALUE_NONE, BOUND_NONE, DEPTH_NONE, MOVE_NONE,
|
||||
ss->staticEval, TT.generation());
|
||||
}
|
||||
|
||||
if (ss->skipEarlyPruning)
|
||||
|
|
@ -753,8 +757,8 @@ namespace {
|
|||
|
||||
// Step 9. ProbCut (skipped when in check)
|
||||
// If we have a very good capture (i.e. SEE > seeValues[captured_piece_type])
|
||||
// and a reduced search returns a value much above beta, we can (almost) safely
|
||||
// prune the previous move.
|
||||
// and a reduced search returns a value much above beta, we can (almost)
|
||||
// safely prune the previous move.
|
||||
if ( !PvNode
|
||||
&& depth >= 5 * ONE_PLY
|
||||
&& abs(beta) < VALUE_MATE_IN_MAX_PLY)
|
||||
|
|
@ -766,7 +770,7 @@ namespace {
|
|||
assert((ss-1)->currentMove != MOVE_NONE);
|
||||
assert((ss-1)->currentMove != MOVE_NULL);
|
||||
|
||||
MovePicker mp(pos, ttMove, thisThread->History, CounterMovesHistory, PieceValue[MG][pos.captured_piece_type()]);
|
||||
MovePicker mp(pos, ttMove, thisThread->history, PieceValue[MG][pos.captured_piece_type()]);
|
||||
CheckInfo ci(pos);
|
||||
|
||||
while ((move = mp.next_move()) != MOVE_NONE)
|
||||
|
|
@ -797,10 +801,11 @@ namespace {
|
|||
|
||||
moves_loop: // When in check search starts from here
|
||||
|
||||
Square prevMoveSq = to_sq((ss-1)->currentMove);
|
||||
Move countermove = thisThread->Countermoves[pos.piece_on(prevMoveSq)][prevMoveSq];
|
||||
Square prevSq = to_sq((ss-1)->currentMove);
|
||||
Move cm = thisThread->counterMoves[pos.piece_on(prevSq)][prevSq];
|
||||
const CounterMovesStats& cmh = CounterMovesHistory[pos.piece_on(prevSq)][prevSq];
|
||||
|
||||
MovePicker mp(pos, ttMove, depth, thisThread->History, CounterMovesHistory, countermove, ss);
|
||||
MovePicker mp(pos, ttMove, depth, thisThread->history, cmh, cm, ss);
|
||||
CheckInfo ci(pos);
|
||||
value = bestValue; // Workaround a bogus 'uninitialized' warning under gcc
|
||||
improving = ss->staticEval >= (ss-2)->staticEval
|
||||
|
|
@ -828,7 +833,8 @@ moves_loop: // When in check search starts from here
|
|||
// At root obey the "searchmoves" option and skip moves not listed in Root
|
||||
// Move List. As a consequence any illegal move is also skipped. In MultiPV
|
||||
// mode we also skip PV moves which have been already searched.
|
||||
if (RootNode && !std::count(thisThread->rootMoves.begin() + thisThread->PVIdx, thisThread->rootMoves.end(), move))
|
||||
if (RootNode && !std::count(thisThread->rootMoves.begin() + thisThread->PVIdx,
|
||||
thisThread->rootMoves.end(), move))
|
||||
continue;
|
||||
|
||||
ss->moveCount = ++moveCount;
|
||||
|
|
@ -894,11 +900,10 @@ moves_loop: // When in check search starts from here
|
|||
&& moveCount >= FutilityMoveCounts[improving][depth])
|
||||
continue;
|
||||
|
||||
// History Score Pruning
|
||||
// History based pruning
|
||||
if ( depth <= 3 * ONE_PLY
|
||||
&& thisThread->History[pos.moved_piece(move)][to_sq(move)] < VALUE_ZERO
|
||||
&& CounterMovesHistory[pos.piece_on(prevMoveSq)][prevMoveSq]
|
||||
[pos.moved_piece(move)][to_sq(move)] < VALUE_ZERO)
|
||||
&& thisThread->history[pos.moved_piece(move)][to_sq(move)] < VALUE_ZERO
|
||||
&& cmh[pos.moved_piece(move)][to_sq(move)] < VALUE_ZERO)
|
||||
continue;
|
||||
|
||||
predictedDepth = newDepth - reduction<PvNode>(improving, depth, moveCount);
|
||||
|
|
@ -945,15 +950,15 @@ moves_loop: // When in check search starts from here
|
|||
{
|
||||
ss->reduction = reduction<PvNode>(improving, depth, moveCount);
|
||||
|
||||
// Increase reduction for cut nodes and moves with a bad history
|
||||
if ( (!PvNode && cutNode)
|
||||
|| ( thisThread->History[pos.piece_on(to_sq(move))][to_sq(move)] < VALUE_ZERO
|
||||
&& CounterMovesHistory[pos.piece_on(prevMoveSq)][prevMoveSq]
|
||||
[pos.piece_on(to_sq(move))][to_sq(move)] <= VALUE_ZERO))
|
||||
|| ( thisThread->history[pos.piece_on(to_sq(move))][to_sq(move)] < VALUE_ZERO
|
||||
&& cmh[pos.piece_on(to_sq(move))][to_sq(move)] <= VALUE_ZERO))
|
||||
ss->reduction += ONE_PLY;
|
||||
|
||||
if ( thisThread->History[pos.piece_on(to_sq(move))][to_sq(move)] > VALUE_ZERO
|
||||
&& CounterMovesHistory[pos.piece_on(prevMoveSq)][prevMoveSq]
|
||||
[pos.piece_on(to_sq(move))][to_sq(move)] > VALUE_ZERO)
|
||||
// Decrease reduction for moves with a good history
|
||||
if ( thisThread->history[pos.piece_on(to_sq(move))][to_sq(move)] > VALUE_ZERO
|
||||
&& cmh[pos.piece_on(to_sq(move))][to_sq(move)] > VALUE_ZERO)
|
||||
ss->reduction = std::max(DEPTH_ZERO, ss->reduction - ONE_PLY);
|
||||
|
||||
// Decrease reduction for moves that escape a capture
|
||||
|
|
@ -1008,7 +1013,8 @@ moves_loop: // When in check search starts from here
|
|||
|
||||
if (RootNode)
|
||||
{
|
||||
RootMove& rm = *std::find(thisThread->rootMoves.begin(), thisThread->rootMoves.end(), move);
|
||||
RootMove& rm = *std::find(thisThread->rootMoves.begin(),
|
||||
thisThread->rootMoves.end(), move);
|
||||
|
||||
// PV move or new best move ?
|
||||
if (moveCount == 1 || value > alpha)
|
||||
|
|
@ -1087,16 +1093,17 @@ moves_loop: // When in check search starts from here
|
|||
update_stats(pos, ss, bestMove, depth, quietsSearched, quietCount);
|
||||
|
||||
// Bonus for prior countermove that caused the fail low
|
||||
else if (!bestMove)
|
||||
else if ( depth >= 3 * ONE_PLY
|
||||
&& !bestMove
|
||||
&& !inCheck
|
||||
&& !pos.captured_piece_type()
|
||||
&& is_ok((ss - 1)->currentMove)
|
||||
&& is_ok((ss - 2)->currentMove))
|
||||
{
|
||||
if (is_ok((ss - 2)->currentMove) && is_ok((ss - 1)->currentMove) && !pos.captured_piece_type() && !inCheck && depth>=3*ONE_PLY)
|
||||
{
|
||||
Value bonus = Value((depth / ONE_PLY) * (depth / ONE_PLY));
|
||||
Square prevSq = to_sq((ss - 1)->currentMove);
|
||||
Square prevPrevSq = to_sq((ss - 2)->currentMove);
|
||||
HistoryStats& flMoveCmh = CounterMovesHistory[pos.piece_on(prevPrevSq)][prevPrevSq];
|
||||
flMoveCmh.updateCMH(pos.piece_on(prevSq), prevSq, bonus);
|
||||
}
|
||||
Value bonus = Value((depth / ONE_PLY) * (depth / ONE_PLY));
|
||||
Square prevPrevSq = to_sq((ss - 2)->currentMove);
|
||||
CounterMovesStats& prevCmh = CounterMovesHistory[pos.piece_on(prevPrevSq)][prevPrevSq];
|
||||
prevCmh.update(pos.piece_on(prevSq), prevSq, bonus);
|
||||
}
|
||||
|
||||
tte->save(posKey, value_to_tt(bestValue, ss->ply),
|
||||
|
|
@ -1146,7 +1153,8 @@ moves_loop: // When in check search starts from here
|
|||
|
||||
// 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()];
|
||||
return ss->ply >= MAX_PLY && !InCheck ? evaluate(pos)
|
||||
: DrawValue[pos.side_to_move()];
|
||||
|
||||
assert(0 <= ss->ply && ss->ply < MAX_PLY);
|
||||
|
||||
|
|
@ -1194,7 +1202,8 @@ moves_loop: // When in check search starts from here
|
|||
}
|
||||
else
|
||||
ss->staticEval = bestValue =
|
||||
(ss-1)->currentMove != MOVE_NULL ? evaluate(pos) : -(ss-1)->staticEval + 2 * Eval::Tempo;
|
||||
(ss-1)->currentMove != MOVE_NULL ? evaluate(pos)
|
||||
: -(ss-1)->staticEval + 2 * Eval::Tempo;
|
||||
|
||||
// Stand pat. Return immediately if static value is at least beta
|
||||
if (bestValue >= beta)
|
||||
|
|
@ -1216,7 +1225,7 @@ moves_loop: // When in check search starts from here
|
|||
// to search the moves. Because the depth is <= 0 here, only captures,
|
||||
// queen promotions and checks (only if depth >= DEPTH_QS_CHECKS) will
|
||||
// be generated.
|
||||
MovePicker mp(pos, ttMove, depth, pos.this_thread()->History, CounterMovesHistory, to_sq((ss-1)->currentMove));
|
||||
MovePicker mp(pos, ttMove, depth, pos.this_thread()->history, to_sq((ss-1)->currentMove));
|
||||
CheckInfo ci(pos);
|
||||
|
||||
// Loop through the moves until no moves remain or a beta cutoff occurs
|
||||
|
|
@ -1289,7 +1298,7 @@ moves_loop: // When in check search starts from here
|
|||
if (PvNode) // Update pv even in fail-high case
|
||||
update_pv(ss->pv, move, (ss+1)->pv);
|
||||
|
||||
if (PvNode && value < beta) // Update alpha here! Always alpha < beta
|
||||
if (PvNode && value < beta) // Update alpha here!
|
||||
{
|
||||
alpha = value;
|
||||
bestMove = move;
|
||||
|
|
@ -1370,32 +1379,34 @@ moves_loop: // When in check search starts from here
|
|||
Value bonus = Value((depth / ONE_PLY) * (depth / ONE_PLY));
|
||||
|
||||
Square prevSq = to_sq((ss-1)->currentMove);
|
||||
HistoryStats& cmh = CounterMovesHistory[pos.piece_on(prevSq)][prevSq];
|
||||
CounterMovesStats& cmh = CounterMovesHistory[pos.piece_on(prevSq)][prevSq];
|
||||
Thread* thisThread = pos.this_thread();
|
||||
|
||||
thisThread->History.updateH(pos.moved_piece(move), to_sq(move), bonus);
|
||||
thisThread->history.update(pos.moved_piece(move), to_sq(move), bonus);
|
||||
|
||||
if (is_ok((ss-1)->currentMove))
|
||||
{
|
||||
thisThread->Countermoves.update(pos.piece_on(prevSq), prevSq, move);
|
||||
cmh.updateCMH(pos.moved_piece(move), to_sq(move), bonus);
|
||||
thisThread->counterMoves.update(pos.piece_on(prevSq), prevSq, move);
|
||||
cmh.update(pos.moved_piece(move), to_sq(move), bonus);
|
||||
}
|
||||
|
||||
// Decrease all the other played quiet moves
|
||||
for (int i = 0; i < quietsCnt; ++i)
|
||||
{
|
||||
thisThread->History.updateH(pos.moved_piece(quiets[i]), to_sq(quiets[i]), -bonus);
|
||||
thisThread->history.update(pos.moved_piece(quiets[i]), to_sq(quiets[i]), -bonus);
|
||||
|
||||
if (is_ok((ss-1)->currentMove))
|
||||
cmh.updateCMH(pos.moved_piece(quiets[i]), to_sq(quiets[i]), -bonus);
|
||||
cmh.update(pos.moved_piece(quiets[i]), to_sq(quiets[i]), -bonus);
|
||||
}
|
||||
|
||||
// Extra penalty for PV move in previous ply when it gets refuted
|
||||
if (is_ok((ss-2)->currentMove) && (ss-1)->moveCount == 1 && !pos.captured_piece_type())
|
||||
// Extra penalty for TT move in previous ply when it gets refuted
|
||||
if ( (ss-1)->moveCount == 1
|
||||
&& !pos.captured_piece_type()
|
||||
&& is_ok((ss-2)->currentMove))
|
||||
{
|
||||
Square prevPrevSq = to_sq((ss-2)->currentMove);
|
||||
HistoryStats& ttMoveCmh = CounterMovesHistory[pos.piece_on(prevPrevSq)][prevPrevSq];
|
||||
ttMoveCmh.updateCMH(pos.piece_on(prevSq), prevSq, -bonus - 2 * depth / ONE_PLY - 1);
|
||||
CounterMovesStats& prevCmh = CounterMovesHistory[pos.piece_on(prevPrevSq)][prevPrevSq];
|
||||
prevCmh.update(pos.piece_on(prevSq), prevSq, -bonus - 2 * depth / ONE_PLY - 1);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -91,6 +91,8 @@ Thread::Thread() /* : splitPoints() */ { // Initialization of non POD broken in
|
|||
|
||||
searching = false;
|
||||
maxPly = 0;
|
||||
history.clear();
|
||||
counterMoves.clear();
|
||||
idx = Threads.size(); // Starts from 0
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -76,10 +76,10 @@ struct Thread : public ThreadBase {
|
|||
|
||||
Position rootPos;
|
||||
Search::RootMoveVector rootMoves;
|
||||
Depth rootDepth;
|
||||
Search::Stack stack[MAX_PLY+4];
|
||||
HistoryStats History;
|
||||
MovesStats Countermoves;
|
||||
Depth depth;
|
||||
HistoryStats history;
|
||||
MovesStats counterMoves;
|
||||
};
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -58,7 +58,6 @@ void init(OptionsMap& o) {
|
|||
|
||||
o["Write Debug Log"] << Option(false, on_logger);
|
||||
o["Contempt"] << Option(0, -100, 100);
|
||||
o["Min Split Depth"] << Option(5, 0, 12, on_threads);
|
||||
o["Threads"] << Option(1, 1, MAX_THREADS, on_threads);
|
||||
o["Hash"] << Option(16, 1, MaxHashMB, on_hash_size);
|
||||
o["Clear Hash"] << Option(on_clear_hash);
|
||||
|
|
|
|||
Loading…
Reference in New Issue