X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fsearch.cpp;h=0c5ead46754c20411fe6ab3de99953dceb884524;hp=6829ab619b317d85f354d9d08e5a47eb3fc3c396;hb=e9de96f0e417dc706882b645d14dbf41e7ccc467;hpb=dad632ce5b075e8121bb783dec40d3c8fd4f5ffa

diff --git a/src/search.cpp b/src/search.cpp
index 6829ab61..0c5ead46 100644
--- a/src/search.cpp
+++ b/src/search.cpp
@@ -28,6 +28,7 @@
 #include <iostream>
 #include <sstream>
 
+#include "bitcount.h"
 #include "book.h"
 #include "evaluate.h"
 #include "history.h"
@@ -189,12 +190,19 @@ namespace {
   // Remaining depth:                 1 ply         1.5 ply       2 ply         2.5 ply       3 ply         3.5 ply
   const Value RazorApprMargins[6] = { Value(0x520), Value(0x300), Value(0x300), Value(0x300), Value(0x300), Value(0x300) };
 
-  // The main transposition table
-  TranspositionTable TT;
-
 
   /// 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
 
@@ -281,7 +289,7 @@ namespace {
   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);
@@ -294,6 +302,7 @@ namespace {
   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();
@@ -414,7 +423,10 @@ bool think(const Position& pos, bool infinite, bool ponder, int side_to_move,
 
   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;
@@ -427,6 +439,19 @@ bool think(const Position& pos, bool infinite, bool ponder, int side_to_move,
   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];
@@ -471,10 +496,16 @@ bool think(const Position& pos, bool infinite, bool ponder, int 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
@@ -860,7 +891,7 @@ namespace {
         // 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
@@ -884,8 +915,8 @@ namespace {
         }
         else
         {
-            if (newDepth >= 3*OnePly
-                && i + MultiPV >= LMRPVMoves
+            if (   newDepth >= 3*OnePly
+                && i >= MultiPV + LMRPVMoves - 2 // Remove -2 and decrease LMRPVMoves instead ?
                 && !dangerous
                 && !moveIsCapture
                 && !move_is_promotion(move)
@@ -893,10 +924,10 @@ namespace {
             {
                 ss[0].reduction = OnePly;
                 value = -search(pos, ss, -alpha, newDepth-OnePly, 1, true, 0);
-            }
-            else
+            } else
                 value = alpha + 1; // Just to trigger next condition
-            if(value > alpha)
+
+            if (value > alpha)
             {
                 value = -search(pos, ss, -alpha, newDepth, 1, true, 0);
                 if (value > alpha)
@@ -941,6 +972,7 @@ namespace {
             // 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)
@@ -954,6 +986,8 @@ namespace {
                 // 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()
@@ -1022,7 +1056,7 @@ namespace {
 
     // 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))
@@ -1212,7 +1246,7 @@ namespace {
 
     // 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))
@@ -1468,7 +1502,7 @@ namespace {
 
     // 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))
@@ -1928,15 +1962,15 @@ namespace {
     bool includeAllMoves = (searchMoves[0] == MOVE_NONE);
 
     // Generate all legal moves
-    int lm_count = generate_legal_moves(pos, mlist);
+    MoveStack* last = generate_legal_moves(pos, mlist);
 
     // Add each move to the moves[] array
-    for (int i = 0; i < lm_count; i++)
+    for (MoveStack* cur = mlist; cur != last; cur++)
     {
         bool includeMove = includeAllMoves;
 
         for (int k = 0; !includeMove && searchMoves[k] != MOVE_NONE; k++)
-            includeMove = (searchMoves[k] == mlist[i].move);
+            includeMove = (searchMoves[k] == cur->move);
 
         if (!includeMove)
             continue;
@@ -1945,7 +1979,7 @@ namespace {
         StateInfo st;
         SearchStack ss[PLY_MAX_PLUS_2];
 
-        moves[count].move = mlist[i].move;
+        moves[count].move = cur->move;
         pos.do_move(moves[count].move, st);
         moves[count].score = -qsearch(pos, ss, -VALUE_INFINITE, VALUE_INFINITE, Depth(0), 1, 0);
         pos.undo_move(moves[count].move);
@@ -2055,11 +2089,14 @@ namespace {
   // 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)
@@ -2230,12 +2267,13 @@ namespace {
 
     if (pos.type_of_piece_on(move_from(m)) == PAWN)
     {
-        if (pos.move_is_pawn_push_to_7th(m))
+        Color c = pos.side_to_move();
+        if (relative_rank(c, move_to(m)) == RANK_7)
         {
             result += PawnPushTo7thExtension[pvNode];
             *dangerous = true;
         }
-        if (pos.move_is_passed_pawn_push(m))
+        if (pos.pawn_is_passed(c, move_to(m)))
         {
             result += PassedPawnExtension[pvNode];
             *dangerous = true;
@@ -2392,6 +2430,21 @@ namespace {
     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.