Context.hpp

Go to the documentation of this file.

/*
 * ======================================================================================
 *
 * ░▒▓███████▓▒░░▒▓████████▓▒░▒▓███████▓▒░       ░▒▓███████▓▒░ ░▒▓██████▓▒░▒▓████████▓▒░
 * ░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░      ░▒▓█▓▒░░▒▓█▓▒░      ░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░░▒▓█▓▒░ ░▒▓█▓▒░
 * ░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░      ░▒▓█▓▒░░▒▓█▓▒░      ░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░░▒▓█▓▒░ ░▒▓█▓▒░
 * ░▒▓███████▓▒░░▒▓██████▓▒░ ░▒▓█▓▒░░▒▓█▓▒░      ░▒▓███████▓▒░░▒▓█▓▒░░▒▓█▓▒░ ░▒▓█▓▒░
 * ░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░      ░▒▓█▓▒░░▒▓█▓▒░      ░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░░▒▓█▓▒░ ░▒▓█▓▒░
 * ░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░      ░▒▓█▓▒░░▒▓█▓▒░      ░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░░▒▓█▓▒░ ░▒▓█▓▒░
 * ░▒▓███████▓▒░░▒▓████████▓▒░▒▓█▓▒░░▒▓█▓▒░      ░▒▓███████▓▒░ ░▒▓██████▓▒░  ░▒▓█▓▒░
 *
 * ======================================================================================
 */

 
#pragma once
 
#include <atomic>
#include <libbenbot/data-structures/KillerMoves.hpp>
#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;

struct Context final {
    Context() = default;

    explicit Context(Callbacks&& callbacksToUse)
        : callbacks { std::move(callbacksToUse) }
    {
    }
 
    Context(const Context&)            = delete;
    Context& operator=(const Context&) = delete;
 
    Context(Context&&)            = delete;
    Context& operator=(Context&&) = delete;
 
    ~Context() = default;

    void search();

    void abort() noexcept { exitFlag.store(true, std::memory_order::release); }

    void clear_transposition_table()
    {
        wait();
        transTable.clear();
    }

    void resize_transposition_table(size_t sizeMB)
    {
        wait();
        transTable.resize(sizeMB);
    }

    [[nodiscard]] auto probe_transposition_table(const Position& pos) const
        -> std::optional<TTData>
    {
        return transTable.find(pos);
    }

    [[nodiscard]] auto in_progress() const noexcept -> bool { return activeFlag.load(std::memory_order::acquire); }

    void wait() const;

    void set_pondering(const bool isPonderMode) noexcept { pondering.store(isPonderMode, std::memory_order::release); }

    void ponder_hit() noexcept { pondering.store(false, std::memory_order::release); }

    void set_position(const Position& pos)
    {
        wait();
        position = pos;
 
        // clear this so that all legal moves will be searched by default
        options.movesToSearch.clear();
    }

    void set_options(const Options& opts)
    {
        wait();
        options = opts;
    }

    void set_options(const chess::uci::GoCommandOptions& opts)
    {
        wait();
        options = Options::from_libchess(opts, position.is_white_to_move());
    }

    void set_callbacks(Callbacks&& callbacksToUse)
    {
        wait();
        callbacks = std::move(callbacksToUse);
    }

    [[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;
};
 
} // namespace ben_bot::search