Call it a day.

Author: xlnwel

src/game.cpp

@@ -8,9 +8,11 @@
 using namespace std;
 using namespace game;
 
-Game::Game(const Board& b, Piece p): init_state(b, p) {}
+Game::Game(const Board& b, Piece p): 
+    init_state(b, p), win1(0), win2(0) {}
 
-Game::Game(unique_ptr<Board>&& b, Piece p): init_state(std::move(b), p) {}
+Game::Game(unique_ptr<Board>&& b, Piece p): 
+    init_state(std::move(b), p), win1(0), win2(0) {}
 
 State Game::result(const State& state, Point m, Piece p) const {
     auto new_board = state.copy_board();
@@ -51,7 +53,23 @@ void Game::play(const Player* p1, const Player* p2) const {
         i = (i+1) % 2;
     }
     s.display();
+    switch(s.get_piece()) {
+    case Piece::White: ++win1; break;
+    case Piece::Black: ++win2; break;
+    default:
+        throw logic_error("Game ends with Blank piece");
+    }
     cout << get_piece_color(s.get_piece()) << " won!\n";
     cout << get_piece_color(p1->get_piece()) << " utility: " << s.get_utility(p1->get_piece()) << '\n';
     cout << get_piece_color(p2->get_piece()) << " utility: " << s.get_utility(p2->get_piece()) << '\n';
 }
+
+double Game::compute_win_rate(Piece p) const {
+    double x;
+    switch(p) {
+    case Piece::White: x = win1; break;
+    case Piece::Black: x = win2; break;
+    default: x = 0; break;
+    }
+    return x / (win1 + win2);
+}

src/game.hpp

@@ -16,11 +16,13 @@ namespace game {
         Game(std::unique_ptr<Board>&& b, Piece p=Piece::Blank);
 
         void play(const Player*, const Player*) const;
-        // copy the state, update it and return
         State result(const State&, Point, Piece) const;
         State get_initial_state() const { return init_state; }
+        double compute_win_rate(Piece) const;
     private:
         State init_state;
+        mutable int win1;
+        mutable int win2;
     };
 }
 

src/hex_board.cpp

@@ -98,9 +98,6 @@ double HexBoard::compute_utility(Piece piece) const {
     }
     auto white_score = static_cast<double>(down - top + 1) / n;
     auto black_score = static_cast<double>(right - left + 1) / n;
-    // display();
-    // cout << piece << down - top + 1 << " " << right - left + 1 << endl;
-    // assert(false);
     return piece == Piece::White? white_score - black_score: black_score - white_score;
 }
 

src/hex_board.hpp

@@ -10,7 +10,7 @@
 namespace game {
     class HexBoard: public RhombusBoard {
     public:
-        explicit HexBoard(std::size_t nn=11): RhombusBoard(nn) {}
+        explicit HexBoard(std::size_t nn=9): RhombusBoard(nn) {}
 
         void display(std::ostream& os=std::cout) const final;
         HexBoard* clone() const final { return new HexBoard(*this);}

src/main.cpp

@@ -12,6 +12,7 @@
 #include "alphabeta_cutoff_player.hpp"
 #include "minmax_player.hpp"
 #include "mcts_player.hpp"
+#include "mcts_eval_multithread_player.hpp"
 #include "mcts_multithread_player.hpp"
 #include "mcts_multithread_threadpool_player.hpp"
 
@@ -27,7 +28,7 @@ using namespace utility;
 
 string ask_for_player_type(int player_idx) {
     string pt;
-    cout << "Select player" << player_idx << "(AlphaBeta AlphaBetaCutOff MCTS MCTSMT MinMax): ";
+    cout << "Select player" << player_idx << "(AlphaBeta AlphaBetaCutOff MCTS MCTSEMT MCTSMT MinMax): ";
     cin >> pt;
     transform(pt.begin(), pt.end(), pt.begin(), ::toupper);
     return pt;
@@ -36,7 +37,21 @@ string ask_for_player_type(int player_idx) {
 int ask_for_n(const string& p, int player_idx) {
     if (p == "ALPHABETA" || p == "MINMAX")
         return 0;
-    cout << "Player" << player_idx <<"-the number of simulations/The depth to cutoff: ";
+    string s;
+    if (p == "ALPHABETACUTOFF") {
+        s = "The depth to cutoff";
+    }
+    else {
+        s = "The number of simulations";
+    }
+    cout << "(Player" << player_idx <<")" + s + ": ";
+    int n;
+    cin >> n;
+    return n;
+}
+
+int ask_for_experiments() {
+    cout << "Number of experiments: ";
     int n;
     cin >> n;
     return n;
@@ -51,33 +66,44 @@ 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 == "MCTSEMT")
+        return make_unique<MCTSEvaluationMultiThreadPlayer>(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);
 }
 
+void print_win_rate(const Game& g, const string& p_type, const Player* p) {
+    cout << get_piece_color(p->get_piece()) << "(" << p_type
+        << ") win rate: " << g.compute_win_rate(p->get_piece())
+        << "\n";
+}
+
 int main() {
     cout << "Board size: ";
     size_t n;
     cin >> n;
-    string p1_type = ask_for_player_type(1);
-    string p2_type = ask_for_player_type(2);
+    auto p1_type = ask_for_player_type(1);
+    auto p2_type = ask_for_player_type(2);
     int n1 = ask_for_n(p1_type, 1);
     int n2 = ask_for_n(p2_type, 2);
 
     auto p1 = create_player(p1_type, Piece::White, n1);
     auto p2 = create_player(p2_type, Piece::Black, n2);
-    // int n = 5;
+    int n_exps = ask_for_experiments();
+    // int n = 9;
     // string p1_type = "MCTS";
     // string p2_type = "MCTS";
-    // auto p1 = make_unique<MCTSPlayer>(Piece::White, 100);
-    // auto p2 = make_unique<MCTSPlayer>(Piece::Black, 100);
+    // auto p1 = make_unique<MCTSMultiThreadThreadPoolPlayer>(Piece::White, 1000);
+    // auto p2 = make_unique<MCTSMultiThreadThreadPoolPlayer>(Piece::Black, 1000);
     string description = "Time to run (" + p1_type + " vs " + p2_type + 
         ") on (" + to_string(n) + " x " + to_string(n) + ") board: ";
     Game g(make_board("Hex", n)); 
-    for (auto i = 0; i != 10; ++i) {
+    for (auto i = 0; i != n_exps; ++i) {
         timeit(description, &g, &Game::play, p1.get(), p2.get());
     }
+    print_win_rate(g, p1_type, p1.get());
+    print_win_rate(g, p2_type, p2.get());
 }

src/mcts_eval_multithread_player.cpp

@@ -0,0 +1,100 @@
+#include <cmath>
+#include <limits>
+#include <random>
+#include <future>
+
+#include "mcts_eval_multithread_player.hpp"
+
+using namespace std;
+using namespace game;
+
+
+MCTSEvaluationMultiThreadPlayer::MCTSEvaluationMultiThreadPlayer(Piece p, int nn, double cc):
+    Player(p), n(nn), c(cc) {}
+
+Point MCTSEvaluationMultiThreadPlayer::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] && children[i]->n > max_n)
+            max_i = i;
+    }
+    return moves[max_i];
+}
+
+double MCTSEvaluationMultiThreadPlayer::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();
+}
+
+MCTSEvaluationMultiThreadPlayer::Node* MCTSEvaluationMultiThreadPlayer::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());
+    }
+}
+
+double MCTSEvaluationMultiThreadPlayer::simulate(const Game& game, const State& s) const {
+    s.compute_utility();
+    return s.get_utility(get_piece());
+}
+
+void MCTSEvaluationMultiThreadPlayer::backup(Node* p, double v) const {
+    assert(p);
+    {
+        lock_guard lk(p->m);
+        ++p->n;
+        p->utility += v;
+    }
+    if (p->parent)
+        backup(p->parent, v);
+}
+void MCTSEvaluationMultiThreadPlayer::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);
+    }
+}

