1 //===- llvm/unittest/Support/AllocatorTest.cpp - BumpPtrAllocator tests ---===// 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 #include "llvm/Support/Allocator.h" 11 #include "gtest/gtest.h" 12 #include <cstdlib> 13 14 using namespace llvm; 15 16 namespace { 17 18 TEST(AllocatorTest, Basics) { 19 BumpPtrAllocator Alloc; 20 int *a = (int*)Alloc.Allocate(sizeof(int), 1); 21 int *b = (int*)Alloc.Allocate(sizeof(int) * 10, 1); 22 int *c = (int*)Alloc.Allocate(sizeof(int), 1); 23 *a = 1; 24 b[0] = 2; 25 b[9] = 2; 26 *c = 3; 27 EXPECT_EQ(1, *a); 28 EXPECT_EQ(2, b[0]); 29 EXPECT_EQ(2, b[9]); 30 EXPECT_EQ(3, *c); 31 EXPECT_EQ(1U, Alloc.GetNumSlabs()); 32 33 BumpPtrAllocator Alloc2 = std::move(Alloc); 34 EXPECT_EQ(0U, Alloc.GetNumSlabs()); 35 EXPECT_EQ(1U, Alloc2.GetNumSlabs()); 36 37 // Make sure the old pointers still work. These are especially interesting 38 // under ASan or Valgrind. 39 EXPECT_EQ(1, *a); 40 EXPECT_EQ(2, b[0]); 41 EXPECT_EQ(2, b[9]); 42 EXPECT_EQ(3, *c); 43 44 Alloc = std::move(Alloc2); 45 EXPECT_EQ(0U, Alloc2.GetNumSlabs()); 46 EXPECT_EQ(1U, Alloc.GetNumSlabs()); 47 } 48 49 // Allocate enough bytes to create three slabs. 50 TEST(AllocatorTest, ThreeSlabs) { 51 BumpPtrAllocator Alloc; 52 Alloc.Allocate(3000, 1); 53 EXPECT_EQ(1U, Alloc.GetNumSlabs()); 54 Alloc.Allocate(3000, 1); 55 EXPECT_EQ(2U, Alloc.GetNumSlabs()); 56 Alloc.Allocate(3000, 1); 57 EXPECT_EQ(3U, Alloc.GetNumSlabs()); 58 } 59 60 // Allocate enough bytes to create two slabs, reset the allocator, and do it 61 // again. 62 TEST(AllocatorTest, TestReset) { 63 BumpPtrAllocator Alloc; 64 65 // Allocate something larger than the SizeThreshold=4096. 66 (void)Alloc.Allocate(5000, 1); 67 Alloc.Reset(); 68 // Calling Reset should free all CustomSizedSlabs. 69 EXPECT_EQ(0u, Alloc.GetNumSlabs()); 70 71 Alloc.Allocate(3000, 1); 72 EXPECT_EQ(1U, Alloc.GetNumSlabs()); 73 Alloc.Allocate(3000, 1); 74 EXPECT_EQ(2U, Alloc.GetNumSlabs()); 75 Alloc.Reset(); 76 EXPECT_EQ(1U, Alloc.GetNumSlabs()); 77 Alloc.Allocate(3000, 1); 78 EXPECT_EQ(1U, Alloc.GetNumSlabs()); 79 Alloc.Allocate(3000, 1); 80 EXPECT_EQ(2U, Alloc.GetNumSlabs()); 81 } 82 83 // Test some allocations at varying alignments. 84 TEST(AllocatorTest, TestAlignment) { 85 BumpPtrAllocator Alloc; 86 uintptr_t a; 87 a = (uintptr_t)Alloc.Allocate(1, 2); 88 EXPECT_EQ(0U, a & 1); 89 a = (uintptr_t)Alloc.Allocate(1, 4); 90 EXPECT_EQ(0U, a & 3); 91 a = (uintptr_t)Alloc.Allocate(1, 8); 92 EXPECT_EQ(0U, a & 7); 93 a = (uintptr_t)Alloc.Allocate(1, 16); 94 EXPECT_EQ(0U, a & 15); 95 a = (uintptr_t)Alloc.Allocate(1, 32); 96 EXPECT_EQ(0U, a & 31); 97 a = (uintptr_t)Alloc.Allocate(1, 64); 98 EXPECT_EQ(0U, a & 63); 99 a = (uintptr_t)Alloc.Allocate(1, 128); 100 EXPECT_EQ(0U, a & 127); 101 } 102 103 // Test allocating just over the slab size. This tests a bug where before the 104 // allocator incorrectly calculated the buffer end pointer. 105 TEST(AllocatorTest, TestOverflow) { 106 BumpPtrAllocator Alloc; 107 108 // Fill the slab right up until the end pointer. 109 Alloc.Allocate(4096, 1); 110 EXPECT_EQ(1U, Alloc.GetNumSlabs()); 111 112 // If we don't allocate a new slab, then we will have overflowed. 113 Alloc.Allocate(1, 1); 114 EXPECT_EQ(2U, Alloc.GetNumSlabs()); 115 } 116 117 // Test allocating with a size larger than the initial slab size. 118 TEST(AllocatorTest, TestSmallSlabSize) { 119 BumpPtrAllocator Alloc; 120 121 Alloc.Allocate(8000, 1); 122 EXPECT_EQ(1U, Alloc.GetNumSlabs()); 123 } 124 125 // Test requesting alignment that goes past the end of the current slab. 126 TEST(AllocatorTest, TestAlignmentPastSlab) { 127 BumpPtrAllocator Alloc; 128 Alloc.Allocate(4095, 1); 129 130 // Aligning the current slab pointer is likely to move it past the end of the 131 // slab, which would confuse any unsigned comparisons with the difference of 132 // the end pointer and the aligned pointer. 133 Alloc.Allocate(1024, 8192); 134 135 EXPECT_EQ(2U, Alloc.GetNumSlabs()); 136 } 137 138 // Mock slab allocator that returns slabs aligned on 4096 bytes. There is no 139 // easy portable way to do this, so this is kind of a hack. 140 class MockSlabAllocator { 141 static size_t LastSlabSize; 142 143 public: 144 ~MockSlabAllocator() { } 145 146 void *Allocate(size_t Size, size_t /*Alignment*/) { 147 // Allocate space for the alignment, the slab, and a void* that goes right 148 // before the slab. 149 size_t Alignment = 4096; 150 void *MemBase = malloc(Size + Alignment - 1 + sizeof(void*)); 151 152 // Find the slab start. 153 void *Slab = (void *)alignAddr((char*)MemBase + sizeof(void *), Alignment); 154 155 // Hold a pointer to the base so we can free the whole malloced block. 156 ((void**)Slab)[-1] = MemBase; 157 158 LastSlabSize = Size; 159 return Slab; 160 } 161 162 void Deallocate(void *Slab, size_t Size) { 163 free(((void**)Slab)[-1]); 164 } 165 166 static size_t GetLastSlabSize() { return LastSlabSize; } 167 }; 168 169 size_t MockSlabAllocator::LastSlabSize = 0; 170 171 // Allocate a large-ish block with a really large alignment so that the 172 // allocator will think that it has space, but after it does the alignment it 173 // will not. 174 TEST(AllocatorTest, TestBigAlignment) { 175 BumpPtrAllocatorImpl<MockSlabAllocator> Alloc; 176 177 // First allocate a tiny bit to ensure we have to re-align things. 178 (void)Alloc.Allocate(1, 1); 179 180 // Now the big chunk with a big alignment. 181 (void)Alloc.Allocate(3000, 2048); 182 183 // We test that the last slab size is not the default 4096 byte slab, but 184 // rather a custom sized slab that is larger. 185 EXPECT_GT(MockSlabAllocator::GetLastSlabSize(), 4096u); 186 } 187 188 } // anonymous namespace 189
