1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
|
/*
* Copyright 2014 Google, Inc
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "SkSmallAllocator.h"
#include "SkTypes.h"
#include "Test.h"
class CountingClass {
public:
CountingClass() {
kCount++;
}
~CountingClass() {
kCount--;
}
static int GetCount() { return kCount; }
private:
static int kCount;
};
int CountingClass::kCount;
template<uint32_t kMaxObjects, size_t kBytes> void test_allocator(skiatest::Reporter* reporter) {
{
SkSmallAllocator<kMaxObjects, kBytes> alloc;
for (uint32_t i = 0; i < kMaxObjects; ++i) {
CountingClass* c = alloc.template createT<CountingClass>();
REPORTER_ASSERT(reporter, c != nullptr);
REPORTER_ASSERT(reporter, CountingClass::GetCount() == static_cast<int>(i+1));
}
}
REPORTER_ASSERT(reporter, CountingClass::GetCount() == 0);
}
// Tests that ensure that the destructor is called, whether the objects
// were created in fStorage or on the heap.
DEF_TEST(SmallAllocator_destructor, reporter) {
// Four times as many bytes as objects will never require any heap
// allocations (since SkAlign4(sizeof(CountingClass)) == 4 and the allocator
// will stop once it reaches kMaxObjects).
test_allocator<5, 20>(reporter);
test_allocator<10, 40>(reporter);
test_allocator<20, 80>(reporter);
#ifndef SK_DEBUG
// Allowing less bytes than objects means some will be allocated on the
// heap. Don't run these in debug where we assert.
test_allocator<50, 20>(reporter);
test_allocator<100, 20>(reporter);
#endif
}
class Dummy {
};
class DummyContainer {
public:
explicit DummyContainer(Dummy* d)
:fDummy(d)
{}
Dummy* getDummy() const { return fDummy; }
private:
Dummy* fDummy;
};
// Test that using a createT with a constructor taking a pointer as a
// parameter works as expected.
DEF_TEST(SmallAllocator_pointer, reporter) {
SkSmallAllocator<1, 8> alloc;
Dummy d;
DummyContainer* container = alloc.createT<DummyContainer>(&d);
REPORTER_ASSERT(reporter, container != nullptr);
REPORTER_ASSERT(reporter, container->getDummy() == &d);
}
#define check_alignment(reporter, ptr) \
REPORTER_ASSERT(reporter, SkIsAlign16((intptr_t)ptr))
DEF_TEST(SmallAllocator_alignment, reporter) {
const size_t totalBytes = 1 + 2 + 4 + 8;
SkSmallAllocator<4, totalBytes> alloc;
check_alignment(reporter, alloc.reserveT<uint8_t>());
check_alignment(reporter, alloc.reserveT<uint16_t>());
check_alignment(reporter, alloc.reserveT<uint32_t>());
check_alignment(reporter, alloc.reserveT<uint64_t>());
}
|
