#include <fstream>
#include <iostream>
#include <sstream>
+#include <vector>
#include "book.h"
#include "evaluate.h"
void init_threads();
void exit_threads();
- int active_threads() const { return ActiveThreads; }
- void set_active_threads(int newActiveThreads) { ActiveThreads = newActiveThreads; }
+ int min_split_depth() const { return minimumSplitDepth; }
+ int active_threads() const { return activeThreads; }
+ void set_active_threads(int cnt) { activeThreads = cnt; }
+ void read_uci_options();
bool available_thread_exists(int master) const;
bool thread_is_available(int slave, int master) const;
- bool thread_should_stop(int threadID) const;
+ bool cutoff_at_splitpoint(int threadID) const;
void wake_sleeping_thread(int threadID);
void idle_loop(int threadID, SplitPoint* sp);
Depth depth, Move threatMove, bool mateThreat, int moveCount, MovePicker* mp, bool pvNode);
private:
- int ActiveThreads;
- volatile bool AllThreadsShouldExit;
+ Depth minimumSplitDepth;
+ int maxThreadsPerSplitPoint;
+ bool useSleepingThreads;
+ int activeThreads;
+ volatile bool allThreadsShouldExit;
Thread threads[MAX_THREADS];
- Lock MPLock;
- WaitCondition WaitCond[MAX_THREADS];
+ Lock mpLock, sleepLock[MAX_THREADS];
+ WaitCondition sleepCond[MAX_THREADS];
};
- // RootMove struct is used for moves at the root at the tree. For each
- // root move, we store a score, a node count, and a PV (really a refutation
- // in the case of moves which fail low).
+ // RootMove struct is used for moves at the root at the tree. For each root
+ // move, we store two scores, a node count, and a PV (really a refutation
+ // in the case of moves which fail low). Value pv_score is normally set at
+ // -VALUE_INFINITE for all non-pv moves, while non_pv_score is computed
+ // according to the order in which moves are returned by MovePicker.
struct RootMove {
- RootMove() : mp_score(0), nodes(0) {}
+ RootMove();
+ RootMove(const RootMove& rm) { *this = rm; }
+ RootMove& operator=(const RootMove& rm);
// RootMove::operator<() is the comparison function used when
// sorting the moves. A move m1 is considered to be better
- // than a move m2 if it has a higher score, or if the moves
- // have equal score but m1 has the higher beta cut-off count.
+ // than a move m2 if it has an higher pv_score, or if it has
+ // equal pv_score but m1 has the higher non_pv_score. In this
+ // way we are guaranteed that PV moves are always sorted as first.
bool operator<(const RootMove& m) const {
-
- return score != m.score ? score < m.score : mp_score <= m.mp_score;
+ return pv_score != m.pv_score ? pv_score < m.pv_score
+ : non_pv_score <= m.non_pv_score;
}
+ void set_pv(const Move newPv[]);
- Move move;
- Value score;
- int mp_score;
int64_t nodes;
+ Value pv_score;
+ Value non_pv_score;
+ Move move;
Move pv[PLY_MAX_PLUS_2];
};
+ RootMove::RootMove() {
- // The RootMoveList class is essentially an array of RootMove objects, with
- // a handful of methods for accessing the data in the individual moves.
+ nodes = 0;
+ pv_score = non_pv_score = -VALUE_INFINITE;
+ move = pv[0] = MOVE_NONE;
+ }
- class RootMoveList {
+ RootMove& RootMove::operator=(const RootMove& rm) {
- public:
- RootMoveList(Position& pos, Move searchMoves[]);
+ nodes = rm.nodes;
+ pv_score = rm.pv_score;
+ non_pv_score = rm.non_pv_score;
+ move = rm.move;
+ set_pv(rm.pv); // Skip costly full pv[] copy
+ return *this;
+ }
- Move move(int moveNum) const { return moves[moveNum].move; }
- Move move_pv(int moveNum, int i) const { return moves[moveNum].pv[i]; }
- int move_count() const { return count; }
- Value move_score(int moveNum) const { return moves[moveNum].score; }
- int64_t move_nodes(int moveNum) const { return moves[moveNum].nodes; }
- void add_move_nodes(int moveNum, int64_t nodes) { moves[moveNum].nodes += nodes; }
- void set_move_score(int moveNum, Value score) { moves[moveNum].score = score; }
+ void RootMove::set_pv(const Move newPv[]) {
- void set_move_pv(int moveNum, const Move pv[]);
- void score_moves(const Position& pos);
- void sort();
- void sort_multipv(int n);
+ Move* p = pv;
- private:
- RootMove moves[MOVES_MAX];
- int count;
+ do *p++ = *newPv; while (*newPv++ != MOVE_NONE);
+ }
+
+
+ // RootMoveList struct is essentially a std::vector<> of RootMove objects,
+ // with an handful of methods above the standard ones.
+
+ struct RootMoveList : public std::vector<RootMove> {
+
+ typedef std::vector<RootMove> Base;
+
+ RootMoveList(Position& pos, Move searchMoves[]);
+ void set_non_pv_scores(const Position& pos);
+
+ void sort() { insertion_sort<RootMove, Base::iterator>(begin(), end()); }
+ void sort_multipv(int n) { insertion_sort<RootMove, Base::iterator>(begin(), begin() + n); }
};
bool UseLogFile;
std::ofstream LogFile;
- // Multi-threads related variables
- Depth MinimumSplitDepth;
- int MaxThreadsPerSplitPoint;
- bool UseSleepingMaster;
+ // Multi-threads manager object
ThreadsManager ThreadsMgr;
// Node counters, used only by thread[0] but try to keep in different cache
template <NodeType PvNode>
Depth extension(const Position& pos, Move m, bool captureOrPromotion, bool moveIsCheck, bool singleEvasion, bool mateThreat, bool* dangerous);
+ bool check_is_dangerous(Position &pos, Move move, Value futilityBase, Value beta, Value *bValue);
bool connected_moves(const Position& pos, Move m1, Move m2);
bool value_is_mate(Value value);
Value value_to_tt(Value v, int ply);
// Init reductions array
for (hd = 1; hd < 64; hd++) for (mc = 1; mc < 64; mc++)
{
- double pvRed = 0.33 + log(double(hd)) * log(double(mc)) / 4.5;
+ double pvRed = log(double(hd)) * log(double(mc)) / 3.0;
double nonPVRed = 0.33 + log(double(hd)) * log(double(mc)) / 2.25;
ReductionMatrix[PV][hd][mc] = (int8_t) ( pvRed >= 1.0 ? floor( pvRed * int(ONE_PLY)) : 0);
ReductionMatrix[NonPV][hd][mc] = (int8_t) (nonPVRed >= 1.0 ? floor(nonPVRed * int(ONE_PLY)) : 0);
PawnEndgameExtension[0] = Options["Pawn Endgame Extension (non-PV nodes)"].value<Depth>();
MateThreatExtension[1] = Options["Mate Threat Extension (PV nodes)"].value<Depth>();
MateThreatExtension[0] = Options["Mate Threat Extension (non-PV nodes)"].value<Depth>();
-
- MinimumSplitDepth = Options["Minimum Split Depth"].value<int>() * ONE_PLY;
- MaxThreadsPerSplitPoint = Options["Maximum Number of Threads per Split Point"].value<int>();
- MultiPV = Options["MultiPV"].value<int>();
- UseLogFile = Options["Use Search Log"].value<bool>();
- UseSleepingMaster = Options["Use Sleeping Master"].value<bool>();
+ MultiPV = Options["MultiPV"].value<int>();
+ UseLogFile = Options["Use Search Log"].value<bool>();
if (UseLogFile)
LogFile.open(Options["Search Log Filename"].value<std::string>().c_str(), std::ios::out | std::ios::app);
read_weights(pos.side_to_move());
// Set the number of active threads
- int newActiveThreads = Options["Threads"].value<int>();
- if (newActiveThreads != ThreadsMgr.active_threads())
- {
- ThreadsMgr.set_active_threads(newActiveThreads);
- init_eval(ThreadsMgr.active_threads());
- }
+ ThreadsMgr.read_uci_options();
+ init_eval(ThreadsMgr.active_threads());
+
+ // Wake up needed threads
+ for (int i = 1; i < ThreadsMgr.active_threads(); i++)
+ ThreadsMgr.wake_sleeping_thread(i);
// Set thinking time
int myTime = time[pos.side_to_move()];
if (UseLogFile)
LogFile.close();
+ // This makes all the threads to go to sleep
+ ThreadsMgr.set_active_threads(1);
+
return !Quit;
}
RootMoveList rml(pos, searchMoves);
// Handle special case of searching on a mate/stale position
- if (rml.move_count() == 0)
+ if (rml.size() == 0)
{
if (PonderSearch)
wait_for_stop_or_ponderhit();
cout << set960(pos.is_chess960()) // Is enough to set once at the beginning
<< "info depth " << 1
<< "\ninfo depth " << 1
- << " score " << value_to_uci(rml.move_score(0))
+ << " score " << value_to_uci(rml[0].pv_score)
<< " time " << current_search_time()
<< " nodes " << pos.nodes_searched()
<< " nps " << nps(pos)
- << " pv " << rml.move(0) << "\n";
+ << " pv " << rml[0].move << "\n";
// Initialize
TT.new_search();
H.clear();
init_ss_array(ss, PLY_MAX_PLUS_2);
pv[0] = pv[1] = MOVE_NONE;
- ValueByIteration[1] = rml.move_score(0);
+ ValueByIteration[1] = rml[0].pv_score;
Iteration = 1;
// Is one move significantly better than others after initial scoring ?
- if ( rml.move_count() == 1
- || rml.move_score(0) > rml.move_score(1) + EasyMoveMargin)
- EasyMove = rml.move(0);
+ if ( rml.size() == 1
+ || rml[0].pv_score > rml[1].pv_score + EasyMoveMargin)
+ EasyMove = rml[0].move;
// Iterative deepening loop
while (Iteration < PLY_MAX)
// Stop search early if there is only a single legal move,
// we search up to Iteration 6 anyway to get a proper score.
- if (Iteration >= 6 && rml.move_count() == 1)
+ if (Iteration >= 6 && rml.size() == 1)
stopSearch = true;
// Stop search early when the last two iterations returned a mate score
// Stop search early if one move seems to be much better than the others
if ( Iteration >= 8
&& EasyMove == pv[0]
- && ( ( rml.move_nodes(0) > (pos.nodes_searched() * 85) / 100
+ && ( ( rml[0].nodes > (pos.nodes_searched() * 85) / 100
&& current_search_time() > TimeMgr.available_time() / 16)
- ||( rml.move_nodes(0) > (pos.nodes_searched() * 98) / 100
+ ||( rml[0].nodes > (pos.nodes_searched() * 98) / 100
&& current_search_time() > TimeMgr.available_time() / 32)))
stopSearch = true;
<< " time " << current_search_time() << endl;
// Print the best move and the ponder move to the standard output
- if (pv[0] == MOVE_NONE)
+ if (pv[0] == MOVE_NONE || MultiPV > 1)
{
- pv[0] = rml.move(0);
+ pv[0] = rml[0].move;
pv[1] = MOVE_NONE;
}
<< move_to_san(pos, pv[1]) // Works also with MOVE_NONE
<< endl;
}
- return rml.move_score(0);
+ return rml[0].pv_score;
}
while (1)
{
// Sort the moves before to (re)search
- rml.score_moves(pos);
+ rml.set_non_pv_scores(pos);
rml.sort();
// Step 10. Loop through all moves in the root move list
- for (int i = 0; i < rml.move_count() && !AbortSearch; i++)
+ for (int i = 0; i < (int)rml.size() && !AbortSearch; i++)
{
// This is used by time management
FirstRootMove = (i == 0);
// Pick the next root move, and print the move and the move number to
// the standard output.
- move = ss->currentMove = rml.move(i);
+ move = ss->currentMove = rml[i].move;
if (current_search_time() >= 1000)
cout << "info currmove " << move
// Step extra. Fail high loop
// If move fails high, we research with bigger window until we are not failing
// high anymore.
- value = - VALUE_INFINITE;
+ value = -VALUE_INFINITE;
while (1)
{
value = -search<NonPV>(pos, ss+1, -(alpha+1), -alpha, newDepth-ss->reduction, 1);
doFullDepthSearch = (value > alpha);
}
-
- // The move failed high, but if reduction is very big we could
- // face a false positive, retry with a less aggressive reduction,
- // if the move fails high again then go with full depth search.
- if (doFullDepthSearch && ss->reduction > 2 * ONE_PLY)
- {
- assert(newDepth - ONE_PLY >= ONE_PLY);
-
- ss->reduction = ONE_PLY;
- value = -search<NonPV>(pos, ss+1, -(alpha+1), -alpha, newDepth-ss->reduction, 1);
- doFullDepthSearch = (value > alpha);
- }
ss->reduction = DEPTH_ZERO; // Restore original reduction
}
// We are failing high and going to do a research. It's important to update
// the score before research in case we run out of time while researching.
- rml.set_move_score(i, value);
+ rml[i].pv_score = value;
ss->bestMove = move;
extract_pv_from_tt(pos, move, pv);
- rml.set_move_pv(i, pv);
+ rml[i].set_pv(pv);
// Print information to the standard output
print_pv_info(pos, pv, alpha, beta, value);
break;
// Remember searched nodes counts for this move
- rml.add_move_nodes(i, pos.nodes_searched() - nodes);
+ rml[i].nodes += pos.nodes_searched() - nodes;
assert(value >= -VALUE_INFINITE && value <= VALUE_INFINITE);
assert(value < beta);
// Step 17. Check for new best move
if (value <= alpha && i >= MultiPV)
- rml.set_move_score(i, -VALUE_INFINITE);
+ rml[i].pv_score = -VALUE_INFINITE;
else
{
// PV move or new best move!
// Update PV
- rml.set_move_score(i, value);
+ rml[i].pv_score = value;
ss->bestMove = move;
extract_pv_from_tt(pos, move, pv);
- rml.set_move_pv(i, pv);
+ rml[i].set_pv(pv);
if (MultiPV == 1)
{
else // MultiPV > 1
{
rml.sort_multipv(i);
- for (int j = 0; j < Min(MultiPV, rml.move_count()); j++)
+ for (int j = 0; j < Min(MultiPV, (int)rml.size()); j++)
{
cout << "info multipv " << j + 1
- << " score " << value_to_uci(rml.move_score(j))
+ << " score " << value_to_uci(rml[j].pv_score)
<< " depth " << (j <= i ? Iteration : Iteration - 1)
<< " time " << current_search_time()
<< " nodes " << pos.nodes_searched()
<< " nps " << nps(pos)
<< " pv ";
- for (int k = 0; rml.move_pv(j, k) != MOVE_NONE && k < PLY_MAX; k++)
- cout << rml.move_pv(j, k) << " ";
+ for (int k = 0; rml[j].pv[k] != MOVE_NONE && k < PLY_MAX; k++)
+ cout << rml[j].pv[k] << " ";
cout << endl;
}
- alpha = rml.move_score(Min(i, MultiPV - 1));
+ alpha = rml[Min(i, MultiPV - 1)].pv_score;
}
} // PV move or new best move
threatMove = sp->threatMove;
mateThreat = sp->mateThreat;
goto split_point_start;
- } else {} // Hack to fix icc's "statement is unreachable" warning
+ }
+ else {} // Hack to fix icc's "statement is unreachable" warning
// Step 1. Initialize node and poll. Polling can abort search
ss->currentMove = ss->bestMove = threatMove = MOVE_NONE;
}
// Step 2. Check for aborted search and immediate draw
- if ( AbortSearch || ThreadsMgr.thread_should_stop(threadID)
- || pos.is_draw() || ply >= PLY_MAX - 1)
+ if ( AbortSearch
+ || ThreadsMgr.cutoff_at_splitpoint(threadID)
+ || pos.is_draw()
+ || ply >= PLY_MAX - 1)
return VALUE_DRAW;
// Step 3. Mate distance pruning
&& !isCheck
&& refinedValue < beta - razor_margin(depth)
&& ttMove == MOVE_NONE
- && (ss-1)->currentMove != MOVE_NULL
&& !value_is_mate(beta)
&& !pos.has_pawn_on_7th(pos.side_to_move()))
{
threatMove = (ss+1)->bestMove;
if ( depth < ThreatDepth
&& (ss-1)->reduction
+ && threatMove != MOVE_NONE
&& connected_moves(pos, (ss-1)->currentMove, threatMove))
return beta - 1;
}
// Loop through all legal moves until no moves remain or a beta cutoff occurs
while ( bestValue < beta
&& (move = mp.get_next_move()) != MOVE_NONE
- && !ThreadsMgr.thread_should_stop(threadID))
+ && !ThreadsMgr.cutoff_at_splitpoint(threadID))
{
assert(move_is_ok(move));
continue;
}
+
+ // Prune moves with negative SEE at low depths
+ if ( predictedDepth < 2 * ONE_PLY
+ && bestValue > value_mated_in(PLY_MAX)
+ && pos.see_sign(move) < 0)
+ {
+ if (SpNode)
+ lock_grab(&(sp->lock));
+
+ continue;
+ }
}
// Step 13. Make the move
// Step extra. pv search (only in PV nodes)
// The first move in list is the expected PV
- if (!SpNode && PvNode && moveCount == 1)
+ if (PvNode && moveCount == 1)
value = -search<PV>(pos, ss+1, -beta, -alpha, newDepth, ply+1);
else
{
&& !captureOrPromotion
&& !dangerous
&& !move_is_castle(move)
- && !(ss->killers[0] == move || ss->killers[1] == move))
+ && ss->killers[0] != move
+ && ss->killers[1] != move)
{
ss->reduction = reduction<PvNode>(depth, moveCount);
+
if (ss->reduction)
{
alpha = SpNode ? sp->alpha : alpha;
doFullDepthSearch = (value > alpha);
}
-
- // The move failed high, but if reduction is very big we could
- // face a false positive, retry with a less aggressive reduction,
- // if the move fails high again then go with full depth search.
- if (doFullDepthSearch && ss->reduction > 2 * ONE_PLY)
- {
- assert(newDepth - ONE_PLY >= ONE_PLY);
-
- ss->reduction = ONE_PLY;
- alpha = SpNode ? sp->alpha : alpha;
- value = -search<NonPV>(pos, ss+1, -(alpha+1), -alpha, newDepth-ss->reduction, ply+1);
- doFullDepthSearch = (value > alpha);
- }
ss->reduction = DEPTH_ZERO; // Restore original reduction
}
alpha = sp->alpha;
}
- if (value > bestValue && !(SpNode && ThreadsMgr.thread_should_stop(threadID)))
+ if (value > bestValue && !(SpNode && ThreadsMgr.cutoff_at_splitpoint(threadID)))
{
bestValue = value;
if (value > alpha)
{
- if (SpNode && (!PvNode || value >= beta))
- sp->stopRequest = true;
-
if (PvNode && value < beta) // We want always alpha < beta
{
alpha = value;
+
if (SpNode)
sp->alpha = value;
}
+ else if (SpNode)
+ sp->betaCutoff = true;
if (value == value_mate_in(ply + 1))
ss->mateKiller = move;
// Step 18. Check for split
if ( !SpNode
- && depth >= MinimumSplitDepth
+ && depth >= ThreadsMgr.min_split_depth()
&& ThreadsMgr.active_threads() > 1
&& bestValue < beta
&& ThreadsMgr.available_thread_exists(threadID)
&& !AbortSearch
- && !ThreadsMgr.thread_should_stop(threadID)
+ && !ThreadsMgr.cutoff_at_splitpoint(threadID)
&& Iteration <= 99)
ThreadsMgr.split<FakeSplit>(pos, ss, ply, &alpha, beta, &bestValue, depth,
threatMove, mateThreat, moveCount, &mp, PvNode);
// Step 20. Update tables
// If the search is not aborted, update the transposition table,
// history counters, and killer moves.
- if (!SpNode && !AbortSearch && !ThreadsMgr.thread_should_stop(threadID))
+ if (!SpNode && !AbortSearch && !ThreadsMgr.cutoff_at_splitpoint(threadID))
{
move = bestValue <= oldAlpha ? MOVE_NONE : ss->bestMove;
vt = bestValue <= oldAlpha ? VALUE_TYPE_UPPER
return bestValue;
}
-
// qsearch() is the quiescence search function, which is called by the main
// search function when the remaining depth is zero (or, to be more precise,
// less than ONE_PLY).
StateInfo st;
Move ttMove, move;
Value bestValue, value, evalMargin, futilityValue, futilityBase;
- bool isCheck, deepChecks, enoughMaterial, moveIsCheck, evasionPrunable;
+ bool isCheck, enoughMaterial, moveIsCheck, evasionPrunable;
const TTEntry* tte;
+ Depth ttDepth;
Value oldAlpha = alpha;
ss->bestMove = ss->currentMove = MOVE_NONE;
if (pos.is_draw() || ply >= PLY_MAX - 1)
return VALUE_DRAW;
+ // 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
+ // only two types of depth in TT: DEPTH_QS_CHECKS or DEPTH_QS_NO_CHECKS.
+ isCheck = pos.is_check();
+ ttDepth = (isCheck || depth >= DEPTH_QS_CHECKS ? DEPTH_QS_CHECKS : DEPTH_QS_NO_CHECKS);
+
// Transposition table lookup. At PV nodes, we don't use the TT for
// pruning, but only for move ordering.
tte = TT.retrieve(pos.get_key());
ttMove = (tte ? tte->move() : MOVE_NONE);
- if (!PvNode && tte && ok_to_use_TT(tte, depth, beta, ply))
+ if (!PvNode && tte && ok_to_use_TT(tte, ttDepth, beta, ply))
{
ss->bestMove = ttMove; // Can be MOVE_NONE
return value_from_tt(tte->value(), ply);
}
- isCheck = pos.is_check();
-
// Evaluate the position statically
if (isCheck)
{
bestValue = futilityBase = -VALUE_INFINITE;
ss->eval = evalMargin = VALUE_NONE;
- deepChecks = enoughMaterial = false;
+ enoughMaterial = false;
}
else
{
if (PvNode && bestValue > alpha)
alpha = bestValue;
- // If we are near beta then try to get a cutoff pushing checks a bit further
- deepChecks = (depth == -ONE_PLY && bestValue >= beta - PawnValueMidgame / 8);
-
// Futility pruning parameters, not needed when in check
futilityBase = ss->eval + evalMargin + FutilityMarginQS;
enoughMaterial = pos.non_pawn_material(pos.side_to_move()) > RookValueMidgame;
// Initialize a MovePicker object for the current position, and prepare
// to search the moves. Because the depth is <= 0 here, only captures,
- // queen promotions and checks (only if depth == 0 or depth == -ONE_PLY
- // and we are near beta) will be generated.
- MovePicker mp = MovePicker(pos, ttMove, deepChecks ? DEPTH_ZERO : depth, H);
+ // queen promotions and checks (only if depth >= DEPTH_QS_CHECKS) will
+ // be generated.
+ MovePicker mp(pos, ttMove, depth, H);
CheckInfo ci(pos);
// Loop through the moves until no moves remain or a beta cutoff occurs
&& pos.see_sign(move) < 0)
continue;
+ // Don't search useless checks
+ if ( !PvNode
+ && !isCheck
+ && moveIsCheck
+ && move != ttMove
+ && !pos.move_is_capture_or_promotion(move)
+ && ss->eval + PawnValueMidgame / 4 < beta
+ && !check_is_dangerous(pos, move, futilityBase, beta, &bestValue))
+ {
+ if (ss->eval + PawnValueMidgame / 4 > bestValue)
+ bestValue = ss->eval + PawnValueMidgame / 4;
+
+ continue;
+ }
+
// Update current move
ss->currentMove = move;
return value_mated_in(ply);
// Update transposition table
- Depth d = (depth == DEPTH_ZERO ? DEPTH_ZERO : DEPTH_ZERO - ONE_PLY);
ValueType vt = (bestValue <= oldAlpha ? VALUE_TYPE_UPPER : bestValue >= beta ? VALUE_TYPE_LOWER : VALUE_TYPE_EXACT);
- TT.store(pos.get_key(), value_to_tt(bestValue, ply), vt, d, ss->bestMove, ss->eval, evalMargin);
+ TT.store(pos.get_key(), value_to_tt(bestValue, ply), vt, ttDepth, ss->bestMove, ss->eval, evalMargin);
assert(bestValue > -VALUE_INFINITE && bestValue < VALUE_INFINITE);
}
+ // check_is_dangerous() tests if a checking move can be pruned in qsearch().
+ // bestValue is updated only when returning false because in that case move
+ // will be pruned.
+
+ bool check_is_dangerous(Position &pos, Move move, Value futilityBase, Value beta, Value *bestValue)
+ {
+ Bitboard b, occ, oldAtt, newAtt, kingAtt;
+ Square from, to, ksq, victimSq;
+ Piece pc;
+ Color them;
+ Value futilityValue, bv = *bestValue;
+
+ from = move_from(move);
+ to = move_to(move);
+ them = opposite_color(pos.side_to_move());
+ ksq = pos.king_square(them);
+ kingAtt = pos.attacks_from<KING>(ksq);
+ pc = pos.piece_on(from);
+
+ occ = pos.occupied_squares() & ~(1ULL << from) & ~(1ULL << ksq);
+ oldAtt = pos.attacks_from(pc, from, occ);
+ newAtt = pos.attacks_from(pc, to, occ);
+
+ // Rule 1. Checks which give opponent's king at most one escape square are dangerous
+ b = kingAtt & ~pos.pieces_of_color(them) & ~newAtt & ~(1ULL << to);
+
+ if (!(b && (b & (b - 1))))
+ return true;
+
+ // Rule 2. Queen contact check is very dangerous
+ if ( type_of_piece(pc) == QUEEN
+ && bit_is_set(kingAtt, to))
+ return true;
+
+ // Rule 3. Creating new double threats with checks
+ b = pos.pieces_of_color(them) & newAtt & ~oldAtt & ~(1ULL << ksq);
+
+ while (b)
+ {
+ victimSq = pop_1st_bit(&b);
+ futilityValue = futilityBase + pos.endgame_value_of_piece_on(victimSq);
+
+ // Note that here we generate illegal "double move"!
+ if ( futilityValue >= beta
+ && pos.see_sign(make_move(from, victimSq)) >= 0)
+ return true;
+
+ if (futilityValue > bv)
+ bv = futilityValue;
+ }
+
+ // Update bestValue only if check is not dangerous (because we will prune the move)
+ *bestValue = bv;
+ return false;
+ }
+
+
// connected_moves() tests whether two moves are 'connected' in the sense
// that the first move somehow made the second move possible (for instance
// if the moving piece is the same in both moves). The first move is assumed
Square f1, t1, f2, t2;
Piece p;
- assert(move_is_ok(m1));
- assert(move_is_ok(m2));
-
- if (m2 == MOVE_NONE)
- return false;
+ assert(m1 && move_is_ok(m1));
+ assert(m2 && move_is_ok(m2));
// Case 1: The moving piece is the same in both moves
f2 = move_from(m2);
/// The ThreadsManager class
+ // read_uci_options() updates number of active threads and other internal
+ // parameters according to the UCI options values. It is called before
+ // to start a new search.
+
+ void ThreadsManager::read_uci_options() {
+
+ maxThreadsPerSplitPoint = Options["Maximum Number of Threads per Split Point"].value<int>();
+ minimumSplitDepth = Options["Minimum Split Depth"].value<int>() * ONE_PLY;
+ useSleepingThreads = Options["Use Sleeping Threads"].value<bool>();
+ activeThreads = Options["Threads"].value<int>();
+ }
+
+
// idle_loop() is where the threads are parked when they have no work to do.
// The parameter 'sp', if non-NULL, is a pointer to an active SplitPoint
// object for which the current thread is the master.
{
// Slave threads can exit as soon as AllThreadsShouldExit raises,
// master should exit as last one.
- if (AllThreadsShouldExit)
+ if (allThreadsShouldExit)
{
assert(!sp);
threads[threadID].state = THREAD_TERMINATED;
// If we are not thinking, wait for a condition to be signaled
// instead of wasting CPU time polling for work.
- while ( threadID >= ActiveThreads
- || threads[threadID].state == THREAD_INITIALIZING
- || (threads[threadID].state == THREAD_AVAILABLE && (!sp || UseSleepingMaster)))
+ while ( threadID >= activeThreads || threads[threadID].state == THREAD_INITIALIZING
+ || (useSleepingThreads && threads[threadID].state == THREAD_AVAILABLE))
{
- lock_grab(&MPLock);
-
- // Test with lock held to avoid races with wake_sleeping_thread()
- for (i = 0; sp && i < ActiveThreads && !sp->slaves[i]; i++) {}
- allFinished = (i == ActiveThreads);
-
- // Retest sleep conditions under lock protection
- if ( AllThreadsShouldExit
- || allFinished
- || !( threadID >= ActiveThreads
- || threads[threadID].state == THREAD_INITIALIZING
- || (threads[threadID].state == THREAD_AVAILABLE && (!sp || UseSleepingMaster))))
+ assert(!sp || useSleepingThreads);
+ assert(threadID != 0 || useSleepingThreads);
+
+ if (threads[threadID].state == THREAD_INITIALIZING)
+ threads[threadID].state = THREAD_AVAILABLE;
+
+ // Grab the lock to avoid races with wake_sleeping_thread()
+ lock_grab(&sleepLock[threadID]);
+
+ // If we are master and all slaves have finished do not go to sleep
+ for (i = 0; sp && i < activeThreads && !sp->slaves[i]; i++) {}
+ allFinished = (i == activeThreads);
+
+ if (allFinished || allThreadsShouldExit)
{
- lock_release(&MPLock);
+ lock_release(&sleepLock[threadID]);
break;
}
- // Put thread to sleep
- threads[threadID].state = THREAD_AVAILABLE;
- cond_wait(&WaitCond[threadID], &MPLock);
- lock_release(&MPLock);
+ // Do sleep here after retesting sleep conditions
+ if (threadID >= activeThreads || threads[threadID].state == THREAD_AVAILABLE)
+ cond_wait(&sleepCond[threadID], &sleepLock[threadID]);
+
+ lock_release(&sleepLock[threadID]);
}
// If this thread has been assigned work, launch a search
if (threads[threadID].state == THREAD_WORKISWAITING)
{
- assert(!AllThreadsShouldExit);
+ assert(!allThreadsShouldExit);
threads[threadID].state = THREAD_SEARCHING;
if (tsp->pvNode)
search<PV, true>(pos, ss, tsp->alpha, tsp->beta, tsp->depth, tsp->ply);
- else {
+ else
search<NonPV, true>(pos, ss, tsp->alpha, tsp->beta, tsp->depth, tsp->ply);
- }
+
assert(threads[threadID].state == THREAD_SEARCHING);
threads[threadID].state = THREAD_AVAILABLE;
// Wake up master thread so to allow it to return from the idle loop in
// case we are the last slave of the split point.
- if (UseSleepingMaster && threadID != tsp->master && threads[tsp->master].state == THREAD_AVAILABLE)
+ if (useSleepingThreads && threadID != tsp->master && threads[tsp->master].state == THREAD_AVAILABLE)
wake_sleeping_thread(tsp->master);
}
// If this thread is the master of a split point and all slaves have
// finished their work at this split point, return from the idle loop.
- for (i = 0; sp && i < ActiveThreads && !sp->slaves[i]; i++) {}
- allFinished = (i == ActiveThreads);
+ for (i = 0; sp && i < activeThreads && !sp->slaves[i]; i++) {}
+ allFinished = (i == activeThreads);
if (allFinished)
{
bool ok;
// Initialize global locks
- lock_init(&MPLock);
+ lock_init(&mpLock);
for (i = 0; i < MAX_THREADS; i++)
- cond_init(&WaitCond[i]);
+ {
+ lock_init(&sleepLock[i]);
+ cond_init(&sleepCond[i]);
+ }
// Initialize splitPoints[] locks
for (i = 0; i < MAX_THREADS; i++)
lock_init(&(threads[i].splitPoints[j].lock));
// Will be set just before program exits to properly end the threads
- AllThreadsShouldExit = false;
+ allThreadsShouldExit = false;
// Threads will be put all threads to sleep as soon as created
- ActiveThreads = 1;
+ activeThreads = 1;
// All threads except the main thread should be initialized to THREAD_INITIALIZING
threads[0].state = THREAD_SEARCHING;
void ThreadsManager::exit_threads() {
- AllThreadsShouldExit = true; // Let the woken up threads to exit idle_loop()
+ allThreadsShouldExit = true; // Let the woken up threads to exit idle_loop()
// Wake up all the threads and waits for termination
for (int i = 1; i < MAX_THREADS; i++)
for (int j = 0; j < MAX_ACTIVE_SPLIT_POINTS; j++)
lock_destroy(&(threads[i].splitPoints[j].lock));
- lock_destroy(&MPLock);
+ lock_destroy(&mpLock);
// Now we can safely destroy the wait conditions
for (int i = 0; i < MAX_THREADS; i++)
- cond_destroy(&WaitCond[i]);
+ {
+ lock_destroy(&sleepLock[i]);
+ cond_destroy(&sleepCond[i]);
+ }
}
- // thread_should_stop() checks whether the thread should stop its search.
- // This can happen if a beta cutoff has occurred in the thread's currently
- // active split point, or in some ancestor of the current split point.
+ // cutoff_at_splitpoint() checks whether a beta cutoff has occurred in
+ // the thread's currently active split point, or in some ancestor of
+ // the current split point.
- bool ThreadsManager::thread_should_stop(int threadID) const {
+ bool ThreadsManager::cutoff_at_splitpoint(int threadID) const {
- assert(threadID >= 0 && threadID < ActiveThreads);
+ assert(threadID >= 0 && threadID < activeThreads);
SplitPoint* sp = threads[threadID].splitPoint;
- for ( ; sp && !sp->stopRequest; sp = sp->parent) {}
+ for ( ; sp && !sp->betaCutoff; sp = sp->parent) {}
return sp != NULL;
}
bool ThreadsManager::thread_is_available(int slave, int master) const {
- assert(slave >= 0 && slave < ActiveThreads);
- assert(master >= 0 && master < ActiveThreads);
- assert(ActiveThreads > 1);
+ assert(slave >= 0 && slave < activeThreads);
+ assert(master >= 0 && master < activeThreads);
+ assert(activeThreads > 1);
if (threads[slave].state != THREAD_AVAILABLE || slave == master)
return false;
// No active split points means that the thread is available as
// a slave for any other thread.
- if (localActiveSplitPoints == 0 || ActiveThreads == 2)
+ if (localActiveSplitPoints == 0 || activeThreads == 2)
return true;
// Apply the "helpful master" concept if possible. Use localActiveSplitPoints
bool ThreadsManager::available_thread_exists(int master) const {
- assert(master >= 0 && master < ActiveThreads);
- assert(ActiveThreads > 1);
+ assert(master >= 0 && master < activeThreads);
+ assert(activeThreads > 1);
- for (int i = 0; i < ActiveThreads; i++)
+ for (int i = 0; i < activeThreads; i++)
if (thread_is_available(i, master))
return true;
assert(*alpha < beta);
assert(beta <= VALUE_INFINITE);
assert(depth > DEPTH_ZERO);
- assert(pos.thread() >= 0 && pos.thread() < ActiveThreads);
- assert(ActiveThreads > 1);
+ assert(pos.thread() >= 0 && pos.thread() < activeThreads);
+ assert(activeThreads > 1);
int i, master = pos.thread();
Thread& masterThread = threads[master];
- lock_grab(&MPLock);
+ lock_grab(&mpLock);
// If no other thread is available to help us, or if we have too many
// active split points, don't split.
if ( !available_thread_exists(master)
|| masterThread.activeSplitPoints >= MAX_ACTIVE_SPLIT_POINTS)
{
- lock_release(&MPLock);
+ lock_release(&mpLock);
return;
}
// Initialize the split point object
splitPoint.parent = masterThread.splitPoint;
splitPoint.master = master;
- splitPoint.stopRequest = false;
+ splitPoint.betaCutoff = false;
splitPoint.ply = ply;
splitPoint.depth = depth;
splitPoint.threatMove = threatMove;
splitPoint.pos = &pos;
splitPoint.nodes = 0;
splitPoint.parentSstack = ss;
- for (i = 0; i < ActiveThreads; i++)
+ for (i = 0; i < activeThreads; i++)
splitPoint.slaves[i] = 0;
masterThread.splitPoint = &splitPoint;
int workersCnt = 1; // At least the master is included
// Allocate available threads setting state to THREAD_BOOKED
- for (i = 0; !Fake && i < ActiveThreads && workersCnt < MaxThreadsPerSplitPoint; i++)
+ for (i = 0; !Fake && i < activeThreads && workersCnt < maxThreadsPerSplitPoint; i++)
if (thread_is_available(i, master))
{
threads[i].state = THREAD_BOOKED;
assert(Fake || workersCnt > 1);
// We can release the lock because slave threads are already booked and master is not available
- lock_release(&MPLock);
+ lock_release(&mpLock);
// Tell the threads that they have work to do. This will make them leave
// their idle loop. But before copy search stack tail for each thread.
- for (i = 0; i < ActiveThreads; i++)
+ for (i = 0; i < activeThreads; i++)
if (i == master || splitPoint.slaves[i])
{
memcpy(splitPoint.sstack[i], ss - 1, 4 * sizeof(SearchStack));
assert(i == master || threads[i].state == THREAD_BOOKED);
threads[i].state = THREAD_WORKISWAITING; // This makes the slave to exit from idle_loop()
- if (i != master)
+
+ if (useSleepingThreads && i != master)
wake_sleeping_thread(i);
}
// We have returned from the idle loop, which means that all threads are
// finished. Update alpha and bestValue, and return.
- lock_grab(&MPLock);
+ lock_grab(&mpLock);
*alpha = splitPoint.alpha;
*bestValue = splitPoint.bestValue;
masterThread.splitPoint = splitPoint.parent;
pos.set_nodes_searched(pos.nodes_searched() + splitPoint.nodes);
- lock_release(&MPLock);
+ lock_release(&mpLock);
}
- // wake_sleeping_thread() wakes up all sleeping threads when it is time
- // to start a new search from the root.
+ // wake_sleeping_thread() wakes up the thread with the given threadID
+ // when it is time to start a new search.
void ThreadsManager::wake_sleeping_thread(int threadID) {
- lock_grab(&MPLock);
- cond_signal(&WaitCond[threadID]);
- lock_release(&MPLock);
+ lock_grab(&sleepLock[threadID]);
+ cond_signal(&sleepCond[threadID]);
+ lock_release(&sleepLock[threadID]);
}
/// The RootMoveList class
- // RootMoveList c'tor
-
RootMoveList::RootMoveList(Position& pos, Move searchMoves[]) {
SearchStack ss[PLY_MAX_PLUS_2];
MoveStack mlist[MOVES_MAX];
StateInfo st;
- bool includeAllMoves = (searchMoves[0] == MOVE_NONE);
+ Move* sm;
// Initialize search stack
init_ss_array(ss, PLY_MAX_PLUS_2);
ss[0].eval = ss[0].evalMargin = VALUE_NONE;
- count = 0;
// Generate all legal moves
MoveStack* last = generate_moves(pos, mlist);
- // Add each move to the moves[] array
+ // Add each move to the RootMoveList's vector
for (MoveStack* cur = mlist; cur != last; cur++)
{
- bool includeMove = includeAllMoves;
-
- for (int k = 0; !includeMove && searchMoves[k] != MOVE_NONE; k++)
- includeMove = (searchMoves[k] == cur->move);
+ // If we have a searchMoves[] list then verify cur->move
+ // is in the list before to add it.
+ for (sm = searchMoves; *sm && *sm != cur->move; sm++) {}
- if (!includeMove)
+ if (searchMoves[0] && *sm != cur->move)
continue;
- // Find a quick score for the move
- moves[count].move = ss[0].currentMove = moves[count].pv[0] = cur->move;
- moves[count].pv[1] = MOVE_NONE;
+ // Find a quick score for the move and add to the list
pos.do_move(cur->move, st);
- moves[count].score = -qsearch<PV>(pos, ss+1, -VALUE_INFINITE, VALUE_INFINITE, DEPTH_ZERO, 1);
+
+ RootMove rm;
+ rm.move = ss[0].currentMove = rm.pv[0] = cur->move;
+ rm.pv[1] = MOVE_NONE;
+ rm.pv_score = -qsearch<PV>(pos, ss+1, -VALUE_INFINITE, VALUE_INFINITE, DEPTH_ZERO, 1);
+ push_back(rm);
+
pos.undo_move(cur->move);
- count++;
}
sort();
}
// Score root moves using the standard way used in main search, the moves
// are scored according to the order in which are returned by MovePicker.
+ // This is the second order score that is used to compare the moves when
+ // the first order pv scores of both moves are equal.
- void RootMoveList::score_moves(const Position& pos)
+ void RootMoveList::set_non_pv_scores(const Position& pos)
{
Move move;
- int score = 1000;
- MovePicker mp = MovePicker(pos, MOVE_NONE, ONE_PLY, H);
+ Value score = VALUE_ZERO;
+ MovePicker mp(pos, MOVE_NONE, ONE_PLY, H);
while ((move = mp.get_next_move()) != MOVE_NONE)
- for (int i = 0; i < count; i++)
- if (moves[i].move == move)
+ for (Base::iterator it = begin(); it != end(); ++it)
+ if (it->move == move)
{
- moves[i].mp_score = score--;
+ it->non_pv_score = score--;
break;
}
}
- // RootMoveList simple methods definitions
-
- void RootMoveList::set_move_pv(int moveNum, const Move pv[]) {
-
- int j;
-
- for (j = 0; pv[j] != MOVE_NONE; j++)
- moves[moveNum].pv[j] = pv[j];
-
- moves[moveNum].pv[j] = MOVE_NONE;
- }
-
-
- // RootMoveList::sort() sorts the root move list at the beginning of a new
- // iteration.
-
- void RootMoveList::sort() {
-
- sort_multipv(count - 1); // Sort all items
- }
-
-
- // RootMoveList::sort_multipv() sorts the first few moves in the root move
- // list by their scores and depths. It is used to order the different PVs
- // correctly in MultiPV mode.
-
- void RootMoveList::sort_multipv(int n) {
-
- int i,j;
-
- for (i = 1; i <= n; i++)
- {
- RootMove rm = moves[i];
- for (j = i; j > 0 && moves[j - 1] < rm; j--)
- moves[j] = moves[j - 1];
-
- moves[j] = rm;
- }
- }
-
} // namespace