From 1403669930c0c21a2ea31404c96b584133239456 Mon Sep 17 00:00:00 2001
From: Disservin <disservin.social@gmail.com>
Date: Sat, 27 Jan 2024 10:54:44 +0100
Subject: [PATCH] Simplify array initializations

also retire a few std::memset calls.

Passed non-regresion STC:
https://tests.stockfishchess.org/tests/view/65b8e162c865510db0276901
LLR: 2.95 (-2.94,2.94) <-1.75,0.25>
Total: 97504 W: 25294 L: 25140 D: 47070
Ptnml(1-2): 378, 11102, 25667, 11198, 407

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

No functional change
---
 src/position.cpp | 10 +++++-----
 src/search.cpp   | 40 ++++++++++++++++++++--------------------
 src/search.h     | 13 +++++++------
 3 files changed, 32 insertions(+), 31 deletions(-)

diff --git a/src/position.cpp b/src/position.cpp
index 6202381d072..c89b1eb0889 100644
--- a/src/position.cpp
+++ b/src/position.cpp
@@ -19,6 +19,7 @@
 #include "position.h"
 
 #include <algorithm>
+#include <array>
 #include <cassert>
 #include <cctype>
 #include <cstddef>
@@ -107,9 +108,8 @@ inline int H1(Key h) { return h & 0x1fff; }
 inline int H2(Key h) { return (h >> 16) & 0x1fff; }
 
 // Cuckoo tables with Zobrist hashes of valid reversible moves, and the moves themselves
-Key  cuckoo[8192];
-Move cuckooMove[8192];
-
+std::array<Key, 8192>  cuckoo;
+std::array<Move, 8192> cuckooMove;
 
 // Initializes at startup the various arrays used to compute hash keys
 void Position::init() {
@@ -130,8 +130,8 @@ void Position::init() {
     Zobrist::noPawns = rng.rand<Key>();
 
     // Prepare the cuckoo tables
-    std::memset(cuckoo, 0, sizeof(cuckoo));
-    std::memset(cuckooMove, 0, sizeof(cuckooMove));
+    cuckoo.fill(0);
+    cuckooMove.fill(Move::none());
     [[maybe_unused]] int count = 0;
     for (Piece pc : Pieces)
         for (Square s1 = SQ_A1; s1 <= SQ_H8; ++s1)
diff --git a/src/search.cpp b/src/search.cpp
index 6a464961a61..29b5c5243b3 100644
--- a/src/search.cpp
+++ b/src/search.cpp
@@ -24,7 +24,6 @@
 #include <cassert>
 #include <cmath>
 #include <cstdlib>
-#include <cstring>
 #include <initializer_list>
 #include <iostream>
 #include <utility>
@@ -212,21 +211,26 @@ void Search::Worker::start_searching() {
 // consumed, the user stops the search, or the maximum search depth is reached.
 void Search::Worker::iterative_deepening() {
 
+    SearchManager* mainThread = (thread_idx == 0 ? main_manager() : nullptr);
+
+    Move pv[MAX_PLY + 1];
+
+    Depth lastBestMoveDepth = 0;
+    Value lastBestScore     = -VALUE_INFINITE;
+    auto  lastBestPV        = std::vector{Move::none()};
+
+    Value  alpha, beta;
+    Value  bestValue     = -VALUE_INFINITE;
+    Color  us            = rootPos.side_to_move();
+    double timeReduction = 1, totBestMoveChanges = 0;
+    int    delta, iterIdx                        = 0;
+
     // Allocate stack with extra size to allow access from (ss - 7) to (ss + 2):
     // (ss - 7) is needed for update_continuation_histories(ss - 1) which accesses (ss - 6),
     // (ss + 2) is needed for initialization of cutOffCnt and killers.
-    Stack             stack[MAX_PLY + 10], *ss = stack + 7;
-    Move              pv[MAX_PLY + 1];
-    Value             alpha, beta;
-    Value             lastBestScore     = -VALUE_INFINITE;
-    std::vector<Move> lastBestPV        = {Move::none()};
-    Depth             lastBestMoveDepth = 0;
-    SearchManager*    mainThread        = (thread_idx == 0 ? main_manager() : nullptr);
-    double            timeReduction = 1, totBestMoveChanges = 0;
-    Color             us = rootPos.side_to_move();
-    int               delta, iterIdx = 0;
-
-    std::memset(ss - 7, 0, 10 * sizeof(Stack));
+    Stack  stack[MAX_PLY + 10] = {};
+    Stack* ss                  = stack + 7;
+
     for (int i = 7; i > 0; --i)
     {
         (ss - i)->continuationHistory =
@@ -239,16 +243,12 @@ void Search::Worker::iterative_deepening() {
 
     ss->pv = pv;
 
-    Value bestValue = -VALUE_INFINITE;
-
     if (mainThread)
     {
         if (mainThread->bestPreviousScore == VALUE_INFINITE)
-            for (int i = 0; i < 4; ++i)
-                mainThread->iterValue[i] = VALUE_ZERO;
+            mainThread->iterValue.fill(VALUE_ZERO);
         else
-            for (int i = 0; i < 4; ++i)
-                mainThread->iterValue[i] = mainThread->bestPreviousScore;
+            mainThread->iterValue.fill(mainThread->bestPreviousScore);
     }
 
     size_t multiPV = size_t(options["MultiPV"]);
@@ -489,7 +489,7 @@ void Search::Worker::clear() {
                     h->fill(-71);
 
 
-    for (int i = 1; i < MAX_MOVES; ++i)
+    for (size_t i = 1; i < reductions.size(); ++i)
         reductions[i] = int((20.37 + std::log(size_t(options["Threads"])) / 2) * std::log(i));
 }
 
diff --git a/src/search.h b/src/search.h
index 3a099c5dddf..b4a65d8e6f6 100644
--- a/src/search.h
+++ b/src/search.h
@@ -19,6 +19,7 @@
 #ifndef SEARCH_H_INCLUDED
 #define SEARCH_H_INCLUDED
 
+#include <array>
 #include <atomic>
 #include <cassert>
 #include <cstddef>
@@ -153,11 +154,11 @@ class SearchManager: public ISearchManager {
     int                       callsCnt;
     std::atomic_bool          ponder;
 
-    double previousTimeReduction;
-    Value  bestPreviousScore;
-    Value  bestPreviousAverageScore;
-    Value  iterValue[4];
-    bool   stopOnPonderhit;
+    std::array<Value, 4> iterValue;
+    double               previousTimeReduction;
+    Value                bestPreviousScore;
+    Value                bestPreviousAverageScore;
+    bool                 stopOnPonderhit;
 
     size_t id;
 };
@@ -233,7 +234,7 @@ class Worker {
     size_t thread_idx;
 
     // Reductions lookup table initialized at startup
-    int reductions[MAX_MOVES];  // [depth or moveNumber]
+    std::array<int, MAX_MOVES> reductions;  // [depth or moveNumber]
 
     // The main thread has a SearchManager, the others have a NullSearchManager
     std::unique_ptr<ISearchManager> manager;