bel_debug.cpp

Go to the documentation of this file.

/*---------------------------------------------------------------------+
 * File: bel_debug.cpp
 * Project: part of belofte - A Promising Chess Program
 * Author: yves
 * SPDX-License-Identifier: GPL-2.0-only
+----------------------------------------------------------------------*/
 
#include "belofte.h"
 
//-----------------------------------------------------------------------
// NOLINTBEGIN
 
void bel_debug::execute(std::string const& args)
{
  if (args == "on") {
    App().setConfig("UCIdebug", 1);
    App().bout.setLevel(99);
  } else if (args == "off") {
    App().setConfig("UCIdebug", 0);
    App().bout.setLevel(0);
    /// @todo add abstraction level on different debug commands
    /// so that they do not need to be coded here (dynamic binding ?)
  } else if (args == "show fen") {
    App().bout << "info string fen " << Game()->getCurrentPosition().getFEN() << "\n";
  } else if (args == "help") {
    App().bout << show_help();
  } else if (args == "gamehistory") {
    App().bout << show_gamehistory();
  } else if (args == "fenhistory") {
    App().bout << show_fenhistory();
  } else if (args == "poshistory") {
    App().bout << show_poshistory();
  } else if (args == "hashhistory") {
    App().bout << show_hashhistory();
  } else if (args == "autosave") {
    App().bout << "not implemented yet\n";
  } else if (args == "logging") {
    App().bout << "not implemented yet\n";
  } else if (args == "ml") {
    bBoard const& b = Game()->getCurrentPosition();
    bMoveList ml;
    ml.generateMoves(b);
    bPgnMoveList pml(b);
    App().bout << "info string ml " << ml << "\n";
    App().bout << "info string ml " << pml << "\n";
  } else if (args == "sortmoves") {
    bBoard const& b = Game()->getCurrentPosition();
    bMoveList ml;
    ml.generateMoves(b);
    ml.sortMoves(false);
    bPgnMoveList pml(b);
    App().bout << "info string ml " << ml << "\n";
    App().bout << "info string ml " << pml << "\n";
  } else if (args == "setrunning") {
    AppEI()->setRunning(true);
  } else if (args == "wait") {
    bel_debug::wait();
  } else if (args == "invert") {
    Game()->getCurrentPosition().invertColours();
  } else if (args == "log on") {
    App().bout.attach(App().getName() + ".log");
  } else if (args == "log off") {
    App().bout.detach();
  } else if (args == "search on") {
    App().sout.attach(App().getName() + ".log");
  } else if (args == "search off") {
    App().sout.detach();
  } else if (args == "verbose 0") {
    /// @todo move to verbose command
    App().sout.setLevel(0);
  } else if (args == "verbose 1") {
    App().sout.setLevel(1);
  } else if (args == "verbose 2") {
    App().sout.setLevel(2);
  } else if (args == "verbose 3") {
    App().sout.setLevel(3);
  } else if (args == "verbose 4") {
    App().sout.setLevel(4);
  } else if (args == "verbose 5") {
    App().sout.setLevel(5);
  } else if (args == "verbose all") {
    App().sout.setLevel(99);
  } else if (args == "") {
    App().bout.setLevel(50);
  } else {
    AppEI()->sendError("argument invalid", "debug " + args);
  }
}
 
void bel_debug::info() const
{
  App().bout << "Info for: " << App().getName() << " - "
          << "Version: " MYVERSION << "\n";
  App().bout << "Built on: " MYRELEASEDATE " for " MYOS " - " MYPLATFORM << "\n";
  App().bout << "Compiled by: " BELOFTE_COMPILER " with flags:";
#if defined(CHRONO_MISSING)
  App().bout << " CHRONO_MISSING";
#endif
#if defined(BELOFTE_NORANDOM)
  App().bout << " BELOFTE_NORANDOM";
#endif
#if defined(BELOFTE_UCIMODE)
  App().bout << " BELOFTE_UCIMODE";
#endif
#if defined(BELOFTE_NOSIGNALS)
  App().bout << " BELOFTE_NOSIGNALS";
#endif
#if defined(BELOFTE_NOUNICODE)
  App().bout << " BELOFTE_NOUNICODE";
#endif
#if defined(INCOMPLETE_C11)
  App().bout << " INCOMPLETE_C11";
#endif
#if defined(NODIRENT)
  App().bout << " NODIRENT";
#endif
#if defined(_WIN32) || defined(WIN32)
  App().bout << " _WIN32";
#endif
#if defined(_DEBUG)
  App().bout << " _DEBUG";
#endif
#if defined(NO_NPS_LOG)
  App().bout << " NO_NPS_LOG";
#endif
  App().bout << "\n";
 
  App().bout
          << "Mode: " << AppEI()->operator std::string() << " - "
          << "UI details: " << belofte::to_string(App().bout.getLevel())
          << (App().bout.isAttached() ? " file " + App().bout.fn() : "")
          << " - Search details: " << belofte::to_string(App().sout.getLevel())
          << (App().sout.isAttached() ? " file: " + App().sout.fn() : "")
          << "\n";
 
  App().bout
          << "Eval: " << Game()->getEval()->operator std::string()
                      << (App().getConfig("random", 0) ? " +-rnd" : "")
                      << " - "
          << "Algo: " << Game()->getAlgorithm()->operator std::string() << "\n"
          << Game()->getLevel().operator std::string();
 
  App().bout.endl();
}
 
