1: /*
2: ** 2008 November 18
3: **
4: ** The author disclaims copyright to this source code. In place of
5: ** a legal notice, here is a blessing:
6: **
7: ** May you do good and not evil.
8: ** May you find forgiveness for yourself and forgive others.
9: ** May you share freely, never taking more than you give.
10: **
11: *************************************************************************
12: **
13: ** This file contains code used for testing the SQLite system.
14: ** None of the code in this file goes into a deliverable build.
15: **
16: ** This file contains an application-defined pager cache
17: ** implementation that can be plugged in in place of the
18: ** default pcache. This alternative pager cache will throw
19: ** some errors that the default cache does not.
20: **
21: ** This pagecache implementation is designed for simplicity
22: ** not speed.
23: */
24: #include "sqlite3.h"
25: #include <string.h>
26: #include <assert.h>
27:
28: /*
29: ** Global data used by this test implementation. There is no
30: ** mutexing, which means this page cache will not work in a
31: ** multi-threaded test.
32: */
33: typedef struct testpcacheGlobalType testpcacheGlobalType;
34: struct testpcacheGlobalType {
35: void *pDummy; /* Dummy allocation to simulate failures */
36: int nInstance; /* Number of current instances */
37: unsigned discardChance; /* Chance of discarding on an unpin (0-100) */
38: unsigned prngSeed; /* Seed for the PRNG */
39: unsigned highStress; /* Call xStress agressively */
40: };
41: static testpcacheGlobalType testpcacheGlobal;
42:
43: /*
44: ** Initializer.
45: **
46: ** Verify that the initializer is only called when the system is
47: ** uninitialized. Allocate some memory and report SQLITE_NOMEM if
48: ** the allocation fails. This provides a means to test the recovery
49: ** from a failed initialization attempt. It also verifies that the
50: ** the destructor always gets call - otherwise there would be a
51: ** memory leak.
52: */
53: static int testpcacheInit(void *pArg){
54: assert( pArg==(void*)&testpcacheGlobal );
55: assert( testpcacheGlobal.pDummy==0 );
56: assert( testpcacheGlobal.nInstance==0 );
57: testpcacheGlobal.pDummy = sqlite3_malloc(10);
58: return testpcacheGlobal.pDummy==0 ? SQLITE_NOMEM : SQLITE_OK;
59: }
60:
61: /*
62: ** Destructor
63: **
64: ** Verify that this is only called after initialization.
65: ** Free the memory allocated by the initializer.
66: */
67: static void testpcacheShutdown(void *pArg){
68: assert( pArg==(void*)&testpcacheGlobal );
69: assert( testpcacheGlobal.pDummy!=0 );
70: assert( testpcacheGlobal.nInstance==0 );
71: sqlite3_free( testpcacheGlobal.pDummy );
72: testpcacheGlobal.pDummy = 0;
73: }
74:
75: /*
76: ** Number of pages in a cache.
77: **
78: ** The number of pages is a hard upper bound in this test module.
79: ** If more pages are requested, sqlite3PcacheFetch() returns NULL.
80: **
81: ** If testing with in-memory temp tables, provide a larger pcache.
82: ** Some of the test cases need this.
83: */
84: #if defined(SQLITE_TEMP_STORE) && SQLITE_TEMP_STORE>=2
85: # define TESTPCACHE_NPAGE 499
86: #else
87: # define TESTPCACHE_NPAGE 217
88: #endif
89: #define TESTPCACHE_RESERVE 17
90:
91: /*
92: ** Magic numbers used to determine validity of the page cache.
93: */
94: #define TESTPCACHE_VALID 0x364585fd
95: #define TESTPCACHE_CLEAR 0xd42670d4
96:
97: /*
98: ** Private implementation of a page cache.
99: */
100: typedef struct testpcache testpcache;
101: struct testpcache {
102: int szPage; /* Size of each page. Multiple of 8. */
103: int szExtra; /* Size of extra data that accompanies each page */
104: int bPurgeable; /* True if the page cache is purgeable */
105: int nFree; /* Number of unused slots in a[] */
106: int nPinned; /* Number of pinned slots in a[] */
107: unsigned iRand; /* State of the PRNG */
108: unsigned iMagic; /* Magic number for sanity checking */
109: struct testpcachePage {
110: sqlite3_pcache_page page; /* Base class */
111: unsigned key; /* The key for this page. 0 means unallocated */
112: int isPinned; /* True if the page is pinned */
113: } a[TESTPCACHE_NPAGE]; /* All pages in the cache */
114: };
115:
116: /*
117: ** Get a random number using the PRNG in the given page cache.
118: */
119: static unsigned testpcacheRandom(testpcache *p){
120: unsigned x = 0;
121: int i;
122: for(i=0; i<4; i++){
123: p->iRand = (p->iRand*69069 + 5);
124: x = (x<<8) | ((p->iRand>>16)&0xff);
125: }
126: return x;
127: }
128:
129:
130: /*
131: ** Allocate a new page cache instance.
132: */
133: static sqlite3_pcache *testpcacheCreate(
134: int szPage,
135: int szExtra,
136: int bPurgeable
137: ){
138: int nMem;
139: char *x;
140: testpcache *p;
141: int i;
142: assert( testpcacheGlobal.pDummy!=0 );
143: szPage = (szPage+7)&~7;
144: nMem = sizeof(testpcache) + TESTPCACHE_NPAGE*(szPage+szExtra);
145: p = sqlite3_malloc( nMem );
146: if( p==0 ) return 0;
147: x = (char*)&p[1];
148: p->szPage = szPage;
149: p->szExtra = szExtra;
150: p->nFree = TESTPCACHE_NPAGE;
151: p->nPinned = 0;
152: p->iRand = testpcacheGlobal.prngSeed;
153: p->bPurgeable = bPurgeable;
154: p->iMagic = TESTPCACHE_VALID;
155: for(i=0; i<TESTPCACHE_NPAGE; i++, x += (szPage+szExtra)){
156: p->a[i].key = 0;
157: p->a[i].isPinned = 0;
158: p->a[i].page.pBuf = (void*)x;
159: p->a[i].page.pExtra = (void*)&x[szPage];
160: }
161: testpcacheGlobal.nInstance++;
162: return (sqlite3_pcache*)p;
163: }
164:
165: /*
166: ** Set the cache size
167: */
168: static void testpcacheCachesize(sqlite3_pcache *pCache, int newSize){
169: testpcache *p = (testpcache*)pCache;
170: assert( p->iMagic==TESTPCACHE_VALID );
171: assert( testpcacheGlobal.pDummy!=0 );
172: assert( testpcacheGlobal.nInstance>0 );
173: }
174:
175: /*
176: ** Return the number of pages in the cache that are being used.
177: ** This includes both pinned and unpinned pages.
178: */
179: static int testpcachePagecount(sqlite3_pcache *pCache){
180: testpcache *p = (testpcache*)pCache;
181: assert( p->iMagic==TESTPCACHE_VALID );
182: assert( testpcacheGlobal.pDummy!=0 );
183: assert( testpcacheGlobal.nInstance>0 );
184: return TESTPCACHE_NPAGE - p->nFree;
185: }
186:
187: /*
188: ** Fetch a page.
189: */
190: static sqlite3_pcache_page *testpcacheFetch(
191: sqlite3_pcache *pCache,
192: unsigned key,
193: int createFlag
194: ){
195: testpcache *p = (testpcache*)pCache;
196: int i, j;
197: assert( p->iMagic==TESTPCACHE_VALID );
198: assert( testpcacheGlobal.pDummy!=0 );
199: assert( testpcacheGlobal.nInstance>0 );
200:
201: /* See if the page is already in cache. Return immediately if it is */
202: for(i=0; i<TESTPCACHE_NPAGE; i++){
203: if( p->a[i].key==key ){
204: if( !p->a[i].isPinned ){
205: p->nPinned++;
206: assert( p->nPinned <= TESTPCACHE_NPAGE - p->nFree );
207: p->a[i].isPinned = 1;
208: }
209: return &p->a[i].page;
210: }
211: }
212:
213: /* If createFlag is 0, never allocate a new page */
214: if( createFlag==0 ){
215: return 0;
216: }
217:
218: /* If no pages are available, always fail */
219: if( p->nPinned==TESTPCACHE_NPAGE ){
220: return 0;
221: }
222:
223: /* Do not allocate the last TESTPCACHE_RESERVE pages unless createFlag is 2 */
224: if( p->nPinned>=TESTPCACHE_NPAGE-TESTPCACHE_RESERVE && createFlag<2 ){
225: return 0;
226: }
227:
228: /* Do not allocate if highStress is enabled and createFlag is not 2.
229: **
230: ** The highStress setting causes pagerStress() to be called much more
231: ** often, which exercises the pager logic more intensely.
232: */
233: if( testpcacheGlobal.highStress && createFlag<2 ){
234: return 0;
235: }
236:
237: /* Find a free page to allocate if there are any free pages.
238: ** Withhold TESTPCACHE_RESERVE free pages until createFlag is 2.
239: */
240: if( p->nFree>TESTPCACHE_RESERVE || (createFlag==2 && p->nFree>0) ){
241: j = testpcacheRandom(p) % TESTPCACHE_NPAGE;
242: for(i=0; i<TESTPCACHE_NPAGE; i++, j = (j+1)%TESTPCACHE_NPAGE){
243: if( p->a[j].key==0 ){
244: p->a[j].key = key;
245: p->a[j].isPinned = 1;
246: memset(p->a[j].page.pBuf, 0, p->szPage);
247: memset(p->a[j].page.pExtra, 0, p->szExtra);
248: p->nPinned++;
249: p->nFree--;
250: assert( p->nPinned <= TESTPCACHE_NPAGE - p->nFree );
251: return &p->a[j].page;
252: }
253: }
254:
255: /* The prior loop always finds a freepage to allocate */
256: assert( 0 );
257: }
258:
259: /* If this cache is not purgeable then we have to fail.
260: */
261: if( p->bPurgeable==0 ){
262: return 0;
263: }
264:
265: /* If there are no free pages, recycle a page. The page to
266: ** recycle is selected at random from all unpinned pages.
267: */
268: j = testpcacheRandom(p) % TESTPCACHE_NPAGE;
269: for(i=0; i<TESTPCACHE_NPAGE; i++, j = (j+1)%TESTPCACHE_NPAGE){
270: if( p->a[j].key>0 && p->a[j].isPinned==0 ){
271: p->a[j].key = key;
272: p->a[j].isPinned = 1;
273: memset(p->a[j].page.pBuf, 0, p->szPage);
274: memset(p->a[j].page.pExtra, 0, p->szExtra);
275: p->nPinned++;
276: assert( p->nPinned <= TESTPCACHE_NPAGE - p->nFree );
277: return &p->a[j].page;
278: }
279: }
280:
281: /* The previous loop always finds a page to recycle. */
282: assert(0);
283: return 0;
284: }
285:
286: /*
287: ** Unpin a page.
288: */
289: static void testpcacheUnpin(
290: sqlite3_pcache *pCache,
291: sqlite3_pcache_page *pOldPage,
292: int discard
293: ){
294: testpcache *p = (testpcache*)pCache;
295: int i;
296: assert( p->iMagic==TESTPCACHE_VALID );
297: assert( testpcacheGlobal.pDummy!=0 );
298: assert( testpcacheGlobal.nInstance>0 );
299:
300: /* Randomly discard pages as they are unpinned according to the
301: ** discardChance setting. If discardChance is 0, the random discard
302: ** never happens. If discardChance is 100, it always happens.
303: */
304: if( p->bPurgeable
305: && (100-testpcacheGlobal.discardChance) <= (testpcacheRandom(p)%100)
306: ){
307: discard = 1;
308: }
309:
310: for(i=0; i<TESTPCACHE_NPAGE; i++){
311: if( &p->a[i].page==pOldPage ){
312: /* The pOldPage pointer always points to a pinned page */
313: assert( p->a[i].isPinned );
314: p->a[i].isPinned = 0;
315: p->nPinned--;
316: assert( p->nPinned>=0 );
317: if( discard ){
318: p->a[i].key = 0;
319: p->nFree++;
320: assert( p->nFree<=TESTPCACHE_NPAGE );
321: }
322: return;
323: }
324: }
325:
326: /* The pOldPage pointer always points to a valid page */
327: assert( 0 );
328: }
329:
330:
331: /*
332: ** Rekey a single page.
333: */
334: static void testpcacheRekey(
335: sqlite3_pcache *pCache,
336: sqlite3_pcache_page *pOldPage,
337: unsigned oldKey,
338: unsigned newKey
339: ){
340: testpcache *p = (testpcache*)pCache;
341: int i;
342: assert( p->iMagic==TESTPCACHE_VALID );
343: assert( testpcacheGlobal.pDummy!=0 );
344: assert( testpcacheGlobal.nInstance>0 );
345:
346: /* If there already exists another page at newKey, verify that
347: ** the other page is unpinned and discard it.
348: */
349: for(i=0; i<TESTPCACHE_NPAGE; i++){
350: if( p->a[i].key==newKey ){
351: /* The new key is never a page that is already pinned */
352: assert( p->a[i].isPinned==0 );
353: p->a[i].key = 0;
354: p->nFree++;
355: assert( p->nFree<=TESTPCACHE_NPAGE );
356: break;
357: }
358: }
359:
360: /* Find the page to be rekeyed and rekey it.
361: */
362: for(i=0; i<TESTPCACHE_NPAGE; i++){
363: if( p->a[i].key==oldKey ){
364: /* The oldKey and pOldPage parameters match */
365: assert( &p->a[i].page==pOldPage );
366: /* Page to be rekeyed must be pinned */
367: assert( p->a[i].isPinned );
368: p->a[i].key = newKey;
369: return;
370: }
371: }
372:
373: /* Rekey is always given a valid page to work with */
374: assert( 0 );
375: }
376:
377:
378: /*
379: ** Truncate the page cache. Every page with a key of iLimit or larger
380: ** is discarded.
381: */
382: static void testpcacheTruncate(sqlite3_pcache *pCache, unsigned iLimit){
383: testpcache *p = (testpcache*)pCache;
384: unsigned int i;
385: assert( p->iMagic==TESTPCACHE_VALID );
386: assert( testpcacheGlobal.pDummy!=0 );
387: assert( testpcacheGlobal.nInstance>0 );
388: for(i=0; i<TESTPCACHE_NPAGE; i++){
389: if( p->a[i].key>=iLimit ){
390: p->a[i].key = 0;
391: if( p->a[i].isPinned ){
392: p->nPinned--;
393: assert( p->nPinned>=0 );
394: }
395: p->nFree++;
396: assert( p->nFree<=TESTPCACHE_NPAGE );
397: }
398: }
399: }
400:
401: /*
402: ** Destroy a page cache.
403: */
404: static void testpcacheDestroy(sqlite3_pcache *pCache){
405: testpcache *p = (testpcache*)pCache;
406: assert( p->iMagic==TESTPCACHE_VALID );
407: assert( testpcacheGlobal.pDummy!=0 );
408: assert( testpcacheGlobal.nInstance>0 );
409: p->iMagic = TESTPCACHE_CLEAR;
410: sqlite3_free(p);
411: testpcacheGlobal.nInstance--;
412: }
413:
414:
415: /*
416: ** Invoke this routine to register or unregister the testing pager cache
417: ** implemented by this file.
418: **
419: ** Install the test pager cache if installFlag is 1 and uninstall it if
420: ** installFlag is 0.
421: **
422: ** When installing, discardChance is a number between 0 and 100 that
423: ** indicates the probability of discarding a page when unpinning the
424: ** page. 0 means never discard (unless the discard flag is set).
425: ** 100 means always discard.
426: */
427: void installTestPCache(
428: int installFlag, /* True to install. False to uninstall. */
429: unsigned discardChance, /* 0-100. Chance to discard on unpin */
430: unsigned prngSeed, /* Seed for the PRNG */
431: unsigned highStress /* Call xStress agressively */
432: ){
433: static const sqlite3_pcache_methods2 testPcache = {
434: 1,
435: (void*)&testpcacheGlobal,
436: testpcacheInit,
437: testpcacheShutdown,
438: testpcacheCreate,
439: testpcacheCachesize,
440: testpcachePagecount,
441: testpcacheFetch,
442: testpcacheUnpin,
443: testpcacheRekey,
444: testpcacheTruncate,
445: testpcacheDestroy,
446: };
447: static sqlite3_pcache_methods2 defaultPcache;
448: static int isInstalled = 0;
449:
450: assert( testpcacheGlobal.nInstance==0 );
451: assert( testpcacheGlobal.pDummy==0 );
452: assert( discardChance<=100 );
453: testpcacheGlobal.discardChance = discardChance;
454: testpcacheGlobal.prngSeed = prngSeed ^ (prngSeed<<16);
455: testpcacheGlobal.highStress = highStress;
456: if( installFlag!=isInstalled ){
457: if( installFlag ){
458: sqlite3_config(SQLITE_CONFIG_GETPCACHE2, &defaultPcache);
459: assert( defaultPcache.xCreate!=testpcacheCreate );
460: sqlite3_config(SQLITE_CONFIG_PCACHE2, &testPcache);
461: }else{
462: assert( defaultPcache.xCreate!=0 );
463: sqlite3_config(SQLITE_CONFIG_PCACHE2, &defaultPcache);
464: }
465: isInstalled = installFlag;
466: }
467: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to test_pcache.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / src