"Fossies" - the Fresh Open Source Software Archive

Member "stockfish-11-linux/src/thread.h" (18 Jan 2020, 3610 Bytes) of package /linux/privat/stockfish-11-linux.zip:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. See also the last Fossies "Diffs" side-by-side code changes report for "thread.h": 9-linux_vs_10-linux.

    1 /*
    2   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
    3   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
    4   Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
    5   Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
    6 
    7   Stockfish is free software: you can redistribute it and/or modify
    8   it under the terms of the GNU General Public License as published by
    9   the Free Software Foundation, either version 3 of the License, or
   10   (at your option) any later version.
   11 
   12   Stockfish is distributed in the hope that it will be useful,
   13   but WITHOUT ANY WARRANTY; without even the implied warranty of
   14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   15   GNU General Public License for more details.
   16 
   17   You should have received a copy of the GNU General Public License
   18   along with this program.  If not, see <http://www.gnu.org/licenses/>.
   19 */
   20 
   21 #ifndef THREAD_H_INCLUDED
   22 #define THREAD_H_INCLUDED
   23 
   24 #include <atomic>
   25 #include <condition_variable>
   26 #include <mutex>
   27 #include <thread>
   28 #include <vector>
   29 
   30 #include "material.h"
   31 #include "movepick.h"
   32 #include "pawns.h"
   33 #include "position.h"
   34 #include "search.h"
   35 #include "thread_win32_osx.h"
   36 
   37 
   38 /// Thread class keeps together all the thread-related stuff. We use
   39 /// per-thread pawn and material hash tables so that once we get a
   40 /// pointer to an entry its life time is unlimited and we don't have
   41 /// to care about someone changing the entry under our feet.
   42 
   43 class Thread {
   44 
   45   std::mutex mutex;
   46   std::condition_variable cv;
   47   size_t idx;
   48   bool exit = false, searching = true; // Set before starting std::thread
   49   NativeThread stdThread;
   50 
   51 public:
   52   explicit Thread(size_t);
   53   virtual ~Thread();
   54   virtual void search();
   55   void clear();
   56   void idle_loop();
   57   void start_searching();
   58   void wait_for_search_finished();
   59   int best_move_count(Move move);
   60 
   61   Pawns::Table pawnsTable;
   62   Material::Table materialTable;
   63   size_t pvIdx, pvLast;
   64   uint64_t ttHitAverage;
   65   int selDepth, nmpMinPly;
   66   Color nmpColor;
   67   std::atomic<uint64_t> nodes, tbHits, bestMoveChanges;
   68 
   69   Position rootPos;
   70   Search::RootMoves rootMoves;
   71   Depth rootDepth, completedDepth;
   72   CounterMoveHistory counterMoves;
   73   ButterflyHistory mainHistory;
   74   CapturePieceToHistory captureHistory;
   75   ContinuationHistory continuationHistory[2][2];
   76   Score contempt;
   77 };
   78 
   79 
   80 /// MainThread is a derived class specific for main thread
   81 
   82 struct MainThread : public Thread {
   83 
   84   using Thread::Thread;
   85 
   86   void search() override;
   87   void check_time();
   88 
   89   double previousTimeReduction;
   90   Value previousScore;
   91   Value iterValue[4];
   92   int callsCnt;
   93   bool stopOnPonderhit;
   94   std::atomic_bool ponder;
   95 };
   96 
   97 
   98 /// ThreadPool struct handles all the threads-related stuff like init, starting,
   99 /// parking and, most importantly, launching a thread. All the access to threads
  100 /// is done through this class.
  101 
  102 struct ThreadPool : public std::vector<Thread*> {
  103 
  104   void start_thinking(Position&, StateListPtr&, const Search::LimitsType&, bool = false);
  105   void clear();
  106   void set(size_t);
  107 
  108   MainThread* main()        const { return static_cast<MainThread*>(front()); }
  109   uint64_t nodes_searched() const { return accumulate(&Thread::nodes); }
  110   uint64_t tb_hits()        const { return accumulate(&Thread::tbHits); }
  111 
  112   std::atomic_bool stop, increaseDepth;
  113 
  114 private:
  115   StateListPtr setupStates;
  116 
  117   uint64_t accumulate(std::atomic<uint64_t> Thread::* member) const {
  118 
  119     uint64_t sum = 0;
  120     for (Thread* th : *this)
  121         sum += (th->*member).load(std::memory_order_relaxed);
  122     return sum;
  123   }
  124 };
  125 
  126 extern ThreadPool Threads;
  127 
  128 #endif // #ifndef THREAD_H_INCLUDED