TB debug framework
Call both new and reference functions in parallel and verify return values match. Log to file any difference to allow debugging while playing real games.tb_dbg
Marco Costalba
parent
3ea9928f55
commit
526499f3ee
|
|
@ -37,7 +37,7 @@ PGOBENCH = ./$(EXE) bench 16 1 1000 default time
|
|||
### Object files
|
||||
OBJS = benchmark.o bitbase.o bitboard.o endgame.o evaluate.o main.o \
|
||||
material.o misc.o movegen.o movepick.o pawns.o position.o psqt.o \
|
||||
search.o thread.o timeman.o tt.o uci.o ucioption.o syzygy/tbprobe.o
|
||||
search.o thread.o timeman.o tt.o uci.o ucioption.o syzygy/tbprobe.o syzygy/tbprobe_ref.o
|
||||
|
||||
### ==========================================================================
|
||||
### Section 2. High-level Configuration
|
||||
|
|
|
|||
|
|
@ -42,7 +42,7 @@ int main(int argc, char* argv[]) {
|
|||
Eval::init();
|
||||
Pawns::init();
|
||||
Threads.init();
|
||||
Tablebases::init(Options["SyzygyPath"]);
|
||||
TablebasesInst::init(Options["SyzygyPath"]);
|
||||
TT.resize(Options["Hash"]);
|
||||
|
||||
UCI::loop(argc, argv);
|
||||
|
|
|
|||
|
|
@ -289,7 +289,7 @@ void MainThread::search() {
|
|||
{
|
||||
// If the current root position is in the tablebases, then RootMoves
|
||||
// contains only moves that preserve the draw or the win.
|
||||
TB::RootInTB = Tablebases::root_probe(rootPos, rootMoves, TB::Score);
|
||||
TB::RootInTB = TablebasesInst::root_probe(rootPos, rootMoves, TB::Score);
|
||||
|
||||
if (TB::RootInTB)
|
||||
TB::Cardinality = 0; // Do not probe tablebases during the search
|
||||
|
|
@ -297,7 +297,7 @@ void MainThread::search() {
|
|||
else // If DTZ tables are missing, use WDL tables as a fallback
|
||||
{
|
||||
// Filter out moves that do not preserve the draw or the win.
|
||||
TB::RootInTB = Tablebases::root_probe_wdl(rootPos, rootMoves, TB::Score);
|
||||
TB::RootInTB = TablebasesInst::root_probe_wdl(rootPos, rootMoves, TB::Score);
|
||||
|
||||
// Only probe during search if winning
|
||||
if (TB::Score <= VALUE_DRAW)
|
||||
|
|
@ -700,7 +700,7 @@ namespace {
|
|||
&& !pos.can_castle(ANY_CASTLING))
|
||||
{
|
||||
TB::ProbeState err;
|
||||
TB::WDLScore v = Tablebases::probe_wdl(pos, &err);
|
||||
TB::WDLScore v = TablebasesInst::probe_wdl(pos, &err);
|
||||
|
||||
if (err != TB::ProbeState::FAIL)
|
||||
{
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,169 @@
|
|||
/*
|
||||
Copyright (c) 2011-2013 Ronald de Man
|
||||
*/
|
||||
|
||||
#ifndef TBCORE_REF_H
|
||||
#define TBCORE_REF_H
|
||||
|
||||
#ifndef _WIN32
|
||||
#include <pthread.h>
|
||||
#define SEP_CHAR ':'
|
||||
#define FD int
|
||||
#define FD_ERR -1
|
||||
#else
|
||||
#include <windows.h>
|
||||
#define SEP_CHAR ';'
|
||||
#define FD HANDLE
|
||||
#define FD_ERR INVALID_HANDLE_VALUE
|
||||
#endif
|
||||
|
||||
#ifndef _WIN32
|
||||
#define LOCK_T pthread_mutex_t
|
||||
#define LOCK_INIT(x) pthread_mutex_init(&(x), NULL)
|
||||
#define LOCK(x) pthread_mutex_lock(&(x))
|
||||
#define UNLOCK(x) pthread_mutex_unlock(&(x))
|
||||
#else
|
||||
#define LOCK_T HANDLE
|
||||
#define LOCK_INIT(x) do { x = CreateMutex(NULL, FALSE, NULL); } while (0)
|
||||
#define LOCK(x) WaitForSingleObject(x, INFINITE)
|
||||
#define UNLOCK(x) ReleaseMutex(x)
|
||||
#endif
|
||||
|
||||
#ifndef _MSC_VER
|
||||
#define BSWAP32(v) __builtin_bswap32(v)
|
||||
#define BSWAP64(v) __builtin_bswap64(v)
|
||||
#else
|
||||
#define BSWAP32(v) _byteswap_ulong(v)
|
||||
#define BSWAP64(v) _byteswap_uint64(v)
|
||||
#endif
|
||||
|
||||
#define WDLSUFFIX ".rtbw"
|
||||
#define DTZSUFFIX ".rtbz"
|
||||
#define WDLDIR "RTBWDIR"
|
||||
#define DTZDIR "RTBZDIR"
|
||||
#define TBPIECES 6
|
||||
|
||||
typedef unsigned long long uint64;
|
||||
typedef unsigned int uint32;
|
||||
typedef unsigned char ubyte;
|
||||
typedef unsigned short ushort;
|
||||
|
||||
const ubyte WDL_MAGIC[4] = { 0x71, 0xe8, 0x23, 0x5d };
|
||||
const ubyte DTZ_MAGIC[4] = { 0xd7, 0x66, 0x0c, 0xa5 };
|
||||
|
||||
#define TBHASHBITS 10
|
||||
|
||||
struct TBHashEntry;
|
||||
|
||||
typedef uint64 base_t;
|
||||
|
||||
struct PairsData {
|
||||
char *indextable;
|
||||
ushort *sizetable;
|
||||
ubyte *data;
|
||||
ushort *offset;
|
||||
ubyte *symlen;
|
||||
ubyte *sympat;
|
||||
int blocksize;
|
||||
int idxbits;
|
||||
int min_len;
|
||||
base_t base[1]; // C++ complains about base[]...
|
||||
};
|
||||
|
||||
struct TBEntry {
|
||||
char *data;
|
||||
uint64 key;
|
||||
uint64 mapping;
|
||||
ubyte ready;
|
||||
ubyte num;
|
||||
ubyte symmetric;
|
||||
ubyte has_pawns;
|
||||
}
|
||||
#ifndef _WIN32
|
||||
__attribute__((__may_alias__))
|
||||
#endif
|
||||
;
|
||||
|
||||
struct TBEntry_piece {
|
||||
char *data;
|
||||
uint64 key;
|
||||
uint64 mapping;
|
||||
ubyte ready;
|
||||
ubyte num;
|
||||
ubyte symmetric;
|
||||
ubyte has_pawns;
|
||||
ubyte enc_type;
|
||||
struct PairsData *precomp[2];
|
||||
int factor[2][TBPIECES];
|
||||
ubyte pieces[2][TBPIECES];
|
||||
ubyte norm[2][TBPIECES];
|
||||
};
|
||||
|
||||
struct TBEntry_pawn {
|
||||
char *data;
|
||||
uint64 key;
|
||||
uint64 mapping;
|
||||
ubyte ready;
|
||||
ubyte num;
|
||||
ubyte symmetric;
|
||||
ubyte has_pawns;
|
||||
ubyte pawns[2];
|
||||
struct {
|
||||
struct PairsData *precomp[2];
|
||||
int factor[2][TBPIECES];
|
||||
ubyte pieces[2][TBPIECES];
|
||||
ubyte norm[2][TBPIECES];
|
||||
} file[4];
|
||||
};
|
||||
|
||||
struct DTZEntry_piece {
|
||||
char *data;
|
||||
uint64 key;
|
||||
uint64 mapping;
|
||||
ubyte ready;
|
||||
ubyte num;
|
||||
ubyte symmetric;
|
||||
ubyte has_pawns;
|
||||
ubyte enc_type;
|
||||
struct PairsData *precomp;
|
||||
int factor[TBPIECES];
|
||||
ubyte pieces[TBPIECES];
|
||||
ubyte norm[TBPIECES];
|
||||
ubyte flags; // accurate, mapped, side
|
||||
ushort map_idx[4];
|
||||
ubyte *map;
|
||||
};
|
||||
|
||||
struct DTZEntry_pawn {
|
||||
char *data;
|
||||
uint64 key;
|
||||
uint64 mapping;
|
||||
ubyte ready;
|
||||
ubyte num;
|
||||
ubyte symmetric;
|
||||
ubyte has_pawns;
|
||||
ubyte pawns[2];
|
||||
struct {
|
||||
struct PairsData *precomp;
|
||||
int factor[TBPIECES];
|
||||
ubyte pieces[TBPIECES];
|
||||
ubyte norm[TBPIECES];
|
||||
} file[4];
|
||||
ubyte flags[4];
|
||||
ushort map_idx[4][4];
|
||||
ubyte *map;
|
||||
};
|
||||
|
||||
struct TBHashEntry {
|
||||
uint64 key;
|
||||
struct TBEntry *ptr;
|
||||
};
|
||||
|
||||
struct DTZTableEntry {
|
||||
uint64 key1;
|
||||
uint64 key2;
|
||||
struct TBEntry *entry;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
|
|
@ -20,10 +20,13 @@
|
|||
#ifndef TBPROBE_H
|
||||
#define TBPROBE_H
|
||||
|
||||
#include <fstream>
|
||||
#include <ostream>
|
||||
|
||||
#include "../search.h"
|
||||
|
||||
#include "tbprobe_ref.h"
|
||||
|
||||
namespace Tablebases {
|
||||
|
||||
enum WDLScore {
|
||||
|
|
@ -75,4 +78,90 @@ inline std::ostream& operator<<(std::ostream& os, const ProbeState v) {
|
|||
|
||||
}
|
||||
|
||||
namespace TablebasesInst {
|
||||
|
||||
typedef Tablebases::WDLScore WDLScore;
|
||||
typedef Tablebases::ProbeState ProbeState;
|
||||
|
||||
inline void init(const std::string& paths) {
|
||||
|
||||
TablebasesRef::init(paths);
|
||||
Tablebases::init(paths);
|
||||
}
|
||||
|
||||
inline int probe_dtz(Position& pos, ProbeState* result) {
|
||||
|
||||
int success = *result;
|
||||
int s1 = TablebasesRef::probe_dtz(pos, &success);
|
||||
int s2 = Tablebases::probe_dtz(pos, result);
|
||||
|
||||
dbg_hit_on(s1 != s2 || !!success != !!(*result));
|
||||
|
||||
if (s1 != s2 || !!success != !!(*result))
|
||||
{
|
||||
std::ofstream log("tb_dbg.log", std::ios::out | std::ios::app);
|
||||
if (log.is_open())
|
||||
{
|
||||
log << pos
|
||||
<< "DTZ: ref = (" << s1 << ", " << !!(success)
|
||||
<< "), new = (" << s2 << ", " << !!(*result) << std::endl;
|
||||
log.close();
|
||||
}
|
||||
}
|
||||
|
||||
return s2;
|
||||
}
|
||||
|
||||
inline WDLScore probe_wdl(Position& pos, ProbeState* result) {
|
||||
|
||||
int success = *result;
|
||||
WDLScore s1 = WDLScore(TablebasesRef::probe_wdl(pos, &success));
|
||||
WDLScore s2 = Tablebases::probe_wdl(pos, result);
|
||||
|
||||
dbg_hit_on(s1 != s2 || !!success != !!(*result));
|
||||
|
||||
if (s1 != s2 || !!success != !!(*result))
|
||||
{
|
||||
std::ofstream log("tb_dbg.log", std::ios::out | std::ios::app);
|
||||
if (log.is_open())
|
||||
{
|
||||
log << pos
|
||||
<< "WDL: ref = (" << s1 << ", " << !!(success)
|
||||
<< "), new = (" << s2 << ", " << !!(*result) << std::endl;
|
||||
log.close();
|
||||
}
|
||||
}
|
||||
|
||||
// Full test DTZ in every position where WDL is called: slow but exaustive
|
||||
TablebasesInst::probe_dtz(pos, result);
|
||||
|
||||
return s2;
|
||||
}
|
||||
|
||||
inline bool root_probe(Position& pos, Search::RootMoves& rootMoves, Value& score) {
|
||||
|
||||
Value score2 = score;
|
||||
Search::RootMoves rootMoves2 = rootMoves;
|
||||
bool s1 = TablebasesRef::root_probe(pos, rootMoves2, score2);
|
||||
bool s2 = Tablebases::root_probe(pos, rootMoves, score);
|
||||
|
||||
dbg_hit_on(s1 != s2 || score != score2 || rootMoves.size() != rootMoves2.size());
|
||||
|
||||
return s2;
|
||||
}
|
||||
|
||||
inline bool root_probe_wdl(Position& pos, Search::RootMoves& rootMoves, Value& score) {
|
||||
|
||||
Value score2 = score;
|
||||
Search::RootMoves rootMoves2 = rootMoves;
|
||||
bool s1 = TablebasesRef::root_probe_wdl(pos, rootMoves2, score2);
|
||||
bool s2 = Tablebases::root_probe_wdl(pos, rootMoves, score);
|
||||
|
||||
dbg_hit_on(s1 != s2 || score != score2 || rootMoves.size() != rootMoves2.size());
|
||||
|
||||
return s2;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -0,0 +1,832 @@
|
|||
/*
|
||||
Copyright (c) 2013 Ronald de Man
|
||||
This file may be redistributed and/or modified without restrictions.
|
||||
|
||||
tbprobe.cpp contains the Stockfish-specific routines of the
|
||||
tablebase probing code. It should be relatively easy to adapt
|
||||
this code to other chess engines.
|
||||
*/
|
||||
|
||||
#define NOMINMAX
|
||||
|
||||
#include <algorithm>
|
||||
|
||||
#include "../position.h"
|
||||
#include "../movegen.h"
|
||||
#include "../bitboard.h"
|
||||
#include "../search.h"
|
||||
|
||||
#include "tbprobe_ref.h"
|
||||
#include "tbcore_ref.h"
|
||||
|
||||
#include "tbcore_ref.cpp"
|
||||
|
||||
namespace Zobrist {
|
||||
extern Key psq[COLOR_NB][PIECE_TYPE_NB][SQUARE_NB];
|
||||
}
|
||||
|
||||
int TablebasesRef::MaxCardinality = 0;
|
||||
|
||||
// Given a position with 6 or fewer pieces, produce a text string
|
||||
// of the form KQPvKRP, where "KQP" represents the white pieces if
|
||||
// mirror == 0 and the black pieces if mirror == 1.
|
||||
static void prt_str(Position& pos, char *str, int mirror)
|
||||
{
|
||||
Color color;
|
||||
PieceType pt;
|
||||
int i;
|
||||
|
||||
color = !mirror ? WHITE : BLACK;
|
||||
for (pt = KING; pt >= PAWN; --pt)
|
||||
for (i = popcount(pos.pieces(color, pt)); i > 0; i--)
|
||||
*str++ = pchr[6 - pt];
|
||||
*str++ = 'v';
|
||||
color = ~color;
|
||||
for (pt = KING; pt >= PAWN; --pt)
|
||||
for (i = popcount(pos.pieces(color, pt)); i > 0; i--)
|
||||
*str++ = pchr[6 - pt];
|
||||
*str++ = 0;
|
||||
}
|
||||
|
||||
// Given a position, produce a 64-bit material signature key.
|
||||
// If the engine supports such a key, it should equal the engine's key.
|
||||
static uint64 calc_key(Position& pos, int mirror)
|
||||
{
|
||||
Color color;
|
||||
PieceType pt;
|
||||
int i;
|
||||
uint64 key = 0;
|
||||
|
||||
color = !mirror ? WHITE : BLACK;
|
||||
for (pt = PAWN; pt <= KING; ++pt)
|
||||
for (i = popcount(pos.pieces(color, pt)); i > 0; i--)
|
||||
key ^= Zobrist::psq[WHITE][pt][i - 1];
|
||||
color = ~color;
|
||||
for (pt = PAWN; pt <= KING; ++pt)
|
||||
for (i = popcount(pos.pieces(color, pt)); i > 0; i--)
|
||||
key ^= Zobrist::psq[BLACK][pt][i - 1];
|
||||
|
||||
return key;
|
||||
}
|
||||
|
||||
// Produce a 64-bit material key corresponding to the material combination
|
||||
// defined by pcs[16], where pcs[1], ..., pcs[6] is the number of white
|
||||
// pawns, ..., kings and pcs[9], ..., pcs[14] is the number of black
|
||||
// pawns, ..., kings.
|
||||
static uint64 calc_key_from_pcs(int *pcs, int mirror)
|
||||
{
|
||||
int color;
|
||||
PieceType pt;
|
||||
int i;
|
||||
uint64 key = 0;
|
||||
|
||||
color = !mirror ? 0 : 8;
|
||||
for (pt = PAWN; pt <= KING; ++pt)
|
||||
for (i = 0; i < pcs[color + pt]; i++)
|
||||
key ^= Zobrist::psq[WHITE][pt][i];
|
||||
color ^= 8;
|
||||
for (pt = PAWN; pt <= KING; ++pt)
|
||||
for (i = 0; i < pcs[color + pt]; i++)
|
||||
key ^= Zobrist::psq[BLACK][pt][i];
|
||||
|
||||
return key;
|
||||
}
|
||||
|
||||
bool is_little_endian() {
|
||||
union {
|
||||
int i;
|
||||
char c[sizeof(int)];
|
||||
} x;
|
||||
x.i = 1;
|
||||
return x.c[0] == 1;
|
||||
}
|
||||
|
||||
static ubyte decompress_pairs(struct PairsData *d, uint64 idx)
|
||||
{
|
||||
static const bool isLittleEndian = is_little_endian();
|
||||
return isLittleEndian ? decompress_pairs<true >(d, idx)
|
||||
: decompress_pairs<false>(d, idx);
|
||||
}
|
||||
|
||||
// probe_wdl_table and probe_dtz_table require similar adaptations.
|
||||
static int probe_wdl_table(Position& pos, int *success)
|
||||
{
|
||||
struct TBEntry *ptr;
|
||||
struct TBHashEntry *ptr2;
|
||||
uint64 idx;
|
||||
uint64 key;
|
||||
int i;
|
||||
ubyte res;
|
||||
int p[TBPIECES];
|
||||
|
||||
// Obtain the position's material signature key.
|
||||
key = pos.material_key();
|
||||
|
||||
// Test for KvK.
|
||||
if (key == (Zobrist::psq[WHITE][KING][0] ^ Zobrist::psq[BLACK][KING][0]))
|
||||
return 0;
|
||||
|
||||
ptr2 = TB_hash[key >> (64 - TBHASHBITS)];
|
||||
for (i = 0; i < HSHMAX; i++)
|
||||
if (ptr2[i].key == key) break;
|
||||
if (i == HSHMAX) {
|
||||
*success = 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
ptr = ptr2[i].ptr;
|
||||
if (!ptr->ready) {
|
||||
LOCK(TB_mutex);
|
||||
if (!ptr->ready) {
|
||||
char str[16];
|
||||
prt_str(pos, str, ptr->key != key);
|
||||
if (!init_table_wdl(ptr, str)) {
|
||||
ptr2[i].key = 0ULL;
|
||||
*success = 0;
|
||||
UNLOCK(TB_mutex);
|
||||
return 0;
|
||||
}
|
||||
// Memory barrier to ensure ptr->ready = 1 is not reordered.
|
||||
#ifdef _MSC_VER
|
||||
_ReadWriteBarrier();
|
||||
#else
|
||||
__asm__ __volatile__ ("" ::: "memory");
|
||||
#endif
|
||||
ptr->ready = 1;
|
||||
}
|
||||
UNLOCK(TB_mutex);
|
||||
}
|
||||
|
||||
int bside, mirror, cmirror;
|
||||
if (!ptr->symmetric) {
|
||||
if (key != ptr->key) {
|
||||
cmirror = 8;
|
||||
mirror = 0x38;
|
||||
bside = (pos.side_to_move() == WHITE);
|
||||
} else {
|
||||
cmirror = mirror = 0;
|
||||
bside = !(pos.side_to_move() == WHITE);
|
||||
}
|
||||
} else {
|
||||
cmirror = pos.side_to_move() == WHITE ? 0 : 8;
|
||||
mirror = pos.side_to_move() == WHITE ? 0 : 0x38;
|
||||
bside = 0;
|
||||
}
|
||||
|
||||
// p[i] is to contain the square 0-63 (A1-H8) for a piece of type
|
||||
// pc[i] ^ cmirror, where 1 = white pawn, ..., 14 = black king.
|
||||
// Pieces of the same type are guaranteed to be consecutive.
|
||||
if (!ptr->has_pawns) {
|
||||
struct TBEntry_piece *entry = (struct TBEntry_piece *)ptr;
|
||||
ubyte *pc = entry->pieces[bside];
|
||||
for (i = 0; i < entry->num;) {
|
||||
Bitboard bb = pos.pieces((Color)((pc[i] ^ cmirror) >> 3),
|
||||
(PieceType)(pc[i] & 0x07));
|
||||
do {
|
||||
p[i++] = pop_lsb(&bb);
|
||||
} while (bb);
|
||||
}
|
||||
idx = encode_piece(entry, entry->norm[bside], p, entry->factor[bside]);
|
||||
res = decompress_pairs(entry->precomp[bside], idx);
|
||||
} else {
|
||||
struct TBEntry_pawn *entry = (struct TBEntry_pawn *)ptr;
|
||||
int k = entry->file[0].pieces[0][0] ^ cmirror;
|
||||
Bitboard bb = pos.pieces((Color)(k >> 3), (PieceType)(k & 0x07));
|
||||
i = 0;
|
||||
do {
|
||||
p[i++] = pop_lsb(&bb) ^ mirror;
|
||||
} while (bb);
|
||||
int f = pawn_file(entry, p);
|
||||
ubyte *pc = entry->file[f].pieces[bside];
|
||||
for (; i < entry->num;) {
|
||||
bb = pos.pieces((Color)((pc[i] ^ cmirror) >> 3),
|
||||
(PieceType)(pc[i] & 0x07));
|
||||
do {
|
||||
p[i++] = pop_lsb(&bb) ^ mirror;
|
||||
} while (bb);
|
||||
}
|
||||
idx = encode_pawn(entry, entry->file[f].norm[bside], p, entry->file[f].factor[bside]);
|
||||
res = decompress_pairs(entry->file[f].precomp[bside], idx);
|
||||
}
|
||||
|
||||
return ((int)res) - 2;
|
||||
}
|
||||
|
||||
static int probe_dtz_table(Position& pos, int wdl, int *success)
|
||||
{
|
||||
struct TBEntry *ptr;
|
||||
uint64 idx;
|
||||
int i, res;
|
||||
int p[TBPIECES];
|
||||
|
||||
// Obtain the position's material signature key.
|
||||
uint64 key = pos.material_key();
|
||||
|
||||
if (DTZ_table[0].key1 != key && DTZ_table[0].key2 != key) {
|
||||
for (i = 1; i < DTZ_ENTRIES; i++)
|
||||
if (DTZ_table[i].key1 == key) break;
|
||||
if (i < DTZ_ENTRIES) {
|
||||
struct DTZTableEntry table_entry = DTZ_table[i];
|
||||
for (; i > 0; i--)
|
||||
DTZ_table[i] = DTZ_table[i - 1];
|
||||
DTZ_table[0] = table_entry;
|
||||
} else {
|
||||
struct TBHashEntry *ptr2 = TB_hash[key >> (64 - TBHASHBITS)];
|
||||
for (i = 0; i < HSHMAX; i++)
|
||||
if (ptr2[i].key == key) break;
|
||||
if (i == HSHMAX) {
|
||||
*success = 0;
|
||||
return 0;
|
||||
}
|
||||
ptr = ptr2[i].ptr;
|
||||
char str[16];
|
||||
int mirror = (ptr->key != key);
|
||||
prt_str(pos, str, mirror);
|
||||
if (DTZ_table[DTZ_ENTRIES - 1].entry)
|
||||
free_dtz_entry(DTZ_table[DTZ_ENTRIES-1].entry);
|
||||
for (i = DTZ_ENTRIES - 1; i > 0; i--)
|
||||
DTZ_table[i] = DTZ_table[i - 1];
|
||||
load_dtz_table(str, calc_key(pos, mirror), calc_key(pos, !mirror));
|
||||
}
|
||||
}
|
||||
|
||||
ptr = DTZ_table[0].entry;
|
||||
if (!ptr) {
|
||||
*success = 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int bside, mirror, cmirror;
|
||||
if (!ptr->symmetric) {
|
||||
if (key != ptr->key) {
|
||||
cmirror = 8;
|
||||
mirror = 0x38;
|
||||
bside = (pos.side_to_move() == WHITE);
|
||||
} else {
|
||||
cmirror = mirror = 0;
|
||||
bside = !(pos.side_to_move() == WHITE);
|
||||
}
|
||||
} else {
|
||||
cmirror = pos.side_to_move() == WHITE ? 0 : 8;
|
||||
mirror = pos.side_to_move() == WHITE ? 0 : 0x38;
|
||||
bside = 0;
|
||||
}
|
||||
|
||||
if (!ptr->has_pawns) {
|
||||
struct DTZEntry_piece *entry = (struct DTZEntry_piece *)ptr;
|
||||
if ((entry->flags & 1) != bside && !entry->symmetric) {
|
||||
*success = -1;
|
||||
return 0;
|
||||
}
|
||||
ubyte *pc = entry->pieces;
|
||||
for (i = 0; i < entry->num;) {
|
||||
Bitboard bb = pos.pieces((Color)((pc[i] ^ cmirror) >> 3),
|
||||
(PieceType)(pc[i] & 0x07));
|
||||
do {
|
||||
p[i++] = pop_lsb(&bb);
|
||||
} while (bb);
|
||||
}
|
||||
idx = encode_piece((struct TBEntry_piece *)entry, entry->norm, p, entry->factor);
|
||||
res = decompress_pairs(entry->precomp, idx);
|
||||
|
||||
if (entry->flags & 2)
|
||||
res = entry->map[entry->map_idx[wdl_to_map[wdl + 2]] + res];
|
||||
|
||||
if (!(entry->flags & pa_flags[wdl + 2]) || (wdl & 1))
|
||||
res *= 2;
|
||||
} else {
|
||||
struct DTZEntry_pawn *entry = (struct DTZEntry_pawn *)ptr;
|
||||
int k = entry->file[0].pieces[0] ^ cmirror;
|
||||
Bitboard bb = pos.pieces((Color)(k >> 3), (PieceType)(k & 0x07));
|
||||
i = 0;
|
||||
do {
|
||||
p[i++] = pop_lsb(&bb) ^ mirror;
|
||||
} while (bb);
|
||||
int f = pawn_file((struct TBEntry_pawn *)entry, p);
|
||||
if ((entry->flags[f] & 1) != bside) {
|
||||
*success = -1;
|
||||
return 0;
|
||||
}
|
||||
ubyte *pc = entry->file[f].pieces;
|
||||
for (; i < entry->num;) {
|
||||
bb = pos.pieces((Color)((pc[i] ^ cmirror) >> 3),
|
||||
(PieceType)(pc[i] & 0x07));
|
||||
do {
|
||||
p[i++] = pop_lsb(&bb) ^ mirror;
|
||||
} while (bb);
|
||||
}
|
||||
idx = encode_pawn((struct TBEntry_pawn *)entry, entry->file[f].norm, p, entry->file[f].factor);
|
||||
res = decompress_pairs(entry->file[f].precomp, idx);
|
||||
|
||||
if (entry->flags[f] & 2)
|
||||
res = entry->map[entry->map_idx[f][wdl_to_map[wdl + 2]] + res];
|
||||
|
||||
if (!(entry->flags[f] & pa_flags[wdl + 2]) || (wdl & 1))
|
||||
res *= 2;
|
||||
}
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
// Add underpromotion captures to list of captures.
|
||||
static ExtMove *add_underprom_caps(Position& pos, ExtMove *stack, ExtMove *end)
|
||||
{
|
||||
ExtMove *moves, *extra = end;
|
||||
|
||||
for (moves = stack; moves < end; moves++) {
|
||||
Move move = moves->move;
|
||||
if (type_of(move) == PROMOTION && !pos.empty(to_sq(move))) {
|
||||
(*extra++).move = (Move)(move - (1 << 12));
|
||||
(*extra++).move = (Move)(move - (2 << 12));
|
||||
(*extra++).move = (Move)(move - (3 << 12));
|
||||
}
|
||||
}
|
||||
|
||||
return extra;
|
||||
}
|
||||
|
||||
static int probe_ab(Position& pos, int alpha, int beta, int *success)
|
||||
{
|
||||
int v;
|
||||
ExtMove stack[64];
|
||||
ExtMove *moves, *end;
|
||||
StateInfo st;
|
||||
|
||||
// Generate (at least) all legal non-ep captures including (under)promotions.
|
||||
// It is OK to generate more, as long as they are filtered out below.
|
||||
if (!pos.checkers()) {
|
||||
end = generate<CAPTURES>(pos, stack);
|
||||
// Since underpromotion captures are not included, we need to add them.
|
||||
end = add_underprom_caps(pos, stack, end);
|
||||
} else
|
||||
end = generate<EVASIONS>(pos, stack);
|
||||
|
||||
CheckInfo ci(pos);
|
||||
|
||||
for (moves = stack; moves < end; moves++) {
|
||||
Move capture = moves->move;
|
||||
if (!pos.capture(capture) || type_of(capture) == ENPASSANT
|
||||
|| !pos.legal(capture, ci.pinned))
|
||||
continue;
|
||||
pos.do_move(capture, st, pos.gives_check(capture, ci));
|
||||
v = -probe_ab(pos, -beta, -alpha, success);
|
||||
pos.undo_move(capture);
|
||||
if (*success == 0) return 0;
|
||||
if (v > alpha) {
|
||||
if (v >= beta) {
|
||||
*success = 2;
|
||||
return v;
|
||||
}
|
||||
alpha = v;
|
||||
}
|
||||
}
|
||||
|
||||
v = probe_wdl_table(pos, success);
|
||||
if (*success == 0) return 0;
|
||||
if (alpha >= v) {
|
||||
*success = 1 + (alpha > 0);
|
||||
return alpha;
|
||||
} else {
|
||||
*success = 1;
|
||||
return v;
|
||||
}
|
||||
}
|
||||
|
||||
// Probe the WDL table for a particular position.
|
||||
// If *success != 0, the probe was successful.
|
||||
// The return value is from the point of view of the side to move:
|
||||
// -2 : loss
|
||||
// -1 : loss, but draw under 50-move rule
|
||||
// 0 : draw
|
||||
// 1 : win, but draw under 50-move rule
|
||||
// 2 : win
|
||||
int TablebasesRef::probe_wdl(Position& pos, int *success)
|
||||
{
|
||||
int v;
|
||||
|
||||
*success = 1;
|
||||
v = probe_ab(pos, -2, 2, success);
|
||||
|
||||
// If en passant is not possible, we are done.
|
||||
if (pos.ep_square() == SQ_NONE)
|
||||
return v;
|
||||
if (!(*success)) return 0;
|
||||
|
||||
// Now handle en passant.
|
||||
int v1 = -3;
|
||||
// Generate (at least) all legal en passant captures.
|
||||
ExtMove stack[192];
|
||||
ExtMove *moves, *end;
|
||||
StateInfo st;
|
||||
|
||||
if (!pos.checkers())
|
||||
end = generate<CAPTURES>(pos, stack);
|
||||
else
|
||||
end = generate<EVASIONS>(pos, stack);
|
||||
|
||||
CheckInfo ci(pos);
|
||||
|
||||
for (moves = stack; moves < end; moves++) {
|
||||
Move capture = moves->move;
|
||||
if (type_of(capture) != ENPASSANT
|
||||
|| !pos.legal(capture, ci.pinned))
|
||||
continue;
|
||||
pos.do_move(capture, st, pos.gives_check(capture, ci));
|
||||
int v0 = -probe_ab(pos, -2, 2, success);
|
||||
pos.undo_move(capture);
|
||||
if (*success == 0) return 0;
|
||||
if (v0 > v1) v1 = v0;
|
||||
}
|
||||
if (v1 > -3) {
|
||||
if (v1 >= v) v = v1;
|
||||
else if (v == 0) {
|
||||
// Check whether there is at least one legal non-ep move.
|
||||
for (moves = stack; moves < end; moves++) {
|
||||
Move capture = moves->move;
|
||||
if (type_of(capture) == ENPASSANT) continue;
|
||||
if (pos.legal(capture, ci.pinned)) break;
|
||||
}
|
||||
if (moves == end && !pos.checkers()) {
|
||||
end = generate<QUIETS>(pos, end);
|
||||
for (; moves < end; moves++) {
|
||||
Move move = moves->move;
|
||||
if (pos.legal(move, ci.pinned))
|
||||
break;
|
||||
}
|
||||
}
|
||||
// If not, then we are forced to play the losing ep capture.
|
||||
if (moves == end)
|
||||
v = v1;
|
||||
}
|
||||
}
|
||||
|
||||
return v;
|
||||
}
|
||||
|
||||
// This routine treats a position with en passant captures as one without.
|
||||
static int probe_dtz_no_ep(Position& pos, int *success)
|
||||
{
|
||||
int wdl, dtz;
|
||||
|
||||
wdl = probe_ab(pos, -2, 2, success);
|
||||
if (*success == 0) return 0;
|
||||
|
||||
if (wdl == 0) return 0;
|
||||
|
||||
if (*success == 2)
|
||||
return wdl == 2 ? 1 : 101;
|
||||
|
||||
ExtMove stack[192];
|
||||
ExtMove *moves, *end = NULL;
|
||||
StateInfo st;
|
||||
CheckInfo ci(pos);
|
||||
|
||||
if (wdl > 0) {
|
||||
// Generate at least all legal non-capturing pawn moves
|
||||
// including non-capturing promotions.
|
||||
if (!pos.checkers())
|
||||
end = generate<NON_EVASIONS>(pos, stack);
|
||||
else
|
||||
end = generate<EVASIONS>(pos, stack);
|
||||
|
||||
for (moves = stack; moves < end; moves++) {
|
||||
Move move = moves->move;
|
||||
if (type_of(pos.moved_piece(move)) != PAWN || pos.capture(move)
|
||||
|| !pos.legal(move, ci.pinned))
|
||||
continue;
|
||||
pos.do_move(move, st, pos.gives_check(move, ci));
|
||||
int v = -probe_ab(pos, -2, -wdl + 1, success);
|
||||
pos.undo_move(move);
|
||||
if (*success == 0) return 0;
|
||||
if (v == wdl)
|
||||
return v == 2 ? 1 : 101;
|
||||
}
|
||||
}
|
||||
|
||||
dtz = 1 + probe_dtz_table(pos, wdl, success);
|
||||
if (*success >= 0) {
|
||||
if (wdl & 1) dtz += 100;
|
||||
return wdl >= 0 ? dtz : -dtz;
|
||||
}
|
||||
|
||||
if (wdl > 0) {
|
||||
int best = 0xffff;
|
||||
for (moves = stack; moves < end; moves++) {
|
||||
Move move = moves->move;
|
||||
if (pos.capture(move) || type_of(pos.moved_piece(move)) == PAWN
|
||||
|| !pos.legal(move, ci.pinned))
|
||||
continue;
|
||||
pos.do_move(move, st, pos.gives_check(move, ci));
|
||||
int v = -TablebasesRef::probe_dtz(pos, success);
|
||||
pos.undo_move(move);
|
||||
if (*success == 0) return 0;
|
||||
if (v > 0 && v + 1 < best)
|
||||
best = v + 1;
|
||||
}
|
||||
return best;
|
||||
} else {
|
||||
int best = -1;
|
||||
if (!pos.checkers())
|
||||
end = generate<NON_EVASIONS>(pos, stack);
|
||||
else
|
||||
end = generate<EVASIONS>(pos, stack);
|
||||
for (moves = stack; moves < end; moves++) {
|
||||
int v;
|
||||
Move move = moves->move;
|
||||
if (!pos.legal(move, ci.pinned))
|
||||
continue;
|
||||
pos.do_move(move, st, pos.gives_check(move, ci));
|
||||
if (st.rule50 == 0) {
|
||||
if (wdl == -2) v = -1;
|
||||
else {
|
||||
v = probe_ab(pos, 1, 2, success);
|
||||
v = (v == 2) ? 0 : -101;
|
||||
}
|
||||
} else {
|
||||
v = -TablebasesRef::probe_dtz(pos, success) - 1;
|
||||
}
|
||||
pos.undo_move(move);
|
||||
if (*success == 0) return 0;
|
||||
if (v < best)
|
||||
best = v;
|
||||
}
|
||||
return best;
|
||||
}
|
||||
}
|
||||
|
||||
static int wdl_to_dtz[] = {
|
||||
-1, -101, 0, 101, 1
|
||||
};
|
||||
|
||||
// Probe the DTZ table for a particular position.
|
||||
// If *success != 0, the probe was successful.
|
||||
// The return value is from the point of view of the side to move:
|
||||
// n < -100 : loss, but draw under 50-move rule
|
||||
// -100 <= n < -1 : loss in n ply (assuming 50-move counter == 0)
|
||||
// 0 : draw
|
||||
// 1 < n <= 100 : win in n ply (assuming 50-move counter == 0)
|
||||
// 100 < n : win, but draw under 50-move rule
|
||||
//
|
||||
// The return value n can be off by 1: a return value -n can mean a loss
|
||||
// in n+1 ply and a return value +n can mean a win in n+1 ply. This
|
||||
// cannot happen for tables with positions exactly on the "edge" of
|
||||
// the 50-move rule.
|
||||
//
|
||||
// This implies that if dtz > 0 is returned, the position is certainly
|
||||
// a win if dtz + 50-move-counter <= 99. Care must be taken that the engine
|
||||
// picks moves that preserve dtz + 50-move-counter <= 99.
|
||||
//
|
||||
// If n = 100 immediately after a capture or pawn move, then the position
|
||||
// is also certainly a win, and during the whole phase until the next
|
||||
// capture or pawn move, the inequality to be preserved is
|
||||
// dtz + 50-movecounter <= 100.
|
||||
//
|
||||
// In short, if a move is available resulting in dtz + 50-move-counter <= 99,
|
||||
// then do not accept moves leading to dtz + 50-move-counter == 100.
|
||||
//
|
||||
int TablebasesRef::probe_dtz(Position& pos, int *success)
|
||||
{
|
||||
*success = 1;
|
||||
int v = probe_dtz_no_ep(pos, success);
|
||||
|
||||
if (pos.ep_square() == SQ_NONE)
|
||||
return v;
|
||||
if (*success == 0) return 0;
|
||||
|
||||
// Now handle en passant.
|
||||
int v1 = -3;
|
||||
|
||||
ExtMove stack[192];
|
||||
ExtMove *moves, *end;
|
||||
StateInfo st;
|
||||
|
||||
if (!pos.checkers())
|
||||
end = generate<CAPTURES>(pos, stack);
|
||||
else
|
||||
end = generate<EVASIONS>(pos, stack);
|
||||
CheckInfo ci(pos);
|
||||
|
||||
for (moves = stack; moves < end; moves++) {
|
||||
Move capture = moves->move;
|
||||
if (type_of(capture) != ENPASSANT
|
||||
|| !pos.legal(capture, ci.pinned))
|
||||
continue;
|
||||
pos.do_move(capture, st, pos.gives_check(capture, ci));
|
||||
int v0 = -probe_ab(pos, -2, 2, success);
|
||||
pos.undo_move(capture);
|
||||
if (*success == 0) return 0;
|
||||
if (v0 > v1) v1 = v0;
|
||||
}
|
||||
if (v1 > -3) {
|
||||
v1 = wdl_to_dtz[v1 + 2];
|
||||
if (v < -100) {
|
||||
if (v1 >= 0)
|
||||
v = v1;
|
||||
} else if (v < 0) {
|
||||
if (v1 >= 0 || v1 < -100)
|
||||
v = v1;
|
||||
} else if (v > 100) {
|
||||
if (v1 > 0)
|
||||
v = v1;
|
||||
} else if (v > 0) {
|
||||
if (v1 == 1)
|
||||
v = v1;
|
||||
} else if (v1 >= 0) {
|
||||
v = v1;
|
||||
} else {
|
||||
for (moves = stack; moves < end; moves++) {
|
||||
Move move = moves->move;
|
||||
if (type_of(move) == ENPASSANT) continue;
|
||||
if (pos.legal(move, ci.pinned)) break;
|
||||
}
|
||||
if (moves == end && !pos.checkers()) {
|
||||
end = generate<QUIETS>(pos, end);
|
||||
for (; moves < end; moves++) {
|
||||
Move move = moves->move;
|
||||
if (pos.legal(move, ci.pinned))
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (moves == end)
|
||||
v = v1;
|
||||
}
|
||||
}
|
||||
|
||||
return v;
|
||||
}
|
||||
|
||||
// Check whether there has been at least one repetition of positions
|
||||
// since the last capture or pawn move.
|
||||
static int has_repeated(StateInfo *st)
|
||||
{
|
||||
while (1) {
|
||||
int i = 4, e = std::min(st->rule50, st->pliesFromNull);
|
||||
if (e < i)
|
||||
return 0;
|
||||
StateInfo *stp = st->previous->previous;
|
||||
do {
|
||||
stp = stp->previous->previous;
|
||||
if (stp->key == st->key)
|
||||
return 1;
|
||||
i += 2;
|
||||
} while (i <= e);
|
||||
st = st->previous;
|
||||
}
|
||||
}
|
||||
|
||||
static Value wdl_to_Value[5] = {
|
||||
-VALUE_MATE + MAX_PLY + 1,
|
||||
VALUE_DRAW - 2,
|
||||
VALUE_DRAW,
|
||||
VALUE_DRAW + 2,
|
||||
VALUE_MATE - MAX_PLY - 1
|
||||
};
|
||||
|
||||
// Use the DTZ tables to filter out moves that don't preserve the win or draw.
|
||||
// If the position is lost, but DTZ is fairly high, only keep moves that
|
||||
// maximise DTZ.
|
||||
//
|
||||
// A return value false indicates that not all probes were successful and that
|
||||
// no moves were filtered out.
|
||||
bool TablebasesRef::root_probe(Position& pos, Search::RootMoves& rootMoves, Value& score)
|
||||
{
|
||||
int success;
|
||||
|
||||
int dtz = probe_dtz(pos, &success);
|
||||
if (!success) return false;
|
||||
|
||||
StateInfo st;
|
||||
CheckInfo ci(pos);
|
||||
|
||||
// Probe each move.
|
||||
for (size_t i = 0; i < rootMoves.size(); i++) {
|
||||
Move move = rootMoves[i].pv[0];
|
||||
pos.do_move(move, st, pos.gives_check(move, ci));
|
||||
int v = 0;
|
||||
if (pos.checkers() && dtz > 0) {
|
||||
ExtMove s[192];
|
||||
if (generate<LEGAL>(pos, s) == s)
|
||||
v = 1;
|
||||
}
|
||||
if (!v) {
|
||||
if (st.rule50 != 0) {
|
||||
v = -TablebasesRef::probe_dtz(pos, &success);
|
||||
if (v > 0) v++;
|
||||
else if (v < 0) v--;
|
||||
} else {
|
||||
v = -TablebasesRef::probe_wdl(pos, &success);
|
||||
v = wdl_to_dtz[v + 2];
|
||||
}
|
||||
}
|
||||
pos.undo_move(move);
|
||||
if (!success) return false;
|
||||
rootMoves[i].score = (Value)v;
|
||||
}
|
||||
|
||||
// Obtain 50-move counter for the root position.
|
||||
// In Stockfish there seems to be no clean way, so we do it like this:
|
||||
int cnt50 = st.previous->rule50;
|
||||
|
||||
// Use 50-move counter to determine whether the root position is
|
||||
// won, lost or drawn.
|
||||
int wdl = 0;
|
||||
if (dtz > 0)
|
||||
wdl = (dtz + cnt50 <= 100) ? 2 : 1;
|
||||
else if (dtz < 0)
|
||||
wdl = (-dtz + cnt50 <= 100) ? -2 : -1;
|
||||
|
||||
// Determine the score to report to the user.
|
||||
score = wdl_to_Value[wdl + 2];
|
||||
// If the position is winning or losing, but too few moves left, adjust the
|
||||
// score to show how close it is to winning or losing.
|
||||
// NOTE: int(PawnValueEg) is used as scaling factor in score_to_uci().
|
||||
if (wdl == 1 && dtz <= 100)
|
||||
score = (Value)(((200 - dtz - cnt50) * int(PawnValueEg)) / 200);
|
||||
else if (wdl == -1 && dtz >= -100)
|
||||
score = -(Value)(((200 + dtz - cnt50) * int(PawnValueEg)) / 200);
|
||||
|
||||
// Now be a bit smart about filtering out moves.
|
||||
size_t j = 0;
|
||||
if (dtz > 0) { // winning (or 50-move rule draw)
|
||||
int best = 0xffff;
|
||||
for (size_t i = 0; i < rootMoves.size(); i++) {
|
||||
int v = rootMoves[i].score;
|
||||
if (v > 0 && v < best)
|
||||
best = v;
|
||||
}
|
||||
int max = best;
|
||||
// If the current phase has not seen repetitions, then try all moves
|
||||
// that stay safely within the 50-move budget, if there are any.
|
||||
if (!has_repeated(st.previous) && best + cnt50 <= 99)
|
||||
max = 99 - cnt50;
|
||||
for (size_t i = 0; i < rootMoves.size(); i++) {
|
||||
int v = rootMoves[i].score;
|
||||
if (v > 0 && v <= max)
|
||||
rootMoves[j++] = rootMoves[i];
|
||||
}
|
||||
} else if (dtz < 0) { // losing (or 50-move rule draw)
|
||||
int best = 0;
|
||||
for (size_t i = 0; i < rootMoves.size(); i++) {
|
||||
int v = rootMoves[i].score;
|
||||
if (v < best)
|
||||
best = v;
|
||||
}
|
||||
// Try all moves, unless we approach or have a 50-move rule draw.
|
||||
if (-best * 2 + cnt50 < 100)
|
||||
return true;
|
||||
for (size_t i = 0; i < rootMoves.size(); i++) {
|
||||
if (rootMoves[i].score == best)
|
||||
rootMoves[j++] = rootMoves[i];
|
||||
}
|
||||
} else { // drawing
|
||||
// Try all moves that preserve the draw.
|
||||
for (size_t i = 0; i < rootMoves.size(); i++) {
|
||||
if (rootMoves[i].score == 0)
|
||||
rootMoves[j++] = rootMoves[i];
|
||||
}
|
||||
}
|
||||
rootMoves.resize(j, Search::RootMove(MOVE_NONE));
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
// Use the WDL tables to filter out moves that don't preserve the win or draw.
|
||||
// This is a fallback for the case that some or all DTZ tables are missing.
|
||||
//
|
||||
// A return value false indicates that not all probes were successful and that
|
||||
// no moves were filtered out.
|
||||
bool TablebasesRef::root_probe_wdl(Position& pos, Search::RootMoves& rootMoves, Value& score)
|
||||
{
|
||||
int success;
|
||||
|
||||
int wdl = TablebasesRef::probe_wdl(pos, &success);
|
||||
if (!success) return false;
|
||||
score = wdl_to_Value[wdl + 2];
|
||||
|
||||
StateInfo st;
|
||||
CheckInfo ci(pos);
|
||||
|
||||
int best = -2;
|
||||
|
||||
// Probe each move.
|
||||
for (size_t i = 0; i < rootMoves.size(); i++) {
|
||||
Move move = rootMoves[i].pv[0];
|
||||
pos.do_move(move, st, pos.gives_check(move, ci));
|
||||
int v = -TablebasesRef::probe_wdl(pos, &success);
|
||||
pos.undo_move(move);
|
||||
if (!success) return false;
|
||||
rootMoves[i].score = (Value)v;
|
||||
if (v > best)
|
||||
best = v;
|
||||
}
|
||||
|
||||
size_t j = 0;
|
||||
for (size_t i = 0; i < rootMoves.size(); i++) {
|
||||
if (rootMoves[i].score == best)
|
||||
rootMoves[j++] = rootMoves[i];
|
||||
}
|
||||
rootMoves.resize(j, Search::RootMove(MOVE_NONE));
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
|
|
@ -0,0 +1,18 @@
|
|||
#ifndef TBPROBE_REF_H
|
||||
#define TBPROBE_REF_H
|
||||
|
||||
#include "../search.h"
|
||||
|
||||
namespace TablebasesRef {
|
||||
|
||||
extern int MaxCardinality;
|
||||
|
||||
void init(const std::string& path);
|
||||
int probe_wdl(Position& pos, int *success);
|
||||
int probe_dtz(Position& pos, int *success);
|
||||
bool root_probe(Position& pos, Search::RootMoves& rootMoves, Value& score);
|
||||
bool root_probe_wdl(Position& pos, Search::RootMoves& rootMoves, Value& score);
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
@ -192,13 +192,13 @@ void UCI::loop(int argc, char* argv[]) {
|
|||
else if (token == "wdl")
|
||||
{
|
||||
Tablebases::ProbeState err;
|
||||
Tablebases::WDLScore v = Tablebases::probe_wdl(pos, &err);
|
||||
Tablebases::WDLScore v = TablebasesInst::probe_wdl(pos, &err);
|
||||
sync_cout << v << " (" << err << ")" << sync_endl;
|
||||
}
|
||||
else if (token == "dtz")
|
||||
{
|
||||
Tablebases::ProbeState err;
|
||||
int dtz = Tablebases::probe_dtz(pos, &err);
|
||||
int dtz = TablebasesInst::probe_dtz(pos, &err);
|
||||
sync_cout << dtz << " (" << err << ")" << sync_endl;
|
||||
}
|
||||
else if (token == "isready") sync_cout << "readyok" << sync_endl;
|
||||
|
|
|
|||
|
|
@ -40,7 +40,7 @@ void on_clear_hash(const Option&) { Search::clear(); }
|
|||
void on_hash_size(const Option& o) { TT.resize(o); }
|
||||
void on_logger(const Option& o) { start_logger(o); }
|
||||
void on_threads(const Option&) { Threads.read_uci_options(); }
|
||||
void on_tb_path(const Option& o) { Tablebases::init(o); }
|
||||
void on_tb_path(const Option& o) { TablebasesInst::init(o); }
|
||||
|
||||
|
||||
/// Our case insensitive less() function as required by UCI protocol
|
||||
|
|
|
|||
Loading…
Reference in New Issue