voterecord.h

Go to the documentation of this file.

// Copyright (c) 2021 The Bitcoin developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
#ifndef BITCOIN_AVALANCHE_VOTERECORD_H
#define BITCOIN_AVALANCHE_VOTERECORD_H
 
#include <nodeid.h>
#include <random.h>
 
#include <array>
#include <atomic>
#include <cstdint>
 
static constexpr int AVALANCHE_FINALIZATION_SCORE = 128;
 
static constexpr uint32_t AVALANCHE_VOTE_STALE_THRESHOLD = 4096;
 
static constexpr uint32_t AVALANCHE_VOTE_STALE_MIN_THRESHOLD = 140;
 
static constexpr uint32_t AVALANCHE_VOTE_STALE_FACTOR = 64;
 
static constexpr int AVALANCHE_MAX_INFLIGHT_POLL = 10;
 
namespace avalanche {
 
struct TestVoteRecord;
 
struct VoteRecord {
private:
    // confidence's LSB bit is the result. Higher bits are actual confidence
    // score.
    uint16_t confidence{0};
 
    // Historical record of votes.
    uint8_t votes{0};
    // Each bit indicate if the vote is to be considered.
    uint8_t consider{0};
    // How many in flight requests exists for this element.
    mutable std::atomic<uint8_t> inflight{0};
 
    // Seed for pseudorandom operations.
    const uint32_t seed;
 
    // Track how many successful votes occured.
    uint32_t successfulVotes{0};
 
    // Track the nodes which are part of the quorum.
    std::array<uint16_t, 8> nodeFilter{{0, 0, 0, 0, 0, 0, 0, 0}};
 
public:
    explicit VoteRecord(bool accepted)
        : VoteRecord(accepted, FastRandomContext().rand<uint32_t>()) {}
 
    VoteRecord(bool accepted, uint32_t seedIn)
        : confidence(accepted), seed(seedIn) {}
 
    VoteRecord(const VoteRecord &other)
        : confidence(other.confidence), votes(other.votes),
          consider(other.consider), inflight(other.inflight.load()),
          seed(other.seed), successfulVotes(other.successfulVotes),
          nodeFilter(other.nodeFilter) {}
 
    bool isAccepted() const { return confidence & 0x01; }
 
    uint16_t getConfidence() const { return confidence >> 1; }
    bool hasFinalized() const {
        return getConfidence() >= AVALANCHE_FINALIZATION_SCORE;
    }
 
    bool isStale(uint32_t staleThreshold = AVALANCHE_VOTE_STALE_THRESHOLD,
                 uint32_t staleFactor = AVALANCHE_VOTE_STALE_FACTOR) const {
        return successfulVotes > staleThreshold &&
               successfulVotes > getConfidence() * staleFactor;
    }
 
    bool registerVote(NodeId nodeid, uint32_t error);
 
    bool registerPoll() const;
 
    bool shouldPoll() const { return inflight < AVALANCHE_MAX_INFLIGHT_POLL; }
 
    void clearInflightRequest(uint8_t count = 1) const;
 
private:
    bool addNodeToQuorum(NodeId nodeid);
 
    friend struct ::avalanche::TestVoteRecord;
};
 
} // namespace avalanche
 
#endif // BITCOIN_AVALANCHE_VOTERECORD_H