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
|
|
|
|
Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
|
2016-01-02 02:43:25 -07:00
|
|
|
Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
|
2020-01-07 13:35:47 -07:00
|
|
|
Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
|
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>
|
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
|
|
|
|
|
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
|
|
|
|
|
|
|
|
/// 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);
|
|
|
|
}
|
|
|
|
|
|
|
|
ss << (Is64Bit ? " 64" : "")
|
2014-11-01 14:43:57 -06:00
|
|
|
<< (HasPext ? " BMI2" : (HasPopCnt ? " POPCNT" : ""))
|
2014-11-01 14:35:10 -06:00
|
|
|
<< (to_uci ? "\nid author ": " by ")
|
2015-10-21 22:57:06 -06:00
|
|
|
<< "T. Romstad, M. Costalba, J. Kiiski, G. Linscott";
|
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
|
|
|
|
|
|
|
|
compiler += "\n __VERSION__ macro expands to: ";
|
|
|
|
#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
|
|
|
|
2019-12-21 12:41:42 -07:00
|
|
|
|
|
|
|
/// aligned_ttmem_alloc will return suitably aligned memory, and if possible use large pages.
|
|
|
|
/// 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 can 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-02-05 07:18:24 -07:00
|
|
|
madvise(mem, allocSize, MADV_HUGEPAGE);
|
|
|
|
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,
|
|
|
|
// we still need to query GetLastError() to ensure that the privileges were actually obtained...
|
|
|
|
if (AdjustTokenPrivileges(
|
|
|
|
hProcessToken, FALSE, &tp, sizeof(TOKEN_PRIVILEGES), &prevTp, &prevTpLen) &&
|
|
|
|
GetLastError() == ERROR_SUCCESS)
|
|
|
|
{
|
|
|
|
// round up size to full pages and allocate
|
|
|
|
allocSize = (allocSize + largePageSize - 1) & ~size_t(largePageSize - 1);
|
|
|
|
mem = VirtualAlloc(
|
|
|
|
NULL, allocSize, MEM_RESERVE | MEM_COMMIT | MEM_LARGE_PAGES, PAGE_READWRITE);
|
|
|
|
|
|
|
|
// privilege no longer needed, restore previous state
|
|
|
|
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-05-04 11:49:27 -06:00
|
|
|
// try to allocate large pages
|
|
|
|
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
|
|
|
|
|
|
|
// fall back to regular, page aligned, allocation if necessary
|
|
|
|
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-05-04 11:49:27 -06:00
|
|
|
/// aligned_ttmem_free will free the previously allocated ttmem
|
|
|
|
#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
|