#include "book.h"
#include "evaluate.h"
#include "history.h"
-#include "maxgain.h"
#include "misc.h"
#include "movegen.h"
#include "movepick.h"
// History table
History H;
- // MaxGain table
- MaxGain MG;
-
/// Functions
Value id_loop(const Position& pos, Move searchMoves[]);
// Initialize
TT.new_search();
H.clear();
- MG.clear();
init_ss_array(ss);
IterationInfo[1] = IterationInfoType(rml.get_move_score(0), rml.get_move_score(0));
Iteration = 1;
update_gains(pos, ss[ply - 1].currentMove, ss[ply - 1].eval, ss[ply].eval);
}
- // Post futility pruning
- if (depth < SelectiveDepth && staticValue - PostFutilityValueMargin >= beta)
- return (staticValue - PostFutilityValueMargin);
+ // Do a "stand pat". If we are above beta by a good margin then
+ // return immediately.
+ // FIXME: test with added condition 'allowNullmove || depth <= OnePly' and !value_is_mate(beta)
+ // FIXME: test with modified condition 'depth < RazorDepth'
+ if ( !isCheck
+ && depth < SelectiveDepth
+ && staticValue - PostFutilityValueMargin >= beta)
+ return staticValue - PostFutilityValueMargin;
// Null move search
if ( allowNullmove
movesSearched[moveCount++] = ss[ply].currentMove = move;
// Futility pruning for captures
+ // FIXME: test disabling 'Futility pruning for captures'
+ // FIXME: test with 'newDepth < RazorDepth'
Color them = opposite_color(pos.side_to_move());
if ( !isCheck
if (newDepth >= OnePly)
preFutilityValueMargin = 112 * bitScanReverse32(int(newDepth) * int(newDepth) / 2);
- if (ss[ply].eval + pos.endgame_value_of_piece_on(move_to(move)) + preFutilityValueMargin + ei.futilityMargin + 90 < beta)
+ Value futilityCaptureValue = ss[ply].eval + pos.endgame_value_of_piece_on(move_to(move)) + preFutilityValueMargin + ei.futilityMargin + 90;
+
+ if (futilityCaptureValue < beta)
+ {
+ if (futilityCaptureValue > bestValue)
+ bestValue = futilityCaptureValue;
continue;
+ }
}
-
// Futility pruning
if ( !isCheck
&& !dangerous
if (predictedDepth >= OnePly)
preFutilityValueMargin = 112 * bitScanReverse32(int(predictedDepth) * int(predictedDepth) / 2);
- preFutilityValueMargin += MG.retrieve(pos.piece_on(move_from(move)), move_from(move), move_to(move)) + 45;
+ preFutilityValueMargin += H.gain(pos.piece_on(move_from(move)), move_from(move), move_to(move)) + 45;
futilityValueScaled = ss[ply].eval + preFutilityValueMargin - moveCount * IncrementalFutilityMargin;
SearchStack* ss = sp->sstack[threadID];
Value value = -VALUE_INFINITE;
Move move;
+ int moveCount;
bool isCheck = pos.is_check();
bool useFutilityPruning = sp->depth < SelectiveDepth
&& !isCheck;
const int FutilityMoveCountMargin = 3 + (1 << (3 * int(sp->depth) / 8));
- while ( sp->bestValue < sp->beta
+ while ( lock_grab_bool(&(sp->lock))
+ && sp->bestValue < sp->beta
&& !thread_should_stop(threadID)
- && (move = sp->mp->get_next_move(sp->lock)) != MOVE_NONE)
+ && (move = sp->mp->get_next_move()) != MOVE_NONE)
{
+ moveCount = ++sp->moves;
+ lock_release(&(sp->lock));
+
assert(move_is_ok(move));
bool moveIsCheck = pos.move_is_check(move, ci);
bool captureOrPromotion = pos.move_is_capture_or_promotion(move);
- lock_grab(&(sp->lock));
- int moveCount = ++sp->moves;
- lock_release(&(sp->lock));
-
ss[sp->ply].currentMove = move;
- // Decide the new search depth.
+ // Decide the new search depth
bool dangerous;
Depth ext = extension(pos, move, false, captureOrPromotion, moveIsCheck, false, false, &dangerous);
Depth newDepth = sp->depth - OnePly + ext;
assert(value > -VALUE_INFINITE && value < VALUE_INFINITE);
if (thread_should_stop(threadID))
+ {
+ lock_grab(&(sp->lock));
break;
+ }
// New best move?
if (value > sp->bestValue) // Less then 2% of cases
}
}
- lock_grab(&(sp->lock));
+ /* Here we have the lock still grabbed */
// If this is the master thread and we have been asked to stop because of
// a beta cutoff higher up in the tree, stop all slave threads.
CheckInfo ci(pos);
SearchStack* ss = sp->sstack[threadID];
Value value = -VALUE_INFINITE;
+ int moveCount;
Move move;
- while ( sp->alpha < sp->beta
+ while ( lock_grab_bool(&(sp->lock))
+ && sp->alpha < sp->beta
&& !thread_should_stop(threadID)
- && (move = sp->mp->get_next_move(sp->lock)) != MOVE_NONE)
+ && (move = sp->mp->get_next_move()) != MOVE_NONE)
{
- bool moveIsCheck = pos.move_is_check(move, ci);
- bool captureOrPromotion = pos.move_is_capture_or_promotion(move);
+ moveCount = ++sp->moves;
+ lock_release(&(sp->lock));
assert(move_is_ok(move));
- lock_grab(&(sp->lock));
- int moveCount = ++sp->moves;
- lock_release(&(sp->lock));
+ bool moveIsCheck = pos.move_is_check(move, ci);
+ bool captureOrPromotion = pos.move_is_capture_or_promotion(move);
ss[sp->ply].currentMove = move;
- // Decide the new search depth.
+ // Decide the new search depth
bool dangerous;
Depth ext = extension(pos, move, true, captureOrPromotion, moveIsCheck, false, false, &dangerous);
Depth newDepth = sp->depth - OnePly + ext;
assert(value > -VALUE_INFINITE && value < VALUE_INFINITE);
if (thread_should_stop(threadID))
+ {
+ lock_grab(&(sp->lock));
break;
+ }
// New best move?
if (value > sp->bestValue) // Less then 2% of cases
}
}
- lock_grab(&(sp->lock));
+ /* Here we have the lock still grabbed */
// If this is the master thread and we have been asked to stop because of
// a beta cutoff higher up in the tree, stop all slave threads.
&& pos.captured_piece() == NO_PIECE_TYPE
&& !move_is_castle(m)
&& !move_is_promotion(m))
- MG.store(pos.piece_on(move_to(m)), move_from(m), move_to(m), -(before + after));
+ H.set_gain(pos.piece_on(move_to(m)), move_from(m), move_to(m), -(before + after));
}
projects / stockfish / blobdiff