Implemented PVS at root nodes, using previous' iteration move as firs…

…t move
crybot · Jun 28, 2017 · 3e55e41 · 3e55e41
1 parent afdacb9
commit 3e55e41
Show file tree

Hide file tree

Showing 8 changed files with 91 additions and 23 deletions.
diff --git a/NapoleonPP b/NapoleonPP
diff --git a/search.cpp b/search.cpp
@@ -17,6 +17,8 @@
 namespace Napoleon
 {
     TranspositionTable Search::Table;
+    bool Search::pondering = false;
+    std::atomic<bool> Search::PonderHit(false);
     std::atomic<bool> Search::StopSignal(true);
     std::atomic<bool> Search::quit(false);
     int Search::GameTime[2];
@@ -34,6 +36,12 @@ namespace Napoleon
     int Search::cores;
     const int Search::default_cores = 1;
 
+    int Search::predictTime(Color color)
+    {
+        int gameTime = GameTime[color];
+        return gameTime / 30 - (gameTime / (60 * 1000));
+    }
+
     // direct interface to the client.
     // it sends the move to the uci gui
     Move Search::StartThinking(SearchType type, Board& board, bool verbose, bool san)
@@ -44,10 +52,12 @@ namespace Napoleon
 
         sendOutput = verbose;
         StopSignal = false;
+        pondering = false;
         searchInfo.SetDepthLimit(depth_limit);
 
-        if (type == SearchType::Infinite)
+        if (type == SearchType::Infinite || type == SearchType::Ponder)
         {
+            if (type == SearchType::Ponder) pondering = true;
             searchInfo.NewSearch(); // default time = Time::Infinite
         }
         else
@@ -71,10 +81,23 @@ namespace Napoleon
 
         if (sendOutput)
         {
+            Move ponder = getPonderMove(board, move);
             if (san)
-                Uci::SendCommand<Command::Move>(move.ToSan(board));
+            {
+                if (ponder.IsNull())
+                    Uci::SendCommand<Command::Move>(move.ToSan(board));
+                else 
+                    Uci::SendCommand<Command::Move>(move.ToSan(board), ponder.ToSan(board));
+            }
             else
-                Uci::SendCommand<Command::Move>(move.ToAlgebraic());
+            {
+                if (ponder.IsNull())
+                    Uci::SendCommand<Command::Move>(move.ToAlgebraic());
+                else 
+                    Uci::SendCommand<Command::Move>(move.ToAlgebraic(), ponder.ToAlgebraic());
+
+            }
+
         }
 
         searchInfo.StopSearch();
@@ -166,10 +189,16 @@ namespace Napoleon
         score = searchRoot(searchInfo.MaxDepth(), -Constants::Infinity, Constants::Infinity, move, board);
         searchInfo.IncrementDepth();
 
-        while ((searchInfo.MaxDepth() < 100 && !searchInfo.TimeOver()))
+        while ((searchInfo.MaxDepth() < 100 && !searchInfo.TimeOver()) || pondering)
         {
             if (StopSignal)
                 break;
+            if(PonderHit)
+            {
+                searchInfo.SetGameTime(predictTime(board.SideToMove()));
+                PonderHit = false;
+                pondering = false;
+            }
 
             searchInfo.MaxPly = 0;
             searchInfo.ResetNodes();
@@ -181,13 +210,10 @@ namespace Napoleon
             temp = searchRoot(searchInfo.MaxDepth(), score - AspirationValue, score + AspirationValue, move, board);
 
             if (temp <= score - AspirationValue)
-            {
                 temp = searchRoot(searchInfo.MaxDepth(), -Constants::Infinity, score + AspirationValue, move, board);
-            }
-            else if (temp >= score + AspirationValue)
-            {
+
+            if (temp >= score + AspirationValue)
                 temp = searchRoot(searchInfo.MaxDepth(), score - AspirationValue, Constants::Infinity, move, board);
-            }
 
             score = temp;
 
@@ -218,6 +244,7 @@ namespace Napoleon
         }
 
         moves.Sort<false>();
+        moves.hashMove = moveToMake;
 
         int i = 0;
         for (auto move = moves.First(); !move.IsNull(); move = moves.Next(), i++)
@@ -229,7 +256,12 @@ namespace Napoleon
             if (i == 0) // leftmost node
                 score = -Search::search<NodeType::PV>(depth - 1, -beta, -alpha, 1, board, false); // pv node
             else
-                score = -Search::search<NodeType::NONPV>(depth - 1, -beta, -alpha, 1, board, true); // cut node
+            {
+                score = -search<NodeType::NONPV>(depth - 1, -alpha - 1, -alpha, 1, board, true);
+
+                if (score > alpha)
+                    score = -search<NodeType::PV>(depth - 1, -beta, -alpha, 1, board, false);
+            }
             board.UndoMove(move);
 
             if (score > alpha)
@@ -395,15 +427,16 @@ namespace Napoleon
 
             MoveSelector moves(board, searchInfo);
 
-            if (moves.count == 1) // forced move extension
-            {
-                assert(false);
-                extension = true;
-                ++depth;
-            }
-
             MoveGenerator::GetPseudoLegalMoves<false>(moves.moves, moves.count, attackers, board); // get captures and non-captures
 
+            /*
+               if (moves.count == 1) // forced move extension
+               {
+               extension = true;
+               ++depth;
+               }
+               */
+
             moves.Sort<false>(ply);
             moves.hashMove = best;
 
@@ -519,13 +552,13 @@ namespace Napoleon
                         {
                             R = 1;
 
-                            if (eval + board.MaterialBalance(Utils::Piece::GetOpposite(board.SideToMove())) + newDepth * 250 <= alpha)
+                            if (moveNumber > 9)
                             {
                                 R = 2;
                             }
                         }
 
-                        newDepth = depth - R;
+                        newDepth = std::max(1, depth - R);
 
                         score = -search<NodeType::NONPV>(newDepth - 1, -alpha - 1, -alpha, ply + 1, board, !cut_node);
 
@@ -703,4 +736,15 @@ namespace Napoleon
 
         return info.str();
     }
