2008-08-31 23:59:13 -06:00
|
|
|
/*
|
2008-10-19 10:56:28 -06:00
|
|
|
Stockfish, a UCI chess playing engine derived from Glaurung 2.1
|
Add NNUE evaluation
This patch ports the efficiently updatable neural network (NNUE) evaluation to Stockfish.
Both the NNUE and the classical evaluations are available, and can be used to
assign a value to a position that is later used in alpha-beta (PVS) search to find the
best move. The classical evaluation computes this value as a function of various chess
concepts, handcrafted by experts, tested and tuned using fishtest. The NNUE evaluation
computes this value with a neural network based on basic inputs. The network is optimized
and trained on the evalutions of millions of positions at moderate search depth.
The NNUE evaluation was first introduced in shogi, and ported to Stockfish afterward.
It can be evaluated efficiently on CPUs, and exploits the fact that only parts
of the neural network need to be updated after a typical chess move.
[The nodchip repository](https://github.com/nodchip/Stockfish) provides additional
tools to train and develop the NNUE networks.
This patch is the result of contributions of various authors, from various communities,
including: nodchip, ynasu87, yaneurao (initial port and NNUE authors), domschl, FireFather,
rqs, xXH4CKST3RXx, tttak, zz4032, joergoster, mstembera, nguyenpham, erbsenzaehler,
dorzechowski, and vondele.
This new evaluation needed various changes to fishtest and the corresponding infrastructure,
for which tomtor, ppigazzini, noobpwnftw, daylen, and vondele are gratefully acknowledged.
The first networks have been provided by gekkehenker and sergiovieri, with the latter
net (nn-97f742aaefcd.nnue) being the current default.
The evaluation function can be selected at run time with the `Use NNUE` (true/false) UCI option,
provided the `EvalFile` option points the the network file (depending on the GUI, with full path).
The performance of the NNUE evaluation relative to the classical evaluation depends somewhat on
the hardware, and is expected to improve quickly, but is currently on > 80 Elo on fishtest:
60000 @ 10+0.1 th 1
https://tests.stockfishchess.org/tests/view/5f28fe6ea5abc164f05e4c4c
ELO: 92.77 +-2.1 (95%) LOS: 100.0%
Total: 60000 W: 24193 L: 8543 D: 27264
Ptnml(0-2): 609, 3850, 9708, 10948, 4885
40000 @ 20+0.2 th 8
https://tests.stockfishchess.org/tests/view/5f290229a5abc164f05e4c58
ELO: 89.47 +-2.0 (95%) LOS: 100.0%
Total: 40000 W: 12756 L: 2677 D: 24567
Ptnml(0-2): 74, 1583, 8550, 7776, 2017
At the same time, the impact on the classical evaluation remains minimal, causing no significant
regression:
sprt @ 10+0.1 th 1
https://tests.stockfishchess.org/tests/view/5f2906a2a5abc164f05e4c5b
LLR: 2.94 (-2.94,2.94) {-6.00,-4.00}
Total: 34936 W: 6502 L: 6825 D: 21609
Ptnml(0-2): 571, 4082, 8434, 3861, 520
sprt @ 60+0.6 th 1
https://tests.stockfishchess.org/tests/view/5f2906cfa5abc164f05e4c5d
LLR: 2.93 (-2.94,2.94) {-6.00,-4.00}
Total: 10088 W: 1232 L: 1265 D: 7591
Ptnml(0-2): 49, 914, 3170, 843, 68
The needed networks can be found at https://tests.stockfishchess.org/nns
It is recommended to use the default one as indicated by the `EvalFile` UCI option.
Guidelines for testing new nets can be found at
https://github.com/glinscott/fishtest/wiki/Creating-my-first-test#nnue-net-tests
Integration has been discussed in various issues:
https://github.com/official-stockfish/Stockfish/issues/2823
https://github.com/official-stockfish/Stockfish/issues/2728
The integration branch will be closed after the merge:
https://github.com/official-stockfish/Stockfish/pull/2825
https://github.com/official-stockfish/Stockfish/tree/nnue-player-wip
closes https://github.com/official-stockfish/Stockfish/pull/2912
This will be an exciting time for computer chess, looking forward to seeing the evolution of
this approach.
Bench: 4746616
2020-08-05 09:11:15 -06:00
|
|
|
Copyright (C) 2004-2020 The Stockfish developers (see AUTHORS file)
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2008-10-19 10:56:28 -06:00
|
|
|
Stockfish is free software: you can redistribute it and/or modify
|
2008-08-31 23:59:13 -06:00
|
|
|
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.
|
2008-09-06 04:30:07 -06:00
|
|
|
|
2008-10-19 10:56:28 -06:00
|
|
|
Stockfish is distributed in the hope that it will be useful,
|
2008-08-31 23:59:13 -06:00
|
|
|
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.
|
2008-09-06 04:30:07 -06:00
|
|
|
|
2008-08-31 23:59:13 -06:00
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*/
|
|
|
|
|
2016-11-21 23:41:46 -07:00
|
|
|
#ifdef _WIN32
|
|
|
|
#if _WIN32_WINNT < 0x0601
|
|
|
|
#undef _WIN32_WINNT
|
2016-11-25 08:51:24 -07:00
|
|
|
#define _WIN32_WINNT 0x0601 // Force to include needed API prototypes
|
2016-11-21 23:41:46 -07:00
|
|
|
#endif
|
2018-03-15 22:34:38 -06:00
|
|
|
|
|
|
|
#ifndef NOMINMAX
|
|
|
|
#define NOMINMAX
|
|
|
|
#endif
|
|
|
|
|
2016-11-25 08:51:24 -07:00
|
|
|
#include <windows.h>
|
|
|
|
// The needed Windows API for processor groups could be missed from old Windows
|
|
|
|
// versions, so instead of calling them directly (forcing the linker to resolve
|
|
|
|
// the calls at compile time), try to load them at runtime. To do this we need
|
|
|
|
// first to define the corresponding function pointers.
|
|
|
|
extern "C" {
|
|
|
|
typedef bool(*fun1_t)(LOGICAL_PROCESSOR_RELATIONSHIP,
|
|
|
|
PSYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX, PDWORD);
|
|
|
|
typedef bool(*fun2_t)(USHORT, PGROUP_AFFINITY);
|
|
|
|
typedef bool(*fun3_t)(HANDLE, CONST GROUP_AFFINITY*, PGROUP_AFFINITY);
|
|
|
|
}
|
2016-11-21 23:41:46 -07:00
|
|
|
#endif
|
|
|
|
|
2014-09-14 02:06:36 -06:00
|
|
|
#include <fstream>
|
2008-08-31 23:59:13 -06:00
|
|
|
#include <iomanip>
|
2008-09-06 04:22:10 -06:00
|
|
|
#include <iostream>
|
2008-08-31 23:59:13 -06:00
|
|
|
#include <sstream>
|
2016-11-21 23:41:46 -07:00
|
|
|
#include <vector>
|
Add NNUE evaluation
This patch ports the efficiently updatable neural network (NNUE) evaluation to Stockfish.
Both the NNUE and the classical evaluations are available, and can be used to
assign a value to a position that is later used in alpha-beta (PVS) search to find the
best move. The classical evaluation computes this value as a function of various chess
concepts, handcrafted by experts, tested and tuned using fishtest. The NNUE evaluation
computes this value with a neural network based on basic inputs. The network is optimized
and trained on the evalutions of millions of positions at moderate search depth.
The NNUE evaluation was first introduced in shogi, and ported to Stockfish afterward.
It can be evaluated efficiently on CPUs, and exploits the fact that only parts
of the neural network need to be updated after a typical chess move.
[The nodchip repository](https://github.com/nodchip/Stockfish) provides additional
tools to train and develop the NNUE networks.
This patch is the result of contributions of various authors, from various communities,
including: nodchip, ynasu87, yaneurao (initial port and NNUE authors), domschl, FireFather,
rqs, xXH4CKST3RXx, tttak, zz4032, joergoster, mstembera, nguyenpham, erbsenzaehler,
dorzechowski, and vondele.
This new evaluation needed various changes to fishtest and the corresponding infrastructure,
for which tomtor, ppigazzini, noobpwnftw, daylen, and vondele are gratefully acknowledged.
The first networks have been provided by gekkehenker and sergiovieri, with the latter
net (nn-97f742aaefcd.nnue) being the current default.
The evaluation function can be selected at run time with the `Use NNUE` (true/false) UCI option,
provided the `EvalFile` option points the the network file (depending on the GUI, with full path).
The performance of the NNUE evaluation relative to the classical evaluation depends somewhat on
the hardware, and is expected to improve quickly, but is currently on > 80 Elo on fishtest:
60000 @ 10+0.1 th 1
https://tests.stockfishchess.org/tests/view/5f28fe6ea5abc164f05e4c4c
ELO: 92.77 +-2.1 (95%) LOS: 100.0%
Total: 60000 W: 24193 L: 8543 D: 27264
Ptnml(0-2): 609, 3850, 9708, 10948, 4885
40000 @ 20+0.2 th 8
https://tests.stockfishchess.org/tests/view/5f290229a5abc164f05e4c58
ELO: 89.47 +-2.0 (95%) LOS: 100.0%
Total: 40000 W: 12756 L: 2677 D: 24567
Ptnml(0-2): 74, 1583, 8550, 7776, 2017
At the same time, the impact on the classical evaluation remains minimal, causing no significant
regression:
sprt @ 10+0.1 th 1
https://tests.stockfishchess.org/tests/view/5f2906a2a5abc164f05e4c5b
LLR: 2.94 (-2.94,2.94) {-6.00,-4.00}
Total: 34936 W: 6502 L: 6825 D: 21609
Ptnml(0-2): 571, 4082, 8434, 3861, 520
sprt @ 60+0.6 th 1
https://tests.stockfishchess.org/tests/view/5f2906cfa5abc164f05e4c5d
LLR: 2.93 (-2.94,2.94) {-6.00,-4.00}
Total: 10088 W: 1232 L: 1265 D: 7591
Ptnml(0-2): 49, 914, 3170, 843, 68
The needed networks can be found at https://tests.stockfishchess.org/nns
It is recommended to use the default one as indicated by the `EvalFile` UCI option.
Guidelines for testing new nets can be found at
https://github.com/glinscott/fishtest/wiki/Creating-my-first-test#nnue-net-tests
Integration has been discussed in various issues:
https://github.com/official-stockfish/Stockfish/issues/2823
https://github.com/official-stockfish/Stockfish/issues/2728
The integration branch will be closed after the merge:
https://github.com/official-stockfish/Stockfish/pull/2825
https://github.com/official-stockfish/Stockfish/tree/nnue-player-wip
closes https://github.com/official-stockfish/Stockfish/pull/2912
This will be an exciting time for computer chess, looking forward to seeing the evolution of
this approach.
Bench: 4746616
2020-08-05 09:11:15 -06:00
|
|
|
#include <cstdlib>
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2020-01-28 08:17:52 -07:00
|
|
|
#if defined(__linux__) && !defined(__ANDROID__)
|
2019-12-21 12:41:42 -07:00
|
|
|
#include <stdlib.h>
|
|
|
|
#include <sys/mman.h>
|
|
|
|
#endif
|
|
|
|
|
2020-08-11 13:02:48 -06:00
|
|
|
#if defined(__APPLE__) || defined(__ANDROID__) || defined(__OpenBSD__) || (defined(__GLIBCXX__) && !defined(_GLIBCXX_HAVE_ALIGNED_ALLOC) && !defined(_WIN32))
|
2020-08-10 08:14:17 -06:00
|
|
|
#define POSIXALIGNEDALLOC
|
|
|
|
#include <stdlib.h>
|
|
|
|
#endif
|
|
|
|
|
2008-08-31 23:59:13 -06:00
|
|
|
#include "misc.h"
|
2010-04-10 04:35:30 -06:00
|
|
|
#include "thread.h"
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2009-04-27 06:38:47 -06:00
|
|
|
using namespace std;
|
|
|
|
|
2014-11-01 14:35:10 -06:00
|
|
|
namespace {
|
|
|
|
|
2013-12-04 23:18:12 -07:00
|
|
|
/// Version number. If Version is left empty, then compile date in the format
|
|
|
|
/// DD-MM-YY and show in engine_info.
|
2020-01-23 09:17:26 -07:00
|
|
|
const string Version = "";
|
2011-01-09 07:57:18 -07:00
|
|
|
|
2012-03-20 07:40:09 -06:00
|
|
|
/// Our fancy logging facility. The trick here is to replace cin.rdbuf() and
|
2012-03-20 13:50:24 -06:00
|
|
|
/// cout.rdbuf() with two Tie objects that tie cin and cout to a file stream. We
|
2013-12-02 11:04:09 -07:00
|
|
|
/// can toggle the logging of std::cout and std:cin at runtime whilst preserving
|
2015-05-09 03:09:06 -06:00
|
|
|
/// usual I/O functionality, all without changing a single line of code!
|
2012-03-20 07:40:09 -06:00
|
|
|
/// Idea from http://groups.google.com/group/comp.lang.c++/msg/1d941c0f26ea0d81
|
2012-03-17 20:20:43 -06:00
|
|
|
|
2015-10-25 05:07:22 -06:00
|
|
|
struct Tie: public streambuf { // MSVC requires split streambuf for cin and cout
|
2012-03-17 20:20:43 -06:00
|
|
|
|
2015-05-09 03:09:06 -06:00
|
|
|
Tie(streambuf* b, streambuf* l) : buf(b), logBuf(l) {}
|
2012-03-17 20:20:43 -06:00
|
|
|
|
2017-08-13 06:33:25 -06:00
|
|
|
int sync() override { return logBuf->pubsync(), buf->pubsync(); }
|
|
|
|
int overflow(int c) override { return log(buf->sputc((char)c), "<< "); }
|
|
|
|
int underflow() override { return buf->sgetc(); }
|
|
|
|
int uflow() override { return log(buf->sbumpc(), ">> "); }
|
2012-03-20 13:50:24 -06:00
|
|
|
|
2015-05-09 03:09:06 -06:00
|
|
|
streambuf *buf, *logBuf;
|
2012-03-20 13:50:24 -06:00
|
|
|
|
2012-07-08 03:22:42 -06:00
|
|
|
int log(int c, const char* prefix) {
|
2012-03-20 13:50:24 -06:00
|
|
|
|
2015-05-09 03:09:06 -06:00
|
|
|
static int last = '\n'; // Single log file
|
2012-03-20 13:50:24 -06:00
|
|
|
|
2012-07-08 03:22:42 -06:00
|
|
|
if (last == '\n')
|
2015-05-09 03:09:06 -06:00
|
|
|
logBuf->sputn(prefix, 3);
|
2012-03-20 13:50:24 -06:00
|
|
|
|
2015-05-09 03:09:06 -06:00
|
|
|
return last = logBuf->sputc((char)c);
|
2012-07-08 03:22:42 -06:00
|
|
|
}
|
|
|
|
};
|
2012-03-20 13:50:24 -06:00
|
|
|
|
2012-07-08 03:22:42 -06:00
|
|
|
class Logger {
|
2012-03-20 13:50:24 -06:00
|
|
|
|
2015-05-09 03:09:06 -06:00
|
|
|
Logger() : in(cin.rdbuf(), file.rdbuf()), out(cout.rdbuf(), file.rdbuf()) {}
|
2016-06-12 17:12:24 -06:00
|
|
|
~Logger() { start(""); }
|
2012-03-20 13:50:24 -06:00
|
|
|
|
|
|
|
ofstream file;
|
|
|
|
Tie in, out;
|
|
|
|
|
2012-03-20 07:40:09 -06:00
|
|
|
public:
|
2016-06-12 17:12:24 -06:00
|
|
|
static void start(const std::string& fname) {
|
2012-03-17 20:20:43 -06:00
|
|
|
|
2012-03-20 07:40:09 -06:00
|
|
|
static Logger l;
|
2012-03-17 20:20:43 -06:00
|
|
|
|
2016-06-12 17:12:24 -06:00
|
|
|
if (!fname.empty() && !l.file.is_open())
|
2012-03-20 07:40:09 -06:00
|
|
|
{
|
2016-06-12 17:12:24 -06:00
|
|
|
l.file.open(fname, ifstream::out);
|
2019-10-21 00:05:14 -06:00
|
|
|
|
|
|
|
if (!l.file.is_open())
|
|
|
|
{
|
|
|
|
cerr << "Unable to open debug log file " << fname << endl;
|
|
|
|
exit(EXIT_FAILURE);
|
|
|
|
}
|
|
|
|
|
2012-03-20 13:50:24 -06:00
|
|
|
cin.rdbuf(&l.in);
|
|
|
|
cout.rdbuf(&l.out);
|
2012-03-20 07:40:09 -06:00
|
|
|
}
|
2016-06-12 17:12:24 -06:00
|
|
|
else if (fname.empty() && l.file.is_open())
|
2012-03-20 07:40:09 -06:00
|
|
|
{
|
2012-03-20 13:50:24 -06:00
|
|
|
cout.rdbuf(l.out.buf);
|
|
|
|
cin.rdbuf(l.in.buf);
|
2012-03-20 07:40:09 -06:00
|
|
|
l.file.close();
|
|
|
|
}
|
2012-03-17 20:20:43 -06:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2014-11-01 14:35:10 -06:00
|
|
|
} // namespace
|
|
|
|
|
Embed default net, and simplify using non-default nets
covers the most important cases from the user perspective:
It embeds the default net in the binary, so a download of that binary will result
in a working engine with the default net. The engine will be functional in the default mode
without any additional user action.
It allows non-default nets to be used, which will be looked for in up to
three directories (working directory, location of the binary, and optionally a specific default directory).
This mechanism is also kept for those developers that use MSVC,
the one compiler that doesn't have an easy mechanism for embedding data.
It is possible to disable embedding, and instead specify a specific directory, e.g. linux distros might want to use
CXXFLAGS="-DNNUE_EMBEDDING_OFF -DDEFAULT_NNUE_DIRECTORY=/usr/share/games/stockfish/" make -j ARCH=x86-64 profile-build
passed STC non-regression:
https://tests.stockfishchess.org/tests/view/5f4a581c150f0aef5f8ae03a
LLR: 2.95 (-2.94,2.94) {-1.25,-0.25}
Total: 66928 W: 7202 L: 7147 D: 52579
Ptnml(0-2): 291, 5309, 22211, 5360, 293
closes https://github.com/official-stockfish/Stockfish/pull/3070
fixes https://github.com/official-stockfish/Stockfish/issues/3030
No functional change.
2020-08-23 05:43:38 -06:00
|
|
|
|
2014-11-01 14:35:10 -06:00
|
|
|
/// engine_info() returns the full name of the current Stockfish version. This
|
|
|
|
/// will be either "Stockfish <Tag> DD-MM-YY" (where DD-MM-YY is the date when
|
|
|
|
/// the program was compiled) or "Stockfish <Version>", depending on whether
|
|
|
|
/// Version is empty.
|
|
|
|
|
|
|
|
const string engine_info(bool to_uci) {
|
|
|
|
|
|
|
|
const string months("Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec");
|
|
|
|
string month, day, year;
|
|
|
|
stringstream ss, date(__DATE__); // From compiler, format is "Sep 21 2008"
|
|
|
|
|
|
|
|
ss << "Stockfish " << Version << setfill('0');
|
|
|
|
|
|
|
|
if (Version.empty())
|
|
|
|
{
|
|
|
|
date >> month >> day >> year;
|
|
|
|
ss << setw(2) << day << setw(2) << (1 + months.find(month) / 4) << year.substr(2);
|
|
|
|
}
|
|
|
|
|
Add NNUE evaluation
This patch ports the efficiently updatable neural network (NNUE) evaluation to Stockfish.
Both the NNUE and the classical evaluations are available, and can be used to
assign a value to a position that is later used in alpha-beta (PVS) search to find the
best move. The classical evaluation computes this value as a function of various chess
concepts, handcrafted by experts, tested and tuned using fishtest. The NNUE evaluation
computes this value with a neural network based on basic inputs. The network is optimized
and trained on the evalutions of millions of positions at moderate search depth.
The NNUE evaluation was first introduced in shogi, and ported to Stockfish afterward.
It can be evaluated efficiently on CPUs, and exploits the fact that only parts
of the neural network need to be updated after a typical chess move.
[The nodchip repository](https://github.com/nodchip/Stockfish) provides additional
tools to train and develop the NNUE networks.
This patch is the result of contributions of various authors, from various communities,
including: nodchip, ynasu87, yaneurao (initial port and NNUE authors), domschl, FireFather,
rqs, xXH4CKST3RXx, tttak, zz4032, joergoster, mstembera, nguyenpham, erbsenzaehler,
dorzechowski, and vondele.
This new evaluation needed various changes to fishtest and the corresponding infrastructure,
for which tomtor, ppigazzini, noobpwnftw, daylen, and vondele are gratefully acknowledged.
The first networks have been provided by gekkehenker and sergiovieri, with the latter
net (nn-97f742aaefcd.nnue) being the current default.
The evaluation function can be selected at run time with the `Use NNUE` (true/false) UCI option,
provided the `EvalFile` option points the the network file (depending on the GUI, with full path).
The performance of the NNUE evaluation relative to the classical evaluation depends somewhat on
the hardware, and is expected to improve quickly, but is currently on > 80 Elo on fishtest:
60000 @ 10+0.1 th 1
https://tests.stockfishchess.org/tests/view/5f28fe6ea5abc164f05e4c4c
ELO: 92.77 +-2.1 (95%) LOS: 100.0%
Total: 60000 W: 24193 L: 8543 D: 27264
Ptnml(0-2): 609, 3850, 9708, 10948, 4885
40000 @ 20+0.2 th 8
https://tests.stockfishchess.org/tests/view/5f290229a5abc164f05e4c58
ELO: 89.47 +-2.0 (95%) LOS: 100.0%
Total: 40000 W: 12756 L: 2677 D: 24567
Ptnml(0-2): 74, 1583, 8550, 7776, 2017
At the same time, the impact on the classical evaluation remains minimal, causing no significant
regression:
sprt @ 10+0.1 th 1
https://tests.stockfishchess.org/tests/view/5f2906a2a5abc164f05e4c5b
LLR: 2.94 (-2.94,2.94) {-6.00,-4.00}
Total: 34936 W: 6502 L: 6825 D: 21609
Ptnml(0-2): 571, 4082, 8434, 3861, 520
sprt @ 60+0.6 th 1
https://tests.stockfishchess.org/tests/view/5f2906cfa5abc164f05e4c5d
LLR: 2.93 (-2.94,2.94) {-6.00,-4.00}
Total: 10088 W: 1232 L: 1265 D: 7591
Ptnml(0-2): 49, 914, 3170, 843, 68
The needed networks can be found at https://tests.stockfishchess.org/nns
It is recommended to use the default one as indicated by the `EvalFile` UCI option.
Guidelines for testing new nets can be found at
https://github.com/glinscott/fishtest/wiki/Creating-my-first-test#nnue-net-tests
Integration has been discussed in various issues:
https://github.com/official-stockfish/Stockfish/issues/2823
https://github.com/official-stockfish/Stockfish/issues/2728
The integration branch will be closed after the merge:
https://github.com/official-stockfish/Stockfish/pull/2825
https://github.com/official-stockfish/Stockfish/tree/nnue-player-wip
closes https://github.com/official-stockfish/Stockfish/pull/2912
This will be an exciting time for computer chess, looking forward to seeing the evolution of
this approach.
Bench: 4746616
2020-08-05 09:11:15 -06:00
|
|
|
ss << (to_uci ? "\nid author ": " by ")
|
|
|
|
<< "the Stockfish developers (see AUTHORS file)";
|
2014-11-01 14:35:10 -06:00
|
|
|
|
|
|
|
return ss.str();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-09-24 11:00:27 -06:00
|
|
|
/// compiler_info() returns a string trying to describe the compiler we use
|
|
|
|
|
|
|
|
const std::string compiler_info() {
|
|
|
|
|
2020-01-21 09:20:00 -07:00
|
|
|
#define stringify2(x) #x
|
|
|
|
#define stringify(x) stringify2(x)
|
|
|
|
#define make_version_string(major, minor, patch) stringify(major) "." stringify(minor) "." stringify(patch)
|
2019-09-24 11:00:27 -06:00
|
|
|
|
|
|
|
/// Predefined macros hell:
|
|
|
|
///
|
|
|
|
/// __GNUC__ Compiler is gcc, Clang or Intel on Linux
|
|
|
|
/// __INTEL_COMPILER Compiler is Intel
|
|
|
|
/// _MSC_VER Compiler is MSVC or Intel on Windows
|
|
|
|
/// _WIN32 Building on Windows (any)
|
|
|
|
/// _WIN64 Building on Windows 64 bit
|
|
|
|
|
|
|
|
std::string compiler = "\nCompiled by ";
|
|
|
|
|
|
|
|
#ifdef __clang__
|
|
|
|
compiler += "clang++ ";
|
2020-01-21 09:20:00 -07:00
|
|
|
compiler += make_version_string(__clang_major__, __clang_minor__, __clang_patchlevel__);
|
2019-09-24 11:00:27 -06:00
|
|
|
#elif __INTEL_COMPILER
|
|
|
|
compiler += "Intel compiler ";
|
|
|
|
compiler += "(version ";
|
2020-01-21 09:20:00 -07:00
|
|
|
compiler += stringify(__INTEL_COMPILER) " update " stringify(__INTEL_COMPILER_UPDATE);
|
2019-09-24 11:00:27 -06:00
|
|
|
compiler += ")";
|
|
|
|
#elif _MSC_VER
|
|
|
|
compiler += "MSVC ";
|
|
|
|
compiler += "(version ";
|
2020-01-21 09:20:00 -07:00
|
|
|
compiler += stringify(_MSC_FULL_VER) "." stringify(_MSC_BUILD);
|
2019-09-24 11:00:27 -06:00
|
|
|
compiler += ")";
|
|
|
|
#elif __GNUC__
|
|
|
|
compiler += "g++ (GNUC) ";
|
2020-01-21 09:20:00 -07:00
|
|
|
compiler += make_version_string(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__);
|
2019-09-24 11:00:27 -06:00
|
|
|
#else
|
|
|
|
compiler += "Unknown compiler ";
|
|
|
|
compiler += "(unknown version)";
|
|
|
|
#endif
|
|
|
|
|
2019-12-21 12:41:42 -07:00
|
|
|
#if defined(__APPLE__)
|
2019-09-24 11:00:27 -06:00
|
|
|
compiler += " on Apple";
|
|
|
|
#elif defined(__CYGWIN__)
|
|
|
|
compiler += " on Cygwin";
|
|
|
|
#elif defined(__MINGW64__)
|
|
|
|
compiler += " on MinGW64";
|
|
|
|
#elif defined(__MINGW32__)
|
|
|
|
compiler += " on MinGW32";
|
|
|
|
#elif defined(__ANDROID__)
|
|
|
|
compiler += " on Android";
|
|
|
|
#elif defined(__linux__)
|
|
|
|
compiler += " on Linux";
|
|
|
|
#elif defined(_WIN64)
|
|
|
|
compiler += " on Microsoft Windows 64-bit";
|
|
|
|
#elif defined(_WIN32)
|
|
|
|
compiler += " on Microsoft Windows 32-bit";
|
|
|
|
#else
|
|
|
|
compiler += " on unknown system";
|
|
|
|
#endif
|
|
|
|
|
Add NNUE evaluation
This patch ports the efficiently updatable neural network (NNUE) evaluation to Stockfish.
Both the NNUE and the classical evaluations are available, and can be used to
assign a value to a position that is later used in alpha-beta (PVS) search to find the
best move. The classical evaluation computes this value as a function of various chess
concepts, handcrafted by experts, tested and tuned using fishtest. The NNUE evaluation
computes this value with a neural network based on basic inputs. The network is optimized
and trained on the evalutions of millions of positions at moderate search depth.
The NNUE evaluation was first introduced in shogi, and ported to Stockfish afterward.
It can be evaluated efficiently on CPUs, and exploits the fact that only parts
of the neural network need to be updated after a typical chess move.
[The nodchip repository](https://github.com/nodchip/Stockfish) provides additional
tools to train and develop the NNUE networks.
This patch is the result of contributions of various authors, from various communities,
including: nodchip, ynasu87, yaneurao (initial port and NNUE authors), domschl, FireFather,
rqs, xXH4CKST3RXx, tttak, zz4032, joergoster, mstembera, nguyenpham, erbsenzaehler,
dorzechowski, and vondele.
This new evaluation needed various changes to fishtest and the corresponding infrastructure,
for which tomtor, ppigazzini, noobpwnftw, daylen, and vondele are gratefully acknowledged.
The first networks have been provided by gekkehenker and sergiovieri, with the latter
net (nn-97f742aaefcd.nnue) being the current default.
The evaluation function can be selected at run time with the `Use NNUE` (true/false) UCI option,
provided the `EvalFile` option points the the network file (depending on the GUI, with full path).
The performance of the NNUE evaluation relative to the classical evaluation depends somewhat on
the hardware, and is expected to improve quickly, but is currently on > 80 Elo on fishtest:
60000 @ 10+0.1 th 1
https://tests.stockfishchess.org/tests/view/5f28fe6ea5abc164f05e4c4c
ELO: 92.77 +-2.1 (95%) LOS: 100.0%
Total: 60000 W: 24193 L: 8543 D: 27264
Ptnml(0-2): 609, 3850, 9708, 10948, 4885
40000 @ 20+0.2 th 8
https://tests.stockfishchess.org/tests/view/5f290229a5abc164f05e4c58
ELO: 89.47 +-2.0 (95%) LOS: 100.0%
Total: 40000 W: 12756 L: 2677 D: 24567
Ptnml(0-2): 74, 1583, 8550, 7776, 2017
At the same time, the impact on the classical evaluation remains minimal, causing no significant
regression:
sprt @ 10+0.1 th 1
https://tests.stockfishchess.org/tests/view/5f2906a2a5abc164f05e4c5b
LLR: 2.94 (-2.94,2.94) {-6.00,-4.00}
Total: 34936 W: 6502 L: 6825 D: 21609
Ptnml(0-2): 571, 4082, 8434, 3861, 520
sprt @ 60+0.6 th 1
https://tests.stockfishchess.org/tests/view/5f2906cfa5abc164f05e4c5d
LLR: 2.93 (-2.94,2.94) {-6.00,-4.00}
Total: 10088 W: 1232 L: 1265 D: 7591
Ptnml(0-2): 49, 914, 3170, 843, 68
The needed networks can be found at https://tests.stockfishchess.org/nns
It is recommended to use the default one as indicated by the `EvalFile` UCI option.
Guidelines for testing new nets can be found at
https://github.com/glinscott/fishtest/wiki/Creating-my-first-test#nnue-net-tests
Integration has been discussed in various issues:
https://github.com/official-stockfish/Stockfish/issues/2823
https://github.com/official-stockfish/Stockfish/issues/2728
The integration branch will be closed after the merge:
https://github.com/official-stockfish/Stockfish/pull/2825
https://github.com/official-stockfish/Stockfish/tree/nnue-player-wip
closes https://github.com/official-stockfish/Stockfish/pull/2912
This will be an exciting time for computer chess, looking forward to seeing the evolution of
this approach.
Bench: 4746616
2020-08-05 09:11:15 -06:00
|
|
|
compiler += "\nCompilation settings include: ";
|
|
|
|
compiler += (Is64Bit ? " 64bit" : " 32bit");
|
2020-08-11 13:59:39 -06:00
|
|
|
#if defined(USE_VNNI)
|
|
|
|
compiler += " VNNI";
|
|
|
|
#endif
|
Add NNUE evaluation
This patch ports the efficiently updatable neural network (NNUE) evaluation to Stockfish.
Both the NNUE and the classical evaluations are available, and can be used to
assign a value to a position that is later used in alpha-beta (PVS) search to find the
best move. The classical evaluation computes this value as a function of various chess
concepts, handcrafted by experts, tested and tuned using fishtest. The NNUE evaluation
computes this value with a neural network based on basic inputs. The network is optimized
and trained on the evalutions of millions of positions at moderate search depth.
The NNUE evaluation was first introduced in shogi, and ported to Stockfish afterward.
It can be evaluated efficiently on CPUs, and exploits the fact that only parts
of the neural network need to be updated after a typical chess move.
[The nodchip repository](https://github.com/nodchip/Stockfish) provides additional
tools to train and develop the NNUE networks.
This patch is the result of contributions of various authors, from various communities,
including: nodchip, ynasu87, yaneurao (initial port and NNUE authors), domschl, FireFather,
rqs, xXH4CKST3RXx, tttak, zz4032, joergoster, mstembera, nguyenpham, erbsenzaehler,
dorzechowski, and vondele.
This new evaluation needed various changes to fishtest and the corresponding infrastructure,
for which tomtor, ppigazzini, noobpwnftw, daylen, and vondele are gratefully acknowledged.
The first networks have been provided by gekkehenker and sergiovieri, with the latter
net (nn-97f742aaefcd.nnue) being the current default.
The evaluation function can be selected at run time with the `Use NNUE` (true/false) UCI option,
provided the `EvalFile` option points the the network file (depending on the GUI, with full path).
The performance of the NNUE evaluation relative to the classical evaluation depends somewhat on
the hardware, and is expected to improve quickly, but is currently on > 80 Elo on fishtest:
60000 @ 10+0.1 th 1
https://tests.stockfishchess.org/tests/view/5f28fe6ea5abc164f05e4c4c
ELO: 92.77 +-2.1 (95%) LOS: 100.0%
Total: 60000 W: 24193 L: 8543 D: 27264
Ptnml(0-2): 609, 3850, 9708, 10948, 4885
40000 @ 20+0.2 th 8
https://tests.stockfishchess.org/tests/view/5f290229a5abc164f05e4c58
ELO: 89.47 +-2.0 (95%) LOS: 100.0%
Total: 40000 W: 12756 L: 2677 D: 24567
Ptnml(0-2): 74, 1583, 8550, 7776, 2017
At the same time, the impact on the classical evaluation remains minimal, causing no significant
regression:
sprt @ 10+0.1 th 1
https://tests.stockfishchess.org/tests/view/5f2906a2a5abc164f05e4c5b
LLR: 2.94 (-2.94,2.94) {-6.00,-4.00}
Total: 34936 W: 6502 L: 6825 D: 21609
Ptnml(0-2): 571, 4082, 8434, 3861, 520
sprt @ 60+0.6 th 1
https://tests.stockfishchess.org/tests/view/5f2906cfa5abc164f05e4c5d
LLR: 2.93 (-2.94,2.94) {-6.00,-4.00}
Total: 10088 W: 1232 L: 1265 D: 7591
Ptnml(0-2): 49, 914, 3170, 843, 68
The needed networks can be found at https://tests.stockfishchess.org/nns
It is recommended to use the default one as indicated by the `EvalFile` UCI option.
Guidelines for testing new nets can be found at
https://github.com/glinscott/fishtest/wiki/Creating-my-first-test#nnue-net-tests
Integration has been discussed in various issues:
https://github.com/official-stockfish/Stockfish/issues/2823
https://github.com/official-stockfish/Stockfish/issues/2728
The integration branch will be closed after the merge:
https://github.com/official-stockfish/Stockfish/pull/2825
https://github.com/official-stockfish/Stockfish/tree/nnue-player-wip
closes https://github.com/official-stockfish/Stockfish/pull/2912
This will be an exciting time for computer chess, looking forward to seeing the evolution of
this approach.
Bench: 4746616
2020-08-05 09:11:15 -06:00
|
|
|
#if defined(USE_AVX512)
|
|
|
|
compiler += " AVX512";
|
|
|
|
#endif
|
2020-08-12 09:21:12 -06:00
|
|
|
compiler += (HasPext ? " BMI2" : "");
|
Add NNUE evaluation
This patch ports the efficiently updatable neural network (NNUE) evaluation to Stockfish.
Both the NNUE and the classical evaluations are available, and can be used to
assign a value to a position that is later used in alpha-beta (PVS) search to find the
best move. The classical evaluation computes this value as a function of various chess
concepts, handcrafted by experts, tested and tuned using fishtest. The NNUE evaluation
computes this value with a neural network based on basic inputs. The network is optimized
and trained on the evalutions of millions of positions at moderate search depth.
The NNUE evaluation was first introduced in shogi, and ported to Stockfish afterward.
It can be evaluated efficiently on CPUs, and exploits the fact that only parts
of the neural network need to be updated after a typical chess move.
[The nodchip repository](https://github.com/nodchip/Stockfish) provides additional
tools to train and develop the NNUE networks.
This patch is the result of contributions of various authors, from various communities,
including: nodchip, ynasu87, yaneurao (initial port and NNUE authors), domschl, FireFather,
rqs, xXH4CKST3RXx, tttak, zz4032, joergoster, mstembera, nguyenpham, erbsenzaehler,
dorzechowski, and vondele.
This new evaluation needed various changes to fishtest and the corresponding infrastructure,
for which tomtor, ppigazzini, noobpwnftw, daylen, and vondele are gratefully acknowledged.
The first networks have been provided by gekkehenker and sergiovieri, with the latter
net (nn-97f742aaefcd.nnue) being the current default.
The evaluation function can be selected at run time with the `Use NNUE` (true/false) UCI option,
provided the `EvalFile` option points the the network file (depending on the GUI, with full path).
The performance of the NNUE evaluation relative to the classical evaluation depends somewhat on
the hardware, and is expected to improve quickly, but is currently on > 80 Elo on fishtest:
60000 @ 10+0.1 th 1
https://tests.stockfishchess.org/tests/view/5f28fe6ea5abc164f05e4c4c
ELO: 92.77 +-2.1 (95%) LOS: 100.0%
Total: 60000 W: 24193 L: 8543 D: 27264
Ptnml(0-2): 609, 3850, 9708, 10948, 4885
40000 @ 20+0.2 th 8
https://tests.stockfishchess.org/tests/view/5f290229a5abc164f05e4c58
ELO: 89.47 +-2.0 (95%) LOS: 100.0%
Total: 40000 W: 12756 L: 2677 D: 24567
Ptnml(0-2): 74, 1583, 8550, 7776, 2017
At the same time, the impact on the classical evaluation remains minimal, causing no significant
regression:
sprt @ 10+0.1 th 1
https://tests.stockfishchess.org/tests/view/5f2906a2a5abc164f05e4c5b
LLR: 2.94 (-2.94,2.94) {-6.00,-4.00}
Total: 34936 W: 6502 L: 6825 D: 21609
Ptnml(0-2): 571, 4082, 8434, 3861, 520
sprt @ 60+0.6 th 1
https://tests.stockfishchess.org/tests/view/5f2906cfa5abc164f05e4c5d
LLR: 2.93 (-2.94,2.94) {-6.00,-4.00}
Total: 10088 W: 1232 L: 1265 D: 7591
Ptnml(0-2): 49, 914, 3170, 843, 68
The needed networks can be found at https://tests.stockfishchess.org/nns
It is recommended to use the default one as indicated by the `EvalFile` UCI option.
Guidelines for testing new nets can be found at
https://github.com/glinscott/fishtest/wiki/Creating-my-first-test#nnue-net-tests
Integration has been discussed in various issues:
https://github.com/official-stockfish/Stockfish/issues/2823
https://github.com/official-stockfish/Stockfish/issues/2728
The integration branch will be closed after the merge:
https://github.com/official-stockfish/Stockfish/pull/2825
https://github.com/official-stockfish/Stockfish/tree/nnue-player-wip
closes https://github.com/official-stockfish/Stockfish/pull/2912
This will be an exciting time for computer chess, looking forward to seeing the evolution of
this approach.
Bench: 4746616
2020-08-05 09:11:15 -06:00
|
|
|
#if defined(USE_AVX2)
|
|
|
|
compiler += " AVX2";
|
|
|
|
#endif
|
|
|
|
#if defined(USE_SSE41)
|
|
|
|
compiler += " SSE41";
|
|
|
|
#endif
|
|
|
|
#if defined(USE_SSSE3)
|
|
|
|
compiler += " SSSE3";
|
|
|
|
#endif
|
2020-08-12 09:21:12 -06:00
|
|
|
#if defined(USE_SSE2)
|
|
|
|
compiler += " SSE2";
|
|
|
|
#endif
|
|
|
|
compiler += (HasPopCnt ? " POPCNT" : "");
|
2020-08-09 08:20:45 -06:00
|
|
|
#if defined(USE_MMX)
|
|
|
|
compiler += " MMX";
|
|
|
|
#endif
|
2020-08-14 20:53:46 -06:00
|
|
|
#if defined(USE_NEON)
|
|
|
|
compiler += " NEON";
|
|
|
|
#endif
|
2020-08-12 09:21:12 -06:00
|
|
|
|
Add NNUE evaluation
This patch ports the efficiently updatable neural network (NNUE) evaluation to Stockfish.
Both the NNUE and the classical evaluations are available, and can be used to
assign a value to a position that is later used in alpha-beta (PVS) search to find the
best move. The classical evaluation computes this value as a function of various chess
concepts, handcrafted by experts, tested and tuned using fishtest. The NNUE evaluation
computes this value with a neural network based on basic inputs. The network is optimized
and trained on the evalutions of millions of positions at moderate search depth.
The NNUE evaluation was first introduced in shogi, and ported to Stockfish afterward.
It can be evaluated efficiently on CPUs, and exploits the fact that only parts
of the neural network need to be updated after a typical chess move.
[The nodchip repository](https://github.com/nodchip/Stockfish) provides additional
tools to train and develop the NNUE networks.
This patch is the result of contributions of various authors, from various communities,
including: nodchip, ynasu87, yaneurao (initial port and NNUE authors), domschl, FireFather,
rqs, xXH4CKST3RXx, tttak, zz4032, joergoster, mstembera, nguyenpham, erbsenzaehler,
dorzechowski, and vondele.
This new evaluation needed various changes to fishtest and the corresponding infrastructure,
for which tomtor, ppigazzini, noobpwnftw, daylen, and vondele are gratefully acknowledged.
The first networks have been provided by gekkehenker and sergiovieri, with the latter
net (nn-97f742aaefcd.nnue) being the current default.
The evaluation function can be selected at run time with the `Use NNUE` (true/false) UCI option,
provided the `EvalFile` option points the the network file (depending on the GUI, with full path).
The performance of the NNUE evaluation relative to the classical evaluation depends somewhat on
the hardware, and is expected to improve quickly, but is currently on > 80 Elo on fishtest:
60000 @ 10+0.1 th 1
https://tests.stockfishchess.org/tests/view/5f28fe6ea5abc164f05e4c4c
ELO: 92.77 +-2.1 (95%) LOS: 100.0%
Total: 60000 W: 24193 L: 8543 D: 27264
Ptnml(0-2): 609, 3850, 9708, 10948, 4885
40000 @ 20+0.2 th 8
https://tests.stockfishchess.org/tests/view/5f290229a5abc164f05e4c58
ELO: 89.47 +-2.0 (95%) LOS: 100.0%
Total: 40000 W: 12756 L: 2677 D: 24567
Ptnml(0-2): 74, 1583, 8550, 7776, 2017
At the same time, the impact on the classical evaluation remains minimal, causing no significant
regression:
sprt @ 10+0.1 th 1
https://tests.stockfishchess.org/tests/view/5f2906a2a5abc164f05e4c5b
LLR: 2.94 (-2.94,2.94) {-6.00,-4.00}
Total: 34936 W: 6502 L: 6825 D: 21609
Ptnml(0-2): 571, 4082, 8434, 3861, 520
sprt @ 60+0.6 th 1
https://tests.stockfishchess.org/tests/view/5f2906cfa5abc164f05e4c5d
LLR: 2.93 (-2.94,2.94) {-6.00,-4.00}
Total: 10088 W: 1232 L: 1265 D: 7591
Ptnml(0-2): 49, 914, 3170, 843, 68
The needed networks can be found at https://tests.stockfishchess.org/nns
It is recommended to use the default one as indicated by the `EvalFile` UCI option.
Guidelines for testing new nets can be found at
https://github.com/glinscott/fishtest/wiki/Creating-my-first-test#nnue-net-tests
Integration has been discussed in various issues:
https://github.com/official-stockfish/Stockfish/issues/2823
https://github.com/official-stockfish/Stockfish/issues/2728
The integration branch will be closed after the merge:
https://github.com/official-stockfish/Stockfish/pull/2825
https://github.com/official-stockfish/Stockfish/tree/nnue-player-wip
closes https://github.com/official-stockfish/Stockfish/pull/2912
This will be an exciting time for computer chess, looking forward to seeing the evolution of
this approach.
Bench: 4746616
2020-08-05 09:11:15 -06:00
|
|
|
#if !defined(NDEBUG)
|
|
|
|
compiler += " DEBUG";
|
|
|
|
#endif
|
|
|
|
|
|
|
|
compiler += "\n__VERSION__ macro expands to: ";
|
2019-09-24 11:00:27 -06:00
|
|
|
#ifdef __VERSION__
|
|
|
|
compiler += __VERSION__;
|
|
|
|
#else
|
|
|
|
compiler += "(undefined macro)";
|
|
|
|
#endif
|
|
|
|
compiler += "\n";
|
|
|
|
|
|
|
|
return compiler;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2014-11-01 14:35:10 -06:00
|
|
|
/// Debug functions used mainly to collect run-time statistics
|
2019-06-21 08:24:28 -06:00
|
|
|
static std::atomic<int64_t> hits[2], means[2];
|
2014-11-01 14:35:10 -06:00
|
|
|
|
|
|
|
void dbg_hit_on(bool b) { ++hits[0]; if (b) ++hits[1]; }
|
2015-02-07 03:15:38 -07:00
|
|
|
void dbg_hit_on(bool c, bool b) { if (c) dbg_hit_on(b); }
|
2014-11-01 14:35:10 -06:00
|
|
|
void dbg_mean_of(int v) { ++means[0]; means[1] += v; }
|
|
|
|
|
|
|
|
void dbg_print() {
|
|
|
|
|
|
|
|
if (hits[0])
|
|
|
|
cerr << "Total " << hits[0] << " Hits " << hits[1]
|
|
|
|
<< " hit rate (%) " << 100 * hits[1] / hits[0] << endl;
|
|
|
|
|
|
|
|
if (means[0])
|
|
|
|
cerr << "Total " << means[0] << " Mean "
|
|
|
|
<< (double)means[1] / means[0] << endl;
|
|
|
|
}
|
|
|
|
|
2012-03-17 20:20:43 -06:00
|
|
|
|
2013-12-02 11:04:09 -07:00
|
|
|
/// Used to serialize access to std::cout to avoid multiple threads writing at
|
2012-08-29 03:25:11 -06:00
|
|
|
/// the same time.
|
|
|
|
|
|
|
|
std::ostream& operator<<(std::ostream& os, SyncCout sc) {
|
|
|
|
|
2019-09-15 23:51:25 -06:00
|
|
|
static std::mutex m;
|
2012-08-29 03:25:11 -06:00
|
|
|
|
2014-02-09 09:31:45 -07:00
|
|
|
if (sc == IO_LOCK)
|
2012-08-29 03:25:11 -06:00
|
|
|
m.lock();
|
|
|
|
|
2014-02-09 09:31:45 -07:00
|
|
|
if (sc == IO_UNLOCK)
|
2012-08-29 03:25:11 -06:00
|
|
|
m.unlock();
|
|
|
|
|
|
|
|
return os;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-03-20 13:50:24 -06:00
|
|
|
/// Trampoline helper to avoid moving Logger to misc.h
|
2016-06-12 17:12:24 -06:00
|
|
|
void start_logger(const std::string& fname) { Logger::start(fname); }
|
2012-03-17 20:20:43 -06:00
|
|
|
|
|
|
|
|
2013-12-02 11:04:09 -07:00
|
|
|
/// prefetch() preloads the given address in L1/L2 cache. This is a non-blocking
|
|
|
|
/// function that doesn't stall the CPU waiting for data to be loaded from memory,
|
|
|
|
/// which can be quite slow.
|
2013-07-23 07:31:57 -06:00
|
|
|
#ifdef NO_PREFETCH
|
2011-04-13 07:12:33 -06:00
|
|
|
|
2015-02-07 11:13:41 -07:00
|
|
|
void prefetch(void*) {}
|
2011-04-13 07:12:33 -06:00
|
|
|
|
2010-06-19 04:10:54 -06:00
|
|
|
#else
|
|
|
|
|
2015-02-07 11:13:41 -07:00
|
|
|
void prefetch(void* addr) {
|
2010-06-19 04:10:54 -06:00
|
|
|
|
2012-10-08 03:19:50 -06:00
|
|
|
# if defined(__INTEL_COMPILER)
|
2013-12-02 11:04:09 -07:00
|
|
|
// This hack prevents prefetches from being optimized away by
|
|
|
|
// Intel compiler. Both MSVC and gcc seem not be affected by this.
|
2010-06-19 04:10:54 -06:00
|
|
|
__asm__ ("");
|
2011-12-30 09:08:07 -07:00
|
|
|
# endif
|
2010-06-19 04:10:54 -06:00
|
|
|
|
2012-10-08 03:19:50 -06:00
|
|
|
# if defined(__INTEL_COMPILER) || defined(_MSC_VER)
|
2015-02-07 11:13:41 -07:00
|
|
|
_mm_prefetch((char*)addr, _MM_HINT_T0);
|
2012-10-05 14:30:22 -06:00
|
|
|
# else
|
|
|
|
__builtin_prefetch(addr);
|
|
|
|
# endif
|
2010-06-19 04:10:54 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
2016-11-21 23:41:46 -07:00
|
|
|
|
2020-07-11 08:59:33 -06:00
|
|
|
|
|
|
|
/// std_aligned_alloc() is our wrapper for systems where the c++17 implementation
|
|
|
|
/// does not guarantee the availability of aligned_alloc(). Memory allocated with
|
|
|
|
/// std_aligned_alloc() must be freed with std_aligned_free().
|
Add NNUE evaluation
This patch ports the efficiently updatable neural network (NNUE) evaluation to Stockfish.
Both the NNUE and the classical evaluations are available, and can be used to
assign a value to a position that is later used in alpha-beta (PVS) search to find the
best move. The classical evaluation computes this value as a function of various chess
concepts, handcrafted by experts, tested and tuned using fishtest. The NNUE evaluation
computes this value with a neural network based on basic inputs. The network is optimized
and trained on the evalutions of millions of positions at moderate search depth.
The NNUE evaluation was first introduced in shogi, and ported to Stockfish afterward.
It can be evaluated efficiently on CPUs, and exploits the fact that only parts
of the neural network need to be updated after a typical chess move.
[The nodchip repository](https://github.com/nodchip/Stockfish) provides additional
tools to train and develop the NNUE networks.
This patch is the result of contributions of various authors, from various communities,
including: nodchip, ynasu87, yaneurao (initial port and NNUE authors), domschl, FireFather,
rqs, xXH4CKST3RXx, tttak, zz4032, joergoster, mstembera, nguyenpham, erbsenzaehler,
dorzechowski, and vondele.
This new evaluation needed various changes to fishtest and the corresponding infrastructure,
for which tomtor, ppigazzini, noobpwnftw, daylen, and vondele are gratefully acknowledged.
The first networks have been provided by gekkehenker and sergiovieri, with the latter
net (nn-97f742aaefcd.nnue) being the current default.
The evaluation function can be selected at run time with the `Use NNUE` (true/false) UCI option,
provided the `EvalFile` option points the the network file (depending on the GUI, with full path).
The performance of the NNUE evaluation relative to the classical evaluation depends somewhat on
the hardware, and is expected to improve quickly, but is currently on > 80 Elo on fishtest:
60000 @ 10+0.1 th 1
https://tests.stockfishchess.org/tests/view/5f28fe6ea5abc164f05e4c4c
ELO: 92.77 +-2.1 (95%) LOS: 100.0%
Total: 60000 W: 24193 L: 8543 D: 27264
Ptnml(0-2): 609, 3850, 9708, 10948, 4885
40000 @ 20+0.2 th 8
https://tests.stockfishchess.org/tests/view/5f290229a5abc164f05e4c58
ELO: 89.47 +-2.0 (95%) LOS: 100.0%
Total: 40000 W: 12756 L: 2677 D: 24567
Ptnml(0-2): 74, 1583, 8550, 7776, 2017
At the same time, the impact on the classical evaluation remains minimal, causing no significant
regression:
sprt @ 10+0.1 th 1
https://tests.stockfishchess.org/tests/view/5f2906a2a5abc164f05e4c5b
LLR: 2.94 (-2.94,2.94) {-6.00,-4.00}
Total: 34936 W: 6502 L: 6825 D: 21609
Ptnml(0-2): 571, 4082, 8434, 3861, 520
sprt @ 60+0.6 th 1
https://tests.stockfishchess.org/tests/view/5f2906cfa5abc164f05e4c5d
LLR: 2.93 (-2.94,2.94) {-6.00,-4.00}
Total: 10088 W: 1232 L: 1265 D: 7591
Ptnml(0-2): 49, 914, 3170, 843, 68
The needed networks can be found at https://tests.stockfishchess.org/nns
It is recommended to use the default one as indicated by the `EvalFile` UCI option.
Guidelines for testing new nets can be found at
https://github.com/glinscott/fishtest/wiki/Creating-my-first-test#nnue-net-tests
Integration has been discussed in various issues:
https://github.com/official-stockfish/Stockfish/issues/2823
https://github.com/official-stockfish/Stockfish/issues/2728
The integration branch will be closed after the merge:
https://github.com/official-stockfish/Stockfish/pull/2825
https://github.com/official-stockfish/Stockfish/tree/nnue-player-wip
closes https://github.com/official-stockfish/Stockfish/pull/2912
This will be an exciting time for computer chess, looking forward to seeing the evolution of
this approach.
Bench: 4746616
2020-08-05 09:11:15 -06:00
|
|
|
|
|
|
|
void* std_aligned_alloc(size_t alignment, size_t size) {
|
2020-07-11 08:59:33 -06:00
|
|
|
|
2020-08-10 08:14:17 -06:00
|
|
|
#if defined(POSIXALIGNEDALLOC)
|
2020-07-11 08:59:33 -06:00
|
|
|
void *mem;
|
|
|
|
return posix_memalign(&mem, alignment, size) ? nullptr : mem;
|
2020-08-11 13:02:48 -06:00
|
|
|
#elif defined(_WIN32)
|
Add NNUE evaluation
This patch ports the efficiently updatable neural network (NNUE) evaluation to Stockfish.
Both the NNUE and the classical evaluations are available, and can be used to
assign a value to a position that is later used in alpha-beta (PVS) search to find the
best move. The classical evaluation computes this value as a function of various chess
concepts, handcrafted by experts, tested and tuned using fishtest. The NNUE evaluation
computes this value with a neural network based on basic inputs. The network is optimized
and trained on the evalutions of millions of positions at moderate search depth.
The NNUE evaluation was first introduced in shogi, and ported to Stockfish afterward.
It can be evaluated efficiently on CPUs, and exploits the fact that only parts
of the neural network need to be updated after a typical chess move.
[The nodchip repository](https://github.com/nodchip/Stockfish) provides additional
tools to train and develop the NNUE networks.
This patch is the result of contributions of various authors, from various communities,
including: nodchip, ynasu87, yaneurao (initial port and NNUE authors), domschl, FireFather,
rqs, xXH4CKST3RXx, tttak, zz4032, joergoster, mstembera, nguyenpham, erbsenzaehler,
dorzechowski, and vondele.
This new evaluation needed various changes to fishtest and the corresponding infrastructure,
for which tomtor, ppigazzini, noobpwnftw, daylen, and vondele are gratefully acknowledged.
The first networks have been provided by gekkehenker and sergiovieri, with the latter
net (nn-97f742aaefcd.nnue) being the current default.
The evaluation function can be selected at run time with the `Use NNUE` (true/false) UCI option,
provided the `EvalFile` option points the the network file (depending on the GUI, with full path).
The performance of the NNUE evaluation relative to the classical evaluation depends somewhat on
the hardware, and is expected to improve quickly, but is currently on > 80 Elo on fishtest:
60000 @ 10+0.1 th 1
https://tests.stockfishchess.org/tests/view/5f28fe6ea5abc164f05e4c4c
ELO: 92.77 +-2.1 (95%) LOS: 100.0%
Total: 60000 W: 24193 L: 8543 D: 27264
Ptnml(0-2): 609, 3850, 9708, 10948, 4885
40000 @ 20+0.2 th 8
https://tests.stockfishchess.org/tests/view/5f290229a5abc164f05e4c58
ELO: 89.47 +-2.0 (95%) LOS: 100.0%
Total: 40000 W: 12756 L: 2677 D: 24567
Ptnml(0-2): 74, 1583, 8550, 7776, 2017
At the same time, the impact on the classical evaluation remains minimal, causing no significant
regression:
sprt @ 10+0.1 th 1
https://tests.stockfishchess.org/tests/view/5f2906a2a5abc164f05e4c5b
LLR: 2.94 (-2.94,2.94) {-6.00,-4.00}
Total: 34936 W: 6502 L: 6825 D: 21609
Ptnml(0-2): 571, 4082, 8434, 3861, 520
sprt @ 60+0.6 th 1
https://tests.stockfishchess.org/tests/view/5f2906cfa5abc164f05e4c5d
LLR: 2.93 (-2.94,2.94) {-6.00,-4.00}
Total: 10088 W: 1232 L: 1265 D: 7591
Ptnml(0-2): 49, 914, 3170, 843, 68
The needed networks can be found at https://tests.stockfishchess.org/nns
It is recommended to use the default one as indicated by the `EvalFile` UCI option.
Guidelines for testing new nets can be found at
https://github.com/glinscott/fishtest/wiki/Creating-my-first-test#nnue-net-tests
Integration has been discussed in various issues:
https://github.com/official-stockfish/Stockfish/issues/2823
https://github.com/official-stockfish/Stockfish/issues/2728
The integration branch will be closed after the merge:
https://github.com/official-stockfish/Stockfish/pull/2825
https://github.com/official-stockfish/Stockfish/tree/nnue-player-wip
closes https://github.com/official-stockfish/Stockfish/pull/2912
This will be an exciting time for computer chess, looking forward to seeing the evolution of
this approach.
Bench: 4746616
2020-08-05 09:11:15 -06:00
|
|
|
return _mm_malloc(size, alignment);
|
|
|
|
#else
|
|
|
|
return std::aligned_alloc(alignment, size);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
void std_aligned_free(void* ptr) {
|
2020-07-11 08:59:33 -06:00
|
|
|
|
2020-08-10 08:14:17 -06:00
|
|
|
#if defined(POSIXALIGNEDALLOC)
|
Add NNUE evaluation
This patch ports the efficiently updatable neural network (NNUE) evaluation to Stockfish.
Both the NNUE and the classical evaluations are available, and can be used to
assign a value to a position that is later used in alpha-beta (PVS) search to find the
best move. The classical evaluation computes this value as a function of various chess
concepts, handcrafted by experts, tested and tuned using fishtest. The NNUE evaluation
computes this value with a neural network based on basic inputs. The network is optimized
and trained on the evalutions of millions of positions at moderate search depth.
The NNUE evaluation was first introduced in shogi, and ported to Stockfish afterward.
It can be evaluated efficiently on CPUs, and exploits the fact that only parts
of the neural network need to be updated after a typical chess move.
[The nodchip repository](https://github.com/nodchip/Stockfish) provides additional
tools to train and develop the NNUE networks.
This patch is the result of contributions of various authors, from various communities,
including: nodchip, ynasu87, yaneurao (initial port and NNUE authors), domschl, FireFather,
rqs, xXH4CKST3RXx, tttak, zz4032, joergoster, mstembera, nguyenpham, erbsenzaehler,
dorzechowski, and vondele.
This new evaluation needed various changes to fishtest and the corresponding infrastructure,
for which tomtor, ppigazzini, noobpwnftw, daylen, and vondele are gratefully acknowledged.
The first networks have been provided by gekkehenker and sergiovieri, with the latter
net (nn-97f742aaefcd.nnue) being the current default.
The evaluation function can be selected at run time with the `Use NNUE` (true/false) UCI option,
provided the `EvalFile` option points the the network file (depending on the GUI, with full path).
The performance of the NNUE evaluation relative to the classical evaluation depends somewhat on
the hardware, and is expected to improve quickly, but is currently on > 80 Elo on fishtest:
60000 @ 10+0.1 th 1
https://tests.stockfishchess.org/tests/view/5f28fe6ea5abc164f05e4c4c
ELO: 92.77 +-2.1 (95%) LOS: 100.0%
Total: 60000 W: 24193 L: 8543 D: 27264
Ptnml(0-2): 609, 3850, 9708, 10948, 4885
40000 @ 20+0.2 th 8
https://tests.stockfishchess.org/tests/view/5f290229a5abc164f05e4c58
ELO: 89.47 +-2.0 (95%) LOS: 100.0%
Total: 40000 W: 12756 L: 2677 D: 24567
Ptnml(0-2): 74, 1583, 8550, 7776, 2017
At the same time, the impact on the classical evaluation remains minimal, causing no significant
regression:
sprt @ 10+0.1 th 1
https://tests.stockfishchess.org/tests/view/5f2906a2a5abc164f05e4c5b
LLR: 2.94 (-2.94,2.94) {-6.00,-4.00}
Total: 34936 W: 6502 L: 6825 D: 21609
Ptnml(0-2): 571, 4082, 8434, 3861, 520
sprt @ 60+0.6 th 1
https://tests.stockfishchess.org/tests/view/5f2906cfa5abc164f05e4c5d
LLR: 2.93 (-2.94,2.94) {-6.00,-4.00}
Total: 10088 W: 1232 L: 1265 D: 7591
Ptnml(0-2): 49, 914, 3170, 843, 68
The needed networks can be found at https://tests.stockfishchess.org/nns
It is recommended to use the default one as indicated by the `EvalFile` UCI option.
Guidelines for testing new nets can be found at
https://github.com/glinscott/fishtest/wiki/Creating-my-first-test#nnue-net-tests
Integration has been discussed in various issues:
https://github.com/official-stockfish/Stockfish/issues/2823
https://github.com/official-stockfish/Stockfish/issues/2728
The integration branch will be closed after the merge:
https://github.com/official-stockfish/Stockfish/pull/2825
https://github.com/official-stockfish/Stockfish/tree/nnue-player-wip
closes https://github.com/official-stockfish/Stockfish/pull/2912
This will be an exciting time for computer chess, looking forward to seeing the evolution of
this approach.
Bench: 4746616
2020-08-05 09:11:15 -06:00
|
|
|
free(ptr);
|
2020-08-11 13:02:48 -06:00
|
|
|
#elif defined(_WIN32)
|
Add NNUE evaluation
This patch ports the efficiently updatable neural network (NNUE) evaluation to Stockfish.
Both the NNUE and the classical evaluations are available, and can be used to
assign a value to a position that is later used in alpha-beta (PVS) search to find the
best move. The classical evaluation computes this value as a function of various chess
concepts, handcrafted by experts, tested and tuned using fishtest. The NNUE evaluation
computes this value with a neural network based on basic inputs. The network is optimized
and trained on the evalutions of millions of positions at moderate search depth.
The NNUE evaluation was first introduced in shogi, and ported to Stockfish afterward.
It can be evaluated efficiently on CPUs, and exploits the fact that only parts
of the neural network need to be updated after a typical chess move.
[The nodchip repository](https://github.com/nodchip/Stockfish) provides additional
tools to train and develop the NNUE networks.
This patch is the result of contributions of various authors, from various communities,
including: nodchip, ynasu87, yaneurao (initial port and NNUE authors), domschl, FireFather,
rqs, xXH4CKST3RXx, tttak, zz4032, joergoster, mstembera, nguyenpham, erbsenzaehler,
dorzechowski, and vondele.
This new evaluation needed various changes to fishtest and the corresponding infrastructure,
for which tomtor, ppigazzini, noobpwnftw, daylen, and vondele are gratefully acknowledged.
The first networks have been provided by gekkehenker and sergiovieri, with the latter
net (nn-97f742aaefcd.nnue) being the current default.
The evaluation function can be selected at run time with the `Use NNUE` (true/false) UCI option,
provided the `EvalFile` option points the the network file (depending on the GUI, with full path).
The performance of the NNUE evaluation relative to the classical evaluation depends somewhat on
the hardware, and is expected to improve quickly, but is currently on > 80 Elo on fishtest:
60000 @ 10+0.1 th 1
https://tests.stockfishchess.org/tests/view/5f28fe6ea5abc164f05e4c4c
ELO: 92.77 +-2.1 (95%) LOS: 100.0%
Total: 60000 W: 24193 L: 8543 D: 27264
Ptnml(0-2): 609, 3850, 9708, 10948, 4885
40000 @ 20+0.2 th 8
https://tests.stockfishchess.org/tests/view/5f290229a5abc164f05e4c58
ELO: 89.47 +-2.0 (95%) LOS: 100.0%
Total: 40000 W: 12756 L: 2677 D: 24567
Ptnml(0-2): 74, 1583, 8550, 7776, 2017
At the same time, the impact on the classical evaluation remains minimal, causing no significant
regression:
sprt @ 10+0.1 th 1
https://tests.stockfishchess.org/tests/view/5f2906a2a5abc164f05e4c5b
LLR: 2.94 (-2.94,2.94) {-6.00,-4.00}
Total: 34936 W: 6502 L: 6825 D: 21609
Ptnml(0-2): 571, 4082, 8434, 3861, 520
sprt @ 60+0.6 th 1
https://tests.stockfishchess.org/tests/view/5f2906cfa5abc164f05e4c5d
LLR: 2.93 (-2.94,2.94) {-6.00,-4.00}
Total: 10088 W: 1232 L: 1265 D: 7591
Ptnml(0-2): 49, 914, 3170, 843, 68
The needed networks can be found at https://tests.stockfishchess.org/nns
It is recommended to use the default one as indicated by the `EvalFile` UCI option.
Guidelines for testing new nets can be found at
https://github.com/glinscott/fishtest/wiki/Creating-my-first-test#nnue-net-tests
Integration has been discussed in various issues:
https://github.com/official-stockfish/Stockfish/issues/2823
https://github.com/official-stockfish/Stockfish/issues/2728
The integration branch will be closed after the merge:
https://github.com/official-stockfish/Stockfish/pull/2825
https://github.com/official-stockfish/Stockfish/tree/nnue-player-wip
closes https://github.com/official-stockfish/Stockfish/pull/2912
This will be an exciting time for computer chess, looking forward to seeing the evolution of
this approach.
Bench: 4746616
2020-08-05 09:11:15 -06:00
|
|
|
_mm_free(ptr);
|
|
|
|
#else
|
|
|
|
free(ptr);
|
|
|
|
#endif
|
|
|
|
}
|
2019-12-21 12:41:42 -07:00
|
|
|
|
2020-07-11 08:59:33 -06:00
|
|
|
/// aligned_ttmem_alloc() will return suitably aligned memory, if possible using large pages.
|
2020-06-24 14:19:58 -06:00
|
|
|
/// The returned pointer is the aligned one, while the mem argument is the one that needs
|
|
|
|
/// to be passed to free. With c++17 some of this functionality could be simplified.
|
|
|
|
|
2020-01-28 08:17:52 -07:00
|
|
|
#if defined(__linux__) && !defined(__ANDROID__)
|
2019-12-21 12:41:42 -07:00
|
|
|
|
2020-02-05 07:18:24 -07:00
|
|
|
void* aligned_ttmem_alloc(size_t allocSize, void*& mem) {
|
2019-12-21 12:41:42 -07:00
|
|
|
|
|
|
|
constexpr size_t alignment = 2 * 1024 * 1024; // assumed 2MB page sizes
|
|
|
|
size_t size = ((allocSize + alignment - 1) / alignment) * alignment; // multiple of alignment
|
2020-05-09 11:45:07 -06:00
|
|
|
if (posix_memalign(&mem, alignment, size))
|
|
|
|
mem = nullptr;
|
2020-08-20 23:42:19 -06:00
|
|
|
#if defined(MADV_HUGEPAGE)
|
2020-02-05 07:18:24 -07:00
|
|
|
madvise(mem, allocSize, MADV_HUGEPAGE);
|
2020-08-20 23:42:19 -06:00
|
|
|
#endif
|
2020-02-05 07:18:24 -07:00
|
|
|
return mem;
|
2019-12-21 12:41:42 -07:00
|
|
|
}
|
|
|
|
|
2020-05-04 11:49:27 -06:00
|
|
|
#elif defined(_WIN64)
|
|
|
|
|
|
|
|
static void* aligned_ttmem_alloc_large_pages(size_t allocSize) {
|
|
|
|
|
|
|
|
HANDLE hProcessToken { };
|
|
|
|
LUID luid { };
|
|
|
|
void* mem = nullptr;
|
|
|
|
|
|
|
|
const size_t largePageSize = GetLargePageMinimum();
|
|
|
|
if (!largePageSize)
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
// We need SeLockMemoryPrivilege, so try to enable it for the process
|
|
|
|
if (!OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hProcessToken))
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
if (LookupPrivilegeValue(NULL, SE_LOCK_MEMORY_NAME, &luid))
|
|
|
|
{
|
|
|
|
TOKEN_PRIVILEGES tp { };
|
|
|
|
TOKEN_PRIVILEGES prevTp { };
|
|
|
|
DWORD prevTpLen = 0;
|
|
|
|
|
|
|
|
tp.PrivilegeCount = 1;
|
|
|
|
tp.Privileges[0].Luid = luid;
|
|
|
|
tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
|
|
|
|
|
|
|
|
// Try to enable SeLockMemoryPrivilege. Note that even if AdjustTokenPrivileges() succeeds,
|
2020-06-24 14:19:58 -06:00
|
|
|
// we still need to query GetLastError() to ensure that the privileges were actually obtained.
|
2020-05-04 11:49:27 -06:00
|
|
|
if (AdjustTokenPrivileges(
|
|
|
|
hProcessToken, FALSE, &tp, sizeof(TOKEN_PRIVILEGES), &prevTp, &prevTpLen) &&
|
|
|
|
GetLastError() == ERROR_SUCCESS)
|
|
|
|
{
|
2020-06-24 14:19:58 -06:00
|
|
|
// Round up size to full pages and allocate
|
2020-05-04 11:49:27 -06:00
|
|
|
allocSize = (allocSize + largePageSize - 1) & ~size_t(largePageSize - 1);
|
|
|
|
mem = VirtualAlloc(
|
|
|
|
NULL, allocSize, MEM_RESERVE | MEM_COMMIT | MEM_LARGE_PAGES, PAGE_READWRITE);
|
|
|
|
|
2020-06-24 14:19:58 -06:00
|
|
|
// Privilege no longer needed, restore previous state
|
2020-05-04 11:49:27 -06:00
|
|
|
AdjustTokenPrivileges(hProcessToken, FALSE, &prevTp, 0, NULL, NULL);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
CloseHandle(hProcessToken);
|
|
|
|
|
|
|
|
return mem;
|
|
|
|
}
|
|
|
|
|
|
|
|
void* aligned_ttmem_alloc(size_t allocSize, void*& mem) {
|
|
|
|
|
2020-05-19 03:08:01 -06:00
|
|
|
static bool firstCall = true;
|
|
|
|
|
2020-06-24 14:19:58 -06:00
|
|
|
// Try to allocate large pages
|
2020-05-04 11:49:27 -06:00
|
|
|
mem = aligned_ttmem_alloc_large_pages(allocSize);
|
2020-05-19 03:08:01 -06:00
|
|
|
|
|
|
|
// Suppress info strings on the first call. The first call occurs before 'uci'
|
|
|
|
// is received and in that case this output confuses some GUIs.
|
|
|
|
if (!firstCall)
|
|
|
|
{
|
|
|
|
if (mem)
|
|
|
|
sync_cout << "info string Hash table allocation: Windows large pages used." << sync_endl;
|
|
|
|
else
|
|
|
|
sync_cout << "info string Hash table allocation: Windows large pages not used." << sync_endl;
|
|
|
|
}
|
|
|
|
firstCall = false;
|
2020-05-04 11:49:27 -06:00
|
|
|
|
2020-06-24 14:19:58 -06:00
|
|
|
// Fall back to regular, page aligned, allocation if necessary
|
2020-05-04 11:49:27 -06:00
|
|
|
if (!mem)
|
|
|
|
mem = VirtualAlloc(NULL, allocSize, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
|
|
|
|
|
|
|
|
return mem;
|
|
|
|
}
|
|
|
|
|
2019-12-21 12:41:42 -07:00
|
|
|
#else
|
|
|
|
|
2020-02-05 07:18:24 -07:00
|
|
|
void* aligned_ttmem_alloc(size_t allocSize, void*& mem) {
|
2019-12-21 12:41:42 -07:00
|
|
|
|
|
|
|
constexpr size_t alignment = 64; // assumed cache line size
|
|
|
|
size_t size = allocSize + alignment - 1; // allocate some extra space
|
2020-02-05 07:18:24 -07:00
|
|
|
mem = malloc(size);
|
|
|
|
void* ret = reinterpret_cast<void*>((uintptr_t(mem) + alignment - 1) & ~uintptr_t(alignment - 1));
|
2019-12-21 12:41:42 -07:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
2020-06-24 14:19:58 -06:00
|
|
|
|
|
|
|
/// aligned_ttmem_free() will free the previously allocated ttmem
|
|
|
|
|
2020-05-04 11:49:27 -06:00
|
|
|
#if defined(_WIN64)
|
|
|
|
|
|
|
|
void aligned_ttmem_free(void* mem) {
|
|
|
|
|
2020-05-14 03:00:35 -06:00
|
|
|
if (mem && !VirtualFree(mem, 0, MEM_RELEASE))
|
2020-05-04 11:49:27 -06:00
|
|
|
{
|
|
|
|
DWORD err = GetLastError();
|
|
|
|
std::cerr << "Failed to free transposition table. Error code: 0x" <<
|
|
|
|
std::hex << err << std::dec << std::endl;
|
|
|
|
exit(EXIT_FAILURE);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#else
|
|
|
|
|
|
|
|
void aligned_ttmem_free(void *mem) {
|
|
|
|
free(mem);
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
2019-12-21 12:41:42 -07:00
|
|
|
|
2016-11-21 23:41:46 -07:00
|
|
|
namespace WinProcGroup {
|
|
|
|
|
|
|
|
#ifndef _WIN32
|
|
|
|
|
|
|
|
void bindThisThread(size_t) {}
|
|
|
|
|
|
|
|
#else
|
|
|
|
|
2018-07-25 10:31:02 -06:00
|
|
|
/// best_group() retrieves logical processor information using Windows specific
|
2016-11-21 23:41:46 -07:00
|
|
|
/// API and returns the best group id for the thread with index idx. Original
|
|
|
|
/// code from Texel by Peter sterlund.
|
|
|
|
|
2018-07-25 10:31:02 -06:00
|
|
|
int best_group(size_t idx) {
|
2016-11-21 23:41:46 -07:00
|
|
|
|
|
|
|
int threads = 0;
|
|
|
|
int nodes = 0;
|
|
|
|
int cores = 0;
|
|
|
|
DWORD returnLength = 0;
|
|
|
|
DWORD byteOffset = 0;
|
|
|
|
|
2016-11-25 08:51:24 -07:00
|
|
|
// Early exit if the needed API is not available at runtime
|
2016-11-21 23:41:46 -07:00
|
|
|
HMODULE k32 = GetModuleHandle("Kernel32.dll");
|
2018-06-20 19:05:27 -06:00
|
|
|
auto fun1 = (fun1_t)(void(*)())GetProcAddress(k32, "GetLogicalProcessorInformationEx");
|
2016-11-25 08:51:24 -07:00
|
|
|
if (!fun1)
|
2016-11-21 23:41:46 -07:00
|
|
|
return -1;
|
|
|
|
|
|
|
|
// First call to get returnLength. We expect it to fail due to null buffer
|
2016-11-25 08:51:24 -07:00
|
|
|
if (fun1(RelationAll, nullptr, &returnLength))
|
2016-11-21 23:41:46 -07:00
|
|
|
return -1;
|
|
|
|
|
|
|
|
// Once we know returnLength, allocate the buffer
|
|
|
|
SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX *buffer, *ptr;
|
|
|
|
ptr = buffer = (SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX*)malloc(returnLength);
|
|
|
|
|
|
|
|
// Second call, now we expect to succeed
|
2016-11-25 08:51:24 -07:00
|
|
|
if (!fun1(RelationAll, buffer, &returnLength))
|
2016-11-21 23:41:46 -07:00
|
|
|
{
|
|
|
|
free(buffer);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2018-12-22 10:05:13 -07:00
|
|
|
while (byteOffset < returnLength)
|
2016-11-21 23:41:46 -07:00
|
|
|
{
|
|
|
|
if (ptr->Relationship == RelationNumaNode)
|
|
|
|
nodes++;
|
|
|
|
|
|
|
|
else if (ptr->Relationship == RelationProcessorCore)
|
|
|
|
{
|
|
|
|
cores++;
|
|
|
|
threads += (ptr->Processor.Flags == LTP_PC_SMT) ? 2 : 1;
|
|
|
|
}
|
|
|
|
|
2018-12-22 10:05:13 -07:00
|
|
|
assert(ptr->Size);
|
2016-11-21 23:41:46 -07:00
|
|
|
byteOffset += ptr->Size;
|
|
|
|
ptr = (SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX*)(((char*)ptr) + ptr->Size);
|
|
|
|
}
|
|
|
|
|
|
|
|
free(buffer);
|
|
|
|
|
|
|
|
std::vector<int> groups;
|
|
|
|
|
|
|
|
// Run as many threads as possible on the same node until core limit is
|
|
|
|
// reached, then move on filling the next node.
|
|
|
|
for (int n = 0; n < nodes; n++)
|
|
|
|
for (int i = 0; i < cores / nodes; i++)
|
|
|
|
groups.push_back(n);
|
|
|
|
|
|
|
|
// In case a core has more than one logical processor (we assume 2) and we
|
|
|
|
// have still threads to allocate, then spread them evenly across available
|
|
|
|
// nodes.
|
|
|
|
for (int t = 0; t < threads - cores; t++)
|
|
|
|
groups.push_back(t % nodes);
|
|
|
|
|
|
|
|
// If we still have more threads than the total number of logical processors
|
|
|
|
// then return -1 and let the OS to decide what to do.
|
|
|
|
return idx < groups.size() ? groups[idx] : -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/// bindThisThread() set the group affinity of the current thread
|
|
|
|
|
|
|
|
void bindThisThread(size_t idx) {
|
|
|
|
|
2016-11-25 08:51:24 -07:00
|
|
|
// Use only local variables to be thread-safe
|
2018-07-25 10:31:02 -06:00
|
|
|
int group = best_group(idx);
|
2016-11-21 23:41:46 -07:00
|
|
|
|
|
|
|
if (group == -1)
|
|
|
|
return;
|
|
|
|
|
2016-11-25 08:51:24 -07:00
|
|
|
// Early exit if the needed API are not available at runtime
|
|
|
|
HMODULE k32 = GetModuleHandle("Kernel32.dll");
|
2018-06-20 19:05:27 -06:00
|
|
|
auto fun2 = (fun2_t)(void(*)())GetProcAddress(k32, "GetNumaNodeProcessorMaskEx");
|
|
|
|
auto fun3 = (fun3_t)(void(*)())GetProcAddress(k32, "SetThreadGroupAffinity");
|
2016-11-25 08:51:24 -07:00
|
|
|
|
|
|
|
if (!fun2 || !fun3)
|
|
|
|
return;
|
|
|
|
|
|
|
|
GROUP_AFFINITY affinity;
|
|
|
|
if (fun2(group, &affinity))
|
|
|
|
fun3(GetCurrentThread(), &affinity, nullptr);
|
2016-11-21 23:41:46 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
} // namespace WinProcGroup
|
Embed default net, and simplify using non-default nets
covers the most important cases from the user perspective:
It embeds the default net in the binary, so a download of that binary will result
in a working engine with the default net. The engine will be functional in the default mode
without any additional user action.
It allows non-default nets to be used, which will be looked for in up to
three directories (working directory, location of the binary, and optionally a specific default directory).
This mechanism is also kept for those developers that use MSVC,
the one compiler that doesn't have an easy mechanism for embedding data.
It is possible to disable embedding, and instead specify a specific directory, e.g. linux distros might want to use
CXXFLAGS="-DNNUE_EMBEDDING_OFF -DDEFAULT_NNUE_DIRECTORY=/usr/share/games/stockfish/" make -j ARCH=x86-64 profile-build
passed STC non-regression:
https://tests.stockfishchess.org/tests/view/5f4a581c150f0aef5f8ae03a
LLR: 2.95 (-2.94,2.94) {-1.25,-0.25}
Total: 66928 W: 7202 L: 7147 D: 52579
Ptnml(0-2): 291, 5309, 22211, 5360, 293
closes https://github.com/official-stockfish/Stockfish/pull/3070
fixes https://github.com/official-stockfish/Stockfish/issues/3030
No functional change.
2020-08-23 05:43:38 -06:00
|
|
|
|
|
|
|
#ifdef _WIN32
|
|
|
|
#include <direct.h>
|
|
|
|
#define GETCWD _getcwd
|
|
|
|
#else
|
|
|
|
#include <unistd.h>
|
|
|
|
#define GETCWD getcwd
|
|
|
|
#endif
|
|
|
|
|
|
|
|
namespace CommandLine {
|
|
|
|
|
|
|
|
string argv0; // path+name of the executable binary, as given by argv[0]
|
|
|
|
string binaryDirectory; // path of the executable directory
|
|
|
|
string workingDirectory; // path of the working directory
|
|
|
|
string pathSeparator; // Separator for our current OS
|
|
|
|
|
|
|
|
void init(int argc, char* argv[]) {
|
|
|
|
(void)argc;
|
|
|
|
string separator;
|
|
|
|
|
|
|
|
// extract the path+name of the executable binary
|
|
|
|
argv0 = argv[0];
|
|
|
|
|
|
|
|
#ifdef _WIN32
|
|
|
|
pathSeparator = "\\";
|
|
|
|
#ifdef _MSC_VER
|
|
|
|
// Under windows argv[0] may not have the extension. Also _get_pgmptr() had
|
|
|
|
// issues in some windows 10 versions, so check returned values carefully.
|
|
|
|
char* pgmptr = nullptr;
|
|
|
|
if (!_get_pgmptr(&pgmptr) && pgmptr != nullptr && *pgmptr)
|
|
|
|
argv0 = pgmptr;
|
|
|
|
#endif
|
|
|
|
#else
|
|
|
|
pathSeparator = "/";
|
|
|
|
#endif
|
|
|
|
|
|
|
|
// extract the working directory
|
|
|
|
workingDirectory = "";
|
|
|
|
char buff[40000];
|
|
|
|
char* cwd = GETCWD(buff, 40000);
|
|
|
|
if (cwd)
|
|
|
|
workingDirectory = cwd;
|
|
|
|
|
|
|
|
// extract the binary directory path from argv0
|
|
|
|
binaryDirectory = argv0;
|
|
|
|
size_t pos = binaryDirectory.find_last_of("\\/");
|
|
|
|
if (pos == std::string::npos)
|
|
|
|
binaryDirectory = "." + pathSeparator;
|
|
|
|
else
|
|
|
|
binaryDirectory.resize(pos + 1);
|
|
|
|
|
|
|
|
// pattern replacement: "./" at the start of path is replaced by the working directory
|
|
|
|
if (binaryDirectory.find("." + pathSeparator) == 0)
|
|
|
|
binaryDirectory.replace(0, 1, workingDirectory);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
} // namespace CommandLine
|