jirayu_sri/stockfish
1
0
Fork 0
mirror of https://github.com/official-stockfish/Stockfish.git synced 2026-07-22 12:47:08 +00:00
Code Issues Packages Projects Releases Wiki Activity

Retire Acc Pointer

Browse Source 
Since @xu-shawn's refactor the acc pointer has become a bit unnecessary,
we can achieve the same behavior by using the dimension size to get the
right accumulator from the `AccumulatorState`. I think the acc pointer
has become a bit of a burden required to be passed through multiple
different functions together with the necessary templating required.

Passed Non-Regression STC:
https://tests.stockfishchess.org/tests/view/67ed600f31d7cf8afdc45183
LLR: 2.94 (-2.94,2.94) <-1.75,0.25>
Total: 279744 W: 72037 L: 72082 D: 135625
Ptnml(0-2): 673, 29918, 78767, 29809, 705

closes https://github.com/official-stockfish/Stockfish/pull/5942

No functional change
This commit is contained in:
Disservin
2025-04-18 13:54:09 +02:00
parent d7c04a9429
commit 7beff18ef0
5 changed files with 135 additions and 145 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/nnue/network.cpp
+10 -12
View File
@@ -219,13 +219,13 @@ Network<Arch, Transformer>::evaluate(const Position& pos
#if defined(ALIGNAS_ON_STACK_VARIABLES_BROKEN) #if defined(ALIGNAS_ON_STACK_VARIABLES_BROKEN)
TransformedFeatureType TransformedFeatureType
transformedFeaturesUnaligned[FeatureTransformer<FTDimensions, nullptr>::BufferSize transformedFeaturesUnaligned[FeatureTransformer<FTDimensions>::BufferSize
+ alignment / sizeof(TransformedFeatureType)]; + alignment / sizeof(TransformedFeatureType)];
auto* transformedFeatures = align_ptr_up<alignment>(&transformedFeaturesUnaligned[0]); auto* transformedFeatures = align_ptr_up<alignment>(&transformedFeaturesUnaligned[0]);
#else #else
alignas(alignment) TransformedFeatureType alignas(alignment)
transformedFeatures[FeatureTransformer<FTDimensions, nullptr>::BufferSize]; TransformedFeatureType transformedFeatures[FeatureTransformer<FTDimensions>::BufferSize];
#endif #endif
ASSERT_ALIGNED(transformedFeatures, alignment); ASSERT_ALIGNED(transformedFeatures, alignment);
@@ -290,13 +290,13 @@ Network<Arch, Transformer>::trace_evaluate(const Position&
#if defined(ALIGNAS_ON_STACK_VARIABLES_BROKEN) #if defined(ALIGNAS_ON_STACK_VARIABLES_BROKEN)
TransformedFeatureType TransformedFeatureType
transformedFeaturesUnaligned[FeatureTransformer<FTDimensions, nullptr>::BufferSize transformedFeaturesUnaligned[FeatureTransformer<FTDimensions>::BufferSize
+ alignment / sizeof(TransformedFeatureType)]; + alignment / sizeof(TransformedFeatureType)];
auto* transformedFeatures = align_ptr_up<alignment>(&transformedFeaturesUnaligned[0]); auto* transformedFeatures = align_ptr_up<alignment>(&transformedFeaturesUnaligned[0]);
#else #else
alignas(alignment) TransformedFeatureType alignas(alignment)
transformedFeatures[FeatureTransformer<FTDimensions, nullptr>::BufferSize]; TransformedFeatureType transformedFeatures[FeatureTransformer<FTDimensions>::BufferSize];
#endif #endif
ASSERT_ALIGNED(transformedFeatures, alignment); ASSERT_ALIGNED(transformedFeatures, alignment);
@@ -452,12 +452,10 @@ bool Network<Arch, Transformer>::write_parameters(std::ostream& stream,
// Explicit template instantiations // Explicit template instantiations
template class Network< template class Network<NetworkArchitecture<TransformedFeatureDimensionsBig, L2Big, L3Big>,
NetworkArchitecture<TransformedFeatureDimensionsBig, L2Big, L3Big>, FeatureTransformer<TransformedFeatureDimensionsBig>>;
FeatureTransformer<TransformedFeatureDimensionsBig, &AccumulatorState::accumulatorBig>>;
template class Network< template class Network<NetworkArchitecture<TransformedFeatureDimensionsSmall, L2Small, L3Small>,
NetworkArchitecture<TransformedFeatureDimensionsSmall, L2Small, L3Small>, FeatureTransformer<TransformedFeatureDimensionsSmall>>;
FeatureTransformer<TransformedFeatureDimensionsSmall, &AccumulatorState::accumulatorSmall>>;
} // namespace Stockfish::Eval::NNUE } // namespace Stockfish::Eval::NNUE
src/nnue/network.h
+2 -4
View File
@@ -110,13 +110,11 @@ class Network {
}; };
// Definitions of the network types // Definitions of the network types
using SmallFeatureTransformer = using SmallFeatureTransformer = FeatureTransformer<TransformedFeatureDimensionsSmall>;
FeatureTransformer<TransformedFeatureDimensionsSmall, &AccumulatorState::accumulatorSmall>;
using SmallNetworkArchitecture = using SmallNetworkArchitecture =
NetworkArchitecture<TransformedFeatureDimensionsSmall, L2Small, L3Small>; NetworkArchitecture<TransformedFeatureDimensionsSmall, L2Small, L3Small>;
using BigFeatureTransformer = using BigFeatureTransformer = FeatureTransformer<TransformedFeatureDimensionsBig>;
FeatureTransformer<TransformedFeatureDimensionsBig, &AccumulatorState::accumulatorBig>;
using BigNetworkArchitecture = NetworkArchitecture<TransformedFeatureDimensionsBig, L2Big, L3Big>; using BigNetworkArchitecture = NetworkArchitecture<TransformedFeatureDimensionsBig, L2Big, L3Big>;
using NetworkBig = Network<BigNetworkArchitecture, BigFeatureTransformer>; using NetworkBig = Network<BigNetworkArchitecture, BigFeatureTransformer>;
src/nnue/nnue_accumulator.cpp
+49 -65
View File
@@ -50,17 +50,15 @@ namespace {
template<Color Perspective, template<Color Perspective,
IncUpdateDirection Direction = FORWARD, IncUpdateDirection Direction = FORWARD,
IndexType TransformedFeatureDimensions, IndexType TransformedFeatureDimensions>
Accumulator<TransformedFeatureDimensions> AccumulatorState::*accPtr>
void update_accumulator_incremental( void update_accumulator_incremental(
const FeatureTransformer<TransformedFeatureDimensions, accPtr>& featureTransformer, const FeatureTransformer<TransformedFeatureDimensions>& featureTransformer,
const Square ksq, const Square ksq,
AccumulatorState& target_state, AccumulatorState& target_state,
const AccumulatorState& computed); const AccumulatorState& computed);
template<Color Perspective, IndexType Dimensions, Accumulator<Dimensions> AccumulatorState::*accPtr> template<Color Perspective, IndexType Dimensions>
void update_accumulator_refresh_cache( void update_accumulator_refresh_cache(const FeatureTransformer<Dimensions>& featureTransformer,
const FeatureTransformer<Dimensions, accPtr>& featureTransformer,
const Position& pos, const Position& pos,
AccumulatorState& accumulatorState, AccumulatorState& accumulatorState,
AccumulatorCaches::Cache<Dimensions>& cache); AccumulatorCaches::Cache<Dimensions>& cache);
@@ -86,18 +84,14 @@ void AccumulatorStack::reset(const Position& rootPos,
AccumulatorCaches& caches) noexcept { AccumulatorCaches& caches) noexcept {
m_current_idx = 1; m_current_idx = 1;
update_accumulator_refresh_cache<WHITE, TransformedFeatureDimensionsBig, update_accumulator_refresh_cache<WHITE, TransformedFeatureDimensionsBig>(
&AccumulatorState::accumulatorBig>(
*networks.big.featureTransformer, rootPos, m_accumulators[0], caches.big); *networks.big.featureTransformer, rootPos, m_accumulators[0], caches.big);
update_accumulator_refresh_cache<BLACK, TransformedFeatureDimensionsBig, update_accumulator_refresh_cache<BLACK, TransformedFeatureDimensionsBig>(
&AccumulatorState::accumulatorBig>(
*networks.big.featureTransformer, rootPos, m_accumulators[0], caches.big); *networks.big.featureTransformer, rootPos, m_accumulators[0], caches.big);
update_accumulator_refresh_cache<WHITE, TransformedFeatureDimensionsSmall, update_accumulator_refresh_cache<WHITE, TransformedFeatureDimensionsSmall>(
&AccumulatorState::accumulatorSmall>(
*networks.small.featureTransformer, rootPos, m_accumulators[0], caches.small); *networks.small.featureTransformer, rootPos, m_accumulators[0], caches.small);
update_accumulator_refresh_cache<BLACK, TransformedFeatureDimensionsSmall, update_accumulator_refresh_cache<BLACK, TransformedFeatureDimensionsSmall>(
&AccumulatorState::accumulatorSmall>(
*networks.small.featureTransformer, rootPos, m_accumulators[0], caches.small); *networks.small.featureTransformer, rootPos, m_accumulators[0], caches.small);
} }
@@ -112,24 +106,23 @@ void AccumulatorStack::pop() noexcept {
m_current_idx--; m_current_idx--;
} }
template<IndexType Dimensions, Accumulator<Dimensions> AccumulatorState::*accPtr> template<IndexType Dimensions>
void AccumulatorStack::evaluate(const Position& pos, void AccumulatorStack::evaluate(const Position& pos,
const FeatureTransformer<Dimensions, accPtr>& featureTransformer, const FeatureTransformer<Dimensions>& featureTransformer,
AccumulatorCaches::Cache<Dimensions>& cache) noexcept { AccumulatorCaches::Cache<Dimensions>& cache) noexcept {
evaluate_side<WHITE>(pos, featureTransformer, cache); evaluate_side<WHITE>(pos, featureTransformer, cache);
evaluate_side<BLACK>(pos, featureTransformer, cache); evaluate_side<BLACK>(pos, featureTransformer, cache);
} }
template<Color Perspective, IndexType Dimensions, Accumulator<Dimensions> AccumulatorState::*accPtr> template<Color Perspective, IndexType Dimensions>
void AccumulatorStack::evaluate_side( void AccumulatorStack::evaluate_side(const Position& pos,
const Position& pos, const FeatureTransformer<Dimensions>& featureTransformer,
const FeatureTransformer<Dimensions, accPtr>& featureTransformer,
AccumulatorCaches::Cache<Dimensions>& cache) noexcept { AccumulatorCaches::Cache<Dimensions>& cache) noexcept {
const auto last_usable_accum = find_last_usable_accumulator<Perspective, Dimensions, accPtr>(); const auto last_usable_accum = find_last_usable_accumulator<Perspective, Dimensions>();
if ((m_accumulators[last_usable_accum].*accPtr).computed[Perspective]) if ((m_accumulators[last_usable_accum].template acc<Dimensions>()).computed[Perspective])
forward_update_incremental<Perspective>(pos, featureTransformer, last_usable_accum); forward_update_incremental<Perspective>(pos, featureTransformer, last_usable_accum);
else else
@@ -141,12 +134,12 @@ void AccumulatorStack::evaluate_side(
// Find the earliest usable accumulator, this can either be a computed accumulator or the accumulator // Find the earliest usable accumulator, this can either be a computed accumulator or the accumulator
// state just before a change that requires full refresh. // state just before a change that requires full refresh.
template<Color Perspective, IndexType Dimensions, Accumulator<Dimensions> AccumulatorState::*accPtr> template<Color Perspective, IndexType Dimensions>
std::size_t AccumulatorStack::find_last_usable_accumulator() const noexcept { std::size_t AccumulatorStack::find_last_usable_accumulator() const noexcept {
for (std::size_t curr_idx = m_current_idx - 1; curr_idx > 0; curr_idx--) for (std::size_t curr_idx = m_current_idx - 1; curr_idx > 0; curr_idx--)
{ {
if ((m_accumulators[curr_idx].*accPtr).computed[Perspective]) if ((m_accumulators[curr_idx].template acc<Dimensions>()).computed[Perspective])
return curr_idx; return curr_idx;
if (FeatureSet::requires_refresh(m_accumulators[curr_idx].dirtyPiece, Perspective)) if (FeatureSet::requires_refresh(m_accumulators[curr_idx].dirtyPiece, Perspective))
@@ -156,14 +149,14 @@ std::size_t AccumulatorStack::find_last_usable_accumulator() const noexcept {
return 0; return 0;
} }
template<Color Perspective, IndexType Dimensions, Accumulator<Dimensions> AccumulatorState::*accPtr> template<Color Perspective, IndexType Dimensions>
void AccumulatorStack::forward_update_incremental( void AccumulatorStack::forward_update_incremental(
const Position& pos, const Position& pos,
const FeatureTransformer<Dimensions, accPtr>& featureTransformer, const FeatureTransformer<Dimensions>& featureTransformer,
const std::size_t begin) noexcept { const std::size_t begin) noexcept {
assert(begin < m_accumulators.size()); assert(begin < m_accumulators.size());
assert((m_accumulators[begin].*accPtr).computed[Perspective]); assert((m_accumulators[begin].acc<Dimensions>()).computed[Perspective]);
const Square ksq = pos.square<KING>(Perspective); const Square ksq = pos.square<KING>(Perspective);
@@ -171,18 +164,18 @@ void AccumulatorStack::forward_update_incremental(
update_accumulator_incremental<Perspective>(featureTransformer, ksq, m_accumulators[next], update_accumulator_incremental<Perspective>(featureTransformer, ksq, m_accumulators[next],
m_accumulators[next - 1]); m_accumulators[next - 1]);
assert((latest().*accPtr).computed[Perspective]); assert((latest().acc<Dimensions>()).computed[Perspective]);
} }
template<Color Perspective, IndexType Dimensions, Accumulator<Dimensions> AccumulatorState::*accPtr> template<Color Perspective, IndexType Dimensions>
void AccumulatorStack::backward_update_incremental( void AccumulatorStack::backward_update_incremental(
const Position& pos, const Position& pos,
const FeatureTransformer<Dimensions, accPtr>& featureTransformer, const FeatureTransformer<Dimensions>& featureTransformer,
const std::size_t end) noexcept { const std::size_t end) noexcept {
assert(end < m_accumulators.size()); assert(end < m_accumulators.size());
assert(end < m_current_idx); assert(end < m_current_idx);
assert((latest().*accPtr).computed[Perspective]); assert((latest().acc<Dimensions>()).computed[Perspective]);
const Square ksq = pos.square<KING>(Perspective); const Square ksq = pos.square<KING>(Perspective);
@@ -190,21 +183,17 @@ void AccumulatorStack::backward_update_incremental(
update_accumulator_incremental<Perspective, BACKWARD>( update_accumulator_incremental<Perspective, BACKWARD>(
featureTransformer, ksq, m_accumulators[next], m_accumulators[next + 1]); featureTransformer, ksq, m_accumulators[next], m_accumulators[next + 1]);
assert((m_accumulators[end].*accPtr).computed[Perspective]); assert((m_accumulators[end].acc<Dimensions>()).computed[Perspective]);
} }
// Explicit template instantiations // Explicit template instantiations
template void template void AccumulatorStack::evaluate<TransformedFeatureDimensionsBig>(
AccumulatorStack::evaluate<TransformedFeatureDimensionsBig, &AccumulatorState::accumulatorBig>(
const Position& pos, const Position& pos,
const FeatureTransformer<TransformedFeatureDimensionsBig, &AccumulatorState::accumulatorBig>& const FeatureTransformer<TransformedFeatureDimensionsBig>& featureTransformer,
featureTransformer,
AccumulatorCaches::Cache<TransformedFeatureDimensionsBig>& cache) noexcept; AccumulatorCaches::Cache<TransformedFeatureDimensionsBig>& cache) noexcept;
template void template void AccumulatorStack::evaluate<TransformedFeatureDimensionsSmall>(
AccumulatorStack::evaluate<TransformedFeatureDimensionsSmall, &AccumulatorState::accumulatorSmall>(
const Position& pos, const Position& pos,
const FeatureTransformer<TransformedFeatureDimensionsSmall, &AccumulatorState::accumulatorSmall>& const FeatureTransformer<TransformedFeatureDimensionsSmall>& featureTransformer,
featureTransformer,
AccumulatorCaches::Cache<TransformedFeatureDimensionsSmall>& cache) noexcept; AccumulatorCaches::Cache<TransformedFeatureDimensionsSmall>& cache) noexcept;
@@ -227,13 +216,13 @@ void fused_row_reduce(const ElementType* in, ElementType* out, const Ts* const..
vecIn[i], reinterpret_cast<const typename VectorWrapper::type*>(rows)[i]...); vecIn[i], reinterpret_cast<const typename VectorWrapper::type*>(rows)[i]...);
} }
template<Color Perspective, IndexType Dimensions, Accumulator<Dimensions> AccumulatorState::*accPtr> template<Color Perspective, IndexType Dimensions>
struct AccumulatorUpdateContext { struct AccumulatorUpdateContext {
const FeatureTransformer<Dimensions, accPtr>& featureTransformer; const FeatureTransformer<Dimensions>& featureTransformer;
const AccumulatorState& from; const AccumulatorState& from;
AccumulatorState& to; AccumulatorState& to;
AccumulatorUpdateContext(const FeatureTransformer<Dimensions, accPtr>& ft, AccumulatorUpdateContext(const FeatureTransformer<Dimensions>& ft,
const AccumulatorState& accF, const AccumulatorState& accF,
AccumulatorState& accT) noexcept : AccumulatorState& accT) noexcept :
featureTransformer{ft}, featureTransformer{ft},
@@ -252,31 +241,27 @@ struct AccumulatorUpdateContext {
return &featureTransformer.psqtWeights[index * PSQTBuckets]; return &featureTransformer.psqtWeights[index * PSQTBuckets];
}; };
fused_row_reduce<Vec16Wrapper, Dimensions, ops...>((from.*accPtr).accumulation[Perspective], fused_row_reduce<Vec16Wrapper, Dimensions, ops...>(
(to.*accPtr).accumulation[Perspective], (from.acc<Dimensions>()).accumulation[Perspective],
to_weight_vector(indices)...); (to.acc<Dimensions>()).accumulation[Perspective], to_weight_vector(indices)...);
fused_row_reduce<Vec32Wrapper, PSQTBuckets, ops...>( fused_row_reduce<Vec32Wrapper, PSQTBuckets, ops...>(
(from.*accPtr).psqtAccumulation[Perspective], (to.*accPtr).psqtAccumulation[Perspective], (from.acc<Dimensions>()).psqtAccumulation[Perspective],
to_psqt_weight_vector(indices)...); (to.acc<Dimensions>()).psqtAccumulation[Perspective], to_psqt_weight_vector(indices)...);
} }
}; };
template<Color Perspective, IndexType Dimensions, Accumulator<Dimensions> AccumulatorState::*accPtr> template<Color Perspective, IndexType Dimensions>
auto make_accumulator_update_context( auto make_accumulator_update_context(const FeatureTransformer<Dimensions>& featureTransformer,
const FeatureTransformer<Dimensions, accPtr>& featureTransformer,
const AccumulatorState& accumulatorFrom, const AccumulatorState& accumulatorFrom,
AccumulatorState& accumulatorTo) noexcept { AccumulatorState& accumulatorTo) noexcept {
return AccumulatorUpdateContext<Perspective, Dimensions, accPtr>{ return AccumulatorUpdateContext<Perspective, Dimensions>{featureTransformer, accumulatorFrom,
featureTransformer, accumulatorFrom, accumulatorTo}; accumulatorTo};
} }
template<Color Perspective, template<Color Perspective, IncUpdateDirection Direction, IndexType TransformedFeatureDimensions>
IncUpdateDirection Direction,
IndexType TransformedFeatureDimensions,
Accumulator<TransformedFeatureDimensions> AccumulatorState::*accPtr>
void update_accumulator_incremental( void update_accumulator_incremental(
const FeatureTransformer<TransformedFeatureDimensions, accPtr>& featureTransformer, const FeatureTransformer<TransformedFeatureDimensions>& featureTransformer,
const Square ksq, const Square ksq,
AccumulatorState& target_state, AccumulatorState& target_state,
const AccumulatorState& computed) { const AccumulatorState& computed) {
@@ -285,8 +270,8 @@ void update_accumulator_incremental(
assert(Forward != Backward); assert(Forward != Backward);
assert((computed.*accPtr).computed[Perspective]); assert((computed.acc<TransformedFeatureDimensions>()).computed[Perspective]);
assert(!(target_state.*accPtr).computed[Perspective]); assert(!(target_state.acc<TransformedFeatureDimensions>()).computed[Perspective]);
// The size must be enough to contain the largest possible update. // The size must be enough to contain the largest possible update.
// That might depend on the feature set and generally relies on the // That might depend on the feature set and generally relies on the
@@ -340,12 +325,11 @@ void update_accumulator_incremental(
removed[1]); removed[1]);
} }
(target_state.*accPtr).computed[Perspective] = true; (target_state.acc<TransformedFeatureDimensions>()).computed[Perspective] = true;
} }
template<Color Perspective, IndexType Dimensions, Accumulator<Dimensions> AccumulatorState::*accPtr> template<Color Perspective, IndexType Dimensions>
void update_accumulator_refresh_cache( void update_accumulator_refresh_cache(const FeatureTransformer<Dimensions>& featureTransformer,
const FeatureTransformer<Dimensions, accPtr>& featureTransformer,
const Position& pos, const Position& pos,
AccumulatorState& accumulatorState, AccumulatorState& accumulatorState,
AccumulatorCaches::Cache<Dimensions>& cache) { AccumulatorCaches::Cache<Dimensions>& cache) {
@@ -378,7 +362,7 @@ void update_accumulator_refresh_cache(
} }
} }
auto& accumulator = accumulatorState.*accPtr; auto& accumulator = accumulatorState.acc<Dimensions>();
accumulator.computed[Perspective] = true; accumulator.computed[Perspective] = true;
#ifdef VECTOR #ifdef VECTOR
src/nnue/nnue_accumulator.h
+36 -25
View File
@@ -46,10 +46,7 @@ struct Networks;
template<IndexType Size> template<IndexType Size>
struct alignas(CacheLineSize) Accumulator; struct alignas(CacheLineSize) Accumulator;
struct AccumulatorState; template<IndexType TransformedFeatureDimensions>
template<IndexType TransformedFeatureDimensions,
Accumulator<TransformedFeatureDimensions> AccumulatorState::*accPtr>
class FeatureTransformer; class FeatureTransformer;
// Class that holds the result of affine transformation of input features // Class that holds the result of affine transformation of input features
@@ -121,6 +118,30 @@ struct AccumulatorState {
Accumulator<TransformedFeatureDimensionsSmall> accumulatorSmall; Accumulator<TransformedFeatureDimensionsSmall> accumulatorSmall;
DirtyPiece dirtyPiece; DirtyPiece dirtyPiece;
template<IndexType Size>
auto& acc() noexcept {
static_assert(Size == TransformedFeatureDimensionsBig
|| Size == TransformedFeatureDimensionsSmall,
"Invalid size for accumulator");
if constexpr (Size == TransformedFeatureDimensionsBig)
return accumulatorBig;
else if constexpr (Size == TransformedFeatureDimensionsSmall)
return accumulatorSmall;
}
template<IndexType Size>
const auto& acc() const noexcept {
static_assert(Size == TransformedFeatureDimensionsBig
|| Size == TransformedFeatureDimensionsSmall,
"Invalid size for accumulator");
if constexpr (Size == TransformedFeatureDimensionsBig)
return accumulatorBig;
else if constexpr (Size == TransformedFeatureDimensionsSmall)
return accumulatorSmall;
}
void reset(const DirtyPiece& dp) noexcept; void reset(const DirtyPiece& dp) noexcept;
}; };
@@ -138,40 +159,30 @@ class AccumulatorStack {
void push(const DirtyPiece& dirtyPiece) noexcept; void push(const DirtyPiece& dirtyPiece) noexcept;
void pop() noexcept; void pop() noexcept;
template<IndexType Dimensions, Accumulator<Dimensions> AccumulatorState::*accPtr> template<IndexType Dimensions>
void evaluate(const Position& pos, void evaluate(const Position& pos,
const FeatureTransformer<Dimensions, accPtr>& featureTransformer, const FeatureTransformer<Dimensions>& featureTransformer,
AccumulatorCaches::Cache<Dimensions>& cache) noexcept; AccumulatorCaches::Cache<Dimensions>& cache) noexcept;
private: private:
[[nodiscard]] AccumulatorState& mut_latest() noexcept; [[nodiscard]] AccumulatorState& mut_latest() noexcept;
template<Color Perspective, template<Color Perspective, IndexType Dimensions>
IndexType Dimensions,
Accumulator<Dimensions> AccumulatorState::*accPtr>
void evaluate_side(const Position& pos, void evaluate_side(const Position& pos,
const FeatureTransformer<Dimensions, accPtr>& featureTransformer, const FeatureTransformer<Dimensions>& featureTransformer,
AccumulatorCaches::Cache<Dimensions>& cache) noexcept; AccumulatorCaches::Cache<Dimensions>& cache) noexcept;
template<Color Perspective, template<Color Perspective, IndexType Dimensions>
IndexType Dimensions,
Accumulator<Dimensions> AccumulatorState::*accPtr>
[[nodiscard]] std::size_t find_last_usable_accumulator() const noexcept; [[nodiscard]] std::size_t find_last_usable_accumulator() const noexcept;
template<Color Perspective, template<Color Perspective, IndexType Dimensions>
IndexType Dimensions, void forward_update_incremental(const Position& pos,
Accumulator<Dimensions> AccumulatorState::*accPtr> const FeatureTransformer<Dimensions>& featureTransformer,
void
forward_update_incremental(const Position& pos,
const FeatureTransformer<Dimensions, accPtr>& featureTransformer,
const std::size_t begin) noexcept; const std::size_t begin) noexcept;
template<Color Perspective, template<Color Perspective, IndexType Dimensions>
IndexType Dimensions, void backward_update_incremental(const Position& pos,
Accumulator<Dimensions> AccumulatorState::*accPtr> const FeatureTransformer<Dimensions>& featureTransformer,
void
backward_update_incremental(const Position& pos,
const FeatureTransformer<Dimensions, accPtr>& featureTransformer,
const std::size_t end) noexcept; const std::size_t end) noexcept;
std::vector<AccumulatorState> m_accumulators; std::vector<AccumulatorState> m_accumulators;
src/nnue/nnue_feature_transformer.h
+3 -4
View File
@@ -294,8 +294,7 @@ class SIMDTiling {
// Input feature converter // Input feature converter
template<IndexType TransformedFeatureDimensions, template<IndexType TransformedFeatureDimensions>
Accumulator<TransformedFeatureDimensions> AccumulatorState::*accPtr>
class FeatureTransformer { class FeatureTransformer {
// Number of output dimensions for one side // Number of output dimensions for one side
@@ -400,12 +399,12 @@ class FeatureTransformer {
const auto& accumulatorState = accumulatorStack.latest(); const auto& accumulatorState = accumulatorStack.latest();
const Color perspectives[2] = {pos.side_to_move(), ~pos.side_to_move()}; const Color perspectives[2] = {pos.side_to_move(), ~pos.side_to_move()};
const auto& psqtAccumulation = (accumulatorState.*accPtr).psqtAccumulation; const auto& psqtAccumulation = (accumulatorState.acc<HalfDimensions>()).psqtAccumulation;
const auto psqt = const auto psqt =
(psqtAccumulation[perspectives[0]][bucket] - psqtAccumulation[perspectives[1]][bucket]) (psqtAccumulation[perspectives[0]][bucket] - psqtAccumulation[perspectives[1]][bucket])
/ 2; / 2;
const auto& accumulation = (accumulatorState.*accPtr).accumulation; const auto& accumulation = (accumulatorState.acc<HalfDimensions>()).accumulation;
for (IndexType p = 0; p < 2; ++p) for (IndexType p = 0; p < 2; ++p)
{ {