refactor: standard UCI options into engine base class

Author: benthevining

libbenbot/include/libbenbot/engine/Engine.hpp

@@ -20,7 +20,6 @@
 #pragma once
 
 #include <array>
-#include <atomic>
 #include <filesystem>
 #include <functional>
 #include <libbenbot/search/Thread.hpp>
@@ -80,7 +79,10 @@ class [[nodiscard]] Engine final : public uci::EngineBase {
 
     auto is_searching() const noexcept -> bool override { return searcher.context.in_progress(); }
 
-    [[nodiscard]] auto get_options() -> std::span<uci::Option*> override { return options; }
+    [[nodiscard]] auto get_custom_uci_options() noexcept -> OptionList override
+    {
+        return options;
+    }
 
     [[nodiscard]] auto get_custom_uci_commands() const noexcept -> CommandList override
     {
@@ -112,41 +114,29 @@ class [[nodiscard]] Engine final : public uci::EngineBase {
 
     [[nodiscard]] static auto create_move_format_option() -> uci::ComboOption;
 
+    void resize_transposition_table(const size_t sizeMB) override
+    {
+        searcher.context.resize_transposition_table(sizeMB);
+    }
+
+    void set_ponder(const bool shouldPonder) override
+    {
+        // 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);
+    }
+
     search::Thread searcher;
 
     /* ----- UCI options ----- */
 
-    uci::IntOption ttSize {
-        "Hash",
-        1, 2048, 16,
-        "Sets the maximum transposition table size (in MB).",
-        [this](const int sizeMB) {
-            searcher.context.resize_transposition_table(static_cast<size_t>(sizeMB));
-        }
-    };
-
     uci::Action clearTT {
         "Clear Hash",
         [this] { searcher.context.clear_transposition_table(); },
         "Press to clear the transposition table."
     };
 
-    // The engine doesn't start pondering on its own without explicitly being told to
-    // via another go command; this option is needed to inform the GUI that the engine
-    // supports pondering, and also gives the engine the opportunity to adjust its time
-    // management algorithm when pondering is enabled.
-    uci::BoolOption ponder {
-        "Ponder",
-        false,
-        "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 {
         "Threads", 1, 1, 1,
         "Number of searcher threads (currently a dummy)."
@@ -179,8 +169,8 @@ class [[nodiscard]] Engine final : public uci::EngineBase {
         [this](const bool sanitize) { set_sanitize_positions(sanitize); }
     };
 
-    std::array<uci::Option*, 9uz> options {
-        &ttSize, &clearTT, &ponder, &threads, &moveOverhead, &logFile, &prettyPrintMode, &moveFormat, &sanitizePositions
+    std::array<uci::Option*, 7uz> options {
+        &clearTT, &threads, &moveOverhead, &logFile, &prettyPrintMode, &moveFormat, &sanitizePositions
     };
 
     std::array<EngineCommand, 10uz> customCommands {

libbenbot/src/engine/Engine.cpp

@@ -13,7 +13,6 @@
  */
 
 #include <algorithm>
-#include <atomic>
 #include <chrono>
 #include <cstddef> // IWYU pragma: keep - for size_t
 #include <filesystem>
@@ -39,7 +38,6 @@
 namespace ben_bot {
 
 using std::filesystem::path;
-using std::memory_order_relaxed;
 using std::size_t;
 using uci::printing::info_string;
 
@@ -103,7 +101,7 @@ void Engine::go(const uci::GoCommandOptions& opts)
     searcher.context.set_options(newOpts);
 
     searcher.context.set_pondering(
-        opts.ponderMode and ponder.get_value());
+        opts.ponderMode and opt_Ponder.get_value());
 
     searcher.start();
 }

libchess/include/libchess/uci/EngineBase.hpp

@@ -21,8 +21,10 @@
 
 #include <array>
 #include <atomic>
+#include <cassert>
 #include <functional>
 #include <libchess/uci/CommandParsing.hpp>
+#include <libchess/uci/Options.hpp>
 #include <span>
 #include <string>
 #include <string_view>
@@ -37,8 +39,6 @@ namespace chess::uci {
 using game::Position;
 using std::string_view;
 
-struct Option;
-
 /** A UCI command that the engine can respond to.
     @ingroup uci
  */
@@ -75,8 +75,6 @@ struct EngineCommand final {
     }
 };
 
-using std::memory_order_relaxed;
-
 /** A base class for UCI @cite Meyer-Kahlen_2006 chess engines.
 
     This class provides handling of UCI command parsing, so that
@@ -109,9 +107,6 @@ struct EngineBase {
     /** This must return the name of the engine's author. */
     [[nodiscard]] virtual auto get_author() const -> string_view = 0;
 
-    /** This must return the list of all options the engine supports. */
-    [[nodiscard]] virtual auto get_options() -> std::span<Option*> { return { }; }
-
     /** This function will be called when the "isready" command is received,
         and may block while waiting for background tasks to complete. This
         function should be thread-safe.
@@ -187,16 +182,31 @@ struct EngineBase {
         return { };
     }
 
+    /** Typedef for a view of a list of engine options. */
+    using OptionList = std::span<Option*>;
+
+    /** Subclasses should overload this to return their custom UCI options. */
+    [[nodiscard]] virtual auto get_custom_uci_options() noexcept -> OptionList
+    {
+        return { };
+    }
+
+    /** Returns the engine's list of supported standard UCI commands. */
+    [[nodiscard]] auto get_standard_uci_options() noexcept -> OptionList
+    {
+        return standardUCIOptions;
+    }
+
     /** Returns true if the engine's debugging mode is active. */
     [[nodiscard]] auto is_debug_mode() const noexcept -> bool
     {
-        return debugMode.load(memory_order_relaxed);
+        return debugMode.load(std::memory_order_relaxed);
     }
 
     /** Sets the engine's debugging mode. */
     void set_debug_mode(const bool shouldDebug) noexcept
     {
-        debugMode.store(shouldDebug, memory_order_relaxed);
+        debugMode.store(shouldDebug, std::memory_order_relaxed);
     }
 
     /** Tells the base class whether to sanitize incoming positions when processing
@@ -208,9 +218,44 @@ struct EngineBase {
      */
     void set_sanitize_positions(const bool shouldSanitize) noexcept
     {
-        sanitizeIncomingPositions.store(shouldSanitize, memory_order_relaxed);
+        sanitizeIncomingPositions.store(shouldSanitize, std::memory_order_release);
     }
 
+    /** Subclasses should implement this to resize their transposition table. */
+    virtual void resize_transposition_table([[maybe_unused]] const size_t sizeMB) { }
+
+    /** Subclasses can implement this to be informed when the ponder parameter changes. */
+    virtual void set_ponder([[maybe_unused]] const bool shouldPonder) { }
+
+    //// @name Standard UCI options
+    /// @{
+
+    /** Standard UCI option for hash size. */
+    IntOption opt_Hash {
+        "Hash",
+        1, 2048, 16,
+        "Sets the transposition table size (in MB)",
+        [this](const int sizeMB) {
+            assert(sizeMB >= 0);
+            resize_transposition_table(static_cast<size_t>(sizeMB));
+        }
+    };
+
+    /** Standard UCI option for pondering.
+        The engine doesn't start pondering on its own without explicitly being told to
+        via another ``go`` command; this option is needed to inform the GUI that the engine
+        supports pondering, and also gives the engine the opportunity to adjust its time
+        management algorithm when pondering is enabled.
+     */
+    BoolOption opt_Ponder {
+        "Ponder",
+        false,
+        "Controls whether pondering is allowed.",
+        [this](const bool shouldPonder) { set_ponder(shouldPonder); }
+    };
+
+    /// @}
+
 private:
     void respond_to_uci();
     void respond_to_isready();
@@ -289,6 +334,10 @@ struct EngineBase {
             .description = "Handle license registration",
             .argsHelp    = { } }
     };
+
+    std::array<Option*, 2uz> standardUCIOptions {
+        &opt_Hash, &opt_Ponder
+    };
 };
 
 } // namespace chess::uci

libchess/src/uci/EngineBase.cpp

@@ -14,6 +14,7 @@
 
 #include <algorithm>
 #include <atomic>
+#include <cassert>
 #include <expected>
 #include <format>
 #include <iostream>
@@ -32,7 +33,9 @@ namespace chess::uci {
 
 using printing::info_string;
 using std::cout;
+using std::memory_order_acquire;
 using std::memory_order_relaxed;
+using std::memory_order_release;
 using std::println;
 using std::string_view;
 using util::strings::split_at_first_space;
@@ -79,7 +82,7 @@ void EngineBase::respond_to_uci()
     println(cout, "id name {}", get_name());
     println(cout, "id author {}", get_author());
 
-    for (const auto* option : get_options())
+    for (const auto* option : get_custom_uci_options())
         println(cout, "{}", option->get_declaration_string());
 
     println(cout, "uciok");
@@ -95,6 +98,7 @@ void EngineBase::respond_to_isready()
         wait();
 
     println(cout, "readyok");
+
     cout.flush();
 }
 
@@ -108,7 +112,9 @@ void EngineBase::respond_to_newgame()
 void EngineBase::handle_quit()
 {
     abort_search();
-    shouldExit.store(true, std::memory_order::release);
+
+    shouldExit.store(true, memory_order_release);
+
     wait();
 }
 
@@ -125,7 +131,7 @@ void EngineBase::handle_setpos(const string_view arguments)
     [[maybe_unused]] const auto obj
         = parse_position_options(arguments)
               .and_then([this](const Position& pos) -> std::expected<void, std::string> {
-                  if (sanitizeIncomingPositions.load(memory_order_relaxed)) {
+                  if (sanitizeIncomingPositions.load(memory_order_acquire)) {
                       if (const auto errorStr = pos.is_illegal()) {
                           [[unlikely]];
                           return std::unexpected {
@@ -173,21 +179,33 @@ void EngineBase::handle_setoption(const string_view arguments)
 
     wait();
 
-    const auto options = get_options();
+    auto update_option = [name, isNPos, rest, valueTokenIdx](const OptionList options) {
+        if (const auto it = std::ranges::find_if(
+                options,
+                [name](const Option* opt) { return opt->get_name() == name; });
+            it != options.end()) {
+            auto* option = *it;
 
-    if (const auto it = std::ranges::find_if(
-            options,
-            [name](const Option* opt) { return opt->get_name() == name; });
-        it != options.end()) {
-        auto* option = *it;
+            assert(option != nullptr);
 
-        if (isNPos)
-            option->handle_setvalue({ });
-        else
-            option->handle_setvalue(trim(rest.substr(valueTokenIdx)));
-    } else {
-        info_string(std::format("Attempted to set unknown option '{}'", name));
-    }
+            if (isNPos)
+                option->handle_setvalue({ });
+            else
+                option->handle_setvalue(trim(rest.substr(valueTokenIdx)));
+
+            return true;
+        }
+
+        return false;
+    };
+
+    if (update_option(standardUCIOptions))
+        return;
+
+    if (update_option(get_custom_uci_options()))
+        return;
+
+    info_string(std::format("Attempted to set unknown option '{}'", name));
 }
 
 void EngineBase::loop()
@@ -198,7 +216,7 @@ void EngineBase::loop()
         std::getline(std::cin, inputBuf);
 
         handle_command(inputBuf);
-    } while (not shouldExit.load(std::memory_order::acquire));
+    } while (not shouldExit.load(memory_order_acquire));
 }
 
 } // namespace chess::uci