StateInfo is usually allocated on the stack by search()

And passed in do_move(), this ensures maximum efficiency and
speed and at the same time unlimited move numbers.

The draw back is that to handle Position init we need to
reserve a StateInfo inside Position itself and use at
init time and when copying from another Position.

After lazy SMP we don't need anymore this gimmick and we can
get rid of this special case and always pass an external
StateInfo to Position object.

Also rewritten and simplified Position constructors.

Verified it does not regress with a 3 threads SMP test:
ELO: -0.00 +-12.7 (95%) LOS: 50.0%
Total: 1000 W: 173 L: 173 D: 654

No functional change.

diff --git a/src/benchmark.cpp b/src/benchmark.cpp
index 6d69541fcb574755fd21126880edbebc2bf6a38b..2978f3468ff55812c6c0551499638d8c7ebe67a4 100644 (file)
--- a/src/benchmark.cpp
+++ b/src/benchmark.cpp
@@ -144,10 +144,12 @@ void benchmark(const Position& current, istream& is) {
 
   uint64_t nodes = 0;
   TimePoint elapsed = now();
 
   uint64_t nodes = 0;
   TimePoint elapsed = now();

+  Position pos;

 
   for (size_t i = 0; i < fens.size(); ++i)
   {
 
   for (size_t i = 0; i < fens.size(); ++i)
   {

-      Position pos(fens[i], Options["UCI_Chess960"], Threads.main());
+      StateListPtr states(new std::vector<StateInfo>(1));
+      pos.set(fens[i], Options["UCI_Chess960"], &states->back(), Threads.main());

 
       cerr << "\nPosition: " << i + 1 << '/' << fens.size() << endl;
 
 
       cerr << "\nPosition: " << i + 1 << '/' << fens.size() << endl;
 


@@ -156,9 +158,8 @@ void benchmark(const Position& current, istream& is) {
 
       else
       {
 
       else
       {

-          Search::StateStackPtr st;

           limits.startTime = now();
           limits.startTime = now();

-          Threads.start_thinking(pos, limits, st);
+          Threads.start_thinking(pos, states, limits);

           Threads.main()->wait_for_search_finished();
           nodes += Threads.nodes_searched();
       }
           Threads.main()->wait_for_search_finished();
           nodes += Threads.nodes_searched();
       }

diff --git a/src/endgame.cpp b/src/endgame.cpp
index cc6630439cdfdd743a905563b43a9c720835a852..04469e87b4ea3f23d09d22852bd7b152370904d4 100644 (file)
--- a/src/endgame.cpp
+++ b/src/endgame.cpp
@@ -99,7 +99,8 @@ namespace {
     string fen =  sides[0] + char(8 - sides[0].length() + '0') + "/8/8/8/8/8/8/"
                 + sides[1] + char(8 - sides[1].length() + '0') + " w - - 0 10";
 
     string fen =  sides[0] + char(8 - sides[0].length() + '0') + "/8/8/8/8/8/8/"
                 + sides[1] + char(8 - sides[1].length() + '0') + " w - - 0 10";
 

-    return Position(fen, false, nullptr).material_key();
+    StateInfo st;
+    return Position().set(fen, false, &st, nullptr).material_key();

   }
 
 } // namespace
   }
 
 } // namespace

diff --git a/src/position.cpp b/src/position.cpp
index f42377de24577ec6f87aded6099b86a159a4b2ab..6e8b03d1afb3bfabba40a34a52a216e01b49c817 100644 (file)
--- a/src/position.cpp
+++ b/src/position.cpp
@@ -155,42 +155,11 @@ void Position::init() {
 }
 
 
 }
 
 

-/// Position::operator=() creates a copy of 'pos' but detaching the state pointer
-/// from the source to be self-consistent and not depending on any external data.
-
-Position& Position::operator=(const Position& pos) {
-
-  std::memcpy(this, &pos, sizeof(Position));
-  std::memcpy(&startState, st, sizeof(StateInfo));
-  st = &startState;
-  nodes = 0;
-
-  assert(pos_is_ok());
-
-  return *this;
-}
-
-
-/// Position::clear() erases the position object to a pristine state, with an
-/// empty board, white to move, and no castling rights.
-
-void Position::clear() {
-
-  std::memset(this, 0, sizeof(Position));
-  startState.epSquare = SQ_NONE;
-  st = &startState;
-
-  for (int i = 0; i < PIECE_TYPE_NB; ++i)
-      for (int j = 0; j < 16; ++j)
-          pieceList[WHITE][i][j] = pieceList[BLACK][i][j] = SQ_NONE;
-}
-
-

 /// Position::set() initializes the position object with the given FEN string.
 /// This function is not very robust - make sure that input FENs are correct,
 /// this is assumed to be the responsibility of the GUI.
 
 /// Position::set() initializes the position object with the given FEN string.
 /// This function is not very robust - make sure that input FENs are correct,
 /// this is assumed to be the responsibility of the GUI.
 

