Electroneum
Loading...
Searching...
No Matches
pruning.cpp File Reference
#include "gtest/gtest.h"
#include "misc_log_ex.h"
#include "cryptonote_config.h"
#include "common/pruning.h"
Include dependency graph for pruning.cpp:

Go to the source code of this file.

Macros

#define ASSERT_EX(x)

Functions

 TEST (pruning, parts)
 TEST (pruning, out_of_range)
 TEST (pruning, fits)
 TEST (pruning, tip)
 TEST (pruning, seed)
 TEST (pruning, match)
 TEST (pruning, stripe_size)
 TEST (pruning, next_unpruned)
 TEST (pruning, next_pruned)

Macro Definition Documentation

◆ ASSERT_EX

#define ASSERT_EX ( x)
Value:
do { bool ex = false; try { x; } catch(...) { ex = true; } ASSERT_TRUE(ex); } while(0)
ASSERT_TRUE
#define ASSERT_TRUE(condition)
Definition gtest.h:1865

Definition at line 35 of file pruning.cpp.

Function Documentation

◆ TEST() [1/9]

TEST ( pruning ,
fits  )

Definition at line 64 of file pruning.cpp.

65{
66 const uint32_t log_stripes = 3;
67 const uint32_t num_stripes = 1 << log_stripes;
68 for (uint32_t stripe = 1; stripe <= num_stripes; ++stripe)
69 {
70 const uint32_t seed = tools::make_pruning_seed(stripe, log_stripes);
71 ASSERT_NE(seed, 0);
72 ASSERT_EQ(tools::get_pruning_log_stripes(seed), log_stripes);
73 ASSERT_EQ(tools::get_pruning_stripe(seed), stripe);
74 }
75}
ASSERT_EQ
#define ASSERT_EQ(val1, val2)
Definition gtest.h:1956
ASSERT_NE
#define ASSERT_NE(val1, val2)
Definition gtest.h:1960
tools::get_pruning_log_stripes
constexpr uint32_t get_pruning_log_stripes(uint32_t pruning_seed)
Definition pruning.h:40
tools::get_pruning_stripe
uint32_t get_pruning_stripe(uint64_t block_height, uint64_t blockchain_height, uint32_t log_stripes)
Definition pruning.cpp:54
tools::make_pruning_seed
uint32_t make_pruning_seed(uint32_t stripe, uint32_t log_stripes)
Definition pruning.cpp:37
uint32_t
unsigned int uint32_t
Definition stdint.h:126
Here is the call graph for this function:

◆ TEST() [2/9]

TEST ( pruning ,
match  )

Definition at line 110 of file pruning.cpp.

111{
112 static constexpr uint64_t H = CRYPTONOTE_PRUNING_TIP_BLOCKS + 1000;
113 static_assert(H >= CRYPTONOTE_PRUNING_TIP_BLOCKS, "H must be >= CRYPTONOTE_PRUNING_TIP_BLOCKS");
114 for (uint64_t h = 0; h < H - CRYPTONOTE_PRUNING_TIP_BLOCKS; ++h)
115 {
116 uint32_t pruning_seed = tools::get_pruning_seed(h, H, CRYPTONOTE_PRUNING_LOG_STRIPES);
117 uint32_t pruning_stripe = tools::get_pruning_stripe(pruning_seed);
118 ASSERT_TRUE(pruning_stripe > 0 && pruning_stripe <= (1 << CRYPTONOTE_PRUNING_LOG_STRIPES));
119 for (uint32_t other_pruning_stripe = 1; other_pruning_stripe <= (1 << CRYPTONOTE_PRUNING_LOG_STRIPES); ++other_pruning_stripe)
120 {
121 uint32_t other_pruning_seed = tools::make_pruning_seed(other_pruning_stripe, CRYPTONOTE_PRUNING_LOG_STRIPES);
122 ASSERT_TRUE(tools::has_unpruned_block(h, H, other_pruning_seed) == (other_pruning_seed == pruning_seed));
123 }
124 }
125}
CRYPTONOTE_PRUNING_LOG_STRIPES
#define CRYPTONOTE_PRUNING_LOG_STRIPES
Definition cryptonote_config.h:188
CRYPTONOTE_PRUNING_TIP_BLOCKS
#define CRYPTONOTE_PRUNING_TIP_BLOCKS
Definition cryptonote_config.h:189
tools::get_pruning_seed
uint32_t get_pruning_seed(uint64_t block_height, uint64_t blockchain_height, uint32_t log_stripes)
Definition pruning.cpp:61
tools::has_unpruned_block
bool has_unpruned_block(uint64_t block_height, uint64_t blockchain_height, uint32_t pruning_seed)
Definition pruning.cpp:44
uint64_t
unsigned __int64 uint64_t
Definition stdint.h:136
Here is the call graph for this function:

◆ TEST() [3/9]

TEST ( pruning ,
next_pruned  )

Definition at line 202 of file pruning.cpp.

203{
204 static_assert((1 << CRYPTONOTE_PRUNING_LOG_STRIPES) >= 4, "CRYPTONOTE_PRUNING_LOG_STRIPES too low");
205
206 const uint64_t SS = CRYPTONOTE_PRUNING_STRIPE_SIZE;
207 const uint64_t NS = 1 << CRYPTONOTE_PRUNING_LOG_STRIPES;
208 const uint64_t TB = NS * SS;
209
210 const uint32_t seed1 = tools::make_pruning_seed(1, CRYPTONOTE_PRUNING_LOG_STRIPES);
211 const uint32_t seed2 = tools::make_pruning_seed(2, CRYPTONOTE_PRUNING_LOG_STRIPES);
212 const uint32_t seedNS_1 = tools::make_pruning_seed(NS-1, CRYPTONOTE_PRUNING_LOG_STRIPES);
213 const uint32_t seedNS = tools::make_pruning_seed(NS, CRYPTONOTE_PRUNING_LOG_STRIPES);
214
215 for (uint64_t h = 0; h < 100; ++h)
216 ASSERT_EQ(tools::get_next_pruned_block_height(h, 10000000, 0), 10000000);
217 for (uint64_t h = 10000000 - 1 - CRYPTONOTE_PRUNING_TIP_BLOCKS; h < 10000000; ++h)
218 ASSERT_EQ(tools::get_next_pruned_block_height(h, 10000000, 0), 10000000);
219
220 ASSERT_EQ(tools::get_next_pruned_block_height(1, 10000000, seed1), SS);
221 ASSERT_EQ(tools::get_next_pruned_block_height(SS-1, 10000000, seed1), SS);
222 ASSERT_EQ(tools::get_next_pruned_block_height(SS, 10000000, seed1), SS);
223 ASSERT_EQ(tools::get_next_pruned_block_height(TB-1, 10000000, seed1), TB-1);
224 ASSERT_EQ(tools::get_next_pruned_block_height(TB, 10000000, seed1), TB+SS);
225
226 ASSERT_EQ(tools::get_next_pruned_block_height(1, 10000000, seed2), 1);
227 ASSERT_EQ(tools::get_next_pruned_block_height(SS-1, 10000000, seed2), SS-1);
228 ASSERT_EQ(tools::get_next_pruned_block_height(SS, 10000000, seed2), 2*SS);
229 ASSERT_EQ(tools::get_next_pruned_block_height(TB-1, 10000000, seed2), TB-1);
230
231 ASSERT_EQ(tools::get_next_pruned_block_height(1, 10000000, seedNS_1), 1);
232 ASSERT_EQ(tools::get_next_pruned_block_height(SS-1, 10000000, seedNS_1), SS-1);
233 ASSERT_EQ(tools::get_next_pruned_block_height(SS, 10000000, seedNS_1), SS);
234 ASSERT_EQ(tools::get_next_pruned_block_height(TB-1, 10000000, seedNS_1), TB-1);
235
236 ASSERT_EQ(tools::get_next_pruned_block_height(1, 10000000, seedNS), 1);
237 ASSERT_EQ(tools::get_next_pruned_block_height(SS-1, 10000000, seedNS), SS-1);
238 ASSERT_EQ(tools::get_next_pruned_block_height(SS, 10000000, seedNS), SS);
239 ASSERT_EQ(tools::get_next_pruned_block_height(TB-1, 10000000, seedNS), TB);
240}
CRYPTONOTE_PRUNING_STRIPE_SIZE
#define CRYPTONOTE_PRUNING_STRIPE_SIZE
Definition cryptonote_config.h:187
tools::get_next_pruned_block_height
uint64_t get_next_pruned_block_height(uint64_t block_height, uint64_t blockchain_height, uint32_t pruning_seed)
Definition pruning.cpp:93
Here is the call graph for this function:

