#include <algorithm> // For std::count
#include <cassert>
-#include <iostream>
#include "movegen.h"
#include "search.h"
ThreadPool Threads; // Global object
-namespace { extern "C" {
+namespace {
// start_routine() is the C function which is called when a new thread
// is launched. It is a wrapper to the virtual function idle_loop().
- long start_routine(Thread* th) { th->idle_loop(); return 0; }
+ extern "C" { long start_routine(Thread* th) { th->idle_loop(); return 0; } }
-} }
+
+ // Helpers to launch a thread after creation and joining before delete. Must be
+ // outside Thread c'tor and d'tor because object shall be fully initialized
+ // when start_routine (and hence virtual idle_loop) is called and when joining.
+
+ template<typename T> T* new_thread() {
+ T* th = new T();
+ thread_create(th->handle, start_routine, th);
+ return th;
+ }
+
+ void delete_thread(Thread* th) {
+ th->exit = true; // Search must be already finished
+ th->notify_one();
+ thread_join(th->handle); // Wait for thread termination
+ delete th;
+ }
+
+}
// Thread c'tor starts a newly-created thread of execution that will call
activeSplitPoint = NULL;
activePosition = NULL;
idx = Threads.size();
-
- if (!thread_create(handle, start_routine, this))
- {
- std::cerr << "Failed to create thread number " << idx << std::endl;
- ::exit(EXIT_FAILURE);
- }
-}
-
-
-// Thread d'tor waits for thread termination before to return
-
-Thread::~Thread() {
-
- exit = true; // Search must be already finished
- notify_one();
- thread_join(handle); // Wait for thread termination
}
void ThreadPool::init() {
sleepWhileIdle = true;
- timer = new TimerThread();
- push_back(new MainThread());
+ timer = new_thread<TimerThread>();
+ push_back(new_thread<MainThread>());
read_uci_options();
}
void ThreadPool::exit() {
- delete timer; // As first because check_time() accesses threads data
+ delete_thread(timer); // As first because check_time() accesses threads data
for (iterator it = begin(); it != end(); ++it)
- delete *it;
+ delete_thread(*it);
}
assert(requested > 0);
while (size() < requested)
- push_back(new Thread());
+ push_back(new_thread<Thread>());
while (size() > requested)
{
- delete back();
+ delete_thread(back());
pop_back();
}
}
template <bool Fake>
void Thread::split(Position& pos, Stack* ss, Value alpha, Value beta, Value* bestValue,
Move* bestMove, Depth depth, Move threatMove, int moveCount,
- MovePicker* movePicker, int nodeType) {
+ MovePicker* movePicker, int nodeType, bool cutNode) {
assert(pos.pos_is_ok());
assert(*bestValue <= alpha && alpha < beta && beta <= VALUE_INFINITE);
sp.alpha = alpha;
sp.beta = beta;
sp.nodeType = nodeType;
+ sp.cutNode = cutNode;
sp.movePicker = movePicker;
sp.moveCount = moveCount;
sp.pos = &pos;
}
// Explicit template instantiations
-template void Thread::split<false>(Position&, Stack*, Value, Value, Value*, Move*, Depth, Move, int, MovePicker*, int);
-template void Thread::split< true>(Position&, Stack*, Value, Value, Value*, Move*, Depth, Move, int, MovePicker*, int);
+template void Thread::split<false>(Position&, Stack*, Value, Value, Value*, Move*, Depth, Move, int, MovePicker*, int, bool);
+template void Thread::split< true>(Position&, Stack*, Value, Value, Value*, Move*, Depth, Move, int, MovePicker*, int, bool);
// wait_for_think_finished() waits for main thread to go to sleep then returns