mirrors/sqlite
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Fix the allocator in mem5.c so that it can be enabled at run time using the sqlite3_config() function. (CVS 5304)

Browse Source 
FossilOrigin-Name: 30ff6bb0b2d1068d28e86ac90bb9f454e4537a2d
This commit is contained in:
danielk1977 2008-06-25 14:26:07 +00:00
parent 32155ef0ff
commit c66c0e14a6
8 changed files with 286 additions and 258 deletions

22
manifest

@ -1,5 +1,5 @@
C Fix\sup\ssome\sdetails\sto\sdo\swith\sthe\smem3.c\s(memsys3)\sallocator.\sIf\sthe\slibrary\sis\scompiled\swith\sSQLITE_ENABLE_MEMSYS3,\sthe\smemsys3\sallocator\scan\sbe\sselected\sat\sruntime.\s(CVS\s5303) C Fix\sthe\sallocator\sin\smem5.c\sso\sthat\sit\scan\sbe\senabled\sat\srun\stime\susing\sthe\ssqlite3_config()\sfunction.\s(CVS\s5304)
D 2008-06-25T10:34:35 D 2008-06-25T14:26:08
F Makefile.arm-wince-mingw32ce-gcc ac5f7b2cef0cd850d6f755ba6ee4ab961b1fadf7 F Makefile.arm-wince-mingw32ce-gcc ac5f7b2cef0cd850d6f755ba6ee4ab961b1fadf7
F Makefile.in ff6f90048555a0088f6a4b7406bed5e55a7c4eff F Makefile.in ff6f90048555a0088f6a4b7406bed5e55a7c4eff
F Makefile.linux-gcc d53183f4aa6a9192d249731c90dbdffbd2c68654 F Makefile.linux-gcc d53183f4aa6a9192d249731c90dbdffbd2c68654
@ -114,14 +114,14 @@ F src/insert.c f8c7da31409ec19a769b960a4a2b9cca7bab80bd
F src/journal.c cffd2cd214e58c0e99c3ff632b3bee6c7cbb260e F src/journal.c cffd2cd214e58c0e99c3ff632b3bee6c7cbb260e
F src/legacy.c 3626c71fb70912abec9a4312beba753a9ce800df F src/legacy.c 3626c71fb70912abec9a4312beba753a9ce800df
F src/loadext.c 40024a0f476c1279494876b9a002001b29e5d3e3 F src/loadext.c 40024a0f476c1279494876b9a002001b29e5d3e3
F src/main.c 5ddfc15bdc034253bdb204522f77f2548d01f2c6 F src/main.c 1291a974ff9ffcb771ce4060795c9c3059268049
F src/malloc.c f52166df8abd7ff6990dbee1a0ce3534addc8617 F src/malloc.c f52166df8abd7ff6990dbee1a0ce3534addc8617
F src/md5.c 008216bbb5d34c6fbab5357aa68575ad8a31516a F src/md5.c 008216bbb5d34c6fbab5357aa68575ad8a31516a
F src/mem1.c 8340fa5f969e9f9b9bdeb54106457a2003456d2b F src/mem1.c 8340fa5f969e9f9b9bdeb54106457a2003456d2b
F src/mem2.c 23f9538f35fbcd5665afe7056a56be0c7ed65aa7 F src/mem2.c 23f9538f35fbcd5665afe7056a56be0c7ed65aa7
F src/mem3.c 8ecfb0a61a363f34922fe3f73e698adf229eb55a F src/mem3.c 8ecfb0a61a363f34922fe3f73e698adf229eb55a
F src/mem4.c 6703adb1717b26d9d70a1c2586b4b7b7ffee7909 F src/mem4.c 6703adb1717b26d9d70a1c2586b4b7b7ffee7909
F src/mem5.c ad31a0a481b86b86f4ac0b6d952e69727d4e113a F src/mem5.c 604b5989eb11bee83f4114208f8d6df0ebbe50df
F src/mutex.c a485a0eac8ee2cd95f66e565b4c6696c18db968f F src/mutex.c a485a0eac8ee2cd95f66e565b4c6696c18db968f
F src/mutex.h 236677b27760d85701b5872d01b5cafedde5f0a9 F src/mutex.h 236677b27760d85701b5872d01b5cafedde5f0a9
F src/mutex_os2.c 9c5637aa4c307c552566d0f0b3bd206245b54a97 F src/mutex_os2.c 9c5637aa4c307c552566d0f0b3bd206245b54a97
@ -142,9 +142,9 @@ F src/printf.c 8b063da9dcde26b7c500a01444b718d86f21bc6e
F src/random.c 5c754319d38abdd6acd74601ee0105504adc508a F src/random.c 5c754319d38abdd6acd74601ee0105504adc508a
F src/select.c 79f60dc4a7e90bb907c7a2cca42f45276d1ead99 F src/select.c 79f60dc4a7e90bb907c7a2cca42f45276d1ead99
F src/shell.c 61fa61932ed52825720ebfd3f8381b8d550ef766 F src/shell.c 61fa61932ed52825720ebfd3f8381b8d550ef766
F src/sqlite.h.in 3ad63197bdc9fa1623c1e139ee6f39e7d2ccfa5b F src/sqlite.h.in b5c731b88ab1275396920103b5ecbefba200d423
F src/sqlite3ext.h f162a72daef5ebf8b211fe8c0ec96e85d22fbf9b F src/sqlite3ext.h f162a72daef5ebf8b211fe8c0ec96e85d22fbf9b
F src/sqliteInt.h 5f0b40ff6924972923b7921cd36731ed292cf4da F src/sqliteInt.h d045d18b412345ed2f9d2e5a05e6de25051522a5
F src/sqliteLimit.h f435e728c6b620ef7312814d660a81f9356eb5c8 F src/sqliteLimit.h f435e728c6b620ef7312814d660a81f9356eb5c8
F src/status.c 6cb10377992505bd69f1ca1d75c1240a65f25a58 F src/status.c 6cb10377992505bd69f1ca1d75c1240a65f25a58
F src/table.c 1fa8f8113ac9cbc09ae4801c6d2a7f0af82c5822 F src/table.c 1fa8f8113ac9cbc09ae4801c6d2a7f0af82c5822
@ -166,7 +166,7 @@ F src/test_devsym.c 6012cb8e3acf812513511025a4fa5d626e0ba19b
F src/test_func.c f4aafa10f17d52c43a64b47717265802e6e552b3 F src/test_func.c f4aafa10f17d52c43a64b47717265802e6e552b3
F src/test_hexio.c 2f1122aa3f012fa0142ee3c36ce5c902a70cd12f F src/test_hexio.c 2f1122aa3f012fa0142ee3c36ce5c902a70cd12f
F src/test_loadext.c df8ab3a6481ddebbdf0d28ebac5d9e0790f7860f F src/test_loadext.c df8ab3a6481ddebbdf0d28ebac5d9e0790f7860f
F src/test_malloc.c 9cb0a261b2e744c1daf0ed407501eb6506ce9f75 F src/test_malloc.c db4b54a81e83c0e71e1780365e022ed96fac52b0
F src/test_md5.c 28209a4e2068711b5443c33104fe41f21d160071 F src/test_md5.c 28209a4e2068711b5443c33104fe41f21d160071
F src/test_mutex.c b1433eb96520656fb3e4a218253a94ac32bd5775 F src/test_mutex.c b1433eb96520656fb3e4a218253a94ac32bd5775
F src/test_onefile.c 1f87d4a21cbfb24a7c35e4333fa0bd34d641f68d F src/test_onefile.c 1f87d4a21cbfb24a7c35e4333fa0bd34d641f68d
@ -422,7 +422,7 @@ F test/pager2.test c025f91b75fe65e85febda64d9416428b8a5cab5
F test/pager3.test 2323bf27fd5bd887b580247e5bce500ceee994b4 F test/pager3.test 2323bf27fd5bd887b580247e5bce500ceee994b4
F test/pageropt.test 6df72c441db0a037b7ec6990d16311c24fbea77b F test/pageropt.test 6df72c441db0a037b7ec6990d16311c24fbea77b
F test/pagesize.test e0a8b3fe80f8b8e808d94a00734c7a18c76c407e F test/pagesize.test e0a8b3fe80f8b8e808d94a00734c7a18c76c407e
F test/permutations.test 501db15728957fa7893117c167f37cc7f1bb9387 F test/permutations.test 23b6ff4ef5f8f1b78d9eb47fda8f8ad080757f49
F test/pragma.test 44bc52afa72cabfeae82641e0033ca24919f3ce8 F test/pragma.test 44bc52afa72cabfeae82641e0033ca24919f3ce8
F test/pragma2.test 5364893491b9231dd170e3459bfc2e2342658b47 F test/pragma2.test 5364893491b9231dd170e3459bfc2e2342658b47
F test/printf.test c3405535b418d454e8a52196a0fc592ec9eec58d F test/printf.test c3405535b418d454e8a52196a0fc592ec9eec58d
@ -594,7 +594,7 @@ F tool/speedtest16.c c8a9c793df96db7e4933f0852abb7a03d48f2e81
F tool/speedtest2.tcl ee2149167303ba8e95af97873c575c3e0fab58ff F tool/speedtest2.tcl ee2149167303ba8e95af97873c575c3e0fab58ff
F tool/speedtest8.c 1dbced29de5f59ba2ebf877edcadf171540374d1 F tool/speedtest8.c 1dbced29de5f59ba2ebf877edcadf171540374d1
F tool/speedtest8inst1.c 293327bc76823f473684d589a8160bde1f52c14e F tool/speedtest8inst1.c 293327bc76823f473684d589a8160bde1f52c14e
P 9902be8d66453d3f4cfdc7f81a4ebe9bc6729204 P 9c6c8e01b31abfe2bc8e650bbfdb504021dc7e59
R 1a2b1623ff42cc1c532b2d95d3c3b31f R 8f7483e2fdaf9f81d7806dda44fbca72
U danielk1977 U danielk1977
Z 75609bc694f005e3e95998b63bdcf69a Z b5c0c1b2ba1d5eb688c90f849be1cc0e