◆ TEST() [4/9]

TEST ( pruning ,
next_unpruned  )

Definition at line 152 of file pruning.cpp.

153{
154 static_assert((1 << CRYPTONOTE_PRUNING_LOG_STRIPES) >= 4, "CRYPTONOTE_PRUNING_LOG_STRIPES too low");
155
156 const uint64_t SS = CRYPTONOTE_PRUNING_STRIPE_SIZE;
157 const uint64_t NS = 1 << CRYPTONOTE_PRUNING_LOG_STRIPES;
158 const uint64_t TB = NS * SS;
159
160 for (uint64_t h = 0; h < 100; ++h)
161 ASSERT_EQ(tools::get_next_unpruned_block_height(h, 10000000, 0), h);
162
163 const uint32_t seed1 = tools::make_pruning_seed(1, CRYPTONOTE_PRUNING_LOG_STRIPES);
164 const uint32_t seed2 = tools::make_pruning_seed(2, CRYPTONOTE_PRUNING_LOG_STRIPES);
165 const uint32_t seed3 = tools::make_pruning_seed(3, CRYPTONOTE_PRUNING_LOG_STRIPES);
166 const uint32_t seed4 = tools::make_pruning_seed(4, CRYPTONOTE_PRUNING_LOG_STRIPES);
167 const uint32_t seedNS = tools::make_pruning_seed(NS, CRYPTONOTE_PRUNING_LOG_STRIPES);
168
169 ASSERT_EQ(tools::get_next_unpruned_block_height(0, 10000000, seed1), 0);
170 ASSERT_EQ(tools::get_next_unpruned_block_height(1, 10000000, seed1), 1);
171 ASSERT_EQ(tools::get_next_unpruned_block_height(SS-1, 10000000, seed1), SS-1);
172 ASSERT_EQ(tools::get_next_unpruned_block_height(SS, 10000000, seed1), TB);
173 ASSERT_EQ(tools::get_next_unpruned_block_height(TB, 10000000, seed1), TB);
174 ASSERT_EQ(tools::get_next_unpruned_block_height(TB-1, 10000000, seed1), TB);
175
176 ASSERT_EQ(tools::get_next_unpruned_block_height(0, 10000000, seed2), SS);
177 ASSERT_EQ(tools::get_next_unpruned_block_height(1, 10000000, seed2), SS);
178 ASSERT_EQ(tools::get_next_unpruned_block_height(SS-1, 10000000, seed2), SS);
179 ASSERT_EQ(tools::get_next_unpruned_block_height(SS, 10000000, seed2), SS);
180 ASSERT_EQ(tools::get_next_unpruned_block_height(2*SS-1, 10000000, seed2), 2*SS-1);
181 ASSERT_EQ(tools::get_next_unpruned_block_height(2*SS, 10000000, seed2), TB+SS);
182 ASSERT_EQ(tools::get_next_unpruned_block_height(TB+2*SS,10000000, seed2), TB*2+SS);
183
184 ASSERT_EQ(tools::get_next_unpruned_block_height(0, 10000000, seed3), SS*2);
185 ASSERT_EQ(tools::get_next_unpruned_block_height(SS, 10000000, seed3), SS*2);
186 ASSERT_EQ(tools::get_next_unpruned_block_height(2*SS, 10000000, seed3), SS*2);
187 ASSERT_EQ(tools::get_next_unpruned_block_height(3*SS-1, 10000000, seed3), SS*3-1);
188 ASSERT_EQ(tools::get_next_unpruned_block_height(3*SS, 10000000, seed3), TB+SS*2);
189 ASSERT_EQ(tools::get_next_unpruned_block_height(TB+3*SS,10000000, seed3), TB*2+SS*2);
190
191 ASSERT_EQ(tools::get_next_unpruned_block_height(SS, 10000000, seed4), 3*SS);
192 ASSERT_EQ(tools::get_next_unpruned_block_height(4*SS-1, 10000000, seed4), 4*SS-1);
193 ASSERT_EQ(tools::get_next_unpruned_block_height(4*SS, 10000000, seed4), TB+3*SS);
194 ASSERT_EQ(tools::get_next_unpruned_block_height(TB+4*SS,10000000, seed4), TB*2+3*SS);
195
196 ASSERT_EQ(tools::get_next_unpruned_block_height(SS, 10000000, seedNS), (NS-1)*SS);
197 ASSERT_EQ(tools::get_next_unpruned_block_height(NS*SS-1,10000000, seedNS), NS*SS-1);
198 ASSERT_EQ(tools::get_next_unpruned_block_height(NS*SS, 10000000, seedNS), TB+(NS-1)*SS);
199 ASSERT_EQ(tools::get_next_unpruned_block_height(TB+NS*SS, 10000000, seedNS), TB*2+(NS-1)*SS);
200}
tools::get_next_unpruned_block_height
uint64_t get_next_unpruned_block_height(uint64_t block_height, uint64_t blockchain_height, uint32_t pruning_seed)
Definition pruning.cpp:69
Here is the call graph for this function:

