Branch data Line data Source code
1 : : // Copyright (c) 2016-2022 The Bitcoin Core developers
2 : : // Distributed under the MIT software license, see the accompanying
3 : : // file COPYING or http://www.opensource.org/licenses/mit-license.php.
4 : :
5 : : #include <consensus/params.h>
6 : : #include <util/check.h>
7 : : #include <versionbits.h>
8 : :
9 : 293808 : ThresholdState AbstractThresholdConditionChecker::GetStateFor(const CBlockIndex* pindexPrev, const Consensus::Params& params, ThresholdConditionCache& cache) const
10 : : {
11 : 293808 : int nPeriod = Period(params);
12 : 293808 : int nThreshold = Threshold(params);
13 : 293808 : int min_activation_height = MinActivationHeight(params);
14 : 293808 : int64_t nTimeStart = BeginTime(params);
15 : 293808 : int64_t nTimeTimeout = EndTime(params);
16 : :
17 : : // Check if this deployment is always active.
18 [ + + ]: 293808 : if (nTimeStart == Consensus::BIP9Deployment::ALWAYS_ACTIVE) {
19 : : return ThresholdState::ACTIVE;
20 : : }
21 : :
22 : : // Check if this deployment is never active.
23 [ + + ]: 177488 : if (nTimeStart == Consensus::BIP9Deployment::NEVER_ACTIVE) {
24 : : return ThresholdState::FAILED;
25 : : }
26 : :
27 : : // A block's state is always the same as that of the first of its period, so it is computed based on a pindexPrev whose height equals a multiple of nPeriod - 1.
28 [ + + ]: 177026 : if (pindexPrev != nullptr) {
29 : 177000 : pindexPrev = pindexPrev->GetAncestor(pindexPrev->nHeight - ((pindexPrev->nHeight + 1) % nPeriod));
30 : : }
31 : :
32 : : // Walk backwards in steps of nPeriod to find a pindexPrev whose information is known
33 : 177026 : std::vector<const CBlockIndex*> vToCompute;
34 [ + + ]: 179462 : while (cache.count(pindexPrev) == 0) {
35 [ + + ]: 3775 : if (pindexPrev == nullptr) {
36 : : // The genesis block is by definition defined.
37 [ + - ]: 1240 : cache[pindexPrev] = ThresholdState::DEFINED;
38 : 1240 : break;
39 : : }
40 [ + + ]: 2535 : if (pindexPrev->GetMedianTimePast() < nTimeStart) {
41 : : // Optimization: don't recompute down further, as we know every earlier block will be before the start time
42 [ + - ]: 99 : cache[pindexPrev] = ThresholdState::DEFINED;
43 : 99 : break;
44 : : }
45 [ + - ]: 2436 : vToCompute.push_back(pindexPrev);
46 [ + - ]: 2436 : pindexPrev = pindexPrev->GetAncestor(pindexPrev->nHeight - nPeriod);
47 : : }
48 : :
49 : : // At this point, cache[pindexPrev] is known
50 [ - + ]: 177026 : assert(cache.count(pindexPrev));
51 [ + - ]: 177026 : ThresholdState state = cache[pindexPrev];
52 : :
53 : : // Now walk forward and compute the state of descendants of pindexPrev
54 [ + + ]: 179462 : while (!vToCompute.empty()) {
55 : 2436 : ThresholdState stateNext = state;
56 : 2436 : pindexPrev = vToCompute.back();
57 [ + + + + ]: 2436 : vToCompute.pop_back();
58 : :
59 [ + + + + ]: 2436 : switch (state) {
60 : 370 : case ThresholdState::DEFINED: {
61 [ + - ]: 370 : if (pindexPrev->GetMedianTimePast() >= nTimeStart) {
62 : 370 : stateNext = ThresholdState::STARTED;
63 : : }
64 : : break;
65 : : }
66 : : case ThresholdState::STARTED: {
67 : : // We need to count
68 : : const CBlockIndex* pindexCount = pindexPrev;
69 : : int count = 0;
70 [ + + ]: 12441 : for (int i = 0; i < nPeriod; i++) {
71 [ + - + + ]: 12064 : if (Condition(pindexCount, params)) {
72 : 3143 : count++;
73 : : }
74 : 12064 : pindexCount = pindexCount->pprev;
75 : : }
76 [ + + ]: 377 : if (count >= nThreshold) {
77 : : stateNext = ThresholdState::LOCKED_IN;
78 [ + + ]: 288 : } else if (pindexPrev->GetMedianTimePast() >= nTimeTimeout) {
79 : 44 : stateNext = ThresholdState::FAILED;
80 : : }
81 : : break;
82 : : }
83 : 339 : case ThresholdState::LOCKED_IN: {
84 : : // Progresses into ACTIVE provided activation height will have been reached.
85 [ + + ]: 339 : if (pindexPrev->nHeight + 1 >= min_activation_height) {
86 : 74 : stateNext = ThresholdState::ACTIVE;
87 : : }
88 : : break;
89 : : }
90 : : case ThresholdState::FAILED:
91 : : case ThresholdState::ACTIVE: {
92 : : // Nothing happens, these are terminal states.
93 : : break;
94 : : }
95 : : }
96 [ + - ]: 2436 : cache[pindexPrev] = state = stateNext;
97 : : }
98 : :
99 : 177026 : return state;
100 : 177026 : }
101 : :
102 : 11718 : BIP9Stats AbstractThresholdConditionChecker::GetStateStatisticsFor(const CBlockIndex* pindex, const Consensus::Params& params, std::vector<bool>* signalling_blocks) const
103 : : {
104 : 11718 : BIP9Stats stats = {};
105 : :
106 : 11718 : stats.period = Period(params);
107 : 11718 : stats.threshold = Threshold(params);
108 : :
109 [ + - ]: 11718 : if (pindex == nullptr) return stats;
110 : :
111 : : // Find how many blocks are in the current period
112 : 11718 : int blocks_in_period = 1 + (pindex->nHeight % stats.period);
113 : :
114 : : // Reset signalling_blocks
115 [ + + ]: 11718 : if (signalling_blocks) {
116 : 5766 : signalling_blocks->assign(blocks_in_period, false);
117 : : }
118 : :
119 : : // Count from current block to beginning of period
120 : : int elapsed = 0;
121 : : int count = 0;
122 : : const CBlockIndex* currentIndex = pindex;
123 : 190464 : do {
124 : 190464 : ++elapsed;
125 : 190464 : --blocks_in_period;
126 [ + + ]: 190464 : if (Condition(currentIndex, params)) {
127 : 84806 : ++count;
128 [ + + ]: 84806 : if (signalling_blocks) signalling_blocks->at(blocks_in_period) = true;
129 : : }
130 : 190464 : currentIndex = currentIndex->pprev;
131 [ + + ]: 190464 : } while(blocks_in_period > 0);
132 : :
133 : 11718 : stats.elapsed = elapsed;
134 : 11718 : stats.count = count;
135 : 11718 : stats.possible = (stats.period - stats.threshold ) >= (stats.elapsed - count);
136 : :
137 : 11718 : return stats;
138 : : }
139 : :
140 : 6147 : int AbstractThresholdConditionChecker::GetStateSinceHeightFor(const CBlockIndex* pindexPrev, const Consensus::Params& params, ThresholdConditionCache& cache) const
141 : : {
142 : 6147 : int64_t start_time = BeginTime(params);
143 [ + + ]: 6147 : if (start_time == Consensus::BIP9Deployment::ALWAYS_ACTIVE || start_time == Consensus::BIP9Deployment::NEVER_ACTIVE) {
144 : : return 0;
145 : : }
146 : :
147 : 5481 : const ThresholdState initialState = GetStateFor(pindexPrev, params, cache);
148 : :
149 : : // BIP 9 about state DEFINED: "The genesis block is by definition in this state for each deployment."
150 [ + + ]: 5481 : if (initialState == ThresholdState::DEFINED) {
151 : : return 0;
152 : : }
153 : :
154 : 4758 : const int nPeriod = Period(params);
155 : :
156 : : // A block's state is always the same as that of the first of its period, so it is computed based on a pindexPrev whose height equals a multiple of nPeriod - 1.
157 : : // To ease understanding of the following height calculation, it helps to remember that
158 : : // right now pindexPrev points to the block prior to the block that we are computing for, thus:
159 : : // if we are computing for the last block of a period, then pindexPrev points to the second to last block of the period, and
160 : : // if we are computing for the first block of a period, then pindexPrev points to the last block of the previous period.
161 : : // The parent of the genesis block is represented by nullptr.
162 : 4758 : pindexPrev = Assert(pindexPrev->GetAncestor(pindexPrev->nHeight - ((pindexPrev->nHeight + 1) % nPeriod)));
163 : :
164 : 4758 : const CBlockIndex* previousPeriodParent = pindexPrev->GetAncestor(pindexPrev->nHeight - nPeriod);
165 : :
166 [ + + + + ]: 55290 : while (previousPeriodParent != nullptr && GetStateFor(previousPeriodParent, params, cache) == initialState) {
167 : 45774 : pindexPrev = previousPeriodParent;
168 : 45774 : previousPeriodParent = pindexPrev->GetAncestor(pindexPrev->nHeight - nPeriod);
169 : : }
170 : :
171 : : // Adjust the result because right now we point to the parent block.
172 : 4758 : return pindexPrev->nHeight + 1;
173 : : }
174 : :
175 : : namespace
176 : : {
177 : : /**
178 : : * Class to implement versionbits logic.
179 : : */
180 : : class VersionBitsConditionChecker : public AbstractThresholdConditionChecker {
181 : : private:
182 : : const Consensus::DeploymentPos id;
183 : :
184 : : protected:
185 : 232256 : int64_t BeginTime(const Consensus::Params& params) const override { return params.vDeployments[id].nStartTime; }
186 : 232247 : int64_t EndTime(const Consensus::Params& params) const override { return params.vDeployments[id].nTimeout; }
187 : 232247 : int MinActivationHeight(const Consensus::Params& params) const override { return params.vDeployments[id].min_activation_height; }
188 : 232247 : int Period(const Consensus::Params& params) const override { return params.nMinerConfirmationWindow; }
189 : 232247 : int Threshold(const Consensus::Params& params) const override { return params.nRuleChangeActivationThreshold; }
190 : :
191 : 0 : bool Condition(const CBlockIndex* pindex, const Consensus::Params& params) const override
192 : : {
193 [ # # ]: 0 : return (((pindex->nVersion & VERSIONBITS_TOP_MASK) == VERSIONBITS_TOP_BITS) && (pindex->nVersion & Mask(params)) != 0);
194 : : }
195 : :
196 : : public:
197 : 243721 : explicit VersionBitsConditionChecker(Consensus::DeploymentPos id_) : id(id_) {}
198 [ # # ]: 0 : uint32_t Mask(const Consensus::Params& params) const { return (uint32_t{1}) << params.vDeployments[id].bit; }
199 : : };
200 : :
201 : : } // namespace
202 : :
203 : 12 : ThresholdState VersionBitsCache::State(const CBlockIndex* pindexPrev, const Consensus::Params& params, Consensus::DeploymentPos pos)
204 : : {
205 : 12 : LOCK(m_mutex);
206 [ + - + - ]: 12 : return VersionBitsConditionChecker(pos).GetStateFor(pindexPrev, params, m_caches[pos]);
207 : 12 : }
208 : :
209 : 0 : BIP9Stats VersionBitsCache::Statistics(const CBlockIndex* pindex, const Consensus::Params& params, Consensus::DeploymentPos pos, std::vector<bool>* signalling_blocks)
210 : : {
211 : 0 : return VersionBitsConditionChecker(pos).GetStateStatisticsFor(pindex, params, signalling_blocks);
212 : : }
213 : :
214 : 9 : int VersionBitsCache::StateSinceHeight(const CBlockIndex* pindexPrev, const Consensus::Params& params, Consensus::DeploymentPos pos)
215 : : {
216 : 9 : LOCK(m_mutex);
217 [ + - + - ]: 9 : return VersionBitsConditionChecker(pos).GetStateSinceHeightFor(pindexPrev, params, m_caches[pos]);
218 : 9 : }
219 : :
220 : 11468 : uint32_t VersionBitsCache::Mask(const Consensus::Params& params, Consensus::DeploymentPos pos)
221 : : {
222 : 11468 : return VersionBitsConditionChecker(pos).Mask(params);
223 : : }
224 : :
225 : 116116 : int32_t VersionBitsCache::ComputeBlockVersion(const CBlockIndex* pindexPrev, const Consensus::Params& params)
226 : : {
227 : 116116 : LOCK(m_mutex);
228 : 116116 : int32_t nVersion = VERSIONBITS_TOP_BITS;
229 : :
230 [ + + ]: 348348 : for (int i = 0; i < (int)Consensus::MAX_VERSION_BITS_DEPLOYMENTS; i++) {
231 : 232232 : Consensus::DeploymentPos pos = static_cast<Consensus::DeploymentPos>(i);
232 [ + - ]: 232232 : ThresholdState state = VersionBitsConditionChecker(pos).GetStateFor(pindexPrev, params, m_caches[pos]);
233 [ + + ]: 232232 : if (state == ThresholdState::LOCKED_IN || state == ThresholdState::STARTED) {
234 [ + - ]: 11468 : nVersion |= Mask(params, pos);
235 : : }
236 : : }
237 : :
238 [ + - ]: 116116 : return nVersion;
239 : 116116 : }
240 : :
241 : 1698 : void VersionBitsCache::Clear()
242 : : {
243 : 1698 : LOCK(m_mutex);
244 [ + + ]: 5094 : for (unsigned int d = 0; d < Consensus::MAX_VERSION_BITS_DEPLOYMENTS; d++) {
245 : 3396 : m_caches[d].clear();
246 : : }
247 : 1698 : }
|
