database/sqlite
1
0
Fork 0
mirror of https://github.com/sqlite/sqlite.git synced 2025-07-30 19:03:16 +03:00
Code Activity

The power-of-two first-fit memory allocator is now working. (CVS 4793)

Browse Source 
FossilOrigin-Name: d134d29cea971eb01a0e0fd94341ab79e2d5b57a
This commit is contained in:
drh
2008-02-16 16:21:45 +00:00
parent 66ce4d02fe
commit 2d7636e212
7 changed files with 231 additions and 413 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
manifest
View File

@ -1,5 +1,5 @@
C Fix\sa\sbug\sin\sthe\s".show"\scommand\sof\sthe\sCLI.\s\sTicket\s#2942.\s(CVS\s4792) C The\spower-of-two\sfirst-fit\smemory\sallocator\sis\snow\sworking.\s(CVS\s4793)
D 2008-02-15T17:38:06 D 2008-02-16T16:21:46
F Makefile.arm-wince-mingw32ce-gcc ac5f7b2cef0cd850d6f755ba6ee4ab961b1fadf7 F Makefile.arm-wince-mingw32ce-gcc ac5f7b2cef0cd850d6f755ba6ee4ab961b1fadf7
F Makefile.in bc2b5df3e3d0d4b801b824b7ef6dec43812b049b F Makefile.in bc2b5df3e3d0d4b801b824b7ef6dec43812b049b
F Makefile.linux-gcc d53183f4aa6a9192d249731c90dbdffbd2c68654 F Makefile.linux-gcc d53183f4aa6a9192d249731c90dbdffbd2c68654
@ -109,7 +109,7 @@ F src/mem1.c 62a821702d3292809ca78e7c55c3ca04b05a3757
F src/mem2.c 021eecbb210cfe90a8e7be9f04b01329d2c38851 F src/mem2.c 021eecbb210cfe90a8e7be9f04b01329d2c38851
F src/mem3.c 979191678eb1aac0af7e5df9ab3897a07410ff4c F src/mem3.c 979191678eb1aac0af7e5df9ab3897a07410ff4c
F src/mem4.c 45c328ec6dcb7e8d319cb383615b5fe547ca5409 F src/mem4.c 45c328ec6dcb7e8d319cb383615b5fe547ca5409
F src/mem5.c addb464d2328ad5dcd38a127a19a10fb654e1349 F src/mem5.c e15148be341ba68af22cf62c59d03ad369a448fd
F src/mutex.c 3259f62c2429967aee6dc112117a6d2f499ef061 F src/mutex.c 3259f62c2429967aee6dc112117a6d2f499ef061
F src/mutex.h 079fa6fe9da18ceb89e79012c010594c6672addb F src/mutex.h 079fa6fe9da18ceb89e79012c010594c6672addb
F src/mutex_os2.c 19ab15764736f13b94b4f70e53f77547cbddd47a F src/mutex_os2.c 19ab15764736f13b94b4f70e53f77547cbddd47a
@ -154,11 +154,11 @@ F src/test9.c 4615ef08750245a2d96aaa7cbe2fb4aff2b57acc
F src/test_async.c 5f21392d66869a4c87dc9153e40d0dc0e085261f F src/test_async.c 5f21392d66869a4c87dc9153e40d0dc0e085261f
F src/test_autoext.c 855157d97aa28cf84233847548bfacda21807436 F src/test_autoext.c 855157d97aa28cf84233847548bfacda21807436
F src/test_btree.c c1308ba0b88ab577fa56c9e493a09829dfcded9c F src/test_btree.c c1308ba0b88ab577fa56c9e493a09829dfcded9c
F src/test_config.c e7db7a46833d0df98ae6c9a11f70dada1bcca249 F src/test_config.c 9223ff4a7b8b97c9d12965b0123db1cbd6757efb
F src/test_devsym.c fd8884c2269fb7e0db2c52d21ec59d31a33790ba F src/test_devsym.c fd8884c2269fb7e0db2c52d21ec59d31a33790ba
F src/test_hexio.c 1a1cd8324d57585ea86b922f609fa1fbaaf9662d F src/test_hexio.c 1a1cd8324d57585ea86b922f609fa1fbaaf9662d
F src/test_loadext.c 22065d601a18878e5542191001f0eaa5d77c0ed8 F src/test_loadext.c 22065d601a18878e5542191001f0eaa5d77c0ed8
F src/test_malloc.c f57e6327a9c32dc71fb2c15941f64d4e91461d3b F src/test_malloc.c 6a47772a8530dbf3f6578a53e96303ac1dc3244a
F src/test_md5.c c107c96637123239c3518b5fbe97a79130f4d32e F src/test_md5.c c107c96637123239c3518b5fbe97a79130f4d32e
F src/test_onefile.c 54282b6796d55d7acc489be83b89b8715e7d3756 F src/test_onefile.c 54282b6796d55d7acc489be83b89b8715e7d3756
F src/test_schema.c 12c9de7661d6294eec2d57afbb52e2af1128084f F src/test_schema.c 12c9de7661d6294eec2d57afbb52e2af1128084f
@ -454,7 +454,7 @@ F test/table.test 13b1c2e2fb4727b35ee1fb7641fc469214fd2455
F test/tableapi.test 4546eb710d979db023bfcc16b0c108b1557fcb43 F test/tableapi.test 4546eb710d979db023bfcc16b0c108b1557fcb43
F test/tclsqlite.test 3fac87cb1059c46b8fa8a60b553f4f1adb0fb6d9 F test/tclsqlite.test 3fac87cb1059c46b8fa8a60b553f4f1adb0fb6d9
F test/temptable.test 19b851b9e3e64d91e9867619b2a3f5fffee6e125 F test/temptable.test 19b851b9e3e64d91e9867619b2a3f5fffee6e125
F test/tester.tcl 70ed4c0dda3e2277bac9e0bf38e60df9dc360d08 F test/tester.tcl 7760c4101448e5595b2ee095e540643fa31a1610
F test/thread001.test 8fbd9559da0bbdc273e00318c7fd66c162020af7 F test/thread001.test 8fbd9559da0bbdc273e00318c7fd66c162020af7
F test/thread002.test 2c4ad2c386f60f6fe268cd91c769ee35b3c1fd0b F test/thread002.test 2c4ad2c386f60f6fe268cd91c769ee35b3c1fd0b
F test/thread1.test 776c9e459b75ba905193b351926ac4019b049f35 F test/thread1.test 776c9e459b75ba905193b351926ac4019b049f35
@ -549,7 +549,7 @@ F tool/memleak2.awk 9cc20c8e8f3c675efac71ea0721ee6874a1566e8
F tool/memleak3.tcl 7707006ee908cffff210c98158788d85bb3fcdbf F tool/memleak3.tcl 7707006ee908cffff210c98158788d85bb3fcdbf
F tool/mkkeywordhash.c ef93810fc41fb3d3dbacf9a33a29be88ea99ffa9 F tool/mkkeywordhash.c ef93810fc41fb3d3dbacf9a33a29be88ea99ffa9
F tool/mkopts.tcl 66ac10d240cc6e86abd37dc908d50382f84ff46e x F tool/mkopts.tcl 66ac10d240cc6e86abd37dc908d50382f84ff46e x
F tool/mksqlite3c.tcl c315696c91d0a986e696dce14b0db1ea93e2c2d0 F tool/mksqlite3c.tcl c1876ef95be512ce466f09d7b2d1157f9766f2b1
F tool/mksqlite3internalh.tcl 47737a925fb02fce43e2c0a14b3cc17574a4d44a F tool/mksqlite3internalh.tcl 47737a925fb02fce43e2c0a14b3cc17574a4d44a
F tool/omittest.tcl 7d1fdf469e2f4d175f70c36e469db64a1626fabb F tool/omittest.tcl 7d1fdf469e2f4d175f70c36e469db64a1626fabb
F tool/opcodeDoc.awk b3a2a3d5d3075b8bd90b7afe24283efdd586659c F tool/opcodeDoc.awk b3a2a3d5d3075b8bd90b7afe24283efdd586659c
@ -619,7 +619,7 @@ F www/tclsqlite.tcl 8be95ee6dba05eabcd27a9d91331c803f2ce2130
F www/vdbe.tcl 87a31ace769f20d3627a64fa1fade7fed47b90d0 F www/vdbe.tcl 87a31ace769f20d3627a64fa1fade7fed47b90d0
F www/version3.tcl 890248cf7b70e60c383b0e84d77d5132b3ead42b F www/version3.tcl 890248cf7b70e60c383b0e84d77d5132b3ead42b
F www/whentouse.tcl fc46eae081251c3c181bd79c5faef8195d7991a5 F www/whentouse.tcl fc46eae081251c3c181bd79c5faef8195d7991a5
P 6d33cbd99cb0db680767ceb31ec6345e90a805bc P dedf5f230bf34a207f2ee0a8349a2ea602a38aba
R 278e440ef39be86aca5c9fcf37732ebc R cf36f2227f0aebc7182206911a7828ca
U drh U drh
Z 27b6c195ad861a325b1d53c0c1393102 Z 7f0671ff9d8e2cc545c59a85da0cd625

