bitboard-tables.h

Go to the documentation of this file.

// Hoover Chess Utilities / PGN reader
// Copyright (C) 2023-2026  Sami Kiminki
//
// This program 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.
//
// This program 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 <https://www.gnu.org/licenses/>.
 
#ifndef HOOVER_CHESS_UTILS__PGN_READER__BITBOARD_TABLES_H_INCLUDED
#define HOOVER_CHESS_UTILS__PGN_READER__BITBOARD_TABLES_H_INCLUDED
 
#include "pgnreader-config.h"
 
#include <array>
#include <cstdint>
 
#define BITBOARD_TABLES_HAVE_X86_BMI2             (HAVE_X86_BMI2)
#define BITBOARD_TABLES_HAVE_AARCH64_SVE2_BITPERM (0 && HAVE_AARCH64_SVE2_BITPERM)
 
#define BITBOARD_TABLES_HAVE_ELEMENTARY           0
#define BITBOARD_TABLES_HAVE_BLACK_MAGIC          (!(BITBOARD_TABLES_HAVE_X86_BMI2 || BITBOARD_TABLES_HAVE_AARCH64_SVE2_BITPERM))
#define BITBOARD_TABLES_HAVE_HYPERBOLA            0
 
namespace hoover_chess_utils::pgn_reader
{
 
struct BitBoardTables
{
    alignas(64)
    std::array<std::array<std::uint64_t, 2U>, 64U> pawnAttackMasks;
 
    alignas(64)
    std::array<std::uint64_t, 64U> knightAttackMasks;
 
    alignas(64)
    std::array<std::uint64_t, 64U> kingAttackMasks;
 
    alignas(64)
    std::array<std::array<std::uint64_t, 64U>, 65U> rayIntercepts;
 
    alignas(64)
    std::array<std::array<std::uint64_t, 64U>, 64U> raysFromKing;
 
    alignas(64)
    std::array<std::array<std::uint8_t, 8U>, 256U> rookHorizAttackMasks;
 
#if (BITBOARD_TABLES_HAVE_X86_BMI2)
    alignas(64) std::array<std::uint64_t, 64U> bmi2BishopMasks;
    alignas(64) std::array<const std::uint64_t *, 64U> bmi2BishopOffsets;
    alignas(64) std::array<std::uint64_t, 64U> bmi2RookMasks;
    alignas(64) std::array<const std::uint64_t *, 64U> bmi2RookOffsets;
    alignas(64) std::uint64_t bmi2BishopRookAttackData[5248U + 102400U];
#endif
 
#if (BITBOARD_TABLES_HAVE_ELEMENTARY)
    struct MasksAndMultipliers
    {
        std::uint64_t masks[3U];
        std::uint64_t shift;
        std::uint64_t multipliers[3U];
        std::uint64_t zeroPadding;
    };
 
    static_assert(sizeof(MasksAndMultipliers) == 64);
 
    alignas(64) std::array<MasksAndMultipliers, 64U> elementaryBishopMaskMults;
    alignas(64) std::array<std::uint32_t, 64U> elementaryBishopOffsets;
    alignas(64) std::array<MasksAndMultipliers, 64U> elementaryRookMaskMults;
    alignas(64) std::array<std::uint32_t, 64U> elementaryRookOffsets;
    alignas(64) std::array<std::uint64_t, 5248U + 102400U> elementaryBishopRookAttackData;
#endif
 
#if (BITBOARD_TABLES_HAVE_AARCH64_SVE2_BITPERM)
    alignas(64) std::array<std::uint64_t, 128U> sve2BishopRookMasks;
    alignas(64) std::array<std::uint64_t, 128U> sve2BishopRookOffsets;
    alignas(64) std::array<std::uint64_t, 5248U + 102400U> sve2BishopRookAttackData;
#endif
 
#if (BITBOARD_TABLES_HAVE_HYPERBOLA)
    struct HyperbolaAttackMasks
    {
        std::uint64_t sqBit;
        std::uint64_t vertMaskEx; // vertical column minus square
        std::uint64_t diagBLTREx; // diagonal minus square
        std::uint64_t diagBRTLEx; // anti-diagonal minus square
    };
 
    alignas(64) std::array<HyperbolaAttackMasks, 64U> hyperbolaAttackMasks;
#endif
 
#if (BITBOARD_TABLES_HAVE_BLACK_MAGIC)
    struct BlackMagicData {
        const std::uint64_t *attacksBase;
        std::uint64_t mask;
        std::uint64_t hash;
 
        BlackMagicData(std::uint64_t _attacksOffset,
                       std::uint64_t _mask,
                       std::uint64_t _hash) noexcept;
    };
 
    alignas(64) std::array<std::uint64_t, 88507U> blackMagicAttacks;
    alignas(64) std::array<BlackMagicData, 64U> blackMagicBishopMagics;
    alignas(64) std::array<BlackMagicData, 64U> blackMagicRookMagics;
#endif
 
};
 
extern const BitBoardTables ctBitBoardTables;
 
}
 
#endif