WebSVN – Games.Chess Giants – Diff – //engine-stockfish/uci.cpp

   Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
-  Copyright (C) 2015-2016 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
+  Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, 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
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
+#include <cassert>
 #include <iostream>
 #include <sstream>
 #include <string>
 #include "evaluate.h"
 #include "movegen.h"
 #include "position.h"
 #include "search.h"
 #include "thread.h"
+#include "tt.h"
 #include "timeman.h"
 #include "uci.h"
+#include "syzygy/tbprobe.h"
 using namespace std;
-extern void benchmark(const Position& pos, istream& is);
+extern vector<string> setup_bench(const Position&, istream&);
 namespace {
   // FEN string of the initial position, normal chess
   const char* StartFEN = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1";
-  // A list to keep track of the position states along the setup moves (from the
-  // start position to the position just before the search starts). Needed by
-  // 'draw by repetition' detection.
-  StateListPtr States(new std::deque<StateInfo>(1));
   // position() is called when engine receives the "position" UCI command.
   // The function sets up the position described in the given FEN string ("fen")
   // or the starting position ("startpos") and then makes the moves given in the
   // following move list ("moves").
-  void position(Position& pos, istringstream& is) {
+  void position(Position& pos, istringstream& is, StateListPtr& states) {
     Move m;
     string token, fen;
     is >> token;
         while (is >> token && token != "moves")
             fen += token + " ";
     else
         return;
-    States = StateListPtr(new std::deque<StateInfo>(1));
+    states = StateListPtr(new std::deque<StateInfo>(1)); // Drop old and create a new one
-    pos.set(fen, Options["UCI_Chess960"], &States->back(), Threads.main());
+    pos.set(fen, Options["UCI_Chess960"], &states->back(), Threads.main());
     // Parse move list (if any)
     while (is >> token && (m = UCI::to_move(pos, token)) != MOVE_NONE)
+    {
-        States->push_back(StateInfo());
+        states->emplace_back();
-        pos.do_move(m, States->back(), pos.gives_check(m));
+        pos.do_move(m, states->back());
+    }
+  }
   // setoption() is called when engine receives the "setoption" UCI command. The
   // go() is called when engine receives the "go" UCI command. The function sets
   // the thinking time and other parameters from the input string, then starts
   // the search.
-  void go(Position& pos, istringstream& is) {
+  void go(Position& pos, istringstream& is, StateListPtr& states) {
     Search::LimitsType limits;
     string token;
+    bool ponderMode = false;
     limits.startTime = now(); // As early as possible!
     while (is >> token)
         if (token == "searchmoves")
         else if (token == "movestogo") is >> limits.movestogo;
         else if (token == "depth")     is >> limits.depth;
         else if (token == "nodes")     is >> limits.nodes;
         else if (token == "movetime")  is >> limits.movetime;
         else if (token == "mate")      is >> limits.mate;
+        else if (token == "perft")     is >> limits.perft;
         else if (token == "infinite")  limits.infinite = 1;
-        else if (token == "ponder")    limits.ponder = 1;
+        else if (token == "ponder")    ponderMode = true;
-    Threads.start_thinking(pos, States, limits);
+    Threads.start_thinking(pos, states, limits, ponderMode);
+  }
+  // bench() is called when engine receives the "bench" command. Firstly
+  // a list of UCI commands is setup according to bench parameters, then
+  // it is run one by one printing a summary at the end.
+  void bench(Position& pos, istream& args, StateListPtr& states) {
+    string token;
+    uint64_t num, nodes = 0, cnt = 1;
+    vector<string> list = setup_bench(pos, args);
+    num = count_if(list.begin(), list.end(), [](string s) { return s.find("go ") == 0; });
+    TimePoint elapsed = now();
+    for (const auto& cmd : list)
+    {
+        istringstream is(cmd);
+        is >> skipws >> token;
+        if (token == "go")
+        {
+            cerr << "\nPosition: " << cnt++ << '/' << num << endl;
+            go(pos, is, states);
+            Threads.main()->wait_for_search_finished();
+            nodes += Threads.nodes_searched();
+        }
+        else if (token == "setoption")  setoption(is);
+        else if (token == "position")   position(pos, is, states);
+        else if (token == "ucinewgame") Search::clear();
+    }
+    elapsed = now() - elapsed + 1; // Ensure positivity to avoid a 'divide by zero'
+    dbg_print(); // Just before exiting
+    cerr << "\n==========================="
+         << "\nTotal time (ms) : " << elapsed
+         << "\nNodes searched  : " << nodes
+         << "\nNodes/second    : " << 1000 * nodes / elapsed << endl;
+  }
 } // namespace
 void UCI::loop(int argc, char* argv[]) {
   Position pos;
   string token, cmd;
+  StateListPtr states(new std::deque<StateInfo>(1));
+  auto uiThread = std::make_shared<Thread>(0);
-  pos.set(StartFEN, false, &States->back(), Threads.main());
+  pos.set(StartFEN, false, &states->back(), uiThread.get());
   for (int i = 1; i < argc; ++i)
       cmd += std::string(argv[i]) + " ";
   do {
       if (argc == 1 && !getline(cin, cmd)) // Block here waiting for input or EOF
           cmd = "quit";
       istringstream is(cmd);
-      token.clear(); // getline() could return empty or blank line
+      token.clear(); // Avoid a stale if getline() returns empty or blank line
       is >> skipws >> token;
-      // The GUI sends 'ponderhit' to tell us to ponder on the same move the
+      // The GUI sends 'ponderhit' to tell us the user has played the expected move.
-      // opponent has played. In case Signals.stopOnPonderhit is set we are
+      // So 'ponderhit' will be sent if we were told to ponder on the same move the
-      // waiting for 'ponderhit' to stop the search (for instance because we
+      // user has played. We should continue searching but switch from pondering to
-      // already ran out of time), otherwise we should continue searching but
+      // normal search. In case Threads.stopOnPonderhit is set we are waiting for
-      // switching from pondering to normal search.
+      // 'ponderhit' to stop the search, for instance if max search depth is reached.
       if (    token == "quit"
           ||  token == "stop"
-          || (token == "ponderhit" && Search::Signals.stopOnPonderhit))
+          || (token == "ponderhit" && Threads.stopOnPonderhit))
-      {
-          Search::Signals.stop = true;
+          Threads.stop = true;
-          Threads.main()->start_searching(true); // Could be sleeping
-      }
       else if (token == "ponderhit")
-          Search::Limits.ponder = 0; // Switch to normal search
+          Threads.ponder = false; // Switch to normal search
       else if (token == "uci")
           sync_cout << "id name " << engine_info(true)
                     << "\n"       << Options
                     << "\nuciok"  << sync_endl;
-      else if (token == "ucinewgame")
-      {
-          Search::clear();
-          Time.availableNodes = 0;
-      }
-      else if (token == "isready")    sync_cout << "readyok" << sync_endl;
-      else if (token == "go")         go(pos, is);
-      else if (token == "position")   position(pos, is);
       else if (token == "setoption")  setoption(is);
+      else if (token == "go")         go(pos, is, states);
+      else if (token == "position")   position(pos, is, states);
+      else if (token == "ucinewgame") Search::clear();
+      else if (token == "isready")    sync_cout << "readyok" << sync_endl;
-      // Additional custom non-UCI commands, useful for debugging
+      // Additional custom non-UCI commands, mainly for debugging
-      else if (token == "flip")       pos.flip();
+      else if (token == "flip")  pos.flip();
-      else if (token == "bench")      benchmark(pos, is);
+      else if (token == "bench") bench(pos, is, states);
-      else if (token == "d")          sync_cout << pos << sync_endl;
+      else if (token == "d")     sync_cout << pos << sync_endl;
-      else if (token == "eval")       sync_cout << Eval::trace(pos) << sync_endl;
+      else if (token == "eval")  sync_cout << Eval::trace(pos) << sync_endl;
-      else if (token == "perft")
-      {
-          int depth;
-          stringstream ss;
-          is >> depth;
-          ss << Options["Hash"]    << " "
-             << Options["Threads"] << " " << depth << " current perft";
-          benchmark(pos, ss);
-      }
       else
           sync_cout << "Unknown command: " << cmd << sync_endl;
-  } while (token != "quit" && argc == 1); // Passed args have one-shot behaviour
+  } while (token != "quit" && argc == 1); // Command line args are one-shot
-  Threads.main()->wait_for_search_finished();
+}
 /// UCI::value() converts a Value to a string suitable for use with the UCI
 /// protocol specification:
 /// cp <x>    The score from the engine's point of view in centipawns.
 /// mate <y>  Mate in y moves, not plies. If the engine is getting mated
 ///           use negative values for y.
 string UCI::value(Value v) {
+  assert(-VALUE_INFINITE < v && v < VALUE_INFINITE);
   stringstream ss;
   if (abs(v) < VALUE_MATE - MAX_PLY)
       ss << "cp " << v * 100 / PawnValueEg;

Subversion Repositories Games.Chess Giants

Games.Chess Giants//engine-stockfish/uci.cpp – Rev 154 → 169