stellar

UCI Chess engine written in C++20

git clone git://git.dimitrijedobrota.com/stellar.git

commit	7bfd425bdb622ab79089b11a8b6648226125079e
parent	2d0ab1b27672f89ac0096924217704544c4a8901
author	Dimitrije Dobrota <mail@dimitrijedobrota.com>
date	Mon, 11 Mar 2024 15:27:24 +0000

Get rid of constexpr table initialization * Drastically reduce compile time * Drastically compiler load

Diffstat:

M	CMakeLists.txt	\|	+-----------------
M	src/arena/arena.cpp	\|	++
M	src/attack/CMakeLists.txt	\|	+-
M	src/attack/attack.cpp	\|	+++++++++
M	src/attack/attack.hpp	\|	++--
A	src/attack/bishop.cpp	\|	+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
M	src/attack/bishop.hpp	\|	++++------------------------------------------------------------------------------
M	src/attack/queen.hpp	\|	+-
A	src/attack/rook.cpp	\|	+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
M	src/attack/rook.hpp	\|	+++-------------------------------------------------------------------------------
M	src/attack/slider.hpp	\|	++
M	src/engine/engine.cpp	\|	+
M	src/perft/perft.cpp	\|	++

13 files changed, 214 insertions(+), 201 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt

@@ -3,7 +3,7 @@ set(CMAKE_EXPORT_COMPILE_COMMANDS ON)

