git.sesse.net Git - stockfish/blob - src/tune.h

   1 /*
   2   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   3   Copyright (C) 2004-2023 The Stockfish developers (see AUTHORS file)
   4
   5   Stockfish is free software: you can redistribute it and/or modify
   6   it under the terms of the GNU General Public License as published by
   7   the Free Software Foundation, either version 3 of the License, or
   8   (at your option) any later version.
   9
  10   Stockfish is distributed in the hope that it will be useful,
  11   but WITHOUT ANY WARRANTY; without even the implied warranty of
  12   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13   GNU General Public License for more details.
  14
  15   You should have received a copy of the GNU General Public License
  16   along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17 */
  18
  19 #ifndef TUNE_H_INCLUDED
  20 #define TUNE_H_INCLUDED
  21
  22 #include <cstddef>
  23 #include <memory>
  24 #include <string>
  25 #include <type_traits> // IWYU pragma: keep
  26 #include <utility>
  27 #include <vector>
  28
  29 namespace Stockfish {
  30 enum Value : int;
  31
  32 using Range = std::pair<int, int>; // Option's min-max values
  33 using RangeFun = Range (int);
  34
  35 // Default Range function, to calculate Option's min-max values
  36 inline Range default_range(int v) {
  37   return v > 0 ? Range(0, 2 * v) : Range(2 * v, 0);
  38 }
  39
  40 struct SetRange {
  41   explicit SetRange(RangeFun f) : fun(f) {}
  42   SetRange(int min, int max) : fun(nullptr), range(min, max) {}
  43   Range operator()(int v) const { return fun ? fun(v) : range; }
  44
  45   RangeFun* fun;
  46   Range range;
  47 };
  48
  49 #define SetDefaultRange SetRange(default_range)
  50
  51
  52 // Tune class implements the 'magic' code that makes the setup of a fishtest tuning
  53 // session as easy as it can be. Mainly you have just to remove const qualifiers
  54 // from the variables you want to tune and flag them for tuning, so if you have:
  55 //
  56 //   const Value myValue[][2] = { { V(100), V(20) }, { V(7), V(78) } };
  57 //
  58 // If you have a my_post_update() function to run after values have been updated,
  59 // and a my_range() function to set custom Option's min-max values, then you just
  60 // remove the 'const' qualifiers and write somewhere below in the file:
  61 //
  62 //   TUNE(SetRange(my_range), myValue, my_post_update);
  63 //
  64 // You can also set the range directly, and restore the default at the end
  65 //
  66 //   TUNE(SetRange(-100, 100), myValue, SetDefaultRange);
  67 //
  68 // In case update function is slow and you have many parameters, you can add:
  69 //
  70 //   UPDATE_ON_LAST();
  71 //
  72 // And the values update, including post update function call, will be done only
  73 // once, after the engine receives the last UCI option, that is the one defined
  74 // and created as the last one, so the GUI should send the options in the same
  75 // order in which have been defined.
  76
  77 class Tune {
  78
  79   using PostUpdate = void (); // Post-update function
  80
  81   Tune() { read_results(); }
  82   Tune(const Tune&) = delete;
  83   void operator=(const Tune&) = delete;
  84   void read_results();
  85
  86   static Tune& instance() { static Tune t; return t; } // Singleton
  87
  88   // Use polymorphism to accommodate Entry of different types in the same vector
  89   struct EntryBase {
  90     virtual ~EntryBase() = default;
  91     virtual void init_option() = 0;
  92     virtual void read_option() = 0;
  93   };
  94
  95   template<typename T>
  96   struct Entry : public EntryBase {
  97
  98     static_assert(!std::is_const_v<T>, "Parameter cannot be const!");
  99
 100     static_assert(   std::is_same_v<T, int>
 101                   || std::is_same_v<T, Value>
 102                   || std::is_same_v<T, PostUpdate>, "Parameter type not supported!");
 103
 104     Entry(const std::string& n, T& v, const SetRange& r) : name(n), value(v), range(r) {}
 105     void operator=(const Entry&) = delete; // Because 'value' is a reference
 106     void init_option() override;
 107     void read_option() override;
 108
 109     std::string name;
 110     T& value;
 111     SetRange range;
 112   };
 113
 114   // Our facility to fill the container, each Entry corresponds to a parameter
 115   // to tune. We use variadic templates to deal with an unspecified number of
 116   // entries, each one of a possible different type.
 117   static std::string next(std::string& names, bool pop = true);
 118
 119   int add(const SetRange&, std::string&&) { return 0; }
 120
 121   template<typename T, typename... Args>
 122   int add(const SetRange& range, std::string&& names, T& value, Args&&... args) {
 123     list.push_back(std::unique_ptr<EntryBase>(new Entry<T>(next(names), value, range)));
 124     return add(range, std::move(names), args...);
 125   }
 126
 127   // Template specialization for arrays: recursively handle multi-dimensional arrays
 128   template<typename T, size_t N, typename... Args>
 129   int add(const SetRange& range, std::string&& names, T (&value)[N], Args&&... args) {
 130     for (size_t i = 0; i < N; i++)
 131         add(range, next(names, i == N - 1) + "[" + std::to_string(i) + "]", value[i]);
 132     return add(range, std::move(names), args...);
 133   }
 134
 135   // Template specialization for SetRange
 136   template<typename... Args>
 137   int add(const SetRange&, std::string&& names, SetRange& value, Args&&... args) {
 138     return add(value, (next(names), std::move(names)), args...);
 139   }
 140
 141   std::vector<std::unique_ptr<EntryBase>> list;
 142
 143 public:
 144   template<typename... Args>
 145   static int add(const std::string& names, Args&&... args) {
 146     return instance().add(SetDefaultRange, names.substr(1, names.size() - 2), args...); // Remove trailing parenthesis
 147   }
 148   static void init() { for (auto& e : instance().list) e->init_option(); read_options(); } // Deferred, due to UCI::Options access
 149   static void read_options() { for (auto& e : instance().list) e->read_option(); }
 150   static bool update_on_last;
 151 };
 152
 153 // Some macro magic :-) we define a dummy int variable that the compiler initializes calling Tune::add()
 154 #define STRINGIFY(x) #x
 155 #define UNIQUE2(x, y) x ## y
 156 #define UNIQUE(x, y) UNIQUE2(x, y) // Two indirection levels to expand __LINE__
 157 #define TUNE(...) int UNIQUE(p, __LINE__) = Tune::add(STRINGIFY((__VA_ARGS__)), __VA_ARGS__)
 158
 159 #define UPDATE_ON_LAST() bool UNIQUE(p, __LINE__) = Tune::update_on_last = true
 160
 161 } // namespace Stockfish
 162
 163 #endif // #ifndef TUNE_H_INCLUDED