X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fsearch.cpp;h=902049c351205e8f32405f999f978d8c21ef35e1;hp=af895a376388890827fc4277e842ae036cc697c8;hb=8bf9dc825420bddb6d8425352e53a97a285027ec;hpb=fdc9f8cbd787e61c4b9bff8a220235e9daa22c2c

diff --git a/src/search.cpp b/src/search.cpp
index af895a37..902049c3 100644
--- a/src/search.cpp
+++ b/src/search.cpp
@@ -64,6 +64,7 @@ namespace {
        static storage duration are automatically set to zero before enter main()
     */
   public:
+    Thread& operator[](int threadID) { return threads[threadID]; }
     void init_threads();
     void exit_threads();
 
@@ -75,13 +76,11 @@ namespace {
     bool available_thread_exists(int master) const;
     bool thread_is_available(int slave, int master) const;
     bool cutoff_at_splitpoint(int threadID) const;
-    void wake_sleeping_thread(int threadID);
     void idle_loop(int threadID, SplitPoint* sp);
 
     template <bool Fake>
     void split(Position& pos, SearchStack* ss, Value* alpha, const Value beta, Value* bestValue,
                Depth depth, Move threatMove, int moveCount, MovePicker* mp, bool pvNode);
-
   private:
     Lock mpLock;
     Depth minimumSplitDepth;
@@ -117,7 +116,7 @@ namespace {
 
     void extract_pv_from_tt(Position& pos);
     void insert_pv_in_tt(Position& pos);
-    std::string pv_info_to_uci(Position& pos, int depth, Value alpha, Value beta, int pvIdx);
+    std::string pv_info_to_uci(Position& pos, int depth, int selDepth, Value alpha, Value beta, int pvIdx);
 
     int64_t nodes;
     Value pv_score;
@@ -234,7 +233,7 @@ namespace {
   int MultiPV, UCIMultiPV;
 
   // Time management variables
-  int SearchStartTime, MaxNodes, MaxDepth, ExactMaxTime;
+  int MaxNodes, MaxDepth, ExactMaxTime;
   bool UseTimeManagement, InfiniteSearch, Pondering, StopOnPonderhit;
   bool FirstRootMove, StopRequest, QuitRequest, AspirationFailLow;
   TimeManager TimeMgr;
@@ -292,7 +291,7 @@ namespace {
   void update_gains(const Position& pos, Move move, Value before, Value after);
   void do_skill_level(Move* best, Move* ponder);
 
-  int current_search_time();
+  int current_search_time(int set = 0);
   std::string value_to_uci(Value v);
   std::string speed_to_uci(int64_t nodes);
   void poll(const Position& pos);
@@ -449,7 +448,7 @@ bool think(Position& pos, bool infinite, bool ponder, int time[], int increment[
   // Initialize global search-related variables
   StopOnPonderhit = StopRequest = QuitRequest = AspirationFailLow = SendSearchedNodes = false;
   NodesSincePoll = 0;
-  SearchStartTime = get_system_time();
+  current_search_time(get_system_time());
   ExactMaxTime = maxTime;
   MaxDepth = maxDepth;
   MaxNodes = maxNodes;
@@ -505,9 +504,12 @@ bool think(Position& pos, bool infinite, bool ponder, int time[], int increment[
   ThreadsMgr.read_uci_options();
   init_eval(ThreadsMgr.active_threads());
 
-  // Wake up needed threads. Main thread, with threadID == 0, is always active
-  for (int i = 1; i < ThreadsMgr.active_threads(); i++)
-      ThreadsMgr.wake_sleeping_thread(i);
+  // Wake up needed threads and reset maxPly counter
+  for (int i = 0; i < ThreadsMgr.active_threads(); i++)
+  {
+      ThreadsMgr[i].wake_up();
+      ThreadsMgr[i].maxPly = 0;
+  }
 
   // Set thinking time
   int myTime = time[pos.side_to_move()];
@@ -595,7 +597,7 @@ namespace {
     SearchStack ss[PLY_MAX_PLUS_2];
     Value bestValues[PLY_MAX_PLUS_2];
     int bestMoveChanges[PLY_MAX_PLUS_2];
-    int depth, aspirationDelta;
+    int depth, selDepth, aspirationDelta;
     Value value, alpha, beta;
     Move bestMove, easyMove, skillBest, skillPonder;
 
@@ -687,9 +689,15 @@ namespace {
         if (SkillLevelEnabled && depth == 1 + SkillLevel)
             do_skill_level(&skillBest, &skillPonder);
 
+        // Retrieve max searched depth among threads
+        selDepth = 0;
+        for (int i = 0; i < ThreadsMgr.active_threads(); i++)
+            if (ThreadsMgr[i].maxPly > selDepth)
+                selDepth = ThreadsMgr[i].maxPly;
+
         // Send PV line to GUI and to log file
         for (int i = 0; i < Min(UCIMultiPV, (int)Rml.size()); i++)
-            cout << Rml[i].pv_info_to_uci(pos, depth, alpha, beta, i) << endl;
+            cout << Rml[i].pv_info_to_uci(pos, depth, selDepth, alpha, beta, i) << endl;
 
         if (UseLogFile)
             LogFile << pretty_pv(pos, depth, value, current_search_time(), Rml[0].pv) << endl;
@@ -792,6 +800,10 @@ namespace {
     isCheck = pos.is_check();
     ss->ply = (ss-1)->ply + 1;
 
+    // Used to send selDepth info to GUI
+    if (PvNode && ThreadsMgr[threadID].maxPly < ss->ply)
+        ThreadsMgr[threadID].maxPly = ss->ply;
+
     if (SpNode)
     {
         sp = ss->sp;
@@ -1831,9 +1843,14 @@ split_point_start: // At split points actual search starts from here
   // current_search_time() returns the number of milliseconds which have passed
   // since the beginning of the current search.
 
-  int current_search_time() {
+  int current_search_time(int set) {
+
+    static int searchStartTime;
 
-    return get_system_time() - SearchStartTime;
+    if (set)
+        searchStartTime = set;
+
+    return get_system_time() - searchStartTime;
   }
 
 
@@ -1849,9 +1866,9 @@ split_point_start: // At split points actual search starts from here
     std::stringstream s;
 
     if (abs(v) < VALUE_MATE - PLY_MAX * ONE_PLY)
-      s << "cp " << int(v) * 100 / int(PawnValueMidgame); // Scale to centipawns
+        s << "cp " << int(v) * 100 / int(PawnValueMidgame); // Scale to centipawns
     else
-      s << "mate " << (v > 0 ? VALUE_MATE - v + 1 : -VALUE_MATE - v) / 2;
+        s << "mate " << (v > 0 ? VALUE_MATE - v + 1 : -VALUE_MATE - v) / 2;
 
     return s.str();
   }
@@ -2021,7 +2038,7 @@ split_point_start: // At split points actual search starts from here
     assert(threadID >= 0 && threadID < MAX_THREADS);
 
     int i;
-    bool allFinished = false;
+    bool allFinished;
 
     while (true)
     {
@@ -2036,7 +2053,8 @@ split_point_start: // At split points actual search starts from here
 
         // If we are not thinking, wait for a condition to be signaled
         // instead of wasting CPU time polling for work.
-        while (   threadID >= activeThreads || threads[threadID].state == THREAD_INITIALIZING
+        while (   threadID >= activeThreads
+               || threads[threadID].state == THREAD_INITIALIZING
                || (useSleepingThreads && threads[threadID].state == THREAD_AVAILABLE))
         {
             assert(!sp || useSleepingThreads);
@@ -2045,7 +2063,7 @@ split_point_start: // At split points actual search starts from here
             if (threads[threadID].state == THREAD_INITIALIZING)
                 threads[threadID].state = THREAD_AVAILABLE;
 
-            // Grab the lock to avoid races with wake_sleeping_thread()
+            // Grab the lock to avoid races with Thread::wake_up()
             lock_grab(&threads[threadID].sleepLock);
 
             // If we are master and all slaves have finished do not go to sleep
@@ -2072,7 +2090,7 @@ split_point_start: // At split points actual search starts from here
 
             threads[threadID].state = THREAD_SEARCHING;
 
-            // Copy SplitPoint position and search stack and call search()
+            // Copy split point position and search stack and call search()
             // with SplitPoint template parameter set to true.
             SearchStack ss[PLY_MAX_PLUS_2];
             SplitPoint* tsp = threads[threadID].splitPoint;
@@ -2092,8 +2110,10 @@ split_point_start: // At split points actual search starts from here
 
             // Wake up master thread so to allow it to return from the idle loop in
             // case we are the last slave of the split point.
-            if (useSleepingThreads && threadID != tsp->master && threads[tsp->master].state == THREAD_AVAILABLE)
-                wake_sleeping_thread(tsp->master);
+            if (   useSleepingThreads
+                && threadID != tsp->master
+                && threads[tsp->master].state == THREAD_AVAILABLE)
+                threads[tsp->master].wake_up();
         }
 
         // If this thread is the master of a split point and all slaves have
@@ -2119,41 +2139,36 @@ split_point_start: // At split points actual search starts from here
   }
 
 
-  // init_threads() is called during startup. It launches all helper threads,
-  // and initializes the split point stack and the global locks and condition
-  // objects.
+  // init_threads() is called during startup. Initializes locks and condition
+  // variables and launches all threads sending them immediately to sleep.
 
   void ThreadsManager::init_threads() {
 
     int i, arg[MAX_THREADS];
     bool ok;
 
-    // Initialize global locks
+    // This flag is needed to properly end the threads when program exits
+    allThreadsShouldExit = false;
+
+    // Threads will sent to sleep as soon as created, only main thread is kept alive
+    activeThreads = 1;
+
     lock_init(&mpLock);
 
     for (i = 0; i < MAX_THREADS; i++)
     {
+        // Initialize thread and split point locks
         lock_init(&threads[i].sleepLock);
         cond_init(&threads[i].sleepCond);
-    }
 
-    // Initialize splitPoints[] locks
-    for (i = 0; i < MAX_THREADS; i++)
         for (int j = 0; j < MAX_ACTIVE_SPLIT_POINTS; j++)
             lock_init(&(threads[i].splitPoints[j].lock));
 
-    // Will be set just before program exits to properly end the threads
-    allThreadsShouldExit = false;
-
-    // Threads will be put all threads to sleep as soon as created
-    activeThreads = 1;
-
-    // All threads except the main thread should be initialized to THREAD_INITIALIZING
-    threads[0].state = THREAD_SEARCHING;
-    for (i = 1; i < MAX_THREADS; i++)
-        threads[i].state = THREAD_INITIALIZING;
+        // All threads but first should be set to THREAD_INITIALIZING
+        threads[i].state = (i == 0 ? THREAD_SEARCHING : THREAD_INITIALIZING);
+    }
 
-    // Launch the helper threads
+    // Create and startup the threads
     for (i = 1; i < MAX_THREADS; i++)
     {
         arg[i] = i;
@@ -2182,28 +2197,27 @@ split_point_start: // At split points actual search starts from here
 
   void ThreadsManager::exit_threads() {
 
-    allThreadsShouldExit = true; // Let the woken up threads to exit idle_loop()
+    // Force the woken up threads to exit idle_loop() and hence terminate
+    allThreadsShouldExit = true;
 
-    // Wake up all the threads and waits for termination
-    for (int i = 1; i < MAX_THREADS; i++)
+    for (int i = 0; i < MAX_THREADS; i++)
     {
-        wake_sleeping_thread(i);
-        while (threads[i].state != THREAD_TERMINATED) {}
-    }
+        // Wake up all the threads and waits for termination
+        if (i != 0)
+        {
+            threads[i].wake_up();
+            while (threads[i].state != THREAD_TERMINATED) {}
+        }
+
+        // Now we can safely destroy the locks and wait conditions
+        lock_destroy(&threads[i].sleepLock);
+        cond_destroy(&threads[i].sleepCond);
 
-    // Now we can safely destroy the locks
-    for (int i = 0; i < MAX_THREADS; i++)
         for (int j = 0; j < MAX_ACTIVE_SPLIT_POINTS; j++)
             lock_destroy(&(threads[i].splitPoints[j].lock));
+    }
 
     lock_destroy(&mpLock);
-
-    // Now we can safely destroy the wait conditions
-    for (int i = 0; i < MAX_THREADS; i++)
-    {
-        lock_destroy(&threads[i].sleepLock);
-        cond_destroy(&threads[i].sleepCond);
-    }
   }
 
 
@@ -2362,7 +2376,7 @@ split_point_start: // At split points actual search starts from here
             threads[i].state = THREAD_WORKISWAITING; // This makes the slave to exit from idle_loop()
 
             if (useSleepingThreads && i != master)
-                wake_sleeping_thread(i);
+                threads[i].wake_up();
         }
 
     // Everything is set up. The master thread enters the idle loop, from
@@ -2386,17 +2400,6 @@ split_point_start: // At split points actual search starts from here
   }
 
 
-  // wake_sleeping_thread() wakes up the thread with the given threadID
-  // when it is time to start a new search.
-
-  void ThreadsManager::wake_sleeping_thread(int threadID) {
-
-     lock_grab(&threads[threadID].sleepLock);
-     cond_signal(&threads[threadID].sleepCond);
-     lock_release(&threads[threadID].sleepLock);
-  }
-
-
   /// RootMove and RootMoveList method's definitions
 
   RootMove::RootMove() {
@@ -2483,21 +2486,20 @@ split_point_start: // At split points actual search starts from here
   // pv_info_to_uci() returns a string with information on the current PV line
   // formatted according to UCI specification.
 
-  std::string RootMove::pv_info_to_uci(Position& pos, int depth, Value alpha,
+  std::string RootMove::pv_info_to_uci(Position& pos, int depth, int selDepth, Value alpha,
                                        Value beta, int pvIdx) {
-    std::stringstream s, l;
-    Move* m = pv;
-
-    while (*m != MOVE_NONE)
-        l << *m++ << " ";
+    std::stringstream s;
 
     s << "info depth " << depth
-      << " seldepth " << int(m - pv)
+      << " seldepth " << selDepth
       << " multipv " << pvIdx + 1
       << " score " << value_to_uci(pv_score)
       << (pv_score >= beta ? " lowerbound" : pv_score <= alpha ? " upperbound" : "")
       << speed_to_uci(pos.nodes_searched())
-      << " pv "    << l.str();
+      << " pv ";
+
+    for (Move* m = pv; *m != MOVE_NONE; m++)
+        s << *m << " ";
 
     return s.str();
   }