OLD | NEW |
---|---|
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "base/metrics/sample_vector.h" | 5 #include "base/metrics/sample_vector.h" |
6 | 6 |
7 #include <limits.h> | 7 #include <limits.h> |
8 #include <stddef.h> | 8 #include <stddef.h> |
9 | 9 |
10 #include <atomic> | |
10 #include <memory> | 11 #include <memory> |
11 #include <vector> | 12 #include <vector> |
12 | 13 |
13 #include "base/metrics/bucket_ranges.h" | 14 #include "base/metrics/bucket_ranges.h" |
14 #include "base/metrics/histogram.h" | 15 #include "base/metrics/histogram.h" |
16 #include "base/metrics/persistent_memory_allocator.h" | |
15 #include "base/test/gtest_util.h" | 17 #include "base/test/gtest_util.h" |
16 #include "testing/gtest/include/gtest/gtest.h" | 18 #include "testing/gtest/include/gtest/gtest.h" |
17 | 19 |
18 namespace base { | 20 namespace base { |
19 namespace { | |
20 | 21 |
21 TEST(SampleVectorTest, AccumulateTest) { | 22 class SampleVectorTest : public testing::Test { |
23 public: | |
24 const HistogramBase::AtomicCount* GetSamplesCounts( | |
Alexei Svitkine (slow)
2017/04/12 17:38:07
Nit: Seems like this can just be a free-standing f
bcwhite
2017/04/13 00:06:01
It's accessing a protected method off of SampleVec
Alexei Svitkine (slow)
2017/04/18 20:52:19
Ah, I missed that it was using a protected method.
bcwhite
2017/04/19 18:13:01
Done.
| |
25 const SampleVectorBase& samples) { | |
26 return samples.counts(); | |
27 } | |
28 }; | |
29 | |
30 TEST_F(SampleVectorTest, AccumulateTest) { | |
22 // Custom buckets: [1, 5) [5, 10) | 31 // Custom buckets: [1, 5) [5, 10) |
23 BucketRanges ranges(3); | 32 BucketRanges ranges(3); |
24 ranges.set_range(0, 1); | 33 ranges.set_range(0, 1); |
25 ranges.set_range(1, 5); | 34 ranges.set_range(1, 5); |
26 ranges.set_range(2, 10); | 35 ranges.set_range(2, 10); |
27 SampleVector samples(1, &ranges); | 36 SampleVector samples(1, &ranges); |
28 | 37 |
29 samples.Accumulate(1, 200); | 38 samples.Accumulate(1, 200); |
30 samples.Accumulate(2, -300); | 39 samples.Accumulate(2, -300); |
31 EXPECT_EQ(-100, samples.GetCountAtIndex(0)); | 40 EXPECT_EQ(-100, samples.GetCountAtIndex(0)); |
32 | 41 |
33 samples.Accumulate(5, 200); | 42 samples.Accumulate(5, 200); |
34 EXPECT_EQ(200, samples.GetCountAtIndex(1)); | 43 EXPECT_EQ(200, samples.GetCountAtIndex(1)); |
35 | 44 |
36 EXPECT_EQ(600, samples.sum()); | 45 EXPECT_EQ(600, samples.sum()); |
37 EXPECT_EQ(100, samples.redundant_count()); | 46 EXPECT_EQ(100, samples.redundant_count()); |
38 EXPECT_EQ(samples.TotalCount(), samples.redundant_count()); | 47 EXPECT_EQ(samples.TotalCount(), samples.redundant_count()); |
39 | 48 |
40 samples.Accumulate(5, -100); | 49 samples.Accumulate(5, -100); |
41 EXPECT_EQ(100, samples.GetCountAtIndex(1)); | 50 EXPECT_EQ(100, samples.GetCountAtIndex(1)); |
42 | 51 |
43 EXPECT_EQ(100, samples.sum()); | 52 EXPECT_EQ(100, samples.sum()); |
44 EXPECT_EQ(0, samples.redundant_count()); | 53 EXPECT_EQ(0, samples.redundant_count()); |
45 EXPECT_EQ(samples.TotalCount(), samples.redundant_count()); | 54 EXPECT_EQ(samples.TotalCount(), samples.redundant_count()); |
46 } | 55 } |
47 | 56 |
48 TEST(SampleVectorTest, Accumulate_LargeValuesDontOverflow) { | 57 TEST_F(SampleVectorTest, Accumulate_LargeValuesDontOverflow) { |
49 // Custom buckets: [1, 250000000) [250000000, 500000000) | 58 // Custom buckets: [1, 250000000) [250000000, 500000000) |
50 BucketRanges ranges(3); | 59 BucketRanges ranges(3); |
51 ranges.set_range(0, 1); | 60 ranges.set_range(0, 1); |
52 ranges.set_range(1, 250000000); | 61 ranges.set_range(1, 250000000); |
53 ranges.set_range(2, 500000000); | 62 ranges.set_range(2, 500000000); |
54 SampleVector samples(1, &ranges); | 63 SampleVector samples(1, &ranges); |
55 | 64 |
56 samples.Accumulate(240000000, 200); | 65 samples.Accumulate(240000000, 200); |
57 samples.Accumulate(249999999, -300); | 66 samples.Accumulate(249999999, -300); |
58 EXPECT_EQ(-100, samples.GetCountAtIndex(0)); | 67 EXPECT_EQ(-100, samples.GetCountAtIndex(0)); |
59 | 68 |
60 samples.Accumulate(250000000, 200); | 69 samples.Accumulate(250000000, 200); |
61 EXPECT_EQ(200, samples.GetCountAtIndex(1)); | 70 EXPECT_EQ(200, samples.GetCountAtIndex(1)); |
62 | 71 |
63 EXPECT_EQ(23000000300LL, samples.sum()); | 72 EXPECT_EQ(23000000300LL, samples.sum()); |
64 EXPECT_EQ(100, samples.redundant_count()); | 73 EXPECT_EQ(100, samples.redundant_count()); |
65 EXPECT_EQ(samples.TotalCount(), samples.redundant_count()); | 74 EXPECT_EQ(samples.TotalCount(), samples.redundant_count()); |
66 | 75 |
67 samples.Accumulate(250000000, -100); | 76 samples.Accumulate(250000000, -100); |
68 EXPECT_EQ(100, samples.GetCountAtIndex(1)); | 77 EXPECT_EQ(100, samples.GetCountAtIndex(1)); |
69 | 78 |
70 EXPECT_EQ(-1999999700LL, samples.sum()); | 79 EXPECT_EQ(-1999999700LL, samples.sum()); |
71 EXPECT_EQ(0, samples.redundant_count()); | 80 EXPECT_EQ(0, samples.redundant_count()); |
72 EXPECT_EQ(samples.TotalCount(), samples.redundant_count()); | 81 EXPECT_EQ(samples.TotalCount(), samples.redundant_count()); |
73 } | 82 } |
74 | 83 |
75 TEST(SampleVectorTest, AddSubtractTest) { | 84 TEST_F(SampleVectorTest, AddSubtractTest) { |
76 // Custom buckets: [0, 1) [1, 2) [2, 3) [3, INT_MAX) | 85 // Custom buckets: [0, 1) [1, 2) [2, 3) [3, INT_MAX) |
77 BucketRanges ranges(5); | 86 BucketRanges ranges(5); |
78 ranges.set_range(0, 0); | 87 ranges.set_range(0, 0); |
79 ranges.set_range(1, 1); | 88 ranges.set_range(1, 1); |
80 ranges.set_range(2, 2); | 89 ranges.set_range(2, 2); |
81 ranges.set_range(3, 3); | 90 ranges.set_range(3, 3); |
82 ranges.set_range(4, INT_MAX); | 91 ranges.set_range(4, INT_MAX); |
83 | 92 |
84 SampleVector samples1(1, &ranges); | 93 SampleVector samples1(1, &ranges); |
85 samples1.Accumulate(0, 100); | 94 samples1.Accumulate(0, 100); |
(...skipping 23 matching lines...) Expand all Loading... | |
109 samples1.Subtract(samples2); | 118 samples1.Subtract(samples2); |
110 EXPECT_EQ(100, samples1.GetCountAtIndex(0)); | 119 EXPECT_EQ(100, samples1.GetCountAtIndex(0)); |
111 EXPECT_EQ(0, samples1.GetCountAtIndex(1)); | 120 EXPECT_EQ(0, samples1.GetCountAtIndex(1)); |
112 EXPECT_EQ(100, samples1.GetCountAtIndex(2)); | 121 EXPECT_EQ(100, samples1.GetCountAtIndex(2)); |
113 EXPECT_EQ(100, samples1.GetCountAtIndex(3)); | 122 EXPECT_EQ(100, samples1.GetCountAtIndex(3)); |
114 EXPECT_EQ(600, samples1.sum()); | 123 EXPECT_EQ(600, samples1.sum()); |
115 EXPECT_EQ(300, samples1.TotalCount()); | 124 EXPECT_EQ(300, samples1.TotalCount()); |
116 EXPECT_EQ(samples1.redundant_count(), samples1.TotalCount()); | 125 EXPECT_EQ(samples1.redundant_count(), samples1.TotalCount()); |
117 } | 126 } |
118 | 127 |
119 TEST(SampleVectorDeathTest, BucketIndexTest) { | 128 TEST_F(SampleVectorTest, BucketIndexDeathTest) { |
120 // 8 buckets with exponential layout: | 129 // 8 buckets with exponential layout: |
121 // [0, 1) [1, 2) [2, 4) [4, 8) [8, 16) [16, 32) [32, 64) [64, INT_MAX) | 130 // [0, 1) [1, 2) [2, 4) [4, 8) [8, 16) [16, 32) [32, 64) [64, INT_MAX) |
122 BucketRanges ranges(9); | 131 BucketRanges ranges(9); |
123 Histogram::InitializeBucketRanges(1, 64, &ranges); | 132 Histogram::InitializeBucketRanges(1, 64, &ranges); |
124 SampleVector samples(1, &ranges); | 133 SampleVector samples(1, &ranges); |
125 | 134 |
126 // Normal case | 135 // Normal case |
127 samples.Accumulate(0, 1); | 136 samples.Accumulate(0, 1); |
128 samples.Accumulate(3, 2); | 137 samples.Accumulate(3, 2); |
129 samples.Accumulate(64, 3); | 138 samples.Accumulate(64, 3); |
(...skipping 21 matching lines...) Expand all Loading... | |
151 samples2.Accumulate(5, 2); | 160 samples2.Accumulate(5, 2); |
152 samples2.Accumulate(9, 2); | 161 samples2.Accumulate(9, 2); |
153 EXPECT_EQ(2, samples2.GetCount(1)); | 162 EXPECT_EQ(2, samples2.GetCount(1)); |
154 EXPECT_EQ(4, samples2.GetCount(5)); | 163 EXPECT_EQ(4, samples2.GetCount(5)); |
155 | 164 |
156 // Extreme case. | 165 // Extreme case. |
157 EXPECT_DCHECK_DEATH(samples2.Accumulate(0, 100)); | 166 EXPECT_DCHECK_DEATH(samples2.Accumulate(0, 100)); |
158 EXPECT_DCHECK_DEATH(samples2.Accumulate(10, 100)); | 167 EXPECT_DCHECK_DEATH(samples2.Accumulate(10, 100)); |
159 } | 168 } |
160 | 169 |
161 TEST(SampleVectorDeathTest, AddSubtractBucketNotMatchTest) { | 170 TEST_F(SampleVectorTest, AddSubtractBucketNotMatchDeathTest) { |
162 // Custom buckets 1: [1, 3) [3, 5) | 171 // Custom buckets 1: [1, 3) [3, 5) |
163 BucketRanges ranges1(3); | 172 BucketRanges ranges1(3); |
164 ranges1.set_range(0, 1); | 173 ranges1.set_range(0, 1); |
165 ranges1.set_range(1, 3); | 174 ranges1.set_range(1, 3); |
166 ranges1.set_range(2, 5); | 175 ranges1.set_range(2, 5); |
167 SampleVector samples1(1, &ranges1); | 176 SampleVector samples1(1, &ranges1); |
168 | 177 |
169 // Custom buckets 2: [0, 1) [1, 3) [3, 6) [6, 7) | 178 // Custom buckets 2: [0, 1) [1, 3) [3, 6) [6, 7) |
170 BucketRanges ranges2(5); | 179 BucketRanges ranges2(5); |
171 ranges2.set_range(0, 0); | 180 ranges2.set_range(0, 0); |
(...skipping 18 matching lines...) Expand all Loading... | |
190 EXPECT_DCHECK_DEATH(samples1.Add(samples2)); | 199 EXPECT_DCHECK_DEATH(samples1.Add(samples2)); |
191 EXPECT_DCHECK_DEATH(samples1.Subtract(samples2)); | 200 EXPECT_DCHECK_DEATH(samples1.Subtract(samples2)); |
192 | 201 |
193 // Bucket not match: [3, 5) VS [3, 6) | 202 // Bucket not match: [3, 5) VS [3, 6) |
194 samples2.Accumulate(6, -100); | 203 samples2.Accumulate(6, -100); |
195 samples2.Accumulate(3, 100); | 204 samples2.Accumulate(3, 100); |
196 EXPECT_DCHECK_DEATH(samples1.Add(samples2)); | 205 EXPECT_DCHECK_DEATH(samples1.Add(samples2)); |
197 EXPECT_DCHECK_DEATH(samples1.Subtract(samples2)); | 206 EXPECT_DCHECK_DEATH(samples1.Subtract(samples2)); |
198 } | 207 } |
199 | 208 |
200 TEST(SampleVectorIteratorTest, IterateTest) { | 209 TEST_F(SampleVectorTest, IterateTest) { |
201 BucketRanges ranges(5); | 210 BucketRanges ranges(5); |
202 ranges.set_range(0, 0); | 211 ranges.set_range(0, 0); |
203 ranges.set_range(1, 1); | 212 ranges.set_range(1, 1); |
204 ranges.set_range(2, 2); | 213 ranges.set_range(2, 2); |
205 ranges.set_range(3, 3); | 214 ranges.set_range(3, 3); |
206 ranges.set_range(4, 4); | 215 ranges.set_range(4, 4); |
207 | 216 |
208 std::vector<HistogramBase::Count> counts(3); | 217 std::vector<HistogramBase::Count> counts(3); |
209 counts[0] = 1; | 218 counts[0] = 1; |
210 counts[1] = 0; // Iterator will bypass this empty bucket. | 219 counts[1] = 0; // Iterator will bypass this empty bucket. |
(...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
250 EXPECT_EQ(i + 1, max); | 259 EXPECT_EQ(i + 1, max); |
251 EXPECT_EQ(i, count); | 260 EXPECT_EQ(i, count); |
252 | 261 |
253 size_t index; | 262 size_t index; |
254 EXPECT_TRUE(it2->GetBucketIndex(&index)); | 263 EXPECT_TRUE(it2->GetBucketIndex(&index)); |
255 EXPECT_EQ(static_cast<size_t>(i), index); | 264 EXPECT_EQ(static_cast<size_t>(i), index); |
256 } | 265 } |
257 EXPECT_EQ(4, i); | 266 EXPECT_EQ(4, i); |
258 } | 267 } |
259 | 268 |
260 TEST(SampleVectorIteratorDeathTest, IterateDoneTest) { | 269 TEST_F(SampleVectorTest, IterateDoneDeathTest) { |
261 BucketRanges ranges(5); | 270 BucketRanges ranges(5); |
262 ranges.set_range(0, 0); | 271 ranges.set_range(0, 0); |
263 ranges.set_range(1, 1); | 272 ranges.set_range(1, 1); |
264 ranges.set_range(2, 2); | 273 ranges.set_range(2, 2); |
265 ranges.set_range(3, 3); | 274 ranges.set_range(3, 3); |
266 ranges.set_range(4, INT_MAX); | 275 ranges.set_range(4, INT_MAX); |
267 SampleVector samples(1, &ranges); | 276 SampleVector samples(1, &ranges); |
268 | 277 |
269 std::unique_ptr<SampleCountIterator> it = samples.Iterator(); | 278 std::unique_ptr<SampleCountIterator> it = samples.Iterator(); |
270 | 279 |
271 EXPECT_TRUE(it->Done()); | 280 EXPECT_TRUE(it->Done()); |
272 | 281 |
273 HistogramBase::Sample min; | 282 HistogramBase::Sample min; |
274 HistogramBase::Sample max; | 283 HistogramBase::Sample max; |
275 HistogramBase::Count count; | 284 HistogramBase::Count count; |
276 EXPECT_DCHECK_DEATH(it->Get(&min, &max, &count)); | 285 EXPECT_DCHECK_DEATH(it->Get(&min, &max, &count)); |
277 | 286 |
278 EXPECT_DCHECK_DEATH(it->Next()); | 287 EXPECT_DCHECK_DEATH(it->Next()); |
279 | 288 |
280 samples.Accumulate(2, 100); | 289 samples.Accumulate(2, 100); |
281 it = samples.Iterator(); | 290 it = samples.Iterator(); |
282 EXPECT_FALSE(it->Done()); | 291 EXPECT_FALSE(it->Done()); |
283 } | 292 } |
284 | 293 |
285 } // namespace | 294 TEST_F(SampleVectorTest, SingleSampleTest) { |
295 // Custom buckets: [1, 5) [5, 10) | |
296 BucketRanges ranges(3); | |
297 ranges.set_range(0, 1); | |
298 ranges.set_range(1, 5); | |
299 ranges.set_range(2, 10); | |
300 SampleVector samples(&ranges); | |
301 | |
302 EXPECT_FALSE(GetSamplesCounts(samples)); | |
303 samples.Accumulate(3, 200); | |
304 EXPECT_EQ(200, samples.GetCount(3)); | |
305 EXPECT_FALSE(GetSamplesCounts(samples)); | |
306 samples.Accumulate(3, 500); | |
307 EXPECT_EQ(700, samples.GetCount(3)); | |
308 EXPECT_FALSE(GetSamplesCounts(samples)); | |
309 samples.Accumulate(3, -100); | |
310 EXPECT_EQ(600, samples.GetCount(3)); | |
311 EXPECT_FALSE(GetSamplesCounts(samples)); | |
312 EXPECT_EQ(3 * 600, samples.sum()); | |
313 EXPECT_EQ(600, samples.TotalCount()); | |
314 EXPECT_EQ(600, samples.redundant_count()); | |
315 | |
316 HistogramBase::Sample min; | |
317 HistogramBase::Sample max; | |
318 HistogramBase::Count count; | |
319 std::unique_ptr<SampleCountIterator> it = samples.Iterator(); | |
320 ASSERT_FALSE(it->Done()); | |
321 it->Get(&min, &max, &count); | |
322 EXPECT_EQ(1, min); | |
323 EXPECT_EQ(5, max); | |
324 EXPECT_EQ(600, count); | |
325 it->Next(); | |
326 EXPECT_TRUE(it->Done()); | |
327 | |
328 samples.Accumulate(8, 100); | |
329 EXPECT_TRUE(GetSamplesCounts(samples)); | |
330 EXPECT_EQ(600, samples.GetCount(3)); | |
331 EXPECT_EQ(100, samples.GetCount(8)); | |
332 EXPECT_EQ(3 * 600 + 8 * 100, samples.sum()); | |
333 EXPECT_EQ(700, samples.TotalCount()); | |
334 EXPECT_EQ(700, samples.redundant_count()); | |
335 | |
336 it = samples.Iterator(); | |
337 ASSERT_FALSE(it->Done()); | |
338 it->Get(&min, &max, &count); | |
339 EXPECT_EQ(1, min); | |
340 EXPECT_EQ(5, max); | |
341 EXPECT_EQ(600, count); | |
342 it->Next(); | |
343 ASSERT_FALSE(it->Done()); | |
344 it->Get(&min, &max, &count); | |
345 EXPECT_EQ(5, min); | |
346 EXPECT_EQ(10, max); | |
347 EXPECT_EQ(100, count); | |
348 it->Next(); | |
349 EXPECT_TRUE(it->Done()); | |
350 } | |
351 | |
352 TEST_F(SampleVectorTest, PersistentSampleVectorTest) { | |
353 LocalPersistentMemoryAllocator allocator(64 << 10, 0, ""); | |
354 std::atomic<PersistentMemoryAllocator::Reference> samples_ref; | |
355 samples_ref.store(0, std::memory_order_relaxed); | |
356 HistogramSamples::Metadata samples_meta; | |
357 memset(&samples_meta, 0, sizeof(samples_meta)); | |
358 | |
359 // Custom buckets: [1, 5) [5, 10) | |
360 BucketRanges ranges(3); | |
361 ranges.set_range(0, 1); | |
362 ranges.set_range(1, 5); | |
363 ranges.set_range(2, 10); | |
364 | |
365 // Persistent allocation. | |
366 const size_t counts_bytes = | |
367 sizeof(HistogramBase::AtomicCount) * ranges.bucket_count(); | |
368 const DelayedPersistentAllocation allocation(&allocator, &samples_ref, 0, | |
369 counts_bytes); | |
370 | |
371 PersistentSampleVector samples1(0, &ranges, &samples_meta, allocation); | |
372 EXPECT_FALSE(GetSamplesCounts(samples1)); | |
373 samples1.Accumulate(3, 200); | |
374 EXPECT_EQ(200, samples1.GetCount(3)); | |
375 EXPECT_FALSE(GetSamplesCounts(samples1)); | |
376 EXPECT_EQ(0, samples1.GetCount(8)); | |
377 EXPECT_FALSE(GetSamplesCounts(samples1)); | |
378 | |
379 PersistentSampleVector samples2(0, &ranges, &samples_meta, allocation); | |
380 EXPECT_EQ(200, samples2.GetCount(3)); | |
381 EXPECT_FALSE(GetSamplesCounts(samples2)); | |
382 | |
383 HistogramBase::Sample min; | |
384 HistogramBase::Sample max; | |
385 HistogramBase::Count count; | |
386 std::unique_ptr<SampleCountIterator> it = samples2.Iterator(); | |
387 ASSERT_FALSE(it->Done()); | |
388 it->Get(&min, &max, &count); | |
389 EXPECT_EQ(1, min); | |
390 EXPECT_EQ(5, max); | |
391 EXPECT_EQ(200, count); | |
392 it->Next(); | |
393 EXPECT_TRUE(it->Done()); | |
394 | |
395 samples1.Accumulate(8, 100); | |
396 EXPECT_TRUE(GetSamplesCounts(samples1)); | |
397 | |
398 EXPECT_FALSE(GetSamplesCounts(samples2)); | |
399 EXPECT_EQ(200, samples2.GetCount(3)); | |
400 EXPECT_EQ(100, samples2.GetCount(8)); | |
401 EXPECT_TRUE(GetSamplesCounts(samples2)); | |
402 EXPECT_EQ(3 * 200 + 8 * 100, samples2.sum()); | |
403 EXPECT_EQ(300, samples2.TotalCount()); | |
404 EXPECT_EQ(300, samples2.redundant_count()); | |
405 | |
406 it = samples2.Iterator(); | |
407 ASSERT_FALSE(it->Done()); | |
408 it->Get(&min, &max, &count); | |
409 EXPECT_EQ(1, min); | |
410 EXPECT_EQ(5, max); | |
411 EXPECT_EQ(200, count); | |
412 it->Next(); | |
413 ASSERT_FALSE(it->Done()); | |
414 it->Get(&min, &max, &count); | |
415 EXPECT_EQ(5, min); | |
416 EXPECT_EQ(10, max); | |
417 EXPECT_EQ(100, count); | |
418 it->Next(); | |
419 EXPECT_TRUE(it->Done()); | |
420 | |
421 PersistentSampleVector samples3(0, &ranges, &samples_meta, allocation); | |
422 EXPECT_TRUE(GetSamplesCounts(samples2)); | |
423 EXPECT_EQ(200, samples3.GetCount(3)); | |
424 EXPECT_EQ(100, samples3.GetCount(8)); | |
425 EXPECT_EQ(3 * 200 + 8 * 100, samples3.sum()); | |
426 EXPECT_EQ(300, samples3.TotalCount()); | |
427 EXPECT_EQ(300, samples3.redundant_count()); | |
428 | |
429 it = samples3.Iterator(); | |
430 ASSERT_FALSE(it->Done()); | |
431 it->Get(&min, &max, &count); | |
432 EXPECT_EQ(1, min); | |
433 EXPECT_EQ(5, max); | |
434 EXPECT_EQ(200, count); | |
435 it->Next(); | |
436 ASSERT_FALSE(it->Done()); | |
437 it->Get(&min, &max, &count); | |
438 EXPECT_EQ(5, min); | |
439 EXPECT_EQ(10, max); | |
440 EXPECT_EQ(100, count); | |
441 it->Next(); | |
442 EXPECT_TRUE(it->Done()); | |
443 } | |
444 | |
445 TEST_F(SampleVectorTest, PersistentSampleVectorTestWithOutsideAlloc) { | |
446 LocalPersistentMemoryAllocator allocator(64 << 10, 0, ""); | |
447 std::atomic<PersistentMemoryAllocator::Reference> samples_ref; | |
448 samples_ref.store(0, std::memory_order_relaxed); | |
449 HistogramSamples::Metadata samples_meta; | |
450 memset(&samples_meta, 0, sizeof(samples_meta)); | |
451 | |
452 // Custom buckets: [1, 5) [5, 10) | |
453 BucketRanges ranges(3); | |
454 ranges.set_range(0, 1); | |
455 ranges.set_range(1, 5); | |
456 ranges.set_range(2, 10); | |
457 | |
458 // Persistent allocation. | |
459 const size_t counts_bytes = | |
460 sizeof(HistogramBase::AtomicCount) * ranges.bucket_count(); | |
461 const DelayedPersistentAllocation allocation(&allocator, &samples_ref, 0, | |
462 counts_bytes); | |
463 | |
464 PersistentSampleVector samples(0, &ranges, &samples_meta, allocation); | |
465 EXPECT_FALSE(GetSamplesCounts(samples)); | |
466 samples.Accumulate(3, 200); | |
467 EXPECT_EQ(200, samples.GetCount(3)); | |
468 EXPECT_FALSE(GetSamplesCounts(samples)); | |
469 | |
470 // Because the delayed allocation can be shared with other objects (the | |
471 // |offset| parameter allows concatinating multiple data blocks into the | |
472 // same allocation), it's possible that the allocation gets realized from | |
473 // the outside even though the data block being accessed is all zero. | |
474 allocation.Get(); | |
475 EXPECT_EQ(200, samples.GetCount(3)); | |
476 EXPECT_FALSE(GetSamplesCounts(samples)); | |
477 | |
478 HistogramBase::Sample min; | |
479 HistogramBase::Sample max; | |
480 HistogramBase::Count count; | |
481 std::unique_ptr<SampleCountIterator> it = samples.Iterator(); | |
482 ASSERT_FALSE(it->Done()); | |
483 it->Get(&min, &max, &count); | |
484 EXPECT_EQ(1, min); | |
485 EXPECT_EQ(5, max); | |
486 EXPECT_EQ(200, count); | |
487 it->Next(); | |
488 EXPECT_TRUE(it->Done()); | |
489 | |
490 samples.Accumulate(3, 100); | |
491 EXPECT_EQ(300, samples.GetCount(3)); | |
492 | |
493 it = samples.Iterator(); | |
494 ASSERT_FALSE(it->Done()); | |
495 it->Get(&min, &max, &count); | |
496 EXPECT_EQ(1, min); | |
497 EXPECT_EQ(5, max); | |
498 EXPECT_EQ(300, count); | |
499 it->Next(); | |
500 EXPECT_TRUE(it->Done()); | |
501 | |
502 samples.Accumulate(8, 100); | |
503 EXPECT_TRUE(GetSamplesCounts(samples)); | |
504 EXPECT_EQ(300, samples.GetCount(3)); | |
505 EXPECT_EQ(100, samples.GetCount(8)); | |
506 } | |
507 | |
286 } // namespace base | 508 } // namespace base |
OLD | NEW |