kate/BadFish
1
0
Fork 0
mirror of https://github.com/sockspls/badfish synced 2025-07-13 12:39:16 +00:00
Code Issues Releases Wiki Activity

Speed up kpk initialization

Browse source 
The trick is to classify more position at first cycle,
so to reduce following work. Speed up is of about 50% !

Also some cleanup while there.

Signed-off-by: Marco Costalba <mcostalba@gmail.com>
This commit is contained in:
Marco Costalba 2011-06-15 09:09:04 +02:00
parent 4c9d570e43
commit 15683034a7
2 changed files with 110 additions and 123 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

229
src/bitbase.cpp
View file

@ -28,15 +28,17 @@ namespace {
RESULT_UNKNOWN, RESULT_UNKNOWN,
RESULT_INVALID, RESULT_INVALID,
RESULT_WIN, RESULT_WIN,
RESULT_LOSS,
RESULT_DRAW RESULT_DRAW
}; };
struct KPKPosition { struct KPKPosition {
Result classify_knowns(int index);
Result classify(int index, Result db[]);
private:
void from_index(int index); void from_index(int index);
bool is_legal() const; Result classify_white(const Result db[]);
bool is_immediate_draw() const; Result classify_black(const Result db[]);
bool is_immediate_win() const;
Bitboard wk_attacks() const { return StepAttacksBB[WK][whiteKingSquare]; } Bitboard wk_attacks() const { return StepAttacksBB[WK][whiteKingSquare]; }
Bitboard bk_attacks() const { return StepAttacksBB[BK][blackKingSquare]; } Bitboard bk_attacks() const { return StepAttacksBB[BK][blackKingSquare]; }
Bitboard pawn_attacks() const { return StepAttacksBB[WP][pawnSquare]; } Bitboard pawn_attacks() const { return StepAttacksBB[WP][pawnSquare]; }
@ -46,13 +48,11 @@ namespace {
}; };
// The possible pawns squares are 24, the first 4 files and ranks from 2 to 7 // The possible pawns squares are 24, the first 4 files and ranks from 2 to 7
const int IndexMax = 2 * 24 * 64 * 64; // color * wp_sq * wk_sq * bk_sq const int IndexMax = 2 * 24 * 64 * 64; // color * wp_sq * wk_sq * bk_sq = 196608
// Each uint32_t stores results of 32 positions, one per bit // Each uint32_t stores results of 32 positions, one per bit
uint32_t KPKBitbase[IndexMax / 32]; uint32_t KPKBitbase[IndexMax / 32];
Result classify_wtm(const KPKPosition& pos, const Result bb[]);
Result classify_btm(const KPKPosition& pos, const Result bb[]);
int compute_index(Square wksq, Square bksq, Square wpsq, Color stm); int compute_index(Square wksq, Square bksq, Square wpsq, Color stm);
} }
@ -65,64 +65,49 @@ uint32_t probe_kpk_bitbase(Square wksq, Square wpsq, Square bksq, Color stm) {
} }
void init_kpk_bitbase() { void kpk_bitbase_init() {
Result bb[IndexMax]; Result db[IndexMax];
KPKPosition pos; KPKPosition pos;
bool repeat; int index, bit, repeat = 1;
// Initialize table // Initialize table
for (int i = 0; i < IndexMax; i++) for (index = 0; index < IndexMax; index++)
{ db[index] = pos.classify_knowns(index);
pos.from_index(i);
bb[i] = !pos.is_legal() ? RESULT_INVALID
: pos.is_immediate_draw() ? RESULT_DRAW
: pos.is_immediate_win() ? RESULT_WIN : RESULT_UNKNOWN;
}
// Iterate until all positions are classified (30 cycles needed) // Iterate until all positions are classified (30 cycles needed)
do { while (repeat)
repeat = false; for (repeat = index = 0; index < IndexMax; index++)
if ( db[index] == RESULT_UNKNOWN
for (int i = 0; i < IndexMax; i++) && pos.classify(index, db) != RESULT_UNKNOWN)
if (bb[i] == RESULT_UNKNOWN) repeat = 1;
{
pos.from_index(i);
bb[i] = (pos.sideToMove == WHITE) ? classify_wtm(pos, bb)
: classify_btm(pos, bb);
if (bb[i] != RESULT_UNKNOWN)
repeat = true;
}
} while (repeat);
// Map 32 position results into one KPKBitbase[] entry // Map 32 position results into one KPKBitbase[] entry
for (int i = 0; i < IndexMax / 32; i++) for (index = 0; index < IndexMax / 32; index++)
for (int j = 0; j < 32; j++) for (bit = 0; bit < 32; bit++)
if (bb[32 * i + j] == RESULT_WIN || bb[32 * i + j] == RESULT_LOSS) if (db[32 * index + bit] == RESULT_WIN)
KPKBitbase[i] |= (1 << j); KPKBitbase[index] |= (1 << bit);
} }
namespace { namespace {
// A KPK bitbase index is an integer in [0, IndexMax] range // A KPK bitbase index is an integer in [0, IndexMax] range
// //
// Information is mapped in this way // Information is mapped in this way
// //
// bit 0: side to move (WHITE or BLACK) // bit 0: side to move (WHITE or BLACK)
// bit 1- 6: black king square (from SQ_A1 to SQ_H8) // bit 1- 6: black king square (from SQ_A1 to SQ_H8)
// bit 7-12: white king square (from SQ_A1 to SQ_H8) // bit 7-12: white king square (from SQ_A1 to SQ_H8)
// bit 13-14: white pawn file (from FILE_A to FILE_D) // bit 13-14: white pawn file (from FILE_A to FILE_D)
// bit 15-17: white pawn rank - 1 (from RANK_2 - 1 to RANK_7 - 1) // bit 15-17: white pawn rank - 1 (from RANK_2 - 1 to RANK_7 - 1)
int compute_index(Square wksq, Square bksq, Square wpsq, Color stm) { int compute_index(Square wksq, Square bksq, Square wpsq, Color stm) {
assert(square_file(wpsq) <= FILE_D); assert(square_file(wpsq) <= FILE_D);
int p = int(square_file(wpsq)) + 4 * int(square_rank(wpsq) - 1); int p = square_file(wpsq) + 4 * (square_rank(wpsq) - 1);
int r = int(stm) + 2 * int(bksq) + 128 * int(wksq) + 8192 * p; int r = stm + 2 * bksq + 128 * wksq + 8192 * p;
assert(r >= 0 && r < IndexMax); assert(r >= 0 && r < IndexMax);
@ -131,73 +116,79 @@ namespace {
void KPKPosition::from_index(int index) { void KPKPosition::from_index(int index) {
int s = (index / 8192) % 24; int s = index >> 13;
sideToMove = Color(index & 1);
sideToMove = Color(index % 2); blackKingSquare = Square((index >> 1) & 63);
blackKingSquare = Square((index / 2) % 64); whiteKingSquare = Square((index >> 7) & 63);
whiteKingSquare = Square((index / 128) % 64); pawnSquare = make_square(File(s & 3), Rank((s >> 2) + 1));
pawnSquare = make_square(File(s % 4), Rank(s / 4 + 1));
} }
bool KPKPosition::is_legal() const { Result KPKPosition::classify_knowns(int index) {
from_index(index);
// Check if two pieces are on the same square
if ( whiteKingSquare == pawnSquare if ( whiteKingSquare == pawnSquare
|| whiteKingSquare == blackKingSquare || whiteKingSquare == blackKingSquare
|| blackKingSquare == pawnSquare) || blackKingSquare == pawnSquare)
return false; return RESULT_INVALID;
if (sideToMove == WHITE) // Check if a king can be captured
{ if ( bit_is_set(wk_attacks(), blackKingSquare)
if ( bit_is_set(wk_attacks(), blackKingSquare) || (bit_is_set(pawn_attacks(), blackKingSquare) && sideToMove == WHITE))
|| bit_is_set(pawn_attacks(), blackKingSquare)) return RESULT_INVALID;
return false;
}
else if (bit_is_set(bk_attacks(), whiteKingSquare))
return false;
return true;
}
bool KPKPosition::is_immediate_draw() const {
if (sideToMove == BLACK)
{
Bitboard wka = wk_attacks();
Bitboard bka = bk_attacks();
// Case 1: Stalemate
if ((bka & ~(wka | pawn_attacks())) == EmptyBoardBB)
return true;
// Case 2: King can capture pawn
if (bit_is_set(bka, pawnSquare) && !bit_is_set(wka, pawnSquare))
return true;
}
else
{
// Case 1: Stalemate (possible pawn files are only from A to D)
if ( whiteKingSquare == SQ_A8
&& pawnSquare == SQ_A7
&& (blackKingSquare == SQ_C7 || blackKingSquare == SQ_C8))
return true;
}
return false;
}
bool KPKPosition::is_immediate_win() const {
// The position is an immediate win if it is white to move and the // The position is an immediate win if it is white to move and the
// white pawn can be promoted without getting captured. // white pawn can be promoted without getting captured.
return sideToMove == WHITE if ( square_rank(pawnSquare) == RANK_7
&& square_rank(pawnSquare) == RANK_7 && sideToMove == WHITE
&& whiteKingSquare != pawnSquare + DELTA_N && whiteKingSquare != pawnSquare + DELTA_N
&& ( square_distance(blackKingSquare, pawnSquare + DELTA_N) > 1 && ( square_distance(blackKingSquare, pawnSquare + DELTA_N) > 1
|| bit_is_set(wk_attacks(), pawnSquare + DELTA_N)); || bit_is_set(wk_attacks(), pawnSquare + DELTA_N)))
return RESULT_WIN;
// Check for known draw positions
//
// Case 1: Stalemate
if ( sideToMove == BLACK
&& (bk_attacks() & ~(wk_attacks() | pawn_attacks())) == EmptyBoardBB)
return RESULT_DRAW;
// Case 2: King can capture pawn
if ( sideToMove == BLACK
&& bit_is_set(bk_attacks(), pawnSquare) && !bit_is_set(wk_attacks(), pawnSquare))
return RESULT_DRAW;
// Case 3: Black king in front of white pawn
if ( blackKingSquare == pawnSquare + DELTA_N
&& square_rank(pawnSquare) < RANK_7)
return RESULT_DRAW;
// Case 4: White king in front of pawn and black has opposition
if ( whiteKingSquare == pawnSquare + DELTA_N
&& blackKingSquare == pawnSquare + DELTA_N + DELTA_N + DELTA_N
&& square_rank(pawnSquare) < RANK_5
&& sideToMove == WHITE)
return RESULT_DRAW;
// Case 5: Stalemate with rook pawn
if ( blackKingSquare == SQ_A8
&& square_file(pawnSquare) == FILE_A)
return RESULT_DRAW;
return RESULT_UNKNOWN;
} }
Result classify_wtm(const KPKPosition& pos, const Result bb[]) { Result KPKPosition::classify(int index, Result db[]) {
// If one move leads to a position classified as RESULT_LOSS, the result from_index(index);
db[index] = (sideToMove == WHITE ? classify_white(db) : classify_black(db));
return db[index];
}
Result KPKPosition::classify_white(const Result db[]) {
// If one move leads to a position classified as RESULT_WIN, the result
// of the current position is RESULT_WIN. If all moves lead to positions // of the current position is RESULT_WIN. If all moves lead to positions
// classified as RESULT_DRAW, the current position is classified RESULT_DRAW // classified as RESULT_DRAW, the current position is classified RESULT_DRAW
// otherwise the current position is classified as RESULT_UNKNOWN. // otherwise the current position is classified as RESULT_UNKNOWN.
@ -208,13 +199,13 @@ namespace {
Result r; Result r;
// King moves // King moves
b = pos.wk_attacks(); b = wk_attacks();
while (b) while (b)
{ {
s = pop_1st_bit(&b); s = pop_1st_bit(&b);
r = bb[compute_index(s, pos.blackKingSquare, pos.pawnSquare, BLACK)]; r = db[compute_index(s, blackKingSquare, pawnSquare, BLACK)];
if (r == RESULT_LOSS) if (r == RESULT_WIN)
return RESULT_WIN; return RESULT_WIN;
if (r == RESULT_UNKNOWN) if (r == RESULT_UNKNOWN)
@ -222,26 +213,24 @@ namespace {
} }
// Pawn moves // Pawn moves
if (square_rank(pos.pawnSquare) < RANK_7) if (square_rank(pawnSquare) < RANK_7)
{ {
s = pos.pawnSquare + DELTA_N; s = pawnSquare + DELTA_N;
r = bb[compute_index(pos.whiteKingSquare, pos.blackKingSquare, s, BLACK)]; r = db[compute_index(whiteKingSquare, blackKingSquare, s, BLACK)];
if (r == RESULT_LOSS) if (r == RESULT_WIN)
return RESULT_WIN; return RESULT_WIN;
if (r == RESULT_UNKNOWN) if (r == RESULT_UNKNOWN)
unknownFound = true; unknownFound = true;
// Double pawn push // Double pawn push
if ( square_rank(s) == RANK_3 if (square_rank(s) == RANK_3 && r != RESULT_INVALID)
&& s != pos.whiteKingSquare
&& s != pos.blackKingSquare)
{ {
s += DELTA_N; s += DELTA_N;
r = bb[compute_index(pos.whiteKingSquare, pos.blackKingSquare, s, BLACK)]; r = db[compute_index(whiteKingSquare, blackKingSquare, s, BLACK)];
if (r == RESULT_LOSS) if (r == RESULT_WIN)
return RESULT_WIN; return RESULT_WIN;
if (r == RESULT_UNKNOWN) if (r == RESULT_UNKNOWN)
@ -251,14 +240,12 @@ namespace {
return unknownFound ? RESULT_UNKNOWN : RESULT_DRAW; return unknownFound ? RESULT_UNKNOWN : RESULT_DRAW;
} }
Result KPKPosition::classify_black(const Result db[]) {
Result classify_btm(const KPKPosition& pos, const Result bb[]) {
// If one move leads to a position classified as RESULT_DRAW, the result // If one move leads to a position classified as RESULT_DRAW, the result
// of the current position is RESULT_DRAW. If all moves lead to positions // of the current position is RESULT_DRAW. If all moves lead to positions
// classified as RESULT_WIN, the current position is classified as // classified as RESULT_WIN, the position is classified as RESULT_WIN.
// RESULT_LOSS. Otherwise, the current position is classified as // Otherwise, the current position is classified as RESULT_UNKNOWN.
// RESULT_UNKNOWN.
bool unknownFound = false; bool unknownFound = false;
Bitboard b; Bitboard b;
@ -266,11 +253,11 @@ namespace {
Result r; Result r;
// King moves // King moves
b = pos.bk_attacks(); b = bk_attacks();
while (b) while (b)
{ {
s = pop_1st_bit(&b); s = pop_1st_bit(&b);
r = bb[compute_index(pos.whiteKingSquare, s, pos.pawnSquare, WHITE)]; r = db[compute_index(whiteKingSquare, s, pawnSquare, WHITE)];
if (r == RESULT_DRAW) if (r == RESULT_DRAW)
return RESULT_DRAW; return RESULT_DRAW;
@ -278,7 +265,7 @@ namespace {
if (r == RESULT_UNKNOWN) if (r == RESULT_UNKNOWN)
unknownFound = true; unknownFound = true;
} }
return unknownFound ? RESULT_UNKNOWN : RESULT_LOSS; return unknownFound ? RESULT_UNKNOWN : RESULT_WIN;
} }
} }

4
src/main.cpp
View file

@ -39,7 +39,7 @@ using namespace std;
extern bool execute_uci_command(const string& cmd); extern bool execute_uci_command(const string& cmd);
extern void benchmark(int argc, char* argv[]); extern void benchmark(int argc, char* argv[]);
extern void init_kpk_bitbase(); extern void kpk_bitbase_init();
int main(int argc, char* argv[]) { int main(int argc, char* argv[]) {
@ -52,7 +52,7 @@ int main(int argc, char* argv[]) {
// Startup initializations // Startup initializations
init_bitboards(); init_bitboards();
Position::init(); Position::init();
init_kpk_bitbase(); kpk_bitbase_init();
init_search(); init_search();
Threads.init(); Threads.init();