summary |
shortlog |
log |
commit | commitdiff |
tree
raw |
patch |
inline | side by side (from parent 1:
7bcd979)
search() is used as a "leading star" and other routines
are modified according to it.
No functional change
Signed-off-by: Marco Costalba <mcostalba@gmail.com>
assert(threadID >= 0 && threadID < TM.active_threads());
Move movesSearched[256];
assert(threadID >= 0 && threadID < TM.active_threads());
Move movesSearched[256];
StateInfo st;
const TTEntry* tte;
Move ttMove, move;
Depth ext, newDepth;
StateInfo st;
const TTEntry* tte;
Move ttMove, move;
Depth ext, newDepth;
- Value oldAlpha, value;
- bool isCheck, mateThreat, singleEvasion, moveIsCheck, captureOrPromotion, dangerous;
+ Value bestValue, value, oldAlpha;
+ bool isCheck, singleEvasion, moveIsCheck, captureOrPromotion, dangerous;
+ bool mateThreat = false;
- Value bestValue = value = -VALUE_INFINITE;
+ bestValue = value = -VALUE_INFINITE;
if (depth < OnePly)
return qsearch(pos, ss, alpha, beta, Depth(0), ply, threadID);
if (depth < OnePly)
return qsearch(pos, ss, alpha, beta, Depth(0), ply, threadID);
isCheck = pos.is_check();
if (!isCheck)
{
isCheck = pos.is_check();
if (!isCheck)
{
ss[ply].eval = evaluate(pos, ei, threadID);
update_gains(pos, ss[ply - 1].currentMove, ss[ply - 1].eval, ss[ply].eval);
}
ss[ply].eval = evaluate(pos, ei, threadID);
update_gains(pos, ss[ply - 1].currentMove, ss[ply - 1].eval, ss[ply].eval);
}
// splitting, we don't have to repeat all this work in sp_search(). We
// also don't need to store anything to the hash table here: This is taken
// care of after we return from the split point.
// splitting, we don't have to repeat all this work in sp_search(). We
// also don't need to store anything to the hash table here: This is taken
// care of after we return from the split point.
+ // FIXME: We are currently ignoring mateThreat flag here
void sp_search(SplitPoint* sp, int threadID) {
assert(threadID >= 0 && threadID < TM.active_threads());
assert(TM.active_threads() > 1);
void sp_search(SplitPoint* sp, int threadID) {
assert(threadID >= 0 && threadID < TM.active_threads());
assert(TM.active_threads() > 1);
- Position pos(*sp->pos);
- CheckInfo ci(pos);
- SearchStack* ss = sp->sstack[threadID];
- Value value = -VALUE_INFINITE;
+ Depth ext, newDepth;
+ Value value, futilityValueScaled;
+ bool isCheck, moveIsCheck, captureOrPromotion, dangerous;
- bool isCheck = pos.is_check();
+ value = -VALUE_INFINITE;
+
+ Position pos(*sp->pos);
+ CheckInfo ci(pos);
+ SearchStack* ss = sp->sstack[threadID];
+ isCheck = pos.is_check();
// Step 10. Loop through moves
// Loop through all legal moves until no moves remain or a beta cutoff occurs
// Step 10. Loop through moves
// Loop through all legal moves until no moves remain or a beta cutoff occurs
assert(move_is_ok(move));
assert(move_is_ok(move));
- bool moveIsCheck = pos.move_is_check(move, ci);
- bool captureOrPromotion = pos.move_is_capture_or_promotion(move);
+ moveIsCheck = pos.move_is_check(move, ci);
+ captureOrPromotion = pos.move_is_capture_or_promotion(move);
// Step 11. Decide the new search depth
// Step 11. Decide the new search depth
- bool dangerous;
- Depth ext = extension(pos, move, false, captureOrPromotion, moveIsCheck, false, false, &dangerous);
- Depth newDepth = sp->depth - OnePly + ext;
+ ext = extension(pos, move, false, captureOrPromotion, moveIsCheck, false, false, &dangerous);
+ newDepth = sp->depth - OnePly + ext;
// Update current move
ss[sp->ply].currentMove = move;
// Update current move
ss[sp->ply].currentMove = move;
// Value based pruning
Depth predictedDepth = newDepth - nonpv_reduction(sp->depth, moveCount);
// Value based pruning
Depth predictedDepth = newDepth - nonpv_reduction(sp->depth, moveCount);
- Value futilityValueScaled = ss[sp->ply].eval + futility_margin(predictedDepth, moveCount)
+ futilityValueScaled = ss[sp->ply].eval + futility_margin(predictedDepth, moveCount)
+ H.gain(pos.piece_on(move_from(move)), move_to(move)) + 45;
if (futilityValueScaled < sp->beta)
+ H.gain(pos.piece_on(move_from(move)), move_to(move)) + 45;
if (futilityValueScaled < sp->beta)
// don't have to repeat all this work in sp_search_pv(). We also don't
// need to store anything to the hash table here: This is taken care of
// after we return from the split point.
// don't have to repeat all this work in sp_search_pv(). We also don't
// need to store anything to the hash table here: This is taken care of
// after we return from the split point.
+ // FIXME: We are ignoring mateThreat flag!
void sp_search_pv(SplitPoint* sp, int threadID) {
assert(threadID >= 0 && threadID < TM.active_threads());
assert(TM.active_threads() > 1);
void sp_search_pv(SplitPoint* sp, int threadID) {
assert(threadID >= 0 && threadID < TM.active_threads());
assert(TM.active_threads() > 1);
+ StateInfo st;
+ Move move;
+ Depth ext, newDepth;
+ Value value;
+ bool moveIsCheck, captureOrPromotion, dangerous;
+ int moveCount;
+ value = -VALUE_INFINITE;
+
Position pos(*sp->pos);
CheckInfo ci(pos);
SearchStack* ss = sp->sstack[threadID];
Position pos(*sp->pos);
CheckInfo ci(pos);
SearchStack* ss = sp->sstack[threadID];
- StateInfo st;
- Value value = -VALUE_INFINITE;
- int moveCount;
- Move move;
// Step 10. Loop through moves
// Loop through all legal moves until no moves remain or a beta cutoff occurs
// Step 10. Loop through moves
// Loop through all legal moves until no moves remain or a beta cutoff occurs
assert(move_is_ok(move));
assert(move_is_ok(move));
- bool moveIsCheck = pos.move_is_check(move, ci);
- bool captureOrPromotion = pos.move_is_capture_or_promotion(move);
+ moveIsCheck = pos.move_is_check(move, ci);
+ captureOrPromotion = pos.move_is_capture_or_promotion(move);
// Step 11. Decide the new search depth
// Step 11. Decide the new search depth
- bool dangerous;
- Depth ext = extension(pos, move, true, captureOrPromotion, moveIsCheck, false, false, &dangerous);
- Depth newDepth = sp->depth - OnePly + ext;
+ ext = extension(pos, move, true, captureOrPromotion, moveIsCheck, false, false, &dangerous);
+ newDepth = sp->depth - OnePly + ext;
// Update current move
ss[sp->ply].currentMove = move;
// Update current move
ss[sp->ply].currentMove = move;