mirror of https://github.com/sqlite/sqlite
Fix the allocator in mem5.c so that it can be enabled at run time using the sqlite3_config() function. (CVS 5304)
FossilOrigin-Name: 30ff6bb0b2d1068d28e86ac90bb9f454e4537a2d
This commit is contained in:
danielk1977
parent
32155ef0ff
commit
c66c0e14a6
22
manifest
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)
|
||||
D 2008-06-25T10:34:35
|
||||
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-25T14:26:08
|
||||
F Makefile.arm-wince-mingw32ce-gcc ac5f7b2cef0cd850d6f755ba6ee4ab961b1fadf7
|
||||
F Makefile.in ff6f90048555a0088f6a4b7406bed5e55a7c4eff
|
||||
F Makefile.linux-gcc d53183f4aa6a9192d249731c90dbdffbd2c68654
|
||||
|
|
@ -114,14 +114,14 @@ F src/insert.c f8c7da31409ec19a769b960a4a2b9cca7bab80bd
|
|||
F src/journal.c cffd2cd214e58c0e99c3ff632b3bee6c7cbb260e
|
||||
F src/legacy.c 3626c71fb70912abec9a4312beba753a9ce800df
|
||||
F src/loadext.c 40024a0f476c1279494876b9a002001b29e5d3e3
|
||||
F src/main.c 5ddfc15bdc034253bdb204522f77f2548d01f2c6
|
||||
F src/main.c 1291a974ff9ffcb771ce4060795c9c3059268049
|
||||
F src/malloc.c f52166df8abd7ff6990dbee1a0ce3534addc8617
|
||||
F src/md5.c 008216bbb5d34c6fbab5357aa68575ad8a31516a
|
||||
F src/mem1.c 8340fa5f969e9f9b9bdeb54106457a2003456d2b
|
||||
F src/mem2.c 23f9538f35fbcd5665afe7056a56be0c7ed65aa7
|
||||
F src/mem3.c 8ecfb0a61a363f34922fe3f73e698adf229eb55a
|
||||
F src/mem4.c 6703adb1717b26d9d70a1c2586b4b7b7ffee7909
|
||||
F src/mem5.c ad31a0a481b86b86f4ac0b6d952e69727d4e113a
|
||||
F src/mem5.c 604b5989eb11bee83f4114208f8d6df0ebbe50df
|
||||
F src/mutex.c a485a0eac8ee2cd95f66e565b4c6696c18db968f
|
||||
F src/mutex.h 236677b27760d85701b5872d01b5cafedde5f0a9
|
||||
F src/mutex_os2.c 9c5637aa4c307c552566d0f0b3bd206245b54a97
|
||||
|
|
@ -142,9 +142,9 @@ F src/printf.c 8b063da9dcde26b7c500a01444b718d86f21bc6e
|
|||
F src/random.c 5c754319d38abdd6acd74601ee0105504adc508a
|
||||
F src/select.c 79f60dc4a7e90bb907c7a2cca42f45276d1ead99
|
||||
F src/shell.c 61fa61932ed52825720ebfd3f8381b8d550ef766
|
||||
F src/sqlite.h.in 3ad63197bdc9fa1623c1e139ee6f39e7d2ccfa5b
|
||||
F src/sqlite.h.in b5c731b88ab1275396920103b5ecbefba200d423
|
||||
F src/sqlite3ext.h f162a72daef5ebf8b211fe8c0ec96e85d22fbf9b
|
||||
F src/sqliteInt.h 5f0b40ff6924972923b7921cd36731ed292cf4da
|
||||
F src/sqliteInt.h d045d18b412345ed2f9d2e5a05e6de25051522a5
|
||||
F src/sqliteLimit.h f435e728c6b620ef7312814d660a81f9356eb5c8
|
||||
F src/status.c 6cb10377992505bd69f1ca1d75c1240a65f25a58
|
||||
F src/table.c 1fa8f8113ac9cbc09ae4801c6d2a7f0af82c5822
|
||||
|
|
@ -166,7 +166,7 @@ F src/test_devsym.c 6012cb8e3acf812513511025a4fa5d626e0ba19b
|
|||
F src/test_func.c f4aafa10f17d52c43a64b47717265802e6e552b3
|
||||
F src/test_hexio.c 2f1122aa3f012fa0142ee3c36ce5c902a70cd12f
|
||||
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_mutex.c b1433eb96520656fb3e4a218253a94ac32bd5775
|
||||
F src/test_onefile.c 1f87d4a21cbfb24a7c35e4333fa0bd34d641f68d
|
||||
|
|
@ -422,7 +422,7 @@ F test/pager2.test c025f91b75fe65e85febda64d9416428b8a5cab5
|
|||
F test/pager3.test 2323bf27fd5bd887b580247e5bce500ceee994b4
|
||||
F test/pageropt.test 6df72c441db0a037b7ec6990d16311c24fbea77b
|
||||
F test/pagesize.test e0a8b3fe80f8b8e808d94a00734c7a18c76c407e
|
||||
F test/permutations.test 501db15728957fa7893117c167f37cc7f1bb9387
|
||||
F test/permutations.test 23b6ff4ef5f8f1b78d9eb47fda8f8ad080757f49
|
||||
F test/pragma.test 44bc52afa72cabfeae82641e0033ca24919f3ce8
|
||||
F test/pragma2.test 5364893491b9231dd170e3459bfc2e2342658b47
|
||||
F test/printf.test c3405535b418d454e8a52196a0fc592ec9eec58d
|
||||
|
|
@ -594,7 +594,7 @@ F tool/speedtest16.c c8a9c793df96db7e4933f0852abb7a03d48f2e81
|
|||
F tool/speedtest2.tcl ee2149167303ba8e95af97873c575c3e0fab58ff
|
||||
F tool/speedtest8.c 1dbced29de5f59ba2ebf877edcadf171540374d1
|
||||
F tool/speedtest8inst1.c 293327bc76823f473684d589a8160bde1f52c14e
|
||||
P 9902be8d66453d3f4cfdc7f81a4ebe9bc6729204
|
||||
R 1a2b1623ff42cc1c532b2d95d3c3b31f
|
||||
P 9c6c8e01b31abfe2bc8e650bbfdb504021dc7e59
|
||||
R 8f7483e2fdaf9f81d7806dda44fbca72
|
||||
U danielk1977
|
||||
Z 75609bc694f005e3e95998b63bdcf69a
|
||||
Z b5c0c1b2ba1d5eb688c90f849be1cc0e
|
||||
|
|
|
|||
|
|
@ -1 +1 @@
|
|||
9c6c8e01b31abfe2bc8e650bbfdb504021dc7e59
|
||||
30ff6bb0b2d1068d28e86ac90bb9f454e4537a2d
|
||||
10
src/main.c
10
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>
|
||||
|
|
@ -156,6 +156,14 @@ int sqlite3_config(int op, ...){
|
|||
sqlite3MemSetMemsys3(pMem, nMem);
|
||||
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 */
|
||||
|
|
|
|||
383
src/mem5.c
383
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,23 +196,16 @@ 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 );
|
||||
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 );
|
||||
|
||||
mem.aCtrl[i] = CTRL_FREE | iLogsize;
|
||||
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;
|
||||
|
||||
#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 */
|
||||
|
|
|
|||
|
|
@ -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}
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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]
|
||||
source $testdir/tester.tcl
|
||||
|
|
@ -353,6 +353,30 @@ run_tests "memsys3" -description {
|
|||
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 crash.test with persistent journals on a SAFE_APPEND file-system.
|
||||
# } -initialize {
|
||||
|
|
|
|||
Loading…
Reference in New Issue