/*
Stockfish, a UCI chess playing engine derived from Glaurung 2.1
Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
- Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+ Copyright (C) 2008-2013 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
void id_loop(Position& pos);
Value value_to_tt(Value v, int ply);
Value value_from_tt(Value v, int ply);
- bool check_is_dangerous(Position& pos, Move move, Value futilityBase, Value beta);
+ bool check_is_dangerous(const Position& pos, Move move, Value futilityBase, Value beta);
bool allows(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);
static PolyglotBook book; // Defined static to initialize the PRNG only once
RootColor = RootPos.side_to_move();
- TimeMgr.init(Limits, RootPos.startpos_ply_counter(), RootColor);
+ TimeMgr.init(Limits, RootPos.game_ply(), RootColor);
if (RootMoves.empty())
{
// we want to keep the same order for all the moves but the new
// PV that goes to the front. Note that in case of MultiPV search
// the already searched PV lines are preserved.
- sort<RootMove>(RootMoves.begin() + PVIdx, RootMoves.end());
+ std::stable_sort(RootMoves.begin() + PVIdx, RootMoves.end());
// Write PV back to transposition table in case the relevant
// entries have been overwritten during the search.
}
// Sort the PV lines searched so far and update the GUI
- sort<RootMove>(RootMoves.begin(), RootMoves.begin() + PVIdx + 1);
+ std::stable_sort(RootMoves.begin(), RootMoves.begin() + PVIdx + 1);
if (PVIdx + 1 == PVSize || Time::now() - SearchTime > 3000)
sync_cout << uci_pv(pos, depth, alpha, beta) << sync_endl;
Move movesSearched[64];
StateInfo st;
const TTEntry *tte;
- SplitPoint* sp;
+ SplitPoint* splitPoint;
Key posKey;
Move ttMove, move, excludedMove, bestMove, threatMove;
Depth ext, newDepth;
if (SpNode)
{
- sp = ss->sp;
- bestMove = sp->bestMove;
- threatMove = sp->threatMove;
- bestValue = sp->bestValue;
+ splitPoint = ss->splitPoint;
+ bestMove = splitPoint->bestMove;
+ threatMove = splitPoint->threatMove;
+ bestValue = splitPoint->bestValue;
tte = NULL;
ttMove = excludedMove = MOVE_NONE;
ttValue = VALUE_NONE;
- assert(sp->bestValue > -VALUE_INFINITE && sp->moveCount > 0);
+ assert(splitPoint->bestValue > -VALUE_INFINITE && splitPoint->moveCount > 0);
goto split_point_start;
}
else if (tte)
{
// Never assume anything on values stored in TT
- if ( (ss->staticEval = eval = tte->static_value()) == VALUE_NONE
- ||(ss->evalMargin = tte->static_value_margin()) == VALUE_NONE)
+ if ( (ss->staticEval = eval = tte->eval_value()) == VALUE_NONE
+ ||(ss->evalMargin = tte->eval_margin()) == VALUE_NONE)
eval = ss->staticEval = evaluate(pos, ss->evalMargin);
// Can ttValue be used as a better position evaluation?
if (!pos.pl_move_is_legal(move, ci.pinned))
continue;
- moveCount = ++sp->moveCount;
- sp->mutex.unlock();
+ moveCount = ++splitPoint->moveCount;
+ splitPoint->mutex.unlock();
}
else
moveCount++;
newDepth = depth - ONE_PLY + ext;
// Step 13. Futility pruning (is omitted in PV nodes)
- if ( !PvNode
- && !captureOrPromotion
+ if ( !captureOrPromotion
&& !inCheck
&& !dangerous
- && move != ttMove
- && (bestValue > VALUE_MATED_IN_MAX_PLY || ( bestValue == -VALUE_INFINITE
- && alpha > VALUE_MATED_IN_MAX_PLY)))
+ && move != ttMove)
{
// Move count based pruning
- if ( depth < 16 * ONE_PLY
+ if ( !PvNode
+ && depth < 16 * ONE_PLY
&& moveCount >= FutilityMoveCounts[depth]
&& (!threatMove || !refutes(pos, move, threatMove)))
{
if (SpNode)
- sp->mutex.lock();
+ splitPoint->mutex.lock();
continue;
}
futilityValue = ss->staticEval + ss->evalMargin + futility_margin(predictedDepth, moveCount)
+ Gain[pos.piece_moved(move)][to_sq(move)];
- if (futilityValue < beta)
+ if (!PvNode && futilityValue < beta)
{
if (SpNode)
- sp->mutex.lock();
+ splitPoint->mutex.lock();
continue;
}
&& pos.see_sign(move) < 0)
{
if (SpNode)
- sp->mutex.lock();
+ splitPoint->mutex.lock();
continue;
}
{
ss->reduction = reduction<PvNode>(depth, moveCount);
Depth d = std::max(newDepth - ss->reduction, ONE_PLY);
- alpha = SpNode ? sp->alpha : alpha;
+ if (SpNode)
+ alpha = splitPoint->alpha;
value = -search<NonPV>(pos, ss+1, -(alpha+1), -alpha, d);
// Step 16. Full depth search, when LMR is skipped or fails high
if (doFullDepthSearch)
{
- alpha = SpNode ? sp->alpha : alpha;
+ if (SpNode)
+ alpha = splitPoint->alpha;
+
value = newDepth < ONE_PLY ?
givesCheck ? -qsearch<NonPV, true>(pos, ss+1, -(alpha+1), -alpha, DEPTH_ZERO)
: -qsearch<NonPV, false>(pos, ss+1, -(alpha+1), -alpha, DEPTH_ZERO)
// Step 18. Check for new best move
if (SpNode)
{
- sp->mutex.lock();
- bestValue = sp->bestValue;
- alpha = sp->alpha;
+ splitPoint->mutex.lock();
+ bestValue = splitPoint->bestValue;
+ alpha = splitPoint->alpha;
}
// Finished searching the move. If Signals.stop is true, the search
if (value > bestValue)
{
- bestValue = SpNode ? sp->bestValue = value : value;
+ bestValue = SpNode ? splitPoint->bestValue = value : value;
if (value > alpha)
{
- bestMove = SpNode ? sp->bestMove = move : move;
+ bestMove = SpNode ? splitPoint->bestMove = move : move;
if (PvNode && value < beta) // Update alpha! Always alpha < beta
- alpha = SpNode ? sp->alpha = value : value;
+ alpha = SpNode ? splitPoint->alpha = value : value;
else
{
assert(value >= beta); // Fail high
if (SpNode)
- sp->cutoff = true;
+ splitPoint->cutoff = true;
break;
}
// Step 19. Check for splitting the search
if ( !SpNode
&& depth >= Threads.minimumSplitDepth
- && Threads.slave_available(thisThread)
+ && Threads.available_slave(thisThread)
&& thisThread->splitPointsSize < MAX_SPLITPOINTS_PER_THREAD)
{
assert(bestValue < beta);
if (tte)
{
// Never assume anything on values stored in TT
- if ( (ss->staticEval = bestValue = tte->static_value()) == VALUE_NONE
- ||(ss->evalMargin = tte->static_value_margin()) == VALUE_NONE)
+ if ( (ss->staticEval = bestValue = tte->eval_value()) == VALUE_NONE
+ ||(ss->evalMargin = tte->eval_margin()) == VALUE_NONE)
ss->staticEval = bestValue = evaluate(pos, ss->evalMargin);
}
else
// check_is_dangerous() tests if a checking move can be pruned in qsearch()
- bool check_is_dangerous(Position& pos, Move move, Value futilityBase, Value beta)
+ bool check_is_dangerous(const Position& pos, Move move, Value futilityBase, Value beta)
{
Piece pc = pos.piece_moved(move);
Square from = from_sq(move);
Position pos(*sp->pos, this);
memcpy(ss, sp->ss - 1, 4 * sizeof(Stack));
- (ss+1)->sp = sp;
+ (ss+1)->splitPoint = sp;
sp->mutex.lock();
- assert(sp->slavesPositions[idx] == NULL);
+ assert(activePosition == NULL);
- sp->slavesPositions[idx] = &pos;
+ activePosition = &pos;
switch (sp->nodeType) {
case Root:
assert(searching);
searching = false;
- sp->slavesPositions[idx] = NULL;
+ activePosition = NULL;
sp->slavesMask &= ~(1ULL << idx);
sp->nodes += pos.nodes_searched();
nodes = RootPos.nodes_searched();
// Loop across all split points and sum accumulated SplitPoint nodes plus
- // all the currently active slaves positions.
+ // all the currently active positions nodes.
for (size_t i = 0; i < Threads.size(); i++)
for (int j = 0; j < Threads[i]->splitPointsSize; j++)
{
Bitboard sm = sp.slavesMask;
while (sm)
{
- Position* pos = sp.slavesPositions[pop_lsb(&sm)];
- nodes += pos ? pos->nodes_searched() : 0;
+ Position* pos = Threads[pop_lsb(&sm)]->activePosition;
+ if (pos)
+ nodes += pos->nodes_searched();
}
sp.mutex.unlock();
projects / stockfish / blobdiff