◆ TEST() [5/9]

TEST ( pruning ,
out_of_range  )

Definition at line 58 of file pruning.cpp.

59{
60 ASSERT_EX(tools::make_pruning_seed(5, 2));
61 ASSERT_EX(tools::make_pruning_seed(0, 2));
62}
ASSERT_EX
#define ASSERT_EX(x)
Definition pruning.cpp:35
Here is the call graph for this function:

◆ TEST() [6/9]

TEST ( pruning ,
parts  )

Definition at line 37 of file pruning.cpp.

38{
39 ASSERT_EQ(tools::get_pruning_stripe(tools::make_pruning_seed(3, 2)), 3);
40 ASSERT_EQ(tools::get_pruning_stripe(tools::make_pruning_seed(1, 2)), 1);
41 ASSERT_EQ(tools::get_pruning_stripe(tools::make_pruning_seed(7, 7)), 7);
42
43 ASSERT_EQ(tools::get_pruning_log_stripes(tools::make_pruning_seed(1, 2)), 2);
44 ASSERT_EQ(tools::get_pruning_log_stripes(tools::make_pruning_seed(1, 0)), 0);
45 ASSERT_EQ(tools::get_pruning_log_stripes(tools::make_pruning_seed(1, 7)), 7);
46 ASSERT_EQ(tools::get_pruning_log_stripes(tools::make_pruning_seed(7, 7)), 7);
47
48 for (uint32_t log_stripes = 1; log_stripes <= tools::PRUNING_SEED_LOG_STRIPES_MASK; ++log_stripes)
49 {
50 for (uint32_t stripe = 1; stripe <= (1 << log_stripes); ++stripe)
51 {
52 ASSERT_EQ(tools::get_pruning_log_stripes(tools::make_pruning_seed(stripe, log_stripes)), log_stripes);
53 ASSERT_EQ(tools::get_pruning_stripe(tools::make_pruning_seed(stripe, log_stripes)), stripe);
54 }
55 }
56}
Here is the call graph for this function:

◆ TEST() [7/9]

TEST ( pruning ,
seed  )

Definition at line 90 of file pruning.cpp.

