1 /*
2 * Copyright (C) 2013 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include <stdlib.h>
18 #include <string.h>
19 #include <sys/mman.h>
20
21 #include <gtest/gtest.h>
22
23 #include "../linker_allocator.h"
24
25 #include <unistd.h>
26
27 namespace {
28
29 /*
30 * this one has size below allocator cap which is 2*sizeof(void*)
31 */
32 struct test_struct_small {
33 char dummy_str[5];
34 };
35
36 struct test_struct_large {
37 char dummy_str[1009];
38 };
39
40 struct test_struct_huge {
41 char dummy_str[73939];
42 };
43
44 struct test_struct_512 {
45 char dummy_str[503];
46 };
47
48 };
49
50 static size_t kPageSize = sysconf(_SC_PAGE_SIZE);
51
TEST(linker_memory,test_alloc_0)52 TEST(linker_memory, test_alloc_0) {
53 LinkerMemoryAllocator allocator;
54 void* ptr = allocator.alloc(0);
55 ASSERT_TRUE(ptr != nullptr);
56 free(ptr);
57 }
58
TEST(linker_memory,test_free_nullptr)59 TEST(linker_memory, test_free_nullptr) {
60 LinkerMemoryAllocator allocator;
61 allocator.free(nullptr);
62 }
63
TEST(linker_memory,test_realloc)64 TEST(linker_memory, test_realloc) {
65 LinkerMemoryAllocator allocator;
66 uint32_t* array = reinterpret_cast<uint32_t*>(allocator.alloc(512));
67 const size_t array_size = 512 / sizeof(uint32_t);
68
69 uint32_t model[1000];
70
71 model[0] = 1;
72 model[1] = 1;
73
74 for (size_t i = 2; i < 1000; ++i) {
75 model[i] = model[i - 1] + model[i - 2];
76 }
77
78 memcpy(array, model, array_size);
79
80 uint32_t* reallocated_ptr = reinterpret_cast<uint32_t*>(allocator.realloc(array, 1024));
81
82 ASSERT_TRUE(reallocated_ptr != nullptr);
83 ASSERT_TRUE(reallocated_ptr != array);
84
85 ASSERT_TRUE(memcmp(reallocated_ptr, model, array_size) == 0);
86
87 array = reallocated_ptr;
88
89 memcpy(array, model, 2*array_size);
90
91 reallocated_ptr = reinterpret_cast<uint32_t*>(allocator.realloc(array, 62));
92
93 ASSERT_TRUE(reallocated_ptr == array);
94
95 reallocated_ptr = reinterpret_cast<uint32_t*>(allocator.realloc(array, 4000));
96
97 ASSERT_TRUE(reallocated_ptr != nullptr);
98 ASSERT_TRUE(reallocated_ptr != array);
99
100 ASSERT_TRUE(memcmp(reallocated_ptr, model, array_size * 2) == 0);
101
102 array = reallocated_ptr;
103
104 memcpy(array, model, 4000);
105
106 reallocated_ptr = reinterpret_cast<uint32_t*>(allocator.realloc(array, 64000));
107
108 ASSERT_TRUE(reallocated_ptr != nullptr);
109 ASSERT_TRUE(reallocated_ptr != array);
110
111 ASSERT_TRUE(memcmp(reallocated_ptr, model, 4000) == 0);
112
113 ASSERT_EQ(nullptr, realloc(reallocated_ptr, 0));
114 }
115
TEST(linker_memory,test_small_smoke)116 TEST(linker_memory, test_small_smoke) {
117 LinkerMemoryAllocator allocator;
118
119 uint8_t zeros[16];
120 memset(zeros, 0, sizeof(zeros));
121
122 test_struct_small* ptr1 =
123 reinterpret_cast<test_struct_small*>(allocator.alloc(sizeof(test_struct_small)));
124 test_struct_small* ptr2 =
125 reinterpret_cast<test_struct_small*>(allocator.alloc(sizeof(test_struct_small)));
126
127 ASSERT_TRUE(ptr1 != nullptr);
128 ASSERT_TRUE(ptr2 != nullptr);
129 ASSERT_EQ(reinterpret_cast<uintptr_t>(ptr1)+16, reinterpret_cast<uintptr_t>(ptr2));
130 ASSERT_TRUE(memcmp(ptr1, zeros, 16) == 0);
131
132 allocator.free(ptr1);
133 allocator.free(ptr2);
134 }
135
TEST(linker_memory,test_huge_smoke)136 TEST(linker_memory, test_huge_smoke) {
137 LinkerMemoryAllocator allocator;
138
139 // this should trigger proxy-to-mmap
140 test_struct_huge* ptr1 =
141 reinterpret_cast<test_struct_huge*>(allocator.alloc(sizeof(test_struct_huge)));
142 test_struct_huge* ptr2 =
143 reinterpret_cast<test_struct_huge*>(allocator.alloc(sizeof(test_struct_huge)));
144
145 ASSERT_TRUE(ptr1 != nullptr);
146 ASSERT_TRUE(ptr2 != nullptr);
147
148 ASSERT_TRUE(
149 reinterpret_cast<uintptr_t>(ptr1)/kPageSize != reinterpret_cast<uintptr_t>(ptr2)/kPageSize);
150 allocator.free(ptr2);
151 allocator.free(ptr1);
152 }
153
TEST(linker_memory,test_large)154 TEST(linker_memory, test_large) {
155 LinkerMemoryAllocator allocator;
156
157 test_struct_large* ptr1 =
158 reinterpret_cast<test_struct_large*>(allocator.alloc(sizeof(test_struct_large)));
159 test_struct_large* ptr2 =
160 reinterpret_cast<test_struct_large*>(allocator.alloc(1024));
161
162 ASSERT_TRUE(ptr1 != nullptr);
163 ASSERT_TRUE(ptr2 != nullptr);
164
165 ASSERT_EQ(reinterpret_cast<uintptr_t>(ptr1) + 1024, reinterpret_cast<uintptr_t>(ptr2));
166
167 // let's allocate until we reach the next page.
168 size_t n = kPageSize / sizeof(test_struct_large) + 1 - 2;
169 test_struct_large* objects[n];
170
171 for (size_t i = 0; i < n; ++i) {
172 test_struct_large* obj_ptr =
173 reinterpret_cast<test_struct_large*>(allocator.alloc(sizeof(test_struct_large)));
174 ASSERT_TRUE(obj_ptr != nullptr);
175 objects[i] = obj_ptr;
176 }
177
178 test_struct_large* ptr_to_free =
179 reinterpret_cast<test_struct_large*>(allocator.alloc(sizeof(test_struct_large)));
180
181 ASSERT_TRUE(ptr_to_free != nullptr);
182
183 allocator.free(ptr1);
184
185 for (size_t i=0; i<n; ++i) {
186 allocator.free(objects[i]);
187 }
188
189 allocator.free(ptr2);
190 allocator.free(ptr_to_free);
191 }
192
193
194