project(

Stellar

VERSION 1.2.2

VERSION 1.2.3

DESCRIPTION "Chess engine written in C++"

HOMEPAGE_URL https://git.dimitrijedobrota.com/stellar.git

LANGUAGES CXX

@@ -25,7 +25,6 @@ set(CMAKE_BUILD_TYPE "${CMAKE_BUILD_TYPE}" CACHE STRING

FORCE

)

include(CheckCXXCompilerFlag)

option(STELLAR_ENABLE_PCH "Build using pre-compiled headers" ON)

@@ -35,21 +34,6 @@ function(stellar_target_precompile_headers)

endif()

endfunction()

CHECK_CXX_COMPILER_FLAG("-fconstexpr-ops-limit=10000000000" COMPILER_SUPPORTS_CONSTEXPR_OPS_LIMIT)

if(COMPILER_SUPPORTS_CONSTEXPR_OPS_LIMIT)

set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fconstexpr-ops-limit=1000000000")

endif()

CHECK_CXX_COMPILER_FLAG("-fconstexpr-steps=1000000000" COMPILER_SUPPORTS_CONSTEXPR_STEPS)

if(COMPILER_SUPPORTS_CONSTEXPR_STEPS)

set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fconstexpr-steps=1000000000")

endif()

CHECK_CXX_COMPILER_FLAG("-march=native" COMPILER_SUPPORTS_MARCH_NATIVE)

if(COMPILER_SUPPORTS_MARCH_NATIVE)

set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=native")

endif()

add_subdirectory(src)

include(CheckIPOSupported)

diff --git a/src/arena/arena.cpp b/src/arena/arena.cpp

@@ -7,6 +7,7 @@

#include <bits/getopt_core.h>

#include <stdexcept>

#include "attack.hpp"

#include "logger.hpp"

#include "match.hpp"

@@ -95,6 +96,7 @@ int main(int argc, char *argv[]) {

for (int i = optind; i < argc; i++)

positions.emplace_back(!strcmp(argv[i], "-") ? start_position : argv[i]);

attack::init();

Arena arena(engine1, engine2);

arena(positions, settings1, settings2);

diff --git a/src/attack/CMakeLists.txt b/src/attack/CMakeLists.txt

@@ -1,4 +1,4 @@

add_library(attack attack.cpp)

add_library(attack attack.cpp bishop.cpp rook.cpp)

target_link_libraries(attack

PRIVATE bit

diff --git a/src/attack/attack.cpp b/src/attack/attack.cpp

@@ -1,1 +1,10 @@

#include "attack.hpp"

namespace attack {

void init(void) {

bishop::init();

rook::init();

}

} // namespace attack

diff --git a/src/attack/attack.hpp b/src/attack/attack.hpp

@@ -11,12 +11,12 @@

#include "pawnw.hpp"

#include "queen.hpp"

#include "rook.hpp"

#include "slider.hpp"

namespace attack {

void init(void);

using attack_f = U64 (*)(const square::Square, U64);

}

} // namespace attack

#endif

diff --git a/src/attack/bishop.cpp b/src/attack/bishop.cpp

@@ -0,0 +1,94 @@

#include "bishop.hpp"

#include "bit.hpp"

#include "bitboard.hpp"

#include "slider.hpp"

#include <array>

#include <iostream>

namespace attack {

namespace bishop {

inline constexpr const U64 bishop_magic_numbers[64] = {

C64(0x40040844404084), C64(0x2004208a004208), C64(0x10190041080202), C64(0x108060845042010),

C64(0x581104180800210), C64(0x2112080446200010), C64(0x1080820820060210), C64(0x3c0808410220200),

C64(0x4050404440404), C64(0x21001420088), C64(0x24d0080801082102), C64(0x1020a0a020400),

C64(0x40308200402), C64(0x4011002100800), C64(0x401484104104005), C64(0x801010402020200),

C64(0x400210c3880100), C64(0x404022024108200), C64(0x810018200204102), C64(0x4002801a02003),

C64(0x85040820080400), C64(0x810102c808880400), C64(0xe900410884800), C64(0x8002020480840102),

C64(0x220200865090201), C64(0x2010100a02021202), C64(0x152048408022401), C64(0x20080002081110),

C64(0x4001001021004000), C64(0x800040400a011002), C64(0xe4004081011002), C64(0x1c004001012080),

C64(0x8004200962a00220), C64(0x8422100208500202), C64(0x2000402200300c08), C64(0x8646020080080080),

C64(0x80020a0200100808), C64(0x2010004880111000), C64(0x623000a080011400), C64(0x42008c0340209202),

C64(0x209188240001000), C64(0x400408a884001800), C64(0x110400a6080400), C64(0x1840060a44020800),

C64(0x90080104000041), C64(0x201011000808101), C64(0x1a2208080504f080), C64(0x8012020600211212),

C64(0x500861011240000), C64(0x180806108200800), C64(0x4000020e01040044), C64(0x300000261044000a),

C64(0x802241102020002), C64(0x20906061210001), C64(0x5a84841004010310), C64(0x4010801011c04),

C64(0xa010109502200), C64(0x4a02012000), C64(0x500201010098b028), C64(0x8040002811040900),

C64(0x28000010020204), C64(0x6000020202d0240), C64(0x8918844842082200), C64(0x4010011029020020),

};

static inline constexpr const int relevant_bits[64] = {

// clang-format off

6, 5, 5, 5, 5, 5, 5, 6,

5, 5, 5, 5, 5, 5, 5, 5,

5, 5, 7, 7, 7, 7, 5, 5,

5, 5, 7, 9, 9, 7, 5, 5,

5, 5, 7, 7, 7, 7, 5, 5,

5, 5, 5, 5, 5, 5, 5, 5,

6, 5, 5, 5, 5, 5, 5, 6,

// clang-format on

};

inline constexpr const bitboard::direction_f dir[4] = {bitboard::noEaOne, bitboard::noWeOne,

bitboard::soEaOne, bitboard::soWeOne};

inline constexpr U32 hash(const U64 key, const square::Square square) {

uint8_t square_i = to_underlying(square);

return (key * bishop_magic_numbers[square_i]) >> (64 - relevant_bits[square_i]);

}

inline constexpr U64 mask_fly(const square::Square square, U64 block) {

uint8_t square_i = to_underlying(square);

int tr = square_i / 8, tf = square_i % 8;

int len[4] = {std::min(7 - tf, 7 - tr), std::min(tf, 7 - tr), std::min(7 - tf, tr), std::min(tf, tr)};

return attack::slider::mask(square, block, dir, len);

}

std::array<U64, 64> masks = {{0}};

inline U64 mask(const square::Square square) { return masks[to_underlying(square)]; }

std::array<std::array<U64, 4098>, 64> attacks = {{{0}}};

void init(void) {

for (uint8_t square = 0; square < 64; square++) {

int tr = square / 8, tf = square % 8;

int len[4] = {std::min(7 - tf, 7 - tr) - 1, std::min(tf, 7 - tr) - 1, std::min(7 - tf, tr) - 1,

std::min(tf, tr) - 1};

masks[square] = attack::slider::mask(static_cast<square::Square>(square), C64(0), dir, len);

}

for (uint8_t square = 0; square < 64; square++) {

square::Square Square = static_cast<square::Square>(square);

U64 attack_mask = mask(Square);

uint8_t relevant_bits = bit::count(attack_mask);

U64 occupancy_indices = C64(1) << relevant_bits;

for (U64 idx = 0; idx < occupancy_indices; idx++) {

U64 occupancy = attack::slider::occupancy(idx, relevant_bits, attack_mask);

U32 magic_index = hash(occupancy, Square);

attacks[square][magic_index] = mask_fly(Square, occupancy);

}

U64 attack(const square::Square square, U64 occupancy) {

occupancy &= mask(square);

occupancy = hash(occupancy, square);

return attacks[to_underlying(square)][occupancy];

}

} // namespace bishop

} // namespace attack

diff --git a/src/attack/bishop.hpp b/src/attack/bishop.hpp

@@ -1,103 +1,16 @@

#ifndef STELLAR_ATTACK_BISHOP_H

#define STELLAR_ATTACK_BISHOP_H

#ifndef STELLAR_BISHOP_H

#define STELLAR_BISHOP_H

#include "bit.hpp"

#include "bitboard.hpp"

#include "slider.hpp"

#include "square.hpp"

#include "utils.hpp"