Initial work towards adjustable playing strength.

Added the UCI_LimitStrength and the UCI_Elo options, with an Elo
range of 2100-2900. When UCI_LimitStrength is enabled, the number
of threads is set to 1, and the search speed is slowed down according
to the chosen Elo level.

Todo:

1. Implement Elo levels below 2100 by blundering on purpose and/or
   crippling the evaluation.
2. Automatically calibrate the maximum Elo by measuring the CPU speed
   during program initialization, perhaps by doing some bitboard
   computations and measuring the time taken.

No functional change when UCI_LimitStrength is false (the default).

diff --git a/src/search.cpp b/src/search.cpp
index 6829ab619b317d85f354d9d08e5a47eb3fc3c396..f0d2431487641dc765f5c56d1a7a029f7cf439ef 100644 (file)
--- 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"
@@ -195,6 +196,16 @@ namespace {
 
   /// 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 +292,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 +305,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 +426,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 +442,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 +499,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
@@ -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))
@@ -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)
@@ -2392,6 +2429,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.

diff --git a/src/ucioption.cpp b/src/ucioption.cpp
index a0269464db99f7d5ee1b26f08a70140602d6aaea..e25877fe462fdb6801da62e293983f6fae649862 100644 (file)
--- a/src/ucioption.cpp
+++ b/src/ucioption.cpp
@@ -131,6 +131,8 @@ namespace {
     o["UCI_ShowCurrLine"] = Option(false);
     o["UCI_Chess960"] = Option(false);
     o["UCI_AnalyseMode"] = Option(false);
+    o["UCI_LimitStrength"] = Option(false);
+    o["UCI_Elo"] = Option(2900, 2100, 2900);
 
     // Any option should know its name so to be easily printed
     for (Options::iterator it = o.begin(); it != o.end(); ++it)