Swaps std::uniform_int_distribution for absl::uniform_int_distribution.

This should be 2x faster. PiperOrigin-RevId: 272676089 Change-Id: I78f5053d56e3b2e07bee4cca76918e25101e73c6
ifeela · Oct 7, 2019 · b56449a · b56449a
1 parent e6f4d94
commit b56449a
Show file tree

Hide file tree

Showing 11 changed files with 27 additions and 16 deletions.
diff --git a/open_spiel/CMakeLists.txt b/open_spiel/CMakeLists.txt
@@ -49,7 +49,7 @@ add_subdirectory (abseil-cpp)
 add_library(open_spiel_core OBJECT ${OPEN_SPIEL_CORE_FILES})
 target_include_directories (open_spiel_core PUBLIC ${CMAKE_CURRENT_SOURCE_DIR} abseil-cpp)
 link_libraries(open_spiel_core absl::container absl::strings absl::str_format
-               absl::time absl::optional)
+               absl::time absl::optional absl::random_random)
 
 # Just the minimal base library: no games.
 set (OPEN_SPIEL_CORE_OBJECTS $<TARGET_OBJECTS:open_spiel_core>)

diff --git a/open_spiel/algorithms/mcts.cc b/open_spiel/algorithms/mcts.cc
@@ -18,6 +18,8 @@
 #include <limits>
 #include <random>
 
