diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/main.c | 10 | ||||
| -rw-r--r-- | src/mem5.c | 385 | ||||
| -rw-r--r-- | src/sqlite.h.in | 11 | ||||
| -rw-r--r-- | src/sqliteInt.h | 3 | ||||
| -rw-r--r-- | src/test_malloc.c | 87 |
5 files changed, 250 insertions, 246 deletions
diff --git a/src/main.c b/src/main.c index 5f231f181..36fe82bbf 100644 --- a/src/main.c +++ b/src/main.c @@ -14,7 +14,7 @@ ** other files are for internal use by SQLite and should not be ** accessed by users of the library. ** -** $Id: main.c,v 1.460 2008/06/25 10:34:35 danielk1977 Exp $ +** $Id: main.c,v 1.461 2008/06/25 14:26:08 danielk1977 Exp $ */ #include "sqliteInt.h" #include <ctype.h> @@ -157,6 +157,14 @@ int sqlite3_config(int op, ...){ break; } #endif +#ifdef SQLITE_ENABLE_MEMSYS5 + case SQLITE_CONFIG_MEMSYS5: { + u8 *pMem = va_arg(ap, u8*); + int nMem = va_arg(ap, int); + sqlite3MemSetMemsys5(pMem, nMem); + break; + } +#endif case SQLITE_CONFIG_MALLOC: { /* Specify an alternative malloc implementation */ sqlite3Config.m = *va_arg(ap, sqlite3_mem_methods*); diff --git a/src/mem5.c b/src/mem5.c index 198b0743e..4ce5bf09e 100644 --- a/src/mem5.c +++ b/src/mem5.c @@ -13,14 +13,17 @@ ** allocation subsystem for use by SQLite. ** ** This version of the memory allocation subsystem omits all -** use of malloc(). All dynamically allocatable memory is -** contained in a static array, mem.aPool[]. The size of this -** fixed memory pool is SQLITE_POW2_MEMORY_SIZE bytes. +** use of malloc(). The SQLite user supplies a block of memory +** before calling sqlite3_initialize() from which allocations +** are made and returned by the xMalloc() and xRealloc() +** implementations. Once sqlite3_initialize() has been called, +** the amount of memory available to SQLite is fixed and cannot +** be changed. ** -** This version of the memory allocation subsystem is used if -** and only if SQLITE_POW2_MEMORY_SIZE is defined. +** This version of the memory allocation subsystem is included +** in the build only if SQLITE_ENABLE_MEMSYS5 is defined. ** -** $Id: mem5.c,v 1.6 2008/06/18 17:09:10 danielk1977 Exp $ +** $Id: mem5.c,v 1.7 2008/06/25 14:26:08 danielk1977 Exp $ */ #include "sqliteInt.h" @@ -28,7 +31,7 @@ ** This version of the memory allocator is used only when ** SQLITE_POW2_MEMORY_SIZE is defined. */ -#ifdef SQLITE_POW2_MEMORY_SIZE +#ifdef SQLITE_ENABLE_MEMSYS5 /* ** Log2 of the minimum size of an allocation. For example, if @@ -63,37 +66,32 @@ struct Mem5Block { union { char aData[POW2_MIN]; struct { - int next; /* Index in mem.aPool[] of next free chunk */ - int prev; /* Index in mem.aPool[] of previous free chunk */ + int next; /* Index in mem5.aPool[] of next free chunk */ + int prev; /* Index in mem5.aPool[] of previous free chunk */ } list; } 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. +** Masks used for mem5.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 -** into a single structure named "mem". This is to keep the +** into a single structure named "mem5". This is to keep the ** static variables organized and to reduce namespace pollution ** when this module is combined with other in the amalgamation. */ static struct { /* - ** The alarm callback and its arguments. The mem.mutex lock will + ** The alarm callback and its arguments. The mem5.mutex lock will ** be held while the callback is running. Recursive calls into ** the memory subsystem are allowed, but no new callbacks will be ** issued. The alarmBusy variable is set to prevent recursive @@ -130,142 +128,67 @@ static struct { ** Space for tracking which blocks are checked out and the size ** of each block. One byte per block. */ - u8 aCtrl[NBLOCK]; + u8 *aCtrl; /* ** Memory available for allocation */ - Mem5Block aPool[NBLOCK]; -} mem; + int nBlock; + Mem5Block *aPool; +} mem5; /* -** Unlink the chunk at mem.aPool[i] from list it is currently -** on. It should be found on mem.aiFreelist[iLogsize]. +** Unlink the chunk at mem5.aPool[i] from list it is currently +** on. It should be found on mem5.aiFreelist[iLogsize]. */ static void memsys5Unlink(int i, int iLogsize){ int next, prev; - assert( i>=0 && i<NBLOCK ); + assert( i>=0 && i<mem5.nBlock ); assert( iLogsize>=0 && iLogsize<NSIZE ); - assert( (mem.aCtrl[i] & CTRL_LOGSIZE)==iLogsize ); - assert( sqlite3_mutex_held(mem.mutex) ); + assert( (mem5.aCtrl[i] & CTRL_LOGSIZE)==iLogsize ); - next = mem.aPool[i].u.list.next; - prev = mem.aPool[i].u.list.prev; + next = mem5.aPool[i].u.list.next; + prev = mem5.aPool[i].u.list.prev; if( prev<0 ){ - mem.aiFreelist[iLogsize] = next; + mem5.aiFreelist[iLogsize] = next; }else{ - mem.aPool[prev].u.list.next = next; + mem5.aPool[prev].u.list.next = next; } if( next>=0 ){ - mem.aPool[next].u.list.prev = prev; + mem5.aPool[next].u.list.prev = prev; } } /* -** Link the chunk at mem.aPool[i] so that is on the iLogsize +** Link the chunk at mem5.aPool[i] so that is on the iLogsize ** free list. */ static void memsys5Link(int i, int iLogsize){ int x; - assert( sqlite3_mutex_held(mem.mutex) ); - assert( i>=0 && i<NBLOCK ); + assert( sqlite3_mutex_held(mem5.mutex) ); + assert( i>=0 && i<mem5.nBlock ); assert( iLogsize>=0 && iLogsize<NSIZE ); - assert( (mem.aCtrl[i] & CTRL_LOGSIZE)==iLogsize ); + assert( (mem5.aCtrl[i] & CTRL_LOGSIZE)==iLogsize ); - mem.aPool[i].u.list.next = x = mem.aiFreelist[iLogsize]; - mem.aPool[i].u.list.prev = -1; + mem5.aPool[i].u.list.next = x = mem5.aiFreelist[iLogsize]; + mem5.aPool[i].u.list.prev = -1; if( x>=0 ){ - assert( x<NBLOCK ); - mem.aPool[x].u.list.prev = i; + assert( x<mem5.nBlock ); + mem5.aPool[x].u.list.prev = i; } - mem.aiFreelist[iLogsize] = i; + mem5.aiFreelist[iLogsize] = i; } /* -** Enter the mutex mem.mutex. Allocate it if it is not already allocated. +** Enter the mutex mem5.mutex. Allocate it if it is not already allocated. ** ** Also: Initialize the memory allocation subsystem the first time ** this routine is called. */ static void memsys5Enter(void){ - 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 = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MEM); - sqlite3_mutex_enter(mem.mutex); - for(i=0; i<NSIZE; i++) mem.aiFreelist[i] = -1; - for(i=0; i<=NBLOCK-SZ_MAX; i += SZ_MAX){ - mem.aCtrl[i] = (NSIZE-1) | CTRL_FREE; - memsys5Link(i, NSIZE-1); - } - }else{ - sqlite3_mutex_enter(mem.mutex); - } -} - -/* -** Return the amount of memory currently checked out. -*/ -sqlite3_int64 sqlite3_memory_used(void){ - return mem.currentOut; -} - -/* -** Return the maximum amount of memory that has ever been -** checked out since either the beginning of this process -** or since the most recent reset. -*/ -sqlite3_int64 sqlite3_memory_highwater(int resetFlag){ - sqlite3_int64 n; - memsys5Enter(); - n = mem.maxOut; - if( resetFlag ){ - mem.maxOut = mem.currentOut; - } - sqlite3_mutex_leave(mem.mutex); - return n; } - -/* -** Trigger the alarm -*/ -static void memsys5Alarm(int nByte){ - void (*xCallback)(void*,sqlite3_int64,int); - sqlite3_int64 nowUsed; - void *pArg; - if( mem.alarmCallback==0 || mem.alarmBusy ) return; - mem.alarmBusy = 1; - xCallback = mem.alarmCallback; - nowUsed = mem.currentOut; - pArg = mem.alarmArg; - sqlite3_mutex_leave(mem.mutex); - xCallback(pArg, nowUsed, nByte); - sqlite3_mutex_enter(mem.mutex); - mem.alarmBusy = 0; -} - -/* -** Change the alarm callback. -** -** This is a no-op for the static memory allocator. The purpose -** of the memory alarm is to support sqlite3_soft_heap_limit(). -** But with this memory allocator, the soft_heap_limit is really -** a hard limit that is fixed at SQLITE_POW2_MEMORY_SIZE. -*/ -int sqlite3_memory_alarm( - void(*xCallback)(void *pArg, sqlite3_int64 used,int N), - void *pArg, - sqlite3_int64 iThreshold -){ - memsys5Enter(); - mem.alarmCallback = xCallback; - mem.alarmArg = pArg; - mem.alarmThreshold = iThreshold; - sqlite3_mutex_leave(mem.mutex); - return SQLITE_OK; +static void memsys5Leave(void){ } /* @@ -273,24 +196,17 @@ int sqlite3_memory_alarm( ** size returned omits the 8-byte header overhead. This only ** works for chunks that are currently checked out. */ -int sqlite3MallocSize(void *p){ +static int memsys5Size(void *p){ int iSize = 0; if( p ){ - int i = ((Mem5Block*)p) - mem.aPool; - assert( i>=0 && i<NBLOCK ); - iSize = 1 << ((mem.aCtrl[i]&CTRL_LOGSIZE) + SQLITE_POW2_LOGMIN); + int i = ((Mem5Block*)p) - mem5.aPool; + assert( i>=0 && i<mem5.nBlock ); + iSize = 1 << ((mem5.aCtrl[i]&CTRL_LOGSIZE) + SQLITE_POW2_LOGMIN); } return iSize; } /* -** Initialize the memmory allocation subsystem. -*/ -int sqlite3MallocInit(void){ - return SQLITE_OK; -} - -/* ** Find the first entry on the freelist iLogsize. Unlink that ** entry and return its index. */ @@ -299,11 +215,11 @@ static int memsys5UnlinkFirst(int iLogsize){ int iFirst; assert( iLogsize>=0 && iLogsize<NSIZE ); - i = iFirst = mem.aiFreelist[iLogsize]; + i = iFirst = mem5.aiFreelist[iLogsize]; assert( iFirst>=0 ); while( i>0 ){ if( i<iFirst ) iFirst = i; - i = mem.aPool[i].u.list.next; + i = mem5.aPool[i].u.list.next; } memsys5Unlink(iFirst, iLogsize); return iFirst; @@ -313,38 +229,27 @@ static int memsys5UnlinkFirst(int iLogsize){ ** Return a block of memory of at least nBytes in size. ** Return NULL if unable. */ -static void *memsys5Malloc(int nByte){ - int i; /* Index of a mem.aPool[] slot */ - int iBin; /* Index into mem.aiFreelist[] */ +static void *memsys5MallocUnsafe(int nByte){ + int i; /* Index of a mem5.aPool[] slot */ + int iBin; /* Index into mem5.aiFreelist[] */ int iFullSz; /* Size of allocation rounded up to power of 2 */ int iLogsize; /* Log2 of iFullSz/POW2_MIN */ - assert( sqlite3_mutex_held(mem.mutex) ); - /* Keep track of the maximum allocation request. Even unfulfilled ** requests are counted */ - if( nByte>mem.maxRequest ){ - mem.maxRequest = nByte; + if( nByte>mem5.maxRequest ){ + mem5.maxRequest = nByte; } - /* Simulate a memory allocation fault */ - if( sqlite3FaultStep(SQLITE_FAULTINJECTOR_MALLOC) ) return 0; - /* Round nByte up to the next valid power of two */ if( nByte>POW2_MAX ) return 0; for(iFullSz=POW2_MIN, iLogsize=0; iFullSz<nByte; iFullSz *= 2, iLogsize++){} - /* If we will be over the memory alarm threshold after this allocation, - ** then trigger the memory overflow alarm */ - if( mem.alarmCallback!=0 && mem.currentOut+iFullSz>=mem.alarmThreshold ){ - memsys5Alarm(iFullSz); - } - - /* Make sure mem.aiFreelist[iLogsize] contains at least one free + /* Make sure mem5.aiFreelist[iLogsize] contains at least one free ** block. If not, then split a block of the next larger power of ** two in order to create a new free block of size iLogsize. */ - for(iBin=iLogsize; mem.aiFreelist[iBin]<0 && iBin<NSIZE; iBin++){} + for(iBin=iLogsize; mem5.aiFreelist[iBin]<0 && iBin<NSIZE; iBin++){} if( iBin>=NSIZE ) return 0; i = memsys5UnlinkFirst(iBin); while( iBin>iLogsize ){ @@ -352,48 +257,47 @@ static void *memsys5Malloc(int nByte){ iBin--; newSize = 1 << iBin; - mem.aCtrl[i+newSize] = CTRL_FREE | iBin; + mem5.aCtrl[i+newSize] = CTRL_FREE | iBin; memsys5Link(i+newSize, iBin); } - mem.aCtrl[i] = iLogsize; + mem5.aCtrl[i] = iLogsize; /* Update allocator performance statistics. */ - mem.nAlloc++; - mem.totalAlloc += iFullSz; - mem.totalExcess += iFullSz - nByte; - mem.currentCount++; - mem.currentOut += iFullSz; - if( mem.maxCount<mem.currentCount ) mem.maxCount = mem.currentCount; - if( mem.maxOut<mem.currentOut ) mem.maxOut = mem.currentOut; + mem5.nAlloc++; + mem5.totalAlloc += iFullSz; + mem5.totalExcess += iFullSz - nByte; + mem5.currentCount++; + mem5.currentOut += iFullSz; + if( mem5.maxCount<mem5.currentCount ) mem5.maxCount = mem5.currentCount; + if( mem5.maxOut<mem5.currentOut ) mem5.maxOut = mem5.currentOut; /* Return a pointer to the allocated memory. */ - return (void*)&mem.aPool[i]; + return (void*)&mem5.aPool[i]; } /* ** Free an outstanding memory allocation. */ -void memsys5Free(void *pOld){ +static void memsys5FreeUnsafe(void *pOld){ u32 size, iLogsize; int i; - i = ((Mem5Block*)pOld) - mem.aPool; - assert( sqlite3_mutex_held(mem.mutex) ); - assert( i>=0 && i<NBLOCK ); - assert( (mem.aCtrl[i] & CTRL_FREE)==0 ); - iLogsize = mem.aCtrl[i] & CTRL_LOGSIZE; + i = ((Mem5Block*)pOld) - mem5.aPool; + assert( i>=0 && i<mem5.nBlock ); + assert( (mem5.aCtrl[i] & CTRL_FREE)==0 ); + iLogsize = mem5.aCtrl[i] & CTRL_LOGSIZE; size = 1<<iLogsize; - assert( i+size-1<NBLOCK ); - mem.aCtrl[i] |= CTRL_FREE; - mem.aCtrl[i+size-1] |= CTRL_FREE; - 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; + assert( i+size-1<mem5.nBlock ); + mem5.aCtrl[i] |= CTRL_FREE; + mem5.aCtrl[i+size-1] |= CTRL_FREE; + assert( mem5.currentCount>0 ); + assert( mem5.currentOut>=0 ); + mem5.currentCount--; + mem5.currentOut -= size*POW2_MIN; + assert( mem5.currentOut>0 || mem5.currentCount==0 ); + assert( mem5.currentCount>0 || mem5.currentOut==0 ); + + mem5.aCtrl[i] = CTRL_FREE | iLogsize; while( iLogsize<NSIZE-1 ){ int iBuddy; @@ -402,17 +306,17 @@ void memsys5Free(void *pOld){ }else{ iBuddy = i + size; } - assert( iBuddy>=0 && iBuddy<NBLOCK ); - if( mem.aCtrl[iBuddy]!=(CTRL_FREE | iLogsize) ) break; + assert( iBuddy>=0 && iBuddy<mem5.nBlock ); + if( mem5.aCtrl[iBuddy]!=(CTRL_FREE | iLogsize) ) break; memsys5Unlink(iBuddy, iLogsize); iLogsize++; if( iBuddy<i ){ - mem.aCtrl[iBuddy] = CTRL_FREE | iLogsize; - mem.aCtrl[i] = 0; + mem5.aCtrl[iBuddy] = CTRL_FREE | iLogsize; + mem5.aCtrl[i] = 0; i = iBuddy; }else{ - mem.aCtrl[i] = CTRL_FREE | iLogsize; - mem.aCtrl[iBuddy] = 0; + mem5.aCtrl[i] = CTRL_FREE | iLogsize; + mem5.aCtrl[iBuddy] = 0; } size *= 2; } @@ -422,12 +326,12 @@ void memsys5Free(void *pOld){ /* ** Allocate nBytes of memory */ -void *sqlite3_malloc(int nBytes){ +static void *memsys5Malloc(int nBytes){ sqlite3_int64 *p = 0; if( nBytes>0 ){ memsys5Enter(); - p = memsys5Malloc(nBytes); - sqlite3_mutex_leave(mem.mutex); + p = memsys5MallocUnsafe(nBytes); + memsys5Leave(); } return (void*)p; } @@ -435,49 +339,70 @@ void *sqlite3_malloc(int nBytes){ /* ** Free memory. */ -void sqlite3_free(void *pPrior){ +static void memsys5Free(void *pPrior){ if( pPrior==0 ){ return; } - assert( mem.mutex!=0 ); - sqlite3_mutex_enter(mem.mutex); - memsys5Free(pPrior); - sqlite3_mutex_leave(mem.mutex); + memsys5Enter(); + memsys5FreeUnsafe(pPrior); + memsys5Leave(); } /* ** Change the size of an existing memory allocation */ -void *sqlite3_realloc(void *pPrior, int nBytes){ +static void *memsys5Realloc(void *pPrior, int nBytes){ int nOld; void *p; if( pPrior==0 ){ - return sqlite3_malloc(nBytes); + return memsys5Malloc(nBytes); } if( nBytes<=0 ){ - sqlite3_free(pPrior); + memsys5Free(pPrior); return 0; } - assert( mem.mutex!=0 ); - nOld = sqlite3MallocSize(pPrior); + nOld = memsys5Size(pPrior); if( nBytes<=nOld ){ return pPrior; } - sqlite3_mutex_enter(mem.mutex); - p = memsys5Malloc(nBytes); + memsys5Enter(); + p = memsys5MallocUnsafe(nBytes); if( p ){ memcpy(p, pPrior, nOld); - memsys5Free(pPrior); + memsys5FreeUnsafe(pPrior); } - sqlite3_mutex_leave(mem.mutex); + memsys5Leave(); return p; } /* +** Round up a request size to the next valid allocation size. +*/ +static int memsys5Roundup(int n){ + int iFullSz; + for(iFullSz=POW2_MIN; iFullSz<n; iFullSz *= 2); + return iFullSz; +} + +/* +** Initialize this module. +*/ +static int memsys5Init(void *NotUsed){ + return SQLITE_OK; +} + +/* +** Deinitialize this module. +*/ +static void memsys5Shutdown(void *NotUsed){ + return; +} + +/* ** Open the file indicated and write a log of all unfreed memory ** allocations into that log. */ -void sqlite3MemdebugDump(const char *zFilename){ +void sqlite3Memsys5Dump(const char *zFilename){ #ifdef SQLITE_DEBUG FILE *out; int i, j, n; @@ -494,18 +419,18 @@ void sqlite3MemdebugDump(const char *zFilename){ } memsys5Enter(); for(i=0; i<NSIZE; i++){ - for(n=0, j=mem.aiFreelist[i]; j>=0; j = mem.aPool[j].u.list.next, n++){} + for(n=0, j=mem5.aiFreelist[i]; j>=0; j = mem5.aPool[j].u.list.next, n++){} fprintf(out, "freelist items of size %d: %d\n", POW2_MIN << i, n); } - fprintf(out, "mem.nAlloc = %llu\n", mem.nAlloc); - fprintf(out, "mem.totalAlloc = %llu\n", mem.totalAlloc); - fprintf(out, "mem.totalExcess = %llu\n", mem.totalExcess); - fprintf(out, "mem.currentOut = %u\n", mem.currentOut); - fprintf(out, "mem.currentCount = %u\n", mem.currentCount); - fprintf(out, "mem.maxOut = %u\n", mem.maxOut); - fprintf(out, "mem.maxCount = %u\n", mem.maxCount); - fprintf(out, "mem.maxRequest = %u\n", mem.maxRequest); - sqlite3_mutex_leave(mem.mutex); + fprintf(out, "mem5.nAlloc = %llu\n", mem5.nAlloc); + fprintf(out, "mem5.totalAlloc = %llu\n", mem5.totalAlloc); + fprintf(out, "mem5.totalExcess = %llu\n", mem5.totalExcess); + fprintf(out, "mem5.currentOut = %u\n", mem5.currentOut); + fprintf(out, "mem5.currentCount = %u\n", mem5.currentCount); + fprintf(out, "mem5.maxOut = %u\n", mem5.maxOut); + fprintf(out, "mem5.maxCount = %u\n", mem5.maxCount); + fprintf(out, "mem5.maxRequest = %u\n", mem5.maxRequest); + memsys5Leave(); if( out==stdout ){ fflush(stdout); }else{ @@ -514,5 +439,47 @@ void sqlite3MemdebugDump(const char *zFilename){ #endif } +/* +** This routine is the only routine in this file with external +** linkage. +** +** Populate the low-level memory allocation function pointers in +** sqlite3Config.m with pointers to the routines in this file. The +** arguments specify the block of memory to manage. +** +** This routine is only called by sqlite3_config(), and therefore +** is not required to be threadsafe (it is not). +*/ +void sqlite3MemSetMemsys5(u8 *zByte, int nByte){ + static const sqlite3_mem_methods memsys5Methods = { + memsys5Malloc, + memsys5Free, + memsys5Realloc, + memsys5Size, + memsys5Roundup, + memsys5Init, + memsys5Shutdown, + 0 + }; + int i; + + mem5.nBlock = (nByte / (sizeof(Mem5Block)+sizeof(u8))); + mem5.nBlock -= (mem5.nBlock%SZ_MAX); + mem5.aPool = (Mem5Block *)zByte; + mem5.aCtrl = (u8 *)&mem5.aPool[mem5.nBlock]; + + assert( sizeof(Mem5Block)==POW2_MIN ); + assert( mem5.nBlock>=SZ_MAX ); + assert( (mem5.nBlock%SZ_MAX)==0 ); + + for(i=0; i<NSIZE; i++) mem5.aiFreelist[i] = -1; + for(i=0; i<=mem5.nBlock-SZ_MAX; i += SZ_MAX){ + mem5.aCtrl[i] = (NSIZE-1) | CTRL_FREE; + memsys5Link(i, NSIZE-1); + } + + /* Configure the functions to call to allocate memory. */ + sqlite3_config(SQLITE_CONFIG_MALLOC, &memsys5Methods); +} -#endif /* !SQLITE_POW2_MEMORY_SIZE */ +#endif /* SQLITE_ENABLE_MEMSYS5 */ diff --git a/src/sqlite.h.in b/src/sqlite.h.in index dd1557f65..39ab45b73 100644 --- a/src/sqlite.h.in +++ b/src/sqlite.h.in @@ -30,7 +30,7 @@ ** the version number) and changes its name to "sqlite3.h" as ** part of the build process. ** -** @(#) $Id: sqlite.h.in,v 1.356 2008/06/25 10:34:35 danielk1977 Exp $ +** @(#) $Id: sqlite.h.in,v 1.357 2008/06/25 14:26:08 danielk1977 Exp $ */ #ifndef _SQLITE3_H_ #define _SQLITE3_H_ @@ -1115,6 +1115,14 @@ struct sqlite3_mem_methods { ** caller must ensure that the block of memory remains valid for as long ** as the memsys3 allocator is in use.</dd> ** +** <dt>SQLITE_CONFIG_MEMSYS5</dt> +** <dd>This option is only available if SQLite is compiled with the +** SQLITE_ENABLE_MEMSYS5 symbol defined. If available, then it is similar +** to the SQLITE_CONFIG_MEMSYS3 option. The "memsys5" allocator differs +** from the "memsys3" allocator in that it rounds all allocations up to +** the next largest power of two. Although this is sometimes more wasteful +** than the procudures used by memsys3, it guarantees an upper limit on +** internal fragmentation.</dd> ** </dl> */ #define SQLITE_CONFIG_SINGLETHREAD 1 /* nil */ @@ -1129,6 +1137,7 @@ struct sqlite3_mem_methods { #define SQLITE_CONFIG_MUTEX 10 /* sqlite3_mutex_methods* */ #define SQLITE_CONFIG_GETMUTEX 11 /* sqlite3_mutex_methods* */ #define SQLITE_CONFIG_MEMSYS3 12 /* u8*, int */ +#define SQLITE_CONFIG_MEMSYS5 13 /* u8*, int */ /* ** CAPI3REF: Enable Or Disable Extended Result Codes {F12200} diff --git a/src/sqliteInt.h b/src/sqliteInt.h index 7b94f368c..34a69bcde 100644 --- a/src/sqliteInt.h +++ b/src/sqliteInt.h @@ -11,7 +11,7 @@ ************************************************************************* ** Internal interface definitions for SQLite. ** -** @(#) $Id: sqliteInt.h,v 1.727 2008/06/25 10:34:35 danielk1977 Exp $ +** @(#) $Id: sqliteInt.h,v 1.728 2008/06/25 14:26:08 danielk1977 Exp $ */ #ifndef _SQLITEINT_H_ #define _SQLITEINT_H_ @@ -1804,6 +1804,7 @@ void *sqlite3PageMalloc(int); void sqlite3PageFree(void*); void sqlite3MemSetDefault(void); void sqlite3MemSetMemsys3(u8 *pBlock, int nBlock); +void sqlite3MemSetMemsys5(u8 *pBlock, int nBlock); void sqlite3BenignMallocHooks(void (*)(void), void (*)(void)); #ifndef SQLITE_MUTEX_NOOP diff --git a/src/test_malloc.c b/src/test_malloc.c index 95b44ac5f..dbb6fecf4 100644 --- a/src/test_malloc.c +++ b/src/test_malloc.c @@ -13,7 +13,7 @@ ** This file contains code used to implement test interfaces to the ** memory allocation subsystem. ** -** $Id: test_malloc.c,v 1.30 2008/06/25 10:34:35 danielk1977 Exp $ +** $Id: test_malloc.c,v 1.31 2008/06/25 14:26:09 danielk1977 Exp $ */ #include "sqliteInt.h" #include "tcl.h" @@ -931,18 +931,20 @@ static int test_config_pagecache( } /* -** Usage: sqlite3_config_memsys3 NBYTE +** Usage: +** +** sqlite3_config_memsys3 NBYTE +** sqlite3_config_memsys5 NBYTE ** */ static int test_config_memsys3( - void * clientData, + void * clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[] ){ int sz, rc; - Tcl_Obj *pResult; - static char buf[1000000]; + static char buf[1048576]; if( objc!=2 ){ Tcl_WrongNumArgs(interp, 1, objv, "NBYTE"); return TCL_ERROR; @@ -956,14 +958,17 @@ static int test_config_memsys3( if( sz>sizeof(buf) ){ sz = sizeof(buf); } - rc = sqlite3_config(SQLITE_CONFIG_MEMSYS3, buf, sz); + rc = sqlite3_config((int)clientData, buf, sz); } Tcl_SetResult(interp, (char *)sqlite3TestErrorName(rc), TCL_VOLATILE); return TCL_OK; } /* -** Usage: sqlite3_dump_memsys3 FILENAME +** Usage: +** +** sqlite3_dump_memsys3 FILENAME +** sqlite3_dump_memsys5 FILENAME ** ** Write a summary of unfreed memsys3 allocations to FILENAME. */ @@ -977,13 +982,23 @@ static int test_dump_memsys3( Tcl_WrongNumArgs(interp, 1, objv, "FILENAME"); return TCL_ERROR; } -#if defined(SQLITE_MEMDEBUG) || defined(SQLITE_MEMORY_SIZE) \ - || defined(SQLITE_POW2_MEMORY_SIZE) - { - extern void sqlite3Memsys3Dump(const char*); - sqlite3Memsys3Dump(Tcl_GetString(objv[1])); - } + + switch( (int)clientData ){ + case SQLITE_CONFIG_MEMSYS3: { +#ifdef SQLITE_ENABLE_MEMSYS3 + extern void sqlite3Memsys3Dump(const char*); + sqlite3Memsys3Dump(Tcl_GetString(objv[1])); + break; #endif + } + case SQLITE_CONFIG_MEMSYS5: { +#ifdef SQLITE_ENABLE_MEMSYS5 + extern void sqlite3Memsys5Dump(const char*); + sqlite3Memsys5Dump(Tcl_GetString(objv[1])); + break; +#endif + } + } return TCL_OK; } @@ -1069,31 +1084,35 @@ int Sqlitetest_malloc_Init(Tcl_Interp *interp){ static struct { char *zName; Tcl_ObjCmdProc *xProc; + int clientData; } aObjCmd[] = { - { "sqlite3_malloc", test_malloc }, - { "sqlite3_realloc", test_realloc }, - { "sqlite3_free", test_free }, - { "memset", test_memset }, - { "memget", test_memget }, - { "sqlite3_memory_used", test_memory_used }, - { "sqlite3_memory_highwater", test_memory_highwater }, - { "sqlite3_memdebug_backtrace", test_memdebug_backtrace }, - { "sqlite3_memdebug_dump", test_memdebug_dump }, - { "sqlite3_memdebug_fail", test_memdebug_fail }, - { "sqlite3_memdebug_pending", test_memdebug_pending }, - { "sqlite3_memdebug_settitle", test_memdebug_settitle }, - { "sqlite3_memdebug_malloc_count", test_memdebug_malloc_count }, - { "sqlite3_memdebug_log", test_memdebug_log }, - { "sqlite3_config_scratch", test_config_scratch }, - { "sqlite3_config_pagecache", test_config_pagecache }, - { "sqlite3_config_memsys3", test_config_memsys3 }, - { "sqlite3_dump_memsys3", test_dump_memsys3 }, - { "sqlite3_status", test_status }, - { "install_malloc_faultsim", test_install_malloc_faultsim }, + { "sqlite3_malloc", test_malloc ,0. }, + { "sqlite3_realloc", test_realloc ,0. }, + { "sqlite3_free", test_free ,0. }, + { "memset", test_memset ,0. }, + { "memget", test_memget ,0. }, + { "sqlite3_memory_used", test_memory_used ,0. }, + { "sqlite3_memory_highwater", test_memory_highwater ,0. }, + { "sqlite3_memdebug_backtrace", test_memdebug_backtrace ,0. }, + { "sqlite3_memdebug_dump", test_memdebug_dump ,0. }, + { "sqlite3_memdebug_fail", test_memdebug_fail ,0. }, + { "sqlite3_memdebug_pending", test_memdebug_pending ,0. }, + { "sqlite3_memdebug_settitle", test_memdebug_settitle ,0. }, + { "sqlite3_memdebug_malloc_count", test_memdebug_malloc_count ,0. }, + { "sqlite3_memdebug_log", test_memdebug_log ,0. }, + { "sqlite3_config_scratch", test_config_scratch ,0. }, + { "sqlite3_config_pagecache", test_config_pagecache ,0. }, + { "sqlite3_status", test_status ,0. }, + { "install_malloc_faultsim", test_install_malloc_faultsim ,0. }, + { "sqlite3_config_memsys3", test_config_memsys3, SQLITE_CONFIG_MEMSYS3 }, + { "sqlite3_config_memsys5", test_config_memsys3, SQLITE_CONFIG_MEMSYS5 }, + { "sqlite3_dump_memsys3", test_dump_memsys3 , SQLITE_CONFIG_MEMSYS3 }, + { "sqlite3_dump_memsys5", test_dump_memsys3 , SQLITE_CONFIG_MEMSYS5 } }; int i; for(i=0; i<sizeof(aObjCmd)/sizeof(aObjCmd[0]); i++){ - Tcl_CreateObjCommand(interp, aObjCmd[i].zName, aObjCmd[i].xProc, 0, 0); + ClientData c = (ClientData)aObjCmd[i].clientData; + Tcl_CreateObjCommand(interp, aObjCmd[i].zName, aObjCmd[i].xProc, c, 0); } return TCL_OK; } |