refactor: search context encapsulation (#481)

Author: benthevining

.github/workflows/sprt_internal.yml

@@ -43,12 +43,12 @@ jobs:
     env:
       CMAKE_PRESET: gcc
       CMAKE_BUILD_PARALLEL_LEVEL: 8
-      BUILD_DIR: ${{ github.workspace }}/Builds/clang
+      BUILD_DIR: ${{ github.workspace }}/Builds/gcc
       SPRT_OUTPUT_LOG: ${{ github.workspace }}/logs/sprt/output.log
       # these directories are used for building & installing the latest
       # main, in the case that we're using main as the SPRT baseline
       TMP_ROOT: ${{ github.workspace }}/tmp-main
-      TMP_BUILD_DIR: ${{ github.workspace }}/tmp-main/Builds/clang
+      TMP_BUILD_DIR: ${{ github.workspace }}/tmp-main/Builds/gcc
       TMP_DEPLOY_DIR: ${{ github.workspace }}/tmp-main/deploy
 
     steps:

libbenbot/include/libbenbot/data-structures/TranspositionTable.hpp

@@ -104,7 +104,7 @@ class TranspositionTable final {
     TranspositionTable& operator=(TranspositionTable&& other) noexcept;
 
     /** Retrieves the stored record for the given position,
-        or nullptr if the given position isn't in the table.
+        or ``nullopt`` if the given position isn't in the table.
      */
     [[nodiscard]] auto find(const Position& pos) const -> std::optional<TTData>;
 

libbenbot/include/libbenbot/engine/Engine.hpp

@@ -26,13 +26,16 @@
 #include <libbenbot/engine/CustomCommand.hpp>
 #include <libbenbot/search/Thread.hpp>
 #include <libchess/game/Position.hpp>
-#include <libchess/uci/CommandParsing.hpp>
 #include <libchess/uci/EngineBase.hpp>
 #include <libchess/uci/Options.hpp>
 #include <span>
 #include <string>
 #include <string_view>
 
+namespace chess::uci {
+struct GoCommandOptions;
+} // namespace chess::uci
+
 namespace ben_bot {
 
 using chess::game::Position;
@@ -65,7 +68,7 @@ class [[nodiscard]] Engine final : public uci::EngineBase {
 
     void new_game(bool firstCall) override;
 
-    void set_position(const Position& pos) override { searcher.set_position(pos); }
+    void set_position(const Position& pos) override { searcher.context.set_position(pos); }
 
     void go(const uci::GoCommandOptions& opts) override;
 
@@ -122,9 +125,7 @@ class [[nodiscard]] Engine final : public uci::EngineBase {
         1, 2048, 16,
         "Sets the maximum transposition table size (in MB).",
         [this](const int sizeMB) {
-            wait();
-            searcher.context.transTable.resize(
-                static_cast<size_t>(sizeMB));
+            searcher.context.resize_transposition_table(static_cast<size_t>(sizeMB));
         }
     };
 
@@ -141,7 +142,13 @@ class [[nodiscard]] Engine final : public uci::EngineBase {
     uci::BoolOption ponder {
         "Ponder",
         false,
-        "Controls whether pondering is allowed."
+        "Controls whether pondering is allowed.",
+        [this](const bool shouldPonder) {
+            // the ponder flag is only ever turned on via the go options,
+            // but it can be turned off by disabling this UCI option
+            if (not shouldPonder)
+                searcher.context.set_pondering(false);
+        }
     };
 
     uci::IntOption threads {

libbenbot/include/libbenbot/search/Context.hpp

@@ -24,10 +24,14 @@
 #include <libbenbot/data-structures/TranspositionTable.hpp>
 #include <libbenbot/search/Callbacks.hpp>
 #include <libbenbot/search/Options.hpp>
+#include <libchess/game/Position.hpp>
+#include <optional>
 #include <utility>
 
 namespace ben_bot::search {
 
+using chess::game::Position;
+
 /** This struct encapsulates everything needed to perform a search.
     You can keep one of these alive between searches by simply updating
     the options and then calling ``search()`` again.
@@ -50,31 +54,13 @@ struct Context final {
     Context(Context&&)            = delete;
     Context& operator=(Context&&) = delete;
 
-    /** The options to use for the search.
-        This object can only be safely mutated when no search is executing.
-     */
-    Options options;
-
-    /** The transposition table used for this search.
-        This object's methods can only be safely called when no search is executing.
-     */
-    TranspositionTable transTable;
-
-    /** The callbacks used to provide results about the search. */
-    Callbacks callbacks;
-
     /** Performs a search.
         Results will be propagated via the ``callbacks`` that have been
         assigned.
 
         The search may execute for a potentially unbounded amount of time.
         The search can be interrupted by calling the ``abort()`` method while
         ``search()`` is executing.
-
-        This function accesses ``options`` and ``transTable``; these objects
-        must not be mutated while ``search()`` is executing. ``abort()``,
-        ``wait()``, ``in_progress()``, and ``reset()`` may be called while
-        ``search()`` is executing without introducing data races.
      */
     void search();
 
@@ -88,14 +74,29 @@ struct Context final {
 
     /** Clears the transposition table.
         If a search is in progress, this method blocks until it returns.
-        Invoking this method is thread-safe, even if a search was in progress.
      */
     void clear_transposition_table()
     {
         wait();
         transTable.clear();
     }
 
+    /** Resizes the transposition table.
+        If a search is in progress, this method blocks until it returns.
+     */
+    void resize_transposition_table(size_t sizeMB)
+    {
+        wait();
+        transTable.resize(sizeMB);
+    }
+
+    /** Probes the transposition table for the given position. */
+    [[nodiscard]] auto probe_transposition_table(const Position& pos) const
+        -> std::optional<TTData>
+    {
+        return transTable.find(pos);
+    }
+
     /** Returns true if a search is currently in progress. */
     [[nodiscard]] auto in_progress() const noexcept -> bool { return activeFlag.load(std::memory_order::acquire); }
 
@@ -115,13 +116,63 @@ struct Context final {
      */
     void ponder_hit() noexcept { pondering.store(false, std::memory_order::release); }
 
+    /** Sets the position to be searched by the next search.
+        If a search is in progress, this function blocks until it completes.
+     */
+    void set_position(const Position& pos)
+    {
+        wait();
+        position = pos;
+
+        // clear this so that all legal moves will be searched by default
+        options.movesToSearch.clear();
+    }
+
+    /** Sets the options to be used by the next search.
+        If a search is in progress, this function blocks until it completes.
+     */
+    void set_options(const Options& opts)
+    {
+        wait();
+        options = opts;
+    }
+
+    /** Sets the options to be used by the next search.
+        If a search is in progress, this function blocks until it completes.
+     */
+    void set_options(const chess::uci::GoCommandOptions& opts)
+    {
+        wait();
+        options = Options::from_libchess(opts, position.is_white_to_move());
+    }
+
+    /** Sets the result callbacks that will be used for the next search.
+        If a search is in progress, this function blocks until it completes.
+     */
+    void set_callbacks(Callbacks&& callbacksToUse)
+    {
+        wait();
+        callbacks = std::move(callbacksToUse);
+    }
+
+    /** Returns the current position. */
+    [[nodiscard]] auto get_position() const noexcept -> const Position& { return position; }
+
 private:
     std::atomic_bool exitFlag { false };
 
     std::atomic_bool activeFlag { false };
 
     std::atomic_bool pondering { false };
 
+    Position position;
+
+    Options options;
+
+    Callbacks callbacks;
+
+    TranspositionTable transTable;
+
     KillerMoves killerMoves;
 };
 

libbenbot/include/libbenbot/search/Options.hpp

@@ -27,7 +27,6 @@
 
 #include <chrono>
 #include <cstddef> // IWYU pragma: keep - for size_t
-#include <libchess/game/Position.hpp>
 #include <libchess/moves/MoveGen.hpp>
 #include <limits>
 #include <optional>
@@ -51,9 +50,6 @@ using std::size_t;
     @see Context
  */
 struct Options final {
-    /** The root position to be searched. */
-    chess::game::Position position;
-
     /** The maximum search depth (in plies). */
     size_t depth { std::numeric_limits<size_t>::max() };
 
@@ -81,8 +77,10 @@ struct Options final {
     /** Search for mate in this many moves. */
     std::optional<size_t> mateIn;
 
-    /** Updates the values in this options struct with the UCI "go" command options. */
-    void update_from(const chess::uci::GoCommandOptions& goOptions);
+    /** Translates the raw UCI "go" command options into this struct's fields. */
+    [[nodiscard]] static auto from_libchess(
+        const chess::uci::GoCommandOptions& goOptions,
+        bool                                isWhiteToMove) -> Options;
 };
 
 } // namespace ben_bot::search

libbenbot/include/libbenbot/search/Thread.hpp

@@ -60,22 +60,16 @@ struct Thread final {
      */
     Context context;
 
-    /** Sets the position to be searched by the next search invocation.
-        This method blocks waiting for any previously executing search to complete.
-     */
-    void set_position(const Position& pos);
-
     /** Begins searching asynchronously.
         This method returns immediately, and the actual search will be performed by
         a background thread.
      */
-    /// @{
-    void start(
-        const chess::uci::GoCommandOptions& options,
-        milliseconds                        moveOverheadTime = milliseconds { 0uz });
+    void start()
+    {
+        context.wait(); // shouldn't have been searching, but better safe than sorry
 
-    void start();
-    /// @}
+        startSearch.store(true, std::memory_order::release);
+    }
 
 private:
     void thread_func();

libbenbot/src/engine/Bench.cpp

@@ -15,7 +15,7 @@
 #include <algorithm>
 #include <cassert>
 #include <chrono>
-#include <cmath>
+#include <cmath>   // IWYU pragma: keep - for std::round()
 #include <cstddef> // IWYU pragma: keep - for size_t
 #include <expected>
 #include <filesystem>
@@ -24,6 +24,7 @@
 #include <libbenbot/Resources.hpp>
 #include <libbenbot/engine/Engine.hpp>
 #include <libbenbot/search/Callbacks.hpp>
+#include <libbenbot/search/Options.hpp>
 #include <libbenbot/search/Result.hpp>
 #include <libbenbot/search/Thread.hpp>
 #include <libchess/notation/EPD.hpp>
@@ -66,15 +67,19 @@ namespace {
             : threadNumber { threadNum }
             , outputProgress { printProgressOutput }
         {
-            thread.set_position(position.position);
+            thread.context.set_position(position.position);
+
+            search::Options options;
 
             if (const auto it = position.operations.find("depth");
                 it != position.operations.end()) {
-                thread.context.options.depth = util::strings::int_from_string(it->second, defaultDepth);
+                options.depth = util::strings::int_from_string(it->second, defaultDepth);
             } else {
-                thread.context.options.depth = defaultDepth;
+                options.depth = defaultDepth;
             }
 
+            thread.context.set_options(options);
+
             thread.start();
         }