Method SanityCheck

src/txgraph.cpp:2836–2907

}

void GenericClusterImpl::SanityCheck(const TxGraphImpl& graph, int level) const
{
    // There must be an m_mapping for each m_depgraph position (including holes).
    assert(m_depgraph.PositionRange() == m_mapping.size());
    // The linearization for this Cluster must contain every transaction once.
    assert(m_depgraph.TxCount() == m_linearization.size());
    // Unless a split is to be applied, the cluster cannot have any holes.
    if (!NeedsSplitting()) {
        assert(m_depgraph.Positions() == SetType::Fill(m_depgraph.TxCount()));
    }

    // Compute the chunking of m_linearization.
    auto linchunking = ChunkLinearizationInfo(m_depgraph, m_linearization);
    unsigned chunk_num{0};

    // Verify m_linearization.
    SetType m_done;
    LinearizationIndex linindex{0};
    DepGraphIndex chunk_pos{0}; //!< position within the current chunk
    assert(m_depgraph.IsAcyclic());
    if (m_linearization.empty()) return;
    FeeFrac equal_feerate_prefix = linchunking[chunk_num].feerate;
    for (auto lin_pos : m_linearization) {
        assert(lin_pos < m_mapping.size());
        const auto& entry = graph.m_entries[m_mapping[lin_pos]];
        // Check that the linearization is topological.
        m_done.Set(lin_pos);
        if (IsTopological()) {
            assert(m_done.IsSupersetOf(m_depgraph.Ancestors(lin_pos)));
        }
        // Check that the Entry has a locator pointing back to this Cluster & position within it.
        assert(entry.m_locator[level].cluster == this);
        assert(entry.m_locator[level].index == lin_pos);
        // For main-level entries, check linearization position and chunk feerate.
        if (level == 0 && IsAcceptable()) {
            assert(entry.m_main_lin_index == linindex);
            ++linindex;
            if (!linchunking[chunk_num].transactions[lin_pos]) {
                // First transaction of a new chunk.
                ++chunk_num;
                assert(chunk_num < linchunking.size());
                chunk_pos = 0;
                if (ByRatio{linchunking[chunk_num].feerate} < ByRatio{equal_feerate_prefix}) {
                    equal_feerate_prefix = linchunking[chunk_num].feerate;
                } else {
                    assert(ByRatio{linchunking[chunk_num].feerate} == ByRatio{equal_feerate_prefix});
                    equal_feerate_prefix += linchunking[chunk_num].feerate;
                }
            }
            assert(entry.m_main_chunk_feerate == linchunking[chunk_num].feerate);
            assert(entry.m_main_equal_feerate_chunk_prefix_size == equal_feerate_prefix.size);
            // Verify that an entry in the chunk index exists for every chunk-ending transaction.
            ++chunk_pos;
            if (graph.m_main_clusterset.m_to_remove.empty()) {
                bool is_chunk_end = (chunk_pos == linchunking[chunk_num].transactions.Count());
                assert((entry.m_main_chunkindex_iterator != graph.m_main_chunkindex.end()) == is_chunk_end);
                if (is_chunk_end) {
                    auto& chunk_data = *entry.m_main_chunkindex_iterator;