GCC Code Coverage Report

Directory: cvmfs/
File: cvmfs/sqlitemem.cc
Date: 2026-07-05 02:36:18
Exec Total Coverage
Lines: 154 159 96.9%
Branches: 80 122 65.6%
Line Branch Exec Source
1 /**
2 * This file is part of the CernVM File System.
3 */
4
5 #include "sqlitemem.h"
6
7 #include <cassert>
8 #include <cstddef>
9 #include <cstring>
10 #include <new>
11
12 #include "malloc_arena.h"
13 #include "util/concurrency.h"
14 #include "util/exception.h"
15 #include "util/smalloc.h"
16
17 using namespace std; // NOLINT
18
19
20 9469 void *SqliteMemoryManager::LookasideBufferArena::GetBuffer() {
21
2/2
✓ Branch 0 taken 22339 times.
✓ Branch 1 taken 78 times.
 22417 for (unsigned i = 0; i < kNoBitmaps; ++i) {
22 22339 const int bit_set = ffs(freemap_[i]);
23
2/2
✓ Branch 0 taken 9391 times.
✓ Branch 1 taken 12948 times.
 22339 if (bit_set != 0) {
24 9391 freemap_[i] &= ~(1 << (bit_set - 1)); // set bit to zero
25 9391 const int nbuffer = i * sizeof(int) * 8 + bit_set - 1;
26 9391 return reinterpret_cast<char *>(arena_) + nbuffer * kBufferSize;
27 }
28 }
29 78 return NULL;
30 }
31
32
33 3458 bool SqliteMemoryManager::LookasideBufferArena::IsEmpty() {
34
2/2
✓ Branch 0 taken 8762 times.
✓ Branch 1 taken 104 times.
 8866 for (unsigned i = 0; i < kNoBitmaps; ++i) {
35
2/2
✓ Branch 0 taken 3354 times.
✓ Branch 1 taken 5408 times.
 8762 if (~freemap_[i] != 0)
36 3354 return false;
37 }
38 104 return true;
39 }
40
41
42 9469 bool SqliteMemoryManager::LookasideBufferArena::Contains(void *buffer) {
43
3/4
✓ Branch 0 taken 9469 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 26 times.
✓ Branch 3 taken 9443 times.
 9469 if ((buffer == NULL) || (buffer < arena_))
44 26 return false;
45 9443 return (static_cast<uint64_t>((reinterpret_cast<char *>(buffer)
46 9443 - reinterpret_cast<char *>(arena_)))
47 9443 < kArenaSize);
48 }
49
50
51 2703 SqliteMemoryManager::LookasideBufferArena::LookasideBufferArena()
52 2703 : arena_(sxmmap(kArenaSize)) {
53 // All buffers unused, i.e. all bits set
54 2703 memset(freemap_, 0xFF, kNoBitmaps * sizeof(int));
55 2703 }
56
57
58 2699 SqliteMemoryManager::LookasideBufferArena::~LookasideBufferArena() {
59 2699 sxunmap(arena_, kArenaSize);
60 2699 }
61
62
63 9391 void SqliteMemoryManager::LookasideBufferArena::PutBuffer(void *buffer) {
64
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 9391 times.
 9391 assert(buffer >= arena_);
65 9391 const ptrdiff_t nbuffer = (reinterpret_cast<char *>(buffer)
66 9391 - reinterpret_cast<char *>(arena_))
67 / kBufferSize;
68
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 9391 times.
 9391 assert(static_cast<uint64_t>(nbuffer) < kBuffersPerArena);
69 9391 const int nfreemap = nbuffer / (sizeof(int) * 8);
70 9391 freemap_[nfreemap] |= 1 << (nbuffer % (sizeof(int) * 8));
71 9391 }
72
73
74 //------------------------------------------------------------------------------
75
76
77 SqliteMemoryManager *SqliteMemoryManager::instance_ = NULL;
78
79
80 /**
81 * Sqlite ensures that size > 0.
82 */
83 1519203 void *SqliteMemoryManager::xMalloc(int size) {
84 1519203 return instance_->GetMemory(size);
85 }
86
87
88 /**
89 * Sqlite ensures that ptr != NULL.
90 */
91 1519110 void SqliteMemoryManager::xFree(void *ptr) { instance_->PutMemory(ptr); }
92
93
94 /**
95 * Sqlite ensures that ptr != NULL and new_size > 0.
96 */
97 601118 void *SqliteMemoryManager::xRealloc(void *ptr, int new_size) {
98 601118 const int old_size = xSize(ptr);
99
2/2
✓ Branch 0 taken 14893 times.
✓ Branch 1 taken 586225 times.
 601118 if (old_size >= new_size)
100 14893 return ptr;
101
102 586225 void *new_ptr = xMalloc(new_size);
103 586225 memcpy(new_ptr, ptr, old_size);
104 586225 xFree(ptr);
105 586225 return new_ptr;
106 }
107
108
109 /**
110 * Sqlite ensures that ptr != NULL.
111 */
112 2679319 int SqliteMemoryManager::xSize(void *ptr) {
113 2679319 return instance_->GetMemorySize(ptr);
114 }
115
116
117 1014070 int SqliteMemoryManager::xRoundup(int size) { return RoundUp8(size); }
118
119
120 2521 int SqliteMemoryManager::xInit(void *app_data __attribute__((unused))) {
121 2521 return SQLITE_OK;
122 }
123
124
125 2517 void SqliteMemoryManager::xShutdown(void *app_data __attribute__((unused))) { }
126
127
128 2521 void SqliteMemoryManager::AssignGlobalArenas() {
129
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2521 times.
 2521 if (assigned_)
130 ✗ return;
131 int retval;
132
133 2521 retval = sqlite3_config(SQLITE_CONFIG_PAGECACHE, page_cache_memory_,
134 kPageCacheSlotSize, kPageCacheNoSlots);
135
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2521 times.
 2521 assert(retval == SQLITE_OK);
136
137 2521 retval = sqlite3_config(SQLITE_CONFIG_GETMALLOC, &sqlite3_mem_vanilla_);
138
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2521 times.
 2521 assert(retval == SQLITE_OK);
139 2521 retval = sqlite3_config(SQLITE_CONFIG_MALLOC, &mem_methods_);
140
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2521 times.
 2521 assert(retval == SQLITE_OK);
141
142 2521 assigned_ = true;
143 }
144
145
146 /**
147 * Needs to be the first operation on an opened sqlite database. Returns the
148 * location of the buffer.
149 */
150 1019 void *SqliteMemoryManager::AssignLookasideBuffer(sqlite3 *db) {
151 1019 const MutexLockGuard lock_guard(lock_);
152
153
1/2
✓ Branch 1 taken 1019 times.
✗ Branch 2 not taken.
 1019 void *buffer = GetLookasideBuffer();
154
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1019 times.
 1019 assert(buffer != NULL);
155
1/2
✓ Branch 1 taken 1019 times.
✗ Branch 2 not taken.
 1019 const int retval = sqlite3_db_config(db, SQLITE_DBCONFIG_LOOKASIDE, buffer,
156 kLookasideSlotSize,
157 kLookasideSlotsPerDb);
158
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1019 times.
 1019 assert(retval == SQLITE_OK);
159 1019 return buffer;
160 1019 }
161
162
163 2647 void SqliteMemoryManager::CleanupInstance() {
164
1/2
✓ Branch 0 taken 2647 times.
✗ Branch 1 not taken.
 2647 delete instance_;
165 2647 instance_ = NULL;
166 2647 }
167
168
169 /**
170 * Opens a new arena if necessary.
171 */
172 4373 void *SqliteMemoryManager::GetLookasideBuffer() {
173 void *result;
174 vector<LookasideBufferArena *>::reverse_iterator
175 4373 reverse_iter = lookaside_buffer_arenas_.rbegin();
176 const vector<LookasideBufferArena *>::reverse_iterator
177 4373 i_rend = lookaside_buffer_arenas_.rend();
178
3/4
✓ Branch 2 taken 4399 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 4373 times.
✓ Branch 5 taken 26 times.
 4399 for (; reverse_iter != i_rend; ++reverse_iter) {
179 4373 result = (*reverse_iter)->GetBuffer();
180
2/2
✓ Branch 0 taken 4347 times.
✓ Branch 1 taken 26 times.
 4373 if (result != NULL)
181 4347 return result;
182 }
183
184
1/2
✓ Branch 1 taken 26 times.
✗ Branch 2 not taken.
 26 LookasideBufferArena *new_arena = new LookasideBufferArena();
185
1/2
✓ Branch 1 taken 26 times.
✗ Branch 2 not taken.
 26 lookaside_buffer_arenas_.push_back(new_arena);
186 26 return new_arena->GetBuffer();
187 }
188
189
190 2679423 int SqliteMemoryManager::GetMemorySize(void *ptr) {
191 2679423 return MallocArena::GetMallocArena(ptr, kArenaSize)->GetSize(ptr);
192 }
193
194
195 /**
196 * Opens new arenas as necessary.
197 */
198 2039359 void *SqliteMemoryManager::GetMemory(int size) {
199
1/2
✓ Branch 2 taken 2039359 times.
✗ Branch 3 not taken.
 2039359 void *p = malloc_arenas_[idx_last_arena_]->Malloc(size);
200
2/2
✓ Branch 0 taken 2039333 times.
✓ Branch 1 taken 26 times.
 2039359 if (p != NULL)
201 2039333 return p;
202 26 const unsigned N = malloc_arenas_.size();
203
2/2
✓ Branch 0 taken 26 times.
✓ Branch 1 taken 26 times.
 52 for (unsigned i = 0; i < N; ++i) {
204
1/2
✓ Branch 2 taken 26 times.
✗ Branch 3 not taken.
 26 p = malloc_arenas_[i]->Malloc(size);
205
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 26 times.
 26 if (p != NULL) {
206 ✗ idx_last_arena_ = i;
207 ✗ return p;
208 }
209 }
210 26 idx_last_arena_ = N;
211
2/4
✓ Branch 1 taken 26 times.
✗ Branch 2 not taken.
✓ Branch 4 taken 26 times.
✗ Branch 5 not taken.
 26 MallocArena *M = new MallocArena(kArenaSize);
212
1/2
✓ Branch 1 taken 26 times.
✗ Branch 2 not taken.
 26 malloc_arenas_.push_back(M);
213
1/2
✓ Branch 1 taken 26 times.
✗ Branch 2 not taken.
 26 p = M->Malloc(size);
214
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 26 times.
 26 assert(p != NULL);
215 26 return p;
216 }
217
218
219 2651 SqliteMemoryManager::SqliteMemoryManager()
220 2651 : assigned_(false)
221 2651 , page_cache_memory_(sxmmap(kPageCacheSize))
222 2651 , idx_last_arena_(0) {
223 2651 memset(&sqlite3_mem_vanilla_, 0, sizeof(sqlite3_mem_vanilla_));
224 2651 const int retval = pthread_mutex_init(&lock_, NULL);
225
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2651 times.
 2651 assert(retval == 0);
226
227
2/4
✓ Branch 1 taken 2651 times.
✗ Branch 2 not taken.
✓ Branch 5 taken 2651 times.
✗ Branch 6 not taken.
 2651 lookaside_buffer_arenas_.push_back(new LookasideBufferArena());
228
3/6
✓ Branch 1 taken 2651 times.
✗ Branch 2 not taken.
✓ Branch 4 taken 2651 times.
✗ Branch 5 not taken.
✓ Branch 7 taken 2651 times.
✗ Branch 8 not taken.
 2651 malloc_arenas_.push_back(new MallocArena(kArenaSize));
229
230 2651 memset(&mem_methods_, 0, sizeof(mem_methods_));
231 2651 mem_methods_.xMalloc = xMalloc;
232 2651 mem_methods_.xFree = xFree;
233 2651 mem_methods_.xRealloc = xRealloc;
234 2651 mem_methods_.xSize = xSize;
235 2651 mem_methods_.xRoundup = xRoundup;
236 2651 mem_methods_.xInit = xInit;
237 2651 mem_methods_.xShutdown = xShutdown;
238 2651 mem_methods_.pAppData = NULL;
239 2651 }
240
241
242 /**
243 * Must be executed only after sqlite3_shutdown.
244 */
245 2647 SqliteMemoryManager::~SqliteMemoryManager() {
246
2/2
✓ Branch 0 taken 2517 times.
✓ Branch 1 taken 130 times.
 2647 if (assigned_) {
247 // Reset sqlite to default values
248 int retval;
249 2517 retval = sqlite3_config(SQLITE_CONFIG_PAGECACHE, NULL, 0, 0);
250
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2517 times.
 2517 assert(retval == SQLITE_OK);
251 2517 retval = sqlite3_config(SQLITE_CONFIG_MALLOC, &sqlite3_mem_vanilla_);
252
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2517 times.
 2517 assert(retval == SQLITE_OK);
253 }
254
255 2647 sxunmap(page_cache_memory_, kPageCacheSize);
256
2/2
✓ Branch 1 taken 2647 times.
✓ Branch 2 taken 2647 times.
 5294 for (unsigned i = 0; i < lookaside_buffer_arenas_.size(); ++i)
257
1/2
✓ Branch 1 taken 2647 times.
✗ Branch 2 not taken.
 2647 delete lookaside_buffer_arenas_[i];
258
2/2
✓ Branch 1 taken 2647 times.
✓ Branch 2 taken 2647 times.
 5294 for (unsigned i = 0; i < malloc_arenas_.size(); ++i)
259
1/2
✓ Branch 1 taken 2647 times.
✗ Branch 2 not taken.
 2647 delete malloc_arenas_[i];
260 2647 pthread_mutex_destroy(&lock_);
261 2647 }
262
263
264 /**
265 * Only entirely empty arenas are freed to the system. In cvmfs, catalogs
266 * are gradually opened and sometimes close altogether when a new root catalog
267 * arrives. Hence there is no fragmentation.
268 */
269 4373 void SqliteMemoryManager::PutLookasideBuffer(void *buffer) {
270 4373 const unsigned N = lookaside_buffer_arenas_.size();
271
1/2
✓ Branch 0 taken 4373 times.
✗ Branch 1 not taken.
 4373 for (unsigned i = 0; i < N; ++i) {
272
1/2
✓ Branch 2 taken 4373 times.
✗ Branch 3 not taken.
 4373 if (lookaside_buffer_arenas_[i]->Contains(buffer)) {
273 4373 lookaside_buffer_arenas_[i]->PutBuffer(buffer);
274
6/6
✓ Branch 0 taken 3328 times.
✓ Branch 1 taken 1045 times.
✓ Branch 4 taken 26 times.
✓ Branch 5 taken 3302 times.
✓ Branch 6 taken 26 times.
✓ Branch 7 taken 4347 times.
 4373 if ((N > 1) && lookaside_buffer_arenas_[i]->IsEmpty()) {
275
1/2
✓ Branch 1 taken 26 times.
✗ Branch 2 not taken.
 26 delete lookaside_buffer_arenas_[i];
276
1/2
✓ Branch 4 taken 26 times.
✗ Branch 5 not taken.
 26 lookaside_buffer_arenas_.erase(lookaside_buffer_arenas_.begin() + i);
277 }
278 4373 return;
279 }
280 }
281 ✗ PANIC(NULL);
282 }
283
284
285 /**
286 * Closes empty areas.
287 */
288 1519214 void SqliteMemoryManager::PutMemory(void *ptr) {
289 1519214 MallocArena *M = MallocArena::GetMallocArena(ptr, kArenaSize);
290 1519214 M->Free(ptr);
291 1519214 const unsigned N = malloc_arenas_.size();
292
5/6
✓ Branch 0 taken 26 times.
✓ Branch 1 taken 1519188 times.
✓ Branch 3 taken 26 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 26 times.
✓ Branch 6 taken 1519188 times.
 1519214 if ((N > 1) && M->IsEmpty()) {
293
1/2
✓ Branch 0 taken 52 times.
✗ Branch 1 not taken.
 52 for (unsigned i = 0; i < N; ++i) {
294
2/2
✓ Branch 1 taken 26 times.
✓ Branch 2 taken 26 times.
 52 if (malloc_arenas_[i] == M) {
295
1/2
✓ Branch 1 taken 26 times.
✗ Branch 2 not taken.
 26 delete malloc_arenas_[i];
296
1/2
✓ Branch 4 taken 26 times.
✗ Branch 5 not taken.
 26 malloc_arenas_.erase(malloc_arenas_.begin() + i);
297 26 idx_last_arena_ = 0;
298 26 return;
299 }
300 }
301 ✗ PANIC(NULL);
302 }
303 }
304
305
306 /**
307 * To be used after an sqlite database has been closed.
308 */
309 1019 void SqliteMemoryManager::ReleaseLookasideBuffer(void *buffer) {
310 1019 const MutexLockGuard lock_guard(lock_);
311
1/2
✓ Branch 1 taken 1019 times.
✗ Branch 2 not taken.
 1019 PutLookasideBuffer(buffer);
312 1019 }
313