-void Position::set(const string& fenStr, bool isChess960, Thread* th) {
+Position& Position::set(const string& fenStr, bool isChess960, StateInfo* si, Thread* th) {

 /*
    A FEN string defines a particular position using only the ASCII character set.
 
 /*
    A FEN string defines a particular position using only the ASCII character set.
 


@@ -230,7 +199,11 @@ void Position::set(const string& fenStr, bool isChess960, Thread* th) {
   Square sq = SQ_A8;
   std::istringstream ss(fenStr);
 
   Square sq = SQ_A8;
   std::istringstream ss(fenStr);
 

-  clear();
+  std::memset(this, 0, sizeof(Position));
+  std::memset(si, 0, sizeof(StateInfo));
+  std::fill_n(&pieceList[0][0][0], sizeof(pieceList) / sizeof(Square), SQ_NONE);
+  st = si;
+

   ss >> std::noskipws;
 
   // 1. Piece placement
   ss >> std::noskipws;
 
   // 1. Piece placement


@@ -291,6 +264,8 @@ void Position::set(const string& fenStr, bool isChess960, Thread* th) {
       if (!(attackers_to(st->epSquare) & pieces(sideToMove, PAWN)))
           st->epSquare = SQ_NONE;
   }
       if (!(attackers_to(st->epSquare) & pieces(sideToMove, PAWN)))
           st->epSquare = SQ_NONE;
   }

+  else
+      st->epSquare = SQ_NONE;

 
   // 5-6. Halfmove clock and fullmove number
   ss >> std::skipws >> st->rule50 >> gamePly;
 
   // 5-6. Halfmove clock and fullmove number
   ss >> std::skipws >> st->rule50 >> gamePly;


@@ -304,6 +279,8 @@ void Position::set(const string& fenStr, bool isChess960, Thread* th) {
   set_state(st);
 
   assert(pos_is_ok());
   set_state(st);
 
   assert(pos_is_ok());

+
+  return *this;

 }
 
 
 }
 
 


@@ -1108,7 +1085,7 @@ void Position::flip() {
   std::getline(ss, token); // Half and full moves
   f += token;
 
   std::getline(ss, token); // Half and full moves
   f += token;
 

-  set(f, is_chess960(), this_thread());
+  set(f, is_chess960(), st, this_thread());

 
   assert(pos_is_ok());
 }
 
   assert(pos_is_ok());
 }

diff --git a/src/position.h b/src/position.h
index 1070236be818ffbad0e07e214f5aa443ef2c3234..d44ed009e5d2405d8cb0826241b936724e6df488 100644 (file)
--- a/src/position.h
+++ b/src/position.h
@@ -23,7 +23,9 @@
 
 #include <cassert>
 #include <cstddef>  // For offsetof()
 
 #include <cassert>
 #include <cstddef>  // For offsetof()

+#include <memory>   // For std::unique_ptr

 #include <string>
 #include <string>

+#include <vector>

 
 #include "bitboard.h"
 #include "types.h"
 
 #include "bitboard.h"
 #include "types.h"


@@ -75,6 +77,8 @@ struct StateInfo {
   StateInfo* previous;
 };
 
   StateInfo* previous;
 };
 

+typedef std::unique_ptr<std::vector<StateInfo>> StateListPtr;
+

 
 /// Position class stores information regarding the board representation as
 /// pieces, side to move, hash keys, castling info, etc. Important methods are
 
 /// Position class stores information regarding the board representation as
 /// pieces, side to move, hash keys, castling info, etc. Important methods are


@@ -86,14 +90,12 @@ class Position {
 public:
   static void init();
 
 public:
   static void init();
 

-  Position() = default; // To define the global object RootPos
+  Position() = default;

   Position(const Position&) = delete;
   Position(const Position&) = delete;

-  Position(const Position& pos, Thread* th) { *this = pos; thisThread = th; }
-  Position(const std::string& f, bool c960, Thread* th) { set(f, c960, th); }
-  Position& operator=(const Position&); // To assign RootPos from UCI
+  Position& operator=(const Position&) = delete;

 
   // FEN string input/output
 
   // FEN string input/output

-  void set(const std::string& fenStr, bool isChess960, Thread* th);
+  Position& set(const std::string& fenStr, bool isChess960, StateInfo* si, Thread* th);

   const std::string fen() const;
 
   // Position representation
   const std::string fen() const;
 
   // Position representation


@@ -178,7 +180,6 @@ public:
 
 private:
   // Initialization helpers (used while setting up a position)
 
 private:
   // Initialization helpers (used while setting up a position)

-  void clear();

   void set_castling_right(Color c, Square rfrom);
   void set_state(StateInfo* si) const;
 
   void set_castling_right(Color c, Square rfrom);
   void set_state(StateInfo* si) const;
 


@@ -200,7 +201,6 @@ private:
   int castlingRightsMask[SQUARE_NB];
   Square castlingRookSquare[CASTLING_RIGHT_NB];
   Bitboard castlingPath[CASTLING_RIGHT_NB];
   int castlingRightsMask[SQUARE_NB];
   Square castlingRookSquare[CASTLING_RIGHT_NB];
   Bitboard castlingPath[CASTLING_RIGHT_NB];

-  StateInfo startState;

   uint64_t nodes;
   int gamePly;
   Color sideToMove;
   uint64_t nodes;
   int gamePly;
   Color sideToMove;

diff --git a/src/search.cpp b/src/search.cpp
index 10d491c025e7e9a2383472b812010f9a5dc74839..317645331c5c1d45ebaac7cbc42e9aca06e4fbbe 100644 (file)
--- a/src/search.cpp
+++ b/src/search.cpp
@@ -40,7 +40,6 @@ namespace Search {
 
   SignalsType Signals;
   LimitsType Limits;
 
   SignalsType Signals;
   LimitsType Limits;

-  StateStackPtr SetupStates;

 }
 
 namespace Tablebases {
 }
 
 namespace Tablebases {


@@ -317,16 +316,8 @@ void MainThread::search() {
       }
 
       for (Thread* th : Threads)
       }
 
       for (Thread* th : Threads)

-      {
-          th->maxPly = 0;
-          th->rootDepth = DEPTH_ZERO;

           if (th != this)
           if (th != this)

-          {
-              th->rootPos = Position(rootPos, th);
-              th->rootMoves = rootMoves;

               th->start_searching();
               th->start_searching();

-          }
-      }

 
       Thread::search(); // Let's start searching!
   }
 
       Thread::search(); // Let's start searching!
   }


@@ -1488,7 +1479,7 @@ moves_loop: // When in check search starts from here
 
   Move Skill::pick_best(size_t multiPV) {
 
 
   Move Skill::pick_best(size_t multiPV) {
 

-    const Search::RootMoveVector& rootMoves = Threads.main()->rootMoves;
+    const RootMoves& rootMoves = Threads.main()->rootMoves;

     static PRNG rng(now()); // PRNG sequence should be non-deterministic
 
     // RootMoves are already sorted by score in descending order
     static PRNG rng(now()); // PRNG sequence should be non-deterministic
 
     // RootMoves are already sorted by score in descending order


@@ -1553,7 +1544,7 @@ string UCI::pv(const Position& pos, Depth depth, Value alpha, Value beta) {
 
   std::stringstream ss;
   int elapsed = Time.elapsed() + 1;
 
   std::stringstream ss;
   int elapsed = Time.elapsed() + 1;

-  const Search::RootMoveVector& rootMoves = pos.this_thread()->rootMoves;
+  const RootMoves& rootMoves = pos.this_thread()->rootMoves;

   size_t PVIdx = pos.this_thread()->PVIdx;
   size_t multiPV = std::min((size_t)Options["MultiPV"], rootMoves.size());
   uint64_t nodes_searched = Threads.nodes_searched();
   size_t PVIdx = pos.this_thread()->PVIdx;
   size_t multiPV = std::min((size_t)Options["MultiPV"], rootMoves.size());
   uint64_t nodes_searched = Threads.nodes_searched();

diff --git a/src/search.h b/src/search.h
index 84420373482dfce078751b7883d04bedd59ae1cd..d722af1e63ab4e1c4dad848695e52230201d1520 100644 (file)
--- a/src/search.h
+++ b/src/search.h
@@ -22,8 +22,6 @@
 #define SEARCH_H_INCLUDED
 
 #include <atomic>
 #define SEARCH_H_INCLUDED
 
 #include <atomic>

-#include <memory>  // For std::unique_ptr
-#include <stack>

 #include <vector>
 
 #include "misc.h"
 #include <vector>
 
 #include "misc.h"


@@ -65,7 +63,7 @@ struct RootMove {
   std::vector<Move> pv;
 };
 
   std::vector<Move> pv;
 };
 

-typedef std::vector<RootMove> RootMoveVector;
+typedef std::vector<RootMove> RootMoves;

 
 /// LimitsType struct stores information sent by GUI about available time to
 /// search the current move, maximum depth/time, if we are in analysis mode or
 
 /// LimitsType struct stores information sent by GUI about available time to
 /// search the current move, maximum depth/time, if we are in analysis mode or


@@ -74,8 +72,8 @@ typedef std::vector<RootMove> RootMoveVector;
 struct LimitsType {
 
   LimitsType() { // Init explicitly due to broken value-initialization of non POD in MSVC
 struct LimitsType {
 
   LimitsType() { // Init explicitly due to broken value-initialization of non POD in MSVC

-    nodes = time[WHITE] = time[BLACK] = inc[WHITE] = inc[BLACK] = npmsec = movestogo =
-    depth = movetime = mate = infinite = ponder = 0;
+    nodes = time[WHITE] = time[BLACK] = inc[WHITE] = inc[BLACK] =
+    npmsec = movestogo = depth = movetime = mate = infinite = ponder = 0;

   }
 
   bool use_time_management() const {
   }
 
   bool use_time_management() const {


@@ -95,11 +93,8 @@ struct SignalsType {
   std::atomic_bool stop, stopOnPonderhit;
 };
 
   std::atomic_bool stop, stopOnPonderhit;
 };
 

-typedef std::unique_ptr<std::stack<StateInfo>> StateStackPtr;
-

 extern SignalsType Signals;
 extern LimitsType Limits;
 extern SignalsType Signals;
 extern LimitsType Limits;

-extern StateStackPtr SetupStates;

 
 void init();
 void clear();
 
 void init();
 void clear();

diff --git a/src/syzygy/tbprobe.cpp b/src/syzygy/tbprobe.cpp
index 14d34e79b097af0ac406d822f5dbe1006e245ff3..e07cd1bc3e23e36d7412745356d902828e603217 100644 (file)
--- a/src/syzygy/tbprobe.cpp
+++ b/src/syzygy/tbprobe.cpp
@@ -688,7 +688,7 @@ static Value wdl_to_Value[5] = {
 //
 // A return value false indicates that not all probes were successful and that
 // no moves were filtered out.
 //
 // A return value false indicates that not all probes were successful and that
 // no moves were filtered out.

-bool Tablebases::root_probe(Position& pos, Search::RootMoveVector& rootMoves, Value& score)
+bool Tablebases::root_probe(Position& pos, Search::RootMoves& rootMoves, Value& score)

 {
   int success;
 
 {
   int success;
 


@@ -795,7 +795,7 @@ bool Tablebases::root_probe(Position& pos, Search::RootMoveVector& rootMoves, Va
 //
 // A return value false indicates that not all probes were successful and that
 // no moves were filtered out.
 //
 // A return value false indicates that not all probes were successful and that
 // no moves were filtered out.

-bool Tablebases::root_probe_wdl(Position& pos, Search::RootMoveVector& rootMoves, Value& score)
+bool Tablebases::root_probe_wdl(Position& pos, Search::RootMoves& rootMoves, Value& score)

 {
   int success;
 
 {
   int success;
 

diff --git a/src/syzygy/tbprobe.h b/src/syzygy/tbprobe.h
index 4233e1aae14829037995aaf8d1bddbdd42ab6ffe..2bcc0834c9cb8bb7896679703aa8627f067bba14 100644 (file)
--- a/src/syzygy/tbprobe.h
+++ b/src/syzygy/tbprobe.h
@@ -10,8 +10,8 @@ extern int MaxCardinality;
 void init(const std::string& path);
 int probe_wdl(Position& pos, int *success);
 int probe_dtz(Position& pos, int *success);
 void init(const std::string& path);
 int probe_wdl(Position& pos, int *success);
 int probe_dtz(Position& pos, int *success);

-bool root_probe(Position& pos, Search::RootMoveVector& rootMoves, Value& score);
-bool root_probe_wdl(Position& pos, Search::RootMoveVector& rootMoves, Value& score);
+bool root_probe(Position& pos, Search::RootMoves& rootMoves, Value& score);
+bool root_probe_wdl(Position& pos, Search::RootMoves& rootMoves, Value& score);

 
 }
 
 
 }
 

diff --git a/src/thread.cpp b/src/thread.cpp
index 440b8bf0e4f06b5ea6087aa76c2e9aec3ca02cc0..dc4ec05e2f586607453270181e6cd9e7bbe841d6 100644 (file)
--- a/src/thread.cpp
+++ b/src/thread.cpp
@@ -26,8 +26,6 @@
 #include "thread.h"
 #include "uci.h"
 
 #include "thread.h"
 #include "uci.h"
 

-using namespace Search;
-

 ThreadPool Threads; // Global object
 
 /// Thread constructor launches the thread and then waits until it goes to sleep
 ThreadPool Threads; // Global object
 
 /// Thread constructor launches the thread and then waits until it goes to sleep


@@ -171,26 +169,34 @@ int64_t ThreadPool::nodes_searched() {
 /// ThreadPool::start_thinking() wakes up the main thread sleeping in idle_loop()
 /// and starts a new search, then returns immediately.
 
 /// ThreadPool::start_thinking() wakes up the main thread sleeping in idle_loop()
 /// and starts a new search, then returns immediately.
 

-void ThreadPool::start_thinking(const Position& pos, const LimitsType& limits,
-                                StateStackPtr& states) {
+void ThreadPool::start_thinking(const Position& pos, StateListPtr& states,
+                                const Search::LimitsType& limits) {

 
   main()->wait_for_search_finished();
 
 
   main()->wait_for_search_finished();
 

-  Signals.stopOnPonderhit = Signals.stop = false;
-
-  main()->rootMoves.clear();
-  main()->rootPos = pos;
-  Limits = limits;
-  if (states.get()) // If we don't set a new position, preserve current state
-  {
-      SetupStates = std::move(states); // Ownership transfer here
-      assert(!states.get());
-  }
+  Search::Signals.stopOnPonderhit = Search::Signals.stop = false;
+  Search::Limits = limits;
+  Search::RootMoves rootMoves;

 
   for (const auto& m : MoveList<LEGAL>(pos))
       if (   limits.searchmoves.empty()
           || std::count(limits.searchmoves.begin(), limits.searchmoves.end(), m))
 
   for (const auto& m : MoveList<LEGAL>(pos))
       if (   limits.searchmoves.empty()
           || std::count(limits.searchmoves.begin(), limits.searchmoves.end(), m))

-          main()->rootMoves.push_back(RootMove(m));
+          rootMoves.push_back(Search::RootMove(m));
+
+  // After ownership transfer 'states' becomes empty, so if we stop the search
+  // and call 'go' again without setting a new position states.get() == NULL.
+  assert(states.get() || setupStates.get());
+
+  if (states.get())
+      setupStates = std::move(states); // Ownership transfer, states is now empty
+
+  for (Thread* th : Threads)
+  {
+      th->maxPly = 0;
+      th->rootDepth = DEPTH_ZERO;
+      th->rootMoves = rootMoves;
+      th->rootPos.set(pos.fen(), pos.is_chess960(), &setupStates->back(), th);
+  }

 
   main()->start_searching();
 }
 
   main()->start_searching();
 }

diff --git a/src/thread.h b/src/thread.h
index 43ddfbb710b80643484c48302f32bc931f221b98..0b112de9b0f14540d414c506f61998053ad0c72e 100644 (file)
--- a/src/thread.h
+++ b/src/thread.h
@@ -64,7 +64,7 @@ public:
   int maxPly, callsCnt;
 
   Position rootPos;
   int maxPly, callsCnt;
 
   Position rootPos;

-  Search::RootMoveVector rootMoves;
+  Search::RootMoves rootMoves;

   Depth rootDepth;
   HistoryStats history;
   MoveStats counterMoves;
   Depth rootDepth;
   HistoryStats history;
   MoveStats counterMoves;


@@ -94,9 +94,12 @@ struct ThreadPool : public std::vector<Thread*> {
   void exit(); // be initialized and valid during the whole thread lifetime.
 
   MainThread* main() { return static_cast<MainThread*>(at(0)); }
   void exit(); // be initialized and valid during the whole thread lifetime.
 
   MainThread* main() { return static_cast<MainThread*>(at(0)); }

-  void start_thinking(const Position&, const Search::LimitsType&, Search::StateStackPtr&);
+  void start_thinking(const Position&, StateListPtr&, const Search::LimitsType&);

   void read_uci_options();
   int64_t nodes_searched();
   void read_uci_options();
   int64_t nodes_searched();

+
+private:
+  StateListPtr setupStates;

 };
 
 extern ThreadPool Threads;
 };
 
 extern ThreadPool Threads;

diff --git a/src/timeman.cpp b/src/timeman.cpp
index bc9c2e5b4b7876025d9cf86126cdeec4f242a633..c7c19f47cce34a8d53cc15cf61c3f87c5d5755a9 100644 (file)
--- a/src/timeman.cpp
+++ b/src/timeman.cpp
@@ -33,7 +33,7 @@ namespace {
   enum TimeType { OptimumTime, MaxTime };
 
   const int MoveHorizon   = 50;   // Plan time management at most this many moves ahead
   enum TimeType { OptimumTime, MaxTime };
 
   const int MoveHorizon   = 50;   // Plan time management at most this many moves ahead

-  const double MaxRatio   = 7.09;  // When in trouble, we can step over reserved time with this ratio
+  const double MaxRatio   = 7.09; // When in trouble, we can step over reserved time with this ratio

   const double StealRatio = 0.35; // However we must not steal time from remaining moves over this ratio
 
 
   const double StealRatio = 0.35; // However we must not steal time from remaining moves over this ratio
 
 

diff --git a/src/uci.cpp b/src/uci.cpp
index 4d12ca40c30dc43d11ea64c5b22fadc39503f9d9..cfd253b1f586a5c8d7ddda7f50bb8b5b8162eeac 100644 (file)
--- a/src/uci.cpp
+++ b/src/uci.cpp
@@ -39,10 +39,10 @@ namespace {
   // FEN string of the initial position, normal chess
   const char* StartFEN = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1";
 
   // FEN string of the initial position, normal chess
   const char* StartFEN = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1";
 

-  // Stack to keep track of the position states along the setup moves (from the
+  // 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.
   // start position to the position just before the search starts). Needed by
   // 'draw by repetition' detection.

-  Search::StateStackPtr SetupStates;
+  StateListPtr States(new std::vector<StateInfo>(1));

 
 
   // position() is called when engine receives the "position" UCI command.
 
 
   // position() is called when engine receives the "position" UCI command.


@@ -68,14 +68,14 @@ namespace {
     else
         return;
 
     else
         return;
 

-    pos.set(fen, Options["UCI_Chess960"], Threads.main());
-    SetupStates = Search::StateStackPtr(new std::stack<StateInfo>);
+    States = StateListPtr(new std::vector<StateInfo>(1));
+    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)
     {
 
     // Parse move list (if any)
     while (is >> token && (m = UCI::to_move(pos, token)) != MOVE_NONE)
     {

-        SetupStates->push(StateInfo());
-        pos.do_move(m, SetupStates->top(), pos.gives_check(m, CheckInfo(pos)));
+        States->push_back(StateInfo());
+        pos.do_move(m, States->back(), pos.gives_check(m, CheckInfo(pos)));

     }
   }
 
     }
   }
 


@@ -132,7 +132,7 @@ namespace {
         else if (token == "infinite")  limits.infinite = 1;
         else if (token == "ponder")    limits.ponder = 1;
 
         else if (token == "infinite")  limits.infinite = 1;
         else if (token == "ponder")    limits.ponder = 1;
 

-    Threads.start_thinking(pos, limits, SetupStates);
+    Threads.start_thinking(pos, States, limits);

   }
 
 } // namespace
   }
 
 } // namespace


@@ -146,9 +146,11 @@ namespace {
 
 void UCI::loop(int argc, char* argv[]) {
 
 
 void UCI::loop(int argc, char* argv[]) {
 

-  Position pos(StartFEN, false, Threads.main()); // The root position
+  Position pos;

   string token, cmd;
 
   string token, cmd;
 

+  pos.set(StartFEN, false, &States->back(), Threads.main());
+

   for (int i = 1; i < argc; ++i)
       cmd += std::string(argv[i]) + " ";
 
   for (int i = 1; i < argc; ++i)
       cmd += std::string(argv[i]) + " ";