Many hyperlinks are disabled.
Use anonymous login
to enable hyperlinks.
Overview
Comment: | Add an alternative application-defined pcache implementation and add test cases to permutations.test to invoke it. Added the SQLITE_CONFIG_GETPCACHE method to sqlite3_config(). (CVS 5920) |
---|---|
Downloads: | Tarball | ZIP archive |
Timelines: | family | ancestors | descendants | both | trunk |
Files: | files | file ages | folders |
SHA1: |
16f1e6ec2ad92f68c0079a0c2b5ca08a |
User & Date: | drh 2008-11-19 01:20:26.000 |
Context
2008-11-19
| ||
09:05 | Changes to avoid "unused parameter" compiler warnings. (CVS 5921) (check-in: 88134322c3 user: danielk1977 tags: trunk) | |
01:20 | Add an alternative application-defined pcache implementation and add test cases to permutations.test to invoke it. Added the SQLITE_CONFIG_GETPCACHE method to sqlite3_config(). (CVS 5920) (check-in: 16f1e6ec2a user: drh tags: trunk) | |
2008-11-18
| ||
23:25 | Fix to the lemon parser template when YYSTACKSIZE is 0 (dynamically allocated stack space). (CVS 5919) (check-in: 00ccc5967f user: drh tags: trunk) | |
Changes
Changes to Makefile.in.
︙ | ︙ | |||
372 373 374 375 376 377 378 379 380 381 382 383 384 385 | $(TOP)/src/test_func.c \ $(TOP)/src/test_hexio.c \ $(TOP)/src/test_malloc.c \ $(TOP)/src/test_md5.c \ $(TOP)/src/test_mutex.c \ $(TOP)/src/test_onefile.c \ $(TOP)/src/test_osinst.c \ $(TOP)/src/test_schema.c \ $(TOP)/src/test_server.c \ $(TOP)/src/test_tclvar.c \ $(TOP)/src/test_thread.c # Header files used by all library source files. # | > | 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 | $(TOP)/src/test_func.c \ $(TOP)/src/test_hexio.c \ $(TOP)/src/test_malloc.c \ $(TOP)/src/test_md5.c \ $(TOP)/src/test_mutex.c \ $(TOP)/src/test_onefile.c \ $(TOP)/src/test_osinst.c \ $(TOP)/src/test_pcache.c \ $(TOP)/src/test_schema.c \ $(TOP)/src/test_server.c \ $(TOP)/src/test_tclvar.c \ $(TOP)/src/test_thread.c # Header files used by all library source files. # |
︙ | ︙ |
Changes to main.mk.
︙ | ︙ | |||
224 225 226 227 228 229 230 231 232 233 234 235 236 237 | $(TOP)/src/test_func.c \ $(TOP)/src/test_hexio.c \ $(TOP)/src/test_malloc.c \ $(TOP)/src/test_md5.c \ $(TOP)/src/test_mutex.c \ $(TOP)/src/test_onefile.c \ $(TOP)/src/test_osinst.c \ $(TOP)/src/test_schema.c \ $(TOP)/src/test_server.c \ $(TOP)/src/test_tclvar.c \ $(TOP)/src/test_thread.c \ $(TOP)/src/test_wsd.c \ #TESTSRC += $(TOP)/ext/fts2/fts2_tokenizer.c | > | 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 | $(TOP)/src/test_func.c \ $(TOP)/src/test_hexio.c \ $(TOP)/src/test_malloc.c \ $(TOP)/src/test_md5.c \ $(TOP)/src/test_mutex.c \ $(TOP)/src/test_onefile.c \ $(TOP)/src/test_osinst.c \ $(TOP)/src/test_pcache.c \ $(TOP)/src/test_schema.c \ $(TOP)/src/test_server.c \ $(TOP)/src/test_tclvar.c \ $(TOP)/src/test_thread.c \ $(TOP)/src/test_wsd.c \ #TESTSRC += $(TOP)/ext/fts2/fts2_tokenizer.c |
︙ | ︙ |
Changes to src/main.c.
︙ | ︙ | |||
10 11 12 13 14 15 16 | ** ************************************************************************* ** Main file for the SQLite library. The routines in this file ** implement the programmer interface to the library. Routines in ** other files are for internal use by SQLite and should not be ** accessed by users of the library. ** | | | 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 | ** ************************************************************************* ** Main file for the SQLite library. The routines in this file ** implement the programmer interface to the library. Routines in ** other files are for internal use by SQLite and should not be ** accessed by users of the library. ** ** $Id: main.c,v 1.513 2008/11/19 01:20:26 drh Exp $ */ #include "sqliteInt.h" #include <ctype.h> #ifdef SQLITE_ENABLE_FTS3 # include "fts3.h" #endif |
︙ | ︙ | |||
310 311 312 313 314 315 316 317 318 319 320 321 322 323 | } case SQLITE_CONFIG_PCACHE: { /* Specify an alternative malloc implementation */ sqlite3GlobalConfig.pcache = *va_arg(ap, sqlite3_pcache_methods*); break; } #if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5) case SQLITE_CONFIG_HEAP: { /* Designate a buffer for heap memory space */ sqlite3GlobalConfig.pHeap = va_arg(ap, void*); sqlite3GlobalConfig.nHeap = va_arg(ap, int); sqlite3GlobalConfig.mnReq = va_arg(ap, int); | > > > > > > > > | 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 | } case SQLITE_CONFIG_PCACHE: { /* Specify an alternative malloc implementation */ sqlite3GlobalConfig.pcache = *va_arg(ap, sqlite3_pcache_methods*); break; } case SQLITE_CONFIG_GETPCACHE: { if( sqlite3GlobalConfig.pcache.xInit==0 ){ sqlite3PCacheSetDefault(); } *va_arg(ap, sqlite3_pcache_methods*) = sqlite3GlobalConfig.pcache; break; } #if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5) case SQLITE_CONFIG_HEAP: { /* Designate a buffer for heap memory space */ sqlite3GlobalConfig.pHeap = va_arg(ap, void*); sqlite3GlobalConfig.nHeap = va_arg(ap, int); sqlite3GlobalConfig.mnReq = va_arg(ap, int); |
︙ | ︙ |
Changes to src/sqlite.h.in.
︙ | ︙ | |||
26 27 28 29 30 31 32 | ** on how SQLite interfaces are suppose to operate. ** ** The name of this file under configuration management is "sqlite.h.in". ** The makefile makes some minor changes to this file (such as inserting ** the version number) and changes its name to "sqlite3.h" as ** part of the build process. ** | | | 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 | ** on how SQLite interfaces are suppose to operate. ** ** The name of this file under configuration management is "sqlite.h.in". ** The makefile makes some minor changes to this file (such as inserting ** the version number) and changes its name to "sqlite3.h" as ** part of the build process. ** ** @(#) $Id: sqlite.h.in,v 1.415 2008/11/19 01:20:26 drh Exp $ */ #ifndef _SQLITE3_H_ #define _SQLITE3_H_ #include <stdarg.h> /* Needed for the definition of va_list */ /* ** Make sure we can call this stuff from C++. |
︙ | ︙ | |||
6679 6680 6681 6682 6683 6684 6685 | ** ** The cache is not required to perform any reference counting. A single ** call to xUnpin() unpins the page regardless of the number of prior calls ** to xFetch(). ** ** The xRekey() method is used to change the key value associated with the ** page passed as the second argument from oldKey to newKey. If the cache | | | > | 6679 6680 6681 6682 6683 6684 6685 6686 6687 6688 6689 6690 6691 6692 6693 6694 6695 | ** ** The cache is not required to perform any reference counting. A single ** call to xUnpin() unpins the page regardless of the number of prior calls ** to xFetch(). ** ** The xRekey() method is used to change the key value associated with the ** page passed as the second argument from oldKey to newKey. If the cache ** previously contains an entry associated with newKey, it should be ** discarded. Any prior cache entry associated with newKey is guaranteed not ** to be pinned. ** ** When SQLite calls the xTruncate() method, the cache must discard all ** existing cache entries with page numbers (keys) greater than or equal ** to the value of the iLimit parameter passed to xTruncate(). If any ** of these pages are pinned, they are implicitly unpinned, meaning that ** they can be safely discarded. ** |
︙ | ︙ |
Changes to src/test_malloc.c.
︙ | ︙ | |||
9 10 11 12 13 14 15 | ** May you share freely, never taking more than you give. ** ************************************************************************* ** ** This file contains code used to implement test interfaces to the ** memory allocation subsystem. ** | | | 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 | ** May you share freely, never taking more than you give. ** ************************************************************************* ** ** This file contains code used to implement test interfaces to the ** memory allocation subsystem. ** ** $Id: test_malloc.c,v 1.51 2008/11/19 01:20:26 drh Exp $ */ #include "sqliteInt.h" #include "tcl.h" #include <stdlib.h> #include <string.h> #include <assert.h> |
︙ | ︙ | |||
940 941 942 943 944 945 946 947 948 949 950 951 952 953 | } pResult = Tcl_NewObj(); Tcl_ListObjAppendElement(0, pResult, Tcl_NewIntObj(rc)); Tcl_ListObjAppendElement(0, pResult, Tcl_NewIntObj(N)); Tcl_SetObjResult(interp, pResult); return TCL_OK; } /* ** Usage: sqlite3_config_memstatus BOOLEAN ** ** Enable or disable memory status reporting using SQLITE_CONFIG_MEMSTATUS. */ static int test_config_memstatus( | > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 | } pResult = Tcl_NewObj(); Tcl_ListObjAppendElement(0, pResult, Tcl_NewIntObj(rc)); Tcl_ListObjAppendElement(0, pResult, Tcl_NewIntObj(N)); Tcl_SetObjResult(interp, pResult); return TCL_OK; } /* ** Usage: sqlite3_config_alt_pcache INSTALL_FLAG DISCARD_CHANCE PRNG_SEED ** ** Set up the alternative test page cache. Install if INSTALL_FLAG is ** true and uninstall (reverting to the default page cache) if INSTALL_FLAG ** is false. DISCARD_CHANGE is an integer between 0 and 100 inclusive ** which determines the chance of discarding a page when unpinned. 100 ** is certainty. 0 is never. PRNG_SEED is the pseudo-random number generator ** seed. */ static int test_alt_pcache( void * clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[] ){ int installFlag; int discardChance; int prngSeed; extern void installTestPCache(int,unsigned,unsigned); if( objc!=4 ){ Tcl_WrongNumArgs(interp, 1, objv, "INSTALLFLAG DISCARDCHANCE PRNGSEEED"); return TCL_ERROR; } if( Tcl_GetIntFromObj(interp, objv[1], &installFlag) ) return TCL_ERROR; if( Tcl_GetIntFromObj(interp, objv[2], &discardChance) ) return TCL_ERROR; if( Tcl_GetIntFromObj(interp, objv[3], &prngSeed) ) return TCL_ERROR; if( discardChance<0 || discardChance>100 ){ Tcl_AppendResult(interp, "discard-chance should be between 0 and 100", (char*)0); return TCL_ERROR; } installTestPCache(installFlag, (unsigned)discardChance, (unsigned)prngSeed); return TCL_OK; } /* ** Usage: sqlite3_config_memstatus BOOLEAN ** ** Enable or disable memory status reporting using SQLITE_CONFIG_MEMSTATUS. */ static int test_config_memstatus( |
︙ | ︙ | |||
1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 | { "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 }, { "sqlite3_db_status", test_db_status ,0 }, { "install_malloc_faultsim", test_install_malloc_faultsim ,0 }, { "sqlite3_config_heap", test_config_heap ,0 }, { "sqlite3_config_memstatus", test_config_memstatus ,0 }, { "sqlite3_config_lookaside", test_config_lookaside ,0 }, { "sqlite3_config_error", test_config_error ,0 }, { "sqlite3_db_config_lookaside",test_db_config_lookaside ,0 }, { "sqlite3_dump_memsys3", test_dump_memsys3 ,3 }, | > | | 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 | { "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_config_alt_pcache", test_alt_pcache ,0 }, { "sqlite3_status", test_status ,0 }, { "sqlite3_db_status", test_db_status ,0 }, { "install_malloc_faultsim", test_install_malloc_faultsim ,0 }, { "sqlite3_config_heap", test_config_heap ,0 }, { "sqlite3_config_memstatus", test_config_memstatus ,0 }, { "sqlite3_config_lookaside", test_config_lookaside ,0 }, { "sqlite3_config_error", test_config_error ,0 }, { "sqlite3_db_config_lookaside",test_db_config_lookaside ,0 }, { "sqlite3_dump_memsys3", test_dump_memsys3 ,3 }, { "sqlite3_dump_memsys5", test_dump_memsys3 ,5 }, }; int i; for(i=0; i<sizeof(aObjCmd)/sizeof(aObjCmd[0]); i++){ ClientData c = (ClientData)aObjCmd[i].clientData; Tcl_CreateObjCommand(interp, aObjCmd[i].zName, aObjCmd[i].xProc, c, 0); } return TCL_OK; } #endif |
Added src/test_pcache.c.
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 | /* ** 2008 November 18 ** ** The author disclaims copyright to this source code. In place of ** a legal notice, here is a blessing: ** ** May you do good and not evil. ** May you find forgiveness for yourself and forgive others. ** May you share freely, never taking more than you give. ** ************************************************************************* ** ** This file contains code used for testing the SQLite system. ** None of the code in this file goes into a deliverable build. ** ** This file contains an application-defined pager cache ** implementation that can be plugged in in place of the ** default pcache. This alternative pager cache will throw ** some errors that the default cache does not. ** ** This pagecache implementation is designed for simplicity ** not speed. ** ** $Id: test_pcache.c,v 1.1 2008/11/19 01:20:26 drh Exp $ */ #include "sqlite3.h" #include <string.h> #include <assert.h> /* ** Global data used by this test implementation. There is no ** mutexing, which means this page cache will not work in a ** multi-threaded test. */ typedef struct testpcacheGlobalType testpcacheGlobalType; struct testpcacheGlobalType { void *pDummy; /* Dummy allocation to simulate failures */ int nInstance; /* Number of current instances */ unsigned discardChance; /* Chance of discarding on an unpin */ unsigned prngSeed; /* Seed for the PRNG */ }; static testpcacheGlobalType testpcacheGlobal; /* ** Initializer. ** ** Verify that the initializer is only called when the system is ** uninitialized. Allocate some memory and report SQLITE_NOMEM if ** the allocation fails. This provides a means to test the recovery ** from a failed initialization attempt. It also verifies that the ** the destructor always gets call - otherwise there would be a ** memory leak. */ static int testpcacheInit(void *pArg){ assert( pArg==(void*)&testpcacheGlobal ); assert( testpcacheGlobal.pDummy==0 ); assert( testpcacheGlobal.nInstance==0 ); testpcacheGlobal.pDummy = sqlite3_malloc(10); return testpcacheGlobal.pDummy==0 ? SQLITE_NOMEM : SQLITE_OK; } /* ** Destructor ** ** Verify that this is only called after initialization. ** Free the memory allocated by the initializer. */ static void testpcacheShutdown(void *pArg){ assert( pArg==(void*)&testpcacheGlobal ); assert( testpcacheGlobal.pDummy!=0 ); assert( testpcacheGlobal.nInstance==0 ); sqlite3_free( testpcacheGlobal.pDummy ); testpcacheGlobal.pDummy = 0; } /* ** Number of pages in a cache */ #define TESTPCACHE_NPAGE 217 #define TESTPCACHE_RESERVE 17 /* ** Magic numbers used to determine validity of the page cache. */ #define TESTPCACHE_VALID 0x364585fd #define TESTPCACHE_CLEAR 0xd42670d4 /* ** Private implementation of a page cache. */ typedef struct testpcache testpcache; struct testpcache { int szPage; /* Size of each page. Multiple of 8. */ int bPurgeable; /* True if the page cache is purgeable */ int nFree; /* Number of unused slots in a[] */ int nPinned; /* Number of pinned slots in a[] */ unsigned iRand; /* State of the PRNG */ unsigned iMagic; /* Magic number for sanity checking */ struct testpcachePage { unsigned key; /* The key for this page. 0 means unallocated */ int isPinned; /* True if the page is pinned */ void *pData; /* Data for this page */ } a[TESTPCACHE_NPAGE]; /* All pages in the cache */ }; /* ** Get a random number using the PRNG in the given page cache. */ static unsigned testpcacheRandom(testpcache *p){ unsigned x = 0; int i; for(i=0; i<4; i++){ p->iRand = (p->iRand*69069 + 5); x = (x<<8) | ((p->iRand>>16)&0xff); } return x; } /* ** Allocate a new page cache instance. */ static sqlite3_pcache *testpcacheCreate(int szPage, int bPurgeable){ int nMem; char *x; testpcache *p; int i; assert( testpcacheGlobal.pDummy!=0 ); szPage = (szPage+7)&~7; nMem = sizeof(testpcache) + TESTPCACHE_NPAGE*szPage; p = sqlite3_malloc( nMem ); if( p==0 ) return 0; x = (char*)&p[1]; p->szPage = szPage; p->nFree = TESTPCACHE_NPAGE; p->nPinned = 0; p->iRand = testpcacheGlobal.prngSeed; p->bPurgeable = bPurgeable; p->iMagic = TESTPCACHE_VALID; for(i=0; i<TESTPCACHE_NPAGE; i++, x += szPage){ p->a[i].key = 0; p->a[i].isPinned = 0; p->a[i].pData = (void*)x; } testpcacheGlobal.nInstance++; return (sqlite3_pcache*)p; } /* ** Set the cache size */ static void testpcacheCachesize(sqlite3_pcache *pCache, int newSize){ testpcache *p = (testpcache*)pCache; assert( p->iMagic==TESTPCACHE_VALID ); assert( newSize>=1 ); assert( testpcacheGlobal.pDummy!=0 ); assert( testpcacheGlobal.nInstance>0 ); } /* ** Return the number of pages in the cache that are being used. ** This includes both pinned and unpinned pages. */ static int testpcachePagecount(sqlite3_pcache *pCache){ testpcache *p = (testpcache*)pCache; assert( p->iMagic==TESTPCACHE_VALID ); assert( testpcacheGlobal.pDummy!=0 ); assert( testpcacheGlobal.nInstance>0 ); return TESTPCACHE_NPAGE - p->nFree; } /* ** Fetch a page. */ static void *testpcacheFetch( sqlite3_pcache *pCache, unsigned key, int createFlag ){ testpcache *p = (testpcache*)pCache; int i, j; assert( p->iMagic==TESTPCACHE_VALID ); assert( testpcacheGlobal.pDummy!=0 ); assert( testpcacheGlobal.nInstance>0 ); /* See if the page is already in cache. Return immediately if it is */ for(i=0; i<TESTPCACHE_NPAGE; i++){ if( p->a[i].key==key ){ if( !p->a[i].isPinned ){ p->nPinned++; assert( p->nPinned <= TESTPCACHE_NPAGE - p->nFree ); p->a[i].isPinned = 1; } return p->a[i].pData; } } /* If createFlag is 0, never allocate a new page */ if( createFlag==0 ){ return 0; } /* If no pages are available, always fail */ if( p->nPinned==TESTPCACHE_NPAGE ){ return 0; } /* Do not allocate the last TESTPCACHE_RESERVE pages unless createFlag is 2 */ if( p->nPinned>=TESTPCACHE_NPAGE-TESTPCACHE_RESERVE && createFlag<2 ){ return 0; } /* Find a free page to allocate if there are any free pages. ** Withhold TESTPCACHE_RESERVE free pages until createFlag is 2. */ if( p->nFree>TESTPCACHE_RESERVE || (createFlag==2 && p->nFree>0) ){ j = testpcacheRandom(p) % TESTPCACHE_NPAGE; for(i=0; i<TESTPCACHE_NPAGE; i++, j = (j+1)%TESTPCACHE_NPAGE){ if( p->a[j].key==0 ){ p->a[j].key = key; p->a[j].isPinned = 1; memset(p->a[j].pData, 0, p->szPage); p->nPinned++; p->nFree--; assert( p->nPinned <= TESTPCACHE_NPAGE - p->nFree ); return p->a[j].pData; } } /* The prior loop always finds a freepage to allocate */ assert( 0 ); } /* If this cache is not purgeable then we have to fail. */ if( p->bPurgeable==0 ){ return 0; } /* If there are no free pages, recycle a page. The page to ** recycle is selected at random from all unpinned pages. */ j = testpcacheRandom(p) % TESTPCACHE_NPAGE; for(i=0; i<TESTPCACHE_NPAGE; i++, j = (j+1)%TESTPCACHE_NPAGE){ if( p->a[j].key>0 && p->a[j].isPinned==0 ){ p->a[j].key = key; p->a[j].isPinned = 1; memset(p->a[j].pData, 0, p->szPage); p->nPinned++; assert( p->nPinned <= TESTPCACHE_NPAGE - p->nFree ); return p->a[j].pData; } } /* The previous loop always finds a page to recycle. */ assert(0); return 0; } /* ** Unpin a page. */ static void testpcacheUnpin( sqlite3_pcache *pCache, void *pOldPage, int discard ){ testpcache *p = (testpcache*)pCache; int i; assert( p->iMagic==TESTPCACHE_VALID ); assert( testpcacheGlobal.pDummy!=0 ); assert( testpcacheGlobal.nInstance>0 ); /* Randomly discard pages as they are unpinned according to the ** discardChance setting. If discardChance is 0, the random discard ** never happens. If discardChance is 100, it always happens. */ if( p->bPurgeable && (100-testpcacheGlobal.discardChance) <= (testpcacheRandom(p)%100) ){ discard = 1; } for(i=0; i<TESTPCACHE_NPAGE; i++){ if( p->a[i].pData==pOldPage ){ /* The pOldPage pointer always points to a pinned page */ assert( p->a[i].isPinned ); p->a[i].isPinned = 0; p->nPinned--; assert( p->nPinned>=0 ); if( discard ){ p->a[i].key = 0; p->nFree++; assert( p->nFree<=TESTPCACHE_NPAGE ); } return; } } /* The pOldPage pointer always points to a valid page */ assert( 0 ); } /* ** Rekey a single page. */ static void testpcacheRekey( sqlite3_pcache *pCache, void *pOldPage, unsigned oldKey, unsigned newKey ){ testpcache *p = (testpcache*)pCache; int i; assert( p->iMagic==TESTPCACHE_VALID ); assert( testpcacheGlobal.pDummy!=0 ); assert( testpcacheGlobal.nInstance>0 ); /* If there already exists another page at newKey, verify that ** the other page is unpinned and discard it. */ for(i=0; i<TESTPCACHE_NPAGE; i++){ if( p->a[i].key==newKey ){ /* The new key is never a page that is already pinned */ assert( p->a[i].isPinned==0 ); p->a[i].key = 0; p->nFree++; assert( p->nFree<=TESTPCACHE_NPAGE ); break; } } /* Find the page to be rekeyed and rekey it. */ for(i=0; i<TESTPCACHE_NPAGE; i++){ if( p->a[i].key==oldKey ){ /* The oldKey and pOldPage parameters match */ assert( p->a[i].pData==pOldPage ); /* Page to be rekeyed must be pinned */ assert( p->a[i].isPinned ); p->a[i].key = newKey; return; } } /* Rekey is always given a valid page to work with */ assert( 0 ); } /* ** Truncate the page cache. Every page with a key of iLimit or larger ** is discarded. */ static void testpcacheTruncate(sqlite3_pcache *pCache, unsigned iLimit){ testpcache *p = (testpcache*)pCache; unsigned int i; assert( p->iMagic==TESTPCACHE_VALID ); assert( testpcacheGlobal.pDummy!=0 ); assert( testpcacheGlobal.nInstance>0 ); for(i=0; i<TESTPCACHE_NPAGE; i++){ if( p->a[i].key>=iLimit ){ p->a[i].key = 0; if( p->a[i].isPinned ){ p->nPinned--; assert( p->nPinned>=0 ); } p->nFree++; assert( p->nFree<=TESTPCACHE_NPAGE ); } } } /* ** Destroy a page cache. */ static void testpcacheDestroy(sqlite3_pcache *pCache){ testpcache *p = (testpcache*)pCache; assert( p->iMagic==TESTPCACHE_VALID ); assert( testpcacheGlobal.pDummy!=0 ); assert( testpcacheGlobal.nInstance>0 ); p->iMagic = TESTPCACHE_CLEAR; sqlite3_free(p); testpcacheGlobal.nInstance--; } /* ** Invoke this routine to register or unregister the testing pager cache ** implemented by this file. ** ** Install the test pager cache if installFlag is 1 and uninstall it if ** installFlag is 0. ** ** When installing, discardChance is a number between 0 and 100 that ** indicates the probability of discarding a page when unpinning the ** page. 0 means never discard (unless the discard flag is set). ** 100 means always discard. */ void installTestPCache( int installFlag, /* True to install. False to uninstall. */ unsigned discardChance, /* 0-100. Chance to discard on unpin */ unsigned prngSeed /* Seed for the PRNG */ ){ static const sqlite3_pcache_methods testPcache = { (void*)&testpcacheGlobal, testpcacheInit, testpcacheShutdown, testpcacheCreate, testpcacheCachesize, testpcachePagecount, testpcacheFetch, testpcacheUnpin, testpcacheRekey, testpcacheTruncate, testpcacheDestroy, }; static sqlite3_pcache_methods defaultPcache; static int isInstalled = 0; assert( testpcacheGlobal.nInstance==0 ); assert( testpcacheGlobal.pDummy==0 ); assert( discardChance<=100 ); testpcacheGlobal.discardChance = discardChance; testpcacheGlobal.prngSeed = prngSeed ^ (prngSeed<<16); if( installFlag!=isInstalled ){ if( installFlag ){ sqlite3_config(SQLITE_CONFIG_GETPCACHE, &defaultPcache); assert( defaultPcache.xCreate!=testpcacheCreate ); sqlite3_config(SQLITE_CONFIG_PCACHE, &testPcache); }else{ assert( defaultPcache.xCreate!=0 ); sqlite3_config(SQLITE_CONFIG_PCACHE, &defaultPcache); } isInstalled = installFlag; } } |
Changes to test/permutations.test.
1 2 3 4 5 6 7 8 9 10 11 | # 2008 June 21 # # The author disclaims copyright to this source code. In place of # a legal notice, here is a blessing: # # May you do good and not evil. # May you find forgiveness for yourself and forgive others. # May you share freely, never taking more than you give. # #*********************************************************************** # | | | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 | # 2008 June 21 # # The author disclaims copyright to this source code. In place of # a legal notice, here is a blessing: # # May you do good and not evil. # May you find forgiveness for yourself and forgive others. # May you share freely, never taking more than you give. # #*********************************************************************** # # $Id: permutations.test,v 1.39 2008/11/19 01:20:26 drh Exp $ set testdir [file dirname $argv0] source $testdir/tester.tcl # Argument processing. # #puts "PERM-DEBUG: argv=$argv" |
︙ | ︙ | |||
600 601 602 603 604 605 606 607 608 609 610 611 612 613 | sqlite3_simulate_device -char safe_append } -shutdown { rename sqlite3 {} rename sqlite3_shutdown sqlite3 } -include [lsort [concat shared_err.test $ALLTESTS]] \ -exclude async3.test # End of tests ############################################################################# if {$::perm::testmode eq "targets"} { puts "" ; exit } # Restore the [sqlite3] command. | > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 | sqlite3_simulate_device -char safe_append } -shutdown { rename sqlite3 {} rename sqlite3_shutdown sqlite3 } -include [lsort [concat shared_err.test $ALLTESTS]] \ -exclude async3.test # The set of tests to run on the alternative-pcache set perm-alt-pcache-testset { async.test attach.test delete.test delete2.test index.test insert.test insert2.test join.test join2.test rollback.test select1.test select2.test trans.test update.test } run_tests "pcache0" -description { Alternative pcache implementation without random discard } -initialize { catch {db close} sqlite3_reset_auto_extension sqlite3_shutdown sqlite3_config_alt_pcache 1 0 1 sqlite3_initialize autoinstall_test_functions } -shutdown { catch {db close} sqlite3_reset_auto_extension sqlite3_shutdown sqlite3_config_alt_pcache 0 0 0 sqlite3_config_lookaside 100 500 install_malloc_faultsim 1 sqlite3_initialize } -include ${perm-alt-pcache-testset} run_tests "pcache10" -description { Alternative pcache implementation without 10% random discard } -initialize { catch {db close} sqlite3_reset_auto_extension sqlite3_shutdown sqlite3_config_alt_pcache 1 50 1 sqlite3_initialize autoinstall_test_functions } -shutdown { catch {db close} sqlite3_reset_auto_extension sqlite3_shutdown sqlite3_config_alt_pcache 0 0 0 sqlite3_initialize } -include ${perm-alt-pcache-testset} run_tests "pcache50" -description { Alternative pcache implementation without 50% random discard } -initialize { catch {db close} sqlite3_reset_auto_extension sqlite3_shutdown sqlite3_config_alt_pcache 1 50 1 sqlite3_initialize autoinstall_test_functions } -shutdown { catch {db close} sqlite3_reset_auto_extension sqlite3_shutdown sqlite3_config_alt_pcache 0 0 0 sqlite3_initialize } -include ${perm-alt-pcache-testset} run_tests "pcache90" -description { Alternative pcache implementation without 90% random discard } -initialize { catch {db close} sqlite3_reset_auto_extension sqlite3_shutdown sqlite3_config_alt_pcache 1 50 1 sqlite3_initialize autoinstall_test_functions } -shutdown { catch {db close} sqlite3_reset_auto_extension sqlite3_shutdown sqlite3_config_alt_pcache 0 0 0 sqlite3_initialize } -include ${perm-alt-pcache-testset} run_tests "pcache100" -description { Alternative pcache implementation that always discards when unpinning } -initialize { catch {db close} sqlite3_reset_auto_extension sqlite3_shutdown sqlite3_config_alt_pcache 1 100 1 sqlite3_initialize autoinstall_test_functions } -shutdown { catch {db close} sqlite3_reset_auto_extension sqlite3_shutdown sqlite3_config_alt_pcache 0 0 0 sqlite3_initialize } -include ${perm-alt-pcache-testset} # End of tests ############################################################################# if {$::perm::testmode eq "targets"} { puts "" ; exit } # Restore the [sqlite3] command. |
︙ | ︙ |