PASSED = 12, UNSTOPPABLE = 13, SPACE = 14, TOTAL = 15
};
- // Pawn and material hash tables, indexed by the current thread id.
- // Note that they will be initialized at 0 being global variables.
- MaterialInfoTable* MaterialTable[MAX_THREADS];
- PawnInfoTable* PawnTable[MAX_THREADS];
-
// Function prototypes
template<bool HasPopCnt, bool Trace>
Value do_evaluate(const Position& pos, Value& margin);
}
-/// prefetchTables() is called in do_move() to prefetch pawn and material
-/// hash tables data that will be needed shortly after in evaluation.
-
-void prefetchTables(Key pKey, Key mKey, int threadID) {
-
- PawnTable[threadID]->prefetch(pKey);
- MaterialTable[threadID]->prefetch(mKey);
-}
-
-
/// evaluate() is the main evaluation function. It always computes two
/// values, an endgame score and a middle game score, and interpolates
/// between them based on the remaining material.
assert(pos.is_ok());
assert(pos.thread() >= 0 && pos.thread() < MAX_THREADS);
- assert(!pos.is_check());
+ assert(!pos.in_check());
// Initialize value by reading the incrementally updated scores included
// in the position object (material + piece square tables).
margins[WHITE] = margins[BLACK] = VALUE_ZERO;
// Probe the material hash table
- MaterialInfo* mi = MaterialTable[pos.thread()]->get_material_info(pos);
+ MaterialInfo* mi = Threads[pos.thread()].materialTable.get_material_info(pos);
bonus += mi->material_value();
// If we have a specialized evaluation function for the current material
}
// Probe the pawn hash table
- ei.pi = PawnTable[pos.thread()]->get_pawn_info(pos);
+ ei.pi = Threads[pos.thread()].pawnTable.get_pawn_info(pos);
bonus += apply_weight(ei.pi->pawns_value(), Weights[PawnStructure]);
// Initialize attack and king safety bitboards
// If one side has only a king, check whether exists any unstoppable passed pawn
if (!pos.non_pawn_material(WHITE) || !pos.non_pawn_material(BLACK))
- {
bonus += evaluate_unstoppable_pawns<HasPopCnt>(pos, ei);
- if (Trace)
- trace_add(UNSTOPPABLE, evaluate_unstoppable_pawns<HasPopCnt>(pos, ei));
- }
-
// Evaluate space for both sides, only in middle-game.
if (mi->space_weight())
{
trace_add(MOBILITY, apply_weight(mobilityWhite, Weights[Mobility]), apply_weight(mobilityBlack, Weights[Mobility]));
trace_add(THREAT, evaluate_threats<WHITE>(pos, ei), evaluate_threats<BLACK>(pos, ei));
trace_add(PASSED, evaluate_passed_pawns<WHITE>(pos, ei), evaluate_passed_pawns<BLACK>(pos, ei));
+ trace_add(UNSTOPPABLE, evaluate_unstoppable_pawns<HasPopCnt>(pos, ei));
trace_add(TOTAL, bonus);
TraceStream << "\nUncertainty margin: White: " << to_cp(margins[WHITE])
<< ", Black: " << to_cp(margins[BLACK])
} // namespace
-/// init_eval() initializes various tables used by the evaluation function
-
-void init_eval(int threads) {
-
- assert(threads <= MAX_THREADS);
-
- for (int i = 0; i < MAX_THREADS; i++)
- {
- if (i >= threads)
- {
- delete PawnTable[i];
- delete MaterialTable[i];
- PawnTable[i] = NULL;
- MaterialTable[i] = NULL;
- continue;
- }
- if (!PawnTable[i])
- PawnTable[i] = new PawnInfoTable();
-
- if (!MaterialTable[i])
- MaterialTable[i] = new MaterialInfoTable();
- }
-}
-
-
-/// quit_eval() releases heap-allocated memory at program termination
-
-void quit_eval() {
-
- init_eval(0);
-}
-
-
/// read_weights() reads evaluation weights from the corresponding UCI parameters
void read_evaluation_uci_options(Color us) {
return apply_weight(bonus, Weights[PassedPawns]);
}
+
// evaluate_unstoppable_pawns() evaluates the unstoppable passed pawns for both sides
+
template<bool HasPopCnt>
Score evaluate_unstoppable_pawns(const Position& pos, EvalInfo& ei) {
const BitCountType Max15 = HasPopCnt ? CNT_POPCNT : CpuIs64Bit ? CNT64_MAX15 : CNT32_MAX15;
+ Bitboard b1, b2, queeningPath, candidates, supBB, sacBB;
+ Square s1, s2, queeningSquare, supSq, sacSq;
+ Color c, winnerSide, loserSide;
+ bool pathDefended, opposed;
+ int pliesToGo, movesToGo, oppMovesToGo;
+ int pliesToQueen[] = { 256, 256 };
+
// Step 1. Hunt for unstoppable pawns. If we find at least one, record how many plies
// are required for promotion
- int pliesToGo[2] = {256, 256};
-
- for (Color c = WHITE; c <= BLACK; c++)
+ for (c = WHITE; c <= BLACK; c++)
{
// Skip if other side has non-pawn pieces
if (pos.non_pawn_material(opposite_color(c)))
continue;
- Bitboard b = ei.pi->passed_pawns(c);
+ b1 = ei.pi->passed_pawns(c);
- while (b)
+ while (b1)
{
- Square s = pop_1st_bit(&b);
- Square queeningSquare = relative_square(c, make_square(square_file(s), RANK_8));
+ s1 = pop_1st_bit(&b1);
+ queeningSquare = relative_square(c, make_square(square_file(s1), RANK_8));
+ queeningPath = squares_in_front_of(c, s1);
- int mtg = RANK_8 - relative_rank(c, s) - int(relative_rank(c, s) == RANK_2);
- int oppmtg = square_distance(pos.king_square(opposite_color(c)), queeningSquare) - int(c != pos.side_to_move());
- bool pathDefended = ((ei.attackedBy[c][0] & squares_in_front_of(c, s)) == squares_in_front_of(c, s));
+ // Compute plies from queening and check direct advancement
+ movesToGo = rank_distance(s1, queeningSquare) - int(relative_rank(c, s1) == RANK_2);
+ oppMovesToGo = square_distance(pos.king_square(opposite_color(c)), queeningSquare) - int(c != pos.side_to_move());
+ pathDefended = ((ei.attackedBy[c][0] & queeningPath) == queeningPath);
- if (mtg >= oppmtg && !pathDefended)
+ if (movesToGo >= oppMovesToGo && !pathDefended)
continue;
- int blockerCount = count_1s<Max15>(squares_in_front_of(c, s) & pos.occupied_squares());
- mtg += blockerCount;
+ // Opponent king cannot block because path is defended and position
+ // is not in check. So only friendly pieces can be blockers.
+ assert(!pos.in_check());
+ assert(queeningPath & pos.occupied_squares() == queeningPath & pos.pieces_of_color(c));
+
+ // Add moves needed to free the path from friendly pieces and retest condition
+ movesToGo += count_1s<Max15>(queeningPath & pos.pieces_of_color(c));
- if (mtg >= oppmtg && !pathDefended)
+ if (movesToGo >= oppMovesToGo && !pathDefended)
continue;
- int ptg = 2 * mtg - int(c == pos.side_to_move());
+ pliesToGo = 2 * movesToGo - int(c == pos.side_to_move());
- if (ptg < pliesToGo[c])
- pliesToGo[c] = ptg;
+ if (pliesToGo < pliesToQueen[c])
+ pliesToQueen[c] = pliesToGo;
}
}
- // Step 2. If either side cannot promote at least three plies before the other side then
- // situation becomes too complex and we give up. Otherwise we determine the possibly "winning side"
- if (abs(pliesToGo[WHITE] - pliesToGo[BLACK]) < 3)
- return make_score(0, 0);
+ // Step 2. If either side cannot promote at least three plies before the other side then situation
+ // becomes too complex and we give up. Otherwise we determine the possibly "winning side"
+ if (abs(pliesToQueen[WHITE] - pliesToQueen[BLACK]) < 3)
+ return SCORE_ZERO;
- Color winnerSide = (pliesToGo[WHITE] < pliesToGo[BLACK] ? WHITE : BLACK);
- Color loserSide = opposite_color(winnerSide);
+ winnerSide = (pliesToQueen[WHITE] < pliesToQueen[BLACK] ? WHITE : BLACK);
+ loserSide = opposite_color(winnerSide);
// Step 3. Can the losing side possibly create a new passed pawn and thus prevent the loss?
// We collect the potential candidates in potentialBB.
- Bitboard pawnBB = pos.pieces(PAWN, loserSide);
- Bitboard potentialBB = pawnBB;
- const Bitboard passedBB = ei.pi->passed_pawns(loserSide);
+ b1 = candidates = pos.pieces(PAWN, loserSide);
- while(pawnBB)
+ while (b1)
{
- Square psq = pop_1st_bit(&pawnBB);
+ s1 = pop_1st_bit(&b1);
- // Check direct advancement
- int mtg = RANK_8 - relative_rank(loserSide, psq) - int(relative_rank(loserSide, psq) == RANK_2);
- int ptg = 2 * mtg - int(loserSide == pos.side_to_move());
+ // Compute plies from queening
+ queeningSquare = relative_square(loserSide, make_square(square_file(s1), RANK_8));
+ movesToGo = rank_distance(s1, queeningSquare) - int(relative_rank(loserSide, s1) == RANK_2);
+ pliesToGo = 2 * movesToGo - int(loserSide == pos.side_to_move());
- // Check if (without even considering any obstacles) we're too far away
- if (pliesToGo[winnerSide] + 3 <= ptg)
- {
- clear_bit(&potentialBB, psq);
- continue;
- }
-
- // If this is passed pawn, then it _may_ promote in time. We give up.
- if (bit_is_set(passedBB, psq))
- return make_score(0, 0);
-
- // Doubled pawn is worthless
- if (squares_in_front_of(loserSide, psq) & (pos.pieces(PAWN, loserSide)))
- {
- clear_bit(&potentialBB, psq);
- continue;
- }
+ // Check if (without even considering any obstacles) we're too far away or doubled
+ if ( pliesToQueen[winnerSide] + 3 <= pliesToGo
+ || (squares_in_front_of(loserSide, s1) & pos.pieces(PAWN, loserSide)))
+ clear_bit(&candidates, s1);
}
- // Step 4. Check new passed pawn creation through king capturing and sacrifises
- pawnBB = potentialBB;
+ // If any candidate is already a passed pawn it _may_ promote in time. We give up.
+ if (candidates & ei.pi->passed_pawns(loserSide))
+ return SCORE_ZERO;
- while(pawnBB)
+ // Step 4. Check new passed pawn creation through king capturing and sacrifices
+ b1 = candidates;
+
+ while (b1)
{
- Square psq = pop_1st_bit(&pawnBB);
+ s1 = pop_1st_bit(&b1);
- int mtg = RANK_8 - relative_rank(loserSide, psq) - int(relative_rank(loserSide, psq) == RANK_2);
- int ptg = 2 * mtg - int(loserSide == pos.side_to_move());
+ // Compute plies from queening
+ queeningSquare = relative_square(loserSide, make_square(square_file(s1), RANK_8));
+ movesToGo = rank_distance(s1, queeningSquare) - int(relative_rank(loserSide, s1) == RANK_2);
+ pliesToGo = 2 * movesToGo - int(loserSide == pos.side_to_move());
// Generate list of obstacles
- Bitboard obsBB = passed_pawn_mask(loserSide, psq) & pos.pieces(PAWN, winnerSide);
- const bool pawnIsOpposed = squares_in_front_of(loserSide, psq) & obsBB;
- assert(obsBB);
+ opposed = squares_in_front_of(loserSide, s1) & pos.pieces(PAWN, winnerSide);
+ b2 = passed_pawn_mask(loserSide, s1) & pos.pieces(PAWN, winnerSide);
+
+ assert(b2);
// How many plies does it take to remove all the obstacles?
int sacptg = 0;
int realObsCount = 0;
int minKingDist = 256;
+ int kingptg = 256;
- while(obsBB)
+ while (b2)
{
- Square obSq = pop_1st_bit(&obsBB);
- int minMoves = 256;
+ s2 = pop_1st_bit(&b2);
+ movesToGo = 256;
- // Check pawns that can give support to overcome obstacle (Eg. wp: a4,b4 bp: b2. b4 is giving support)
- if (!pawnIsOpposed && square_file(psq) != square_file(obSq))
+ // Check pawns that can give support to overcome obstacle, for instance
+ // black pawns: a4, b4 white: b2 then pawn in b4 is giving support.
+ if (!opposed && square_file(s1) != square_file(s2))
{
- Bitboard supBB = in_front_bb(winnerSide, Square(obSq + (winnerSide == WHITE ? 8 : -8)))
- & neighboring_files_bb(psq) & potentialBB;
+ supBB = in_front_bb(winnerSide, s2 + pawn_push(winnerSide)) & neighboring_files_bb(s1) & candidates;
- while(supBB) // This while-loop could be replaced with supSq = LSB/MSB(supBB) (depending on color)
+ while (supBB) // This while-loop could be replaced with supSq = LSB/MSB(supBB) (depending on color)
{
- Square supSq = pop_1st_bit(&supBB);
- int dist = square_distance(obSq, supSq);
- minMoves = Min(minMoves, dist - 2);
+ supSq = pop_1st_bit(&supBB);
+ movesToGo = Min(movesToGo, square_distance(s2, supSq) - 2);
}
-
}
- // Check pawns that can be sacrifised
- Bitboard sacBB = passed_pawn_mask(winnerSide, obSq) & neighboring_files_bb(obSq) & potentialBB & ~(1ULL << psq);
+ // Check pawns that can be sacrificed
+ sacBB = passed_pawn_mask(winnerSide, s2) & neighboring_files_bb(s2) & candidates & ~(1ULL << s1);
- while(sacBB) // This while-loop could be replaced with sacSq = LSB/MSB(sacBB) (depending on color)
+ while (sacBB) // This while-loop could be replaced with sacSq = LSB/MSB(sacBB) (depending on color)
{
- Square sacSq = pop_1st_bit(&sacBB);
- int dist = square_distance(obSq, sacSq);
- minMoves = Min(minMoves, dist - 2);
+ sacSq = pop_1st_bit(&sacBB);
+ movesToGo = Min(movesToGo, square_distance(s2, sacSq) - 2);
}
- // If obstacle can be destroyed with immediate pawn sacrifise, it's not real obstacle
- if (minMoves <= 0)
+ // Good, obstacle can be destroyed with an immediate pawn sacrifice,
+ // it's not a real obstacle and we have nothing to add to pliesToGo.
+ if (movesToGo <= 0)
continue;
- // Pawn sac calculations
- sacptg += minMoves * 2;
-
- // King capture calc
+ // Plies needed to sacrifice the pawn
+ sacptg += movesToGo * 2;
realObsCount++;
- int kingDist = square_distance(pos.king_square(loserSide), obSq);
- minKingDist = Min(minKingDist, kingDist);
+
+ // Plies needed for the king to capture opposing pawn
+ minKingDist = Min(minKingDist, square_distance(pos.king_square(loserSide), s2));
+ kingptg = (minKingDist + realObsCount) * 2;
}
- // Check if pawn sac plan _may_ save the day
- if (pliesToGo[winnerSide] + 3 > ptg + sacptg)
- return make_score(0, 0);
+ // Check if pawn sacrifice plan _may_ save the day
+ if (pliesToQueen[winnerSide] + 3 > pliesToGo + sacptg)
+ return SCORE_ZERO;
// Check if king capture plan _may_ save the day (contains some false positives)
- int kingptg = (minKingDist + realObsCount) * 2;
- if (pliesToGo[winnerSide] + 3 > ptg + kingptg)
- return make_score(0, 0);
+ if (pliesToQueen[winnerSide] + 3 > pliesToGo + kingptg)
+ return SCORE_ZERO;
}
- // Step 5. Assign bonus
- const int Sign[2] = {1, -1};
- return Sign[winnerSide] * make_score(0, (Value) 0x500 - 0x20 * pliesToGo[winnerSide]);
+ // Winning pawn is unstoppable and will promote as first, return big score
+ Score score = make_score(0, (Value) 0x500 - 0x20 * pliesToQueen[winnerSide]);
+ return winnerSide == WHITE ? score : -score;
}