X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fmisc.h;h=8ad17b502f4d3c0bfc02c03054ff20643fd8c40a;hp=6fa86d734039297b4c3a4bddad787a2c9f69db9a;hb=530fccbf272ffe424ae53a464b91db148cc968ae;hpb=e17fa64aec39c43708ed80eccb715e36da1cdd64 diff --git a/src/misc.h b/src/misc.h index 6fa86d73..8ad17b50 100644 --- a/src/misc.h +++ b/src/misc.h @@ -1,7 +1,6 @@ /* Stockfish, a UCI chess playing engine derived from Glaurung 2.1 - Copyright (C) 2004-2008 Tord Romstad (Glaurung author) - Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad + Copyright (C) 2004-2020 The Stockfish developers (see AUTHORS file) Stockfish is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -17,59 +16,114 @@ along with this program. If not, see . */ - -#if !defined(MISC_H_INCLUDED) +#ifndef MISC_H_INCLUDED #define MISC_H_INCLUDED - -//// -//// Includes -//// - -#include +#include +#include +#include #include +#include -#include "application.h" #include "types.h" -//// -//// Macros -//// - -#define Min(x, y) (((x) < (y))? (x) : (y)) -#define Max(x, y) (((x) < (y))? (y) : (x)) - - -//// -//// Prototypes -//// - -extern const std::string engine_name(); -extern int get_system_time(); -extern int cpu_count(); -extern int Bioskey(); -extern void prefetch(char* addr); -extern void prefetchPawn(Key, int); - - -//// -//// Debug -//// - -extern bool dbg_show_mean; -extern bool dbg_show_hit_rate; - -extern uint64_t dbg_cnt0; -extern uint64_t dbg_cnt1; - -extern void dbg_hit_on(bool b); -extern void dbg_hit_on_c(bool c, bool b); -extern void dbg_before(); -extern void dbg_after(); -extern void dbg_mean_of(int v); -extern void dbg_print_hit_rate(); -extern void dbg_print_mean(); -extern void dbg_print_hit_rate(std::ofstream& logFile); -extern void dbg_print_mean(std::ofstream& logFile); - -#endif // !defined(MISC_H_INCLUDED) +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* std_aligned_alloc(size_t alignment, size_t size); +void std_aligned_free(void* ptr); +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::steady_clock::now().time_since_epoch()).count(); +} + +template +struct HashTable { + Entry* operator[](Key key) { return &table[(uint32_t)key & (Size - 1)]; } + +private: + std::vector table = std::vector(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 + + +/// 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 +/// + +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 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 T sparse_rand() + { return T(rand64() & rand64() & rand64()); } +}; + +inline uint64_t mul_hi64(uint64_t a, uint64_t b) { +#if defined(__GNUC__) && defined(IS_64BIT) + __extension__ typedef unsigned __int128 uint128; + return ((uint128)a * (uint128)b) >> 64; +#else + uint64_t aL = (uint32_t)a, aH = a >> 32; + uint64_t bL = (uint32_t)b, bH = b >> 32; + uint64_t c1 = (aL * bL) >> 32; + uint64_t c2 = aH * bL + c1; + uint64_t c3 = aL * bH + (uint32_t)c2; + return aH * bH + (c2 >> 32) + (c3 >> 32); +#endif +} + +/// 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