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( |
| 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 // Ensure that a single value accumulates correctly. |
| 303 EXPECT_FALSE(GetSamplesCounts(samples)); |
| 304 samples.Accumulate(3, 200); |
| 305 EXPECT_EQ(200, samples.GetCount(3)); |
| 306 EXPECT_FALSE(GetSamplesCounts(samples)); |
| 307 samples.Accumulate(3, 500); |
| 308 EXPECT_EQ(700, samples.GetCount(3)); |
| 309 EXPECT_FALSE(GetSamplesCounts(samples)); |
| 310 samples.Accumulate(3, -100); |
| 311 EXPECT_EQ(600, samples.GetCount(3)); |
| 312 EXPECT_FALSE(GetSamplesCounts(samples)); |
| 313 EXPECT_EQ(3 * 600, samples.sum()); |
| 314 EXPECT_EQ(600, samples.TotalCount()); |
| 315 EXPECT_EQ(600, samples.redundant_count()); |
| 316 |
| 317 // Ensure that the iterator returns only one value. |
| 318 HistogramBase::Sample min; |
| 319 HistogramBase::Sample max; |
| 320 HistogramBase::Count count; |
| 321 std::unique_ptr<SampleCountIterator> it = samples.Iterator(); |
| 322 ASSERT_FALSE(it->Done()); |
| 323 it->Get(&min, &max, &count); |
| 324 EXPECT_EQ(1, min); |
| 325 EXPECT_EQ(5, max); |
| 326 EXPECT_EQ(600, count); |
| 327 it->Next(); |
| 328 EXPECT_TRUE(it->Done()); |
| 329 |
| 330 // Ensure that it can be merged to another single-sample vector. |
| 331 SampleVector samples_copy(&ranges); |
| 332 samples_copy.Add(samples); |
| 333 EXPECT_FALSE(GetSamplesCounts(samples_copy)); |
| 334 EXPECT_EQ(3 * 600, samples_copy.sum()); |
| 335 EXPECT_EQ(600, samples_copy.TotalCount()); |
| 336 EXPECT_EQ(600, samples_copy.redundant_count()); |
| 337 |
| 338 // A different value should cause creation of the counts array. |
| 339 samples.Accumulate(8, 100); |
| 340 EXPECT_TRUE(GetSamplesCounts(samples)); |
| 341 EXPECT_EQ(600, samples.GetCount(3)); |
| 342 EXPECT_EQ(100, samples.GetCount(8)); |
| 343 EXPECT_EQ(3 * 600 + 8 * 100, samples.sum()); |
| 344 EXPECT_EQ(600 + 100, samples.TotalCount()); |
| 345 EXPECT_EQ(600 + 100, samples.redundant_count()); |
| 346 |
| 347 // The iterator should now return both values. |
| 348 it = samples.Iterator(); |
| 349 ASSERT_FALSE(it->Done()); |
| 350 it->Get(&min, &max, &count); |
| 351 EXPECT_EQ(1, min); |
| 352 EXPECT_EQ(5, max); |
| 353 EXPECT_EQ(600, count); |
| 354 it->Next(); |
| 355 ASSERT_FALSE(it->Done()); |
| 356 it->Get(&min, &max, &count); |
| 357 EXPECT_EQ(5, min); |
| 358 EXPECT_EQ(10, max); |
| 359 EXPECT_EQ(100, count); |
| 360 it->Next(); |
| 361 EXPECT_TRUE(it->Done()); |
| 362 |
| 363 // Ensure that it can merged to a single-sample vector. |
| 364 samples_copy.Add(samples); |
| 365 EXPECT_TRUE(GetSamplesCounts(samples_copy)); |
| 366 EXPECT_EQ(3 * 1200 + 8 * 100, samples_copy.sum()); |
| 367 EXPECT_EQ(1200 + 100, samples_copy.TotalCount()); |
| 368 EXPECT_EQ(1200 + 100, samples_copy.redundant_count()); |
| 369 } |
| 370 |
| 371 TEST_F(SampleVectorTest, PersistentSampleVectorTest) { |
| 372 LocalPersistentMemoryAllocator allocator(64 << 10, 0, ""); |
| 373 std::atomic<PersistentMemoryAllocator::Reference> samples_ref; |
| 374 samples_ref.store(0, std::memory_order_relaxed); |
| 375 HistogramSamples::Metadata samples_meta; |
| 376 memset(&samples_meta, 0, sizeof(samples_meta)); |
| 377 |
| 378 // Custom buckets: [1, 5) [5, 10) |
| 379 BucketRanges ranges(3); |
| 380 ranges.set_range(0, 1); |
| 381 ranges.set_range(1, 5); |
| 382 ranges.set_range(2, 10); |
| 383 |
| 384 // Persistent allocation. |
| 385 const size_t counts_bytes = |
| 386 sizeof(HistogramBase::AtomicCount) * ranges.bucket_count(); |
| 387 const DelayedPersistentAllocation allocation(&allocator, &samples_ref, 1, |
| 388 counts_bytes); |
| 389 |
| 390 PersistentSampleVector samples1(0, &ranges, &samples_meta, allocation); |
| 391 EXPECT_FALSE(GetSamplesCounts(samples1)); |
| 392 samples1.Accumulate(3, 200); |
| 393 EXPECT_EQ(200, samples1.GetCount(3)); |
| 394 EXPECT_FALSE(GetSamplesCounts(samples1)); |
| 395 EXPECT_EQ(0, samples1.GetCount(8)); |
| 396 EXPECT_FALSE(GetSamplesCounts(samples1)); |
| 397 |
| 398 PersistentSampleVector samples2(0, &ranges, &samples_meta, allocation); |
| 399 EXPECT_EQ(200, samples2.GetCount(3)); |
| 400 EXPECT_FALSE(GetSamplesCounts(samples2)); |
| 401 |
| 402 HistogramBase::Sample min; |
| 403 HistogramBase::Sample max; |
| 404 HistogramBase::Count count; |
| 405 std::unique_ptr<SampleCountIterator> it = samples2.Iterator(); |
| 406 ASSERT_FALSE(it->Done()); |
| 407 it->Get(&min, &max, &count); |
| 408 EXPECT_EQ(1, min); |
| 409 EXPECT_EQ(5, max); |
| 410 EXPECT_EQ(200, count); |
| 411 it->Next(); |
| 412 EXPECT_TRUE(it->Done()); |
| 413 |
| 414 samples1.Accumulate(8, 100); |
| 415 EXPECT_TRUE(GetSamplesCounts(samples1)); |
| 416 |
| 417 EXPECT_FALSE(GetSamplesCounts(samples2)); |
| 418 EXPECT_EQ(200, samples2.GetCount(3)); |
| 419 EXPECT_EQ(100, samples2.GetCount(8)); |
| 420 EXPECT_TRUE(GetSamplesCounts(samples2)); |
| 421 EXPECT_EQ(3 * 200 + 8 * 100, samples2.sum()); |
| 422 EXPECT_EQ(300, samples2.TotalCount()); |
| 423 EXPECT_EQ(300, samples2.redundant_count()); |
| 424 |
| 425 it = samples2.Iterator(); |
| 426 ASSERT_FALSE(it->Done()); |
| 427 it->Get(&min, &max, &count); |
| 428 EXPECT_EQ(1, min); |
| 429 EXPECT_EQ(5, max); |
| 430 EXPECT_EQ(200, count); |
| 431 it->Next(); |
| 432 ASSERT_FALSE(it->Done()); |
| 433 it->Get(&min, &max, &count); |
| 434 EXPECT_EQ(5, min); |
| 435 EXPECT_EQ(10, max); |
| 436 EXPECT_EQ(100, count); |
| 437 it->Next(); |
| 438 EXPECT_TRUE(it->Done()); |
| 439 |
| 440 PersistentSampleVector samples3(0, &ranges, &samples_meta, allocation); |
| 441 EXPECT_TRUE(GetSamplesCounts(samples2)); |
| 442 EXPECT_EQ(200, samples3.GetCount(3)); |
| 443 EXPECT_EQ(100, samples3.GetCount(8)); |
| 444 EXPECT_EQ(3 * 200 + 8 * 100, samples3.sum()); |
| 445 EXPECT_EQ(300, samples3.TotalCount()); |
| 446 EXPECT_EQ(300, samples3.redundant_count()); |
| 447 |
| 448 it = samples3.Iterator(); |
| 449 ASSERT_FALSE(it->Done()); |
| 450 it->Get(&min, &max, &count); |
| 451 EXPECT_EQ(1, min); |
| 452 EXPECT_EQ(5, max); |
| 453 EXPECT_EQ(200, count); |
| 454 it->Next(); |
| 455 ASSERT_FALSE(it->Done()); |
| 456 it->Get(&min, &max, &count); |
| 457 EXPECT_EQ(5, min); |
| 458 EXPECT_EQ(10, max); |
| 459 EXPECT_EQ(100, count); |
| 460 it->Next(); |
| 461 EXPECT_TRUE(it->Done()); |
| 462 } |
| 463 |
| 464 TEST_F(SampleVectorTest, PersistentSampleVectorTestWithOutsideAlloc) { |
| 465 LocalPersistentMemoryAllocator allocator(64 << 10, 0, ""); |
| 466 std::atomic<PersistentMemoryAllocator::Reference> samples_ref; |
| 467 samples_ref.store(0, std::memory_order_relaxed); |
| 468 HistogramSamples::Metadata samples_meta; |
| 469 memset(&samples_meta, 0, sizeof(samples_meta)); |
| 470 |
| 471 // Custom buckets: [1, 5) [5, 10) |
| 472 BucketRanges ranges(3); |
| 473 ranges.set_range(0, 1); |
| 474 ranges.set_range(1, 5); |
| 475 ranges.set_range(2, 10); |
| 476 |
| 477 // Persistent allocation. |
| 478 const size_t counts_bytes = |
| 479 sizeof(HistogramBase::AtomicCount) * ranges.bucket_count(); |
| 480 const DelayedPersistentAllocation allocation(&allocator, &samples_ref, 1, |
| 481 counts_bytes); |
| 482 |
| 483 PersistentSampleVector samples(0, &ranges, &samples_meta, allocation); |
| 484 EXPECT_FALSE(GetSamplesCounts(samples)); |
| 485 samples.Accumulate(3, 200); |
| 486 EXPECT_EQ(200, samples.GetCount(3)); |
| 487 EXPECT_FALSE(GetSamplesCounts(samples)); |
| 488 |
| 489 // Because the delayed allocation can be shared with other objects (the |
| 490 // |offset| parameter allows concatinating multiple data blocks into the |
| 491 // same allocation), it's possible that the allocation gets realized from |
| 492 // the outside even though the data block being accessed is all zero. |
| 493 allocation.Get(); |
| 494 EXPECT_EQ(200, samples.GetCount(3)); |
| 495 EXPECT_FALSE(GetSamplesCounts(samples)); |
| 496 |
| 497 HistogramBase::Sample min; |
| 498 HistogramBase::Sample max; |
| 499 HistogramBase::Count count; |
| 500 std::unique_ptr<SampleCountIterator> it = samples.Iterator(); |
| 501 ASSERT_FALSE(it->Done()); |
| 502 it->Get(&min, &max, &count); |
| 503 EXPECT_EQ(1, min); |
| 504 EXPECT_EQ(5, max); |
| 505 EXPECT_EQ(200, count); |
| 506 it->Next(); |
| 507 EXPECT_TRUE(it->Done()); |
| 508 |
| 509 samples.Accumulate(3, 100); |
| 510 EXPECT_EQ(300, samples.GetCount(3)); |
| 511 |
| 512 it = samples.Iterator(); |
| 513 ASSERT_FALSE(it->Done()); |
| 514 it->Get(&min, &max, &count); |
| 515 EXPECT_EQ(1, min); |
| 516 EXPECT_EQ(5, max); |
| 517 EXPECT_EQ(300, count); |
| 518 it->Next(); |
| 519 EXPECT_TRUE(it->Done()); |
| 520 |
| 521 samples.Accumulate(8, 100); |
| 522 EXPECT_TRUE(GetSamplesCounts(samples)); |
| 523 EXPECT_EQ(300, samples.GetCount(3)); |
| 524 EXPECT_EQ(100, samples.GetCount(8)); |
| 525 } |
| 526 |
286 } // namespace base | 527 } // namespace base |
OLD | NEW |