-extern const std::string engine_name();
-extern const std::string engine_authors();
-extern int get_system_time();
-extern int cpu_count();
-extern int input_available();
-extern void prefetch(char* addr);
-
-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();
-
-struct Log : public std::ofstream {
- Log(const std::string& f = "log.txt") : std::ofstream(f.c_str(), std::ios::out | std::ios::app) {}
- ~Log() { if (is_open()) close(); }
+namespace Stockfish {
+
+std::string engine_info(bool to_uci = false);
+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_large_pages_alloc(size_t size); // memory aligned by page size, min alignment: 4096 bytes
+void aligned_large_pages_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
+
+
+// align_ptr_up() : get the first aligned element of an array.
+// ptr must point to an array of size at least `sizeof(T) * N + alignment` bytes,
+// where N is the number of elements in the array.
+template <uintptr_t Alignment, typename T>
+T* align_ptr_up(T* ptr)
+{
+ static_assert(alignof(T) < Alignment);
+
+ const uintptr_t ptrint = reinterpret_cast<uintptr_t>(reinterpret_cast<char*>(ptr));
+ return reinterpret_cast<T*>(reinterpret_cast<char*>((ptrint + (Alignment - 1)) / Alignment * Alignment));
+}
+
+
+// IsLittleEndian : true if and only if the binary is compiled on a little endian machine
+static inline const union { uint32_t i; char c[4]; } Le = { 0x01020304 };
+static inline const bool IsLittleEndian = (Le.c[0] == 4);
+
+
+// RunningAverage : a class to calculate a running average of a series of values.
+// For efficiency, all computations are done with integers.
+class RunningAverage {
+ public:
+
+ // Constructor
+ RunningAverage() {}
+
+ // Reset the running average to rational value p / q
+ void set(int64_t p, int64_t q)
+ { average = p * PERIOD * RESOLUTION / q; }
+
+ // Update average with value v
+ void update(int64_t v)
+ { average = RESOLUTION * v + (PERIOD - 1) * average / PERIOD; }
+
+ // Test if average is strictly greater than rational a / b
+ bool is_greater(int64_t a, int64_t b)
+ { return b * average > a * PERIOD * RESOLUTION ; }
+
+ private :
+ static constexpr int64_t PERIOD = 4096;
+ static constexpr int64_t RESOLUTION = 1024;
+ int64_t average;
+};
+
+template <typename T, std::size_t MaxSize>
+class ValueList {
+
+public:
+ std::size_t size() const { return size_; }
+ void resize(std::size_t newSize) { size_ = newSize; }
+ void push_back(const T& value) { values_[size_++] = value; }
+ T& operator[](std::size_t index) { return values_[index]; }
+ T* begin() { return values_; }
+ T* end() { return values_ + size_; }
+ const T& operator[](std::size_t index) const { return values_[index]; }
+ const T* begin() const { return values_; }
+ const T* end() const { return values_ + size_; }
+
+ void swap(ValueList& other) {
+ const std::size_t maxSize = std::max(size_, other.size_);
+ for (std::size_t i = 0; i < maxSize; ++i) {
+ std::swap(values_[i], other.values_[i]);
+ }
+ std::swap(size_, other.size_);
+ }
+
+private:
+ T values_[MaxSize];
+ std::size_t size_ = 0;