src/Bit-Genie

src/generated_*.txt

#pragma once

#include "../stringparse.h"

class CommandLineParser {

CommandLineParser(int argc, char **argv) {

options = std::vector<std::string>(argv, argv + argc);

}

std::string get_option(std::string_view key) const {

for (std::size_t i = 0; i < options.size(); i++) {

if (options[i] == key)

return options[i + 1];

}

return "";

}

uint64_t get_option(std::string_view key, uint64_t default_value) const {

std::string value = get_option(key);

return value.size() ? std::stoull(value) : default_value;

}

std::vector<std::string> options;

};

#include "game.h"

#define DRAW_STRING ("[0.5]")

#define WHITE_WIN_STRING ("[1.0]")

#define BLACK_WIN_STRING ("[0.0]")

Game::Game(std::ofstream &output_file, std::mt19937 &rng)

: output_file(output_file), rng(rng) {}

bool Game::filter_position() {

return (qsearch(search, MIN_EVAL, MAX_EVAL) == search.position.static_evaluation()) && !search.position.king_in_check();

}

bool Game::make_book_move() {

if (is_mated())

return false;

Movelist movelist;

search.position.generate_legal(movelist);

std::uniform_int_distribution distribution(0, static_cast<int>(movelist.size() - 1));

int rand_index = distribution(rng);

search.position.apply_move(movelist[rand_index]);

ply++;

return true;

}

void Game::save_position(int search_score) {

saved_positions.push_back({ search.position.get_fen(), search_score });

}

bool Game::is_mated() const {

Movelist movelist;

search.position.generate_legal(movelist);

return movelist.size() == 0;

}

void Game::new_game() {

ply = 0;

search.position.set_fen("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1");

saved_positions.clear();

search.reset();

}

void Game::save_game(std::string const &result) {

for (auto const &saved_position : saved_positions) {

std::string line = saved_position.first + " " + result + " " + std::to_string(saved_position.second);

output_file << line << '\n';

}

}

SearchResult Game::search_position() {

return ::search_position(search, false);

}

void Game::run() {

std::string wdl_string;

int draw_score_counter = 0, win_score_counter = 0;

while (true) {

/* TODO: command line arg */

if (ply < 8) {

if (!make_book_move())

break;

continue;

}

if (search.position.drawn()) {

wdl_string = DRAW_STRING;

break;

}

if (is_mated()) {

if (search.position.king_in_check())

wdl_string = search.position.get_side() == CLR_WHITE ? BLACK_WIN_STRING : WHITE_WIN_STRING;

else

wdl_string = DRAW_STRING;

break;

}

auto result = search_position();

int white_relative_score = search.position.get_side() == CLR_WHITE ? result.score : -result.score;

// TODO command line arg

if (result.score >= 1000 && ply == 8)

return;

if (filter_position())

save_position(white_relative_score);

// TODO command line arg

bool is_draw_score = std::abs(result.score) <= 20;

bool is_win_score = std::abs(result.score) >= 1000;

draw_score_counter = is_draw_score ? draw_score_counter + 1 : 0;

win_score_counter = is_win_score ? win_score_counter + 1 : 0;

// TODO command line arg

if (draw_score_counter >= 12) {

wdl_string = DRAW_STRING;

break;

}

if (win_score_counter >= 4) {

wdl_string = white_relative_score > 0 ? WHITE_WIN_STRING : BLACK_WIN_STRING;

break;

}

search.position.apply_move(result.best_move);

search.reset_counters();

ply++;

}

save_game(wdl_string);

}

#pragma once

#include "../search.h"

#include "../position.h"

#include <vector>

#include <random>

#include <memory>

#include <fstream>

#include <utility>

#include <string_view>

class Game {

Game(std::ofstream &output_file, std::mt19937 &rng);

bool filter_position();

bool make_book_move();

void save_position(int search_score);

bool is_mated() const;

void save_game(std::string const &result);

void new_game();

SearchResult search_position();

void run();

std::size_t total_fens_written() const {

return saved_positions.size();

}

int ply = 0;

SearchInfo search;

std::ofstream &output_file;

std::mt19937 &rng;

std::vector<std::pair<std::string, int>> saved_positions;

};

#include "generator.h"

#include <chrono>

#include <time.h>

#include <iomanip>

#include <sstream>

std::string get_current_date_time() {

auto now = std::chrono::system_clock::now();

auto in_time_t = std::chrono::system_clock::to_time_t(now);

std::stringstream ss;

ss << std::put_time(std::localtime(&in_time_t), "%Y-%m-%d %X");

return ss.str();

}

void GamePool::run_batch(std::string_view output_file_path, std::uint64_t target_fens, std::uint64_t seed) {

std::mt19937 rng(seed);

std::ofstream output_file(output_file_path.data());

if (!output_file) {

std::cerr << "Couldn't open " << output_file_path << std::endl;

std::terminate();

}

Game game(output_file, rng);

for (std::uint64_t n_batch_fens = 0; n_batch_fens <= target_fens;) {

game.run();

n_games++;

n_batch_fens += game.total_fens_written();

n_fens += game.total_fens_written();

game.new_game();

}

output_file.close();

}

void GamePool::run(std::uint64_t target_fens) {

std::random_device rd;

std::uint64_t batch_size = target_fens / FEN_GENERATOR_THREADS;

for (int i = 0; i < FEN_GENERATOR_THREADS; i++) {

std::string output_path = "generated_" + std::to_string(i) + ".txt";

workers.emplace_back(&GamePool::run_batch, this, output_path, batch_size, rd());

}

std::cout << "\n{" << get_current_date_time() << "}: started generation\n";

std::uint64_t n_previous_fens = 0;

while (n_fens <= (batch_size * FEN_GENERATOR_THREADS)) {

std::this_thread::sleep_for(std::chrono::seconds(1));

std::uint64_t n_batch_fens = n_fens - n_previous_fens;

std::cout << "\r{" << get_current_date_time() << "}: generating... [total=" << n_fens << ", speed=" << n_batch_fens << "]" << std::flush;

n_previous_fens = n_fens;

}

std::cout << '\n';

std::cout << "{" << get_current_date_time() << "}: finished generation" << std::endl;

for (auto &worker : workers)

worker.join();

}

#pragma once

#include "game.h"

#include "cmdline.h"

#include <thread>

#include <atomic>

inline int FEN_GENERATOR_THREADS = 1;

class GamePool {

GamePool() = default;

void run(std::uint64_t target_fens);

void run_batch(std::string_view output_file, std::uint64_t target_fens, std::uint64_t seed);

std::vector<std::thread> workers;

std::atomic_uint64_t n_games = { 0 };

std::atomic_uint64_t n_fens = { 0 };

};