: can_return_tt(tte, depth, beta, ss->ply)))
{
TT.refresh(tte);
- ss->bestMove = ttMove; // Can be MOVE_NONE
- return value_from_tt(tte->value(), ss->ply);
+ ss->bestMove = move = ttMove; // Can be MOVE_NONE
+ value = value_from_tt(tte->value(), ss->ply);
+
+ if ( value >= beta
+ && move
+ && !pos.move_is_capture_or_promotion(move)
+ && move != ss->killers[0])
+ {
+ ss->killers[1] = ss->killers[0];
+ ss->killers[0] = move;
+ }
+ return value;
}
// Step 5. Evaluate the position statically and update parent's gain statistics
Piece p1, p2;
Square ksq;
- assert(m1 && move_is_ok(m1));
- assert(m2 && move_is_ok(m2));
+ assert(move_is_ok(m1));
+ assert(move_is_ok(m2));
// Case 1: The moving piece is the same in both moves
f2 = move_from(m2);
bool connected_threat(const Position& pos, Move m, Move threat) {
assert(move_is_ok(m));
- assert(threat && move_is_ok(threat));
+ assert(move_is_ok(threat));
assert(!pos.move_is_capture_or_promotion(m));
assert(!pos.move_is_passed_pawn_push(m));
// instead of wasting CPU time polling for work.
while ( do_sleep
|| do_terminate
- || (Threads.use_sleeping_threads() && state == Thread::AVAILABLE))
+ || (Threads.use_sleeping_threads() && !is_searching))
{
assert((!sp && threadID) || Threads.use_sleeping_threads());
- // Grab the lock to avoid races with Thread::wake_up()
- lock_grab(&sleepLock);
-
// Slave thread should exit as soon as do_terminate flag raises
if (do_terminate)
{
assert(!sp);
- lock_release(&sleepLock);
return;
}
+ // Grab the lock to avoid races with Thread::wake_up()
+ lock_grab(&sleepLock);
+
// If we are master and all slaves have finished don't go to sleep
if (sp && all_slaves_finished(sp))
{
// particular we need to avoid a deadlock in case a master thread has,
// in the meanwhile, allocated us and sent the wake_up() call before we
// had the chance to grab the lock.
- if (do_sleep || state == Thread::AVAILABLE)
+ if (do_sleep || !is_searching)
cond_wait(&sleepCond, &sleepLock);
lock_release(&sleepLock);
}
// If this thread has been assigned work, launch a search
- if (state == Thread::SEARCHING)
+ if (is_searching)
{
assert(!do_terminate);
else
assert(false);
- assert(state == Thread::SEARCHING);
+ assert(is_searching);
- state = Thread::AVAILABLE;
+ is_searching = false;
// 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 ( Threads.use_sleeping_threads()
&& threadID != tsp->master
- && Threads[tsp->master].state == Thread::AVAILABLE)
+ && !Threads[tsp->master].is_searching)
Threads[tsp->master].wake_up();
}