1 //===-- sanitizer_vector_test.cpp -----------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file is a part of *Sanitizer runtime.
10 //
11 //===----------------------------------------------------------------------===//
12 #include "sanitizer_common/sanitizer_ring_buffer.h"
13 #include "gtest/gtest.h"
14 
15 namespace __sanitizer {
16 
17 struct LargeStruct {
18   int64_t v;
19   int64_t extra[3];
20 
21   explicit LargeStruct(int64_t v) : v(v) {}
22   operator int64_t() { return v; }
23 };
24 
25 struct Struct10Bytes {
26   short t[3];
27 };
28 
29 TEST(RingBuffer, Construct) {
30   RingBuffer<int64_t> *RBlong = RingBuffer<int64_t>::New(20);
31   EXPECT_EQ(RBlong->size(), 20U);
32   RBlong->Delete();
33 }
34 
35 template <class T> void TestRB() {
36   RingBuffer<T> *RB;
37   const size_t Sizes[] = {1, 2, 3, 5, 8, 16, 20, 40, 10000};
38   for (size_t Size : Sizes) {
39     RB = RingBuffer<T>::New(Size);
40     EXPECT_EQ(RB->size(), Size);
41     RB->Delete();
42   }
43 
44   RB = RingBuffer<T>::New(4);
45   EXPECT_EQ(RB->size(), 4U);
46 #define EXPECT_RING_BUFFER(a0, a1, a2, a3) \
47   EXPECT_EQ((int64_t)(*RB)[0], (int64_t)a0);                 \
48   EXPECT_EQ((int64_t)(*RB)[1], (int64_t)a1);                 \
49   EXPECT_EQ((int64_t)(*RB)[2], (int64_t)a2);                 \
50   EXPECT_EQ((int64_t)(*RB)[3], (int64_t)a3);
51 
52   RB->push(T(1)); EXPECT_RING_BUFFER(1, 0, 0, 0);
53   RB->push(T(2)); EXPECT_RING_BUFFER(2, 1, 0, 0);
54   RB->push(T(3)); EXPECT_RING_BUFFER(3, 2, 1, 0);
55   RB->push(T(4)); EXPECT_RING_BUFFER(4, 3, 2, 1);
56   RB->push(T(5)); EXPECT_RING_BUFFER(5, 4, 3, 2);
57   RB->push(T(6)); EXPECT_RING_BUFFER(6, 5, 4, 3);
58   RB->push(T(7)); EXPECT_RING_BUFFER(7, 6, 5, 4);
59   RB->push(T(8)); EXPECT_RING_BUFFER(8, 7, 6, 5);
60   RB->push(T(9)); EXPECT_RING_BUFFER(9, 8, 7, 6);
61   RB->push(T(10)); EXPECT_RING_BUFFER(10, 9, 8, 7);
62   RB->push(T(11)); EXPECT_RING_BUFFER(11, 10, 9, 8);
63   RB->push(T(12)); EXPECT_RING_BUFFER(12, 11, 10, 9);
64 
65 #undef EXPECT_RING_BUFFER
66 }
67 
68 #if SANITIZER_WORDSIZE == 64
69 TEST(RingBuffer, int64) {
70   TestRB<int64_t>();
71 }
72 
73 TEST(RingBuffer, LargeStruct) {
74   TestRB<LargeStruct>();
75 }
76 
77 template<typename T>
78 CompactRingBuffer<T> *AllocCompactRingBuffer(size_t count) {
79   size_t sz = sizeof(T) * count;
80   EXPECT_EQ(0ULL, sz % 4096);
81   void *p = MmapAlignedOrDieOnFatalError(sz, sz * 2, "CompactRingBuffer");
82   return new CompactRingBuffer<T>(p, sz);
83 }
84 
85 TEST(CompactRingBuffer, int64) {
86   const size_t page_sizes[] = {1, 2, 4, 128};
87 
88   for (size_t pages : page_sizes) {
89     size_t count = 4096 * pages / sizeof(int64_t);
90     auto R = AllocCompactRingBuffer<int64_t>(count);
91     int64_t top = count * 3 + 13;
92     for (int64_t i = 0; i < top; ++i) R->push(i);
93     for (int64_t i = 0; i < (int64_t)count; ++i)
94       EXPECT_EQ(top - i - 1, (*R)[i]);
95   }
96 }
97 #endif
98 }  // namespace __sanitizer
99