mirror of
https://github.com/sockspls/badfish
synced 2025-07-12 03:59:15 +00:00

This is the first patch teaching Stockfish how to use the 7-pieces Syzygy tablebase currently calculated by Bujun Guo (@noobpwnftw) and Ronald de Man (@syzygy1). The 7-pieces database are so big that they required a change in the internal format of the files (technically, some DTZ values are 16 bits long, so this had to be stored as wide integers in the Huffman tree). Here are the estimated file size for the 7-pieces Syzygy files, compared to the 151G of the 6-pieces Syzygy: ``` 7.1T ./7men_testing/4v3_pawnful (ongoing, 120 of 325 sets remaining) 2.4T ./7men_testing/4v3_pawnless 2.3T ./7men_testing/5v2_pawnful 660G ./7men_testing/5v2_pawnless 117G ./7men_testing/6v1_pawnful 87G ./7men_testing/6v1_pawnless ``` Some pointers to download or recalculate the tables: Location of original files, by Bujun Guo: ftp://ftp.chessdb.cn/pub/syzygy/ Mirrors: http://tablebase.sesse.net/ (partial) http://tablebase.lichess.ovh/tables/standard/7/ Generator code: https://github.com/syzygy1/tb/ Closes https://github.com/official-stockfish/Stockfish/pull/1707 Bench: 5591925 (No functional change if SyzygyTB is not used) ---------------------- Comment by Leonardo Ljubičić (@DragonMist) This is an amazing achievement, generating and being able to use 7 men syzygy on the fly. Thank you for your efforts @noobpwnftw !! Looking forward how this will work in real life, and expecting some trade off between gaining perfect play and slow disc Access, but once the disc speed and space is not a problem, I expect 7 men to yield something like 30 elo at least. ----------------------- Comment by Michael Byrne (@MichaelB7) This definitely has a bright future. I turned off the 50 move rule (ala ICCF new rules) for the following position: `[d]8/8/1b6/8/4N2r/1k6/7B/R1K5 w - - 0 1` This position is a 451 ply win for white (sans the 50 move rule, this position was identified by the generator as the longest cursed win for white in KRBN v KRB). Now Stockfish finds it instantly (as it should), nice work 👊👍 . ``` dep score nodes time 7 +132.79 4339 0:00.00 Rb1+ Kc4 Nd6+ Kc5 Bg1+ Kxd6 Rxb6+ Kc7 Be3 Rh2 Bd4 6 +132.79 1652 0:00.00 Rb1+ Kc4 Nd2+ Kd5 Rxb6 Rxh2 Nf3 Rf2 5 +132.79 589 0:00.00 Rb1+ Kc4 Rxb6 Rxh2 Nf6 Rh1+ Kb2 4 +132.79 308 0:00.00 Rb1+ Kc4 Nd6+ Kc3 Rxb6 Rxh2 3 +132.79 88 0:00.00 Rb1+ Ka4 Nc3+ Ka5 Ra1+ Kb4 Ra4+ Kxc3 Rxh4 2 +132.79 54 0:00.00 Rb1+ Ka4 Nc3+ Ka5 Ra1+ Kb4 1 +132.7 ```
177 lines
5.7 KiB
C++
177 lines
5.7 KiB
C++
/*
|
|
Stockfish, a UCI chess playing engine derived from Glaurung 2.1
|
|
Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
|
|
Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
|
|
Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
|
|
|
|
Stockfish is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
Stockfish is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include <algorithm>
|
|
#include <cassert>
|
|
#include <ostream>
|
|
|
|
#include "misc.h"
|
|
#include "search.h"
|
|
#include "thread.h"
|
|
#include "tt.h"
|
|
#include "uci.h"
|
|
#include "syzygy/tbprobe.h"
|
|
|
|
using std::string;
|
|
|
|
UCI::OptionsMap Options; // Global object
|
|
|
|
namespace UCI {
|
|
|
|
/// 'On change' actions, triggered by an option's value change
|
|
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& o) { Threads.set(o); }
|
|
void on_tb_path(const Option& o) { Tablebases::init(o); }
|
|
|
|
|
|
/// Our case insensitive less() function as required by UCI protocol
|
|
bool CaseInsensitiveLess::operator() (const string& s1, const string& s2) const {
|
|
|
|
return std::lexicographical_compare(s1.begin(), s1.end(), s2.begin(), s2.end(),
|
|
[](char c1, char c2) { return tolower(c1) < tolower(c2); });
|
|
}
|
|
|
|
|
|
/// init() initializes the UCI options to their hard-coded default values
|
|
|
|
void init(OptionsMap& o) {
|
|
|
|
// at most 2^32 clusters.
|
|
constexpr int MaxHashMB = Is64Bit ? 131072 : 2048;
|
|
|
|
o["Debug Log File"] << Option("", on_logger);
|
|
o["Contempt"] << Option(21, -100, 100);
|
|
o["Analysis Contempt"] << Option("Both var Off var White var Black var Both", "Both");
|
|
o["Threads"] << Option(1, 1, 512, on_threads);
|
|
o["Hash"] << Option(16, 1, MaxHashMB, on_hash_size);
|
|
o["Clear Hash"] << Option(on_clear_hash);
|
|
o["Ponder"] << Option(false);
|
|
o["MultiPV"] << Option(1, 1, 500);
|
|
o["Skill Level"] << Option(20, 0, 20);
|
|
o["Move Overhead"] << Option(30, 0, 5000);
|
|
o["Minimum Thinking Time"] << Option(20, 0, 5000);
|
|
o["Slow Mover"] << Option(84, 10, 1000);
|
|
o["nodestime"] << Option(0, 0, 10000);
|
|
o["UCI_Chess960"] << Option(false);
|
|
o["UCI_AnalyseMode"] << Option(false);
|
|
o["SyzygyPath"] << Option("<empty>", on_tb_path);
|
|
o["SyzygyProbeDepth"] << Option(1, 1, 100);
|
|
o["Syzygy50MoveRule"] << Option(true);
|
|
o["SyzygyProbeLimit"] << Option(7, 0, 7);
|
|
}
|
|
|
|
|
|
/// operator<<() is used to print all the options default values in chronological
|
|
/// insertion order (the idx field) and in the format defined by the UCI protocol.
|
|
|
|
std::ostream& operator<<(std::ostream& os, const OptionsMap& om) {
|
|
|
|
for (size_t idx = 0; idx < om.size(); ++idx)
|
|
for (const auto& it : om)
|
|
if (it.second.idx == idx)
|
|
{
|
|
const Option& o = it.second;
|
|
os << "\noption name " << it.first << " type " << o.type;
|
|
|
|
if (o.type == "string" || o.type == "check" || o.type == "combo")
|
|
os << " default " << o.defaultValue;
|
|
|
|
if (o.type == "spin")
|
|
os << " default " << int(stof(o.defaultValue))
|
|
<< " min " << o.min
|
|
<< " max " << o.max;
|
|
|
|
break;
|
|
}
|
|
|
|
return os;
|
|
}
|
|
|
|
|
|
/// Option class constructors and conversion operators
|
|
|
|
Option::Option(const char* v, OnChange f) : type("string"), min(0), max(0), on_change(f)
|
|
{ defaultValue = currentValue = v; }
|
|
|
|
Option::Option(bool v, OnChange f) : type("check"), min(0), max(0), on_change(f)
|
|
{ defaultValue = currentValue = (v ? "true" : "false"); }
|
|
|
|
Option::Option(OnChange f) : type("button"), min(0), max(0), on_change(f)
|
|
{}
|
|
|
|
Option::Option(double v, int minv, int maxv, OnChange f) : type("spin"), min(minv), max(maxv), on_change(f)
|
|
{ defaultValue = currentValue = std::to_string(v); }
|
|
|
|
Option::Option(const char* v, const char* cur, OnChange f) : type("combo"), min(0), max(0), on_change(f)
|
|
{ defaultValue = v; currentValue = cur; }
|
|
|
|
Option::operator double() const {
|
|
assert(type == "check" || type == "spin");
|
|
return (type == "spin" ? stof(currentValue) : currentValue == "true");
|
|
}
|
|
|
|
Option::operator std::string() const {
|
|
assert(type == "string");
|
|
return currentValue;
|
|
}
|
|
|
|
bool Option::operator==(const char* s) const {
|
|
assert(type == "combo");
|
|
return !CaseInsensitiveLess()(currentValue, s)
|
|
&& !CaseInsensitiveLess()(s, currentValue);
|
|
}
|
|
|
|
|
|
/// operator<<() inits options and assigns idx in the correct printing order
|
|
|
|
void Option::operator<<(const Option& o) {
|
|
|
|
static size_t insert_order = 0;
|
|
|
|
*this = o;
|
|
idx = insert_order++;
|
|
}
|
|
|
|
|
|
/// operator=() updates currentValue and triggers on_change() action. It's up to
|
|
/// the GUI to check for option's limits, but we could receive the new value from
|
|
/// the user by console window, so let's check the bounds anyway.
|
|
|
|
Option& Option::operator=(const string& v) {
|
|
|
|
assert(!type.empty());
|
|
|
|
if ( (type != "button" && v.empty())
|
|
|| (type == "check" && v != "true" && v != "false")
|
|
|| (type == "spin" && (stof(v) < min || stof(v) > max)))
|
|
return *this;
|
|
|
|
if (type != "button")
|
|
currentValue = v;
|
|
|
|
if (on_change)
|
|
on_change(*this);
|
|
|
|
return *this;
|
|
}
|
|
|
|
} // namespace UCI
|