X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Fthread.cpp;h=b38bdd6ed51e2848fd60770c936d7a80793e427c;hb=ca14345ba26fc40e1039029659f57028f510502f;hp=30c921d1808ebd4716dee58bab6deeefe0e54279;hpb=fecefbb99cb0147f37d6895765a315f34c935786;p=stockfish

diff --git a/src/thread.cpp b/src/thread.cpp
index 30c921d1..b38bdd6e 100644
--- a/src/thread.cpp
+++ b/src/thread.cpp
@@ -1,7 +1,8 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2015-2016 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
@@ -17,317 +18,192 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#include <iostream>
+#include <algorithm> // For std::count
+#include <cassert>
 
+#include "movegen.h"
+#include "search.h"
 #include "thread.h"
-#include "ucioption.h"
+#include "uci.h"
+#include "syzygy/tbprobe.h"
 
-ThreadsManager ThreadsMgr; // Global object definition
+ThreadPool Threads; // Global object
 
-namespace {
+/// Thread constructor launches the thread and then waits until it goes to sleep
+/// in idle_loop().
 
- // init_thread() is the function which is called when a new thread is
- // launched. It simply calls the idle_loop() function with the supplied
- // threadID. There are two versions of this function; one for POSIX
- // threads and one for Windows threads.
+Thread::Thread() {
 
-#if !defined(_MSC_VER)
+  resetCalls = exit = false;
+  maxPly = callsCnt = 0;
+  history.clear();
+  counterMoves.clear();
+  idx = Threads.size(); // Start from 0
 
-  void* init_thread(void* threadID) {
-
-    ThreadsMgr.idle_loop(*(int*)threadID, NULL);
-    return NULL;
-  }
-
-#else
+  std::unique_lock<Mutex> lk(mutex);
+  searching = true;
+  nativeThread = std::thread(&Thread::idle_loop, this);
+  sleepCondition.wait(lk, [&]{ return !searching; });
+}
 
-  DWORD WINAPI init_thread(LPVOID threadID) {
 
-    ThreadsMgr.idle_loop(*(int*)threadID, NULL);
-    return 0;
-  }
+/// Thread destructor waits for thread termination before returning
 
-#endif
+Thread::~Thread() {
 
+  mutex.lock();
+  exit = true;
+  sleepCondition.notify_one();
+  mutex.unlock();
+  nativeThread.join();
 }
 
 
-// read_uci_options() updates number of active threads and other internal
-// parameters according to the UCI options values. It is called before
-// to start a new search.
+/// Thread::wait_for_search_finished() waits on sleep condition
+/// until not searching
 
-void ThreadsManager::read_uci_options() {
+void Thread::wait_for_search_finished() {
 
-  maxThreadsPerSplitPoint = Options["Maximum Number of Threads per Split Point"].value<int>();
-  minimumSplitDepth       = Options["Minimum Split Depth"].value<int>() * ONE_PLY;
-  useSleepingThreads      = Options["Use Sleeping Threads"].value<bool>();
-  activeThreads           = Options["Threads"].value<int>();
+  std::unique_lock<Mutex> lk(mutex);
+  sleepCondition.wait(lk, [&]{ return !searching; });
 }
 
-// init_threads() is called during startup. Initializes locks and condition
-// variables and launches all threads sending them immediately to sleep.
 
-void ThreadsManager::init_threads() {
+/// Thread::wait() waits on sleep condition until condition is true
 
-  int i, arg[MAX_THREADS];
-  bool ok;
+void Thread::wait(std::atomic_bool& condition) {
 
-  // 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;
+  std::unique_lock<Mutex> lk(mutex);
+  sleepCondition.wait(lk, [&]{ return bool(condition); });
+}
 
-  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);
+/// Thread::start_searching() wakes up the thread that will start the search
 
-      for (int j = 0; j < MAX_ACTIVE_SPLIT_POINTS; j++)
-          lock_init(&(threads[i].splitPoints[j].lock));
+void Thread::start_searching(bool resume) {
 
-      // All threads but first should be set to THREAD_INITIALIZING
-      threads[i].state = (i == 0 ? THREAD_SEARCHING : THREAD_INITIALIZING);
+  std::unique_lock<Mutex> lk(mutex);
 
-      // Not in Threads c'tor to avoid global initialization order issues
-      threads[i].pawnTable.init();
-      threads[i].materialTable.init();
-  }
+  if (!resume)
+      searching = true;
 
-  // Create and startup the threads
-  for (i = 1; i < MAX_THREADS; i++)
-  {
-      arg[i] = i;
-
-#if !defined(_MSC_VER)
-      pthread_t pthread[1];
-      ok = (pthread_create(pthread, NULL, init_thread, (void*)(&arg[i])) == 0);
-      pthread_detach(pthread[0]);
-#else
-      ok = (CreateThread(NULL, 0, init_thread, (LPVOID)(&arg[i]), 0, NULL) != NULL);
-#endif
-      if (!ok)
-      {
-          std::cout << "Failed to create thread number " << i << std::endl;
-          exit(EXIT_FAILURE);
-      }
-
-      // Wait until the thread has finished launching and is gone to sleep
-      while (threads[i].state == THREAD_INITIALIZING) {}
-  }
+  sleepCondition.notify_one();
 }
 
 
-// exit_threads() is called when the program exits. It makes all the
-// helper threads exit cleanly.
-
-void ThreadsManager::exit_threads() {
+/// Thread::idle_loop() is where the thread is parked when it has no work to do
 
-  // Force the woken up threads to exit idle_loop() and hence terminate
-  allThreadsShouldExit = true;
+void Thread::idle_loop() {
 
-  for (int i = 0; i < MAX_THREADS; i++)
+  while (!exit)
   {
-      // Wake up all the threads and waits for termination
-      if (i != 0)
+      std::unique_lock<Mutex> lk(mutex);
+
+      searching = false;
+
+      while (!searching && !exit)
       {
-          threads[i].wake_up();
-          while (threads[i].state != THREAD_TERMINATED) {}
+          sleepCondition.notify_one(); // Wake up any waiting thread
+          sleepCondition.wait(lk);
       }
 
-      // Now we can safely destroy the locks and wait conditions
-      lock_destroy(&threads[i].sleepLock);
-      cond_destroy(&threads[i].sleepCond);
+      lk.unlock();
 
-      for (int j = 0; j < MAX_ACTIVE_SPLIT_POINTS; j++)
-          lock_destroy(&(threads[i].splitPoints[j].lock));
+      if (!exit)
+          search();
   }
-
-  lock_destroy(&mpLock);
 }
 
 
-// cutoff_at_splitpoint() checks whether a beta cutoff has occurred in
-// the thread's currently active split point, or in some ancestor of
-// the current split point.
-
-bool ThreadsManager::cutoff_at_splitpoint(int threadID) const {
+/// ThreadPool::init() creates and launches requested threads that will go
+/// immediately to sleep. We cannot use a constructor because Threads is a
+/// static object and we need a fully initialized engine at this point due to
+/// allocation of Endgames in the Thread constructor.
 
-  assert(threadID >= 0 && threadID < activeThreads);
+void ThreadPool::init() {
 
-  SplitPoint* sp = threads[threadID].splitPoint;
-
-  for ( ; sp && !sp->betaCutoff; sp = sp->parent) {}
-  return sp != NULL;
+  push_back(new MainThread);
+  read_uci_options();
 }
 
 
-// thread_is_available() checks whether the thread with threadID "slave" is
-// available to help the thread with threadID "master" at a split point. An
-// obvious requirement is that "slave" must be idle. With more than two
-// threads, this is not by itself sufficient:  If "slave" is the master of
-// some active split point, it is only available as a slave to the other
-// threads which are busy searching the split point at the top of "slave"'s
-// split point stack (the "helpful master concept" in YBWC terminology).
+/// ThreadPool::exit() terminates threads before the program exits. Cannot be
+/// done in destructor because threads must be terminated before deleting any
+/// static objects while still in main().
 
-bool ThreadsManager::thread_is_available(int slave, int master) const {
+void ThreadPool::exit() {
 
-  assert(slave >= 0 && slave < activeThreads);
-  assert(master >= 0 && master < activeThreads);
-  assert(activeThreads > 1);
+  while (size())
+      delete back(), pop_back();
+}
 
-  if (threads[slave].state != THREAD_AVAILABLE || slave == master)
-      return false;
 
-  // Make a local copy to be sure doesn't change under our feet
-  int localActiveSplitPoints = threads[slave].activeSplitPoints;
+/// ThreadPool::read_uci_options() updates internal threads parameters from the
+/// corresponding UCI options and creates/destroys threads to match requested
+/// number. Thread objects are dynamically allocated.
 
-  // No active split points means that the thread is available as
-  // a slave for any other thread.
-  if (localActiveSplitPoints == 0 || activeThreads == 2)
-      return true;
+void ThreadPool::read_uci_options() {
 
-  // Apply the "helpful master" concept if possible. Use localActiveSplitPoints
-  // that is known to be > 0, instead of threads[slave].activeSplitPoints that
-  // could have been set to 0 by another thread leading to an out of bound access.
-  if (threads[slave].splitPoints[localActiveSplitPoints - 1].slaves[master])
-      return true;
+  size_t requested = Options["Threads"];
 
-  return false;
-}
+  assert(requested > 0);
 
+  while (size() < requested)
+      push_back(new Thread);
 
-// available_thread_exists() tries to find an idle thread which is available as
-// a slave for the thread with threadID "master".
+  while (size() > requested)
+      delete back(), pop_back();
+}
 
-bool ThreadsManager::available_thread_exists(int master) const {
 
-  assert(master >= 0 && master < activeThreads);
-  assert(activeThreads > 1);
+/// ThreadPool::nodes_searched() returns the number of nodes searched
 
-  for (int i = 0; i < activeThreads; i++)
-      if (thread_is_available(i, master))
-          return true;
+int64_t ThreadPool::nodes_searched() {
 
-  return false;
+  int64_t nodes = 0;
+  for (Thread* th : *this)
+      nodes += th->rootPos.nodes_searched();
+  return nodes;
 }
 
 
-// split() does the actual work of distributing the work at a node between
-// several available threads. If it does not succeed in splitting the
-// node (because no idle threads are available, or because we have no unused
-// split point objects), the function immediately returns. If splitting is
-// possible, a SplitPoint object is initialized with all the data that must be
-// copied to the helper threads and we tell our helper threads that they have
-// been assigned work. This will cause them to instantly leave their idle loops and
-// call search().When all threads have returned from search() then split() returns.
-
-template <bool Fake>
-void ThreadsManager::split(Position& pos, SearchStack* ss, Value* alpha, const Value beta,
-                           Value* bestValue, Depth depth, Move threatMove,
-                           int moveCount, MovePicker* mp, bool pvNode) {
-  assert(pos.is_ok());
-  assert(*bestValue >= -VALUE_INFINITE);
-  assert(*bestValue <= *alpha);
-  assert(*alpha < beta);
-  assert(beta <= VALUE_INFINITE);
-  assert(depth > DEPTH_ZERO);
-  assert(pos.thread() >= 0 && pos.thread() < activeThreads);
-  assert(activeThreads > 1);
-
-  int i, master = pos.thread();
-  Thread& masterThread = threads[master];
-
-  lock_grab(&mpLock);
-
-  // If no other thread is available to help us, or if we have too many
-  // active split points, don't split.
-  if (   !available_thread_exists(master)
-      || masterThread.activeSplitPoints >= MAX_ACTIVE_SPLIT_POINTS)
-  {
-      lock_release(&mpLock);
-      return;
-  }
+/// ThreadPool::start_thinking() wakes up the main thread sleeping in idle_loop()
+/// and starts a new search, then returns immediately.
 
-  // Pick the next available split point object from the split point stack
-  SplitPoint& splitPoint = masterThread.splitPoints[masterThread.activeSplitPoints++];
-
-  // Initialize the split point object
-  splitPoint.parent = masterThread.splitPoint;
-  splitPoint.master = master;
-  splitPoint.betaCutoff = false;
-  splitPoint.depth = depth;
-  splitPoint.threatMove = threatMove;
-  splitPoint.alpha = *alpha;
-  splitPoint.beta = beta;
-  splitPoint.pvNode = pvNode;
-  splitPoint.bestValue = *bestValue;
-  splitPoint.mp = mp;
-  splitPoint.moveCount = moveCount;
-  splitPoint.pos = &pos;
-  splitPoint.nodes = 0;
-  splitPoint.ss = ss;
-  for (i = 0; i < activeThreads; i++)
-      splitPoint.slaves[i] = 0;
-
-  masterThread.splitPoint = &splitPoint;
-
-  // If we are here it means we are not available
-  assert(masterThread.state != THREAD_AVAILABLE);
-
-  int workersCnt = 1; // At least the master is included
-
-  // Allocate available threads setting state to THREAD_BOOKED
-  for (i = 0; !Fake && i < activeThreads && workersCnt < maxThreadsPerSplitPoint; i++)
-      if (thread_is_available(i, master))
-      {
-          threads[i].state = THREAD_BOOKED;
-          threads[i].splitPoint = &splitPoint;
-          splitPoint.slaves[i] = 1;
-          workersCnt++;
-      }
+void ThreadPool::start_thinking(Position& pos, StateListPtr& states,
+                                const Search::LimitsType& limits) {
 
-  assert(Fake || workersCnt > 1);
+  main()->wait_for_search_finished();
 
-  // We can release the lock because slave threads are already booked and master is not available
-  lock_release(&mpLock);
+  Search::Signals.stopOnPonderhit = Search::Signals.stop = false;
+  Search::Limits = limits;
+  Search::RootMoves rootMoves;
 
-  // Tell the threads that they have work to do. This will make them leave
-  // their idle loop.
-  for (i = 0; i < activeThreads; i++)
-      if (i == master || splitPoint.slaves[i])
-      {
-          assert(i == master || threads[i].state == THREAD_BOOKED);
+  for (const auto& m : MoveList<LEGAL>(pos))
+      if (   limits.searchmoves.empty()
+          || std::count(limits.searchmoves.begin(), limits.searchmoves.end(), m))
+          rootMoves.push_back(Search::RootMove(m));
 
-          threads[i].state = THREAD_WORKISWAITING; // This makes the slave to exit from idle_loop()
+  Tablebases::filter_root_moves(pos, rootMoves);
 
-          if (useSleepingThreads && i != master)
-              threads[i].wake_up();
-      }
+  // 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());
 
-  // Everything is set up. The master thread enters the idle loop, from
-  // which it will instantly launch a search, because its state is
-  // THREAD_WORKISWAITING.  We send the split point as a second parameter to the
-  // idle loop, which means that the main thread will return from the idle
-  // loop when all threads have finished their work at this split point.
-  idle_loop(master, &splitPoint);
+  if (states.get())
+      setupStates = std::move(states); // Ownership transfer, states is now empty
 
-  // We have returned from the idle loop, which means that all threads are
-  // finished. Update alpha and bestValue, and return.
-  lock_grab(&mpLock);
+  StateInfo tmp = setupStates->back();
 
-  *alpha = splitPoint.alpha;
-  *bestValue = splitPoint.bestValue;
-  masterThread.activeSplitPoints--;
-  masterThread.splitPoint = splitPoint.parent;
-  pos.set_nodes_searched(pos.nodes_searched() + splitPoint.nodes);
+  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);
+  }
 
-  lock_release(&mpLock);
-}
+  setupStates->back() = tmp; // Restore st->previous, cleared by Position::set()
 
-// Explicit template instantiations
-template void ThreadsManager::split<0>(Position&, SearchStack*, Value*, const Value, Value*, Depth, Move, int, MovePicker*, bool);
-template void ThreadsManager::split<1>(Position&, SearchStack*, Value*, const Value, Value*, Depth, Move, int, MovePicker*, bool);
+  main()->start_searching();
+}