third_party/sqlite/sqlite-src-3080704/src/mem5.c

   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 allocations 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   ** 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 ** If the STATIC_MEM mutex is not already held, obtain it now. The mutex
 187 ** will already be held (obtained by code in malloc.c) if
 188 ** sqlite3GlobalConfig.bMemStat is true.
 189 */
 190 static void memsys5Enter(void){
 191   sqlite3_mutex_enter(mem5.mutex);
 192 }
 193 static void memsys5Leave(void){
 194   sqlite3_mutex_leave(mem5.mutex);
 195 }
 196
 197 /*
 198 ** Return the size of an outstanding allocation, in bytes.  The
 199 ** size returned omits the 8-byte header overhead.  This only
 200 ** works for chunks that are currently checked out.
 201 */
 202 static int memsys5Size(void *p){
 203   int iSize = 0;
 204   if( p ){
 205     int i = (int)(((u8 *)p-mem5.zPool)/mem5.szAtom);
 206     assert( i>=0 && i<mem5.nBlock );
 207     iSize = mem5.szAtom * (1 << (mem5.aCtrl[i]&CTRL_LOGSIZE));
 208   }
 209   return iSize;
 210 }
 211
 212 /*
 213 ** Return a block of memory of at least nBytes in size.
 214 ** Return NULL if unable.  Return NULL if nBytes==0.
 215 **
 216 ** The caller guarantees that nByte is positive.
 217 **
 218 ** The caller has obtained a mutex prior to invoking this
 219 ** routine so there is never any chance that two or more
 220 ** threads can be in this routine at the same time.
 221 */
 222 static void *memsys5MallocUnsafe(int nByte){
 223   int i;           /* Index of a mem5.aPool[] slot */
 224   int iBin;        /* Index into mem5.aiFreelist[] */
 225   int iFullSz;     /* Size of allocation rounded up to power of 2 */
 226   int iLogsize;    /* Log2 of iFullSz/POW2_MIN */
 227
 228   /* nByte must be a positive */
 229   assert( nByte>0 );
 230
 231   /* Keep track of the maximum allocation request.  Even unfulfilled
 232   ** requests are counted */
 233   if( (u32)nByte>mem5.maxRequest ){
 234     mem5.maxRequest = nByte;
 235   }
 236
 237   /* Abort if the requested allocation size is larger than the largest
 238   ** power of two that we can represent using 32-bit signed integers.
 239   */
 240   if( nByte > 0x40000000 ){
 241     return 0;
 242   }
 243
 244   /* Round nByte up to the next valid power of two */
 245   for(iFullSz=mem5.szAtom, iLogsize=0; iFullSz<nByte; iFullSz *= 2, iLogsize++){}
 246
 247   /* Make sure mem5.aiFreelist[iLogsize] contains at least one free
 248   ** block.  If not, then split a block of the next larger power of
 249   ** two in order to create a new free block of size iLogsize.
 250   */
 251   for(iBin=iLogsize; iBin<=LOGMAX && mem5.aiFreelist[iBin]<0; iBin++){}
 252   if( iBin>LOGMAX ){
 253     testcase( sqlite3GlobalConfig.xLog!=0 );
 254     sqlite3_log(SQLITE_NOMEM, "failed to allocate %u bytes", nByte);
 255     return 0;
 256   }
 257   i = mem5.aiFreelist[iBin];
 258   memsys5Unlink(i, iBin);
 259   while( iBin>iLogsize ){
 260     int newSize;
 261
 262     iBin--;
 263     newSize = 1 << iBin;
 264     mem5.aCtrl[i+newSize] = CTRL_FREE | iBin;
 265     memsys5Link(i+newSize, iBin);
 266   }
 267   mem5.aCtrl[i] = iLogsize;
 268
 269   /* Update allocator performance statistics. */
 270   mem5.nAlloc++;
 271   mem5.totalAlloc += iFullSz;
 272   mem5.totalExcess += iFullSz - nByte;
 273   mem5.currentCount++;
 274   mem5.currentOut += iFullSz;
 275   if( mem5.maxCount<mem5.currentCount ) mem5.maxCount = mem5.currentCount;
 276   if( mem5.maxOut<mem5.currentOut ) mem5.maxOut = mem5.currentOut;
 277
 278 #ifdef SQLITE_DEBUG
 279   /* Make sure the allocated memory does not assume that it is set to zero
 280   ** or retains a value from a previous allocation */
 281   memset(&mem5.zPool[i*mem5.szAtom], 0xAA, iFullSz);
 282 #endif
 283
 284   /* Return a pointer to the allocated memory. */
 285   return (void*)&mem5.zPool[i*mem5.szAtom];
 286 }
 287
 288 /*
 289 ** Free an outstanding memory allocation.
 290 */
 291 static void memsys5FreeUnsafe(void *pOld){
 292   u32 size, iLogsize;
 293   int iBlock;
 294
 295   /* Set iBlock to the index of the block pointed to by pOld in
 296   ** the array of mem5.szAtom byte blocks pointed to by mem5.zPool.
 297   */
 298   iBlock = (int)(((u8 *)pOld-mem5.zPool)/mem5.szAtom);
 299
 300   /* Check that the pointer pOld points to a valid, non-free block. */
 301   assert( iBlock>=0 && iBlock<mem5.nBlock );
 302   assert( ((u8 *)pOld-mem5.zPool)%mem5.szAtom==0 );
 303   assert( (mem5.aCtrl[iBlock] & CTRL_FREE)==0 );
 304
 305   iLogsize = mem5.aCtrl[iBlock] & CTRL_LOGSIZE;
 306   size = 1<<iLogsize;
 307   assert( iBlock+size-1<(u32)mem5.nBlock );
 308
 309   mem5.aCtrl[iBlock] |= CTRL_FREE;
 310   mem5.aCtrl[iBlock+size-1] |= CTRL_FREE;
 311   assert( mem5.currentCount>0 );
 312   assert( mem5.currentOut>=(size*mem5.szAtom) );
 313   mem5.currentCount--;
 314   mem5.currentOut -= size*mem5.szAtom;
 315   assert( mem5.currentOut>0 || mem5.currentCount==0 );
 316   assert( mem5.currentCount>0 || mem5.currentOut==0 );
 317
 318   mem5.aCtrl[iBlock] = CTRL_FREE | iLogsize;
 319   while( ALWAYS(iLogsize<LOGMAX) ){
 320     int iBuddy;
 321     if( (iBlock>>iLogsize) & 1 ){
 322       iBuddy = iBlock - size;
 323     }else{
 324       iBuddy = iBlock + size;
 325     }
 326     assert( iBuddy>=0 );
 327     if( (iBuddy+(1<<iLogsize))>mem5.nBlock ) break;
 328     if( mem5.aCtrl[iBuddy]!=(CTRL_FREE | iLogsize) ) break;
 329     memsys5Unlink(iBuddy, iLogsize);
 330     iLogsize++;
 331     if( iBuddy<iBlock ){
 332       mem5.aCtrl[iBuddy] = CTRL_FREE | iLogsize;
 333       mem5.aCtrl[iBlock] = 0;
 334       iBlock = iBuddy;
 335     }else{
 336       mem5.aCtrl[iBlock] = CTRL_FREE | iLogsize;
 337       mem5.aCtrl[iBuddy] = 0;
 338     }
 339     size *= 2;
 340   }
 341
 342 #ifdef SQLITE_DEBUG
 343   /* Overwrite freed memory with the 0x55 bit pattern to verify that it is
 344   ** not used after being freed */
 345   memset(&mem5.zPool[iBlock*mem5.szAtom], 0x55, size);
 346 #endif
 347
 348   memsys5Link(iBlock, iLogsize);
 349 }
 350
 351 /*
 352 ** Allocate nBytes of memory.
 353 */
 354 static void *memsys5Malloc(int nBytes){
 355   sqlite3_int64 *p = 0;
 356   if( nBytes>0 ){
 357     memsys5Enter();
 358     p = memsys5MallocUnsafe(nBytes);
 359     memsys5Leave();
 360   }
 361   return (void*)p;
 362 }
 363
 364 /*
 365 ** Free memory.
 366 **
 367 ** The outer layer memory allocator prevents this routine from
 368 ** being called with pPrior==0.
 369 */
 370 static void memsys5Free(void *pPrior){
 371   assert( pPrior!=0 );
 372   memsys5Enter();
 373   memsys5FreeUnsafe(pPrior);
 374   memsys5Leave();
 375 }
 376
 377 /*
 378 ** Change the size of an existing memory allocation.
 379 **
 380 ** The outer layer memory allocator prevents this routine from
 381 ** being called with pPrior==0.
 382 **
 383 ** nBytes is always a value obtained from a prior call to
 384 ** memsys5Round().  Hence nBytes is always a non-negative power
 385 ** of two.  If nBytes==0 that means that an oversize allocation
 386 ** (an allocation larger than 0x40000000) was requested and this
 387 ** routine should return 0 without freeing pPrior.
 388 */
 389 static void *memsys5Realloc(void *pPrior, int nBytes){
 390   int nOld;
 391   void *p;
 392   assert( pPrior!=0 );
 393   assert( (nBytes&(nBytes-1))==0 );  /* EV: R-46199-30249 */
 394   assert( nBytes>=0 );
 395   if( nBytes==0 ){
 396     return 0;
 397   }
 398   nOld = memsys5Size(pPrior);
 399   if( nBytes<=nOld ){
 400     return pPrior;
 401   }
 402   memsys5Enter();
 403   p = memsys5MallocUnsafe(nBytes);
 404   if( p ){
 405     memcpy(p, pPrior, nOld);
 406     memsys5FreeUnsafe(pPrior);
 407   }
 408   memsys5Leave();
 409   return p;
 410 }
 411
 412 /*
 413 ** Round up a request size to the next valid allocation size.  If
 414 ** the allocation is too large to be handled by this allocation system,
 415 ** return 0.
 416 **
 417 ** All allocations must be a power of two and must be expressed by a
 418 ** 32-bit signed integer.  Hence the largest allocation is 0x40000000
 419 ** or 1073741824 bytes.
 420 */
 421 static int memsys5Roundup(int n){
 422   int iFullSz;
 423   if( n > 0x40000000 ) return 0;
 424   for(iFullSz=mem5.szAtom; iFullSz<n; iFullSz *= 2);
 425   return iFullSz;
 426 }
 427
 428 /*
 429 ** Return the ceiling of the logarithm base 2 of iValue.
 430 **
 431 ** Examples:   memsys5Log(1) -> 0
 432 **             memsys5Log(2) -> 1
 433 **             memsys5Log(4) -> 2
 434 **             memsys5Log(5) -> 3
 435 **             memsys5Log(8) -> 3
 436 **             memsys5Log(9) -> 4
 437 */
 438 static int memsys5Log(int iValue){
 439   int iLog;
 440   for(iLog=0; (iLog<(int)((sizeof(int)*8)-1)) && (1<<iLog)<iValue; iLog++);
 441   return iLog;
 442 }
 443
 444 /*
 445 ** Initialize the memory allocator.
 446 **
 447 ** This routine is not threadsafe.  The caller must be holding a mutex
 448 ** to prevent multiple threads from entering at the same time.
 449 */
 450 static int memsys5Init(void *NotUsed){
 451   int ii;            /* Loop counter */
 452   int nByte;         /* Number of bytes of memory available to this allocator */
 453   u8 *zByte;         /* Memory usable by this allocator */
 454   int nMinLog;       /* Log base 2 of minimum allocation size in bytes */
 455   int iOffset;       /* An offset into mem5.aCtrl[] */
 456
 457   UNUSED_PARAMETER(NotUsed);
 458
 459   /* For the purposes of this routine, disable the mutex */
 460   mem5.mutex = 0;
 461
 462   /* The size of a Mem5Link object must be a power of two.  Verify that
 463   ** this is case.
 464   */
 465   assert( (sizeof(Mem5Link)&(sizeof(Mem5Link)-1))==0 );
 466
 467   nByte = sqlite3GlobalConfig.nHeap;
 468   zByte = (u8*)sqlite3GlobalConfig.pHeap;
 469   assert( zByte!=0 );  /* sqlite3_config() does not allow otherwise */
 470
 471   /* boundaries on sqlite3GlobalConfig.mnReq are enforced in sqlite3_config() */
 472   nMinLog = memsys5Log(sqlite3GlobalConfig.mnReq);
 473   mem5.szAtom = (1<<nMinLog);
 474   while( (int)sizeof(Mem5Link)>mem5.szAtom ){
 475     mem5.szAtom = mem5.szAtom << 1;
 476   }
 477
 478   mem5.nBlock = (nByte / (mem5.szAtom+sizeof(u8)));
 479   mem5.zPool = zByte;
 480   mem5.aCtrl = (u8 *)&mem5.zPool[mem5.nBlock*mem5.szAtom];
 481
 482   for(ii=0; ii<=LOGMAX; ii++){
 483     mem5.aiFreelist[ii] = -1;
 484   }
 485
 486   iOffset = 0;
 487   for(ii=LOGMAX; ii>=0; ii--){
 488     int nAlloc = (1<<ii);
 489     if( (iOffset+nAlloc)<=mem5.nBlock ){
 490       mem5.aCtrl[iOffset] = ii | CTRL_FREE;
 491       memsys5Link(iOffset, ii);
 492       iOffset += nAlloc;
 493     }
 494     assert((iOffset+nAlloc)>mem5.nBlock);
 495   }
 496
 497   /* If a mutex is required for normal operation, allocate one */
 498   if( sqlite3GlobalConfig.bMemstat==0 ){
 499     mem5.mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MEM);
 500   }
 501
 502   return SQLITE_OK;
 503 }
 504
 505 /*
 506 ** Deinitialize this module.
 507 */
 508 static void memsys5Shutdown(void *NotUsed){
 509   UNUSED_PARAMETER(NotUsed);
 510   mem5.mutex = 0;
 511   return;
 512 }
 513
 514 #ifdef SQLITE_TEST
 515 /*
 516 ** Open the file indicated and write a log of all unfreed memory
 517 ** allocations into that log.
 518 */
 519 void sqlite3Memsys5Dump(const char *zFilename){
 520   FILE *out;
 521   int i, j, n;
 522   int nMinLog;
 523
 524   if( zFilename==0 || zFilename[0]==0 ){
 525     out = stdout;
 526   }else{
 527     out = fopen(zFilename, "w");
 528     if( out==0 ){
 529       fprintf(stderr, "** Unable to output memory debug output log: %s **\n",
 530                       zFilename);
 531       return;
 532     }
 533   }
 534   memsys5Enter();
 535   nMinLog = memsys5Log(mem5.szAtom);
 536   for(i=0; i<=LOGMAX && i+nMinLog<32; i++){
 537     for(n=0, j=mem5.aiFreelist[i]; j>=0; j = MEM5LINK(j)->next, n++){}
 538     fprintf(out, "freelist items of size %d: %d\n", mem5.szAtom << i, n);
 539   }
 540   fprintf(out, "mem5.nAlloc       = %llu\n", mem5.nAlloc);
 541   fprintf(out, "mem5.totalAlloc   = %llu\n", mem5.totalAlloc);
 542   fprintf(out, "mem5.totalExcess  = %llu\n", mem5.totalExcess);
 543   fprintf(out, "mem5.currentOut   = %u\n", mem5.currentOut);
 544   fprintf(out, "mem5.currentCount = %u\n", mem5.currentCount);
 545   fprintf(out, "mem5.maxOut       = %u\n", mem5.maxOut);
 546   fprintf(out, "mem5.maxCount     = %u\n", mem5.maxCount);
 547   fprintf(out, "mem5.maxRequest   = %u\n", mem5.maxRequest);
 548   memsys5Leave();
 549   if( out==stdout ){
 550     fflush(stdout);
 551   }else{
 552     fclose(out);
 553   }
 554 }
 555 #endif
 556
 557 /*
 558 ** This routine is the only routine in this file with external
 559 ** linkage. It returns a pointer to a static sqlite3_mem_methods
 560 ** struct populated with the memsys5 methods.
 561 */
 562 const sqlite3_mem_methods *sqlite3MemGetMemsys5(void){
 563   static const sqlite3_mem_methods memsys5Methods = {
 564      memsys5Malloc,
 565      memsys5Free,
 566      memsys5Realloc,
 567      memsys5Size,
 568      memsys5Roundup,
 569      memsys5Init,
 570      memsys5Shutdown,
 571      0
 572   };
 573   return &memsys5Methods;
 574 }
 575
 576 #endif /* SQLITE_ENABLE_MEMSYS5 */