Annotation of embedaddon/sqlite3/src/pcache1.c, revision 1.1.1.1
1.1 misho 1: /*
2: ** 2008 November 05
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 implements the default page cache implementation (the
14: ** sqlite3_pcache interface). It also contains part of the implementation
15: ** of the SQLITE_CONFIG_PAGECACHE and sqlite3_release_memory() features.
16: ** If the default page cache implementation is overriden, then neither of
17: ** these two features are available.
18: */
19:
20: #include "sqliteInt.h"
21:
22: typedef struct PCache1 PCache1;
23: typedef struct PgHdr1 PgHdr1;
24: typedef struct PgFreeslot PgFreeslot;
25: typedef struct PGroup PGroup;
26:
27: /* Each page cache (or PCache) belongs to a PGroup. A PGroup is a set
28: ** of one or more PCaches that are able to recycle each others unpinned
29: ** pages when they are under memory pressure. A PGroup is an instance of
30: ** the following object.
31: **
32: ** This page cache implementation works in one of two modes:
33: **
34: ** (1) Every PCache is the sole member of its own PGroup. There is
35: ** one PGroup per PCache.
36: **
37: ** (2) There is a single global PGroup that all PCaches are a member
38: ** of.
39: **
40: ** Mode 1 uses more memory (since PCache instances are not able to rob
41: ** unused pages from other PCaches) but it also operates without a mutex,
42: ** and is therefore often faster. Mode 2 requires a mutex in order to be
43: ** threadsafe, but recycles pages more efficiently.
44: **
45: ** For mode (1), PGroup.mutex is NULL. For mode (2) there is only a single
46: ** PGroup which is the pcache1.grp global variable and its mutex is
47: ** SQLITE_MUTEX_STATIC_LRU.
48: */
49: struct PGroup {
50: sqlite3_mutex *mutex; /* MUTEX_STATIC_LRU or NULL */
51: unsigned int nMaxPage; /* Sum of nMax for purgeable caches */
52: unsigned int nMinPage; /* Sum of nMin for purgeable caches */
53: unsigned int mxPinned; /* nMaxpage + 10 - nMinPage */
54: unsigned int nCurrentPage; /* Number of purgeable pages allocated */
55: PgHdr1 *pLruHead, *pLruTail; /* LRU list of unpinned pages */
56: };
57:
58: /* Each page cache is an instance of the following object. Every
59: ** open database file (including each in-memory database and each
60: ** temporary or transient database) has a single page cache which
61: ** is an instance of this object.
62: **
63: ** Pointers to structures of this type are cast and returned as
64: ** opaque sqlite3_pcache* handles.
65: */
66: struct PCache1 {
67: /* Cache configuration parameters. Page size (szPage) and the purgeable
68: ** flag (bPurgeable) are set when the cache is created. nMax may be
69: ** modified at any time by a call to the pcache1Cachesize() method.
70: ** The PGroup mutex must be held when accessing nMax.
71: */
72: PGroup *pGroup; /* PGroup this cache belongs to */
73: int szPage; /* Size of allocated pages in bytes */
74: int szExtra; /* Size of extra space in bytes */
75: int bPurgeable; /* True if cache is purgeable */
76: unsigned int nMin; /* Minimum number of pages reserved */
77: unsigned int nMax; /* Configured "cache_size" value */
78: unsigned int n90pct; /* nMax*9/10 */
79:
80: /* Hash table of all pages. The following variables may only be accessed
81: ** when the accessor is holding the PGroup mutex.
82: */
83: unsigned int nRecyclable; /* Number of pages in the LRU list */
84: unsigned int nPage; /* Total number of pages in apHash */
85: unsigned int nHash; /* Number of slots in apHash[] */
86: PgHdr1 **apHash; /* Hash table for fast lookup by key */
87:
88: unsigned int iMaxKey; /* Largest key seen since xTruncate() */
89: };
90:
91: /*
92: ** Each cache entry is represented by an instance of the following
93: ** structure. Unless SQLITE_PCACHE_SEPARATE_HEADER is defined, a buffer of
94: ** PgHdr1.pCache->szPage bytes is allocated directly before this structure
95: ** in memory.
96: */
97: struct PgHdr1 {
98: sqlite3_pcache_page page;
99: unsigned int iKey; /* Key value (page number) */
100: PgHdr1 *pNext; /* Next in hash table chain */
101: PCache1 *pCache; /* Cache that currently owns this page */
102: PgHdr1 *pLruNext; /* Next in LRU list of unpinned pages */
103: PgHdr1 *pLruPrev; /* Previous in LRU list of unpinned pages */
104: };
105:
106: /*
107: ** Free slots in the allocator used to divide up the buffer provided using
108: ** the SQLITE_CONFIG_PAGECACHE mechanism.
109: */
110: struct PgFreeslot {
111: PgFreeslot *pNext; /* Next free slot */
112: };
113:
114: /*
115: ** Global data used by this cache.
116: */
117: static SQLITE_WSD struct PCacheGlobal {
118: PGroup grp; /* The global PGroup for mode (2) */
119:
120: /* Variables related to SQLITE_CONFIG_PAGECACHE settings. The
121: ** szSlot, nSlot, pStart, pEnd, nReserve, and isInit values are all
122: ** fixed at sqlite3_initialize() time and do not require mutex protection.
123: ** The nFreeSlot and pFree values do require mutex protection.
124: */
125: int isInit; /* True if initialized */
126: int szSlot; /* Size of each free slot */
127: int nSlot; /* The number of pcache slots */
128: int nReserve; /* Try to keep nFreeSlot above this */
129: void *pStart, *pEnd; /* Bounds of pagecache malloc range */
130: /* Above requires no mutex. Use mutex below for variable that follow. */
131: sqlite3_mutex *mutex; /* Mutex for accessing the following: */
132: int nFreeSlot; /* Number of unused pcache slots */
133: PgFreeslot *pFree; /* Free page blocks */
134: /* The following value requires a mutex to change. We skip the mutex on
135: ** reading because (1) most platforms read a 32-bit integer atomically and
136: ** (2) even if an incorrect value is read, no great harm is done since this
137: ** is really just an optimization. */
138: int bUnderPressure; /* True if low on PAGECACHE memory */
139: } pcache1_g;
140:
141: /*
142: ** All code in this file should access the global structure above via the
143: ** alias "pcache1". This ensures that the WSD emulation is used when
144: ** compiling for systems that do not support real WSD.
145: */
146: #define pcache1 (GLOBAL(struct PCacheGlobal, pcache1_g))
147:
148: /*
149: ** Macros to enter and leave the PCache LRU mutex.
150: */
151: #define pcache1EnterMutex(X) sqlite3_mutex_enter((X)->mutex)
152: #define pcache1LeaveMutex(X) sqlite3_mutex_leave((X)->mutex)
153:
154: /******************************************************************************/
155: /******** Page Allocation/SQLITE_CONFIG_PCACHE Related Functions **************/
156:
157: /*
158: ** This function is called during initialization if a static buffer is
159: ** supplied to use for the page-cache by passing the SQLITE_CONFIG_PAGECACHE
160: ** verb to sqlite3_config(). Parameter pBuf points to an allocation large
161: ** enough to contain 'n' buffers of 'sz' bytes each.
162: **
163: ** This routine is called from sqlite3_initialize() and so it is guaranteed
164: ** to be serialized already. There is no need for further mutexing.
165: */
166: void sqlite3PCacheBufferSetup(void *pBuf, int sz, int n){
167: if( pcache1.isInit ){
168: PgFreeslot *p;
169: sz = ROUNDDOWN8(sz);
170: pcache1.szSlot = sz;
171: pcache1.nSlot = pcache1.nFreeSlot = n;
172: pcache1.nReserve = n>90 ? 10 : (n/10 + 1);
173: pcache1.pStart = pBuf;
174: pcache1.pFree = 0;
175: pcache1.bUnderPressure = 0;
176: while( n-- ){
177: p = (PgFreeslot*)pBuf;
178: p->pNext = pcache1.pFree;
179: pcache1.pFree = p;
180: pBuf = (void*)&((char*)pBuf)[sz];
181: }
182: pcache1.pEnd = pBuf;
183: }
184: }
185:
186: /*
187: ** Malloc function used within this file to allocate space from the buffer
188: ** configured using sqlite3_config(SQLITE_CONFIG_PAGECACHE) option. If no
189: ** such buffer exists or there is no space left in it, this function falls
190: ** back to sqlite3Malloc().
191: **
192: ** Multiple threads can run this routine at the same time. Global variables
193: ** in pcache1 need to be protected via mutex.
194: */
195: static void *pcache1Alloc(int nByte){
196: void *p = 0;
197: assert( sqlite3_mutex_notheld(pcache1.grp.mutex) );
198: sqlite3StatusSet(SQLITE_STATUS_PAGECACHE_SIZE, nByte);
199: if( nByte<=pcache1.szSlot ){
200: sqlite3_mutex_enter(pcache1.mutex);
201: p = (PgHdr1 *)pcache1.pFree;
202: if( p ){
203: pcache1.pFree = pcache1.pFree->pNext;
204: pcache1.nFreeSlot--;
205: pcache1.bUnderPressure = pcache1.nFreeSlot<pcache1.nReserve;
206: assert( pcache1.nFreeSlot>=0 );
207: sqlite3StatusAdd(SQLITE_STATUS_PAGECACHE_USED, 1);
208: }
209: sqlite3_mutex_leave(pcache1.mutex);
210: }
211: if( p==0 ){
212: /* Memory is not available in the SQLITE_CONFIG_PAGECACHE pool. Get
213: ** it from sqlite3Malloc instead.
214: */
215: p = sqlite3Malloc(nByte);
216: if( p ){
217: int sz = sqlite3MallocSize(p);
218: sqlite3_mutex_enter(pcache1.mutex);
219: sqlite3StatusAdd(SQLITE_STATUS_PAGECACHE_OVERFLOW, sz);
220: sqlite3_mutex_leave(pcache1.mutex);
221: }
222: sqlite3MemdebugSetType(p, MEMTYPE_PCACHE);
223: }
224: return p;
225: }
226:
227: /*
228: ** Free an allocated buffer obtained from pcache1Alloc().
229: */
230: static int pcache1Free(void *p){
231: int nFreed = 0;
232: if( p==0 ) return 0;
233: if( p>=pcache1.pStart && p<pcache1.pEnd ){
234: PgFreeslot *pSlot;
235: sqlite3_mutex_enter(pcache1.mutex);
236: sqlite3StatusAdd(SQLITE_STATUS_PAGECACHE_USED, -1);
237: pSlot = (PgFreeslot*)p;
238: pSlot->pNext = pcache1.pFree;
239: pcache1.pFree = pSlot;
240: pcache1.nFreeSlot++;
241: pcache1.bUnderPressure = pcache1.nFreeSlot<pcache1.nReserve;
242: assert( pcache1.nFreeSlot<=pcache1.nSlot );
243: sqlite3_mutex_leave(pcache1.mutex);
244: }else{
245: assert( sqlite3MemdebugHasType(p, MEMTYPE_PCACHE) );
246: sqlite3MemdebugSetType(p, MEMTYPE_HEAP);
247: nFreed = sqlite3MallocSize(p);
248: sqlite3_mutex_enter(pcache1.mutex);
249: sqlite3StatusAdd(SQLITE_STATUS_PAGECACHE_OVERFLOW, -nFreed);
250: sqlite3_mutex_leave(pcache1.mutex);
251: sqlite3_free(p);
252: }
253: return nFreed;
254: }
255:
256: #ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
257: /*
258: ** Return the size of a pcache allocation
259: */
260: static int pcache1MemSize(void *p){
261: if( p>=pcache1.pStart && p<pcache1.pEnd ){
262: return pcache1.szSlot;
263: }else{
264: int iSize;
265: assert( sqlite3MemdebugHasType(p, MEMTYPE_PCACHE) );
266: sqlite3MemdebugSetType(p, MEMTYPE_HEAP);
267: iSize = sqlite3MallocSize(p);
268: sqlite3MemdebugSetType(p, MEMTYPE_PCACHE);
269: return iSize;
270: }
271: }
272: #endif /* SQLITE_ENABLE_MEMORY_MANAGEMENT */
273:
274: /*
275: ** Allocate a new page object initially associated with cache pCache.
276: */
277: static PgHdr1 *pcache1AllocPage(PCache1 *pCache){
278: PgHdr1 *p = 0;
279: void *pPg;
280:
281: /* The group mutex must be released before pcache1Alloc() is called. This
282: ** is because it may call sqlite3_release_memory(), which assumes that
283: ** this mutex is not held. */
284: assert( sqlite3_mutex_held(pCache->pGroup->mutex) );
285: pcache1LeaveMutex(pCache->pGroup);
286: #ifdef SQLITE_PCACHE_SEPARATE_HEADER
287: pPg = pcache1Alloc(pCache->szPage);
288: p = sqlite3Malloc(sizeof(PgHdr1) + pCache->szExtra);
289: if( !pPg || !p ){
290: pcache1Free(pPg);
291: sqlite3_free(p);
292: pPg = 0;
293: }
294: #else
295: pPg = pcache1Alloc(sizeof(PgHdr1) + pCache->szPage + pCache->szExtra);
296: p = (PgHdr1 *)&((u8 *)pPg)[pCache->szPage];
297: #endif
298: pcache1EnterMutex(pCache->pGroup);
299:
300: if( pPg ){
301: p->page.pBuf = pPg;
302: p->page.pExtra = &p[1];
303: if( pCache->bPurgeable ){
304: pCache->pGroup->nCurrentPage++;
305: }
306: return p;
307: }
308: return 0;
309: }
310:
311: /*
312: ** Free a page object allocated by pcache1AllocPage().
313: **
314: ** The pointer is allowed to be NULL, which is prudent. But it turns out
315: ** that the current implementation happens to never call this routine
316: ** with a NULL pointer, so we mark the NULL test with ALWAYS().
317: */
318: static void pcache1FreePage(PgHdr1 *p){
319: if( ALWAYS(p) ){
320: PCache1 *pCache = p->pCache;
321: assert( sqlite3_mutex_held(p->pCache->pGroup->mutex) );
322: pcache1Free(p->page.pBuf);
323: #ifdef SQLITE_PCACHE_SEPARATE_HEADER
324: sqlite3_free(p);
325: #endif
326: if( pCache->bPurgeable ){
327: pCache->pGroup->nCurrentPage--;
328: }
329: }
330: }
331:
332: /*
333: ** Malloc function used by SQLite to obtain space from the buffer configured
334: ** using sqlite3_config(SQLITE_CONFIG_PAGECACHE) option. If no such buffer
335: ** exists, this function falls back to sqlite3Malloc().
336: */
337: void *sqlite3PageMalloc(int sz){
338: return pcache1Alloc(sz);
339: }
340:
341: /*
342: ** Free an allocated buffer obtained from sqlite3PageMalloc().
343: */
344: void sqlite3PageFree(void *p){
345: pcache1Free(p);
346: }
347:
348:
349: /*
350: ** Return true if it desirable to avoid allocating a new page cache
351: ** entry.
352: **
353: ** If memory was allocated specifically to the page cache using
354: ** SQLITE_CONFIG_PAGECACHE but that memory has all been used, then
355: ** it is desirable to avoid allocating a new page cache entry because
356: ** presumably SQLITE_CONFIG_PAGECACHE was suppose to be sufficient
357: ** for all page cache needs and we should not need to spill the
358: ** allocation onto the heap.
359: **
360: ** Or, the heap is used for all page cache memory but the heap is
361: ** under memory pressure, then again it is desirable to avoid
362: ** allocating a new page cache entry in order to avoid stressing
363: ** the heap even further.
364: */
365: static int pcache1UnderMemoryPressure(PCache1 *pCache){
366: if( pcache1.nSlot && (pCache->szPage+pCache->szExtra)<=pcache1.szSlot ){
367: return pcache1.bUnderPressure;
368: }else{
369: return sqlite3HeapNearlyFull();
370: }
371: }
372:
373: /******************************************************************************/
374: /******** General Implementation Functions ************************************/
375:
376: /*
377: ** This function is used to resize the hash table used by the cache passed
378: ** as the first argument.
379: **
380: ** The PCache mutex must be held when this function is called.
381: */
382: static int pcache1ResizeHash(PCache1 *p){
383: PgHdr1 **apNew;
384: unsigned int nNew;
385: unsigned int i;
386:
387: assert( sqlite3_mutex_held(p->pGroup->mutex) );
388:
389: nNew = p->nHash*2;
390: if( nNew<256 ){
391: nNew = 256;
392: }
393:
394: pcache1LeaveMutex(p->pGroup);
395: if( p->nHash ){ sqlite3BeginBenignMalloc(); }
396: apNew = (PgHdr1 **)sqlite3_malloc(sizeof(PgHdr1 *)*nNew);
397: if( p->nHash ){ sqlite3EndBenignMalloc(); }
398: pcache1EnterMutex(p->pGroup);
399: if( apNew ){
400: memset(apNew, 0, sizeof(PgHdr1 *)*nNew);
401: for(i=0; i<p->nHash; i++){
402: PgHdr1 *pPage;
403: PgHdr1 *pNext = p->apHash[i];
404: while( (pPage = pNext)!=0 ){
405: unsigned int h = pPage->iKey % nNew;
406: pNext = pPage->pNext;
407: pPage->pNext = apNew[h];
408: apNew[h] = pPage;
409: }
410: }
411: sqlite3_free(p->apHash);
412: p->apHash = apNew;
413: p->nHash = nNew;
414: }
415:
416: return (p->apHash ? SQLITE_OK : SQLITE_NOMEM);
417: }
418:
419: /*
420: ** This function is used internally to remove the page pPage from the
421: ** PGroup LRU list, if is part of it. If pPage is not part of the PGroup
422: ** LRU list, then this function is a no-op.
423: **
424: ** The PGroup mutex must be held when this function is called.
425: **
426: ** If pPage is NULL then this routine is a no-op.
427: */
428: static void pcache1PinPage(PgHdr1 *pPage){
429: PCache1 *pCache;
430: PGroup *pGroup;
431:
432: if( pPage==0 ) return;
433: pCache = pPage->pCache;
434: pGroup = pCache->pGroup;
435: assert( sqlite3_mutex_held(pGroup->mutex) );
436: if( pPage->pLruNext || pPage==pGroup->pLruTail ){
437: if( pPage->pLruPrev ){
438: pPage->pLruPrev->pLruNext = pPage->pLruNext;
439: }
440: if( pPage->pLruNext ){
441: pPage->pLruNext->pLruPrev = pPage->pLruPrev;
442: }
443: if( pGroup->pLruHead==pPage ){
444: pGroup->pLruHead = pPage->pLruNext;
445: }
446: if( pGroup->pLruTail==pPage ){
447: pGroup->pLruTail = pPage->pLruPrev;
448: }
449: pPage->pLruNext = 0;
450: pPage->pLruPrev = 0;
451: pPage->pCache->nRecyclable--;
452: }
453: }
454:
455:
456: /*
457: ** Remove the page supplied as an argument from the hash table
458: ** (PCache1.apHash structure) that it is currently stored in.
459: **
460: ** The PGroup mutex must be held when this function is called.
461: */
462: static void pcache1RemoveFromHash(PgHdr1 *pPage){
463: unsigned int h;
464: PCache1 *pCache = pPage->pCache;
465: PgHdr1 **pp;
466:
467: assert( sqlite3_mutex_held(pCache->pGroup->mutex) );
468: h = pPage->iKey % pCache->nHash;
469: for(pp=&pCache->apHash[h]; (*pp)!=pPage; pp=&(*pp)->pNext);
470: *pp = (*pp)->pNext;
471:
472: pCache->nPage--;
473: }
474:
475: /*
476: ** If there are currently more than nMaxPage pages allocated, try
477: ** to recycle pages to reduce the number allocated to nMaxPage.
478: */
479: static void pcache1EnforceMaxPage(PGroup *pGroup){
480: assert( sqlite3_mutex_held(pGroup->mutex) );
481: while( pGroup->nCurrentPage>pGroup->nMaxPage && pGroup->pLruTail ){
482: PgHdr1 *p = pGroup->pLruTail;
483: assert( p->pCache->pGroup==pGroup );
484: pcache1PinPage(p);
485: pcache1RemoveFromHash(p);
486: pcache1FreePage(p);
487: }
488: }
489:
490: /*
491: ** Discard all pages from cache pCache with a page number (key value)
492: ** greater than or equal to iLimit. Any pinned pages that meet this
493: ** criteria are unpinned before they are discarded.
494: **
495: ** The PCache mutex must be held when this function is called.
496: */
497: static void pcache1TruncateUnsafe(
498: PCache1 *pCache, /* The cache to truncate */
499: unsigned int iLimit /* Drop pages with this pgno or larger */
500: ){
501: TESTONLY( unsigned int nPage = 0; ) /* To assert pCache->nPage is correct */
502: unsigned int h;
503: assert( sqlite3_mutex_held(pCache->pGroup->mutex) );
504: for(h=0; h<pCache->nHash; h++){
505: PgHdr1 **pp = &pCache->apHash[h];
506: PgHdr1 *pPage;
507: while( (pPage = *pp)!=0 ){
508: if( pPage->iKey>=iLimit ){
509: pCache->nPage--;
510: *pp = pPage->pNext;
511: pcache1PinPage(pPage);
512: pcache1FreePage(pPage);
513: }else{
514: pp = &pPage->pNext;
515: TESTONLY( nPage++; )
516: }
517: }
518: }
519: assert( pCache->nPage==nPage );
520: }
521:
522: /******************************************************************************/
523: /******** sqlite3_pcache Methods **********************************************/
524:
525: /*
526: ** Implementation of the sqlite3_pcache.xInit method.
527: */
528: static int pcache1Init(void *NotUsed){
529: UNUSED_PARAMETER(NotUsed);
530: assert( pcache1.isInit==0 );
531: memset(&pcache1, 0, sizeof(pcache1));
532: if( sqlite3GlobalConfig.bCoreMutex ){
533: pcache1.grp.mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_LRU);
534: pcache1.mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_PMEM);
535: }
536: pcache1.grp.mxPinned = 10;
537: pcache1.isInit = 1;
538: return SQLITE_OK;
539: }
540:
541: /*
542: ** Implementation of the sqlite3_pcache.xShutdown method.
543: ** Note that the static mutex allocated in xInit does
544: ** not need to be freed.
545: */
546: static void pcache1Shutdown(void *NotUsed){
547: UNUSED_PARAMETER(NotUsed);
548: assert( pcache1.isInit!=0 );
549: memset(&pcache1, 0, sizeof(pcache1));
550: }
551:
552: /*
553: ** Implementation of the sqlite3_pcache.xCreate method.
554: **
555: ** Allocate a new cache.
556: */
557: static sqlite3_pcache *pcache1Create(int szPage, int szExtra, int bPurgeable){
558: PCache1 *pCache; /* The newly created page cache */
559: PGroup *pGroup; /* The group the new page cache will belong to */
560: int sz; /* Bytes of memory required to allocate the new cache */
561:
562: /*
563: ** The seperateCache variable is true if each PCache has its own private
564: ** PGroup. In other words, separateCache is true for mode (1) where no
565: ** mutexing is required.
566: **
567: ** * Always use a unified cache (mode-2) if ENABLE_MEMORY_MANAGEMENT
568: **
569: ** * Always use a unified cache in single-threaded applications
570: **
571: ** * Otherwise (if multi-threaded and ENABLE_MEMORY_MANAGEMENT is off)
572: ** use separate caches (mode-1)
573: */
574: #if defined(SQLITE_ENABLE_MEMORY_MANAGEMENT) || SQLITE_THREADSAFE==0
575: const int separateCache = 0;
576: #else
577: int separateCache = sqlite3GlobalConfig.bCoreMutex>0;
578: #endif
579:
580: assert( (szPage & (szPage-1))==0 && szPage>=512 && szPage<=65536 );
581: assert( szExtra < 300 );
582:
583: sz = sizeof(PCache1) + sizeof(PGroup)*separateCache;
584: pCache = (PCache1 *)sqlite3_malloc(sz);
585: if( pCache ){
586: memset(pCache, 0, sz);
587: if( separateCache ){
588: pGroup = (PGroup*)&pCache[1];
589: pGroup->mxPinned = 10;
590: }else{
591: pGroup = &pcache1.grp;
592: }
593: pCache->pGroup = pGroup;
594: pCache->szPage = szPage;
595: pCache->szExtra = szExtra;
596: pCache->bPurgeable = (bPurgeable ? 1 : 0);
597: if( bPurgeable ){
598: pCache->nMin = 10;
599: pcache1EnterMutex(pGroup);
600: pGroup->nMinPage += pCache->nMin;
601: pGroup->mxPinned = pGroup->nMaxPage + 10 - pGroup->nMinPage;
602: pcache1LeaveMutex(pGroup);
603: }
604: }
605: return (sqlite3_pcache *)pCache;
606: }
607:
608: /*
609: ** Implementation of the sqlite3_pcache.xCachesize method.
610: **
611: ** Configure the cache_size limit for a cache.
612: */
613: static void pcache1Cachesize(sqlite3_pcache *p, int nMax){
614: PCache1 *pCache = (PCache1 *)p;
615: if( pCache->bPurgeable ){
616: PGroup *pGroup = pCache->pGroup;
617: pcache1EnterMutex(pGroup);
618: pGroup->nMaxPage += (nMax - pCache->nMax);
619: pGroup->mxPinned = pGroup->nMaxPage + 10 - pGroup->nMinPage;
620: pCache->nMax = nMax;
621: pCache->n90pct = pCache->nMax*9/10;
622: pcache1EnforceMaxPage(pGroup);
623: pcache1LeaveMutex(pGroup);
624: }
625: }
626:
627: /*
628: ** Implementation of the sqlite3_pcache.xShrink method.
629: **
630: ** Free up as much memory as possible.
631: */
632: static void pcache1Shrink(sqlite3_pcache *p){
633: PCache1 *pCache = (PCache1*)p;
634: if( pCache->bPurgeable ){
635: PGroup *pGroup = pCache->pGroup;
636: int savedMaxPage;
637: pcache1EnterMutex(pGroup);
638: savedMaxPage = pGroup->nMaxPage;
639: pGroup->nMaxPage = 0;
640: pcache1EnforceMaxPage(pGroup);
641: pGroup->nMaxPage = savedMaxPage;
642: pcache1LeaveMutex(pGroup);
643: }
644: }
645:
646: /*
647: ** Implementation of the sqlite3_pcache.xPagecount method.
648: */
649: static int pcache1Pagecount(sqlite3_pcache *p){
650: int n;
651: PCache1 *pCache = (PCache1*)p;
652: pcache1EnterMutex(pCache->pGroup);
653: n = pCache->nPage;
654: pcache1LeaveMutex(pCache->pGroup);
655: return n;
656: }
657:
658: /*
659: ** Implementation of the sqlite3_pcache.xFetch method.
660: **
661: ** Fetch a page by key value.
662: **
663: ** Whether or not a new page may be allocated by this function depends on
664: ** the value of the createFlag argument. 0 means do not allocate a new
665: ** page. 1 means allocate a new page if space is easily available. 2
666: ** means to try really hard to allocate a new page.
667: **
668: ** For a non-purgeable cache (a cache used as the storage for an in-memory
669: ** database) there is really no difference between createFlag 1 and 2. So
670: ** the calling function (pcache.c) will never have a createFlag of 1 on
671: ** a non-purgeable cache.
672: **
673: ** There are three different approaches to obtaining space for a page,
674: ** depending on the value of parameter createFlag (which may be 0, 1 or 2).
675: **
676: ** 1. Regardless of the value of createFlag, the cache is searched for a
677: ** copy of the requested page. If one is found, it is returned.
678: **
679: ** 2. If createFlag==0 and the page is not already in the cache, NULL is
680: ** returned.
681: **
682: ** 3. If createFlag is 1, and the page is not already in the cache, then
683: ** return NULL (do not allocate a new page) if any of the following
684: ** conditions are true:
685: **
686: ** (a) the number of pages pinned by the cache is greater than
687: ** PCache1.nMax, or
688: **
689: ** (b) the number of pages pinned by the cache is greater than
690: ** the sum of nMax for all purgeable caches, less the sum of
691: ** nMin for all other purgeable caches, or
692: **
693: ** 4. If none of the first three conditions apply and the cache is marked
694: ** as purgeable, and if one of the following is true:
695: **
696: ** (a) The number of pages allocated for the cache is already
697: ** PCache1.nMax, or
698: **
699: ** (b) The number of pages allocated for all purgeable caches is
700: ** already equal to or greater than the sum of nMax for all
701: ** purgeable caches,
702: **
703: ** (c) The system is under memory pressure and wants to avoid
704: ** unnecessary pages cache entry allocations
705: **
706: ** then attempt to recycle a page from the LRU list. If it is the right
707: ** size, return the recycled buffer. Otherwise, free the buffer and
708: ** proceed to step 5.
709: **
710: ** 5. Otherwise, allocate and return a new page buffer.
711: */
712: static sqlite3_pcache_page *pcache1Fetch(
713: sqlite3_pcache *p,
714: unsigned int iKey,
715: int createFlag
716: ){
717: unsigned int nPinned;
718: PCache1 *pCache = (PCache1 *)p;
719: PGroup *pGroup;
720: PgHdr1 *pPage = 0;
721:
722: assert( pCache->bPurgeable || createFlag!=1 );
723: assert( pCache->bPurgeable || pCache->nMin==0 );
724: assert( pCache->bPurgeable==0 || pCache->nMin==10 );
725: assert( pCache->nMin==0 || pCache->bPurgeable );
726: pcache1EnterMutex(pGroup = pCache->pGroup);
727:
728: /* Step 1: Search the hash table for an existing entry. */
729: if( pCache->nHash>0 ){
730: unsigned int h = iKey % pCache->nHash;
731: for(pPage=pCache->apHash[h]; pPage&&pPage->iKey!=iKey; pPage=pPage->pNext);
732: }
733:
734: /* Step 2: Abort if no existing page is found and createFlag is 0 */
735: if( pPage || createFlag==0 ){
736: pcache1PinPage(pPage);
737: goto fetch_out;
738: }
739:
740: /* The pGroup local variable will normally be initialized by the
741: ** pcache1EnterMutex() macro above. But if SQLITE_MUTEX_OMIT is defined,
742: ** then pcache1EnterMutex() is a no-op, so we have to initialize the
743: ** local variable here. Delaying the initialization of pGroup is an
744: ** optimization: The common case is to exit the module before reaching
745: ** this point.
746: */
747: #ifdef SQLITE_MUTEX_OMIT
748: pGroup = pCache->pGroup;
749: #endif
750:
751: /* Step 3: Abort if createFlag is 1 but the cache is nearly full */
752: assert( pCache->nPage >= pCache->nRecyclable );
753: nPinned = pCache->nPage - pCache->nRecyclable;
754: assert( pGroup->mxPinned == pGroup->nMaxPage + 10 - pGroup->nMinPage );
755: assert( pCache->n90pct == pCache->nMax*9/10 );
756: if( createFlag==1 && (
757: nPinned>=pGroup->mxPinned
758: || nPinned>=pCache->n90pct
759: || pcache1UnderMemoryPressure(pCache)
760: )){
761: goto fetch_out;
762: }
763:
764: if( pCache->nPage>=pCache->nHash && pcache1ResizeHash(pCache) ){
765: goto fetch_out;
766: }
767:
768: /* Step 4. Try to recycle a page. */
769: if( pCache->bPurgeable && pGroup->pLruTail && (
770: (pCache->nPage+1>=pCache->nMax)
771: || pGroup->nCurrentPage>=pGroup->nMaxPage
772: || pcache1UnderMemoryPressure(pCache)
773: )){
774: PCache1 *pOther;
775: pPage = pGroup->pLruTail;
776: pcache1RemoveFromHash(pPage);
777: pcache1PinPage(pPage);
778: pOther = pPage->pCache;
779:
780: /* We want to verify that szPage and szExtra are the same for pOther
781: ** and pCache. Assert that we can verify this by comparing sums. */
782: assert( (pCache->szPage & (pCache->szPage-1))==0 && pCache->szPage>=512 );
783: assert( pCache->szExtra<512 );
784: assert( (pOther->szPage & (pOther->szPage-1))==0 && pOther->szPage>=512 );
785: assert( pOther->szExtra<512 );
786:
787: if( pOther->szPage+pOther->szExtra != pCache->szPage+pCache->szExtra ){
788: pcache1FreePage(pPage);
789: pPage = 0;
790: }else{
791: pGroup->nCurrentPage -= (pOther->bPurgeable - pCache->bPurgeable);
792: }
793: }
794:
795: /* Step 5. If a usable page buffer has still not been found,
796: ** attempt to allocate a new one.
797: */
798: if( !pPage ){
799: if( createFlag==1 ) sqlite3BeginBenignMalloc();
800: pPage = pcache1AllocPage(pCache);
801: if( createFlag==1 ) sqlite3EndBenignMalloc();
802: }
803:
804: if( pPage ){
805: unsigned int h = iKey % pCache->nHash;
806: pCache->nPage++;
807: pPage->iKey = iKey;
808: pPage->pNext = pCache->apHash[h];
809: pPage->pCache = pCache;
810: pPage->pLruPrev = 0;
811: pPage->pLruNext = 0;
812: *(void **)pPage->page.pExtra = 0;
813: pCache->apHash[h] = pPage;
814: }
815:
816: fetch_out:
817: if( pPage && iKey>pCache->iMaxKey ){
818: pCache->iMaxKey = iKey;
819: }
820: pcache1LeaveMutex(pGroup);
821: return &pPage->page;
822: }
823:
824:
825: /*
826: ** Implementation of the sqlite3_pcache.xUnpin method.
827: **
828: ** Mark a page as unpinned (eligible for asynchronous recycling).
829: */
830: static void pcache1Unpin(
831: sqlite3_pcache *p,
832: sqlite3_pcache_page *pPg,
833: int reuseUnlikely
834: ){
835: PCache1 *pCache = (PCache1 *)p;
836: PgHdr1 *pPage = (PgHdr1 *)pPg;
837: PGroup *pGroup = pCache->pGroup;
838:
839: assert( pPage->pCache==pCache );
840: pcache1EnterMutex(pGroup);
841:
842: /* It is an error to call this function if the page is already
843: ** part of the PGroup LRU list.
844: */
845: assert( pPage->pLruPrev==0 && pPage->pLruNext==0 );
846: assert( pGroup->pLruHead!=pPage && pGroup->pLruTail!=pPage );
847:
848: if( reuseUnlikely || pGroup->nCurrentPage>pGroup->nMaxPage ){
849: pcache1RemoveFromHash(pPage);
850: pcache1FreePage(pPage);
851: }else{
852: /* Add the page to the PGroup LRU list. */
853: if( pGroup->pLruHead ){
854: pGroup->pLruHead->pLruPrev = pPage;
855: pPage->pLruNext = pGroup->pLruHead;
856: pGroup->pLruHead = pPage;
857: }else{
858: pGroup->pLruTail = pPage;
859: pGroup->pLruHead = pPage;
860: }
861: pCache->nRecyclable++;
862: }
863:
864: pcache1LeaveMutex(pCache->pGroup);
865: }
866:
867: /*
868: ** Implementation of the sqlite3_pcache.xRekey method.
869: */
870: static void pcache1Rekey(
871: sqlite3_pcache *p,
872: sqlite3_pcache_page *pPg,
873: unsigned int iOld,
874: unsigned int iNew
875: ){
876: PCache1 *pCache = (PCache1 *)p;
877: PgHdr1 *pPage = (PgHdr1 *)pPg;
878: PgHdr1 **pp;
879: unsigned int h;
880: assert( pPage->iKey==iOld );
881: assert( pPage->pCache==pCache );
882:
883: pcache1EnterMutex(pCache->pGroup);
884:
885: h = iOld%pCache->nHash;
886: pp = &pCache->apHash[h];
887: while( (*pp)!=pPage ){
888: pp = &(*pp)->pNext;
889: }
890: *pp = pPage->pNext;
891:
892: h = iNew%pCache->nHash;
893: pPage->iKey = iNew;
894: pPage->pNext = pCache->apHash[h];
895: pCache->apHash[h] = pPage;
896: if( iNew>pCache->iMaxKey ){
897: pCache->iMaxKey = iNew;
898: }
899:
900: pcache1LeaveMutex(pCache->pGroup);
901: }
902:
903: /*
904: ** Implementation of the sqlite3_pcache.xTruncate method.
905: **
906: ** Discard all unpinned pages in the cache with a page number equal to
907: ** or greater than parameter iLimit. Any pinned pages with a page number
908: ** equal to or greater than iLimit are implicitly unpinned.
909: */
910: static void pcache1Truncate(sqlite3_pcache *p, unsigned int iLimit){
911: PCache1 *pCache = (PCache1 *)p;
912: pcache1EnterMutex(pCache->pGroup);
913: if( iLimit<=pCache->iMaxKey ){
914: pcache1TruncateUnsafe(pCache, iLimit);
915: pCache->iMaxKey = iLimit-1;
916: }
917: pcache1LeaveMutex(pCache->pGroup);
918: }
919:
920: /*
921: ** Implementation of the sqlite3_pcache.xDestroy method.
922: **
923: ** Destroy a cache allocated using pcache1Create().
924: */
925: static void pcache1Destroy(sqlite3_pcache *p){
926: PCache1 *pCache = (PCache1 *)p;
927: PGroup *pGroup = pCache->pGroup;
928: assert( pCache->bPurgeable || (pCache->nMax==0 && pCache->nMin==0) );
929: pcache1EnterMutex(pGroup);
930: pcache1TruncateUnsafe(pCache, 0);
931: assert( pGroup->nMaxPage >= pCache->nMax );
932: pGroup->nMaxPage -= pCache->nMax;
933: assert( pGroup->nMinPage >= pCache->nMin );
934: pGroup->nMinPage -= pCache->nMin;
935: pGroup->mxPinned = pGroup->nMaxPage + 10 - pGroup->nMinPage;
936: pcache1EnforceMaxPage(pGroup);
937: pcache1LeaveMutex(pGroup);
938: sqlite3_free(pCache->apHash);
939: sqlite3_free(pCache);
940: }
941:
942: /*
943: ** This function is called during initialization (sqlite3_initialize()) to
944: ** install the default pluggable cache module, assuming the user has not
945: ** already provided an alternative.
946: */
947: void sqlite3PCacheSetDefault(void){
948: static const sqlite3_pcache_methods2 defaultMethods = {
949: 1, /* iVersion */
950: 0, /* pArg */
951: pcache1Init, /* xInit */
952: pcache1Shutdown, /* xShutdown */
953: pcache1Create, /* xCreate */
954: pcache1Cachesize, /* xCachesize */
955: pcache1Pagecount, /* xPagecount */
956: pcache1Fetch, /* xFetch */
957: pcache1Unpin, /* xUnpin */
958: pcache1Rekey, /* xRekey */
959: pcache1Truncate, /* xTruncate */
960: pcache1Destroy, /* xDestroy */
961: pcache1Shrink /* xShrink */
962: };
963: sqlite3_config(SQLITE_CONFIG_PCACHE2, &defaultMethods);
964: }
965:
966: #ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
967: /*
968: ** This function is called to free superfluous dynamically allocated memory
969: ** held by the pager system. Memory in use by any SQLite pager allocated
970: ** by the current thread may be sqlite3_free()ed.
971: **
972: ** nReq is the number of bytes of memory required. Once this much has
973: ** been released, the function returns. The return value is the total number
974: ** of bytes of memory released.
975: */
976: int sqlite3PcacheReleaseMemory(int nReq){
977: int nFree = 0;
978: assert( sqlite3_mutex_notheld(pcache1.grp.mutex) );
979: assert( sqlite3_mutex_notheld(pcache1.mutex) );
980: if( pcache1.pStart==0 ){
981: PgHdr1 *p;
982: pcache1EnterMutex(&pcache1.grp);
983: while( (nReq<0 || nFree<nReq) && ((p=pcache1.grp.pLruTail)!=0) ){
984: nFree += pcache1MemSize(p->page.pBuf);
985: #ifdef SQLITE_PCACHE_SEPARATE_HEADER
986: nFree += sqlite3MemSize(p);
987: #endif
988: pcache1PinPage(p);
989: pcache1RemoveFromHash(p);
990: pcache1FreePage(p);
991: }
992: pcache1LeaveMutex(&pcache1.grp);
993: }
994: return nFree;
995: }
996: #endif /* SQLITE_ENABLE_MEMORY_MANAGEMENT */
997:
998: #ifdef SQLITE_TEST
999: /*
1000: ** This function is used by test procedures to inspect the internal state
1001: ** of the global cache.
1002: */
1003: void sqlite3PcacheStats(
1004: int *pnCurrent, /* OUT: Total number of pages cached */
1005: int *pnMax, /* OUT: Global maximum cache size */
1006: int *pnMin, /* OUT: Sum of PCache1.nMin for purgeable caches */
1007: int *pnRecyclable /* OUT: Total number of pages available for recycling */
1008: ){
1009: PgHdr1 *p;
1010: int nRecyclable = 0;
1011: for(p=pcache1.grp.pLruHead; p; p=p->pLruNext){
1012: nRecyclable++;
1013: }
1014: *pnCurrent = pcache1.grp.nCurrentPage;
1015: *pnMax = (int)pcache1.grp.nMaxPage;
1016: *pnMin = (int)pcache1.grp.nMinPage;
1017: *pnRecyclable = nRecyclable;
1018: }
1019: #endif
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to pcache1.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