91{
92 const uint64_t SS = CRYPTONOTE_PRUNING_STRIPE_SIZE;
93 const uint64_t NS = 1 << CRYPTONOTE_PRUNING_LOG_STRIPES;
94 const uint64_t TB = NS * SS;
95
96 for (uint64_t cycle = 0; cycle < 10; ++cycle)
97 {
98 const uint64_t O = TB * cycle;
99 ASSERT_EQ(tools::get_pruning_stripe(O + 0, 10000000, CRYPTONOTE_PRUNING_LOG_STRIPES), 1);
100 ASSERT_EQ(tools::get_pruning_stripe(O + 1, 10000000, CRYPTONOTE_PRUNING_LOG_STRIPES), 1);
101 ASSERT_EQ(tools::get_pruning_stripe(O + SS-1, 10000000, CRYPTONOTE_PRUNING_LOG_STRIPES), 1);
102 ASSERT_EQ(tools::get_pruning_stripe(O + SS, 10000000, CRYPTONOTE_PRUNING_LOG_STRIPES), 2);
103 ASSERT_EQ(tools::get_pruning_stripe(O + SS*2-1, 10000000, CRYPTONOTE_PRUNING_LOG_STRIPES), 2);
104 ASSERT_EQ(tools::get_pruning_stripe(O + SS*2, 10000000, CRYPTONOTE_PRUNING_LOG_STRIPES), 3);
105 ASSERT_EQ(tools::get_pruning_stripe(O + SS*NS-1, 10000000, CRYPTONOTE_PRUNING_LOG_STRIPES), NS);
106 ASSERT_EQ(tools::get_pruning_stripe(O + SS*NS, 10000000, CRYPTONOTE_PRUNING_LOG_STRIPES), 1);
107 }
108}
Here is the call graph for this function:

◆ TEST() [8/9]

TEST ( pruning ,
stripe_size  )

Definition at line 127 of file pruning.cpp.

128{
129 static constexpr uint64_t H = CRYPTONOTE_PRUNING_TIP_BLOCKS + CRYPTONOTE_PRUNING_STRIPE_SIZE * (1 << CRYPTONOTE_PRUNING_LOG_STRIPES) + 1000;
130 static_assert(H >= CRYPTONOTE_PRUNING_TIP_BLOCKS + CRYPTONOTE_PRUNING_STRIPE_SIZE * (1 << CRYPTONOTE_PRUNING_LOG_STRIPES), "H must be >= that stuff in front");
131 for (uint32_t pruning_stripe = 1; pruning_stripe <= (1 << CRYPTONOTE_PRUNING_LOG_STRIPES); ++pruning_stripe)
132 {
133 uint32_t pruning_seed = tools::make_pruning_seed(pruning_stripe, CRYPTONOTE_PRUNING_LOG_STRIPES);
134 unsigned int current_run = 0, best_run = 0;
135 for (uint64_t h = 0; h < H - CRYPTONOTE_PRUNING_TIP_BLOCKS; ++h)
136 {
137 if (tools::has_unpruned_block(h, H, pruning_seed))
138 {
139 ++current_run;
140 }
141 else if (current_run)
142 {
143 ASSERT_EQ(current_run, CRYPTONOTE_PRUNING_STRIPE_SIZE);
144 best_run = std::max(best_run, current_run);
145 current_run = 0;
146 }
147 }
148 ASSERT_EQ(best_run, CRYPTONOTE_PRUNING_STRIPE_SIZE);
149 }
150}
Here is the call graph for this function:

◆ TEST() [9/9]

TEST ( pruning ,
tip  )

Definition at line 77 of file pruning.cpp.

78{
79 static constexpr uint64_t H = CRYPTONOTE_PRUNING_TIP_BLOCKS + 1000;
80 static_assert(H >= CRYPTONOTE_PRUNING_TIP_BLOCKS, "H must be >= CRYPTONOTE_PRUNING_TIP_BLOCKS");
81 for (uint64_t h = H - CRYPTONOTE_PRUNING_TIP_BLOCKS; h < H; ++h)
82 {
83 uint32_t pruning_seed = tools::get_pruning_seed(h, H, CRYPTONOTE_PRUNING_LOG_STRIPES);
84 ASSERT_EQ(pruning_seed, 0);
85 for (pruning_seed = 0; pruning_seed <= (1 << CRYPTONOTE_PRUNING_LOG_STRIPES); ++pruning_seed)
86 ASSERT_TRUE(tools::has_unpruned_block(h, H, pruning_seed));
87 }
88}
Here is the call graph for this function: