Call it a day.

Author: xlnwel

.gitignore

@@ -4,4 +4,5 @@
 main.dSYM
 .vscode
 hierarchy/build
-.template
+.template
+build

hierarchy/CMakeLists.txt CMakeLists.txt

@@ -5,5 +5,6 @@ set(CMAKE_CXX_STANDARD_REQUIRED True)
 
 project(Game)
 
-AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR} SRCS)
+AUX_SOURCE_DIRECTORY(src SRCS)
+AUX_SOURCE_DIRECTORY(thread SRCS)
 add_executable(game ${SRCS})

hierarchy/alphabeta_cutoff_player.cpp src/alphabeta_cutoff_player.cpp

@@ -13,6 +13,7 @@
 #include "minmax_player.hpp"
 #include "mcts_player.hpp"
 #include "mcts_multithread_player.hpp"
+#include "mcts_multithread_threadpool_player.hpp"
 
 #include "board.hpp"
 #include "game.hpp"
@@ -50,6 +51,8 @@ unique_ptr<Player> create_player(const string& s, Piece p, int n) {
         return make_unique<MCTSPlayer>(p, n);
     if (s == "MCTSMT")
         return make_unique<MCTSMultiThreadPlayer>(p, n);
+    if (s == "MCTSMTTP")
+        return make_unique<MCTSMultiThreadThreadPoolPlayer>(p, n);
     if (s == "MINMAX")
         return make_unique<MinMaxPlayer>(p);
     throw invalid_argument("Invalid player type: " + s);

hierarchy/alphabeta_cutoff_player.hpp src/alphabeta_cutoff_player.hpp

@@ -0,0 +1,110 @@
+#include <cmath>
+#include <limits>
+#include <random>
+#include <future>
+
+#include "mcts_mt_lf_player.hpp"
+
+using namespace std;
+using namespace game;
+
+
+MCTSMultiThreadLockFreePlayer::MCTSMultiThreadLockFreePlayer(Piece p, int nn, double cc):
+    Player(p), n(nn), c(cc) {}
+
+Point MCTSMultiThreadLockFreePlayer::get_move(const Game& game, const State& state) const {
+    assert(!state.is_over());
+    auto root = make_unique<Node>(state);
+    vector<future<void>> v(n);
+    for (auto i = 0; i != n; ++i) {
+        v[i] = std::async([this, game, p=root.get()]() {
+            auto leaf = select_expand(game, p);
+            auto result = simulate(game, leaf->state);
+            backup(leaf, result);
+        });
+    }
+    for (auto& f: v)
+        f.get();
+    int max_i = 0;
+    auto max_n = 0;
+    const auto& moves = state.get_valid_moves();
+    const auto& children = root->children;
+    assert(moves.size() == children.size()); 
+    for (auto i = 0; i != moves.size(); ++i) {
+        if (children[i]->n > max_n)
+            max_i = i;
+    }
+    return moves[max_i];
+}
+
+double MCTSMultiThreadLockFreePlayer::ucb(Node* p) const {
+    // traditional ucb
+    if (p) {
+        return p->utility.load(memory_order_relaxed) / p->n.load(memory_order_relaxed) 
+            + c * sqrt(log(p->parent->n.load(memory_order_relaxed)) / p->n.load(memory_order_relaxed));
+    }
+    return numeric_limits<double>::max();
+}
+
+MCTSMultiThreadLockFreePlayer::Node* MCTSMultiThreadLockFreePlayer::select_expand(const Game& game, Node* p) const {
+    assert(p);
+    assert(!p->children.empty());
+    double max_val = numeric_limits<double>::min();
+    int max_idx = 0;
+    vector<double> v(p->children.size());
+    for (auto i = 0; i != p->children.size(); ++i) {
+        v[i] = ucb(p->children[i].get());
+        if (v[i] > max_val) {
+            max_val = v[i];
+            max_idx = i;
+            if (max_val == numeric_limits<double>::max())
+                break;
+        }
+    }
+    if (!p->children[max_idx]) {
+        make_child(game, p, max_idx);   // expansion happens here, introducing an additional expand could incur additional O(N) the memory, where N is the number of leaf nodes
+        return p->children[max_idx].get();
+    }
+    else if (p->children[max_idx]->state.is_over()) {
+        return p->children[max_idx].get();
+    }
+    else {
+        return select_expand(game, p->children[max_idx].get());
+    }
+}
+
+int MCTSMultiThreadLockFreePlayer::simulate(const Game& game, const State& s) const {
+    if (s.is_over())
+        return s.get_utility(get_piece());
+    assert(!s.get_valid_moves().empty());
+    auto state = game.result(s, s.get_valid_moves()[0], s.to_move());
+    while (!state.is_over()) {
+        state = game.result(
+            state, 
+            state.get_valid_moves()[0], 
+            state.to_move());
+    }
+    return state.get_utility(get_piece());
+}
+
+void MCTSMultiThreadLockFreePlayer::backup(Node* p, int v) const {
+    assert(p);
+    {
+        p->n.fetch_add(1, memory_order_relaxed);
+        auto util = p->utility.load(memory_order_relaxed);
+        while (!p->utility.compare_exchange_weak(util, v, 
+            memory_order_relaxed, memory_order_relaxed));
+    }
+    if (p->parent)
+        backup(p->parent, v);
+}
+void MCTSMultiThreadLockFreePlayer::make_child(const Game& game, Node* p, int idx) const {
+    assert(p);
+    auto moves = p->state.get_valid_moves();
+    auto piece = p->state.to_move();
+    auto state = game.result(p->state, moves[idx], piece);
+    lock_guard lk(p->m);
+    if (!p->children[idx]) {
+        p->children[idx] = make_unique<Node>(std::move(state), p);
+    }
+}

hierarchy/alphabeta_player.cpp src/alphabeta_player.cpp

@@ -0,0 +1,48 @@
+#ifndef GAME_MCTS_MULTITHREAD_LOCKFREE_PLAYER_H_
+#define GAME_MCTS_MULTITHREAD_LOCKFREE_PLAYER_H_
+
+#include <atomic>
+#include <memory>
+#include <mutex>
+#include <utility>
+#include <vector>
+
+#include "state.hpp"
+#include "player.hpp"
+#include "game.hpp"
+
+namespace game {
+    class MCTSMultiThreadLockFreePlayer: public Player {
+    public:
+        MCTSMultiThreadLockFreePlayer(Piece p, int nn, double cc=1.4);
+
+        Point get_move(const Game&, const State&) const override;
+    private:
+        struct Node {
+            Node(const State& s, Node* p=nullptr): 
+                state(s), parent(p), 
+                children(state.get_valid_moves().size()), 
+                n(0), utility(0) {}
+            Node(State&& s, Node* p=nullptr): 
+                state(std::move(s)), parent(p), 
+                children(state.get_valid_moves().size()),
+                n(0), utility(0) {}
+            
+            State state;
+            Node* parent;
+            std::vector<std::unique_ptr<Node>> children;
+            std::atomic_size_t n;
+            std::atomic<double> utility;
+            std::mutex m;
+        };
+        double ucb(Node* p) const;
+        Node* select_expand(const Game&, Node*) const;
+        int simulate(const Game&, const State&) const;
+        void backup(Node*, int) const;
+        void make_child(const Game&, Node*, int) const;
+        int n;  // number of simulations
+        double c;
+    };
+}
+
+#endif

hierarchy/alphabeta_player.hpp src/alphabeta_player.hpp

@@ -6,9 +6,9 @@
 #include <utility>
 #include <vector>
 
-#include "state.hpp"
-#include "player.hpp"
 #include "game.hpp"
+#include "player.hpp"
+#include "state.hpp"
 
 namespace game {
     class MCTSMultiThreadPlayer: public Player {

hierarchy/basics.cpp src/basics.cpp

@@ -0,0 +1,121 @@
+#include <cmath>
+#include <limits>
+#include <random>
+#include <future>
+
+#include "../thread/thread_pool.hpp"
+#include "mcts_multithread_threadpool_player.hpp"
+
+using namespace std;
+using namespace game;
+using namespace thread_utils;
+
+
+MCTSMultiThreadThreadPoolPlayer::MCTSMultiThreadThreadPoolPlayer(
+    Piece p, int nn, double cc): Player(p), n(nn), c(cc) {}
+
+Point MCTSMultiThreadThreadPoolPlayer::get_move(
+        const Game& game, const State& state) const {
+    assert(!state.is_over());
+    auto root = make_unique<Node>(state);
+    auto n_threads = std::thread::hardware_concurrency() - 1;
+    {
+        ThreadPool<void()> tp(n_threads);
+        vector<future<void>> v(n_threads);
+        int sim_per_thread = n / (n_threads+1);
+        auto task = [this](const Game& game, Node* root, int sim_per_thread) {
+            for (auto i = 0; i != sim_per_thread; ++i) {
+                auto leaf = select_expand(game, root);
+                auto result = simulate(game, leaf->state);
+                backup(leaf, result);
+            }
+        };
+        for (auto i = 0; i != n_threads - 1; ++i) {
+            v[i] = tp.submit(task, game, root.get(), sim_per_thread);
+        }
+        task(game, root.get(), n - sim_per_thread * n_threads);
+        for (auto& f: v)
+            f.get();
+    }
+    int max_i = 0;
+    auto max_n = 0;
+    const auto& moves = state.get_valid_moves();
+    const auto& children = root->children;
+    assert(moves.size() == children.size()); 
+    for (auto i = 0; i != moves.size(); ++i) {
+        if (children[i]->n > max_n)
+            max_i = i;
+    }
+    return moves[max_i];
+}
+
+double MCTSMultiThreadThreadPoolPlayer::ucb(Node* p) const {
+    // traditional ucb
+    if (p) {
+        lock_guard lk{p->m};
+        return p->utility / p->n + c * sqrt(log(p->parent->n) / p->n);
+    }
+    return numeric_limits<double>::max();
+}
+
+MCTSMultiThreadThreadPoolPlayer::Node* MCTSMultiThreadThreadPoolPlayer::select_expand(const Game& game, Node* p) const {
+    assert(p);
+    assert(!p->children.empty());
+    double max_val = numeric_limits<double>::min();
+    int max_idx = 0;
+    vector<double> v(p->children.size());
+    for (auto i = 0; i != p->children.size(); ++i) {
+        v[i] = ucb(p->children[i].get());
+        if (v[i] > max_val) {
+            max_val = v[i];
+            max_idx = i;
+            if (max_val == numeric_limits<double>::max())
+                break;
+        }
+    }
+    if (!p->children[max_idx]) {
+        make_child(game, p, max_idx);   // expansion happens here, introducing an additional expand could incur additional O(N) the memory, where N is the number of leaf nodes
+        return p->children[max_idx].get();
+    }
+    else if (p->children[max_idx]->state.is_over()) {
+        return p->children[max_idx].get();
+    }
+    else {
+        return select_expand(game, p->children[max_idx].get());
+    }
+}
+
+int MCTSMultiThreadThreadPoolPlayer::simulate(const Game& game, const State& s) const {
+    if (s.is_over())
+        return s.get_utility(get_piece());
+    assert(!s.get_valid_moves().empty());
+    auto state = game.result(s, s.get_valid_moves()[0], s.to_move());
+    while (!state.is_over()) {
+        state = game.result(
+            state, 
+            state.get_valid_moves()[0], 
+            state.to_move());
+    }
+    return state.get_utility(get_piece());
+}
+
+void MCTSMultiThreadThreadPoolPlayer::backup(Node* p, int v) const {
+    assert(p);
+    {
+        lock_guard lk(p->m);
+        ++p->n;
+        p->utility += v;
+    }
+    if (p->parent)
+        backup(p->parent, v);
+}
+void MCTSMultiThreadThreadPoolPlayer::make_child(const Game& game, Node* p, int idx) const {
+    assert(p);
+    auto moves = p->state.get_valid_moves();
+    auto piece = p->state.to_move();
+    auto state = game.result(p->state, moves[idx], piece);
+    lock_guard lk(p->m);
+    if (!p->children[idx]) {
+        p->children[idx] = make_unique<Node>(std::move(state), p);
+    }
+}

hierarchy/basics.hpp src/basics.hpp

@@ -0,0 +1,47 @@
+#ifndef GAME_MCTS_MULTITHREAD_THREADPOOL_PLAYER_H_
+#define GAME_MCTS_MULTITHREAD_THREADPOOL_PLAYER_H_
+
+#include <memory>
+#include <mutex>
+#include <utility>
+#include <vector>
+
+#include "game.hpp"
+#include "player.hpp"
+#include "state.hpp"
+
+namespace game {
+    class MCTSMultiThreadThreadPoolPlayer: public Player {
+    public:
+        MCTSMultiThreadThreadPoolPlayer(Piece p, int nn, double cc=1.4);
+
+        Point get_move(const Game&, const State&) const override;
+    private:
+        struct Node {
+            Node(const State& s, Node* p=nullptr): 
+                state(s), parent(p), 
+                children(state.get_valid_moves().size()), 
+                n(0), utility(0) {}
+            Node(State&& s, Node* p=nullptr): 
+                state(std::move(s)), parent(p), 
+                children(state.get_valid_moves().size()),
+                n(0), utility(0) {}
+            
+            State state;
+            Node* parent;
+            std::vector<std::unique_ptr<Node>> children;
+            std::size_t n;
+            double utility;
+            std::mutex m;
+        };
+        double ucb(Node* p) const;
+        Node* select_expand(const Game&, Node*) const;
+        int simulate(const Game&, const State&) const;
+        void backup(Node*, int) const;
+        void make_child(const Game&, Node*, int) const;
+        int n;  // number of simulations
+        double c;
+    };
+}
+
+#endif