Skip to content
3 changes: 3 additions & 0 deletions Chess/Concepts.h
Original file line number Diff line number Diff line change
Expand Up @@ -5,3 +5,6 @@ template <class T>
concept StopSearchCondition = requires(const T& condition) {
{ condition.IsTimeToExit() } -> std::convertible_to<bool>;
};

template <class T>
concept CountsNodes = requires(const T& condition) { condition.CountNode(); };
49 changes: 48 additions & 1 deletion Chess/ExitCondition.h
Original file line number Diff line number Diff line change
@@ -1,6 +1,8 @@
#pragma once
#include <atomic>
#include <cassert>
#include <chrono>
#include <cstdint>
#include <memory>
#include <thread>
#include <variant>
Expand Down Expand Up @@ -85,6 +87,20 @@ struct TimeCondition {
};
static_assert(SearchCondition<TimeCondition>);

class NodeBudget {
public:
explicit NodeBudget(std::uint64_t limit) : limit_(limit) {}

void Spend() { searched_.fetch_add(1, std::memory_order_relaxed); }
[[nodiscard]] bool IsSpent() const {
return searched_.load(std::memory_order_relaxed) >= limit_;
}

private:
std::atomic<std::uint64_t> searched_{0};
const std::uint64_t limit_;
};

struct DepthCondition {
explicit DepthCondition(Depth max_depth, StopSignal stop_signal = {})
: max_depth_(max_depth), stop_signal_(std::move(stop_signal)) {}
Expand All @@ -104,7 +120,38 @@ struct DepthCondition {
};
static_assert(SearchCondition<DepthCondition>);

using Condition = std::variant<TimeCondition, DepthCondition>;
class NodeCondition {
public:
NodeCondition(Depth max_depth, StopSignal stop_signal,
std::shared_ptr<NodeBudget> node_budget)
: depth_condition_(max_depth, std::move(stop_signal)),
node_budget_(std::move(node_budget)) {
assert(node_budget_);
}

bool ShouldContinueIteration() const {
return !node_budget_->IsSpent() &&
depth_condition_.ShouldContinueIteration();
}

[[gnu::always_inline]] bool IsTimeToExit() const {
return depth_condition_.IsTimeToExit() || node_budget_->IsSpent();
}

[[gnu::always_inline]] void CountNode() const { node_budget_->Spend(); }

void Update(const IterationInfo& info) { depth_condition_.Update(info); }

private:
DepthCondition depth_condition_;
std::shared_ptr<NodeBudget> node_budget_;
};
static_assert(SearchCondition<NodeCondition>);
static_assert(CountsNodes<NodeCondition>);
static_assert(!CountsNodes<DepthCondition>);
static_assert(!CountsNodes<TimeCondition>);

using Condition = std::variant<TimeCondition, DepthCondition, NodeCondition>;

struct Pondering {
explicit Pondering(StopSignal signal = {})
Expand Down
Loading
Loading