Branch data Line data Source code
1 : : // Copyright (c) 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 : : #ifndef BITCOIN_CLUSTER_LINEARIZE_H
6 : : #define BITCOIN_CLUSTER_LINEARIZE_H
7 : :
8 : : #include <algorithm>
9 : : #include <numeric>
10 : : #include <optional>
11 : : #include <stdint.h>
12 : : #include <vector>
13 : : #include <utility>
14 : :
15 : : #include <random.h>
16 : : #include <span.h>
17 : : #include <util/feefrac.h>
18 : : #include <util/vecdeque.h>
19 : :
20 : : namespace cluster_linearize {
21 : :
22 : : /** Data type to represent transaction indices in DepGraphs and the clusters they represent. */
23 : : using DepGraphIndex = uint32_t;
24 : :
25 : : /** Data structure that holds a transaction graph's preprocessed data (fee, size, ancestors,
26 : : * descendants). */
27 : : template<typename SetType>
28 [ # # # # : 14 : class DepGraph
# # ]
29 : : {
30 : : /** Information about a single transaction. */
31 : : struct Entry
32 : : {
33 : : /** Fee and size of transaction itself. */
34 : 20 : FeeFrac feerate;
35 : : /** All ancestors of the transaction (including itself). */
36 : 20 : SetType ancestors;
37 : : /** All descendants of the transaction (including itself). */
38 : 20 : SetType descendants;
39 : :
40 : : /** Equality operator (primarily for for testing purposes). */
41 [ + - + - : 40 : friend bool operator==(const Entry&, const Entry&) noexcept = default;
- + ]
42 : :
43 : : /** Construct an empty entry. */
44 : 29 : Entry() noexcept = default;
45 : : /** Construct an entry with a given feerate, ancestor set, descendant set. */
46 : 49 : Entry(const FeeFrac& f, const SetType& a, const SetType& d) noexcept : feerate(f), ancestors(a), descendants(d) {}
47 : : };
48 : :
49 : : /** Data for each transaction. */
50 : : std::vector<Entry> entries;
51 : :
52 : : /** Which positions are used. */
53 : : SetType m_used;
54 : :
55 : : public:
56 : : /** Equality operator (primarily for testing purposes). */
57 : 7 : friend bool operator==(const DepGraph& a, const DepGraph& b) noexcept
58 : : {
59 [ + - ]: 7 : if (a.m_used != b.m_used) return false;
60 : : // Only compare the used positions within the entries vector.
61 [ + + + + : 54 : for (auto idx : a.m_used) {
+ + ]
62 [ + - ]: 20 : if (a.entries[idx] != b.entries[idx]) return false;
63 : : }
64 : : return true;
65 : : }
66 : :
67 : : // Default constructors.
68 [ # # ]: 0 : DepGraph() noexcept = default;
69 : : DepGraph(const DepGraph&) noexcept = default;
70 : : DepGraph(DepGraph&&) noexcept = default;
71 : 0 : DepGraph& operator=(const DepGraph&) noexcept = default;
72 : 7 : DepGraph& operator=(DepGraph&&) noexcept = default;
73 : :
74 : : /** Construct a DepGraph object given another DepGraph and a mapping from old to new.
75 : : *
76 : : * @param depgraph The original DepGraph that is being remapped.
77 : : *
78 : : * @param mapping A span such that mapping[i] gives the position in the new DepGraph
79 : : * for position i in the old depgraph. Its size must be equal to
80 : : * depgraph.PositionRange(). The value of mapping[i] is ignored if
81 : : * position i is a hole in depgraph (i.e., if !depgraph.Positions()[i]).
82 : : *
83 : : * @param pos_range The PositionRange() for the new DepGraph. It must equal the largest
84 : : * value in mapping for any used position in depgraph plus 1, or 0 if
85 : : * depgraph.TxCount() == 0.
86 : : *
87 : : * Complexity: O(N^2) where N=depgraph.TxCount().
88 : : */
89 [ + + ]: 7 : DepGraph(const DepGraph<SetType>& depgraph, std::span<const DepGraphIndex> mapping, DepGraphIndex pos_range) noexcept : entries(pos_range)
90 : : {
91 : 7 : Assume(mapping.size() == depgraph.PositionRange());
92 : 7 : Assume((pos_range == 0) == (depgraph.TxCount() == 0));
93 [ + + ]: 34 : for (DepGraphIndex i : depgraph.Positions()) {
94 [ + + ]: 20 : auto new_idx = mapping[i];
95 [ + + ]: 20 : Assume(new_idx < pos_range);
96 : : // Add transaction.
97 [ + + ]: 20 : entries[new_idx].ancestors = SetType::Singleton(new_idx);
98 : 20 : entries[new_idx].descendants = SetType::Singleton(new_idx);
99 [ + + ]: 20 : m_used.Set(new_idx);
100 : : // Fill in fee and size.
101 [ + + ]: 20 : entries[new_idx].feerate = depgraph.entries[i].feerate;
102 : : }
103 [ + + + + ]: 48 : for (DepGraphIndex i : depgraph.Positions()) {
104 : : // Fill in dependencies by mapping direct parents.
105 : 20 : SetType parents;
106 [ + + + + : 65 : for (auto j : depgraph.GetReducedParents(i)) parents.Set(mapping[j]);
+ + ]
107 : 20 : AddDependencies(parents, mapping[i]);
108 : : }
109 : : // Verify that the provided pos_range was correct (no unused positions at the end).
110 : 7 : Assume(m_used.None() ? (pos_range == 0) : (pos_range == m_used.Last() + 1));
111 : 7 : }
112 : :
113 : : /** Get the set of transactions positions in use. Complexity: O(1). */
114 [ + + + + ]: 14 : const SetType& Positions() const noexcept { return m_used; }
[ # # # # ]
115 : : /** Get the range of positions in this DepGraph. All entries in Positions() are in [0, PositionRange() - 1]. */
116 [ + + # # ]: 7 : DepGraphIndex PositionRange() const noexcept { return entries.size(); }
[ # # ]
117 : : /** Get the number of transactions in the graph. Complexity: O(1). */
118 [ + + + - : 34 : auto TxCount() const noexcept { return m_used.Count(); }
+ - ][ # #
# # # # ]
119 : : /** Get the feerate of a given transaction i. Complexity: O(1). */
120 [ + - + + ]: 40 : const FeeFrac& FeeRate(DepGraphIndex i) const noexcept { return entries[i].feerate; }
121 : : /** Get the mutable feerate of a given transaction i. Complexity: O(1). */
122 [ # # # # ]: 0 : FeeFrac& FeeRate(DepGraphIndex i) noexcept { return entries[i].feerate; }
123 : : /** Get the ancestors of a given transaction i. Complexity: O(1). */
124 [ + - + + : 89 : const SetType& Ancestors(DepGraphIndex i) const noexcept { return entries[i].ancestors; }
+ + ][ # #
# # # # ]
125 : : /** Get the descendants of a given transaction i. Complexity: O(1). */
126 [ + + + - ]: 63 : const SetType& Descendants(DepGraphIndex i) const noexcept { return entries[i].descendants; }
[ # # # # ]
127 : :
128 : : /** Add a new unconnected transaction to this transaction graph (in the first available
129 : : * position), and return its DepGraphIndex.
130 : : *
131 : : * Complexity: O(1) (amortized, due to resizing of backing vector).
132 : : */
133 : 49 : DepGraphIndex AddTransaction(const FeeFrac& feefrac) noexcept
134 : : {
135 : : static constexpr auto ALL_POSITIONS = SetType::Fill(SetType::Size());
136 [ + - ]: 49 : auto available = ALL_POSITIONS - m_used;
137 [ + - ]: 49 : Assume(available.Any());
138 : 49 : DepGraphIndex new_idx = available.First();
139 [ + - ]: 49 : if (new_idx == entries.size()) {
140 : 49 : entries.emplace_back(feefrac, SetType::Singleton(new_idx), SetType::Singleton(new_idx));
141 : : } else {
142 : 0 : entries[new_idx] = Entry(feefrac, SetType::Singleton(new_idx), SetType::Singleton(new_idx));
143 : : }
144 : 49 : m_used.Set(new_idx);
145 : 49 : return new_idx;
146 : : }
147 : :
148 : : /** Remove the specified positions from this DepGraph.
149 : : *
150 : : * The specified positions will no longer be part of Positions(), and dependencies with them are
151 : : * removed. Note that due to DepGraph only tracking ancestors/descendants (and not direct
152 : : * dependencies), if a parent is removed while a grandparent remains, the grandparent will
153 : : * remain an ancestor.
154 : : *
155 : : * Complexity: O(N) where N=TxCount().
156 : : */
157 : 7 : void RemoveTransactions(const SetType& del) noexcept
158 : : {
159 : 7 : m_used -= del;
160 : : // Remove now-unused trailing entries.
161 [ + + - + ]: 7 : while (!entries.empty() && !m_used[entries.size() - 1]) {
162 : 0 : entries.pop_back();
163 : : }
164 : : // Remove the deleted transactions from ancestors/descendants of other transactions. Note
165 : : // that the deleted positions will retain old feerate and dependency information. This does
166 : : // not matter as they will be overwritten by AddTransaction if they get used again.
167 [ + + ]: 36 : for (auto& entry : entries) {
168 : 29 : entry.ancestors &= m_used;
169 : 29 : entry.descendants &= m_used;
170 : : }
171 : 7 : }
172 : :
173 : : /** Modify this transaction graph, adding multiple parents to a specified child.
174 : : *
175 : : * Complexity: O(N) where N=TxCount().
176 : : */
177 : 69 : void AddDependencies(const SetType& parents, DepGraphIndex child) noexcept
178 : : {
179 : 69 : Assume(m_used[child]);
180 : 69 : Assume(parents.IsSubsetOf(m_used));
181 : : // Compute the ancestors of parents that are not already ancestors of child.
182 [ + + ]: 69 : SetType par_anc;
183 [ + + + + : 185 : for (auto par : parents - Ancestors(child)) {
+ + ]
184 [ + + ]: 47 : par_anc |= Ancestors(par);
185 : : }
186 [ + + ]: 69 : par_anc -= Ancestors(child);
187 : : // Bail out if there are no such ancestors.
188 [ + + ]: 69 : if (par_anc.None()) return;
189 : : // To each such ancestor, add as descendants the descendants of the child.
190 : 33 : const auto& chl_des = entries[child].descendants;
191 [ + + ]: 123 : for (auto anc_of_par : par_anc) {
192 [ + + ]: 57 : entries[anc_of_par].descendants |= chl_des;
193 : : }
194 : : // To each descendant of the child, add those ancestors.
195 [ + - + + ]: 132 : for (auto dec_of_chl : Descendants(child)) {
196 [ - + ]: 33 : entries[dec_of_chl].ancestors |= par_anc;
197 : : }
198 : : }
199 : :
200 : : /** Compute the (reduced) set of parents of node i in this graph.
201 : : *
202 : : * This returns the minimal subset of the parents of i whose ancestors together equal all of
203 : : * i's ancestors (unless i is part of a cycle of dependencies). Note that DepGraph does not
204 : : * store the set of parents; this information is inferred from the ancestor sets.
205 : : *
206 : : * Complexity: O(N) where N=Ancestors(i).Count() (which is bounded by TxCount()).
207 : : */
208 [ + + ]: 20 : SetType GetReducedParents(DepGraphIndex i) const noexcept
209 : : {
210 [ + + ]: 20 : SetType parents = Ancestors(i);
211 : 20 : parents.Reset(i);
212 [ + + + - : 78 : for (auto parent : parents) {
+ + + + ]
213 [ + - ]: 19 : if (parents[parent]) {
214 : 19 : parents -= Ancestors(parent);
215 : 19 : parents.Set(parent);
216 : : }
217 : : }
218 : 20 : return parents;
219 : : }
220 : :
221 : : /** Compute the (reduced) set of children of node i in this graph.
222 : : *
223 : : * This returns the minimal subset of the children of i whose descendants together equal all of
224 : : * i's descendants (unless i is part of a cycle of dependencies). Note that DepGraph does not
225 : : * store the set of children; this information is inferred from the descendant sets.
226 : : *
227 : : * Complexity: O(N) where N=Descendants(i).Count() (which is bounded by TxCount()).
228 : : */
229 : : SetType GetReducedChildren(DepGraphIndex i) const noexcept
230 : : {
231 : : SetType children = Descendants(i);
232 : : children.Reset(i);
233 : : for (auto child : children) {
234 : : if (children[child]) {
235 : : children -= Descendants(child);
236 : : children.Set(child);
237 : : }
238 : : }
239 : : return children;
240 : : }
241 : :
242 : : /** Compute the aggregate feerate of a set of nodes in this graph.
243 : : *
244 : : * Complexity: O(N) where N=elems.Count().
245 : : **/
246 : 0 : FeeFrac FeeRate(const SetType& elems) const noexcept
247 : : {
248 : 0 : FeeFrac ret;
249 [ # # # # : 0 : for (auto pos : elems) ret += entries[pos].feerate;
# # ]
250 : 0 : return ret;
251 : : }
252 : :
253 : : /** Get the connected component within the subset "todo" that contains tx (which must be in
254 : : * todo).
255 : : *
256 : : * Two transactions are considered connected if they are both in `todo`, and one is an ancestor
257 : : * of the other in the entire graph (so not just within `todo`), or transitively there is a
258 : : * path of transactions connecting them. This does mean that if `todo` contains a transaction
259 : : * and a grandparent, but misses the parent, they will still be part of the same component.
260 : : *
261 : : * Complexity: O(ret.Count()).
262 : : */
263 : 0 : SetType GetConnectedComponent(const SetType& todo, DepGraphIndex tx) const noexcept
264 : : {
265 : 0 : Assume(todo[tx]);
266 : 0 : Assume(todo.IsSubsetOf(m_used));
267 : 0 : auto to_add = SetType::Singleton(tx);
268 : 0 : SetType ret;
269 : : do {
270 : 0 : SetType old = ret;
271 [ # # # # : 0 : for (auto add : to_add) {
# # ]
272 [ # # ]: 0 : ret |= Descendants(add);
273 [ # # ]: 0 : ret |= Ancestors(add);
274 : : }
275 [ # # ]: 0 : ret &= todo;
276 : 0 : to_add = ret - old;
277 [ # # ]: 0 : } while (to_add.Any());
278 : 0 : return ret;
279 : : }
280 : :
281 : : /** Find some connected component within the subset "todo" of this graph.
282 : : *
283 : : * Specifically, this finds the connected component which contains the first transaction of
284 : : * todo (if any).
285 : : *
286 : : * Complexity: O(ret.Count()).
287 : : */
288 [ # # ]: 0 : SetType FindConnectedComponent(const SetType& todo) const noexcept
289 : : {
290 [ # # ]: 0 : if (todo.None()) return todo;
291 : 0 : return GetConnectedComponent(todo, todo.First());
292 : : }
293 : :
294 : : /** Determine if a subset is connected.
295 : : *
296 : : * Complexity: O(subset.Count()).
297 : : */
298 : 0 : bool IsConnected(const SetType& subset) const noexcept
299 : : {
300 [ # # ]: 0 : return FindConnectedComponent(subset) == subset;
301 : : }
302 : :
303 : : /** Determine if this entire graph is connected.
304 : : *
305 : : * Complexity: O(TxCount()).
306 : : */
307 : : bool IsConnected() const noexcept { return IsConnected(m_used); }
308 : :
309 : : /** Append the entries of select to list in a topologically valid order.
310 : : *
311 : : * Complexity: O(select.Count() * log(select.Count())).
312 : : */
313 [ # # ]: 0 : void AppendTopo(std::vector<DepGraphIndex>& list, const SetType& select) const noexcept
314 : : {
315 : 0 : DepGraphIndex old_len = list.size();
316 [ # # # # : 0 : for (auto i : select) list.push_back(i);
# # ]
317 : 0 : std::sort(list.begin() + old_len, list.end(), [&](DepGraphIndex a, DepGraphIndex b) noexcept {
318 [ # # ]: 0 : const auto a_anc_count = entries[a].ancestors.Count();
319 : 0 : const auto b_anc_count = entries[b].ancestors.Count();
320 [ # # ]: 0 : if (a_anc_count != b_anc_count) return a_anc_count < b_anc_count;
321 : 0 : return a < b;
322 : : });
323 : 0 : }
324 : :
325 : : /** Check if this graph is acyclic. */
326 : 0 : bool IsAcyclic() const noexcept
327 : : {
328 [ # # # # : 0 : for (auto i : Positions()) {
# # ]
329 [ # # # # ]: 0 : if ((Ancestors(i) & Descendants(i)) != SetType::Singleton(i)) {
330 : : return false;
331 : : }
332 : : }
333 : : return true;
334 : : }
335 : : };
336 : :
337 : : /** A set of transactions together with their aggregate feerate. */
338 : : template<typename SetType>
339 : : struct SetInfo
340 : : {
341 : : /** The transactions in the set. */
342 : : SetType transactions;
343 : : /** Their combined fee and size. */
344 : : FeeFrac feerate;
345 : :
346 : : /** Construct a SetInfo for the empty set. */
347 : 0 : SetInfo() noexcept = default;
348 : :
349 : : /** Construct a SetInfo for a specified set and feerate. */
350 : 0 : SetInfo(const SetType& txn, const FeeFrac& fr) noexcept : transactions(txn), feerate(fr) {}
351 : :
352 : : /** Construct a SetInfo for a given transaction in a depgraph. */
353 : 0 : explicit SetInfo(const DepGraph<SetType>& depgraph, DepGraphIndex pos) noexcept :
354 : 0 : transactions(SetType::Singleton(pos)), feerate(depgraph.FeeRate(pos)) {}
355 : :
356 : : /** Construct a SetInfo for a set of transactions in a depgraph. */
357 : 0 : explicit SetInfo(const DepGraph<SetType>& depgraph, const SetType& txn) noexcept :
358 : 0 : transactions(txn), feerate(depgraph.FeeRate(txn)) {}
359 : :
360 : : /** Add a transaction to this SetInfo (which must not yet be in it). */
361 : 0 : void Set(const DepGraph<SetType>& depgraph, DepGraphIndex pos) noexcept
362 : : {
363 : 0 : Assume(!transactions[pos]);
364 : 0 : transactions.Set(pos);
365 : 0 : feerate += depgraph.FeeRate(pos);
366 : 0 : }
367 : :
368 : : /** Add the transactions of other to this SetInfo (no overlap allowed). */
369 : 0 : SetInfo& operator|=(const SetInfo& other) noexcept
370 : : {
371 : : Assume(!transactions.Overlaps(other.transactions));
372 : 0 : transactions |= other.transactions;
373 : 0 : feerate += other.feerate;
374 : : return *this;
375 : : }
376 : :
377 : : /** Construct a new SetInfo equal to this, with more transactions added (which may overlap
378 : : * with the existing transactions in the SetInfo). */
379 : 0 : [[nodiscard]] SetInfo Add(const DepGraph<SetType>& depgraph, const SetType& txn) const noexcept
380 : : {
381 : 0 : return {transactions | txn, feerate + depgraph.FeeRate(txn - transactions)};
382 : : }
383 : :
384 : : /** Swap two SetInfo objects. */
385 : 0 : friend void swap(SetInfo& a, SetInfo& b) noexcept
386 : : {
387 : 0 : swap(a.transactions, b.transactions);
388 : 0 : swap(a.feerate, b.feerate);
389 : : }
390 : :
391 : : /** Permit equality testing. */
392 : : friend bool operator==(const SetInfo&, const SetInfo&) noexcept = default;
393 : : };
394 : :
395 : : /** Compute the feerates of the chunks of linearization. */
396 : : template<typename SetType>
397 : : std::vector<FeeFrac> ChunkLinearization(const DepGraph<SetType>& depgraph, std::span<const DepGraphIndex> linearization) noexcept
398 : : {
399 : : std::vector<FeeFrac> ret;
400 : : for (DepGraphIndex i : linearization) {
401 : : /** The new chunk to be added, initially a singleton. */
402 : : auto new_chunk = depgraph.FeeRate(i);
403 : : // As long as the new chunk has a higher feerate than the last chunk so far, absorb it.
404 : : while (!ret.empty() && new_chunk >> ret.back()) {
405 : : new_chunk += ret.back();
406 : : ret.pop_back();
407 : : }
408 : : // Actually move that new chunk into the chunking.
409 : : ret.push_back(std::move(new_chunk));
410 : : }
411 : : return ret;
412 : : }
413 : :
414 : : /** Data structure encapsulating the chunking of a linearization, permitting removal of subsets. */
415 : : template<typename SetType>
416 : 0 : class LinearizationChunking
417 : : {
418 : : /** The depgraph this linearization is for. */
419 : : const DepGraph<SetType>& m_depgraph;
420 : :
421 : : /** The linearization we started from, possibly with removed prefix stripped. */
422 : : std::span<const DepGraphIndex> m_linearization;
423 : :
424 : : /** Chunk sets and their feerates, of what remains of the linearization. */
425 : : std::vector<SetInfo<SetType>> m_chunks;
426 : :
427 : : /** How large a prefix of m_chunks corresponds to removed transactions. */
428 : : DepGraphIndex m_chunks_skip{0};
429 : :
430 : : /** Which transactions remain in the linearization. */
431 : : SetType m_todo;
432 : :
433 : : /** Fill the m_chunks variable, and remove the done prefix of m_linearization. */
434 : 0 : void BuildChunks() noexcept
435 : : {
436 : : // Caller must clear m_chunks.
437 : 0 : Assume(m_chunks.empty());
438 : :
439 : : // Chop off the initial part of m_linearization that is already done.
440 [ # # # # ]: 0 : while (!m_linearization.empty() && !m_todo[m_linearization.front()]) {
441 : 0 : m_linearization = m_linearization.subspan(1);
442 : : }
443 : :
444 : : // Iterate over the remaining entries in m_linearization. This is effectively the same
445 : : // algorithm as ChunkLinearization, but supports skipping parts of the linearization and
446 : : // keeps track of the sets themselves instead of just their feerates.
447 [ # # ]: 0 : for (auto idx : m_linearization) {
448 [ # # ]: 0 : if (!m_todo[idx]) continue;
449 : : // Start with an initial chunk containing just element idx.
450 : 0 : SetInfo add(m_depgraph, idx);
451 : : // Absorb existing final chunks into add while they have lower feerate.
452 [ # # # # ]: 0 : while (!m_chunks.empty() && add.feerate >> m_chunks.back().feerate) {
453 : 0 : add |= m_chunks.back();
454 : 0 : m_chunks.pop_back();
455 : : }
456 : : // Remember new chunk.
457 : 0 : m_chunks.push_back(std::move(add));
458 : : }
459 : 0 : }
460 : :
461 : : public:
462 : : /** Initialize a LinearizationSubset object for a given length of linearization. */
463 : 0 : explicit LinearizationChunking(const DepGraph<SetType>& depgraph LIFETIMEBOUND, std::span<const DepGraphIndex> lin LIFETIMEBOUND) noexcept :
464 : 0 : m_depgraph(depgraph), m_linearization(lin)
465 : : {
466 : : // Mark everything in lin as todo still.
467 [ # # ]: 0 : for (auto i : m_linearization) m_todo.Set(i);
468 : : // Compute the initial chunking.
469 : 0 : m_chunks.reserve(depgraph.TxCount());
470 : 0 : BuildChunks();
471 : 0 : }
472 : :
473 : : /** Determine how many chunks remain in the linearization. */
474 [ # # # # ]: 0 : DepGraphIndex NumChunksLeft() const noexcept { return m_chunks.size() - m_chunks_skip; }
475 : :
476 : : /** Access a chunk. Chunk 0 is the highest-feerate prefix of what remains. */
477 : 0 : const SetInfo<SetType>& GetChunk(DepGraphIndex n) const noexcept
478 : : {
479 : : Assume(n + m_chunks_skip < m_chunks.size());
480 [ # # # # : 0 : return m_chunks[n + m_chunks_skip];
# # ]
481 : : }
482 : :
483 : : /** Remove some subset of transactions from the linearization. */
484 [ # # ]: 0 : void MarkDone(SetType subset) noexcept
485 : : {
486 : 0 : Assume(subset.Any());
487 : 0 : Assume(subset.IsSubsetOf(m_todo));
488 [ # # ]: 0 : m_todo -= subset;
489 [ # # ]: 0 : if (GetChunk(0).transactions == subset) {
490 : : // If the newly done transactions exactly match the first chunk of the remainder of
491 : : // the linearization, we do not need to rechunk; just remember to skip one
492 : : // additional chunk.
493 : 0 : ++m_chunks_skip;
494 : : // With subset marked done, some prefix of m_linearization will be done now. How long
495 : : // that prefix is depends on how many done elements were interspersed with subset,
496 : : // but at least as many transactions as there are in subset.
497 : 0 : m_linearization = m_linearization.subspan(subset.Count());
498 : : } else {
499 : : // Otherwise rechunk what remains of m_linearization.
500 [ # # ]: 0 : m_chunks.clear();
501 : 0 : m_chunks_skip = 0;
502 : 0 : BuildChunks();
503 : : }
504 : 0 : }
505 : :
506 : : /** Find the shortest intersection between subset and the prefixes of remaining chunks
507 : : * of the linearization that has a feerate not below subset's.
508 : : *
509 : : * This is a crucial operation in guaranteeing improvements to linearizations. If subset has
510 : : * a feerate not below GetChunk(0)'s, then moving IntersectPrefixes(subset) to the front of
511 : : * (what remains of) the linearization is guaranteed not to make it worse at any point.
512 : : *
513 : : * See https://delvingbitcoin.org/t/introduction-to-cluster-linearization/1032 for background.
514 : : */
515 : 0 : SetInfo<SetType> IntersectPrefixes(const SetInfo<SetType>& subset) const noexcept
516 : : {
517 : 0 : Assume(subset.transactions.IsSubsetOf(m_todo));
518 : 0 : SetInfo<SetType> accumulator;
519 : : // Iterate over all chunks of the remaining linearization.
520 [ # # ]: 0 : for (DepGraphIndex i = 0; i < NumChunksLeft(); ++i) {
521 : : // Find what (if any) intersection the chunk has with subset.
522 [ # # ]: 0 : const SetType to_add = GetChunk(i).transactions & subset.transactions;
523 [ # # ]: 0 : if (to_add.Any()) {
524 : : // If adding that to accumulator makes us hit all of subset, we are done as no
525 : : // shorter intersection with higher/equal feerate exists.
526 : 0 : accumulator.transactions |= to_add;
527 [ # # ]: 0 : if (accumulator.transactions == subset.transactions) break;
528 : : // Otherwise update the accumulator feerate.
529 [ # # ]: 0 : accumulator.feerate += m_depgraph.FeeRate(to_add);
530 : : // If that does result in something better, or something with the same feerate but
531 : : // smaller, return that. Even if a longer, higher-feerate intersection exists, it
532 : : // does not hurt to return the shorter one (the remainder of the longer intersection
533 : : // will generally be found in the next call to Intersect, but even if not, it is not
534 : : // required for the improvement guarantee this function makes).
535 [ # # ]: 0 : if (!(accumulator.feerate << subset.feerate)) return accumulator;
536 : : }
537 : : }
538 : 0 : return subset;
539 : : }
540 : : };
541 : :
542 : : /** Class encapsulating the state needed to find the best remaining ancestor set.
543 : : *
544 : : * It is initialized for an entire DepGraph, and parts of the graph can be dropped by calling
545 : : * MarkDone.
546 : : *
547 : : * As long as any part of the graph remains, FindCandidateSet() can be called which will return a
548 : : * SetInfo with the highest-feerate ancestor set that remains (an ancestor set is a single
549 : : * transaction together with all its remaining ancestors).
550 : : */
551 : : template<typename SetType>
552 : 0 : class AncestorCandidateFinder
553 : : {
554 : : /** Internal dependency graph. */
555 : : const DepGraph<SetType>& m_depgraph;
556 : : /** Which transaction are left to include. */
557 : : SetType m_todo;
558 : : /** Precomputed ancestor-set feerates (only kept up-to-date for indices in m_todo). */
559 : : std::vector<FeeFrac> m_ancestor_set_feerates;
560 : :
561 : : public:
562 : : /** Construct an AncestorCandidateFinder for a given cluster.
563 : : *
564 : : * Complexity: O(N^2) where N=depgraph.TxCount().
565 : : */
566 : 0 : AncestorCandidateFinder(const DepGraph<SetType>& depgraph LIFETIMEBOUND) noexcept :
567 : 0 : m_depgraph(depgraph),
568 : 0 : m_todo{depgraph.Positions()},
569 [ # # ]: 0 : m_ancestor_set_feerates(depgraph.PositionRange())
570 : : {
571 : : // Precompute ancestor-set feerates.
572 [ # # # # : 0 : for (DepGraphIndex i : m_depgraph.Positions()) {
# # ]
573 : : /** The remaining ancestors for transaction i. */
574 [ # # ]: 0 : SetType anc_to_add = m_depgraph.Ancestors(i);
575 [ # # ]: 0 : FeeFrac anc_feerate;
576 : : // Reuse accumulated feerate from first ancestor, if usable.
577 [ # # ]: 0 : Assume(anc_to_add.Any());
578 : 0 : DepGraphIndex first = anc_to_add.First();
579 [ # # ]: 0 : if (first < i) {
580 : 0 : anc_feerate = m_ancestor_set_feerates[first];
581 : 0 : Assume(!anc_feerate.IsEmpty());
582 : 0 : anc_to_add -= m_depgraph.Ancestors(first);
583 : : }
584 : : // Add in other ancestors (which necessarily include i itself).
585 : 0 : Assume(anc_to_add[i]);
586 [ # # ]: 0 : anc_feerate += m_depgraph.FeeRate(anc_to_add);
587 : : // Store the result.
588 [ # # ]: 0 : m_ancestor_set_feerates[i] = anc_feerate;
589 : : }
590 : 0 : }
591 : :
592 : : /** Remove a set of transactions from the set of to-be-linearized ones.
593 : : *
594 : : * The same transaction may not be MarkDone()'d twice.
595 : : *
596 : : * Complexity: O(N*M) where N=depgraph.TxCount(), M=select.Count().
597 : : */
598 [ # # ]: 0 : void MarkDone(SetType select) noexcept
599 : : {
600 : 0 : Assume(select.Any());
601 : 0 : Assume(select.IsSubsetOf(m_todo));
602 [ # # ]: 0 : m_todo -= select;
603 [ # # # # : 0 : for (auto i : select) {
# # ]
604 [ # # ]: 0 : auto feerate = m_depgraph.FeeRate(i);
605 [ # # # # ]: 0 : for (auto j : m_depgraph.Descendants(i) & m_todo) {
606 [ # # ]: 0 : m_ancestor_set_feerates[j] -= feerate;
607 : : }
608 : : }
609 : 0 : }
610 : :
611 : : /** Check whether any unlinearized transactions remain. */
612 : 0 : bool AllDone() const noexcept
613 : : {
614 : 0 : return m_todo.None();
615 : : }
616 : :
617 : : /** Count the number of remaining unlinearized transactions. */
618 : 0 : DepGraphIndex NumRemaining() const noexcept
619 : : {
620 [ # # ]: 0 : return m_todo.Count();
621 : : }
622 : :
623 : : /** Find the best (highest-feerate, smallest among those in case of a tie) ancestor set
624 : : * among the remaining transactions. Requires !AllDone().
625 : : *
626 : : * Complexity: O(N) where N=depgraph.TxCount();
627 : : */
628 : 0 : SetInfo<SetType> FindCandidateSet() const noexcept
629 : : {
630 : 0 : Assume(!AllDone());
631 : 0 : std::optional<DepGraphIndex> best;
632 [ # # # # : 0 : for (auto i : m_todo) {
# # # # ]
633 [ # # ]: 0 : if (best.has_value()) {
634 [ # # ]: 0 : Assume(!m_ancestor_set_feerates[i].IsEmpty());
635 [ # # ]: 0 : if (!(m_ancestor_set_feerates[i] > m_ancestor_set_feerates[*best])) continue;
636 : : }
637 : 0 : best = i;
638 : : }
639 : 0 : Assume(best.has_value());
640 : 0 : return {m_depgraph.Ancestors(*best) & m_todo, m_ancestor_set_feerates[*best]};
641 : : }
642 : : };
643 : :
644 : : /** Class encapsulating the state needed to perform search for good candidate sets.
645 : : *
646 : : * It is initialized for an entire DepGraph, and parts of the graph can be dropped by calling
647 : : * MarkDone().
648 : : *
649 : : * As long as any part of the graph remains, FindCandidateSet() can be called to perform a search
650 : : * over the set of topologically-valid subsets of that remainder, with a limit on how many
651 : : * combinations are tried.
652 : : */
653 : : template<typename SetType>
654 : : class SearchCandidateFinder
655 : : {
656 : : /** Internal RNG. */
657 : : InsecureRandomContext m_rng;
658 : : /** m_sorted_to_original[i] is the original position that sorted transaction position i had. */
659 : : std::vector<DepGraphIndex> m_sorted_to_original;
660 : : /** m_original_to_sorted[i] is the sorted position original transaction position i has. */
661 : : std::vector<DepGraphIndex> m_original_to_sorted;
662 : : /** Internal dependency graph for the cluster (with transactions in decreasing individual
663 : : * feerate order). */
664 : : DepGraph<SetType> m_sorted_depgraph;
665 : : /** Which transactions are left to do (indices in m_sorted_depgraph's order). */
666 : : SetType m_todo;
667 : :
668 : : /** Given a set of transactions with sorted indices, get their original indices. */
669 : 0 : SetType SortedToOriginal(const SetType& arg) const noexcept
670 : : {
671 : 0 : SetType ret;
672 [ # # # # : 0 : for (auto pos : arg) ret.Set(m_sorted_to_original[pos]);
# # ]
673 : 0 : return ret;
674 : : }
675 : :
676 : : /** Given a set of transactions with original indices, get their sorted indices. */
677 : 0 : SetType OriginalToSorted(const SetType& arg) const noexcept
678 : : {
679 : 0 : SetType ret;
680 [ # # # # : 0 : for (auto pos : arg) ret.Set(m_original_to_sorted[pos]);
# # ]
681 : 0 : return ret;
682 : : }
683 : :
684 : : public:
685 : : /** Construct a candidate finder for a graph.
686 : : *
687 : : * @param[in] depgraph Dependency graph for the to-be-linearized cluster.
688 : : * @param[in] rng_seed A random seed to control the search order.
689 : : *
690 : : * Complexity: O(N^2) where N=depgraph.Count().
691 : : */
692 : 0 : SearchCandidateFinder(const DepGraph<SetType>& depgraph, uint64_t rng_seed) noexcept :
693 : 0 : m_rng(rng_seed),
694 : 0 : m_sorted_to_original(depgraph.TxCount()),
695 [ # # ]: 0 : m_original_to_sorted(depgraph.PositionRange())
696 : : {
697 : : // Determine reordering mapping, by sorting by decreasing feerate. Unused positions are
698 : : // not included, as they will never be looked up anyway.
699 : 0 : DepGraphIndex sorted_pos{0};
700 [ # # # # ]: 0 : for (auto i : depgraph.Positions()) {
701 [ # # ]: 0 : m_sorted_to_original[sorted_pos++] = i;
702 : : }
703 : 0 : std::sort(m_sorted_to_original.begin(), m_sorted_to_original.end(), [&](auto a, auto b) {
704 [ # # ]: 0 : auto feerate_cmp = depgraph.FeeRate(a) <=> depgraph.FeeRate(b);
705 [ # # ]: 0 : if (feerate_cmp == 0) return a < b;
706 : 0 : return feerate_cmp > 0;
707 : : });
708 : : // Compute reverse mapping.
709 [ # # ]: 0 : for (DepGraphIndex i = 0; i < m_sorted_to_original.size(); ++i) {
710 : 0 : m_original_to_sorted[m_sorted_to_original[i]] = i;
711 : : }
712 : : // Compute reordered dependency graph.
713 : 0 : m_sorted_depgraph = DepGraph(depgraph, m_original_to_sorted, m_sorted_to_original.size());
714 : 0 : m_todo = m_sorted_depgraph.Positions();
715 : 0 : }
716 : :
717 : : /** Check whether any unlinearized transactions remain. */
718 : : bool AllDone() const noexcept
719 : : {
720 : 0 : return m_todo.None();
721 : : }
722 : :
723 : : /** Find a high-feerate topologically-valid subset of what remains of the cluster.
724 : : * Requires !AllDone().
725 : : *
726 : : * @param[in] max_iterations The maximum number of optimization steps that will be performed.
727 : : * @param[in] best A set/feerate pair with an already-known good candidate. This may
728 : : * be empty.
729 : : * @return A pair of:
730 : : * - The best (highest feerate, smallest size as tiebreaker)
731 : : * topologically valid subset (and its feerate) that was
732 : : * encountered during search. It will be at least as good as the
733 : : * best passed in (if not empty).
734 : : * - The number of optimization steps that were performed. This will
735 : : * be <= max_iterations. If strictly < max_iterations, the
736 : : * returned subset is optimal.
737 : : *
738 : : * Complexity: possibly O(N * min(max_iterations, sqrt(2^N))) where N=depgraph.TxCount().
739 : : */
740 : 0 : std::pair<SetInfo<SetType>, uint64_t> FindCandidateSet(uint64_t max_iterations, SetInfo<SetType> best) noexcept
741 : : {
742 : 0 : Assume(!AllDone());
743 : :
744 : : // Convert the provided best to internal sorted indices.
745 : 0 : best.transactions = OriginalToSorted(best.transactions);
746 : :
747 : : /** Type for work queue items. */
748 : : struct WorkItem
749 : : {
750 : : /** Set of transactions definitely included (and its feerate). This must be a subset
751 : : * of m_todo, and be topologically valid (includes all in-m_todo ancestors of
752 : : * itself). */
753 : : SetInfo<SetType> inc;
754 : : /** Set of undecided transactions. This must be a subset of m_todo, and have no overlap
755 : : * with inc. The set (inc | und) must be topologically valid. */
756 : : SetType und;
757 : : /** (Only when inc is not empty) The best feerate of any superset of inc that is also a
758 : : * subset of (inc | und), without requiring it to be topologically valid. It forms a
759 : : * conservative upper bound on how good a set this work item can give rise to.
760 : : * Transactions whose feerate is below best's are ignored when determining this value,
761 : : * which means it may technically be an underestimate, but if so, this work item
762 : : * cannot result in something that beats best anyway. */
763 : : FeeFrac pot_feerate;
764 : :
765 : : /** Construct a new work item. */
766 : 0 : WorkItem(SetInfo<SetType>&& i, SetType&& u, FeeFrac&& p_f) noexcept :
767 : 0 : inc(std::move(i)), und(std::move(u)), pot_feerate(std::move(p_f))
768 : : {
769 : 0 : Assume(pot_feerate.IsEmpty() == inc.feerate.IsEmpty());
770 : : }
771 : :
772 : : /** Swap two WorkItems. */
773 : 0 : void Swap(WorkItem& other) noexcept
774 : : {
775 : 0 : swap(inc, other.inc);
776 : 0 : swap(und, other.und);
777 : 0 : swap(pot_feerate, other.pot_feerate);
778 : 0 : }
779 : : };
780 : :
781 : : /** The queue of work items. */
782 : 0 : VecDeque<WorkItem> queue;
783 [ # # # # ]: 0 : queue.reserve(std::max<size_t>(256, 2 * m_todo.Count()));
784 : :
785 : : // Create initial entries per connected component of m_todo. While clusters themselves are
786 : : // generally connected, this is not necessarily true after some parts have already been
787 : : // removed from m_todo. Without this, effort can be wasted on searching "inc" sets that
788 : : // span multiple components.
789 : 0 : auto to_cover = m_todo;
790 : : do {
791 [ # # ]: 0 : auto component = m_sorted_depgraph.FindConnectedComponent(to_cover);
792 [ # # ]: 0 : to_cover -= component;
793 : : // If best is not provided, set it to the first component, so that during the work
794 : : // processing loop below, and during the add_fn/split_fn calls, we do not need to deal
795 : : // with the best=empty case.
796 [ # # ]: 0 : if (best.feerate.IsEmpty()) best = SetInfo(m_sorted_depgraph, component);
797 : 0 : queue.emplace_back(/*inc=*/SetInfo<SetType>{},
798 : : /*und=*/std::move(component),
799 : 0 : /*pot_feerate=*/FeeFrac{});
800 [ # # ]: 0 : } while (to_cover.Any());
801 : :
802 : : /** Local copy of the iteration limit. */
803 : 0 : uint64_t iterations_left = max_iterations;
804 : :
805 : : /** The set of transactions in m_todo which have feerate > best's. */
806 : 0 : SetType imp = m_todo;
807 [ # # ]: 0 : while (imp.Any()) {
808 : 0 : DepGraphIndex check = imp.Last();
809 [ # # ]: 0 : if (m_sorted_depgraph.FeeRate(check) >> best.feerate) break;
810 : 0 : imp.Reset(check);
811 : : }
812 : :
813 : : /** Internal function to add an item to the queue of elements to explore if there are any
814 : : * transactions left to split on, possibly improving it before doing so, and to update
815 : : * best/imp.
816 : : *
817 : : * - inc: the "inc" value for the new work item (must be topological).
818 : : * - und: the "und" value for the new work item ((inc | und) must be topological).
819 : : */
820 : 0 : auto add_fn = [&](SetInfo<SetType> inc, SetType und) noexcept {
821 : : /** SetInfo object with the set whose feerate will become the new work item's
822 : : * pot_feerate. It starts off equal to inc. */
823 [ # # ]: 0 : auto pot = inc;
824 [ # # ]: 0 : if (!inc.feerate.IsEmpty()) {
825 : : // Add entries to pot. We iterate over all undecided transactions whose feerate is
826 : : // higher than best. While undecided transactions of lower feerate may improve pot,
827 : : // the resulting pot feerate cannot possibly exceed best's (and this item will be
828 : : // skipped in split_fn anyway).
829 [ # # # # : 0 : for (auto pos : imp & und) {
# # ]
830 : : // Determine if adding transaction pos to pot (ignoring topology) would improve
831 : : // it. If not, we're done updating pot. This relies on the fact that
832 : : // m_sorted_depgraph, and thus the transactions iterated over, are in decreasing
833 : : // individual feerate order.
834 [ # # ]: 0 : if (!(m_sorted_depgraph.FeeRate(pos) >> pot.feerate)) break;
835 : 0 : pot.Set(m_sorted_depgraph, pos);
836 : : }
837 : :
838 : : // The "jump ahead" optimization: whenever pot has a topologically-valid subset,
839 : : // that subset can be added to inc. Any subset of (pot - inc) has the property that
840 : : // its feerate exceeds that of any set compatible with this work item (superset of
841 : : // inc, subset of (inc | und)). Thus, if T is a topological subset of pot, and B is
842 : : // the best topologically-valid set compatible with this work item, and (T - B) is
843 : : // non-empty, then (T | B) is better than B and also topological. This is in
844 : : // contradiction with the assumption that B is best. Thus, (T - B) must be empty,
845 : : // or T must be a subset of B.
846 : : //
847 : : // See https://delvingbitcoin.org/t/how-to-linearize-your-cluster/303 section 2.4.
848 [ # # ]: 0 : const auto init_inc = inc.transactions;
849 [ # # # # : 0 : for (auto pos : pot.transactions - inc.transactions) {
# # ]
850 : : // If the transaction's ancestors are a subset of pot, we can add it together
851 : : // with its ancestors to inc. Just update the transactions here; the feerate
852 : : // update happens below.
853 [ # # ]: 0 : auto anc_todo = m_sorted_depgraph.Ancestors(pos) & m_todo;
854 [ # # ]: 0 : if (anc_todo.IsSubsetOf(pot.transactions)) inc.transactions |= anc_todo;
855 : : }
856 : : // Finally update und and inc's feerate to account for the added transactions.
857 : 0 : und -= inc.transactions;
858 [ # # ]: 0 : inc.feerate += m_sorted_depgraph.FeeRate(inc.transactions - init_inc);
859 : :
860 : : // If inc's feerate is better than best's, remember it as our new best.
861 [ # # ]: 0 : if (inc.feerate > best.feerate) {
862 : 0 : best = inc;
863 : : // See if we can remove any entries from imp now.
864 [ # # ]: 0 : while (imp.Any()) {
865 [ # # ]: 0 : DepGraphIndex check = imp.Last();
866 [ # # ]: 0 : if (m_sorted_depgraph.FeeRate(check) >> best.feerate) break;
867 : 0 : imp.Reset(check);
868 : : }
869 : : }
870 : :
871 : : // If no potential transactions exist beyond the already included ones, no
872 : : // improvement is possible anymore.
873 [ # # ]: 0 : if (pot.feerate.size == inc.feerate.size) return;
874 : : // At this point und must be non-empty. If it were empty then pot would equal inc.
875 : : Assume(und.Any());
876 : : } else {
877 [ # # ]: 0 : Assume(inc.transactions.None());
878 : : // If inc is empty, we just make sure there are undecided transactions left to
879 : : // split on.
880 [ # # ]: 0 : if (und.None()) return;
881 : : }
882 : :
883 : : // Actually construct a new work item on the queue. Due to the switch to DFS when queue
884 : : // space runs out (see below), we know that no reallocation of the queue should ever
885 : : // occur.
886 : 0 : Assume(queue.size() < queue.capacity());
887 : 0 : queue.emplace_back(/*inc=*/std::move(inc),
888 : : /*und=*/std::move(und),
889 : : /*pot_feerate=*/std::move(pot.feerate));
890 : : };
891 : :
892 : : /** Internal process function. It takes an existing work item, and splits it in two: one
893 : : * with a particular transaction (and its ancestors) included, and one with that
894 : : * transaction (and its descendants) excluded. */
895 : 0 : auto split_fn = [&](WorkItem&& elem) noexcept {
896 : : // Any queue element must have undecided transactions left, otherwise there is nothing
897 : : // to explore anymore.
898 [ # # ]: 0 : Assume(elem.und.Any());
899 : : // The included and undecided set are all subsets of m_todo.
900 [ # # ]: 0 : Assume(elem.inc.transactions.IsSubsetOf(m_todo) && elem.und.IsSubsetOf(m_todo));
901 : : // Included transactions cannot be undecided.
902 : 0 : Assume(!elem.inc.transactions.Overlaps(elem.und));
903 : : // If pot is empty, then so is inc.
904 : 0 : Assume(elem.inc.feerate.IsEmpty() == elem.pot_feerate.IsEmpty());
905 : :
906 [ # # ]: 0 : const DepGraphIndex first = elem.und.First();
907 [ # # ]: 0 : if (!elem.inc.feerate.IsEmpty()) {
908 : : // If no undecided transactions remain with feerate higher than best, this entry
909 : : // cannot be improved beyond best.
910 [ # # ]: 0 : if (!elem.und.Overlaps(imp)) return;
911 : : // We can ignore any queue item whose potential feerate isn't better than the best
912 : : // seen so far.
913 [ # # ]: 0 : if (elem.pot_feerate <= best.feerate) return;
914 : : } else {
915 : : // In case inc is empty use a simpler alternative check.
916 [ # # ]: 0 : if (m_sorted_depgraph.FeeRate(first) <= best.feerate) return;
917 : : }
918 : :
919 : : // Decide which transaction to split on. Splitting is how new work items are added, and
920 : : // how progress is made. One split transaction is chosen among the queue item's
921 : : // undecided ones, and:
922 : : // - A work item is (potentially) added with that transaction plus its remaining
923 : : // descendants excluded (removed from the und set).
924 : : // - A work item is (potentially) added with that transaction plus its remaining
925 : : // ancestors included (added to the inc set).
926 : : //
927 : : // To decide what to split on, consider the undecided ancestors of the highest
928 : : // individual feerate undecided transaction. Pick the one which reduces the search space
929 : : // most. Let I(t) be the size of the undecided set after including t, and E(t) the size
930 : : // of the undecided set after excluding t. Then choose the split transaction t such
931 : : // that 2^I(t) + 2^E(t) is minimal, tie-breaking by highest individual feerate for t.
932 : 0 : DepGraphIndex split = 0;
933 [ # # ]: 0 : const auto select = elem.und & m_sorted_depgraph.Ancestors(first);
934 : 0 : Assume(select.Any());
935 : 0 : std::optional<std::pair<DepGraphIndex, DepGraphIndex>> split_counts;
936 [ # # # # ]: 0 : for (auto t : select) {
937 : : // Call max = max(I(t), E(t)) and min = min(I(t), E(t)). Let counts = {max,min}.
938 : : // Sorting by the tuple counts is equivalent to sorting by 2^I(t) + 2^E(t). This
939 : : // expression is equal to 2^max + 2^min = 2^max * (1 + 1/2^(max - min)). The second
940 : : // factor (1 + 1/2^(max - min)) there is in (1,2]. Thus increasing max will always
941 : : // increase it, even when min decreases. Because of this, we can first sort by max.
942 : 0 : std::pair<DepGraphIndex, DepGraphIndex> counts{
943 [ # # ]: 0 : (elem.und - m_sorted_depgraph.Ancestors(t)).Count(),
944 [ # # ]: 0 : (elem.und - m_sorted_depgraph.Descendants(t)).Count()};
945 [ # # ]: 0 : if (counts.first < counts.second) std::swap(counts.first, counts.second);
946 : : // Remember the t with the lowest counts.
947 [ # # # # ]: 0 : if (!split_counts.has_value() || counts < *split_counts) {
948 [ # # ]: 0 : split = t;
949 [ # # ]: 0 : split_counts = counts;
950 : : }
951 : : }
952 : : // Since there was at least one transaction in select, we must always find one.
953 : 0 : Assume(split_counts.has_value());
954 : :
955 : : // Add a work item corresponding to exclusion of the split transaction.
956 : 0 : const auto& desc = m_sorted_depgraph.Descendants(split);
957 : 0 : add_fn(/*inc=*/elem.inc,
958 : 0 : /*und=*/elem.und - desc);
959 : :
960 : : // Add a work item corresponding to inclusion of the split transaction.
961 : 0 : const auto anc = m_sorted_depgraph.Ancestors(split) & m_todo;
962 : 0 : add_fn(/*inc=*/elem.inc.Add(m_sorted_depgraph, anc),
963 : 0 : /*und=*/elem.und - anc);
964 : :
965 : : // Account for the performed split.
966 : 0 : --iterations_left;
967 : : };
968 : :
969 : : // Work processing loop.
970 : : //
971 : : // New work items are always added at the back of the queue, but items to process use a
972 : : // hybrid approach where they can be taken from the front or the back.
973 : : //
974 : : // Depth-first search (DFS) corresponds to always taking from the back of the queue. This
975 : : // is very memory-efficient (linear in the number of transactions). Breadth-first search
976 : : // (BFS) corresponds to always taking from the front, which potentially uses more memory
977 : : // (up to exponential in the transaction count), but seems to work better in practice.
978 : : //
979 : : // The approach here combines the two: use BFS (plus random swapping) until the queue grows
980 : : // too large, at which point we temporarily switch to DFS until the size shrinks again.
981 [ # # ]: 0 : while (!queue.empty()) {
982 : : // Randomly swap the first two items to randomize the search order.
983 [ # # # # ]: 0 : if (queue.size() > 1 && m_rng.randbool()) {
984 [ # # ]: 0 : queue[0].Swap(queue[1]);
985 : : }
986 : :
987 : : // Processing the first queue item, and then using DFS for everything it gives rise to,
988 : : // may increase the queue size by the number of undecided elements in there, minus 1
989 : : // for the first queue item being removed. Thus, only when that pushes the queue over
990 : : // its capacity can we not process from the front (BFS), and should we use DFS.
991 [ # # ]: 0 : while (queue.size() - 1 + queue.front().und.Count() > queue.capacity()) {
992 [ # # ]: 0 : if (!iterations_left) break;
993 : 0 : auto elem = queue.back();
994 : 0 : queue.pop_back();
995 : 0 : split_fn(std::move(elem));
996 : : }
997 : :
998 : : // Process one entry from the front of the queue (BFS exploration)
999 [ # # ]: 0 : if (!iterations_left) break;
1000 [ # # ]: 0 : auto elem = queue.front();
1001 : 0 : queue.pop_front();
1002 : 0 : split_fn(std::move(elem));
1003 : : }
1004 : :
1005 : : // Return the found best set (converted to the original transaction indices), and the
1006 : : // number of iterations performed.
1007 : 0 : best.transactions = SortedToOriginal(best.transactions);
1008 : 0 : return {std::move(best), max_iterations - iterations_left};
1009 : 0 : }
1010 : :
1011 : : /** Remove a subset of transactions from the cluster being linearized.
1012 : : *
1013 : : * Complexity: O(N) where N=done.Count().
1014 : : */
1015 : 0 : void MarkDone(const SetType& done) noexcept
1016 : : {
1017 : 0 : const auto done_sorted = OriginalToSorted(done);
1018 : 0 : Assume(done_sorted.Any());
1019 : 0 : Assume(done_sorted.IsSubsetOf(m_todo));
1020 : 0 : m_todo -= done_sorted;
1021 : 0 : }
1022 : : };
1023 : :
1024 : : /** Find or improve a linearization for a cluster.
1025 : : *
1026 : : * @param[in] depgraph Dependency graph of the cluster to be linearized.
1027 : : * @param[in] max_iterations Upper bound on the number of optimization steps that will be done.
1028 : : * @param[in] rng_seed A random number seed to control search order. This prevents peers
1029 : : * from predicting exactly which clusters would be hard for us to
1030 : : * linearize.
1031 : : * @param[in] old_linearization An existing linearization for the cluster (which must be
1032 : : * topologically valid), or empty.
1033 : : * @return A pair of:
1034 : : * - The resulting linearization. It is guaranteed to be at least as
1035 : : * good (in the feerate diagram sense) as old_linearization.
1036 : : * - A boolean indicating whether the result is guaranteed to be
1037 : : * optimal.
1038 : : *
1039 : : * Complexity: possibly O(N * min(max_iterations + N, sqrt(2^N))) where N=depgraph.TxCount().
1040 : : */
1041 : : template<typename SetType>
1042 [ # # ]: 0 : std::pair<std::vector<DepGraphIndex>, bool> Linearize(const DepGraph<SetType>& depgraph, uint64_t max_iterations, uint64_t rng_seed, std::span<const DepGraphIndex> old_linearization = {}) noexcept
1043 : : {
1044 [ # # # # ]: 0 : Assume(old_linearization.empty() || old_linearization.size() == depgraph.TxCount());
1045 [ # # ]: 0 : if (depgraph.TxCount() == 0) return {{}, true};
1046 : :
1047 : 0 : uint64_t iterations_left = max_iterations;
1048 : 0 : std::vector<DepGraphIndex> linearization;
1049 : :
1050 : 0 : AncestorCandidateFinder anc_finder(depgraph);
1051 : 0 : std::optional<SearchCandidateFinder<SetType>> src_finder;
1052 : 0 : linearization.reserve(depgraph.TxCount());
1053 [ # # ]: 0 : bool optimal = true;
1054 : :
1055 : : // Treat the initialization of SearchCandidateFinder as taking N^2/64 (rounded up) iterations
1056 : : // (largely due to the cost of constructing the internal sorted-by-feerate DepGraph inside
1057 : : // SearchCandidateFinder), a rough approximation based on benchmark. If we don't have that
1058 : : // many, don't start it.
1059 : 0 : uint64_t start_iterations = (uint64_t{depgraph.TxCount()} * depgraph.TxCount() + 63) / 64;
1060 [ # # ]: 0 : if (iterations_left > start_iterations) {
1061 : 0 : iterations_left -= start_iterations;
1062 : 0 : src_finder.emplace(depgraph, rng_seed);
1063 : : }
1064 : :
1065 : : /** Chunking of what remains of the old linearization. */
1066 : 0 : LinearizationChunking old_chunking(depgraph, old_linearization);
1067 : :
1068 : : while (true) {
1069 : : // Find the highest-feerate prefix of the remainder of old_linearization.
1070 [ # # ]: 0 : SetInfo<SetType> best_prefix;
1071 [ # # ]: 0 : if (old_chunking.NumChunksLeft()) best_prefix = old_chunking.GetChunk(0);
1072 : :
1073 : : // Then initialize best to be either the best remaining ancestor set, or the first chunk.
1074 [ # # ]: 0 : auto best = anc_finder.FindCandidateSet();
1075 [ # # # # ]: 0 : if (!best_prefix.feerate.IsEmpty() && best_prefix.feerate >= best.feerate) best = best_prefix;
1076 : :
1077 : 0 : uint64_t iterations_done_now = 0;
1078 [ # # ]: 0 : uint64_t max_iterations_now = 0;
1079 [ # # ]: 0 : if (src_finder) {
1080 : : // Treat the invocation of SearchCandidateFinder::FindCandidateSet() as costing N/4
1081 : : // up-front (rounded up) iterations (largely due to the cost of connected-component
1082 : : // splitting), a rough approximation based on benchmarks.
1083 : 0 : uint64_t base_iterations = (anc_finder.NumRemaining() + 3) / 4;
1084 [ # # ]: 0 : if (iterations_left > base_iterations) {
1085 : : // Invoke bounded search to update best, with up to half of our remaining
1086 : : // iterations as limit.
1087 : 0 : iterations_left -= base_iterations;
1088 : 0 : max_iterations_now = (iterations_left + 1) / 2;
1089 : 0 : std::tie(best, iterations_done_now) = src_finder->FindCandidateSet(max_iterations_now, best);
1090 : 0 : iterations_left -= iterations_done_now;
1091 : : }
1092 : : }
1093 : :
1094 [ # # ]: 0 : if (iterations_done_now == max_iterations_now) {
1095 [ # # ]: 0 : optimal = false;
1096 : : // If the search result is not (guaranteed to be) optimal, run intersections to make
1097 : : // sure we don't pick something that makes us unable to reach further diagram points
1098 : : // of the old linearization.
1099 [ # # ]: 0 : if (old_chunking.NumChunksLeft() > 0) {
1100 : 0 : best = old_chunking.IntersectPrefixes(best);
1101 : : }
1102 : : }
1103 : :
1104 : : // Add to output in topological order.
1105 : 0 : depgraph.AppendTopo(linearization, best.transactions);
1106 : :
1107 : : // Update state to reflect best is no longer to be linearized.
1108 [ # # ]: 0 : anc_finder.MarkDone(best.transactions);
1109 [ # # ]: 0 : if (anc_finder.AllDone()) break;
1110 [ # # ]: 0 : if (src_finder) src_finder->MarkDone(best.transactions);
1111 [ # # ]: 0 : if (old_chunking.NumChunksLeft() > 0) {
1112 : 0 : old_chunking.MarkDone(best.transactions);
1113 : : }
1114 : : }
1115 : :
1116 : 0 : return {std::move(linearization), optimal};
1117 : 0 : }
1118 : :
1119 : : /** Improve a given linearization.
1120 : : *
1121 : : * @param[in] depgraph Dependency graph of the cluster being linearized.
1122 : : * @param[in,out] linearization On input, an existing linearization for depgraph. On output, a
1123 : : * potentially better linearization for the same graph.
1124 : : *
1125 : : * Postlinearization guarantees:
1126 : : * - The resulting chunks are connected.
1127 : : * - If the input has a tree shape (either all transactions have at most one child, or all
1128 : : * transactions have at most one parent), the result is optimal.
1129 : : * - Given a linearization L1 and a leaf transaction T in it. Let L2 be L1 with T moved to the end,
1130 : : * optionally with its fee increased. Let L3 be the postlinearization of L2. L3 will be at least
1131 : : * as good as L1. This means that replacing transactions with same-size higher-fee transactions
1132 : : * will not worsen linearizations through a "drop conflicts, append new transactions,
1133 : : * postlinearize" process.
1134 : : */
1135 : : template<typename SetType>
1136 : 0 : void PostLinearize(const DepGraph<SetType>& depgraph, std::span<DepGraphIndex> linearization)
1137 : : {
1138 : : // This algorithm performs a number of passes (currently 2); the even ones operate from back to
1139 : : // front, the odd ones from front to back. Each results in an equal-or-better linearization
1140 : : // than the one started from.
1141 : : // - One pass in either direction guarantees that the resulting chunks are connected.
1142 : : // - Each direction corresponds to one shape of tree being linearized optimally (forward passes
1143 : : // guarantee this for graphs where each transaction has at most one child; backward passes
1144 : : // guarantee this for graphs where each transaction has at most one parent).
1145 : : // - Starting with a backward pass guarantees the moved-tree property.
1146 : : //
1147 : : // During an odd (forward) pass, the high-level operation is:
1148 : : // - Start with an empty list of groups L=[].
1149 : : // - For every transaction i in the old linearization, from front to back:
1150 : : // - Append a new group C=[i], containing just i, to the back of L.
1151 : : // - While L has at least one group before C, and the group immediately before C has feerate
1152 : : // lower than C:
1153 : : // - If C depends on P:
1154 : : // - Merge P into C, making C the concatenation of P+C, continuing with the combined C.
1155 : : // - Otherwise:
1156 : : // - Swap P with C, continuing with the now-moved C.
1157 : : // - The output linearization is the concatenation of the groups in L.
1158 : : //
1159 : : // During even (backward) passes, i iterates from the back to the front of the existing
1160 : : // linearization, and new groups are prepended instead of appended to the list L. To enable
1161 : : // more code reuse, both passes append groups, but during even passes the meanings of
1162 : : // parent/child, and of high/low feerate are reversed, and the final concatenation is reversed
1163 : : // on output.
1164 : : //
1165 : : // In the implementation below, the groups are represented by singly-linked lists (pointing
1166 : : // from the back to the front), which are themselves organized in a singly-linked circular
1167 : : // list (each group pointing to its predecessor, with a special sentinel group at the front
1168 : : // that points back to the last group).
1169 : : //
1170 : : // Information about transaction t is stored in entries[t + 1], while the sentinel is in
1171 : : // entries[0].
1172 : :
1173 : : /** Index of the sentinel in the entries array below. */
1174 : : static constexpr DepGraphIndex SENTINEL{0};
1175 : : /** Indicator that a group has no previous transaction. */
1176 : : static constexpr DepGraphIndex NO_PREV_TX{0};
1177 : :
1178 : :
1179 : : /** Data structure per transaction entry. */
1180 : 0 : struct TxEntry
1181 : : {
1182 : : /** The index of the previous transaction in this group; NO_PREV_TX if this is the first
1183 : : * entry of a group. */
1184 : : DepGraphIndex prev_tx;
1185 : :
1186 : : // The fields below are only used for transactions that are the last one in a group
1187 : : // (referred to as tail transactions below).
1188 : :
1189 : : /** Index of the first transaction in this group, possibly itself. */
1190 : : DepGraphIndex first_tx;
1191 : : /** Index of the last transaction in the previous group. The first group (the sentinel)
1192 : : * points back to the last group here, making it a singly-linked circular list. */
1193 : : DepGraphIndex prev_group;
1194 : : /** All transactions in the group. Empty for the sentinel. */
1195 : : SetType group;
1196 : : /** All dependencies of the group (descendants in even passes; ancestors in odd ones). */
1197 : : SetType deps;
1198 : : /** The combined fee/size of transactions in the group. Fee is negated in even passes. */
1199 : : FeeFrac feerate;
1200 : : };
1201 : :
1202 : : // As an example, consider the state corresponding to the linearization [1,0,3,2], with
1203 : : // groups [1,0,3] and [2], in an odd pass. The linked lists would be:
1204 : : //
1205 : : // +-----+
1206 : : // 0<-P-- | 0 S | ---\ Legend:
1207 : : // +-----+ |
1208 : : // ^ | - digit in box: entries index
1209 : : // /--------------F---------+ G | (note: one more than tx value)
1210 : : // v \ | | - S: sentinel group
1211 : : // +-----+ +-----+ +-----+ | (empty feerate)
1212 : : // 0<-P-- | 2 | <--P-- | 1 | <--P-- | 4 T | | - T: tail transaction, contains
1213 : : // +-----+ +-----+ +-----+ | fields beyond prev_tv.
1214 : : // ^ | - P: prev_tx reference
1215 : : // G G - F: first_tx reference
1216 : : // | | - G: prev_group reference
1217 : : // +-----+ |
1218 : : // 0<-P-- | 3 T | <--/
1219 : : // +-----+
1220 : : // ^ |
1221 : : // \-F-/
1222 : : //
1223 : : // During an even pass, the diagram above would correspond to linearization [2,3,0,1], with
1224 : : // groups [2] and [3,0,1].
1225 : :
1226 : 0 : std::vector<TxEntry> entries(depgraph.PositionRange() + 1);
1227 : :
1228 : : // Perform two passes over the linearization.
1229 [ # # ]: 0 : for (int pass = 0; pass < 2; ++pass) {
1230 : 0 : int rev = !(pass & 1);
1231 : : // Construct a sentinel group, identifying the start of the list.
1232 : 0 : entries[SENTINEL].prev_group = SENTINEL;
1233 : 0 : Assume(entries[SENTINEL].feerate.IsEmpty());
1234 : :
1235 : : // Iterate over all elements in the existing linearization.
1236 [ # # ]: 0 : for (DepGraphIndex i = 0; i < linearization.size(); ++i) {
1237 : : // Even passes are from back to front; odd passes from front to back.
1238 [ # # ]: 0 : DepGraphIndex idx = linearization[rev ? linearization.size() - 1 - i : i];
1239 : : // Construct a new group containing just idx. In even passes, the meaning of
1240 : : // parent/child and high/low feerate are swapped.
1241 [ # # ]: 0 : DepGraphIndex cur_group = idx + 1;
1242 [ # # ]: 0 : entries[cur_group].group = SetType::Singleton(idx);
1243 [ # # # # ]: 0 : entries[cur_group].deps = rev ? depgraph.Descendants(idx): depgraph.Ancestors(idx);
1244 : 0 : entries[cur_group].feerate = depgraph.FeeRate(idx);
1245 [ # # ]: 0 : if (rev) entries[cur_group].feerate.fee = -entries[cur_group].feerate.fee;
1246 : 0 : entries[cur_group].prev_tx = NO_PREV_TX; // No previous transaction in group.
1247 : 0 : entries[cur_group].first_tx = cur_group; // Transaction itself is first of group.
1248 : : // Insert the new group at the back of the groups linked list.
1249 : 0 : entries[cur_group].prev_group = entries[SENTINEL].prev_group;
1250 : 0 : entries[SENTINEL].prev_group = cur_group;
1251 : :
1252 : : // Start merge/swap cycle.
1253 : 0 : DepGraphIndex next_group = SENTINEL; // We inserted at the end, so next group is sentinel.
1254 : 0 : DepGraphIndex prev_group = entries[cur_group].prev_group;
1255 : : // Continue as long as the current group has higher feerate than the previous one.
1256 [ # # ]: 0 : while (entries[cur_group].feerate >> entries[prev_group].feerate) {
1257 : : // prev_group/cur_group/next_group refer to (the last transactions of) 3
1258 : : // consecutive entries in groups list.
1259 : 0 : Assume(cur_group == entries[next_group].prev_group);
1260 : 0 : Assume(prev_group == entries[cur_group].prev_group);
1261 : : // The sentinel has empty feerate, which is neither higher or lower than other
1262 : : // feerates. Thus, the while loop we are in here guarantees that cur_group and
1263 : : // prev_group are not the sentinel.
1264 : : Assume(cur_group != SENTINEL);
1265 : : Assume(prev_group != SENTINEL);
1266 [ # # ]: 0 : if (entries[cur_group].deps.Overlaps(entries[prev_group].group)) {
1267 : : // There is a dependency between cur_group and prev_group; merge prev_group
1268 : : // into cur_group. The group/deps/feerate fields of prev_group remain unchanged
1269 : : // but become unused.
1270 : 0 : entries[cur_group].group |= entries[prev_group].group;
1271 : 0 : entries[cur_group].deps |= entries[prev_group].deps;
1272 : 0 : entries[cur_group].feerate += entries[prev_group].feerate;
1273 : : // Make the first of the current group point to the tail of the previous group.
1274 : 0 : entries[entries[cur_group].first_tx].prev_tx = prev_group;
1275 : : // The first of the previous group becomes the first of the newly-merged group.
1276 : 0 : entries[cur_group].first_tx = entries[prev_group].first_tx;
1277 : : // The previous group becomes whatever group was before the former one.
1278 : 0 : prev_group = entries[prev_group].prev_group;
1279 : 0 : entries[cur_group].prev_group = prev_group;
1280 : : } else {
1281 : : // There is no dependency between cur_group and prev_group; swap them.
1282 : 0 : DepGraphIndex preprev_group = entries[prev_group].prev_group;
1283 : : // If PP, P, C, N were the old preprev, prev, cur, next groups, then the new
1284 : : // layout becomes [PP, C, P, N]. Update prev_groups to reflect that order.
1285 : 0 : entries[next_group].prev_group = prev_group;
1286 : 0 : entries[prev_group].prev_group = cur_group;
1287 : 0 : entries[cur_group].prev_group = preprev_group;
1288 : : // The current group remains the same, but the groups before/after it have
1289 : : // changed.
1290 : 0 : next_group = prev_group;
1291 : 0 : prev_group = preprev_group;
1292 : : }
1293 : : }
1294 : : }
1295 : :
1296 : : // Convert the entries back to linearization (overwriting the existing one).
1297 : 0 : DepGraphIndex cur_group = entries[0].prev_group;
1298 : 0 : DepGraphIndex done = 0;
1299 [ # # ]: 0 : while (cur_group != SENTINEL) {
1300 : 0 : DepGraphIndex cur_tx = cur_group;
1301 : : // Traverse the transactions of cur_group (from back to front), and write them in the
1302 : : // same order during odd passes, and reversed (front to back) in even passes.
1303 [ # # ]: 0 : if (rev) {
1304 : : do {
1305 [ # # ]: 0 : *(linearization.begin() + (done++)) = cur_tx - 1;
1306 [ # # ]: 0 : cur_tx = entries[cur_tx].prev_tx;
1307 [ # # ]: 0 : } while (cur_tx != NO_PREV_TX);
1308 : : } else {
1309 : : do {
1310 [ # # ]: 0 : *(linearization.end() - (++done)) = cur_tx - 1;
1311 [ # # ]: 0 : cur_tx = entries[cur_tx].prev_tx;
1312 [ # # ]: 0 : } while (cur_tx != NO_PREV_TX);
1313 : : }
1314 : 0 : cur_group = entries[cur_group].prev_group;
1315 : : }
1316 : 0 : Assume(done == linearization.size());
1317 : : }
1318 : 0 : }
1319 : :
1320 : : /** Merge two linearizations for the same cluster into one that is as good as both.
1321 : : *
1322 : : * Complexity: O(N^2) where N=depgraph.TxCount(); O(N) if both inputs are identical.
1323 : : */
1324 : : template<typename SetType>
1325 : : std::vector<DepGraphIndex> MergeLinearizations(const DepGraph<SetType>& depgraph, std::span<const DepGraphIndex> lin1, std::span<const DepGraphIndex> lin2)
1326 : : {
1327 : : Assume(lin1.size() == depgraph.TxCount());
1328 : : Assume(lin2.size() == depgraph.TxCount());
1329 : :
1330 : : /** Chunkings of what remains of both input linearizations. */
1331 : : LinearizationChunking chunking1(depgraph, lin1), chunking2(depgraph, lin2);
1332 : : /** Output linearization. */
1333 : : std::vector<DepGraphIndex> ret;
1334 : : if (depgraph.TxCount() == 0) return ret;
1335 : : ret.reserve(depgraph.TxCount());
1336 : :
1337 : : while (true) {
1338 : : // As long as we are not done, both linearizations must have chunks left.
1339 : : Assume(chunking1.NumChunksLeft() > 0);
1340 : : Assume(chunking2.NumChunksLeft() > 0);
1341 : : // Find the set to output by taking the best remaining chunk, and then intersecting it with
1342 : : // prefixes of remaining chunks of the other linearization.
1343 : : SetInfo<SetType> best;
1344 : : const auto& lin1_firstchunk = chunking1.GetChunk(0);
1345 : : const auto& lin2_firstchunk = chunking2.GetChunk(0);
1346 : : if (lin2_firstchunk.feerate >> lin1_firstchunk.feerate) {
1347 : : best = chunking1.IntersectPrefixes(lin2_firstchunk);
1348 : : } else {
1349 : : best = chunking2.IntersectPrefixes(lin1_firstchunk);
1350 : : }
1351 : : // Append the result to the output and mark it as done.
1352 : : depgraph.AppendTopo(ret, best.transactions);
1353 : : chunking1.MarkDone(best.transactions);
1354 : : if (chunking1.NumChunksLeft() == 0) break;
1355 : : chunking2.MarkDone(best.transactions);
1356 : : }
1357 : :
1358 : : Assume(ret.size() == depgraph.TxCount());
1359 : : return ret;
1360 : : }
1361 : :
1362 : : /** Make linearization topological, retaining its ordering where possible. */
1363 : : template<typename SetType>
1364 : 0 : void FixLinearization(const DepGraph<SetType>& depgraph, std::span<DepGraphIndex> linearization) noexcept
1365 : : {
1366 : : // This algorithm can be summarized as moving every element in the linearization backwards
1367 : : // until it is placed after all its ancestors.
1368 : 0 : SetType done;
1369 : 0 : const auto len = linearization.size();
1370 : : // Iterate over the elements of linearization from back to front (i is distance from back).
1371 [ # # ]: 0 : for (DepGraphIndex i = 0; i < len; ++i) {
1372 : : /** The element at that position. */
1373 : 0 : DepGraphIndex elem = linearization[len - 1 - i];
1374 : : /** j represents how far from the back of the linearization elem should be placed. */
1375 : 0 : DepGraphIndex j = i;
1376 : : // Figure out which elements need to be moved before elem.
1377 : 0 : SetType place_before = done & depgraph.Ancestors(elem);
1378 : : // Find which position to place elem in (updating j), continuously moving the elements
1379 : : // in between forward.
1380 [ # # ]: 0 : while (place_before.Any()) {
1381 : : // j cannot be 0 here; if it was, then there was necessarily nothing earlier which
1382 : : // elem needs to be placed before anymore, and place_before would be empty.
1383 : : Assume(j > 0);
1384 : 0 : auto to_swap = linearization[len - 1 - (j - 1)];
1385 : 0 : place_before.Reset(to_swap);
1386 : 0 : linearization[len - 1 - (j--)] = to_swap;
1387 : : }
1388 : : // Put elem in its final position and mark it as done.
1389 : 0 : linearization[len - 1 - j] = elem;
1390 : 0 : done.Set(elem);
1391 : : }
1392 : 0 : }
1393 : :
1394 : : } // namespace cluster_linearize
1395 : :
1396 : : #endif // BITCOIN_CLUSTER_LINEARIZE_H
|
