000001 /*
000002 ** 2007 October 14
000003 **
000004 ** The author disclaims copyright to this source code. In place of
000005 ** a legal notice, here is a blessing:
000006 **
000007 ** May you do good and not evil.
000008 ** May you find forgiveness for yourself and forgive others.
000009 ** May you share freely, never taking more than you give.
000010 **
000011 *************************************************************************
000012 ** This file contains the C functions that implement a memory
000013 ** allocation subsystem for use by SQLite.
000014 **
000015 ** This version of the memory allocation subsystem omits all
000016 ** use of malloc(). The application gives SQLite a block of memory
000017 ** before calling sqlite3_initialize() from which allocations
000018 ** are made and returned by the xMalloc() and xRealloc()
000019 ** implementations. Once sqlite3_initialize() has been called,
000020 ** the amount of memory available to SQLite is fixed and cannot
000021 ** be changed.
000022 **
000023 ** This version of the memory allocation subsystem is included
000024 ** in the build only if SQLITE_ENABLE_MEMSYS5 is defined.
000025 **
000026 ** This memory allocator uses the following algorithm:
000027 **
000028 ** 1. All memory allocation sizes are rounded up to a power of 2.
000029 **
000030 ** 2. If two adjacent free blocks are the halves of a larger block,
000031 ** then the two blocks are coalesced into the single larger block.
000032 **
000033 ** 3. New memory is allocated from the first available free block.
000034 **
000035 ** This algorithm is described in: J. M. Robson. "Bounds for Some Functions
000036 ** Concerning Dynamic Storage Allocation". Journal of the Association for
000037 ** Computing Machinery, Volume 21, Number 8, July 1974, pages 491-499.
000038 **
000039 ** Let n be the size of the largest allocation divided by the minimum
000040 ** allocation size (after rounding all sizes up to a power of 2.) Let M
000041 ** be the maximum amount of memory ever outstanding at one time. Let
000042 ** N be the total amount of memory available for allocation. Robson
000043 ** proved that this memory allocator will never breakdown due to
000044 ** fragmentation as long as the following constraint holds:
000045 **
000046 ** N >= M*(1 + log2(n)/2) - n + 1
000047 **
000048 ** The sqlite3_status() logic tracks the maximum values of n and M so
000049 ** that an application can, at any time, verify this constraint.
000050 */
000051 #include "sqliteInt.h"
000052
000053 /*
000054 ** This version of the memory allocator is used only when
000055 ** SQLITE_ENABLE_MEMSYS5 is defined.
000056 */
000057 #ifdef SQLITE_ENABLE_MEMSYS5
000058
000059 /*
000060 ** A minimum allocation is an instance of the following structure.
000061 ** Larger allocations are an array of these structures where the
000062 ** size of the array is a power of 2.
000063 **
000064 ** The size of this object must be a power of two. That fact is
000065 ** verified in memsys5Init().
000066 */
000067 typedef struct Mem5Link Mem5Link;
000068 struct Mem5Link {
000069 int next; /* Index of next free chunk */
000070 int prev; /* Index of previous free chunk */
000071 };
000072
000073 /*
000074 ** Maximum size of any allocation is ((1<<LOGMAX)*mem5.szAtom). Since
000075 ** mem5.szAtom is always at least 8 and 32-bit integers are used,
000076 ** it is not actually possible to reach this limit.
000077 */
000078 #define LOGMAX 30
000079
000080 /*
000081 ** Masks used for mem5.aCtrl[] elements.
000082 */
000083 #define CTRL_LOGSIZE 0x1f /* Log2 Size of this block */
000084 #define CTRL_FREE 0x20 /* True if not checked out */
000085
000086 /*
000087 ** All of the static variables used by this module are collected
000088 ** into a single structure named "mem5". This is to keep the
000089 ** static variables organized and to reduce namespace pollution
000090 ** when this module is combined with other in the amalgamation.
000091 */
000092 static SQLITE_WSD struct Mem5Global {
000093 /*
000094 ** Memory available for allocation
000095 */
000096 int szAtom; /* Smallest possible allocation in bytes */
000097 int nBlock; /* Number of szAtom sized blocks in zPool */
000098 u8 *zPool; /* Memory available to be allocated */
000099
000100 /*
000101 ** Mutex to control access to the memory allocation subsystem.
000102 */
000103 sqlite3_mutex *mutex;
000104
000105 #if defined(SQLITE_DEBUG) || defined(SQLITE_TEST)
000106 /*
000107 ** Performance statistics
000108 */
000109 u64 nAlloc; /* Total number of calls to malloc */
000110 u64 totalAlloc; /* Total of all malloc calls - includes internal frag */
000111 u64 totalExcess; /* Total internal fragmentation */
000112 u32 currentOut; /* Current checkout, including internal fragmentation */
000113 u32 currentCount; /* Current number of distinct checkouts */
000114 u32 maxOut; /* Maximum instantaneous currentOut */
000115 u32 maxCount; /* Maximum instantaneous currentCount */
000116 u32 maxRequest; /* Largest allocation (exclusive of internal frag) */
000117 #endif
000118
000119 /*
000120 ** Lists of free blocks. aiFreelist[0] is a list of free blocks of
000121 ** size mem5.szAtom. aiFreelist[1] holds blocks of size szAtom*2.
000122 ** aiFreelist[2] holds free blocks of size szAtom*4. And so forth.
000123 */
000124 int aiFreelist[LOGMAX+1];
000125
000126 /*
000127 ** Space for tracking which blocks are checked out and the size
000128 ** of each block. One byte per block.
000129 */
000130 u8 *aCtrl;
000131
000132 } mem5;
000133
000134 /*
000135 ** Access the static variable through a macro for SQLITE_OMIT_WSD.
000136 */
000137 #define mem5 GLOBAL(struct Mem5Global, mem5)
000138
000139 /*
000140 ** Assuming mem5.zPool is divided up into an array of Mem5Link
000141 ** structures, return a pointer to the idx-th such link.
000142 */
000143 #define MEM5LINK(idx) ((Mem5Link *)(&mem5.zPool[(idx)*mem5.szAtom]))
000144
000145 /*
000146 ** Unlink the chunk at mem5.aPool[i] from list it is currently
000147 ** on. It should be found on mem5.aiFreelist[iLogsize].
000148 */
000149 static void memsys5Unlink(int i, int iLogsize){
000150 int next, prev;
000151 assert( i>=0 && i<mem5.nBlock );
000152 assert( iLogsize>=0 && iLogsize<=LOGMAX );
000153 assert( (mem5.aCtrl[i] & CTRL_LOGSIZE)==iLogsize );
000154
000155 next = MEM5LINK(i)->next;
000156 prev = MEM5LINK(i)->prev;
000157 if( prev<0 ){
000158 mem5.aiFreelist[iLogsize] = next;
000159 }else{
000160 MEM5LINK(prev)->next = next;
000161 }
000162 if( next>=0 ){
000163 MEM5LINK(next)->prev = prev;
000164 }
000165 }
000166
000167 /*
000168 ** Link the chunk at mem5.aPool[i] so that is on the iLogsize
000169 ** free list.
000170 */
000171 static void memsys5Link(int i, int iLogsize){
000172 int x;
000173 assert( sqlite3_mutex_held(mem5.mutex) );
000174 assert( i>=0 && i<mem5.nBlock );
000175 assert( iLogsize>=0 && iLogsize<=LOGMAX );
000176 assert( (mem5.aCtrl[i] & CTRL_LOGSIZE)==iLogsize );
000177
000178 x = MEM5LINK(i)->next = mem5.aiFreelist[iLogsize];
000179 MEM5LINK(i)->prev = -1;
000180 if( x>=0 ){
000181 assert( x<mem5.nBlock );
000182 MEM5LINK(x)->prev = i;
000183 }
000184 mem5.aiFreelist[iLogsize] = i;
000185 }
000186
000187 /*
000188 ** Obtain or release the mutex needed to access global data structures.
000189 */
000190 static void memsys5Enter(void){
000191 sqlite3_mutex_enter(mem5.mutex);
000192 }
000193 static void memsys5Leave(void){
000194 sqlite3_mutex_leave(mem5.mutex);
000195 }
000196
000197 /*
000198 ** Return the size of an outstanding allocation, in bytes.
000199 ** This only works for chunks that are currently checked out.
000200 */
000201 static int memsys5Size(void *p){
000202 int iSize, i;
000203 assert( p!=0 );
000204 i = (int)(((u8 *)p-mem5.zPool)/mem5.szAtom);
000205 assert( i>=0 && i<mem5.nBlock );
000206 iSize = mem5.szAtom * (1 << (mem5.aCtrl[i]&CTRL_LOGSIZE));
000207 return iSize;
000208 }
000209
000210 /*
000211 ** Return a block of memory of at least nBytes in size.
000212 ** Return NULL if unable. Return NULL if nBytes==0.
000213 **
000214 ** The caller guarantees that nByte is positive.
000215 **
000216 ** The caller has obtained a mutex prior to invoking this
000217 ** routine so there is never any chance that two or more
000218 ** threads can be in this routine at the same time.
000219 */
000220 static void *memsys5MallocUnsafe(int nByte){
000221 int i; /* Index of a mem5.aPool[] slot */
000222 int iBin; /* Index into mem5.aiFreelist[] */
000223 int iFullSz; /* Size of allocation rounded up to power of 2 */
000224 int iLogsize; /* Log2 of iFullSz/POW2_MIN */
000225
000226 /* nByte must be a positive */
000227 assert( nByte>0 );
000228
000229 /* No more than 1GiB per allocation */
000230 if( nByte > 0x40000000 ) return 0;
000231
000232 #if defined(SQLITE_DEBUG) || defined(SQLITE_TEST)
000233 /* Keep track of the maximum allocation request. Even unfulfilled
000234 ** requests are counted */
000235 if( (u32)nByte>mem5.maxRequest ){
000236 mem5.maxRequest = nByte;
000237 }
000238 #endif
000239
000240
000241 /* Round nByte up to the next valid power of two */
000242 for(iFullSz=mem5.szAtom,iLogsize=0; iFullSz<nByte; iFullSz*=2,iLogsize++){}
000243
000244 /* Make sure mem5.aiFreelist[iLogsize] contains at least one free
000245 ** block. If not, then split a block of the next larger power of
000246 ** two in order to create a new free block of size iLogsize.
000247 */
000248 for(iBin=iLogsize; iBin<=LOGMAX && mem5.aiFreelist[iBin]<0; iBin++){}
000249 if( iBin>LOGMAX ){
000250 testcase( sqlite3GlobalConfig.xLog!=0 );
000251 sqlite3_log(SQLITE_NOMEM, "failed to allocate %u bytes", nByte);
000252 return 0;
000253 }
000254 i = mem5.aiFreelist[iBin];
000255 memsys5Unlink(i, iBin);
000256 while( iBin>iLogsize ){
000257 int newSize;
000258
000259 iBin--;
000260 newSize = 1 << iBin;
000261 mem5.aCtrl[i+newSize] = CTRL_FREE | iBin;
000262 memsys5Link(i+newSize, iBin);
000263 }
000264 mem5.aCtrl[i] = iLogsize;
000265
000266 #if defined(SQLITE_DEBUG) || defined(SQLITE_TEST)
000267 /* Update allocator performance statistics. */
000268 mem5.nAlloc++;
000269 mem5.totalAlloc += iFullSz;
000270 mem5.totalExcess += iFullSz - nByte;
000271 mem5.currentCount++;
000272 mem5.currentOut += iFullSz;
000273 if( mem5.maxCount<mem5.currentCount ) mem5.maxCount = mem5.currentCount;
000274 if( mem5.maxOut<mem5.currentOut ) mem5.maxOut = mem5.currentOut;
000275 #endif
000276
000277 #ifdef SQLITE_DEBUG
000278 /* Make sure the allocated memory does not assume that it is set to zero
000279 ** or retains a value from a previous allocation */
000280 memset(&mem5.zPool[i*mem5.szAtom], 0xAA, iFullSz);
000281 #endif
000282
000283 /* Return a pointer to the allocated memory. */
000284 return (void*)&mem5.zPool[i*mem5.szAtom];
000285 }
000286
000287 /*
000288 ** Free an outstanding memory allocation.
000289 */
000290 static void memsys5FreeUnsafe(void *pOld){
000291 u32 size, iLogsize;
000292 int iBlock;
000293
000294 /* Set iBlock to the index of the block pointed to by pOld in
000295 ** the array of mem5.szAtom byte blocks pointed to by mem5.zPool.
000296 */
000297 iBlock = (int)(((u8 *)pOld-mem5.zPool)/mem5.szAtom);
000298
000299 /* Check that the pointer pOld points to a valid, non-free block. */
000300 assert( iBlock>=0 && iBlock<mem5.nBlock );
000301 assert( ((u8 *)pOld-mem5.zPool)%mem5.szAtom==0 );
000302 assert( (mem5.aCtrl[iBlock] & CTRL_FREE)==0 );
000303
000304 iLogsize = mem5.aCtrl[iBlock] & CTRL_LOGSIZE;
000305 size = 1<<iLogsize;
000306 assert( iBlock+size-1<(u32)mem5.nBlock );
000307
000308 mem5.aCtrl[iBlock] |= CTRL_FREE;
000309 mem5.aCtrl[iBlock+size-1] |= CTRL_FREE;
000310
000311 #if defined(SQLITE_DEBUG) || defined(SQLITE_TEST)
000312 assert( mem5.currentCount>0 );
000313 assert( mem5.currentOut>=(size*mem5.szAtom) );
000314 mem5.currentCount--;
000315 mem5.currentOut -= size*mem5.szAtom;
000316 assert( mem5.currentOut>0 || mem5.currentCount==0 );
000317 assert( mem5.currentCount>0 || mem5.currentOut==0 );
000318 #endif
000319
000320 mem5.aCtrl[iBlock] = CTRL_FREE | iLogsize;
000321 while( ALWAYS(iLogsize<LOGMAX) ){
000322 int iBuddy;
000323 if( (iBlock>>iLogsize) & 1 ){
000324 iBuddy = iBlock - size;
000325 assert( iBuddy>=0 );
000326 }else{
000327 iBuddy = iBlock + size;
000328 if( iBuddy>=mem5.nBlock ) break;
000329 }
000330 if( mem5.aCtrl[iBuddy]!=(CTRL_FREE | iLogsize) ) break;
000331 memsys5Unlink(iBuddy, iLogsize);
000332 iLogsize++;
000333 if( iBuddy<iBlock ){
000334 mem5.aCtrl[iBuddy] = CTRL_FREE | iLogsize;
000335 mem5.aCtrl[iBlock] = 0;
000336 iBlock = iBuddy;
000337 }else{
000338 mem5.aCtrl[iBlock] = CTRL_FREE | iLogsize;
000339 mem5.aCtrl[iBuddy] = 0;
000340 }
000341 size *= 2;
000342 }
000343
000344 #ifdef SQLITE_DEBUG
000345 /* Overwrite freed memory with the 0x55 bit pattern to verify that it is
000346 ** not used after being freed */
000347 memset(&mem5.zPool[iBlock*mem5.szAtom], 0x55, size);
000348 #endif
000349
000350 memsys5Link(iBlock, iLogsize);
000351 }
000352
000353 /*
000354 ** Allocate nBytes of memory.
000355 */
000356 static void *memsys5Malloc(int nBytes){
000357 sqlite3_int64 *p = 0;
000358 if( nBytes>0 ){
000359 memsys5Enter();
000360 p = memsys5MallocUnsafe(nBytes);
000361 memsys5Leave();
000362 }
000363 return (void*)p;
000364 }
000365
000366 /*
000367 ** Free memory.
000368 **
000369 ** The outer layer memory allocator prevents this routine from
000370 ** being called with pPrior==0.
000371 */
000372 static void memsys5Free(void *pPrior){
000373 assert( pPrior!=0 );
000374 memsys5Enter();
000375 memsys5FreeUnsafe(pPrior);
000376 memsys5Leave();
000377 }
000378
000379 /*
000380 ** Change the size of an existing memory allocation.
000381 **
000382 ** The outer layer memory allocator prevents this routine from
000383 ** being called with pPrior==0.
000384 **
000385 ** nBytes is always a value obtained from a prior call to
000386 ** memsys5Round(). Hence nBytes is always a non-negative power
000387 ** of two. If nBytes==0 that means that an oversize allocation
000388 ** (an allocation larger than 0x40000000) was requested and this
000389 ** routine should return 0 without freeing pPrior.
000390 */
000391 static void *memsys5Realloc(void *pPrior, int nBytes){
000392 int nOld;
000393 void *p;
000394 assert( pPrior!=0 );
000395 assert( (nBytes&(nBytes-1))==0 ); /* EV: R-46199-30249 */
000396 assert( nBytes>=0 );
000397 if( nBytes==0 ){
000398 return 0;
000399 }
000400 nOld = memsys5Size(pPrior);
000401 if( nBytes<=nOld ){
000402 return pPrior;
000403 }
000404 p = memsys5Malloc(nBytes);
000405 if( p ){
000406 memcpy(p, pPrior, nOld);
000407 memsys5Free(pPrior);
000408 }
000409 return p;
000410 }
000411
000412 /*
000413 ** Round up a request size to the next valid allocation size. If
000414 ** the allocation is too large to be handled by this allocation system,
000415 ** return 0.
000416 **
000417 ** All allocations must be a power of two and must be expressed by a
000418 ** 32-bit signed integer. Hence the largest allocation is 0x40000000
000419 ** or 1073741824 bytes.
000420 */
000421 static int memsys5Roundup(int n){
000422 int iFullSz;
000423 if( n > 0x40000000 ) return 0;
000424 for(iFullSz=mem5.szAtom; iFullSz<n; iFullSz *= 2);
000425 return iFullSz;
000426 }
000427
000428 /*
000429 ** Return the ceiling of the logarithm base 2 of iValue.
000430 **
000431 ** Examples: memsys5Log(1) -> 0
000432 ** memsys5Log(2) -> 1
000433 ** memsys5Log(4) -> 2
000434 ** memsys5Log(5) -> 3
000435 ** memsys5Log(8) -> 3
000436 ** memsys5Log(9) -> 4
000437 */
000438 static int memsys5Log(int iValue){
000439 int iLog;
000440 for(iLog=0; (iLog<(int)((sizeof(int)*8)-1)) && (1<<iLog)<iValue; iLog++);
000441 return iLog;
000442 }
000443
000444 /*
000445 ** Initialize the memory allocator.
000446 **
000447 ** This routine is not threadsafe. The caller must be holding a mutex
000448 ** to prevent multiple threads from entering at the same time.
000449 */
000450 static int memsys5Init(void *NotUsed){
000451 int ii; /* Loop counter */
000452 int nByte; /* Number of bytes of memory available to this allocator */
000453 u8 *zByte; /* Memory usable by this allocator */
000454 int nMinLog; /* Log base 2 of minimum allocation size in bytes */
000455 int iOffset; /* An offset into mem5.aCtrl[] */
000456
000457 UNUSED_PARAMETER(NotUsed);
000458
000459 /* For the purposes of this routine, disable the mutex */
000460 mem5.mutex = 0;
000461
000462 /* The size of a Mem5Link object must be a power of two. Verify that
000463 ** this is case.
000464 */
000465 assert( (sizeof(Mem5Link)&(sizeof(Mem5Link)-1))==0 );
000466
000467 nByte = sqlite3GlobalConfig.nHeap;
000468 zByte = (u8*)sqlite3GlobalConfig.pHeap;
000469 assert( zByte!=0 ); /* sqlite3_config() does not allow otherwise */
000470
000471 /* boundaries on sqlite3GlobalConfig.mnReq are enforced in sqlite3_config() */
000472 nMinLog = memsys5Log(sqlite3GlobalConfig.mnReq);
000473 mem5.szAtom = (1<<nMinLog);
000474 while( (int)sizeof(Mem5Link)>mem5.szAtom ){
000475 mem5.szAtom = mem5.szAtom << 1;
000476 }
000477
000478 mem5.nBlock = (nByte / (mem5.szAtom+sizeof(u8)));
000479 mem5.zPool = zByte;
000480 mem5.aCtrl = (u8 *)&mem5.zPool[mem5.nBlock*mem5.szAtom];
000481
000482 for(ii=0; ii<=LOGMAX; ii++){
000483 mem5.aiFreelist[ii] = -1;
000484 }
000485
000486 iOffset = 0;
000487 for(ii=LOGMAX; ii>=0; ii--){
000488 int nAlloc = (1<<ii);
000489 if( (iOffset+nAlloc)<=mem5.nBlock ){
000490 mem5.aCtrl[iOffset] = ii | CTRL_FREE;
000491 memsys5Link(iOffset, ii);
000492 iOffset += nAlloc;
000493 }
000494 assert((iOffset+nAlloc)>mem5.nBlock);
000495 }
000496
000497 /* If a mutex is required for normal operation, allocate one */
000498 if( sqlite3GlobalConfig.bMemstat==0 ){
000499 mem5.mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MEM);
000500 }
000501
000502 return SQLITE_OK;
000503 }
000504
000505 /*
000506 ** Deinitialize this module.
000507 */
000508 static void memsys5Shutdown(void *NotUsed){
000509 UNUSED_PARAMETER(NotUsed);
000510 mem5.mutex = 0;
000511 return;
000512 }
000513
000514 #ifdef SQLITE_TEST
000515 /*
000516 ** Open the file indicated and write a log of all unfreed memory
000517 ** allocations into that log.
000518 */
000519 void sqlite3Memsys5Dump(const char *zFilename){
000520 FILE *out;
000521 int i, j, n;
000522 int nMinLog;
000523
000524 if( zFilename==0 || zFilename[0]==0 ){
000525 out = stdout;
000526 }else{
000527 out = fopen(zFilename, "w");
000528 if( out==0 ){
000529 fprintf(stderr, "** Unable to output memory debug output log: %s **\n",
000530 zFilename);
000531 return;
000532 }
000533 }
000534 memsys5Enter();
000535 nMinLog = memsys5Log(mem5.szAtom);
000536 for(i=0; i<=LOGMAX && i+nMinLog<32; i++){
000537 for(n=0, j=mem5.aiFreelist[i]; j>=0; j = MEM5LINK(j)->next, n++){}
000538 fprintf(out, "freelist items of size %d: %d\n", mem5.szAtom << i, n);
000539 }
000540 fprintf(out, "mem5.nAlloc = %llu\n", mem5.nAlloc);
000541 fprintf(out, "mem5.totalAlloc = %llu\n", mem5.totalAlloc);
000542 fprintf(out, "mem5.totalExcess = %llu\n", mem5.totalExcess);
000543 fprintf(out, "mem5.currentOut = %u\n", mem5.currentOut);
000544 fprintf(out, "mem5.currentCount = %u\n", mem5.currentCount);
000545 fprintf(out, "mem5.maxOut = %u\n", mem5.maxOut);
000546 fprintf(out, "mem5.maxCount = %u\n", mem5.maxCount);
000547 fprintf(out, "mem5.maxRequest = %u\n", mem5.maxRequest);
000548 memsys5Leave();
000549 if( out==stdout ){
000550 fflush(stdout);
000551 }else{
000552 fclose(out);
000553 }
000554 }
000555 #endif
000556
000557 /*
000558 ** This routine is the only routine in this file with external
000559 ** linkage. It returns a pointer to a static sqlite3_mem_methods
000560 ** struct populated with the memsys5 methods.
000561 */
000562 const sqlite3_mem_methods *sqlite3MemGetMemsys5(void){
000563 static const sqlite3_mem_methods memsys5Methods = {
000564 memsys5Malloc,
000565 memsys5Free,
000566 memsys5Realloc,
000567 memsys5Size,
000568 memsys5Roundup,
000569 memsys5Init,
000570 memsys5Shutdown,
000571 0
000572 };
000573 return &memsys5Methods;
000574 }
000575
000576 #endif /* SQLITE_ENABLE_MEMSYS5 */