void bel_debug::run_bench(bSearchAlgorithm& search, depth_t const nDepth)
{
  int64_t nNodes;
  int64_t nNonLeafNodes;
  int64_t nDuration;
 
  search.m_iterativesearch = false;
 
  Game()->newGame();
  Game()->setFENInitialPos();
  nNodes = Game()->DoPerft(search, nDepth);
  nNonLeafNodes = search.getNonLeafNodes();
  nDuration = search.getDurationMicroSec();
 
  Game()->setFEN("n1n5/PPPk4/8/8/8/8/4Kppp/5N1N b - - 0 1");
  nNodes += Game()->DoPerft(search, nDepth);
  nNonLeafNodes += search.getNonLeafNodes();
  nDuration += search.getDurationMicroSec();
 
  App().bout(-1) << "bench " << search.operator std::string()
          << " Time: " << belofte::prettyTime(nDuration / 1000LL)
          << " Nodes: " << belofte::to_string(nNodes)
          << " Total N.: " << belofte::to_string(nNonLeafNodes + nNodes)
#if !defined(NO_NPS_LOG)
          << " NPS: " << belofte::to_string(static_cast<int64_t>((nNonLeafNodes + nNodes) * 1000000LL / nDuration))
#endif
          ;
  App().bout.endl();
}
 
/**
 * @static Class static function
 */
void bel_debug::wait()
{
  if (App().m_reader.isBatchMode()) {
    while (Game()->isSearching()) {
      // wait 200 ms before testing again
      TimedExecution::sleep_ms(200);
    }
  } else {
    AppEI()->sendError("Not in batch mode", "debug wait");
  }
}
 
/**
 * @static Class static function
 */
std::string bel_debug::show_help()
{
  std::stringstream os;
  os << "debug help        - this message" << "\n"
     << "debug [off|on]    - set level 50, 0 or 99, toggle UCI debug" << "\n"
     << "debug verbose n   - set level n (can be 0-5)" << "\n"
     << "debug verbose all - set level 99" << "\n"
     << "debug log on      - activate logfile for ui protocol" << "\n"
     << "debug log off     - de-activate logfile for ui protocol" << "\n"
     << "debug search on   - activate logfile for search" << "\n"
     << "debug search off  - de-activate logfile for search" << "\n"
     << "debug show fen    - display FEN string of current position" << "\n"
     << "debug ml          - show moves calculated for current position" << "\n"
     << "debug sortmoves   - sort moves and show moves calculated" << "\n"
     << "debug invert      - invert colours" << "\n"
     << "debug gamehistory - show complete game" << "\n"
     << "debug fenhistory  - show all fen strings of game" << "\n"
     << "debug poshistory  - show positions of game" << "\n"
     << "debug setrunning  - set xboard persistent running state" << "\n"
     << "debug wait        - wait for previous batch command to finish" << "\n";
 
  return os.str();
}
 
/**
 * @static Class static function
 */
std::string bel_debug::show_gamehistory()
{
  std::stringstream os;
  positions_t const& positions = Game()->getPositions();
 
  for (bBoard const& b : positions) {
    bMoveList ml;
    movenum_t n_moves = ml.generateMoves(b);
    os << "\n";
    os << b.getFEN() << "\n"
       << b << "\n";
    if (n_moves) {
      // only print moves if there are any
      bPgnMoveList pml(b);
      os << ml << "\n"
         << pml << "\n";
    }
  }
 
  return os.str();
}
 
/**
 * @static Class static function
 */
std::string bel_debug::show_poshistory()
{
  std::stringstream os;
  positions_t const& positions = Game()->getPositions();
 
  for (bBoard const& b : positions) {
    os << b << "\n";
  }
 
  return os.str();
}
 
/**
 * @static Class static function
 */
std::string bel_debug::show_fenhistory()
{
  std::stringstream os;
  positions_t const& positions = Game()->getPositions();
 
  for (bBoard const& b : positions) {
    os << b.getFEN() << "\n";
  }
 
  return os.str();
}
 
/**
 * @static Class static function
 */
std::string bel_debug::show_hashhistory()
{
  std::stringstream os;
  positions_t const& positions = Game()->getPositions();
 
  for (bBoard const& b : positions) {
    os << b.getHashStr() << " : " << b.getFEN() << "\n";
  }
 
  return os.str();
}
 
// NOLINTEND
// --------------------------------------------------------------------
 
// eof