src/mcts_eval_multithread_player.hpp

@@ -0,0 +1,47 @@
+#ifndef GAME_MCTS_EVALUATION_MULTITHREAD_PLAYER_H_
+#define GAME_MCTS_EVALUATION_MULTITHREAD_PLAYER_H_
+
+#include <memory>
+#include <mutex>
+#include <utility>
+#include <vector>
+
+#include "game.hpp"
+#include "player.hpp"
+#include "state.hpp"
+
+namespace game {
+    class MCTSEvaluationMultiThreadPlayer: public Player {
+    public:
+        MCTSEvaluationMultiThreadPlayer(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;
+        double simulate(const Game&, const State&) const;
+        void backup(Node*, double) const;
+        void make_child(const Game&, Node*, int) const;
+        int n;  // number of simulations
+        double c;
+    };
+}
+
+#endif

src/mcts_mt_lf_player.cpp

@@ -31,7 +31,7 @@ Point MCTSMultiThreadLockFreePlayer::get_move(const Game& game, const State& sta
     const auto& children = root->children;
     assert(moves.size() == children.size()); 
     for (auto i = 0; i != moves.size(); ++i) {
-        if (children[i]->n > max_n)
+        if (children[i] && children[i]->n > max_n)
             max_i = i;
     }
     return moves[max_i];

src/mcts_multithread_player.cpp

@@ -31,7 +31,7 @@ Point MCTSMultiThreadPlayer::get_move(const Game& game, const State& state) cons
     const auto& children = root->children;
     assert(moves.size() == children.size()); 
     for (auto i = 0; i != moves.size(); ++i) {
-        if (children[i]->n > max_n)
+        if (children[i] && children[i]->n > max_n)
             max_i = i;
     }
     return moves[max_i];

src/mcts_multithread_threadpool_player.cpp

@@ -18,19 +18,22 @@ 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;
     {
+        auto n_threads = std::thread::hardware_concurrency() - 1;
+        int sim_per_thread = n / (n_threads+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) {
+                assert(root);
                 auto leaf = select_expand(game, root);
+                assert(leaf);
                 auto result = simulate(game, leaf->state);
+                assert(result != 0);
                 backup(leaf, result);
             }
         };
-        for (auto i = 0; i != n_threads - 1; ++i) {
+        for (auto i = 0; i != n_threads; ++i) {
             v[i] = tp.submit(task, game, root.get(), sim_per_thread);
         }
         task(game, root.get(), n - sim_per_thread * n_threads);
@@ -43,7 +46,7 @@ Point MCTSMultiThreadThreadPoolPlayer::get_move(
     const auto& children = root->children;
     assert(moves.size() == children.size()); 
     for (auto i = 0; i != moves.size(); ++i) {
-        if (children[i]->n > max_n)
+        if (children[i] && children[i]->n > max_n)
             max_i = i;
     }
     return moves[max_i];

src/mcts_player.cpp

@@ -25,7 +25,7 @@ Point MCTSPlayer::get_move(const Game& game, const State& state) const {
     const auto& children = root->children;
     assert(moves.size() == children.size()); 
     for (auto i = 0; i != moves.size(); ++i) {
-        if (children[i]->n > max_n)
+        if (children[i] && children[i]->n > max_n)
             max_i = i;
     }
     return moves[max_i];