// Code for calculating NNUE evaluation function
-#include <fstream>
#include <iostream>
#include <set>
#include "../position.h"
#include "../misc.h"
#include "../uci.h"
+#include "../types.h"
#include "evaluate_nnue.h"
-ExtPieceSquare kpp_board_index[PIECE_NB] = {
- // convention: W - us, B - them
- // viewed from other side, W and B are reversed
- { PS_NONE, PS_NONE },
- { PS_W_PAWN, PS_B_PAWN },
- { PS_W_KNIGHT, PS_B_KNIGHT },
- { PS_W_BISHOP, PS_B_BISHOP },
- { PS_W_ROOK, PS_B_ROOK },
- { PS_W_QUEEN, PS_B_QUEEN },
- { PS_W_KING, PS_B_KING },
- { PS_NONE, PS_NONE },
- { PS_NONE, PS_NONE },
- { PS_B_PAWN, PS_W_PAWN },
- { PS_B_KNIGHT, PS_W_KNIGHT },
- { PS_B_BISHOP, PS_W_BISHOP },
- { PS_B_ROOK, PS_W_ROOK },
- { PS_B_QUEEN, PS_W_QUEEN },
- { PS_B_KING, PS_W_KING },
- { PS_NONE, PS_NONE }
-};
-
-
namespace Eval::NNUE {
// Input feature converter
- AlignedPtr<FeatureTransformer> feature_transformer;
+ LargePagePtr<FeatureTransformer> feature_transformer;
// Evaluation function
AlignedPtr<Network> network;
std::memset(pointer.get(), 0, sizeof(T));
}
+ template <typename T>
+ void Initialize(LargePagePtr<T>& pointer) {
+
+ static_assert(alignof(T) <= 4096, "aligned_large_pages_alloc() may fail for such a big alignment requirement of T");
+ pointer.reset(reinterpret_cast<T*>(aligned_large_pages_alloc(sizeof(T))));
+ std::memset(pointer.get(), 0, sizeof(T));
+ }
+
// Read evaluation function parameters
template <typename T>
- bool ReadParameters(std::istream& stream, const AlignedPtr<T>& pointer) {
+ bool ReadParameters(std::istream& stream, T& reference) {
std::uint32_t header;
- stream.read(reinterpret_cast<char*>(&header), sizeof(header));
+ header = read_little_endian<std::uint32_t>(stream);
if (!stream || header != T::GetHashValue()) return false;
- return pointer->ReadParameters(stream);
+ return reference.ReadParameters(stream);
}
} // namespace Detail
}
// Read network header
- bool ReadHeader(std::istream& stream,
- std::uint32_t* hash_value, std::string* architecture) {
-
+ bool ReadHeader(std::istream& stream, std::uint32_t* hash_value, std::string* architecture)
+ {
std::uint32_t version, size;
- stream.read(reinterpret_cast<char*>(&version), sizeof(version));
- stream.read(reinterpret_cast<char*>(hash_value), sizeof(*hash_value));
- stream.read(reinterpret_cast<char*>(&size), sizeof(size));
+
+ version = read_little_endian<std::uint32_t>(stream);
+ *hash_value = read_little_endian<std::uint32_t>(stream);
+ size = read_little_endian<std::uint32_t>(stream);
if (!stream || version != kVersion) return false;
architecture->resize(size);
stream.read(&(*architecture)[0], size);
std::string architecture;
if (!ReadHeader(stream, &hash_value, &architecture)) return false;
if (hash_value != kHashValue) return false;
- if (!Detail::ReadParameters(stream, feature_transformer)) return false;
- if (!Detail::ReadParameters(stream, network)) return false;
+ if (!Detail::ReadParameters(stream, *feature_transformer)) return false;
+ if (!Detail::ReadParameters(stream, *network)) return false;
return stream && stream.peek() == std::ios::traits_type::eof();
}
- // Proceed with the difference calculation if possible
- static void UpdateAccumulatorIfPossible(const Position& pos) {
-
- feature_transformer->UpdateAccumulatorIfPossible(pos);
- }
-
- // Calculate the evaluation value
- static Value ComputeScore(const Position& pos, bool refresh) {
-
- auto& accumulator = pos.state()->accumulator;
- if (!refresh && accumulator.computed_score) {
- return accumulator.score;
- }
-
- alignas(kCacheLineSize) TransformedFeatureType
- transformed_features[FeatureTransformer::kBufferSize];
- feature_transformer->Transform(pos, transformed_features, refresh);
- alignas(kCacheLineSize) char buffer[Network::kBufferSize];
- const auto output = network->Propagate(transformed_features, buffer);
-
- auto score = static_cast<Value>(output[0] / FV_SCALE);
+ // Evaluation function. Perform differential calculation.
+ Value evaluate(const Position& pos) {
- accumulator.score = score;
- accumulator.computed_score = true;
- return accumulator.score;
- }
+ // We manually align the arrays on the stack because with gcc < 9.3
+ // overaligning stack variables with alignas() doesn't work correctly.
- // Load the evaluation function file
- bool load_eval_file(const std::string& evalFile) {
+ constexpr uint64_t alignment = kCacheLineSize;
- Initialize();
- fileName = evalFile;
+#if defined(ALIGNAS_ON_STACK_VARIABLES_BROKEN)
+ TransformedFeatureType transformed_features_unaligned[
+ FeatureTransformer::kBufferSize + alignment / sizeof(TransformedFeatureType)];
+ char buffer_unaligned[Network::kBufferSize + alignment];
- std::ifstream stream(evalFile, std::ios::binary);
+ auto* transformed_features = align_ptr_up<alignment>(&transformed_features_unaligned[0]);
+ auto* buffer = align_ptr_up<alignment>(&buffer_unaligned[0]);
+#else
+ alignas(alignment)
+ TransformedFeatureType transformed_features[FeatureTransformer::kBufferSize];
+ alignas(alignment) char buffer[Network::kBufferSize];
+#endif
- const bool result = ReadParameters(stream);
+ ASSERT_ALIGNED(transformed_features, alignment);
+ ASSERT_ALIGNED(buffer, alignment);
- return result;
- }
+ feature_transformer->Transform(pos, transformed_features);
+ const auto output = network->Propagate(transformed_features, buffer);
- // Evaluation function. Perform differential calculation.
- Value evaluate(const Position& pos) {
- return ComputeScore(pos, false);
+ return static_cast<Value>(output[0] / FV_SCALE);
}
- // Evaluation function. Perform full calculation.
- Value compute_eval(const Position& pos) {
- return ComputeScore(pos, true);
- }
+ // Load eval, from a file stream or a memory stream
+ bool load_eval(std::string name, std::istream& stream) {
- // Proceed with the difference calculation if possible
- void update_eval(const Position& pos) {
- UpdateAccumulatorIfPossible(pos);
+ Initialize();
+ fileName = name;
+ return ReadParameters(stream);
}
} // namespace Eval::NNUE
projects / stockfish / blobdiff