+
+    Move Search::getPonderMove(Board& board, const Move toMake)
+    {
+        Move move = Constants::NullMove;
+        board.MakeMove(toMake);
+        move = Table.GetPv(board.zobrist);
+        board.UndoMove(toMake);
+
+        return move;
+    }
+
 }
diff --git a/search.h b/search.h
@@ -15,7 +15,7 @@ namespace Napoleon
 {
     enum class SearchType
     {
-        Infinite, TimePerGame, TimePerMove
+        Infinite, TimePerGame, TimePerMove, Ponder
     };
 
     enum class NodeType
@@ -28,6 +28,8 @@ namespace Napoleon
     namespace Search
     {
         extern const int AspirationValue;
+        extern bool pondering;
+        extern std::atomic<bool> PonderHit;
         extern std::atomic<bool> StopSignal;
         extern int MoveTime;
         extern int GameTime[2]; // by color
@@ -46,9 +48,11 @@ namespace Napoleon
         void KillThreads();
         void signalThreads(int, int, int, const Board&, bool);
         void parallelSearch();
+        int predictTime(Color);
 
         std::string GetInfo(Board&, Move, int, int, int);
         std::string GetPv(Board&, Move, int);
+        Move getPonderMove(Board&, const Move);
 
         Move StartThinking(SearchType, Board&, bool=true, bool=false);
         void StopThinking();

diff --git a/searchinfo.cpp b/searchinfo.cpp
@@ -49,5 +49,11 @@ namespace Napoleon
         nodes = 0;
     }
 
+    void SearchInfo::SetGameTime(int time)
+    {
+        allocatedTime = time;
+        timer.Restart();
+    }
+
 
 }
diff --git a/searchinfo.h b/searchinfo.h
@@ -27,6 +27,7 @@ namespace Napoleon
         void SetKillers(Move, int);
         void SetHistory(Move, Color, int);
         void SetDepthLimit(int);
+        void SetGameTime(int);
 
         Move FirstKiller(int);
         Move SecondKiller(int);

diff --git a/transpositiontable.cpp b/transpositiontable.cpp
@@ -97,6 +97,7 @@ namespace Napoleon
         std::memset(table, 0, entries*sizeof(HashEntry));
     }
 
+    //TODO return BEST pv move (exact score)
     Move TranspositionTable::GetPv(ZobristKey key)
     {
         auto hash = at(key);

diff --git a/uci.cpp b/uci.cpp
@@ -92,6 +92,7 @@ namespace Napoleon
             }
             else if (cmd == "position")
             {
+                //Search::StopThinking();
                 Move move;
                 string token;
                 stream >> token;
@@ -137,6 +138,11 @@ namespace Napoleon
                 if (Search::StopSignal)
                     go(stream);
             }
+            else if (cmd == "ponderhit")
+            {
+                assert(false);
+                Search::PonderHit = true;
+            }
         }
     }
 
@@ -173,6 +179,10 @@ namespace Napoleon
             {
                 type = SearchType::Infinite;
             }
+            else if (token == "ponder")
+            {
+                type = SearchType::Ponder;
+            }
 
         }
 

diff --git a/uci.h b/uci.h
@@ -17,23 +17,25 @@ namespace Napoleon
         void Start();
 
         template<Command>
-        void SendCommand(std::string);   
+        void SendCommand(std::string, std::string="");   
         void go(std::istringstream&);
 
         extern Board board;
         extern std::thread search;
     }
 
     template<Command cmdType>
-    void Uci::SendCommand(std::string command)
+    void Uci::SendCommand(std::string command, std::string ponder)
     {
         switch(cmdType)
         {
         case Command::Generic:
             std::cout << command << std::endl;
             break;
         case Command::Move:
-            std::cout << "bestmove " << command << std::endl;
+            std::cout << "bestmove " << command;
+            if(!ponder.empty()) std::cout << " ponder " << ponder;
+            std::cout << std::endl;
             break;
         case Command::Info:
             std::cout << "info " << command << std::endl;