-
-struct Thread;
-
-const int MAX_THREADS = 128;
-const int MAX_SPLITPOINTS_PER_THREAD = 8;
-
-/// Mutex and ConditionVariable struct are wrappers of the low level locking
-/// machinery and are modeled after the corresponding C++11 classes.
-
-struct Mutex {
- Mutex() { lock_init(l); }
- ~Mutex() { lock_destroy(l); }
-
- void lock() { lock_grab(l); }
- void unlock() { lock_release(l); }
-
-private:
- friend struct ConditionVariable;
-
- Lock l;
-};
-
-struct ConditionVariable {
- ConditionVariable() { cond_init(c); }
- ~ConditionVariable() { cond_destroy(c); }
-
- void wait(Mutex& m) { cond_wait(c, m.l); }
- void wait_for(Mutex& m, int ms) { timed_wait(c, m.l, ms); }
- void notify_one() { cond_signal(c); }
-
-private:
- WaitCondition c;
-};
-
-
-/// SplitPoint struct stores information shared by the threads searching in
-/// parallel below the same split point. It is populated at splitting time.
-
-struct SplitPoint {
-
- // Const data after split point has been setup
- const Position* pos;
- Search::Stack* ss;
- Thread* masterThread;
- Depth depth;
- Value beta;
- int nodeType;
- bool cutNode;
-
- // Const pointers to shared data
- MovePicker* movePicker;
- SplitPoint* parentSplitPoint;
-
- // Shared variable data
- Mutex mutex;
- std::bitset<MAX_THREADS> slavesMask;
- volatile bool allSlavesSearching;
- volatile uint64_t nodes;
- volatile Value alpha;
- volatile Value bestValue;
- volatile Move bestMove;
- volatile int moveCount;
- volatile bool cutoff;
-};
-
-
-/// ThreadBase struct is the base of the hierarchy from where we derive all the
-/// specialized thread classes.
-
-struct ThreadBase {
-
- ThreadBase() : handle(NativeHandle()), exit(false) {}
- virtual ~ThreadBase() {}
- virtual void idle_loop() = 0;
- void notify_one();
- void wait_for(volatile const bool& b);
-
- Mutex mutex;
- ConditionVariable sleepCondition;
- NativeHandle handle;
- volatile bool exit;
-};
-
-
-/// Thread struct keeps together all the thread related stuff like locks, state
-/// and especially split points. We also use per-thread pawn and material hash
-/// tables so that once we get a pointer to an entry its life time is unlimited
-/// and we don't have to care about someone changing the entry under our feet.
-
-struct Thread : public ThreadBase {
-
- Thread();
- virtual void idle_loop();
- bool cutoff_occurred() const;
- bool available_to(const Thread* master) const;
-
- void split(Position& pos, Search::Stack* ss, Value alpha, Value beta, Value* bestValue, Move* bestMove,
- Depth depth, int moveCount, MovePicker* movePicker, int nodeType, bool cutNode);
-
- SplitPoint splitPoints[MAX_SPLITPOINTS_PER_THREAD];
- Pawns::Table pawnsTable;
- Material::Table materialTable;
- Endgames endgames;
- Position* activePosition;
- size_t idx;
- int maxPly;
- SplitPoint* volatile activeSplitPoint;
- volatile int splitPointsSize;
- volatile bool searching;
+#include "thread_win32_osx.h"
+
+namespace Stockfish {
+
+
+class OptionsMap;
+using Value = int;
+
+// Sometimes we don't want to actually bind the threads, but the recipient still
+// needs to think it runs on *some* NUMA node, such that it can access structures
+// that rely on NUMA node knowledge. This class encapsulates this optional process
+// such that the recipient does not need to know whether the binding happened or not.
+class OptionalThreadToNumaNodeBinder {
+ public:
+ OptionalThreadToNumaNodeBinder(NumaIndex n) :
+ numaConfig(nullptr),
+ numaId(n) {}
+
+ OptionalThreadToNumaNodeBinder(const NumaConfig& cfg, NumaIndex n) :
+ numaConfig(&cfg),
+ numaId(n) {}
+
+ NumaReplicatedAccessToken operator()() const {
+ if (numaConfig != nullptr)
+ return numaConfig->bind_current_thread_to_numa_node(numaId);
+ else
+ return NumaReplicatedAccessToken(numaId);
+ }
+
+ private:
+ const NumaConfig* numaConfig;
+ NumaIndex numaId;