mirror of
https://github.com/HChaZZY/Stockfish.git
synced 2025-12-20 17:16:33 +08:00
beb327f910
There was a bug in commit d4763424d2
(Add support for Windows large pages) that could result in trying to
free memory allocated with VirtualAlloc incorrectly with free().
Fix this by reverting the TT.resize(0) logic in the previous commit,
and instead, just call aligned_ttmem_free() in
TranspositionTable::~TranspositionTable().
fixes https://github.com/official-stockfish/Stockfish/issues/2677
closes https://github.com/official-stockfish/Stockfish/pull/2679
No functional change
125 lines
3.7 KiB
C++
125 lines
3.7 KiB
C++
/*
|
|
Stockfish, a UCI chess playing engine derived from Glaurung 2.1
|
|
Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
|
|
Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
|
|
Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
|
|
|
|
Stockfish is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
Stockfish is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#ifndef MISC_H_INCLUDED
|
|
#define MISC_H_INCLUDED
|
|
|
|
#include <cassert>
|
|
#include <chrono>
|
|
#include <ostream>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
#include "types.h"
|
|
|
|
const std::string engine_info(bool to_uci = false);
|
|
const std::string compiler_info();
|
|
void prefetch(void* addr);
|
|
void start_logger(const std::string& fname);
|
|
void* aligned_ttmem_alloc(size_t size, void*& mem);
|
|
void aligned_ttmem_free(void* mem); // nop if mem == nullptr
|
|
|
|
void dbg_hit_on(bool b);
|
|
void dbg_hit_on(bool c, bool b);
|
|
void dbg_mean_of(int v);
|
|
void dbg_print();
|
|
|
|
typedef std::chrono::milliseconds::rep TimePoint; // A value in milliseconds
|
|
|
|
static_assert(sizeof(TimePoint) == sizeof(int64_t), "TimePoint should be 64 bits");
|
|
|
|
inline TimePoint now() {
|
|
return std::chrono::duration_cast<std::chrono::milliseconds>
|
|
(std::chrono::steady_clock::now().time_since_epoch()).count();
|
|
}
|
|
|
|
template<class Entry, int Size>
|
|
struct HashTable {
|
|
Entry* operator[](Key key) { return &table[(uint32_t)key & (Size - 1)]; }
|
|
|
|
private:
|
|
std::vector<Entry> table = std::vector<Entry>(Size); // Allocate on the heap
|
|
};
|
|
|
|
|
|
enum SyncCout { IO_LOCK, IO_UNLOCK };
|
|
std::ostream& operator<<(std::ostream&, SyncCout);
|
|
|
|
#define sync_cout std::cout << IO_LOCK
|
|
#define sync_endl std::endl << IO_UNLOCK
|
|
|
|
namespace Utility {
|
|
|
|
/// Clamp a value between lo and hi. Available in c++17.
|
|
template<class T> constexpr const T& clamp(const T& v, const T& lo, const T& hi) {
|
|
return v < lo ? lo : v > hi ? hi : v;
|
|
}
|
|
|
|
}
|
|
|
|
/// xorshift64star Pseudo-Random Number Generator
|
|
/// This class is based on original code written and dedicated
|
|
/// to the public domain by Sebastiano Vigna (2014).
|
|
/// It has the following characteristics:
|
|
///
|
|
/// - Outputs 64-bit numbers
|
|
/// - Passes Dieharder and SmallCrush test batteries
|
|
/// - Does not require warm-up, no zeroland to escape
|
|
/// - Internal state is a single 64-bit integer
|
|
/// - Period is 2^64 - 1
|
|
/// - Speed: 1.60 ns/call (Core i7 @3.40GHz)
|
|
///
|
|
/// For further analysis see
|
|
/// <http://vigna.di.unimi.it/ftp/papers/xorshift.pdf>
|
|
|
|
class PRNG {
|
|
|
|
uint64_t s;
|
|
|
|
uint64_t rand64() {
|
|
|
|
s ^= s >> 12, s ^= s << 25, s ^= s >> 27;
|
|
return s * 2685821657736338717LL;
|
|
}
|
|
|
|
public:
|
|
PRNG(uint64_t seed) : s(seed) { assert(seed); }
|
|
|
|
template<typename T> T rand() { return T(rand64()); }
|
|
|
|
/// Special generator used to fast init magic numbers.
|
|
/// Output values only have 1/8th of their bits set on average.
|
|
template<typename T> T sparse_rand()
|
|
{ return T(rand64() & rand64() & rand64()); }
|
|
};
|
|
|
|
|
|
/// Under Windows it is not possible for a process to run on more than one
|
|
/// logical processor group. This usually means to be limited to use max 64
|
|
/// cores. To overcome this, some special platform specific API should be
|
|
/// called to set group affinity for each thread. Original code from Texel by
|
|
/// Peter Österlund.
|
|
|
|
namespace WinProcGroup {
|
|
void bindThisThread(size_t idx);
|
|
}
|
|
|
|
#endif // #ifndef MISC_H_INCLUDED
|