+#include "open_spiel/abseil-cpp/absl/random/uniform_int_distribution.h"
+
 namespace open_spiel {
 namespace algorithms {
 namespace {
@@ -130,7 +132,7 @@ double RandomRolloutEvaluator::evaluate(const State& state) const {
         working_state->ApplyAction(action);
       } else {
         auto actions = working_state->LegalActions();
-        std::uniform_int_distribution<int> dist(0, actions.size() - 1);
+        absl::uniform_int_distribution<int> dist(0, actions.size() - 1);
         int index = dist(rng_);
         working_state->ApplyAction(actions[index]);
       }

diff --git a/open_spiel/contrib/tf_trajectories.cc b/open_spiel/contrib/tf_trajectories.cc
@@ -21,6 +21,7 @@
 #include <random>
 #include <vector>
 
+#include "open_spiel/abseil-cpp/absl/random/uniform_int_distribution.h"
 #include "open_spiel/abseil-cpp/absl/strings/str_join.h"
 #include "third_party/eigen3/unsupported/Eigen/CXX11/src/Tensor/TensorMap.h"
 #include "open_spiel/spiel_utils.h"
@@ -82,7 +83,7 @@ void TFBatchTrajectoryRecorder::GetNextStatesUniform() {
   for (int b = 0; b < batch_size_; ++b) {
     if (!terminal_flags_[b]) {
       std::vector<Action> actions = states_[b]->LegalActions();
-      std::uniform_int_distribution<> dist(0, actions.size() - 1);
+      absl::uniform_int_distribution<> dist(0, actions.size() - 1);
       Action action = actions[dist(rng_)];
       states_[b]->ApplyAction(action);
       SampleChance(b);

diff --git a/open_spiel/examples/example.cc b/open_spiel/examples/example.cc
@@ -17,6 +17,7 @@
 #include <memory>
 #include <random>
 
+#include "open_spiel/abseil-cpp/absl/random/uniform_int_distribution.h"
 #include "open_spiel/spiel.h"
 #include "open_spiel/spiel_utils.h"
 
@@ -120,7 +121,7 @@ int main(int argc, char** argv) {
           PrintLegalActions(*state, player, actions);
         }
 
-        std::uniform_int_distribution<> dis(0, actions.size() - 1);
+        absl::uniform_int_distribution<> dis(0, actions.size() - 1);
         open_spiel::Action action = actions[dis(rng)];
         joint_action.push_back(action);
         std::cerr << "player " << player << " chose "
@@ -149,7 +150,7 @@ int main(int argc, char** argv) {
         PrintLegalActions(*state, player, actions);
       }
 
-      std::uniform_int_distribution<> dis(0, actions.size() - 1);
+      absl::uniform_int_distribution<> dis(0, actions.size() - 1);
       auto action = actions[dis(rng)];
       std::cerr << "chose action: " << state->ActionToString(player, action)
                 << std::endl;

diff --git a/open_spiel/examples/matrix_example.cc b/open_spiel/examples/matrix_example.cc
@@ -15,6 +15,7 @@
 #include <memory>
 #include <random>
 
+#include "open_spiel/abseil-cpp/absl/random/uniform_int_distribution.h"
 #include "open_spiel/matrix_game.h"
 #include "open_spiel/spiel.h"
 
@@ -57,10 +58,10 @@ int main(int argc, char** argv) {
   std::vector<open_spiel::Action> col_actions = state->LegalActions(1);
 
   open_spiel::Action row_action =
-      row_actions[std::uniform_int_distribution<int>(
+      row_actions[absl::uniform_int_distribution<int>(
           0, row_actions.size() - 1)(rng)];
   open_spiel::Action col_action =
-      col_actions[std::uniform_int_distribution<int>(
+      col_actions[absl::uniform_int_distribution<int>(
           0, col_actions.size() - 1)(rng)];
 
   std::cerr << "Joint action is: (" << state->ActionToString(0, row_action)

diff --git a/open_spiel/game_transforms/turn_based_simultaneous_game_test.cc b/open_spiel/game_transforms/turn_based_simultaneous_game_test.cc
@@ -17,6 +17,7 @@
 #include <random>
 #include <string>
 
+#include "open_spiel/abseil-cpp/absl/random/uniform_int_distribution.h"
 #include "open_spiel/spiel.h"
 
 namespace open_spiel {
@@ -63,7 +64,7 @@ void SimulateGames(std::mt19937* rng, const Game& game, State* sim_state,
 
         std::vector<Action> actions;
         actions = sim_state->LegalActions(p);
-        std::uniform_int_distribution<> dis(0, actions.size() - 1);
+        absl::uniform_int_distribution<> dis(0, actions.size() - 1);
         Action action = actions[dis(*rng)];
         joint_action.push_back(action);
         std::cout << "player " << p << " chose "

diff --git a/open_spiel/games/bridge_uncontested_bidding.h b/open_spiel/games/bridge_uncontested_bidding.h
@@ -117,7 +117,7 @@ class Deal {
   Deal() { std::iota(std::begin(cards_), std::end(cards_), 0); }
   void Shuffle(std::mt19937* rng, int begin = 0, int end = kNumCards) {
     for (int i = begin; i < end - 1; ++i) {
-      // We don't use std::uniform_int_distribution because it behaves
+      // We don't use absl::uniform_int_distribution because it behaves
       // differently in different versions of C++, and we want reproducible
       // tests.
       int j = i + (*rng)() % (end - i);

diff --git a/open_spiel/games/chess/chess_common.h b/open_spiel/games/chess/chess_common.h
@@ -20,6 +20,8 @@
 #include <random>
 #include <string>
 
+#include "open_spiel/abseil-cpp/absl/random/uniform_int_distribution.h"
+
 namespace open_spiel {
 namespace chess_common {
 
@@ -116,7 +118,7 @@ class ZobristTable {
 
   ZobristTable(Generator::result_type seed) {
     Generator generator(seed);
-    std::uniform_int_distribution<Generator::result_type> dist;
+    absl::uniform_int_distribution<Generator::result_type> dist;
     data_.reserve(InnerDim);
     for (std::size_t i = 0; i < InnerDim; ++i) {
       data_.emplace_back(dist(generator));
@@ -139,7 +141,7 @@ class ZobristTable<T, InnerDim> {
 
   ZobristTable(Generator::result_type seed) : data_(InnerDim) {
     Generator generator(seed);
-    std::uniform_int_distribution<T> dist;
+    absl::uniform_int_distribution<T> dist;
     for (auto& field : data_) {
       field = dist(generator);
     }

diff --git a/open_spiel/games/go/go_board.cc b/open_spiel/games/go/go_board.cc
@@ -16,6 +16,7 @@
 
 #include <iomanip>
 
+#include "open_spiel/abseil-cpp/absl/random/uniform_int_distribution.h"
 #include "open_spiel/games/chess/chess_common.h"
 #include "open_spiel/spiel_utils.h"
 

diff --git a/open_spiel/spiel_bots.cc b/open_spiel/spiel_bots.cc
@@ -16,6 +16,7 @@
 
 #include <algorithm>
 
+#include "open_spiel/abseil-cpp/absl/random/uniform_int_distribution.h"
 #include "open_spiel/spiel_utils.h"
 
 namespace open_spiel {
@@ -33,7 +34,7 @@ class UniformRandomBot : public Bot {
     const double p = 1.0 / num_legal_actions;
     for (auto action : legal_actions) policy.emplace_back(action, p);
     int selection =
-        std::uniform_int_distribution<int>(0, num_legal_actions - 1)(rng_);
+        absl::uniform_int_distribution<int>(0, num_legal_actions - 1)(rng_);
     return std::make_pair(policy, legal_actions[selection]);
   }
 

diff --git a/open_spiel/tests/basic_tests.cc b/open_spiel/tests/basic_tests.cc
@@ -19,6 +19,7 @@
 #include <set>
 #include <string>
 
+#include "open_spiel/abseil-cpp/absl/random/uniform_int_distribution.h"
 #include "open_spiel/abseil-cpp/absl/time/clock.h"
 #include "open_spiel/game_transforms/turn_based_simultaneous_game.h"
 #include "open_spiel/spiel.h"
@@ -218,7 +219,7 @@ int RandomSimulationFast(std::mt19937* rng, const Game& game, bool verbose) {
       for (int p = 0; p < game.NumPlayers(); p++) {
         std::vector<Action> actions;
         actions = state->LegalActions(p);
-        std::uniform_int_distribution<> dis(0, actions.size() - 1);
+        std::uniform_int_distribution<int> dis(0, actions.size() - 1);
         Action action = actions[dis(*rng)];
         joint_action.push_back(action);
         if (verbose) {
@@ -231,7 +232,7 @@ int RandomSimulationFast(std::mt19937* rng, const Game& game, bool verbose) {
     } else {
       // Sample an action uniformly.
       std::vector<Action> actions = state->LegalActions();
-      std::uniform_int_distribution<> dis(0, actions.size() - 1);
+      std::uniform_int_distribution<int> dis(0, actions.size() - 1);
       Action action = actions[dis(*rng)];
       if (verbose) {
         int p = state->CurrentPlayer();
@@ -348,7 +349,7 @@ void RandomSimulation(std::mt19937* rng, const Game& game, bool undo) {
       for (auto p = Player{0}; p < game.NumPlayers(); p++) {
         std::vector<Action> actions;
         actions = state->LegalActions(p);
-        std::uniform_int_distribution<> dis(0, actions.size() - 1);
+        std::uniform_int_distribution<int> dis(0, actions.size() - 1);
         Action action = actions[dis(*rng)];
         joint_action.push_back(action);
         if (p == 0) {
@@ -394,7 +395,7 @@ void RandomSimulation(std::mt19937* rng, const Game& game, bool undo) {
         SPIEL_CHECK_TRUE(actions.empty());
       else
         SPIEL_CHECK_FALSE(actions.empty());
-      std::uniform_int_distribution<> dis(0, actions.size() - 1);
+      std::uniform_int_distribution<int> dis(0, actions.size() - 1);
       Action action = actions[dis(*rng)];
 
       std::cout << "chose action: " << state->ActionToString(player, action)