#include <iostream>
#include <sstream>
+#include "bitcount.h"
#include "book.h"
#include "evaluate.h"
#include "history.h"
/// Variables initialized by UCI options
+ // Adjustable playing strength
+ int Slowdown = 0;
+ const int SlowdownArray[32] = {
+ 19, 41, 70, 110, 160, 230, 320, 430, 570, 756, 1000, 1300, 1690, 2197,
+ 2834, 3600, 4573, 5809, 7700, 9863, 12633, 16181, 20726, 26584, 34005,
+ 43557, 55792, 71463, 91536, 117247, 150180, 192363
+ };
+ int Strength;
+ const int MaxStrength = 25;
+
// Minimum number of full depth (i.e. non-reduced) moves at PV and non-PV nodes
int LMRPVMoves, LMRNonPVMoves; // heavy SMP read access for the latter
Value qsearch(Position& pos, SearchStack ss[], Value alpha, Value beta, Depth depth, int ply, int threadID);
void sp_search(SplitPoint* sp, int threadID);
void sp_search_pv(SplitPoint* sp, int threadID);
- void init_node(SearchStack ss[], int ply, int threadID);
+ void init_node(const Position& pos, SearchStack ss[], int ply, int threadID);
void update_pv(SearchStack ss[], int ply);
void sp_update_pv(SearchStack* pss, SearchStack ss[], int ply);
bool connected_moves(const Position& pos, Move m1, Move m2);
bool ok_to_history(const Position& pos, Move m);
void update_history(const Position& pos, Move m, Depth depth, Move movesSearched[], int moveCount);
void update_killers(Move m, SearchStack& ss);
+ void slowdown(const Position& pos);
bool fail_high_ply_1();
int current_search_time();
read_weights(pos.side_to_move());
- int newActiveThreads = get_option_value_int("Threads");
+ // Set the number of active threads. If UCI_LimitStrength is enabled, never
+ // use more than one thread.
+ int newActiveThreads =
+ get_option_value_bool("UCI_LimitStrength")? 1 : get_option_value_int("Threads");
if (newActiveThreads != ActiveThreads)
{
ActiveThreads = newActiveThreads;
for (int i = 1; i < ActiveThreads; i++)
assert(thread_is_available(i, 0));
+ // Set playing strength
+ if (get_option_value_bool("UCI_LimitStrength"))
+ {
+ Strength = (get_option_value_int("UCI_Elo") - 2100) / 25;
+ Slowdown =
+ (Strength == MaxStrength)? 0 : SlowdownArray[Max(0, 31-Strength)];
+ }
+ else
+ {
+ Strength = MaxStrength;
+ Slowdown = 0;
+ }
+
// Set thinking time
int myTime = time[side_to_move];
int myIncrement = increment[side_to_move];
NodesBetweenPolls = Min(MaxNodes, 30000);
InfiniteSearch = true; // HACK
}
+ else if (Slowdown) {
+ if (Slowdown > 50000) NodesBetweenPolls = 30;
+ else if (Slowdown > 10000) NodesBetweenPolls = 100;
+ else if (Slowdown > 1000) NodesBetweenPolls = 500;
+ else if (Slowdown > 100) NodesBetweenPolls = 3000;
+ else NodesBetweenPolls = 15000;
+ }
else
NodesBetweenPolls = 30000;
-
// Write information to search log file
if (UseLogFile)
LogFile << "Searching: " << pos.to_fen() << std::endl
<< " currmovenumber " << i + 1 << std::endl;
// Decide search depth for this move
+ bool moveIsCapture = pos.move_is_capture(move);
bool dangerous;
- ext = extension(pos, move, true, pos.move_is_capture(move), pos.move_is_check(move), false, false, &dangerous);
+ ext = extension(pos, move, true, moveIsCapture, pos.move_is_check(move), false, false, &dangerous);
newDepth = (Iteration - 2) * OnePly + ext + InitialDepth;
// Make the move, and search it
}
else
{
- value = -search(pos, ss, -alpha, newDepth, 1, true, 0);
+ if ( newDepth >= 3*OnePly
+ && i >= MultiPV + LMRPVMoves - 2 // Remove -2 and decrease LMRPVMoves instead ?
+ && !dangerous
+ && !moveIsCapture
+ && !move_is_promotion(move)
+ && !move_is_castle(move))
+ {
+ ss[0].reduction = OnePly;
+ value = -search(pos, ss, -alpha, newDepth-OnePly, 1, true, 0);
+ } else
+ value = alpha + 1; // Just to trigger next condition
+
if (value > alpha)
{
- // Fail high! Set the boolean variable FailHigh to true, and
- // re-search the move with a big window. The variable FailHigh is
- // used for time managment: We try to avoid aborting the search
- // prematurely during a fail high research.
- FailHigh = true;
- value = -search_pv(pos, ss, -beta, -alpha, newDepth, 1, 0);
+ value = -search(pos, ss, -alpha, newDepth, 1, true, 0);
+ if (value > alpha)
+ {
+ // Fail high! Set the boolean variable FailHigh to true, and
+ // re-search the move with a big window. The variable FailHigh is
+ // used for time managment: We try to avoid aborting the search
+ // prematurely during a fail high research.
+ FailHigh = true;
+ value = -search_pv(pos, ss, -beta, -alpha, newDepth, 1, 0);
+ }
}
}
// Update PV
rml.set_move_score(i, value);
update_pv(ss, 0);
+ TT.extract_pv(pos, ss[0].pv);
rml.set_move_pv(i, ss[0].pv);
if (MultiPV == 1)
// Print search information to the standard output
std::cout << "info depth " << Iteration
<< " score " << value_to_string(value)
+ << ((value >= beta)?
+ " lowerbound" : ((value <= alpha)? " upperbound" : ""))
<< " time " << current_search_time()
<< " nodes " << nodes_searched()
<< " nps " << nps()
// Initialize, and make an early exit in case of an aborted search,
// an instant draw, maximum ply reached, etc.
- init_node(ss, ply, threadID);
+ init_node(pos, ss, ply, threadID);
// After init_node() that calls poll()
if (AbortSearch || thread_should_stop(threadID))
// Initialize, and make an early exit in case of an aborted search,
// an instant draw, maximum ply reached, etc.
- init_node(ss, ply, threadID);
+ init_node(pos, ss, ply, threadID);
// After init_node() that calls poll()
if (AbortSearch || thread_should_stop(threadID))
pos.undo_null_move();
- if (value_is_mate(nullValue))
- {
- if (nullValue == value_mated_in(ply + 2))
- mateThreat = true;
-
- /* Do not return unproven mates */
- }
- else if (nullValue >= beta)
+ if (nullValue >= beta)
{
if (depth < 6 * OnePly)
return beta;
// move which was reduced. If a connection is found, return a fail
// low score (which will cause the reduced move to fail high in the
// parent node, which will trigger a re-search with full depth).
+ if (nullValue == value_mated_in(ply + 2))
+ mateThreat = true;
+
ss[ply].threatMove = ss[ply + 1].currentMove;
if ( depth < ThreatDepth
&& ss[ply - 1].reduction
// Initialize, and make an early exit in case of an aborted search,
// an instant draw, maximum ply reached, etc.
- init_node(ss, ply, threadID);
+ init_node(pos, ss, ply, threadID);
// After init_node() that calls poll()
if (AbortSearch || thread_should_stop(threadID))
// NodesBetweenPolls nodes, init_node() also calls poll(), which polls
// for user input and checks whether it is time to stop the search.
- void init_node(SearchStack ss[], int ply, int threadID) {
+ void init_node(const Position& pos, SearchStack ss[], int ply, int threadID) {
assert(ply >= 0 && ply < PLY_MAX);
assert(threadID >= 0 && threadID < ActiveThreads);
+ if (Slowdown && Iteration >= 3)
+ slowdown(pos);
+
Threads[threadID].nodes++;
if (threadID == 0)
assert(m != MOVE_NONE);
Depth result = Depth(0);
- *dangerous = check || singleReply || mateThreat;
+ *dangerous = check | singleReply | mateThreat;
- if (check)
- result += CheckExtension[pvNode];
+ if (*dangerous)
+ {
+ if (check)
+ result += CheckExtension[pvNode];
- if (singleReply)
- result += SingleReplyExtension[pvNode];
+ if (singleReply)
+ result += SingleReplyExtension[pvNode];
- if (mateThreat)
- result += MateThreatExtension[pvNode];
+ if (mateThreat)
+ result += MateThreatExtension[pvNode];
+ }
if (pos.type_of_piece_on(move_from(m)) == PAWN)
{
ss.killers[0] = m;
}
+
+ // slowdown() simply wastes CPU cycles doing nothing useful. It's used
+ // in strength handicap mode.
+
+ void slowdown(const Position &pos) {
+ int i, n;
+ n = Slowdown;
+ for (i = 0; i < n; i++) {
+ Square s = Square(i&63);
+ if (count_1s(pos.attacks_to(s)) > 63)
+ std::cout << "This can't happen, but I put this string here anyway, in order to prevent the compiler from optimizing away the useless computation." << std::endl;
+ }
+ }
+
+
// fail_high_ply_1() checks if some thread is currently resolving a fail
// high at ply 1 at the node below the first root node. This information
// is used for time managment.
projects / stockfish / blobdiff