2
manifest.uuid
View File

@ -1 +1 @@
dedf5f230bf34a207f2ee0a8349a2ea602a38aba d134d29cea971eb01a0e0fd94341ab79e2d5b57a

602
src/mem5.c
View File

@ -20,7 +20,7 @@
** This version of the memory allocation subsystem is used if ** This version of the memory allocation subsystem is used if
** and only if SQLITE_POW2_MEMORY_SIZE is defined. ** and only if SQLITE_POW2_MEMORY_SIZE is defined.
** **
** $Id: mem5.c,v 1.1 2008/02/14 23:26:56 drh Exp $ ** $Id: mem5.c,v 1.2 2008/02/16 16:21:46 drh Exp $
*/ */
#include "sqliteInt.h" #include "sqliteInt.h"
@ -31,62 +31,60 @@
#ifdef SQLITE_POW2_MEMORY_SIZE #ifdef SQLITE_POW2_MEMORY_SIZE
/* /*
** Maximum size (in Mem3Blocks) of a "small" chunk. ** Log2 of the minimum size of an allocation. For example, if
** 4 then all allocations will be rounded up to at least 16 bytes.
** If 5 then all allocations will be rounded up to at least 32 bytes.
*/ */
#define MX_SMALL 10 #ifndef SQLITE_POW2_LOGMIN
# define SQLITE_POW2_LOGMIN 6
#endif
#define POW2_MIN (1<<SQLITE_POW2_LOGMIN)
/* /*
** Number of freelist hash slots ** Log2 of the maximum size of an allocation.
*/ */
#define N_HASH 61 #ifndef SQLITE_POW2_LOGMAX
# define SQLITE_POW2_LOGMAX 18
#endif
#define POW2_MAX (((unsigned int)1)<<SQLITE_POW2_LOGMAX)
/* /*
** A memory allocation (also called a "chunk") consists of two or ** Number of distinct allocation sizes.
** more blocks where each block is 8 bytes. The first 8 bytes are
** a header that is not returned to the user.
**
** A chunk is two or more blocks that is either checked out or
** free. The first block has format u.hdr. u.hdr.size4x is 4 times the
** size of the allocation in blocks if the allocation is free.
** The u.hdr.size4x&1 bit is true if the chunk is checked out and
** false if the chunk is on the freelist. The u.hdr.size4x&2 bit
** is true if the previous chunk is checked out and false if the
** previous chunk is free. The u.hdr.prevSize field is the size of
** the previous chunk in blocks if the previous chunk is on the
** freelist. If the previous chunk is checked out, then
** u.hdr.prevSize can be part of the data for that chunk and should
** not be read or written.
**
** We often identify a chunk by its index in mem.aPool[]. When
** this is done, the chunk index refers to the second block of
** the chunk. In this way, the first chunk has an index of 1.
** A chunk index of 0 means "no such chunk" and is the equivalent
** of a NULL pointer.
**
** The second block of free chunks is of the form u.list. The
** two fields form a double-linked list of chunks of related sizes.
** Pointers to the head of the list are stored in mem.aiSmall[]
** for smaller chunks and mem.aiHash[] for larger chunks.
**
** The second block of a chunk is user data if the chunk is checked
** out. If a chunk is checked out, the user data may extend into
** the u.hdr.prevSize value of the following chunk.
*/ */
typedef struct Mem3Block Mem3Block; #define NSIZE (SQLITE_POW2_LOGMAX - SQLITE_POW2_LOGMIN + 1)
struct Mem3Block {
/*
** A minimum allocation is an instance of the following structure.
** Larger allocations are an array of these structures where the
** size of the array is a power of 2.
*/
typedef struct Mem5Block Mem5Block;
struct Mem5Block {
union { union {
char aData[POW2_MIN];
struct { struct {
u32 prevSize; /* Size of previous chunk in Mem3Block elements */ int next; /* Index in mem.aPool[] of next free chunk */
u32 size4x; /* 4x the size of current chunk in Mem3Block elements */ int prev; /* Index in mem.aPool[] of previous free chunk */
} hdr;
struct {
u32 next; /* Index in mem.aPool[] of next free chunk */
u32 prev; /* Index in mem.aPool[] of previous free chunk */
} list; } list;
} u; } u;
}; };
/*
** Number of blocks of memory available for allocation.
*/
#define NBLOCK (SQLITE_POW2_MEMORY_SIZE/POW2_MIN)
/*
** The size in blocks of an POW2_MAX allocation
*/
#define SZ_MAX (1<<(NSIZE-1))
/*
** Masks used for mem.aCtrl[] elements.
*/
#define CTRL_LOGSIZE 0x1f /* Log2 Size of this block relative to POW2_MIN */
#define CTRL_FREE 0x20 /* True if not checked out */
/* /*
** All of the static variables used by this module are collected ** All of the static variables used by this module are collected
** into a single structure named "mem". This is to keep the ** into a single structure named "mem". This is to keep the
@ -103,112 +101,77 @@ static struct {
** Mutex to control access to the memory allocation subsystem. ** Mutex to control access to the memory allocation subsystem.
*/ */
sqlite3_mutex *mutex; sqlite3_mutex *mutex;
/*
** Performance statistics
*/
u64 nAlloc; /* Total number of calls to malloc */
u64 totalAlloc; /* Total of all malloc calls - includes internal frag */
u64 totalExcess; /* Total internal fragmentation */
u32 currentOut; /* Current checkout, including internal fragmentation */
u32 currentCount; /* Current number of distinct checkouts */
u32 maxOut; /* Maximum instantaneous currentOut */
u32 maxCount; /* Maximum instantaneous currentCount */
u32 maxRequest; /* Largest allocation (exclusive of internal frag) */
/* /*
** The minimum amount of free space that we have seen. ** Lists of free blocks of various sizes.
*/ */
u32 mnMaster; int aiFreelist[NSIZE];
/* /*
** iMaster is the index of the master chunk. Most new allocations ** Space for tracking which blocks are checked out and the size
** occur off of this chunk. szMaster is the size (in Mem3Blocks) ** of each block. One byte per block.
** of the current master. iMaster is 0 if there is not master chunk.
** The master chunk is not in either the aiHash[] or aiSmall[].
*/ */
u32 iMaster; u8 aCtrl[NBLOCK];
u32 szMaster;
u64 totalAlloc;
u64 totalExcess;
int nAlloc;
/*
** Array of lists of free blocks according to the block size
** for smaller chunks, or a hash on the block size for larger
** chunks.
*/
u32 aiSmall[MX_SMALL-1]; /* For sizes 2 through MX_SMALL, inclusive */
u32 aiHash[N_HASH]; /* For sizes MX_SMALL+1 and larger */
/* /*
** Memory available for allocation ** Memory available for allocation
*/ */
Mem3Block aPool[SQLITE_POW2_MEMORY_SIZE/sizeof(Mem3Block)+2]; Mem5Block aPool[NBLOCK];
} mem; } mem;
/* /*
** Unlink the chunk at mem.aPool[i] from list it is currently ** Unlink the chunk at mem.aPool[i] from list it is currently
** on. *pRoot is the list that i is a member of. ** on. It should be found on mem.aiFreelist[iLogsize].
*/ */
static void memsys3UnlinkFromList(u32 i, u32 *pRoot){ static void memsys5Unlink(int i, int iLogsize){
u32 next = mem.aPool[i].u.list.next; int next, prev;
u32 prev = mem.aPool[i].u.list.prev; assert( i>=0 && i<NBLOCK );
assert( iLogsize>=0 && iLogsize<NSIZE );
assert( (mem.aCtrl[i] & CTRL_LOGSIZE)==iLogsize );
assert( sqlite3_mutex_held(mem.mutex) ); assert( sqlite3_mutex_held(mem.mutex) );
if( prev==0 ){
*pRoot = next; next = mem.aPool[i].u.list.next;
prev = mem.aPool[i].u.list.prev;
if( prev<0 ){
mem.aiFreelist[iLogsize] = next;
}else{ }else{
mem.aPool[prev].u.list.next = next; mem.aPool[prev].u.list.next = next;
} }
if( next ){ if( next>=0 ){
mem.aPool[next].u.list.prev = prev; mem.aPool[next].u.list.prev = prev;
} }
mem.aPool[i].u.list.next = 0;
mem.aPool[i].u.list.prev = 0;
} }
/* /*
** Unlink the chunk at index i from ** Link the chunk at mem.aPool[i] so that is on the iLogsize
** whatever list is currently a member of. ** free list.
*/ */
static void memsys3Unlink(u32 i){ static void memsys5Link(int i, int iLogsize){
u32 size, hash; int x;
assert( sqlite3_mutex_held(mem.mutex) ); assert( sqlite3_mutex_held(mem.mutex) );
assert( (mem.aPool[i-1].u.hdr.size4x & 1)==0 ); assert( i>=0 && i<NBLOCK );
assert( i>=1 ); assert( iLogsize>=0 && iLogsize<NSIZE );
size = mem.aPool[i-1].u.hdr.size4x/4; assert( (mem.aCtrl[i] & CTRL_LOGSIZE)==iLogsize );
assert( size==mem.aPool[i+size-1].u.hdr.prevSize );
assert( size>=2 );
if( size <= MX_SMALL ){
memsys3UnlinkFromList(i, &mem.aiSmall[size-2]);
}else{
hash = size % N_HASH;
memsys3UnlinkFromList(i, &mem.aiHash[hash]);
}
}
/* mem.aPool[i].u.list.next = x = mem.aiFreelist[iLogsize];
** Link the chunk at mem.aPool[i] so that is on the list rooted mem.aPool[i].u.list.prev = -1;
** at *pRoot. if( x>=0 ){
*/ assert( x<NBLOCK );
static void memsys3LinkIntoList(u32 i, u32 *pRoot){ mem.aPool[x].u.list.prev = i;
assert( sqlite3_mutex_held(mem.mutex) );
mem.aPool[i].u.list.next = *pRoot;
mem.aPool[i].u.list.prev = 0;
if( *pRoot ){
mem.aPool[*pRoot].u.list.prev = i;
}
*pRoot = i;
}
/*
** Link the chunk at index i into either the appropriate
** small chunk list, or into the large chunk hash table.
*/
static void memsys3Link(u32 i){
u32 size, hash;
assert( sqlite3_mutex_held(mem.mutex) );
assert( i>=1 );
assert( (mem.aPool[i-1].u.hdr.size4x & 1)==0 );
size = mem.aPool[i-1].u.hdr.size4x/4;
assert( size==mem.aPool[i+size-1].u.hdr.prevSize );
assert( size>=2 );
if( size <= MX_SMALL ){
memsys3LinkIntoList(i, &mem.aiSmall[size-2]);
}else{
hash = size % N_HASH;
memsys3LinkIntoList(i, &mem.aiHash[hash]);
} }
mem.aiFreelist[iLogsize] = i;
} }
/* /*
@ -217,28 +180,29 @@ static void memsys3Link(u32 i){
** Also: Initialize the memory allocation subsystem the first time ** Also: Initialize the memory allocation subsystem the first time
** this routine is called. ** this routine is called.
*/ */
static void memsys3Enter(void){ static void memsys5Enter(void){
if( mem.mutex==0 ){ if( mem.mutex==0 ){
int i;
assert( sizeof(Mem5Block)==POW2_MIN );
assert( (SQLITE_POW2_MEMORY_SIZE % POW2_MAX)==0 );
assert( SQLITE_POW2_MEMORY_SIZE>=POW2_MAX );
mem.mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MEM); mem.mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MEM);
mem.aPool[0].u.hdr.size4x = SQLITE_POW2_MEMORY_SIZE/2 + 2; sqlite3_mutex_enter(mem.mutex);
mem.aPool[SQLITE_POW2_MEMORY_SIZE/8].u.hdr.prevSize = SQLITE_POW2_MEMORY_SIZE/8; for(i=0; i<NSIZE; i++) mem.aiFreelist[i] = -1;
mem.aPool[SQLITE_POW2_MEMORY_SIZE/8].u.hdr.size4x = 1; for(i=0; i<=NBLOCK-SZ_MAX; i += SZ_MAX){
mem.iMaster = 1; mem.aCtrl[i] = (NSIZE-1) | CTRL_FREE;
mem.szMaster = SQLITE_POW2_MEMORY_SIZE/8; memsys5Link(i, NSIZE-1);
mem.mnMaster = mem.szMaster; }
}else{
sqlite3_mutex_enter(mem.mutex);
} }
sqlite3_mutex_enter(mem.mutex);
} }
/* /*
** Return the amount of memory currently checked out. ** Return the amount of memory currently checked out.
*/ */
sqlite3_int64 sqlite3_memory_used(void){ sqlite3_int64 sqlite3_memory_used(void){
sqlite3_int64 n; return mem.currentOut;
memsys3Enter();
n = SQLITE_POW2_MEMORY_SIZE - mem.szMaster*8;
sqlite3_mutex_leave(mem.mutex);
return n;
} }
/* /*
@ -248,13 +212,11 @@ sqlite3_int64 sqlite3_memory_used(void){
*/ */
sqlite3_int64 sqlite3_memory_highwater(int resetFlag){ sqlite3_int64 sqlite3_memory_highwater(int resetFlag){
sqlite3_int64 n; sqlite3_int64 n;
memsys3Enter(); memsys5Enter();
n = SQLITE_POW2_MEMORY_SIZE - mem.mnMaster*8; n = mem.maxOut;
if( resetFlag ){ if( resetFlag ){
mem.mnMaster = mem.szMaster; mem.maxOut = mem.currentOut;
} }
printf("alloc-cnt=%d avg-size=%lld avg-excess=%lld\n",
mem.nAlloc, mem.totalAlloc/mem.nAlloc, mem.totalExcess/mem.nAlloc);
sqlite3_mutex_leave(mem.mutex); sqlite3_mutex_leave(mem.mutex);
return n; return n;
} }
@ -278,7 +240,7 @@ int sqlite3_memory_alarm(
/* /*
** Called when we are unable to satisfy an allocation of nBytes. ** Called when we are unable to satisfy an allocation of nBytes.
*/ */
static void memsys3OutOfMemory(int nByte){ static void memsys5OutOfMemory(int nByte){
if( !mem.alarmBusy ){ if( !mem.alarmBusy ){
mem.alarmBusy = 1; mem.alarmBusy = 1;
assert( sqlite3_mutex_held(mem.mutex) ); assert( sqlite3_mutex_held(mem.mutex) );
@ -297,232 +259,118 @@ static void memsys3OutOfMemory(int nByte){
int sqlite3MallocSize(void *p){ int sqlite3MallocSize(void *p){
int iSize = 0; int iSize = 0;
if( p ){ if( p ){
Mem3Block *pBlock = (Mem3Block*)p; int i = ((Mem5Block*)p) - mem.aPool;
assert( (pBlock[-1].u.hdr.size4x&1)!=0 ); assert( i>=0 && i<NBLOCK );
iSize = (pBlock[-1].u.hdr.size4x&~3)*2 - 4; iSize = 1 << ((mem.aCtrl[i]&CTRL_LOGSIZE) + SQLITE_POW2_LOGMIN);
} }
return iSize; return iSize;
} }
/* /*
** Chunk i is a free chunk that has been unlinked. Adjust its ** Find the first entry on the freelist iLogsize. Unlink that
** size parameters for check-out and return a pointer to the ** entry and return its index.
** user portion of the chunk.
*/ */
static void *memsys3Checkout(u32 i, int nBlock){ static int memsys5UnlinkFirst(int iLogsize){
u32 x; int i;
assert( sqlite3_mutex_held(mem.mutex) ); int iFirst;
assert( i>=1 );
assert( mem.aPool[i-1].u.hdr.size4x/4==nBlock );
assert( mem.aPool[i+nBlock-1].u.hdr.prevSize==nBlock );
x = mem.aPool[i-1].u.hdr.size4x;
mem.aPool[i-1].u.hdr.size4x = nBlock*4 | 1 | (x&2);
mem.aPool[i+nBlock-1].u.hdr.prevSize = nBlock;
mem.aPool[i+nBlock-1].u.hdr.size4x |= 2;
return &mem.aPool[i];
}
/* assert( iLogsize>=0 && iLogsize<NSIZE );
** Carve a piece off of the end of the mem.iMaster free chunk. i = iFirst = mem.aiFreelist[iLogsize];
** Return a pointer to the new allocation. Or, if the master chunk assert( iFirst>=0 );
** is not large enough, return 0. while( i>0 ){
*/ if( i<iFirst ) iFirst = i;
static void *memsys3FromMaster(int nBlock){ i = mem.aPool[i].u.list.next;
assert( sqlite3_mutex_held(mem.mutex) );
assert( mem.szMaster>=nBlock );
if( nBlock>=mem.szMaster-1 ){
/* Use the entire master */
void *p = memsys3Checkout(mem.iMaster, mem.szMaster);
mem.iMaster = 0;
mem.szMaster = 0;
mem.mnMaster = 0;
return p;
}else{
/* Split the master block. Return the tail. */
u32 newi, x;
newi = mem.iMaster + mem.szMaster - nBlock;
assert( newi > mem.iMaster+1 );
mem.aPool[mem.iMaster+mem.szMaster-1].u.hdr.prevSize = nBlock;
mem.aPool[mem.iMaster+mem.szMaster-1].u.hdr.size4x |= 2;
mem.aPool[newi-1].u.hdr.size4x = nBlock*4 + 1;
mem.szMaster -= nBlock;
mem.aPool[newi-1].u.hdr.prevSize = mem.szMaster;
x = mem.aPool[mem.iMaster-1].u.hdr.size4x & 2;
mem.aPool[mem.iMaster-1].u.hdr.size4x = mem.szMaster*4 | x;
if( mem.szMaster < mem.mnMaster ){
mem.mnMaster = mem.szMaster;
}
return (void*)&mem.aPool[newi];
}
}
/*
** *pRoot is the head of a list of free chunks of the same size
** or same size hash. In other words, *pRoot is an entry in either
** mem.aiSmall[] or mem.aiHash[].
**
** This routine examines all entries on the given list and tries
** to coalesce each entries with adjacent free chunks.
**
** If it sees a chunk that is larger than mem.iMaster, it replaces
** the current mem.iMaster with the new larger chunk. In order for
** this mem.iMaster replacement to work, the master chunk must be
** linked into the hash tables. That is not the normal state of
** affairs, of course. The calling routine must link the master
** chunk before invoking this routine, then must unlink the (possibly
** changed) master chunk once this routine has finished.
*/
static void memsys3Merge(u32 *pRoot){
u32 iNext, prev, size, i, x;
assert( sqlite3_mutex_held(mem.mutex) );
for(i=*pRoot; i>0; i=iNext){
iNext = mem.aPool[i].u.list.next;
size = mem.aPool[i-1].u.hdr.size4x;
assert( (size&1)==0 );
if( (size&2)==0 ){
memsys3UnlinkFromList(i, pRoot);
assert( i > mem.aPool[i-1].u.hdr.prevSize );
prev = i - mem.aPool[i-1].u.hdr.prevSize;
if( prev==iNext ){
iNext = mem.aPool[prev].u.list.next;
}
memsys3Unlink(prev);
size = i + size/4 - prev;
x = mem.aPool[prev-1].u.hdr.size4x & 2;
mem.aPool[prev-1].u.hdr.size4x = size*4 | x;
mem.aPool[prev+size-1].u.hdr.prevSize = size;
memsys3Link(prev);
i = prev;
}else{
size /= 4;
}
if( size>mem.szMaster ){
mem.iMaster = i;
mem.szMaster = size;
}
} }
memsys5Unlink(iFirst, iLogsize);
return iFirst;
} }
/* /*
** Return a block of memory of at least nBytes in size. ** Return a block of memory of at least nBytes in size.
** Return NULL if unable. ** Return NULL if unable.
*/ */
static void *memsys3Malloc(int nByte){ static void *memsys5Malloc(int nByte){
u32 i; int i; /* Index of a mem.aPool[] slot */
int nBlock; int iBin; /* Index into mem.aiFreelist[] */
int toFree; int iFullSz; /* Size of allocation rounded up to power of 2 */
int x; int iLogsize; /* Log2 of iFullSz/POW2_MIN */
assert( sqlite3_mutex_held(mem.mutex) ); assert( sqlite3_mutex_held(mem.mutex) );
assert( sizeof(Mem3Block)==8 ); if( nByte>mem.maxRequest ) mem.maxRequest = nByte;
for(x=256; x<nByte; x *= 2){} if( nByte>POW2_MAX ) return 0;
mem.nAlloc++; for(iFullSz=POW2_MIN, iLogsize=0; iFullSz<nByte; iFullSz *= 2, iLogsize++){}
mem.totalAlloc += x;
mem.totalExcess += x - nByte;
nByte = x;
nBlock = (nByte + 11)/8;
assert( nBlock >= 2 );
/* STEP 1: for(iBin=iLogsize; mem.aiFreelist[iBin]<0 && iBin<NSIZE; iBin++){}
** Look for an entry of the correct size in either the small if( iBin>=NSIZE ) return 0;
** chunk table or in the large chunk hash table. This is i = memsys5UnlinkFirst(iBin);
** successful most of the time (about 9 times out of 10). while( iBin>iLogsize ){
*/ int newSize;
if( nBlock <= MX_SMALL ){
i = mem.aiSmall[nBlock-2]; iBin--;
if( i>0 ){ newSize = 1 << iBin;
memsys3UnlinkFromList(i, &mem.aiSmall[nBlock-2]); mem.aCtrl[i+newSize] = CTRL_FREE | iBin;
return memsys3Checkout(i, nBlock); memsys5Link(i+newSize, iBin);
}
}else{
int hash = nBlock % N_HASH;
for(i=mem.aiHash[hash]; i>0; i=mem.aPool[i].u.list.next){
if( mem.aPool[i-1].u.hdr.size4x/4==nBlock ){
memsys3UnlinkFromList(i, &mem.aiHash[hash]);
return memsys3Checkout(i, nBlock);
}
}
} }
mem.aCtrl[i] = iLogsize;
/* STEP 2: mem.nAlloc++;
** Try to satisfy the allocation by carving a piece off of the end mem.totalAlloc += iFullSz;
** of the master chunk. This step usually works if step 1 fails. mem.totalExcess += iFullSz - nByte;
*/ mem.currentCount++;
if( mem.szMaster>=nBlock ){ mem.currentOut += iFullSz;
return memsys3FromMaster(nBlock); if( mem.maxCount<mem.currentCount ) mem.maxCount = mem.currentCount;
} if( mem.maxOut<mem.currentOut ) mem.maxOut = mem.currentOut;
return (void*)&mem.aPool[i];
/* STEP 3:
** Loop through the entire memory pool. Coalesce adjacent free
** chunks. Recompute the master chunk as the largest free chunk.
** Then try again to satisfy the allocation by carving a piece off
** of the end of the master chunk. This step happens very
** rarely (we hope!)
*/
for(toFree=nBlock*16; toFree<SQLITE_POW2_MEMORY_SIZE*2; toFree *= 2){
memsys3OutOfMemory(toFree);
if( mem.iMaster ){
memsys3Link(mem.iMaster);
mem.iMaster = 0;
mem.szMaster = 0;
}
for(i=0; i<N_HASH; i++){
memsys3Merge(&mem.aiHash[i]);
}
for(i=0; i<MX_SMALL-1; i++){
memsys3Merge(&mem.aiSmall[i]);
}
if( mem.szMaster ){
memsys3Unlink(mem.iMaster);
if( mem.szMaster>=nBlock ){
return memsys3FromMaster(nBlock);
}
}
}
/* If none of the above worked, then we fail. */
return 0;
} }
/* /*
** Free an outstanding memory allocation. ** Free an outstanding memory allocation.
*/ */
void memsys3Free(void *pOld){ void memsys5Free(void *pOld){
Mem3Block *p = (Mem3Block*)pOld; u32 size, iLogsize;
int i; int i;
u32 size, x;
assert( sqlite3_mutex_held(mem.mutex) );
assert( p>mem.aPool && p<&mem.aPool[SQLITE_POW2_MEMORY_SIZE/8] );
i = p - mem.aPool;
assert( (mem.aPool[i-1].u.hdr.size4x&1)==1 );
size = mem.aPool[i-1].u.hdr.size4x/4;
assert( i+size<=SQLITE_POW2_MEMORY_SIZE/8+1 );
mem.aPool[i-1].u.hdr.size4x &= ~1;
mem.aPool[i+size-1].u.hdr.prevSize = size;
mem.aPool[i+size-1].u.hdr.size4x &= ~2;
memsys3Link(i);
/* Try to expand the master using the newly freed chunk */ i = ((Mem5Block*)pOld) - mem.aPool;
if( mem.iMaster ){ assert( sqlite3_mutex_held(mem.mutex) );
while( (mem.aPool[mem.iMaster-1].u.hdr.size4x&2)==0 ){ assert( i>=0 && i<NBLOCK );
size = mem.aPool[mem.iMaster-1].u.hdr.prevSize; assert( (mem.aCtrl[i] & CTRL_FREE)==0 );
mem.iMaster -= size; iLogsize = mem.aCtrl[i] & CTRL_LOGSIZE;
mem.szMaster += size; size = 1<<iLogsize;
memsys3Unlink(mem.iMaster); assert( i+size-1<NBLOCK );
x = mem.aPool[mem.iMaster-1].u.hdr.size4x & 2; mem.aCtrl[i] |= CTRL_FREE;
mem.aPool[mem.iMaster-1].u.hdr.size4x = mem.szMaster*4 | x; mem.aCtrl[i+size-1] |= CTRL_FREE;
mem.aPool[mem.iMaster+mem.szMaster-1].u.hdr.prevSize = mem.szMaster; assert( mem.currentCount>0 );
assert( mem.currentOut>=0 );
mem.currentCount--;
mem.currentOut -= size*POW2_MIN;
assert( mem.currentOut>0 || mem.currentCount==0 );
assert( mem.currentCount>0 || mem.currentOut==0 );
mem.aCtrl[i] = CTRL_FREE | iLogsize;
while( iLogsize<NSIZE-1 ){
int iBuddy;
if( (i>>iLogsize) & 1 ){
iBuddy = i - size;
}else{
iBuddy = i + size;
} }
x = mem.aPool[mem.iMaster-1].u.hdr.size4x & 2; assert( iBuddy>=0 && iBuddy<NBLOCK );
while( (mem.aPool[mem.iMaster+mem.szMaster-1].u.hdr.size4x&1)==0 ){ if( mem.aCtrl[iBuddy]!=(CTRL_FREE | iLogsize) ) break;
memsys3Unlink(mem.iMaster+mem.szMaster); memsys5Unlink(iBuddy, iLogsize);
mem.szMaster += mem.aPool[mem.iMaster+mem.szMaster-1].u.hdr.size4x/4; iLogsize++;
mem.aPool[mem.iMaster-1].u.hdr.size4x = mem.szMaster*4 | x; if( iBuddy<i ){
mem.aPool[mem.iMaster+mem.szMaster-1].u.hdr.prevSize = mem.szMaster; mem.aCtrl[iBuddy] = CTRL_FREE | iLogsize;
mem.aCtrl[i] = 0;
i = iBuddy;
}else{
mem.aCtrl[i] = CTRL_FREE | iLogsize;
mem.aCtrl[iBuddy] = 0;
} }
size *= 2;
} }
memsys5Link(i, iLogsize);
} }
/* /*
@ -531,8 +379,8 @@ void memsys3Free(void *pOld){
void *sqlite3_malloc(int nBytes){ void *sqlite3_malloc(int nBytes){
sqlite3_int64 *p = 0; sqlite3_int64 *p = 0;
if( nBytes>0 ){ if( nBytes>0 ){
memsys3Enter(); memsys5Enter();
p = memsys3Malloc(nBytes); p = memsys5Malloc(nBytes);
sqlite3_mutex_leave(mem.mutex); sqlite3_mutex_leave(mem.mutex);
} }
return (void*)p; return (void*)p;
@ -547,7 +395,7 @@ void sqlite3_free(void *pPrior){
} }
assert( mem.mutex!=0 ); assert( mem.mutex!=0 );
sqlite3_mutex_enter(mem.mutex); sqlite3_mutex_enter(mem.mutex);
memsys3Free(pPrior); memsys5Free(pPrior);
sqlite3_mutex_leave(mem.mutex); sqlite3_mutex_leave(mem.mutex);
} }
@ -566,18 +414,14 @@ void *sqlite3_realloc(void *pPrior, int nBytes){
} }
assert( mem.mutex!=0 ); assert( mem.mutex!=0 );
nOld = sqlite3MallocSize(pPrior); nOld = sqlite3MallocSize(pPrior);
if( nBytes<=nOld && nBytes>=nOld-128 ){ if( nBytes<=nOld ){
return pPrior; return pPrior;
} }
sqlite3_mutex_enter(mem.mutex); sqlite3_mutex_enter(mem.mutex);
p = memsys3Malloc(nBytes); p = memsys5Malloc(nBytes);
if( p ){ if( p ){
if( nOld<nBytes ){ memcpy(p, pPrior, nOld);
memcpy(p, pPrior, nOld); memsys5Free(pPrior);
}else{
memcpy(p, pPrior, nBytes);
}
memsys3Free(pPrior);
} }
sqlite3_mutex_leave(mem.mutex); sqlite3_mutex_leave(mem.mutex);
return p; return p;
@ -590,8 +434,8 @@ void *sqlite3_realloc(void *pPrior, int nBytes){
void sqlite3_memdebug_dump(const char *zFilename){ void sqlite3_memdebug_dump(const char *zFilename){
#ifdef SQLITE_DEBUG #ifdef SQLITE_DEBUG
FILE *out; FILE *out;
int i, j; int i, j, n;
u32 size;
if( zFilename==0 || zFilename[0]==0 ){ if( zFilename==0 || zFilename[0]==0 ){
out = stdout; out = stdout;
}else{ }else{
@ -602,53 +446,19 @@ void sqlite3_memdebug_dump(const char *zFilename){
return; return;
} }
} }
memsys3Enter(); memsys5Enter();
fprintf(out, "CHUNKS:\n"); for(i=0; i<NSIZE; i++){
for(i=1; i<=SQLITE_POW2_MEMORY_SIZE/8; i+=size/4){ for(n=0, j=mem.aiFreelist[i]; j>=0; j = mem.aPool[j].u.list.next, n++){}
size = mem.aPool[i-1].u.hdr.size4x; fprintf(out, "freelist items of size %d: %d\n", POW2_MIN << i, n);
if( size/4<=1 ){
fprintf(out, "%p size error\n", &mem.aPool[i]);
assert( 0 );
break;
}
if( (size&1)==0 && mem.aPool[i+size/4-1].u.hdr.prevSize!=size/4 ){
fprintf(out, "%p tail size does not match\n", &mem.aPool[i]);
assert( 0 );
break;
}
if( ((mem.aPool[i+size/4-1].u.hdr.size4x&2)>>1)!=(size&1) ){
fprintf(out, "%p tail checkout bit is incorrect\n", &mem.aPool[i]);
assert( 0 );
break;
}
if( size&1 ){
fprintf(out, "%p %6d bytes checked out\n", &mem.aPool[i], (size/4)*8-8);
}else{
fprintf(out, "%p %6d bytes free%s\n", &mem.aPool[i], (size/4)*8-8,
i==mem.iMaster ? " **master**" : "");
}
} }
for(i=0; i<MX_SMALL-1; i++){ fprintf(out, "mem.nAlloc = %llu\n", mem.nAlloc);
if( mem.aiSmall[i]==0 ) continue; fprintf(out, "mem.totalAlloc = %llu\n", mem.totalAlloc);
fprintf(out, "small(%2d):", i); fprintf(out, "mem.totalExcess = %llu\n", mem.totalExcess);
for(j = mem.aiSmall[i]; j>0; j=mem.aPool[j].u.list.next){ fprintf(out, "mem.currentOut = %u\n", mem.currentOut);
fprintf(out, " %p(%d)", &mem.aPool[j], fprintf(out, "mem.currentCount = %u\n", mem.currentCount);
(mem.aPool[j-1].u.hdr.size4x/4)*8-8); fprintf(out, "mem.maxOut = %u\n", mem.maxOut);
} fprintf(out, "mem.maxCount = %u\n", mem.maxCount);
fprintf(out, "\n"); fprintf(out, "mem.maxRequest = %u\n", mem.maxRequest);
}
for(i=0; i<N_HASH; i++){
if( mem.aiHash[i]==0 ) continue;
fprintf(out, "hash(%2d):", i);
for(j = mem.aiHash[i]; j>0; j=mem.aPool[j].u.list.next){
fprintf(out, " %p(%d)", &mem.aPool[j],
(mem.aPool[j-1].u.hdr.size4x/4)*8-8);
}
fprintf(out, "\n");
}
fprintf(out, "master=%d\n", mem.iMaster);
fprintf(out, "nowUsed=%d\n", SQLITE_POW2_MEMORY_SIZE - mem.szMaster*8);
fprintf(out, "mxUsed=%d\n", SQLITE_POW2_MEMORY_SIZE - mem.mnMaster*8);
sqlite3_mutex_leave(mem.mutex); sqlite3_mutex_leave(mem.mutex);
if( out==stdout ){ if( out==stdout ){
fflush(stdout); fflush(stdout);

8
src/test_config.c
View File

@ -16,7 +16,7 @@
** The focus of this file is providing the TCL testing layer ** The focus of this file is providing the TCL testing layer
** access to compile-time constants. ** access to compile-time constants.
** **
** $Id: test_config.c,v 1.19 2008/01/23 12:52:41 drh Exp $ ** $Id: test_config.c,v 1.20 2008/02/16 16:21:46 drh Exp $
*/ */
#include "sqliteLimit.h" #include "sqliteLimit.h"
@ -88,6 +88,12 @@ static void set_options(Tcl_Interp *interp){
Tcl_SetVar2(interp, "sqlite_options", "mem3", "0", TCL_GLOBAL_ONLY); Tcl_SetVar2(interp, "sqlite_options", "mem3", "0", TCL_GLOBAL_ONLY);
#endif #endif
#ifdef SQLITE_POW2_MEMORY_SIZE
Tcl_SetVar2(interp, "sqlite_options", "mem5", "1", TCL_GLOBAL_ONLY);
#else
Tcl_SetVar2(interp, "sqlite_options", "mem5", "0", TCL_GLOBAL_ONLY);
#endif
#ifdef SQLITE_OMIT_ALTERTABLE #ifdef SQLITE_OMIT_ALTERTABLE
Tcl_SetVar2(interp, "sqlite_options", "altertable", "0", TCL_GLOBAL_ONLY); Tcl_SetVar2(interp, "sqlite_options", "altertable", "0", TCL_GLOBAL_ONLY);
#else #else

5
src/test_malloc.c
View File

@ -13,7 +13,7 @@
** This file contains code used to implement test interfaces to the ** This file contains code used to implement test interfaces to the
** memory allocation subsystem. ** memory allocation subsystem.
** **
** $Id: test_malloc.c,v 1.12 2008/02/13 18:25:27 danielk1977 Exp $ ** $Id: test_malloc.c,v 1.13 2008/02/16 16:21:46 drh Exp $
*/ */
#include "sqliteInt.h" #include "sqliteInt.h"
#include "tcl.h" #include "tcl.h"
@ -334,7 +334,8 @@ static int test_memdebug_dump(
Tcl_WrongNumArgs(interp, 1, objv, "FILENAME"); Tcl_WrongNumArgs(interp, 1, objv, "FILENAME");
return TCL_ERROR; return TCL_ERROR;
} }
#if defined(SQLITE_MEMDEBUG) || defined(SQLITE_MEMORY_SIZE) #if defined(SQLITE_MEMDEBUG) || defined(SQLITE_MEMORY_SIZE) \
|| defined(SQLITE_POW2_MEMORY_SIZE)
{ {
extern void sqlite3_memdebug_dump(const char*); extern void sqlite3_memdebug_dump(const char*);
sqlite3_memdebug_dump(Tcl_GetString(objv[1])); sqlite3_memdebug_dump(Tcl_GetString(objv[1]));

6
test/tester.tcl
View File

@ -11,7 +11,7 @@
# This file implements some common TCL routines used for regression # This file implements some common TCL routines used for regression
# testing the SQLite library # testing the SQLite library
# #
# $Id: tester.tcl,v 1.104 2008/02/13 18:25:27 danielk1977 Exp $ # $Id: tester.tcl,v 1.105 2008/02/16 16:21:46 drh Exp $
set tcl_precision 15 set tcl_precision 15
@ -215,13 +215,13 @@ proc finalize_testing {} {
if {[sqlite3_memory_used]>0} { if {[sqlite3_memory_used]>0} {
puts "Unfreed memory: [sqlite3_memory_used] bytes" puts "Unfreed memory: [sqlite3_memory_used] bytes"
incr nErr incr nErr
ifcapable memdebug||(mem3&&debug) { ifcapable memdebug||mem5||(mem3&&debug) {
puts "Writing unfreed memory log to \"./memleak.txt\"" puts "Writing unfreed memory log to \"./memleak.txt\""
sqlite3_memdebug_dump ./memleak.txt sqlite3_memdebug_dump ./memleak.txt
} }
} else { } else {
puts "All memory allocations freed - no leaks" puts "All memory allocations freed - no leaks"
ifcapable memdebug { ifcapable memdebug||mem5 {
sqlite3_memdebug_dump ./memusage.txt sqlite3_memdebug_dump ./memusage.txt
} }
} }

1
tool/mksqlite3c.tcl
View File

@ -208,6 +208,7 @@ foreach file {
mem1.c mem1.c
mem2.c mem2.c
mem3.c mem3.c
mem5.c
mutex.c mutex.c
mutex_os2.c mutex_os2.c
mutex_unix.c mutex_unix.c