| OLD | NEW |
|---|
| (Empty) |
| 1 /* | |
| 2 ** 2007 October 14 | |
| 3 ** | |
| 4 ** The author disclaims copyright to this source code. In place of | |
| 5 ** a legal notice, here is a blessing: | |
| 6 ** | |
| 7 ** May you do good and not evil. | |
| 8 ** May you find forgiveness for yourself and forgive others. | |
| 9 ** May you share freely, never taking more than you give. | |
| 10 ** | |
| 11 ************************************************************************* | |
| 12 ** This file contains the C functions that implement a memory | |
| 13 ** allocation subsystem for use by SQLite. | |
| 14 ** | |
| 15 ** This version of the memory allocation subsystem omits all | |
| 16 ** use of malloc(). The application gives SQLite a block of memory | |
| 17 ** before calling sqlite3_initialize() from which allocations | |
| 18 ** are made and returned by the xMalloc() and xRealloc() | |
| 19 ** implementations. Once sqlite3_initialize() has been called, | |
| 20 ** the amount of memory available to SQLite is fixed and cannot | |
| 21 ** be changed. | |
| 22 ** | |
| 23 ** This version of the memory allocation subsystem is included | |
| 24 ** in the build only if SQLITE_ENABLE_MEMSYS5 is defined. | |
| 25 ** | |
| 26 ** This memory allocator uses the following algorithm: | |
| 27 ** | |
| 28 ** 1. All memory allocation sizes are rounded up to a power of 2. | |
| 29 ** | |
| 30 ** 2. If two adjacent free blocks are the halves of a larger block, | |
| 31 ** then the two blocks are coalesced into the single larger block. | |
| 32 ** | |
| 33 ** 3. New memory is allocated from the first available free block. | |
| 34 ** | |
| 35 ** This algorithm is described in: J. M. Robson. "Bounds for Some Functions | |
| 36 ** Concerning Dynamic Storage Allocation". Journal of the Association for | |
| 37 ** Computing Machinery, Volume 21, Number 8, July 1974, pages 491-499. | |
| 38 ** | |
| 39 ** Let n be the size of the largest allocation divided by the minimum | |
| 40 ** allocation size (after rounding all sizes up to a power of 2.) Let M | |
| 41 ** be the maximum amount of memory ever outstanding at one time. Let | |
| 42 ** N be the total amount of memory available for allocation. Robson | |
| 43 ** proved that this memory allocator will never breakdown due to | |
| 44 ** fragmentation as long as the following constraint holds: | |
| 45 ** | |
| 46 ** N >= M*(1 + log2(n)/2) - n + 1 | |
| 47 ** | |
| 48 ** The sqlite3_status() logic tracks the maximum values of n and M so | |
| 49 ** that an application can, at any time, verify this constraint. | |
| 50 */ | |
| 51 #include "sqliteInt.h" | |
| 52 | |
| 53 /* | |
| 54 ** This version of the memory allocator is used only when | |
| 55 ** SQLITE_ENABLE_MEMSYS5 is defined. | |
| 56 */ | |
| 57 #ifdef SQLITE_ENABLE_MEMSYS5 | |
| 58 | |
| 59 /* | |
| 60 ** A minimum allocation is an instance of the following structure. | |
| 61 ** Larger allocations are an array of these structures where the | |
| 62 ** size of the array is a power of 2. | |
| 63 ** | |
| 64 ** The size of this object must be a power of two. That fact is | |
| 65 ** verified in memsys5Init(). | |
| 66 */ | |
| 67 typedef struct Mem5Link Mem5Link; | |
| 68 struct Mem5Link { | |
| 69 int next; /* Index of next free chunk */ | |
| 70 int prev; /* Index of previous free chunk */ | |
| 71 }; | |
| 72 | |
| 73 /* | |
| 74 ** Maximum size of any allocation is ((1<<LOGMAX)*mem5.szAtom). Since | |
| 75 ** mem5.szAtom is always at least 8 and 32-bit integers are used, | |
| 76 ** it is not actually possible to reach this limit. | |
| 77 */ | |
| 78 #define LOGMAX 30 | |
| 79 | |
| 80 /* | |
| 81 ** Masks used for mem5.aCtrl[] elements. | |
| 82 */ | |
| 83 #define CTRL_LOGSIZE 0x1f /* Log2 Size of this block */ | |
| 84 #define CTRL_FREE 0x20 /* True if not checked out */ | |
| 85 | |
| 86 /* | |
| 87 ** All of the static variables used by this module are collected | |
| 88 ** into a single structure named "mem5". This is to keep the | |
| 89 ** static variables organized and to reduce namespace pollution | |
| 90 ** when this module is combined with other in the amalgamation. | |
| 91 */ | |
| 92 static SQLITE_WSD struct Mem5Global { | |
| 93 /* | |
| 94 ** Memory available for allocation | |
| 95 */ | |
| 96 int szAtom; /* Smallest possible allocation in bytes */ | |
| 97 int nBlock; /* Number of szAtom sized blocks in zPool */ | |
| 98 u8 *zPool; /* Memory available to be allocated */ | |
| 99 | |
| 100 /* | |
| 101 ** Mutex to control access to the memory allocation subsystem. | |
| 102 */ | |
| 103 sqlite3_mutex *mutex; | |
| 104 | |
| 105 /* | |
| 106 ** Performance statistics | |
| 107 */ | |
| 108 u64 nAlloc; /* Total number of calls to malloc */ | |
| 109 u64 totalAlloc; /* Total of all malloc calls - includes internal frag */ | |
| 110 u64 totalExcess; /* Total internal fragmentation */ | |
| 111 u32 currentOut; /* Current checkout, including internal fragmentation */ | |
| 112 u32 currentCount; /* Current number of distinct checkouts */ | |
| 113 u32 maxOut; /* Maximum instantaneous currentOut */ | |
| 114 u32 maxCount; /* Maximum instantaneous currentCount */ | |
| 115 u32 maxRequest; /* Largest allocation (exclusive of internal frag) */ | |
| 116 | |
| 117 /* | |
| 118 ** Lists of free blocks. aiFreelist[0] is a list of free blocks of | |
| 119 ** size mem5.szAtom. aiFreelist[1] holds blocks of size szAtom*2. | |
| 120 ** aiFreelist[2] holds free blocks of size szAtom*4. And so forth. | |
| 121 */ | |
| 122 int aiFreelist[LOGMAX+1]; | |
| 123 | |
| 124 /* | |
| 125 ** Space for tracking which blocks are checked out and the size | |
| 126 ** of each block. One byte per block. | |
| 127 */ | |
| 128 u8 *aCtrl; | |
| 129 | |
| 130 } mem5; | |
| 131 | |
| 132 /* | |
| 133 ** Access the static variable through a macro for SQLITE_OMIT_WSD. | |
| 134 */ | |
| 135 #define mem5 GLOBAL(struct Mem5Global, mem5) | |
| 136 | |
| 137 /* | |
| 138 ** Assuming mem5.zPool is divided up into an array of Mem5Link | |
| 139 ** structures, return a pointer to the idx-th such link. | |
| 140 */ | |
| 141 #define MEM5LINK(idx) ((Mem5Link *)(&mem5.zPool[(idx)*mem5.szAtom])) | |
| 142 | |
| 143 /* | |
| 144 ** Unlink the chunk at mem5.aPool[i] from list it is currently | |
| 145 ** on. It should be found on mem5.aiFreelist[iLogsize]. | |
| 146 */ | |
| 147 static void memsys5Unlink(int i, int iLogsize){ | |
| 148 int next, prev; | |
| 149 assert( i>=0 && i<mem5.nBlock ); | |
| 150 assert( iLogsize>=0 && iLogsize<=LOGMAX ); | |
| 151 assert( (mem5.aCtrl[i] & CTRL_LOGSIZE)==iLogsize ); | |
| 152 | |
| 153 next = MEM5LINK(i)->next; | |
| 154 prev = MEM5LINK(i)->prev; | |
| 155 if( prev<0 ){ | |
| 156 mem5.aiFreelist[iLogsize] = next; | |
| 157 }else{ | |
| 158 MEM5LINK(prev)->next = next; | |
| 159 } | |
| 160 if( next>=0 ){ | |
| 161 MEM5LINK(next)->prev = prev; | |
| 162 } | |
| 163 } | |
| 164 | |
| 165 /* | |
| 166 ** Link the chunk at mem5.aPool[i] so that is on the iLogsize | |
| 167 ** free list. | |
| 168 */ | |
| 169 static void memsys5Link(int i, int iLogsize){ | |
| 170 int x; | |
| 171 assert( sqlite3_mutex_held(mem5.mutex) ); | |
| 172 assert( i>=0 && i<mem5.nBlock ); | |
| 173 assert( iLogsize>=0 && iLogsize<=LOGMAX ); | |
| 174 assert( (mem5.aCtrl[i] & CTRL_LOGSIZE)==iLogsize ); | |
| 175 | |
| 176 x = MEM5LINK(i)->next = mem5.aiFreelist[iLogsize]; | |
| 177 MEM5LINK(i)->prev = -1; | |
| 178 if( x>=0 ){ | |
| 179 assert( x<mem5.nBlock ); | |
| 180 MEM5LINK(x)->prev = i; | |
| 181 } | |
| 182 mem5.aiFreelist[iLogsize] = i; | |
| 183 } | |
| 184 | |
| 185 /* | |
| 186 ** Obtain or release the mutex needed to access global data structures. | |
| 187 */ | |
| 188 static void memsys5Enter(void){ | |
| 189 sqlite3_mutex_enter(mem5.mutex); | |
| 190 } | |
| 191 static void memsys5Leave(void){ | |
| 192 sqlite3_mutex_leave(mem5.mutex); | |
| 193 } | |
| 194 | |
| 195 /* | |
| 196 ** Return the size of an outstanding allocation, in bytes. | |
| 197 ** This only works for chunks that are currently checked out. | |
| 198 */ | |
| 199 static int memsys5Size(void *p){ | |
| 200 int iSize, i; | |
| 201 assert( p!=0 ); | |
| 202 i = (int)(((u8 *)p-mem5.zPool)/mem5.szAtom); | |
| 203 assert( i>=0 && i<mem5.nBlock ); | |
| 204 iSize = mem5.szAtom * (1 << (mem5.aCtrl[i]&CTRL_LOGSIZE)); | |
| 205 return iSize; | |
| 206 } | |
| 207 | |
| 208 /* | |
| 209 ** Return a block of memory of at least nBytes in size. | |
| 210 ** Return NULL if unable. Return NULL if nBytes==0. | |
| 211 ** | |
| 212 ** The caller guarantees that nByte is positive. | |
| 213 ** | |
| 214 ** The caller has obtained a mutex prior to invoking this | |
| 215 ** routine so there is never any chance that two or more | |
| 216 ** threads can be in this routine at the same time. | |
| 217 */ | |
| 218 static void *memsys5MallocUnsafe(int nByte){ | |
| 219 int i; /* Index of a mem5.aPool[] slot */ | |
| 220 int iBin; /* Index into mem5.aiFreelist[] */ | |
| 221 int iFullSz; /* Size of allocation rounded up to power of 2 */ | |
| 222 int iLogsize; /* Log2 of iFullSz/POW2_MIN */ | |
| 223 | |
| 224 /* nByte must be a positive */ | |
| 225 assert( nByte>0 ); | |
| 226 | |
| 227 /* Keep track of the maximum allocation request. Even unfulfilled | |
| 228 ** requests are counted */ | |
| 229 if( (u32)nByte>mem5.maxRequest ){ | |
| 230 /* Abort if the requested allocation size is larger than the largest | |
| 231 ** power of two that we can represent using 32-bit signed integers. */ | |
| 232 if( nByte > 0x40000000 ) return 0; | |
| 233 mem5.maxRequest = nByte; | |
| 234 } | |
| 235 | |
| 236 /* Round nByte up to the next valid power of two */ | |
| 237 for(iFullSz=mem5.szAtom,iLogsize=0; iFullSz<nByte; iFullSz*=2,iLogsize++){} | |
| 238 | |
| 239 /* Make sure mem5.aiFreelist[iLogsize] contains at least one free | |
| 240 ** block. If not, then split a block of the next larger power of | |
| 241 ** two in order to create a new free block of size iLogsize. | |
| 242 */ | |
| 243 for(iBin=iLogsize; iBin<=LOGMAX && mem5.aiFreelist[iBin]<0; iBin++){} | |
| 244 if( iBin>LOGMAX ){ | |
| 245 testcase( sqlite3GlobalConfig.xLog!=0 ); | |
| 246 sqlite3_log(SQLITE_NOMEM, "failed to allocate %u bytes", nByte); | |
| 247 return 0; | |
| 248 } | |
| 249 i = mem5.aiFreelist[iBin]; | |
| 250 memsys5Unlink(i, iBin); | |
| 251 while( iBin>iLogsize ){ | |
| 252 int newSize; | |
| 253 | |
| 254 iBin--; | |
| 255 newSize = 1 << iBin; | |
| 256 mem5.aCtrl[i+newSize] = CTRL_FREE | iBin; | |
| 257 memsys5Link(i+newSize, iBin); | |
| 258 } | |
| 259 mem5.aCtrl[i] = iLogsize; | |
| 260 | |
| 261 /* Update allocator performance statistics. */ | |
| 262 mem5.nAlloc++; | |
| 263 mem5.totalAlloc += iFullSz; | |
| 264 mem5.totalExcess += iFullSz - nByte; | |
| 265 mem5.currentCount++; | |
| 266 mem5.currentOut += iFullSz; | |
| 267 if( mem5.maxCount<mem5.currentCount ) mem5.maxCount = mem5.currentCount; | |
| 268 if( mem5.maxOut<mem5.currentOut ) mem5.maxOut = mem5.currentOut; | |
| 269 | |
| 270 #ifdef SQLITE_DEBUG | |
| 271 /* Make sure the allocated memory does not assume that it is set to zero | |
| 272 ** or retains a value from a previous allocation */ | |
| 273 memset(&mem5.zPool[i*mem5.szAtom], 0xAA, iFullSz); | |
| 274 #endif | |
| 275 | |
| 276 /* Return a pointer to the allocated memory. */ | |
| 277 return (void*)&mem5.zPool[i*mem5.szAtom]; | |
| 278 } | |
| 279 | |
| 280 /* | |
| 281 ** Free an outstanding memory allocation. | |
| 282 */ | |
| 283 static void memsys5FreeUnsafe(void *pOld){ | |
| 284 u32 size, iLogsize; | |
| 285 int iBlock; | |
| 286 | |
| 287 /* Set iBlock to the index of the block pointed to by pOld in | |
| 288 ** the array of mem5.szAtom byte blocks pointed to by mem5.zPool. | |
| 289 */ | |
| 290 iBlock = (int)(((u8 *)pOld-mem5.zPool)/mem5.szAtom); | |
| 291 | |
| 292 /* Check that the pointer pOld points to a valid, non-free block. */ | |
| 293 assert( iBlock>=0 && iBlock<mem5.nBlock ); | |
| 294 assert( ((u8 *)pOld-mem5.zPool)%mem5.szAtom==0 ); | |
| 295 assert( (mem5.aCtrl[iBlock] & CTRL_FREE)==0 ); | |
| 296 | |
| 297 iLogsize = mem5.aCtrl[iBlock] & CTRL_LOGSIZE; | |
| 298 size = 1<<iLogsize; | |
| 299 assert( iBlock+size-1<(u32)mem5.nBlock ); | |
| 300 | |
| 301 mem5.aCtrl[iBlock] |= CTRL_FREE; | |
| 302 mem5.aCtrl[iBlock+size-1] |= CTRL_FREE; | |
| 303 assert( mem5.currentCount>0 ); | |
| 304 assert( mem5.currentOut>=(size*mem5.szAtom) ); | |
| 305 mem5.currentCount--; | |
| 306 mem5.currentOut -= size*mem5.szAtom; | |
| 307 assert( mem5.currentOut>0 || mem5.currentCount==0 ); | |
| 308 assert( mem5.currentCount>0 || mem5.currentOut==0 ); | |
| 309 | |
| 310 mem5.aCtrl[iBlock] = CTRL_FREE | iLogsize; | |
| 311 while( ALWAYS(iLogsize<LOGMAX) ){ | |
| 312 int iBuddy; | |
| 313 if( (iBlock>>iLogsize) & 1 ){ | |
| 314 iBuddy = iBlock - size; | |
| 315 }else{ | |
| 316 iBuddy = iBlock + size; | |
| 317 } | |
| 318 assert( iBuddy>=0 ); | |
| 319 if( (iBuddy+(1<<iLogsize))>mem5.nBlock ) break; | |
| 320 if( mem5.aCtrl[iBuddy]!=(CTRL_FREE | iLogsize) ) break; | |
| 321 memsys5Unlink(iBuddy, iLogsize); | |
| 322 iLogsize++; | |
| 323 if( iBuddy<iBlock ){ | |
| 324 mem5.aCtrl[iBuddy] = CTRL_FREE | iLogsize; | |
| 325 mem5.aCtrl[iBlock] = 0; | |
| 326 iBlock = iBuddy; | |
| 327 }else{ | |
| 328 mem5.aCtrl[iBlock] = CTRL_FREE | iLogsize; | |
| 329 mem5.aCtrl[iBuddy] = 0; | |
| 330 } | |
| 331 size *= 2; | |
| 332 } | |
| 333 | |
| 334 #ifdef SQLITE_DEBUG | |
| 335 /* Overwrite freed memory with the 0x55 bit pattern to verify that it is | |
| 336 ** not used after being freed */ | |
| 337 memset(&mem5.zPool[iBlock*mem5.szAtom], 0x55, size); | |
| 338 #endif | |
| 339 | |
| 340 memsys5Link(iBlock, iLogsize); | |
| 341 } | |
| 342 | |
| 343 /* | |
| 344 ** Allocate nBytes of memory. | |
| 345 */ | |
| 346 static void *memsys5Malloc(int nBytes){ | |
| 347 sqlite3_int64 *p = 0; | |
| 348 if( nBytes>0 ){ | |
| 349 memsys5Enter(); | |
| 350 p = memsys5MallocUnsafe(nBytes); | |
| 351 memsys5Leave(); | |
| 352 } | |
| 353 return (void*)p; | |
| 354 } | |
| 355 | |
| 356 /* | |
| 357 ** Free memory. | |
| 358 ** | |
| 359 ** The outer layer memory allocator prevents this routine from | |
| 360 ** being called with pPrior==0. | |
| 361 */ | |
| 362 static void memsys5Free(void *pPrior){ | |
| 363 assert( pPrior!=0 ); | |
| 364 memsys5Enter(); | |
| 365 memsys5FreeUnsafe(pPrior); | |
| 366 memsys5Leave(); | |
| 367 } | |
| 368 | |
| 369 /* | |
| 370 ** Change the size of an existing memory allocation. | |
| 371 ** | |
| 372 ** The outer layer memory allocator prevents this routine from | |
| 373 ** being called with pPrior==0. | |
| 374 ** | |
| 375 ** nBytes is always a value obtained from a prior call to | |
| 376 ** memsys5Round(). Hence nBytes is always a non-negative power | |
| 377 ** of two. If nBytes==0 that means that an oversize allocation | |
| 378 ** (an allocation larger than 0x40000000) was requested and this | |
| 379 ** routine should return 0 without freeing pPrior. | |
| 380 */ | |
| 381 static void *memsys5Realloc(void *pPrior, int nBytes){ | |
| 382 int nOld; | |
| 383 void *p; | |
| 384 assert( pPrior!=0 ); | |
| 385 assert( (nBytes&(nBytes-1))==0 ); /* EV: R-46199-30249 */ | |
| 386 assert( nBytes>=0 ); | |
| 387 if( nBytes==0 ){ | |
| 388 return 0; | |
| 389 } | |
| 390 nOld = memsys5Size(pPrior); | |
| 391 if( nBytes<=nOld ){ | |
| 392 return pPrior; | |
| 393 } | |
| 394 p = memsys5Malloc(nBytes); | |
| 395 if( p ){ | |
| 396 memcpy(p, pPrior, nOld); | |
| 397 memsys5Free(pPrior); | |
| 398 } | |
| 399 return p; | |
| 400 } | |
| 401 | |
| 402 /* | |
| 403 ** Round up a request size to the next valid allocation size. If | |
| 404 ** the allocation is too large to be handled by this allocation system, | |
| 405 ** return 0. | |
| 406 ** | |
| 407 ** All allocations must be a power of two and must be expressed by a | |
| 408 ** 32-bit signed integer. Hence the largest allocation is 0x40000000 | |
| 409 ** or 1073741824 bytes. | |
| 410 */ | |
| 411 static int memsys5Roundup(int n){ | |
| 412 int iFullSz; | |
| 413 if( n > 0x40000000 ) return 0; | |
| 414 for(iFullSz=mem5.szAtom; iFullSz<n; iFullSz *= 2); | |
| 415 return iFullSz; | |
| 416 } | |
| 417 | |
| 418 /* | |
| 419 ** Return the ceiling of the logarithm base 2 of iValue. | |
| 420 ** | |
| 421 ** Examples: memsys5Log(1) -> 0 | |
| 422 ** memsys5Log(2) -> 1 | |
| 423 ** memsys5Log(4) -> 2 | |
| 424 ** memsys5Log(5) -> 3 | |
| 425 ** memsys5Log(8) -> 3 | |
| 426 ** memsys5Log(9) -> 4 | |
| 427 */ | |
| 428 static int memsys5Log(int iValue){ | |
| 429 int iLog; | |
| 430 for(iLog=0; (iLog<(int)((sizeof(int)*8)-1)) && (1<<iLog)<iValue; iLog++); | |
| 431 return iLog; | |
| 432 } | |
| 433 | |
| 434 /* | |
| 435 ** Initialize the memory allocator. | |
| 436 ** | |
| 437 ** This routine is not threadsafe. The caller must be holding a mutex | |
| 438 ** to prevent multiple threads from entering at the same time. | |
| 439 */ | |
| 440 static int memsys5Init(void *NotUsed){ | |
| 441 int ii; /* Loop counter */ | |
| 442 int nByte; /* Number of bytes of memory available to this allocator */ | |
| 443 u8 *zByte; /* Memory usable by this allocator */ | |
| 444 int nMinLog; /* Log base 2 of minimum allocation size in bytes */ | |
| 445 int iOffset; /* An offset into mem5.aCtrl[] */ | |
| 446 | |
| 447 UNUSED_PARAMETER(NotUsed); | |
| 448 | |
| 449 /* For the purposes of this routine, disable the mutex */ | |
| 450 mem5.mutex = 0; | |
| 451 | |
| 452 /* The size of a Mem5Link object must be a power of two. Verify that | |
| 453 ** this is case. | |
| 454 */ | |
| 455 assert( (sizeof(Mem5Link)&(sizeof(Mem5Link)-1))==0 ); | |
| 456 | |
| 457 nByte = sqlite3GlobalConfig.nHeap; | |
| 458 zByte = (u8*)sqlite3GlobalConfig.pHeap; | |
| 459 assert( zByte!=0 ); /* sqlite3_config() does not allow otherwise */ | |
| 460 | |
| 461 /* boundaries on sqlite3GlobalConfig.mnReq are enforced in sqlite3_config() */ | |
| 462 nMinLog = memsys5Log(sqlite3GlobalConfig.mnReq); | |
| 463 mem5.szAtom = (1<<nMinLog); | |
| 464 while( (int)sizeof(Mem5Link)>mem5.szAtom ){ | |
| 465 mem5.szAtom = mem5.szAtom << 1; | |
| 466 } | |
| 467 | |
| 468 mem5.nBlock = (nByte / (mem5.szAtom+sizeof(u8))); | |
| 469 mem5.zPool = zByte; | |
| 470 mem5.aCtrl = (u8 *)&mem5.zPool[mem5.nBlock*mem5.szAtom]; | |
| 471 | |
| 472 for(ii=0; ii<=LOGMAX; ii++){ | |
| 473 mem5.aiFreelist[ii] = -1; | |
| 474 } | |
| 475 | |
| 476 iOffset = 0; | |
| 477 for(ii=LOGMAX; ii>=0; ii--){ | |
| 478 int nAlloc = (1<<ii); | |
| 479 if( (iOffset+nAlloc)<=mem5.nBlock ){ | |
| 480 mem5.aCtrl[iOffset] = ii | CTRL_FREE; | |
| 481 memsys5Link(iOffset, ii); | |
| 482 iOffset += nAlloc; | |
| 483 } | |
| 484 assert((iOffset+nAlloc)>mem5.nBlock); | |
| 485 } | |
| 486 | |
| 487 /* If a mutex is required for normal operation, allocate one */ | |
| 488 if( sqlite3GlobalConfig.bMemstat==0 ){ | |
| 489 mem5.mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MEM); | |
| 490 } | |
| 491 | |
| 492 return SQLITE_OK; | |
| 493 } | |
| 494 | |
| 495 /* | |
| 496 ** Deinitialize this module. | |
| 497 */ | |
| 498 static void memsys5Shutdown(void *NotUsed){ | |
| 499 UNUSED_PARAMETER(NotUsed); | |
| 500 mem5.mutex = 0; | |
| 501 return; | |
| 502 } | |
| 503 | |
| 504 #ifdef SQLITE_TEST | |
| 505 /* | |
| 506 ** Open the file indicated and write a log of all unfreed memory | |
| 507 ** allocations into that log. | |
| 508 */ | |
| 509 void sqlite3Memsys5Dump(const char *zFilename){ | |
| 510 FILE *out; | |
| 511 int i, j, n; | |
| 512 int nMinLog; | |
| 513 | |
| 514 if( zFilename==0 || zFilename[0]==0 ){ | |
| 515 out = stdout; | |
| 516 }else{ | |
| 517 out = fopen(zFilename, "w"); | |
| 518 if( out==0 ){ | |
| 519 fprintf(stderr, "** Unable to output memory debug output log: %s **\n", | |
| 520 zFilename); | |
| 521 return; | |
| 522 } | |
| 523 } | |
| 524 memsys5Enter(); | |
| 525 nMinLog = memsys5Log(mem5.szAtom); | |
| 526 for(i=0; i<=LOGMAX && i+nMinLog<32; i++){ | |
| 527 for(n=0, j=mem5.aiFreelist[i]; j>=0; j = MEM5LINK(j)->next, n++){} | |
| 528 fprintf(out, "freelist items of size %d: %d\n", mem5.szAtom << i, n); | |
| 529 } | |
| 530 fprintf(out, "mem5.nAlloc = %llu\n", mem5.nAlloc); | |
| 531 fprintf(out, "mem5.totalAlloc = %llu\n", mem5.totalAlloc); | |
| 532 fprintf(out, "mem5.totalExcess = %llu\n", mem5.totalExcess); | |
| 533 fprintf(out, "mem5.currentOut = %u\n", mem5.currentOut); | |
| 534 fprintf(out, "mem5.currentCount = %u\n", mem5.currentCount); | |
| 535 fprintf(out, "mem5.maxOut = %u\n", mem5.maxOut); | |
| 536 fprintf(out, "mem5.maxCount = %u\n", mem5.maxCount); | |
| 537 fprintf(out, "mem5.maxRequest = %u\n", mem5.maxRequest); | |
| 538 memsys5Leave(); | |
| 539 if( out==stdout ){ | |
| 540 fflush(stdout); | |
| 541 }else{ | |
| 542 fclose(out); | |
| 543 } | |
| 544 } | |
| 545 #endif | |
| 546 | |
| 547 /* | |
| 548 ** This routine is the only routine in this file with external | |
| 549 ** linkage. It returns a pointer to a static sqlite3_mem_methods | |
| 550 ** struct populated with the memsys5 methods. | |
| 551 */ | |
| 552 const sqlite3_mem_methods *sqlite3MemGetMemsys5(void){ | |
| 553 static const sqlite3_mem_methods memsys5Methods = { | |
| 554 memsys5Malloc, | |
| 555 memsys5Free, | |
| 556 memsys5Realloc, | |
| 557 memsys5Size, | |
| 558 memsys5Roundup, | |
| 559 memsys5Init, | |
| 560 memsys5Shutdown, | |
| 561 0 | |
| 562 }; | |
| 563 return &memsys5Methods; | |
| 564 } | |
| 565 | |
| 566 #endif /* SQLITE_ENABLE_MEMSYS5 */ | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2846743003:
[sql] Remove SQLite 3.10.2 reference directory. (Closed)
