X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fucioption.cpp;h=ab8137c4492b99a26508ef3eed2e4caa76313609;hp=764324d6f01694b44e61e2537993c3002497ecf5;hb=5194b2bb06bbd0d29975bb35eda4d600e6bd8dcf;hpb=bb751d6c890f5c50c642366d601740366cfae8d0 diff --git a/src/ucioption.cpp b/src/ucioption.cpp index 764324d6..ab8137c4 100644 --- a/src/ucioption.cpp +++ b/src/ucioption.cpp @@ -1,270 +1,182 @@ /* - Glaurung, a UCI chess playing engine. - Copyright (C) 2004-2008 Tord Romstad + Stockfish, a UCI chess playing engine derived from Glaurung 2.1 + Copyright (C) 2004-2008 Tord Romstad (Glaurung author) + Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad - Glaurung is free software: you can redistribute it and/or modify + Stockfish is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. - - Glaurung is distributed in the hope that it will be useful, + + Stockfish is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. - + You should have received a copy of the GNU General Public License along with this program. If not, see . */ - -//// -//// Includes -//// - -#include -#include -#include +#include +#include +#include #include "misc.h" #include "thread.h" #include "ucioption.h" +using std::string; +using std::cout; +using std::endl; -//// -//// Variables -//// - -bool Chess960 = false; - - -//// -//// Local definitions -//// - -namespace { - - /// - /// Types - /// - - enum OptionType { SPIN, COMBO, CHECK, STRING, BUTTON, OPTION_TYPE_NONE}; - - struct Option { - char name[50], defaultValue[300], currentValue[300]; - OptionType type; - int minValue, maxValue; - char comboValues[8][64]; - }; - - - /// - /// Variables - /// - - Option Options[] = { - { "Use Search Log", "false", "false", CHECK, 0, 0, {""} }, - { "Search Log Filename", "SearchLog.txt", "SearchLog.txt", STRING, 0, 0, {""} }, - { "Book File", "book.bin", "book.bin", STRING, 0, 0, {""} }, - { "Mobility (Middle Game)", "100", "100", SPIN, 0, 200, {""} }, - { "Mobility (Endgame)", "100", "100", SPIN, 0, 200, {""} }, - { "Pawn Structure (Middle Game)", "100", "100", SPIN, 0, 200, {""} }, - { "Pawn Structure (Endgame)", "100", "100", SPIN, 0, 200, {""} }, - { "Passed Pawns (Middle Game)", "100", "100", SPIN, 0, 200, {""} }, - { "Passed Pawns (Endgame)", "100", "100", SPIN, 0, 200, {""} }, - { "Aggressiveness", "100", "100", SPIN, 0, 200, {""} }, - { "Cowardice", "100", "100", SPIN, 0, 200, {""} }, - { "King Safety Curve", "Quadratic", "Quadratic", COMBO, 0, 0, - { "Quadratic", "Linear" /*, "From File"*/ } }, - { "King Safety Coefficient", "40", "40", SPIN, 1, 100 , {""} }, - { "King Safety X Intercept", "0", "0", SPIN, 0, 20, {""} }, - { "King Safety Max Slope", "30", "30", SPIN, 10, 100, {""} }, - { "King Safety Max Value", "500", "500", SPIN, 100, 1000, {""} }, - { "Queen Contact Check Bonus", "4", "4", SPIN, 0, 8, {""} }, - { "Rook Contact Check Bonus", "2", "2", SPIN, 0, 4, {""} }, - { "Queen Check Bonus", "2", "2", SPIN, 0, 4, {""} }, - { "Rook Check Bonus", "1", "1", SPIN, 0, 4, {""} }, - { "Bishop Check Bonus", "1", "1", SPIN, 0, 4, {""} }, - { "Knight Check Bonus", "1", "1", SPIN, 0, 4, {""} }, - { "Discovered Check Bonus", "3", "3", SPIN, 0, 8, {""} }, - { "Mate Threat Bonus", "3", "3", SPIN, 0, 8, {""} }, - { "Check Extension (PV nodes)", "2", "2", SPIN, 0, 2, {""} }, - { "Check Extension (non-PV nodes)", "1", "1", SPIN, 0, 2, {""} }, - { "Single Reply Extension (PV nodes)", "2", "2", SPIN, 0, 2, {""} }, - { "Single Reply Extension (non-PV nodes)", "2", "2", SPIN, 0, 2, {""} }, - { "Mate Threat Extension (PV nodes)", "0", "0", SPIN, 0, 2, {""} }, - { "Mate Threat Extension (non-PV nodes)", "0", "0", SPIN, 0, 2, {""} }, - { "Pawn Push to 7th Extension (PV nodes)", "1", "1", SPIN, 0, 2, {""} }, - { "Pawn Push to 7th Extension (non-PV nodes)", "1", "1", SPIN, 0, 2, {""} }, - { "Passed Pawn Extension (PV nodes)", "1", "1", SPIN, 0, 2, {""} }, - { "Passed Pawn Extension (non-PV nodes)", "0", "0", SPIN, 0, 2, {""} }, - { "Pawn Endgame Extension (PV nodes)", "2", "2", SPIN, 0, 2, {""} }, - { "Pawn Endgame Extension (non-PV nodes)", "2", "2", SPIN, 0, 2, {""} }, - { "Full Depth Moves (PV nodes)", "14", "14", SPIN, 1, 100, {""} }, - { "Full Depth Moves (non-PV nodes)", "3", "3", SPIN, 1, 100, {""} }, - { "Threat Depth", "5", "5", SPIN, 0, 100, {""} }, - { "Selective Plies", "7", "7", SPIN, 0, 10, {""} }, - { "Futility Pruning (Main Search)", "true", "true", CHECK, 0, 0, {""} }, - { "Futility Pruning (Quiescence Search)", "true", "true", CHECK, 0, 0, {""} }, - { "Futility Margin 0", "50", "50", SPIN, 0, 1000, {""} }, - { "Futility Margin 1", "100", "100", SPIN, 0, 1000, {""} }, - { "Futility Margin 2", "300", "300", SPIN, 0, 1000, {""} }, - { "Maximum Razoring Depth", "3", "3", SPIN, 0, 4, {""} }, - { "Razoring Margin", "300", "300", SPIN, 150, 600, {""} }, - { "Randomness", "0", "0", SPIN, 0, 10, {""} }, - { "Minimum Split Depth", "4", "4", SPIN, 4, 7, {""} }, - { "Maximum Number of Threads per Split Point", "5", "5", SPIN, 4, 8, {""} }, - { "Threads", "1", "1", SPIN, 1, 8, {""} }, - { "Hash", "32", "32", SPIN, 4, 4096, {""} }, - { "Clear Hash", "false", "false", BUTTON, 0, 0, {""} }, - { "Ponder", "true", "true", CHECK, 0, 0, {""} }, - { "OwnBook", "true", "true", CHECK, 0, 0, {""} }, - { "MultiPV", "1", "1", SPIN, 1, 500, {""} }, - { "UCI_ShowCurrLine", "false", "false", CHECK, 0, 0, {""} }, - { "UCI_Chess960", "false", "false", CHECK, 0, 0, {""} }, - { "", "", "", OPTION_TYPE_NONE, 0, 0, {""}} - }; - - - /// - /// Functions - /// - - Option *option_with_name(const char *optionName); +OptionsMap Options; // Global object -} +// Our case insensitive less() function as required by UCI protocol +bool CaseInsensitiveLess::operator() (const string& s1, const string& s2) const { -//// -//// Functions -//// + int c1, c2; + size_t i = 0; -/// init_uci_options() initializes the UCI options. Currently, the only -/// thing this function does is to initialize the default value of the -/// "Threads" parameter to the number of available CPU cores. + while (i < s1.size() && i < s2.size()) + { + c1 = tolower(s1[i]); + c2 = tolower(s2[i++]); -void init_uci_options() { - Option *o; - - o = option_with_name("Threads"); - assert(o != NULL); - - // Limit the default value of "Threads" to 7 even if we have 8 CPU cores. - // According to Ken Dail's tests, Glaurung plays much better with 7 than - // with 8 threads. This is weird, but it is probably difficult to find out - // why before I have a 8-core computer to experiment with myself. - sprintf(o->defaultValue, "%d", Min(cpu_count(), 7)); - sprintf(o->currentValue, "%d", Min(cpu_count(), 7)); - - // Increase the minimum split depth when the number of CPUs is big. - // It would probably be better to let this depend on the number of threads - // instead. - o = option_with_name("Minimum Split Depth"); - assert(o != NULL); - if(cpu_count() > 4) { - sprintf(o->defaultValue, "%d", 6); - sprintf(o->defaultValue, "%d", 6); + if (c1 != c2) + return c1 < c2; } + return s1.size() < s2.size(); } -/// print_uci_options() prints all the UCI options to the standard output, -/// in the format defined by the UCI protocol. - -void print_uci_options() { - static const char optionTypeName[][16] = { - "spin", "combo", "check", "string", "button" - }; - for(Option *o = Options; o->type != OPTION_TYPE_NONE; o++) { - printf("option name %s type %s", o->name, optionTypeName[o->type]); - if(o->type != BUTTON) { - printf(" default %s", o->defaultValue); - if(o->type == SPIN) - printf(" min %d max %d", o->minValue, o->maxValue); - else if(o->type == COMBO) - for(int i = 0; strlen(o->comboValues[i]) > 0; i++) - printf(" var %s", o->comboValues[i]); - } - printf("\n"); - } +// stringify() converts a numeric value of type T to a std::string +template +static string stringify(const T& v) { + + std::ostringstream ss; + ss << v; + return ss.str(); } -/// get_option_value_bool() returns the current value of a UCI parameter of -/// type "check". +/// init_uci_options() initializes the UCI options to their hard coded default +/// values and initializes the default value of "Threads" and "Minimum Split Depth" +/// parameters according to the number of CPU cores. -bool get_option_value_bool(const std::string &optionName) { - Option *o = option_with_name(optionName.c_str()); - return o != NULL && strcmp(o->currentValue, "true") == 0; -} +void init_uci_options() { + Options["Use Search Log"] = Option(false); + Options["Search Log Filename"] = Option("SearchLog.txt"); + Options["Book File"] = Option("book.bin"); + Options["Best Book Move"] = Option(false); + Options["Mobility (Middle Game)"] = Option(100, 0, 200); + Options["Mobility (Endgame)"] = Option(100, 0, 200); + Options["Pawn Structure (Middle Game)"] = Option(100, 0, 200); + Options["Pawn Structure (Endgame)"] = Option(100, 0, 200); + Options["Passed Pawns (Middle Game)"] = Option(100, 0, 200); + Options["Passed Pawns (Endgame)"] = Option(100, 0, 200); + Options["Space"] = Option(100, 0, 200); + Options["Aggressiveness"] = Option(100, 0, 200); + Options["Cowardice"] = Option(100, 0, 200); + Options["Check Extension (PV nodes)"] = Option(2, 0, 2); + Options["Check Extension (non-PV nodes)"] = Option(1, 0, 2); + Options["Single Evasion Extension (PV nodes)"] = Option(2, 0, 2); + Options["Single Evasion Extension (non-PV nodes)"] = Option(2, 0, 2); + Options["Mate Threat Extension (PV nodes)"] = Option(2, 0, 2); + Options["Mate Threat Extension (non-PV nodes)"] = Option(2, 0, 2); + Options["Pawn Push to 7th Extension (PV nodes)"] = Option(1, 0, 2); + Options["Pawn Push to 7th Extension (non-PV nodes)"] = Option(1, 0, 2); + Options["Passed Pawn Extension (PV nodes)"] = Option(1, 0, 2); + Options["Passed Pawn Extension (non-PV nodes)"] = Option(0, 0, 2); + Options["Pawn Endgame Extension (PV nodes)"] = Option(2, 0, 2); + Options["Pawn Endgame Extension (non-PV nodes)"] = Option(2, 0, 2); + Options["Minimum Split Depth"] = Option(4, 4, 7); + Options["Maximum Number of Threads per Split Point"] = Option(5, 4, 8); + Options["Threads"] = Option(1, 1, MAX_THREADS); + Options["Use Sleeping Threads"] = Option(true); + Options["Hash"] = Option(32, 4, 8192); + Options["Clear Hash"] = Option(false, "button"); + Options["Ponder"] = Option(true); + Options["OwnBook"] = Option(true); + Options["MultiPV"] = Option(1, 1, 500); + Options["Emergency Move Horizon"] = Option(40, 0, 50); + Options["Emergency Base Time"] = Option(200, 0, 30000); + Options["Emergency Move Time"] = Option(70, 0, 5000); + Options["Minimum Thinking Time"] = Option(20, 0, 5000); + Options["UCI_Chess960"] = Option(false); + Options["UCI_AnalyseMode"] = Option(false); + + // Set some SMP parameters accordingly to the detected CPU count + Option& thr = Options["Threads"]; + Option& msd = Options["Minimum Split Depth"]; + + thr.defaultValue = thr.currentValue = stringify(cpu_count()); + + if (cpu_count() >= 8) + msd.defaultValue = msd.currentValue = stringify(7); +} -/// get_option_value_int() returns the value of a UCI parameter as an integer. -/// Normally, this function will be used for a parameter of type "spin", but -/// it could also be used with a "combo" parameter, where all the available -/// values are integers. -int get_option_value_int(const std::string &optionName) { - Option *o = option_with_name(optionName.c_str()); - return atoi(o->currentValue); -} +/// options_to_uci() returns a string with all the UCI options in chronological +/// insertion order (the idx field) and in the format defined by the UCI protocol. +string options_to_uci() { -/// get_option_value_string() returns the current value of a UCI parameter as -/// a string. It is used with parameters of type "combo" and "string". + std::stringstream s; -const std::string get_option_value_string(const std::string &optionName) { - Option *o = option_with_name(optionName.c_str()); - return o->currentValue; -} + for (size_t i = 0; i <= Options.size(); i++) + for (OptionsMap::const_iterator it = Options.begin(); it != Options.end(); ++it) + if (it->second.idx == i) + { + const Option& o = it->second; + s << "\noption name " << it->first << " type " << o.type; + if (o.type != "button") + s << " default " << o.defaultValue; -/// button_was_pressed() tests whether a UCI parameter of type "button" has -/// been selected since the last time the function was called. + if (o.type == "spin") + s << " min " << o.minValue << " max " << o.maxValue; -bool button_was_pressed(const std::string &buttonName) { - if(get_option_value_bool(buttonName)) { - set_option_value(buttonName, "false"); - return true; - } - else - return false; + break; + } + return s.str(); } -/// set_option_value() inserts a new value for a UCI parameter. Note that -/// the function does not check that the new value is legal for the given -/// parameter: This is assumed to be the responsibility of the GUI. +/// Option class c'tors -void set_option_value(const std::string &optionName, - const std::string &newValue) { - Option *o = option_with_name(optionName.c_str()); +Option::Option(const char* def) : type("string"), idx(Options.size()), minValue(0), maxValue(0) +{ defaultValue = currentValue = def; } - if(o != NULL) - strcpy(o->currentValue, newValue.c_str()); - else - std::cout << "No such option: " << optionName << std::endl; -} +Option::Option(bool def, string t) : type(t), idx(Options.size()), minValue(0), maxValue(0) +{ defaultValue = currentValue = (def ? "true" : "false"); } +Option::Option(int def, int minv, int maxv) : type("spin"), idx(Options.size()), minValue(minv), maxValue(maxv) +{ defaultValue = currentValue = stringify(def); } -/// push_button() is used to tell the engine that a UCI parameter of type -/// "button" has been selected: -void push_button(const std::string &buttonName) { - set_option_value(buttonName, "true"); -} +/// set_value() updates currentValue of the Option object. Normally it's up to +/// the GUI to check for option's limits, but we could receive the new value +/// directly from the user by teminal window. So let's check the bounds anyway. + +void Option::set_value(const string& value) { + + assert(!type.empty()); + if (value.empty()) + return; -namespace { + if ( (type == "check" || type == "button") + != (value == "true" || value == "false")) + return; - // option_with_name() tries to find a UCI option with a given - // name. It returns a pointer to the UCI option or the null pointer, - // depending on whether an option with the given name exists. - - Option *option_with_name(const char *optionName) { - for(Option *o = Options; o->type != OPTION_TYPE_NONE; o++) - if(strcmp(o->name, optionName) == 0) - return o; - return NULL; + if (type == "spin") + { + int v = atoi(value.c_str()); + if (v < minValue || v > maxValue) + return; } + currentValue = value; }