lib/sanitizer_common/tests/sanitizer_ring_buffer_test.cc

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