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 14using namespace llvm; 15 16namespace { 17 18TEST(AllocatorTest, Basics) { 19 BumpPtrAllocator Alloc; 20 int *a = (int*)Alloc.Allocate(sizeof(int), 0); 21 int *b = (int*)Alloc.Allocate(sizeof(int) * 10, 0); 22 int *c = (int*)Alloc.Allocate(sizeof(int), 0); 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. 50TEST(AllocatorTest, ThreeSlabs) { 51 BumpPtrAllocator Alloc; 52 Alloc.Allocate(3000, 0); 53 EXPECT_EQ(1U, Alloc.GetNumSlabs()); 54 Alloc.Allocate(3000, 0); 55 EXPECT_EQ(2U, Alloc.GetNumSlabs()); 56 Alloc.Allocate(3000, 0); 57 EXPECT_EQ(3U, Alloc.GetNumSlabs()); 58} 59 60// Allocate enough bytes to create two slabs, reset the allocator, and do it 61// again. 62TEST(AllocatorTest, TestReset) { 63 BumpPtrAllocator Alloc; 64 Alloc.Allocate(3000, 0); 65 EXPECT_EQ(1U, Alloc.GetNumSlabs()); 66 Alloc.Allocate(3000, 0); 67 EXPECT_EQ(2U, Alloc.GetNumSlabs()); 68 Alloc.Reset(); 69 EXPECT_EQ(1U, Alloc.GetNumSlabs()); 70 Alloc.Allocate(3000, 0); 71 EXPECT_EQ(1U, Alloc.GetNumSlabs()); 72 Alloc.Allocate(3000, 0); 73 EXPECT_EQ(2U, Alloc.GetNumSlabs()); 74} 75 76// Test some allocations at varying alignments. 77TEST(AllocatorTest, TestAlignment) { 78 BumpPtrAllocator Alloc; 79 uintptr_t a; 80 a = (uintptr_t)Alloc.Allocate(1, 2); 81 EXPECT_EQ(0U, a & 1); 82 a = (uintptr_t)Alloc.Allocate(1, 4); 83 EXPECT_EQ(0U, a & 3); 84 a = (uintptr_t)Alloc.Allocate(1, 8); 85 EXPECT_EQ(0U, a & 7); 86 a = (uintptr_t)Alloc.Allocate(1, 16); 87 EXPECT_EQ(0U, a & 15); 88 a = (uintptr_t)Alloc.Allocate(1, 32); 89 EXPECT_EQ(0U, a & 31); 90 a = (uintptr_t)Alloc.Allocate(1, 64); 91 EXPECT_EQ(0U, a & 63); 92 a = (uintptr_t)Alloc.Allocate(1, 128); 93 EXPECT_EQ(0U, a & 127); 94} 95 96// Test allocating just over the slab size. This tests a bug where before the 97// allocator incorrectly calculated the buffer end pointer. 98TEST(AllocatorTest, TestOverflow) { 99 BumpPtrAllocator Alloc; 100 101 // Fill the slab right up until the end pointer. 102 Alloc.Allocate(4096, 0); 103 EXPECT_EQ(1U, Alloc.GetNumSlabs()); 104 105 // If we don't allocate a new slab, then we will have overflowed. 106 Alloc.Allocate(1, 0); 107 EXPECT_EQ(2U, Alloc.GetNumSlabs()); 108} 109 110// Test allocating with a size larger than the initial slab size. 111TEST(AllocatorTest, TestSmallSlabSize) { 112 BumpPtrAllocator Alloc; 113 114 Alloc.Allocate(8000, 0); 115 EXPECT_EQ(2U, Alloc.GetNumSlabs()); 116} 117 118// Mock slab allocator that returns slabs aligned on 4096 bytes. There is no 119// easy portable way to do this, so this is kind of a hack. 120class MockSlabAllocator { 121 static size_t LastSlabSize; 122 123public: 124 ~MockSlabAllocator() { } 125 126 void *Allocate(size_t Size, size_t /*Alignment*/) { 127 // Allocate space for the alignment, the slab, and a void* that goes right 128 // before the slab. 129 size_t Alignment = 4096; 130 void *MemBase = malloc(Size + Alignment - 1 + sizeof(void*)); 131 132 // Find the slab start. 133 void *Slab = alignPtr((char *)MemBase + sizeof(void *), Alignment); 134 135 // Hold a pointer to the base so we can free the whole malloced block. 136 ((void**)Slab)[-1] = MemBase; 137 138 LastSlabSize = Size; 139 return Slab; 140 } 141 142 void Deallocate(void *Slab, size_t Size) { 143 free(((void**)Slab)[-1]); 144 } 145 146 static size_t GetLastSlabSize() { return LastSlabSize; } 147}; 148 149size_t MockSlabAllocator::LastSlabSize = 0; 150 151// Allocate a large-ish block with a really large alignment so that the 152// allocator will think that it has space, but after it does the alignment it 153// will not. 154TEST(AllocatorTest, TestBigAlignment) { 155 BumpPtrAllocatorImpl<MockSlabAllocator> Alloc; 156 157 // First allocate a tiny bit to ensure we have to re-align things. 158 (void)Alloc.Allocate(1, 0); 159 160 // Now the big chunk with a big alignment. 161 (void)Alloc.Allocate(3000, 2048); 162 163 // We test that the last slab size is not the default 4096 byte slab, but 164 // rather a custom sized slab that is larger. 165 EXPECT_GT(MockSlabAllocator::GetLastSlabSize(), 4096u); 166} 167 168} // anonymous namespace 169