mem3.c.svn-base
上传用户:sunhongbo
上传日期:2022-01-25
资源大小:3010k
文件大小:19k
源码类别:

数据库系统

开发平台:

C/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().  All dynamically allocatable memory is
  17. ** contained in a static array, mem.aPool[].  The size of this
  18. ** fixed memory pool is SQLITE_MEMORY_SIZE bytes.
  19. **
  20. ** This version of the memory allocation subsystem is used if
  21. ** and only if SQLITE_MEMORY_SIZE is defined.
  22. **
  23. ** $Id: mem3.c,v 1.12 2008/02/19 15:15:16 drh Exp $
  24. */
  25. #include "sqliteInt.h"
  26. /*
  27. ** This version of the memory allocator is used only when 
  28. ** SQLITE_MEMORY_SIZE is defined.
  29. */
  30. #ifdef SQLITE_MEMORY_SIZE
  31. /*
  32. ** Maximum size (in Mem3Blocks) of a "small" chunk.
  33. */
  34. #define MX_SMALL 10
  35. /*
  36. ** Number of freelist hash slots
  37. */
  38. #define N_HASH  61
  39. /*
  40. ** A memory allocation (also called a "chunk") consists of two or 
  41. ** more blocks where each block is 8 bytes.  The first 8 bytes are 
  42. ** a header that is not returned to the user.
  43. **
  44. ** A chunk is two or more blocks that is either checked out or
  45. ** free.  The first block has format u.hdr.  u.hdr.size4x is 4 times the
  46. ** size of the allocation in blocks if the allocation is free.
  47. ** The u.hdr.size4x&1 bit is true if the chunk is checked out and
  48. ** false if the chunk is on the freelist.  The u.hdr.size4x&2 bit
  49. ** is true if the previous chunk is checked out and false if the
  50. ** previous chunk is free.  The u.hdr.prevSize field is the size of
  51. ** the previous chunk in blocks if the previous chunk is on the
  52. ** freelist. If the previous chunk is checked out, then
  53. ** u.hdr.prevSize can be part of the data for that chunk and should
  54. ** not be read or written.
  55. **
  56. ** We often identify a chunk by its index in mem.aPool[].  When
  57. ** this is done, the chunk index refers to the second block of
  58. ** the chunk.  In this way, the first chunk has an index of 1.
  59. ** A chunk index of 0 means "no such chunk" and is the equivalent
  60. ** of a NULL pointer.
  61. **
  62. ** The second block of free chunks is of the form u.list.  The
  63. ** two fields form a double-linked list of chunks of related sizes.
  64. ** Pointers to the head of the list are stored in mem.aiSmall[] 
  65. ** for smaller chunks and mem.aiHash[] for larger chunks.
  66. **
  67. ** The second block of a chunk is user data if the chunk is checked 
  68. ** out.  If a chunk is checked out, the user data may extend into
  69. ** the u.hdr.prevSize value of the following chunk.
  70. */
  71. typedef struct Mem3Block Mem3Block;
  72. struct Mem3Block {
  73.   union {
  74.     struct {
  75.       u32 prevSize;   /* Size of previous chunk in Mem3Block elements */
  76.       u32 size4x;     /* 4x the size of current chunk in Mem3Block elements */
  77.     } hdr;
  78.     struct {
  79.       u32 next;       /* Index in mem.aPool[] of next free chunk */
  80.       u32 prev;       /* Index in mem.aPool[] of previous free chunk */
  81.     } list;
  82.   } u;
  83. };
  84. /*
  85. ** All of the static variables used by this module are collected
  86. ** into a single structure named "mem".  This is to keep the
  87. ** static variables organized and to reduce namespace pollution
  88. ** when this module is combined with other in the amalgamation.
  89. */
  90. static struct {
  91.   /*
  92.   ** True if we are evaluating an out-of-memory callback.
  93.   */
  94.   int alarmBusy;
  95.   
  96.   /*
  97.   ** Mutex to control access to the memory allocation subsystem.
  98.   */
  99.   sqlite3_mutex *mutex;
  100.   
  101.   /*
  102.   ** The minimum amount of free space that we have seen.
  103.   */
  104.   u32 mnMaster;
  105.   /*
  106.   ** iMaster is the index of the master chunk.  Most new allocations
  107.   ** occur off of this chunk.  szMaster is the size (in Mem3Blocks)
  108.   ** of the current master.  iMaster is 0 if there is not master chunk.
  109.   ** The master chunk is not in either the aiHash[] or aiSmall[].
  110.   */
  111.   u32 iMaster;
  112.   u32 szMaster;
  113.   /*
  114.   ** Array of lists of free blocks according to the block size 
  115.   ** for smaller chunks, or a hash on the block size for larger
  116.   ** chunks.
  117.   */
  118.   u32 aiSmall[MX_SMALL-1];   /* For sizes 2 through MX_SMALL, inclusive */
  119.   u32 aiHash[N_HASH];        /* For sizes MX_SMALL+1 and larger */
  120.   /*
  121.   ** Memory available for allocation
  122.   */
  123.   Mem3Block aPool[SQLITE_MEMORY_SIZE/sizeof(Mem3Block)+2];
  124. } mem;
  125. /*
  126. ** Unlink the chunk at mem.aPool[i] from list it is currently
  127. ** on.  *pRoot is the list that i is a member of.
  128. */
  129. static void memsys3UnlinkFromList(u32 i, u32 *pRoot){
  130.   u32 next = mem.aPool[i].u.list.next;
  131.   u32 prev = mem.aPool[i].u.list.prev;
  132.   assert( sqlite3_mutex_held(mem.mutex) );
  133.   if( prev==0 ){
  134.     *pRoot = next;
  135.   }else{
  136.     mem.aPool[prev].u.list.next = next;
  137.   }
  138.   if( next ){
  139.     mem.aPool[next].u.list.prev = prev;
  140.   }
  141.   mem.aPool[i].u.list.next = 0;
  142.   mem.aPool[i].u.list.prev = 0;
  143. }
  144. /*
  145. ** Unlink the chunk at index i from 
  146. ** whatever list is currently a member of.
  147. */
  148. static void memsys3Unlink(u32 i){
  149.   u32 size, hash;
  150.   assert( sqlite3_mutex_held(mem.mutex) );
  151.   assert( (mem.aPool[i-1].u.hdr.size4x & 1)==0 );
  152.   assert( i>=1 );
  153.   size = mem.aPool[i-1].u.hdr.size4x/4;
  154.   assert( size==mem.aPool[i+size-1].u.hdr.prevSize );
  155.   assert( size>=2 );
  156.   if( size <= MX_SMALL ){
  157.     memsys3UnlinkFromList(i, &mem.aiSmall[size-2]);
  158.   }else{
  159.     hash = size % N_HASH;
  160.     memsys3UnlinkFromList(i, &mem.aiHash[hash]);
  161.   }
  162. }
  163. /*
  164. ** Link the chunk at mem.aPool[i] so that is on the list rooted
  165. ** at *pRoot.
  166. */
  167. static void memsys3LinkIntoList(u32 i, u32 *pRoot){
  168.   assert( sqlite3_mutex_held(mem.mutex) );
  169.   mem.aPool[i].u.list.next = *pRoot;
  170.   mem.aPool[i].u.list.prev = 0;
  171.   if( *pRoot ){
  172.     mem.aPool[*pRoot].u.list.prev = i;
  173.   }
  174.   *pRoot = i;
  175. }
  176. /*
  177. ** Link the chunk at index i into either the appropriate
  178. ** small chunk list, or into the large chunk hash table.
  179. */
  180. static void memsys3Link(u32 i){
  181.   u32 size, hash;
  182.   assert( sqlite3_mutex_held(mem.mutex) );
  183.   assert( i>=1 );
  184.   assert( (mem.aPool[i-1].u.hdr.size4x & 1)==0 );
  185.   size = mem.aPool[i-1].u.hdr.size4x/4;
  186.   assert( size==mem.aPool[i+size-1].u.hdr.prevSize );
  187.   assert( size>=2 );
  188.   if( size <= MX_SMALL ){
  189.     memsys3LinkIntoList(i, &mem.aiSmall[size-2]);
  190.   }else{
  191.     hash = size % N_HASH;
  192.     memsys3LinkIntoList(i, &mem.aiHash[hash]);
  193.   }
  194. }
  195. /*
  196. ** Enter the mutex mem.mutex. Allocate it if it is not already allocated.
  197. **
  198. ** Also:  Initialize the memory allocation subsystem the first time
  199. ** this routine is called.
  200. */
  201. static void memsys3Enter(void){
  202.   if( mem.mutex==0 ){
  203.     mem.mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MEM);
  204.     mem.aPool[0].u.hdr.size4x = SQLITE_MEMORY_SIZE/2 + 2;
  205.     mem.aPool[SQLITE_MEMORY_SIZE/8].u.hdr.prevSize = SQLITE_MEMORY_SIZE/8;
  206.     mem.aPool[SQLITE_MEMORY_SIZE/8].u.hdr.size4x = 1;
  207.     mem.iMaster = 1;
  208.     mem.szMaster = SQLITE_MEMORY_SIZE/8;
  209.     mem.mnMaster = mem.szMaster;
  210.   }
  211.   sqlite3_mutex_enter(mem.mutex);
  212. }
  213. /*
  214. ** Return the amount of memory currently checked out.
  215. */
  216. sqlite3_int64 sqlite3_memory_used(void){
  217.   sqlite3_int64 n;
  218.   memsys3Enter();
  219.   n = SQLITE_MEMORY_SIZE - mem.szMaster*8;
  220.   sqlite3_mutex_leave(mem.mutex);  
  221.   return n;
  222. }
  223. /*
  224. ** Return the maximum amount of memory that has ever been
  225. ** checked out since either the beginning of this process
  226. ** or since the most recent reset.
  227. */
  228. sqlite3_int64 sqlite3_memory_highwater(int resetFlag){
  229.   sqlite3_int64 n;
  230.   memsys3Enter();
  231.   n = SQLITE_MEMORY_SIZE - mem.mnMaster*8;
  232.   if( resetFlag ){
  233.     mem.mnMaster = mem.szMaster;
  234.   }
  235.   sqlite3_mutex_leave(mem.mutex);  
  236.   return n;
  237. }
  238. /*
  239. ** Change the alarm callback.
  240. **
  241. ** This is a no-op for the static memory allocator.  The purpose
  242. ** of the memory alarm is to support sqlite3_soft_heap_limit().
  243. ** But with this memory allocator, the soft_heap_limit is really
  244. ** a hard limit that is fixed at SQLITE_MEMORY_SIZE.
  245. */
  246. int sqlite3_memory_alarm(
  247.   void(*xCallback)(void *pArg, sqlite3_int64 used,int N),
  248.   void *pArg,
  249.   sqlite3_int64 iThreshold
  250. ){
  251.   return SQLITE_OK;
  252. }
  253. /*
  254. ** Called when we are unable to satisfy an allocation of nBytes.
  255. */
  256. static void memsys3OutOfMemory(int nByte){
  257.   if( !mem.alarmBusy ){
  258.     mem.alarmBusy = 1;
  259.     assert( sqlite3_mutex_held(mem.mutex) );
  260.     sqlite3_mutex_leave(mem.mutex);
  261.     sqlite3_release_memory(nByte);
  262.     sqlite3_mutex_enter(mem.mutex);
  263.     mem.alarmBusy = 0;
  264.   }
  265. }
  266. /*
  267. ** Return the size of an outstanding allocation, in bytes.  The
  268. ** size returned omits the 8-byte header overhead.  This only
  269. ** works for chunks that are currently checked out.
  270. */
  271. int sqlite3MallocSize(void *p){
  272.   int iSize = 0;
  273.   if( p ){
  274.     Mem3Block *pBlock = (Mem3Block*)p;
  275.     assert( (pBlock[-1].u.hdr.size4x&1)!=0 );
  276.     iSize = (pBlock[-1].u.hdr.size4x&~3)*2 - 4;
  277.   }
  278.   return iSize;
  279. }
  280. /*
  281. ** Chunk i is a free chunk that has been unlinked.  Adjust its 
  282. ** size parameters for check-out and return a pointer to the 
  283. ** user portion of the chunk.
  284. */
  285. static void *memsys3Checkout(u32 i, int nBlock){
  286.   u32 x;
  287.   assert( sqlite3_mutex_held(mem.mutex) );
  288.   assert( i>=1 );
  289.   assert( mem.aPool[i-1].u.hdr.size4x/4==nBlock );
  290.   assert( mem.aPool[i+nBlock-1].u.hdr.prevSize==nBlock );
  291.   x = mem.aPool[i-1].u.hdr.size4x;
  292.   mem.aPool[i-1].u.hdr.size4x = nBlock*4 | 1 | (x&2);
  293.   mem.aPool[i+nBlock-1].u.hdr.prevSize = nBlock;
  294.   mem.aPool[i+nBlock-1].u.hdr.size4x |= 2;
  295.   return &mem.aPool[i];
  296. }
  297. /*
  298. ** Carve a piece off of the end of the mem.iMaster free chunk.
  299. ** Return a pointer to the new allocation.  Or, if the master chunk
  300. ** is not large enough, return 0.
  301. */
  302. static void *memsys3FromMaster(int nBlock){
  303.   assert( sqlite3_mutex_held(mem.mutex) );
  304.   assert( mem.szMaster>=nBlock );
  305.   if( nBlock>=mem.szMaster-1 ){
  306.     /* Use the entire master */
  307.     void *p = memsys3Checkout(mem.iMaster, mem.szMaster);
  308.     mem.iMaster = 0;
  309.     mem.szMaster = 0;
  310.     mem.mnMaster = 0;
  311.     return p;
  312.   }else{
  313.     /* Split the master block.  Return the tail. */
  314.     u32 newi, x;
  315.     newi = mem.iMaster + mem.szMaster - nBlock;
  316.     assert( newi > mem.iMaster+1 );
  317.     mem.aPool[mem.iMaster+mem.szMaster-1].u.hdr.prevSize = nBlock;
  318.     mem.aPool[mem.iMaster+mem.szMaster-1].u.hdr.size4x |= 2;
  319.     mem.aPool[newi-1].u.hdr.size4x = nBlock*4 + 1;
  320.     mem.szMaster -= nBlock;
  321.     mem.aPool[newi-1].u.hdr.prevSize = mem.szMaster;
  322.     x = mem.aPool[mem.iMaster-1].u.hdr.size4x & 2;
  323.     mem.aPool[mem.iMaster-1].u.hdr.size4x = mem.szMaster*4 | x;
  324.     if( mem.szMaster < mem.mnMaster ){
  325.       mem.mnMaster = mem.szMaster;
  326.     }
  327.     return (void*)&mem.aPool[newi];
  328.   }
  329. }
  330. /*
  331. ** *pRoot is the head of a list of free chunks of the same size
  332. ** or same size hash.  In other words, *pRoot is an entry in either
  333. ** mem.aiSmall[] or mem.aiHash[].  
  334. **
  335. ** This routine examines all entries on the given list and tries
  336. ** to coalesce each entries with adjacent free chunks.  
  337. **
  338. ** If it sees a chunk that is larger than mem.iMaster, it replaces 
  339. ** the current mem.iMaster with the new larger chunk.  In order for
  340. ** this mem.iMaster replacement to work, the master chunk must be
  341. ** linked into the hash tables.  That is not the normal state of
  342. ** affairs, of course.  The calling routine must link the master
  343. ** chunk before invoking this routine, then must unlink the (possibly
  344. ** changed) master chunk once this routine has finished.
  345. */
  346. static void memsys3Merge(u32 *pRoot){
  347.   u32 iNext, prev, size, i, x;
  348.   assert( sqlite3_mutex_held(mem.mutex) );
  349.   for(i=*pRoot; i>0; i=iNext){
  350.     iNext = mem.aPool[i].u.list.next;
  351.     size = mem.aPool[i-1].u.hdr.size4x;
  352.     assert( (size&1)==0 );
  353.     if( (size&2)==0 ){
  354.       memsys3UnlinkFromList(i, pRoot);
  355.       assert( i > mem.aPool[i-1].u.hdr.prevSize );
  356.       prev = i - mem.aPool[i-1].u.hdr.prevSize;
  357.       if( prev==iNext ){
  358.         iNext = mem.aPool[prev].u.list.next;
  359.       }
  360.       memsys3Unlink(prev);
  361.       size = i + size/4 - prev;
  362.       x = mem.aPool[prev-1].u.hdr.size4x & 2;
  363.       mem.aPool[prev-1].u.hdr.size4x = size*4 | x;
  364.       mem.aPool[prev+size-1].u.hdr.prevSize = size;
  365.       memsys3Link(prev);
  366.       i = prev;
  367.     }else{
  368.       size /= 4;
  369.     }
  370.     if( size>mem.szMaster ){
  371.       mem.iMaster = i;
  372.       mem.szMaster = size;
  373.     }
  374.   }
  375. }
  376. /*
  377. ** Return a block of memory of at least nBytes in size.
  378. ** Return NULL if unable.
  379. */
  380. static void *memsys3Malloc(int nByte){
  381.   u32 i;
  382.   int nBlock;
  383.   int toFree;
  384.   assert( sqlite3_mutex_held(mem.mutex) );
  385.   assert( sizeof(Mem3Block)==8 );
  386.   if( nByte<=12 ){
  387.     nBlock = 2;
  388.   }else{
  389.     nBlock = (nByte + 11)/8;
  390.   }
  391.   assert( nBlock >= 2 );
  392.   /* STEP 1:
  393.   ** Look for an entry of the correct size in either the small
  394.   ** chunk table or in the large chunk hash table.  This is
  395.   ** successful most of the time (about 9 times out of 10).
  396.   */
  397.   if( nBlock <= MX_SMALL ){
  398.     i = mem.aiSmall[nBlock-2];
  399.     if( i>0 ){
  400.       memsys3UnlinkFromList(i, &mem.aiSmall[nBlock-2]);
  401.       return memsys3Checkout(i, nBlock);
  402.     }
  403.   }else{
  404.     int hash = nBlock % N_HASH;
  405.     for(i=mem.aiHash[hash]; i>0; i=mem.aPool[i].u.list.next){
  406.       if( mem.aPool[i-1].u.hdr.size4x/4==nBlock ){
  407.         memsys3UnlinkFromList(i, &mem.aiHash[hash]);
  408.         return memsys3Checkout(i, nBlock);
  409.       }
  410.     }
  411.   }
  412.   /* STEP 2:
  413.   ** Try to satisfy the allocation by carving a piece off of the end
  414.   ** of the master chunk.  This step usually works if step 1 fails.
  415.   */
  416.   if( mem.szMaster>=nBlock ){
  417.     return memsys3FromMaster(nBlock);
  418.   }
  419.   /* STEP 3:  
  420.   ** Loop through the entire memory pool.  Coalesce adjacent free
  421.   ** chunks.  Recompute the master chunk as the largest free chunk.
  422.   ** Then try again to satisfy the allocation by carving a piece off
  423.   ** of the end of the master chunk.  This step happens very
  424.   ** rarely (we hope!)
  425.   */
  426.   for(toFree=nBlock*16; toFree<SQLITE_MEMORY_SIZE*2; toFree *= 2){
  427.     memsys3OutOfMemory(toFree);
  428.     if( mem.iMaster ){
  429.       memsys3Link(mem.iMaster);
  430.       mem.iMaster = 0;
  431.       mem.szMaster = 0;
  432.     }
  433.     for(i=0; i<N_HASH; i++){
  434.       memsys3Merge(&mem.aiHash[i]);
  435.     }
  436.     for(i=0; i<MX_SMALL-1; i++){
  437.       memsys3Merge(&mem.aiSmall[i]);
  438.     }
  439.     if( mem.szMaster ){
  440.       memsys3Unlink(mem.iMaster);
  441.       if( mem.szMaster>=nBlock ){
  442.         return memsys3FromMaster(nBlock);
  443.       }
  444.     }
  445.   }
  446.   /* If none of the above worked, then we fail. */
  447.   return 0;
  448. }
  449. /*
  450. ** Free an outstanding memory allocation.
  451. */
  452. void memsys3Free(void *pOld){
  453.   Mem3Block *p = (Mem3Block*)pOld;
  454.   int i;
  455.   u32 size, x;
  456.   assert( sqlite3_mutex_held(mem.mutex) );
  457.   assert( p>mem.aPool && p<&mem.aPool[SQLITE_MEMORY_SIZE/8] );
  458.   i = p - mem.aPool;
  459.   assert( (mem.aPool[i-1].u.hdr.size4x&1)==1 );
  460.   size = mem.aPool[i-1].u.hdr.size4x/4;
  461.   assert( i+size<=SQLITE_MEMORY_SIZE/8+1 );
  462.   mem.aPool[i-1].u.hdr.size4x &= ~1;
  463.   mem.aPool[i+size-1].u.hdr.prevSize = size;
  464.   mem.aPool[i+size-1].u.hdr.size4x &= ~2;
  465.   memsys3Link(i);
  466.   /* Try to expand the master using the newly freed chunk */
  467.   if( mem.iMaster ){
  468.     while( (mem.aPool[mem.iMaster-1].u.hdr.size4x&2)==0 ){
  469.       size = mem.aPool[mem.iMaster-1].u.hdr.prevSize;
  470.       mem.iMaster -= size;
  471.       mem.szMaster += size;
  472.       memsys3Unlink(mem.iMaster);
  473.       x = mem.aPool[mem.iMaster-1].u.hdr.size4x & 2;
  474.       mem.aPool[mem.iMaster-1].u.hdr.size4x = mem.szMaster*4 | x;
  475.       mem.aPool[mem.iMaster+mem.szMaster-1].u.hdr.prevSize = mem.szMaster;
  476.     }
  477.     x = mem.aPool[mem.iMaster-1].u.hdr.size4x & 2;
  478.     while( (mem.aPool[mem.iMaster+mem.szMaster-1].u.hdr.size4x&1)==0 ){
  479.       memsys3Unlink(mem.iMaster+mem.szMaster);
  480.       mem.szMaster += mem.aPool[mem.iMaster+mem.szMaster-1].u.hdr.size4x/4;
  481.       mem.aPool[mem.iMaster-1].u.hdr.size4x = mem.szMaster*4 | x;
  482.       mem.aPool[mem.iMaster+mem.szMaster-1].u.hdr.prevSize = mem.szMaster;
  483.     }
  484.   }
  485. }
  486. /*
  487. ** Allocate nBytes of memory
  488. */
  489. void *sqlite3_malloc(int nBytes){
  490.   sqlite3_int64 *p = 0;
  491.   if( nBytes>0 ){
  492.     memsys3Enter();
  493.     p = memsys3Malloc(nBytes);
  494.     sqlite3_mutex_leave(mem.mutex);
  495.   }
  496.   return (void*)p; 
  497. }
  498. /*
  499. ** Free memory.
  500. */
  501. void sqlite3_free(void *pPrior){
  502.   if( pPrior==0 ){
  503.     return;
  504.   }
  505.   assert( mem.mutex!=0 );
  506.   sqlite3_mutex_enter(mem.mutex);
  507.   memsys3Free(pPrior);
  508.   sqlite3_mutex_leave(mem.mutex);  
  509. }
  510. /*
  511. ** Change the size of an existing memory allocation
  512. */
  513. void *sqlite3_realloc(void *pPrior, int nBytes){
  514.   int nOld;
  515.   void *p;
  516.   if( pPrior==0 ){
  517.     return sqlite3_malloc(nBytes);
  518.   }
  519.   if( nBytes<=0 ){
  520.     sqlite3_free(pPrior);
  521.     return 0;
  522.   }
  523.   assert( mem.mutex!=0 );
  524.   nOld = sqlite3MallocSize(pPrior);
  525.   if( nBytes<=nOld && nBytes>=nOld-128 ){
  526.     return pPrior;
  527.   }
  528.   sqlite3_mutex_enter(mem.mutex);
  529.   p = memsys3Malloc(nBytes);
  530.   if( p ){
  531.     if( nOld<nBytes ){
  532.       memcpy(p, pPrior, nOld);
  533.     }else{
  534.       memcpy(p, pPrior, nBytes);
  535.     }
  536.     memsys3Free(pPrior);
  537.   }
  538.   sqlite3_mutex_leave(mem.mutex);
  539.   return p;
  540. }
  541. /*
  542. ** Open the file indicated and write a log of all unfreed memory 
  543. ** allocations into that log.
  544. */
  545. void sqlite3MemdebugDump(const char *zFilename){
  546. #ifdef SQLITE_DEBUG
  547.   FILE *out;
  548.   int i, j;
  549.   u32 size;
  550.   if( zFilename==0 || zFilename[0]==0 ){
  551.     out = stdout;
  552.   }else{
  553.     out = fopen(zFilename, "w");
  554.     if( out==0 ){
  555.       fprintf(stderr, "** Unable to output memory debug output log: %s **n",
  556.                       zFilename);
  557.       return;
  558.     }
  559.   }
  560.   memsys3Enter();
  561.   fprintf(out, "CHUNKS:n");
  562.   for(i=1; i<=SQLITE_MEMORY_SIZE/8; i+=size/4){
  563.     size = mem.aPool[i-1].u.hdr.size4x;
  564.     if( size/4<=1 ){
  565.       fprintf(out, "%p size errorn", &mem.aPool[i]);
  566.       assert( 0 );
  567.       break;
  568.     }
  569.     if( (size&1)==0 && mem.aPool[i+size/4-1].u.hdr.prevSize!=size/4 ){
  570.       fprintf(out, "%p tail size does not matchn", &mem.aPool[i]);
  571.       assert( 0 );
  572.       break;
  573.     }
  574.     if( ((mem.aPool[i+size/4-1].u.hdr.size4x&2)>>1)!=(size&1) ){
  575.       fprintf(out, "%p tail checkout bit is incorrectn", &mem.aPool[i]);
  576.       assert( 0 );
  577.       break;
  578.     }
  579.     if( size&1 ){
  580.       fprintf(out, "%p %6d bytes checked outn", &mem.aPool[i], (size/4)*8-8);
  581.     }else{
  582.       fprintf(out, "%p %6d bytes free%sn", &mem.aPool[i], (size/4)*8-8,
  583.                   i==mem.iMaster ? " **master**" : "");
  584.     }
  585.   }
  586.   for(i=0; i<MX_SMALL-1; i++){
  587.     if( mem.aiSmall[i]==0 ) continue;
  588.     fprintf(out, "small(%2d):", i);
  589.     for(j = mem.aiSmall[i]; j>0; j=mem.aPool[j].u.list.next){
  590.       fprintf(out, " %p(%d)", &mem.aPool[j],
  591.               (mem.aPool[j-1].u.hdr.size4x/4)*8-8);
  592.     }
  593.     fprintf(out, "n"); 
  594.   }
  595.   for(i=0; i<N_HASH; i++){
  596.     if( mem.aiHash[i]==0 ) continue;
  597.     fprintf(out, "hash(%2d):", i);
  598.     for(j = mem.aiHash[i]; j>0; j=mem.aPool[j].u.list.next){
  599.       fprintf(out, " %p(%d)", &mem.aPool[j],
  600.               (mem.aPool[j-1].u.hdr.size4x/4)*8-8);
  601.     }
  602.     fprintf(out, "n"); 
  603.   }
  604.   fprintf(out, "master=%dn", mem.iMaster);
  605.   fprintf(out, "nowUsed=%dn", SQLITE_MEMORY_SIZE - mem.szMaster*8);
  606.   fprintf(out, "mxUsed=%dn", SQLITE_MEMORY_SIZE - mem.mnMaster*8);
  607.   sqlite3_mutex_leave(mem.mutex);
  608.   if( out==stdout ){
  609.     fflush(stdout);
  610.   }else{
  611.     fclose(out);
  612.   }
  613. #endif
  614. }
  615. #endif /* !SQLITE_MEMORY_SIZE */