Function recursiveDeleteChildren

Rapfi/database/dbclient.cpp:175–302

/// @return The number of records deleted.
template <bool ParentDeleted, int MaxSplitPly = 4>
void recursiveDeleteChildren(DBStorage                                          &storage,
                             Board                                              &board,
                             Rule                                                rule,
                             const std::function<DBClient::DelType(DBRecord &)> &deleteFilter,
                             int                                                 threadId,
                             int                                                 ply)
{
    if (board.movesLeft() == 0)
        return;

    static std::set<DBKey> deletingKeys[MaxSplitPly];
    static std::set<DBKey> checkingKeys;
    static std::mutex      mutex[MaxSplitPly + 1];

    DBKey thisKey;
    if constexpr (ParentDeleted)
        thisKey = constructDBKey(board, rule);

    // Find all potential children of this board position
    std::vector<Pos> toDeletePos;
    toDeletePos.reserve(board.movesLeft());
    FOR_EVERY_EMPTY_POS(&board, pos)
    {
        toDeletePos.push_back(pos);
    }

    // Do permutation based on thread id
    if (threadId > 0) {
        for (size_t i = 0; i < toDeletePos.size(); i += (threadId + 1) / 2) {
            size_t swapIndex = (i * (threadId + 1)) % toDeletePos.size();
            std::swap(toDeletePos[i], toDeletePos[swapIndex]);
        }
    }

    // Delete all children
    DBKey    key;
    DBRecord record;
    for (auto pos : toDeletePos) {
        board.move(rule, pos);

        key = constructDBKey(board, rule);

        if (storage.get(key, record, deleteFilter ? RECORD_MASK_LVDB : RECORD_MASK_NONE)) {
            switch (deleteFilter ? deleteFilter(record) : DBClient::DelType::DeleteRecursive) {
            default: break;
            case Database::DBClient::DelType::NoDeleteRecursive: {
                bool recursiveCheck = true;
                if (ply == MaxSplitPly) {
                    std::lock_guard lock(mutex[ply]);
                    if (checkingKeys.find(key) != checkingKeys.end())
                        recursiveCheck = false;
                }

                if (recursiveCheck) {
                    std::pair<std::set<DBKey>::iterator, bool> insertedResult;
                    if (ply == MaxSplitPly) {
                        std::lock_guard lock(mutex[ply]);
                        insertedResult = checkingKeys.insert(key);