2
manifest.uuid

@ -1 +1 @@
9c6c8e01b31abfe2bc8e650bbfdb504021dc7e59 30ff6bb0b2d1068d28e86ac90bb9f454e4537a2d

10
src/main.c

@ -14,7 +14,7 @@
** other files are for internal use by SQLite and should not be ** other files are for internal use by SQLite and should not be
** accessed by users of the library. ** 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 "sqliteInt.h"
#include <ctype.h> #include <ctype.h>
@ -156,6 +156,14 @@ int sqlite3_config(int op, ...){
sqlite3MemSetMemsys3(pMem, nMem); sqlite3MemSetMemsys3(pMem, nMem);
break; 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 #endif
case SQLITE_CONFIG_MALLOC: { case SQLITE_CONFIG_MALLOC: {
/* Specify an alternative malloc implementation */ /* Specify an alternative malloc implementation */

383
src/mem5.c

@ -13,14 +13,17 @@
** allocation subsystem for use by SQLite. ** allocation subsystem for use by SQLite.
** **
** This version of the memory allocation subsystem omits all ** This version of the memory allocation subsystem omits all
** use of malloc(). All dynamically allocatable memory is ** use of malloc(). The SQLite user supplies a block of memory
** contained in a static array, mem.aPool[]. The size of this ** before calling sqlite3_initialize() from which allocations
** fixed memory pool is SQLITE_POW2_MEMORY_SIZE bytes. ** 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 ** This version of the memory allocation subsystem is included
** and only if SQLITE_POW2_MEMORY_SIZE is defined. ** 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" #include "sqliteInt.h"
@ -28,7 +31,7 @@
** This version of the memory allocator is used only when ** This version of the memory allocator is used only when
** SQLITE_POW2_MEMORY_SIZE is defined. ** 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 ** Log2 of the minimum size of an allocation. For example, if
@ -63,37 +66,32 @@ struct Mem5Block {
union { union {
char aData[POW2_MIN]; char aData[POW2_MIN];
struct { struct {
int next; /* Index in mem.aPool[] of next free chunk */ int next; /* Index in mem5.aPool[] of next free chunk */
int prev; /* Index in mem.aPool[] of previous free chunk */ int prev; /* Index in mem5.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 ** The size in blocks of an POW2_MAX allocation
*/ */
#define SZ_MAX (1<<(NSIZE-1)) #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_LOGSIZE 0x1f /* Log2 Size of this block relative to POW2_MIN */
#define CTRL_FREE 0x20 /* True if not checked out */ #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 "mem5". This is to keep the
** static variables organized and to reduce namespace pollution ** static variables organized and to reduce namespace pollution
** when this module is combined with other in the amalgamation. ** when this module is combined with other in the amalgamation.
*/ */
static struct { 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 ** be held while the callback is running. Recursive calls into
** the memory subsystem are allowed, but no new callbacks will be ** the memory subsystem are allowed, but no new callbacks will be
** issued. The alarmBusy variable is set to prevent recursive ** 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 ** Space for tracking which blocks are checked out and the size
** of each block. One byte per block. ** of each block. One byte per block.
*/ */
u8 aCtrl[NBLOCK]; u8 *aCtrl;
/* /*
** Memory available for allocation ** Memory available for allocation
*/ */
Mem5Block aPool[NBLOCK]; int nBlock;
} mem; Mem5Block *aPool;
} mem5;
/* /*
** Unlink the chunk at mem.aPool[i] from list it is currently ** Unlink the chunk at mem5.aPool[i] from list it is currently
** on. It should be found on mem.aiFreelist[iLogsize]. ** on. It should be found on mem5.aiFreelist[iLogsize].
*/ */
static void memsys5Unlink(int i, int iLogsize){ static void memsys5Unlink(int i, int iLogsize){
int next, prev; int next, prev;
assert( i>=0 && i<NBLOCK ); assert( i>=0 && i<mem5.nBlock );
assert( iLogsize>=0 && iLogsize<NSIZE ); assert( iLogsize>=0 && iLogsize<NSIZE );
assert( (mem.aCtrl[i] & CTRL_LOGSIZE)==iLogsize ); assert( (mem5.aCtrl[i] & CTRL_LOGSIZE)==iLogsize );
assert( sqlite3_mutex_held(mem.mutex) );
next = mem.aPool[i].u.list.next; next = mem5.aPool[i].u.list.next;
prev = mem.aPool[i].u.list.prev; prev = mem5.aPool[i].u.list.prev;
if( prev<0 ){ if( prev<0 ){
mem.aiFreelist[iLogsize] = next; mem5.aiFreelist[iLogsize] = next;
}else{ }else{
mem.aPool[prev].u.list.next = next; mem5.aPool[prev].u.list.next = next;
} }
if( next>=0 ){ 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. ** free list.
*/ */
static void memsys5Link(int i, int iLogsize){ static void memsys5Link(int i, int iLogsize){
int x; int x;
assert( sqlite3_mutex_held(mem.mutex) ); assert( sqlite3_mutex_held(mem5.mutex) );
assert( i>=0 && i<NBLOCK ); assert( i>=0 && i<mem5.nBlock );
assert( iLogsize>=0 && iLogsize<NSIZE ); 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]; mem5.aPool[i].u.list.next = x = mem5.aiFreelist[iLogsize];
mem.aPool[i].u.list.prev = -1; mem5.aPool[i].u.list.prev = -1;
if( x>=0 ){ if( x>=0 ){
assert( x<NBLOCK ); assert( x<mem5.nBlock );
mem.aPool[x].u.list.prev = i; 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 ** Also: Initialize the memory allocation subsystem the first time
** this routine is called. ** this routine is called.
*/ */
static void memsys5Enter(void){ 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);
}
} }
/* static void memsys5Leave(void){
** 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;
} }
/* /*
@ -273,23 +196,16 @@ int sqlite3_memory_alarm(
** size returned omits the 8-byte header overhead. This only ** size returned omits the 8-byte header overhead. This only
** works for chunks that are currently checked out. ** works for chunks that are currently checked out.
*/ */
int sqlite3MallocSize(void *p){ static int memsys5Size(void *p){
int iSize = 0; int iSize = 0;
if( p ){ if( p ){
int i = ((Mem5Block*)p) - mem.aPool; int i = ((Mem5Block*)p) - mem5.aPool;
assert( i>=0 && i<NBLOCK ); assert( i>=0 && i<mem5.nBlock );
iSize = 1 << ((mem.aCtrl[i]&CTRL_LOGSIZE) + SQLITE_POW2_LOGMIN); iSize = 1 << ((mem5.aCtrl[i]&CTRL_LOGSIZE) + SQLITE_POW2_LOGMIN);
} }
return iSize; return iSize;
} }
/*
** Initialize the memmory allocation subsystem.
*/
int sqlite3MallocInit(void){
return SQLITE_OK;
}
/* /*
** Find the first entry on the freelist iLogsize. Unlink that ** Find the first entry on the freelist iLogsize. Unlink that
** entry and return its index. ** entry and return its index.
@ -299,11 +215,11 @@ static int memsys5UnlinkFirst(int iLogsize){
int iFirst; int iFirst;
assert( iLogsize>=0 && iLogsize<NSIZE ); assert( iLogsize>=0 && iLogsize<NSIZE );
i = iFirst = mem.aiFreelist[iLogsize]; i = iFirst = mem5.aiFreelist[iLogsize];
assert( iFirst>=0 ); assert( iFirst>=0 );
while( i>0 ){ while( i>0 ){
if( i<iFirst ) iFirst = i; if( i<iFirst ) iFirst = i;
i = mem.aPool[i].u.list.next; i = mem5.aPool[i].u.list.next;
} }
memsys5Unlink(iFirst, iLogsize); memsys5Unlink(iFirst, iLogsize);
return iFirst; return iFirst;
@ -313,38 +229,27 @@ static int memsys5UnlinkFirst(int iLogsize){
** 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 *memsys5Malloc(int nByte){ static void *memsys5MallocUnsafe(int nByte){
int i; /* Index of a mem.aPool[] slot */ int i; /* Index of a mem5.aPool[] slot */
int iBin; /* Index into mem.aiFreelist[] */ int iBin; /* Index into mem5.aiFreelist[] */
int iFullSz; /* Size of allocation rounded up to power of 2 */ int iFullSz; /* Size of allocation rounded up to power of 2 */
int iLogsize; /* Log2 of iFullSz/POW2_MIN */ int iLogsize; /* Log2 of iFullSz/POW2_MIN */
assert( sqlite3_mutex_held(mem.mutex) );
/* Keep track of the maximum allocation request. Even unfulfilled /* Keep track of the maximum allocation request. Even unfulfilled
** requests are counted */ ** requests are counted */
if( nByte>mem.maxRequest ){ if( nByte>mem5.maxRequest ){
mem.maxRequest = nByte; 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 */ /* Round nByte up to the next valid power of two */
if( nByte>POW2_MAX ) return 0; if( nByte>POW2_MAX ) return 0;
for(iFullSz=POW2_MIN, iLogsize=0; iFullSz<nByte; iFullSz *= 2, iLogsize++){} for(iFullSz=POW2_MIN, iLogsize=0; iFullSz<nByte; iFullSz *= 2, iLogsize++){}
/* If we will be over the memory alarm threshold after this allocation, /* Make sure mem5.aiFreelist[iLogsize] contains at least one free
** 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
** block. If not, then split a block of the next larger power of ** 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. ** 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; if( iBin>=NSIZE ) return 0;
i = memsys5UnlinkFirst(iBin); i = memsys5UnlinkFirst(iBin);
while( iBin>iLogsize ){ while( iBin>iLogsize ){
@ -352,48 +257,47 @@ static void *memsys5Malloc(int nByte){
iBin--; iBin--;
newSize = 1 << iBin; newSize = 1 << iBin;
mem.aCtrl[i+newSize] = CTRL_FREE | iBin; mem5.aCtrl[i+newSize] = CTRL_FREE | iBin;
memsys5Link(i+newSize, iBin); memsys5Link(i+newSize, iBin);
} }
mem.aCtrl[i] = iLogsize; mem5.aCtrl[i] = iLogsize;
/* Update allocator performance statistics. */ /* Update allocator performance statistics. */
mem.nAlloc++; mem5.nAlloc++;
mem.totalAlloc += iFullSz; mem5.totalAlloc += iFullSz;
mem.totalExcess += iFullSz - nByte; mem5.totalExcess += iFullSz - nByte;
mem.currentCount++; mem5.currentCount++;
mem.currentOut += iFullSz; mem5.currentOut += iFullSz;
if( mem.maxCount<mem.currentCount ) mem.maxCount = mem.currentCount; if( mem5.maxCount<mem5.currentCount ) mem5.maxCount = mem5.currentCount;
if( mem.maxOut<mem.currentOut ) mem.maxOut = mem.currentOut; if( mem5.maxOut<mem5.currentOut ) mem5.maxOut = mem5.currentOut;
/* Return a pointer to the allocated memory. */ /* Return a pointer to the allocated memory. */
return (void*)&mem.aPool[i]; return (void*)&mem5.aPool[i];
} }
/* /*
** Free an outstanding memory allocation. ** Free an outstanding memory allocation.
*/ */
void memsys5Free(void *pOld){ static void memsys5FreeUnsafe(void *pOld){
u32 size, iLogsize; u32 size, iLogsize;
int i; int i;
i = ((Mem5Block*)pOld) - mem.aPool; i = ((Mem5Block*)pOld) - mem5.aPool;
assert( sqlite3_mutex_held(mem.mutex) ); assert( i>=0 && i<mem5.nBlock );
assert( i>=0 && i<NBLOCK ); assert( (mem5.aCtrl[i] & CTRL_FREE)==0 );
assert( (mem.aCtrl[i] & CTRL_FREE)==0 ); iLogsize = mem5.aCtrl[i] & CTRL_LOGSIZE;
iLogsize = mem.aCtrl[i] & CTRL_LOGSIZE;
size = 1<<iLogsize; size = 1<<iLogsize;
assert( i+size-1<NBLOCK ); assert( i+size-1<mem5.nBlock );
mem.aCtrl[i] |= CTRL_FREE; mem5.aCtrl[i] |= CTRL_FREE;
mem.aCtrl[i+size-1] |= CTRL_FREE; mem5.aCtrl[i+size-1] |= CTRL_FREE;
assert( mem.currentCount>0 ); assert( mem5.currentCount>0 );
assert( mem.currentOut>=0 ); assert( mem5.currentOut>=0 );
mem.currentCount--; mem5.currentCount--;
mem.currentOut -= size*POW2_MIN; mem5.currentOut -= size*POW2_MIN;
assert( mem.currentOut>0 || mem.currentCount==0 ); assert( mem5.currentOut>0 || mem5.currentCount==0 );
assert( mem.currentCount>0 || mem.currentOut==0 ); assert( mem5.currentCount>0 || mem5.currentOut==0 );
mem.aCtrl[i] = CTRL_FREE | iLogsize; mem5.aCtrl[i] = CTRL_FREE | iLogsize;
while( iLogsize<NSIZE-1 ){ while( iLogsize<NSIZE-1 ){
int iBuddy; int iBuddy;
@ -402,17 +306,17 @@ void memsys5Free(void *pOld){
}else{ }else{
iBuddy = i + size; iBuddy = i + size;
} }
assert( iBuddy>=0 && iBuddy<NBLOCK ); assert( iBuddy>=0 && iBuddy<mem5.nBlock );
if( mem.aCtrl[iBuddy]!=(CTRL_FREE | iLogsize) ) break; if( mem5.aCtrl[iBuddy]!=(CTRL_FREE | iLogsize) ) break;
memsys5Unlink(iBuddy, iLogsize); memsys5Unlink(iBuddy, iLogsize);
iLogsize++; iLogsize++;
if( iBuddy<i ){ if( iBuddy<i ){
mem.aCtrl[iBuddy] = CTRL_FREE | iLogsize; mem5.aCtrl[iBuddy] = CTRL_FREE | iLogsize;
mem.aCtrl[i] = 0; mem5.aCtrl[i] = 0;
i = iBuddy; i = iBuddy;
}else{ }else{
mem.aCtrl[i] = CTRL_FREE | iLogsize; mem5.aCtrl[i] = CTRL_FREE | iLogsize;
mem.aCtrl[iBuddy] = 0; mem5.aCtrl[iBuddy] = 0;
} }
size *= 2; size *= 2;
} }
@ -422,12 +326,12 @@ void memsys5Free(void *pOld){
/* /*
** Allocate nBytes of memory ** Allocate nBytes of memory
*/ */
void *sqlite3_malloc(int nBytes){ static void *memsys5Malloc(int nBytes){
sqlite3_int64 *p = 0; sqlite3_int64 *p = 0;
if( nBytes>0 ){ if( nBytes>0 ){
memsys5Enter(); memsys5Enter();
p = memsys5Malloc(nBytes); p = memsys5MallocUnsafe(nBytes);
sqlite3_mutex_leave(mem.mutex); memsys5Leave();
} }
return (void*)p; return (void*)p;
} }
@ -435,49 +339,70 @@ void *sqlite3_malloc(int nBytes){
/* /*
** Free memory. ** Free memory.
*/ */
void sqlite3_free(void *pPrior){ static void memsys5Free(void *pPrior){
if( pPrior==0 ){ if( pPrior==0 ){
return; return;
} }
assert( mem.mutex!=0 ); memsys5Enter();
sqlite3_mutex_enter(mem.mutex); memsys5FreeUnsafe(pPrior);
memsys5Free(pPrior); memsys5Leave();
sqlite3_mutex_leave(mem.mutex);
} }
/* /*
** Change the size of an existing memory allocation ** Change the size of an existing memory allocation
*/ */
void *sqlite3_realloc(void *pPrior, int nBytes){ static void *memsys5Realloc(void *pPrior, int nBytes){
int nOld; int nOld;
void *p; void *p;
if( pPrior==0 ){ if( pPrior==0 ){
return sqlite3_malloc(nBytes); return memsys5Malloc(nBytes);
} }
if( nBytes<=0 ){ if( nBytes<=0 ){
sqlite3_free(pPrior); memsys5Free(pPrior);
return 0; return 0;
} }
assert( mem.mutex!=0 ); nOld = memsys5Size(pPrior);
nOld = sqlite3MallocSize(pPrior);
if( nBytes<=nOld ){ if( nBytes<=nOld ){
return pPrior; return pPrior;
} }
sqlite3_mutex_enter(mem.mutex); memsys5Enter();
p = memsys5Malloc(nBytes); p = memsys5MallocUnsafe(nBytes);
if( p ){ if( p ){
memcpy(p, pPrior, nOld); memcpy(p, pPrior, nOld);
memsys5Free(pPrior); memsys5FreeUnsafe(pPrior);
} }
sqlite3_mutex_leave(mem.mutex); memsys5Leave();
return p; 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 ** Open the file indicated and write a log of all unfreed memory
** allocations into that log. ** allocations into that log.
*/ */
void sqlite3MemdebugDump(const char *zFilename){ void sqlite3Memsys5Dump(const char *zFilename){
#ifdef SQLITE_DEBUG #ifdef SQLITE_DEBUG
FILE *out; FILE *out;
int i, j, n; int i, j, n;
@ -494,18 +419,18 @@ void sqlite3MemdebugDump(const char *zFilename){
} }
memsys5Enter(); memsys5Enter();
for(i=0; i<NSIZE; i++){ 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, "freelist items of size %d: %d\n", POW2_MIN << i, n);
} }
fprintf(out, "mem.nAlloc = %llu\n", mem.nAlloc); fprintf(out, "mem5.nAlloc = %llu\n", mem5.nAlloc);
fprintf(out, "mem.totalAlloc = %llu\n", mem.totalAlloc); fprintf(out, "mem5.totalAlloc = %llu\n", mem5.totalAlloc);
fprintf(out, "mem.totalExcess = %llu\n", mem.totalExcess); fprintf(out, "mem5.totalExcess = %llu\n", mem5.totalExcess);
fprintf(out, "mem.currentOut = %u\n", mem.currentOut); fprintf(out, "mem5.currentOut = %u\n", mem5.currentOut);
fprintf(out, "mem.currentCount = %u\n", mem.currentCount); fprintf(out, "mem5.currentCount = %u\n", mem5.currentCount);
fprintf(out, "mem.maxOut = %u\n", mem.maxOut); fprintf(out, "mem5.maxOut = %u\n", mem5.maxOut);
fprintf(out, "mem.maxCount = %u\n", mem.maxCount); fprintf(out, "mem5.maxCount = %u\n", mem5.maxCount);
fprintf(out, "mem.maxRequest = %u\n", mem.maxRequest); fprintf(out, "mem5.maxRequest = %u\n", mem5.maxRequest);
sqlite3_mutex_leave(mem.mutex); memsys5Leave();
if( out==stdout ){ if( out==stdout ){
fflush(stdout); fflush(stdout);
}else{ }else{
@ -514,5 +439,47 @@ void sqlite3MemdebugDump(const char *zFilename){
#endif #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;
#endif /* !SQLITE_POW2_MEMORY_SIZE */ 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_ENABLE_MEMSYS5 */

11
src/sqlite.h.in

@ -30,7 +30,7 @@
** the version number) and changes its name to "sqlite3.h" as ** the version number) and changes its name to "sqlite3.h" as
** part of the build process. ** 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_ #ifndef _SQLITE3_H_
#define _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 ** caller must ensure that the block of memory remains valid for as long
** as the memsys3 allocator is in use.</dd> ** 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> ** </dl>
*/ */
#define SQLITE_CONFIG_SINGLETHREAD 1 /* nil */ #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_MUTEX 10 /* sqlite3_mutex_methods* */
#define SQLITE_CONFIG_GETMUTEX 11 /* sqlite3_mutex_methods* */ #define SQLITE_CONFIG_GETMUTEX 11 /* sqlite3_mutex_methods* */
#define SQLITE_CONFIG_MEMSYS3 12 /* u8*, int */ #define SQLITE_CONFIG_MEMSYS3 12 /* u8*, int */
#define SQLITE_CONFIG_MEMSYS5 13 /* u8*, int */
/* /*
** CAPI3REF: Enable Or Disable Extended Result Codes {F12200} ** CAPI3REF: Enable Or Disable Extended Result Codes {F12200}

3
src/sqliteInt.h

@ -11,7 +11,7 @@
************************************************************************* *************************************************************************
** Internal interface definitions for SQLite. ** 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_ #ifndef _SQLITEINT_H_
#define _SQLITEINT_H_ #define _SQLITEINT_H_
@ -1804,6 +1804,7 @@ void *sqlite3PageMalloc(int);
void sqlite3PageFree(void*); void sqlite3PageFree(void*);
void sqlite3MemSetDefault(void); void sqlite3MemSetDefault(void);
void sqlite3MemSetMemsys3(u8 *pBlock, int nBlock); void sqlite3MemSetMemsys3(u8 *pBlock, int nBlock);
void sqlite3MemSetMemsys5(u8 *pBlock, int nBlock);
void sqlite3BenignMallocHooks(void (*)(void), void (*)(void)); void sqlite3BenignMallocHooks(void (*)(void), void (*)(void));
#ifndef SQLITE_MUTEX_NOOP #ifndef SQLITE_MUTEX_NOOP

87
src/test_malloc.c

@ -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.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 "sqliteInt.h"
#include "tcl.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( static int test_config_memsys3(
void * clientData, void * clientData,
Tcl_Interp *interp, Tcl_Interp *interp,
int objc, int objc,
Tcl_Obj *CONST objv[] Tcl_Obj *CONST objv[]
){ ){
int sz, rc; int sz, rc;
Tcl_Obj *pResult; static char buf[1048576];
static char buf[1000000];
if( objc!=2 ){ if( objc!=2 ){
Tcl_WrongNumArgs(interp, 1, objv, "NBYTE"); Tcl_WrongNumArgs(interp, 1, objv, "NBYTE");
return TCL_ERROR; return TCL_ERROR;
@ -956,14 +958,17 @@ static int test_config_memsys3(
if( sz>sizeof(buf) ){ if( sz>sizeof(buf) ){
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); Tcl_SetResult(interp, (char *)sqlite3TestErrorName(rc), TCL_VOLATILE);
return TCL_OK; 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. ** Write a summary of unfreed memsys3 allocations to FILENAME.
*/ */
@ -977,13 +982,23 @@ static int test_dump_memsys3(
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) \
|| defined(SQLITE_POW2_MEMORY_SIZE) switch( (int)clientData ){
{ case SQLITE_CONFIG_MEMSYS3: {
extern void sqlite3Memsys3Dump(const char*); #ifdef SQLITE_ENABLE_MEMSYS3
sqlite3Memsys3Dump(Tcl_GetString(objv[1])); extern void sqlite3Memsys3Dump(const char*);
} sqlite3Memsys3Dump(Tcl_GetString(objv[1]));
break;
#endif #endif
}
case SQLITE_CONFIG_MEMSYS5: {
#ifdef SQLITE_ENABLE_MEMSYS5
extern void sqlite3Memsys5Dump(const char*);
sqlite3Memsys5Dump(Tcl_GetString(objv[1]));
break;
#endif
}
}
return TCL_OK; return TCL_OK;
} }
@ -1069,31 +1084,35 @@ int Sqlitetest_malloc_Init(Tcl_Interp *interp){
static struct { static struct {
char *zName; char *zName;
Tcl_ObjCmdProc *xProc; Tcl_ObjCmdProc *xProc;
int clientData;
} aObjCmd[] = { } aObjCmd[] = {
{ "sqlite3_malloc", test_malloc }, { "sqlite3_malloc", test_malloc ,0. },
{ "sqlite3_realloc", test_realloc }, { "sqlite3_realloc", test_realloc ,0. },
{ "sqlite3_free", test_free }, { "sqlite3_free", test_free ,0. },
{ "memset", test_memset }, { "memset", test_memset ,0. },
{ "memget", test_memget }, { "memget", test_memget ,0. },
{ "sqlite3_memory_used", test_memory_used }, { "sqlite3_memory_used", test_memory_used ,0. },
{ "sqlite3_memory_highwater", test_memory_highwater }, { "sqlite3_memory_highwater", test_memory_highwater ,0. },
{ "sqlite3_memdebug_backtrace", test_memdebug_backtrace }, { "sqlite3_memdebug_backtrace", test_memdebug_backtrace ,0. },
{ "sqlite3_memdebug_dump", test_memdebug_dump }, { "sqlite3_memdebug_dump", test_memdebug_dump ,0. },
{ "sqlite3_memdebug_fail", test_memdebug_fail }, { "sqlite3_memdebug_fail", test_memdebug_fail ,0. },
{ "sqlite3_memdebug_pending", test_memdebug_pending }, { "sqlite3_memdebug_pending", test_memdebug_pending ,0. },
{ "sqlite3_memdebug_settitle", test_memdebug_settitle }, { "sqlite3_memdebug_settitle", test_memdebug_settitle ,0. },
{ "sqlite3_memdebug_malloc_count", test_memdebug_malloc_count }, { "sqlite3_memdebug_malloc_count", test_memdebug_malloc_count ,0. },
{ "sqlite3_memdebug_log", test_memdebug_log }, { "sqlite3_memdebug_log", test_memdebug_log ,0. },
{ "sqlite3_config_scratch", test_config_scratch }, { "sqlite3_config_scratch", test_config_scratch ,0. },
{ "sqlite3_config_pagecache", test_config_pagecache }, { "sqlite3_config_pagecache", test_config_pagecache ,0. },
{ "sqlite3_config_memsys3", test_config_memsys3 }, { "sqlite3_status", test_status ,0. },
{ "sqlite3_dump_memsys3", test_dump_memsys3 }, { "install_malloc_faultsim", test_install_malloc_faultsim ,0. },
{ "sqlite3_status", test_status }, { "sqlite3_config_memsys3", test_config_memsys3, SQLITE_CONFIG_MEMSYS3 },
{ "install_malloc_faultsim", test_install_malloc_faultsim }, { "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; int i;
for(i=0; i<sizeof(aObjCmd)/sizeof(aObjCmd[0]); 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; return TCL_OK;
} }

26
test/permutations.test

@ -9,7 +9,7 @@
# #
#*********************************************************************** #***********************************************************************
# #
# $Id: permutations.test,v 1.5 2008/06/25 10:34:35 danielk1977 Exp $ # $Id: permutations.test,v 1.6 2008/06/25 14:26:09 danielk1977 Exp $
set testdir [file dirname $argv0] set testdir [file dirname $argv0]
source $testdir/tester.tcl source $testdir/tester.tcl
@ -353,6 +353,30 @@ run_tests "memsys3" -description {
sqlite3_initialize sqlite3_initialize
} }
run_tests "memsys5" -description {
Run tests using the allocator in mem3.c.
} -exclude {
incrblob2.test manydb.test autovacuum.test bigrow.test
collate5.test delete3.test index2.test ioerr.test join3.test
pagesize.test bitvec.test capi3.test memsubsys1.test limit.test
memdb.test capi3c.test func.test
} -initialize {
catch {db close}
sqlite3_reset_auto_extension
sqlite3_shutdown
sqlite3_config_memsys5 1000000
install_malloc_faultsim 1
sqlite3_initialize
autoinstall_test_functions
} -shutdown {
catch {db close}
sqlite3_reset_auto_extension
sqlite3_shutdown
sqlite3_config_memsys5 0
install_malloc_faultsim 1
sqlite3_initialize
}
# run_tests "crash_safe_append" -description { # run_tests "crash_safe_append" -description {
# Run crash.test with persistent journals on a SAFE_APPEND file-system. # Run crash.test with persistent journals on a SAFE_APPEND file-system.
# } -initialize { # } -initialize {