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 overridden, then neither of
17** these two features are available.
18**
19** A Page cache line looks like this:
20**
21** -------------------------------------------------------------
22** | database page content | PgHdr1 | MemPage | PgHdr |
23** -------------------------------------------------------------
24**
25** The database page content is up front (so that buffer overreads tend to
26** flow harmlessly into the PgHdr1, MemPage, and PgHdr extensions). MemPage
27** is the extension added by the btree.c module containing information such
28** as the database page number and how that database page is used. PgHdr
29** is added by the pcache.c layer and contains information used to keep track
30** of which pages are "dirty". PgHdr1 is an extension added by this
31** module (pcache1.c). The PgHdr1 header is a subclass of sqlite3_pcache_page.
32** PgHdr1 contains information needed to look up a page by its page number.
33** The superclass sqlite3_pcache_page.pBuf points to the start of the
34** database page content and sqlite3_pcache_page.pExtra points to PgHdr.
35**
36** The size of the extension (MemPage+PgHdr+PgHdr1) can be determined at
37** runtime using sqlite3_config(SQLITE_CONFIG_PCACHE_HDRSZ, &size). The
38** sizes of the extensions sum to 272 bytes on x64 for 3.8.10, but this
39** size can vary according to architecture, compile-time options, and
40** SQLite library version number.
41**
42** Historical note: It used to be that if the SQLITE_PCACHE_SEPARATE_HEADER
43** was defined, then the page content would be held in a separate memory
44** allocation from the PgHdr1. This was intended to avoid clownshoe memory
45** allocations. However, the btree layer needs a small (16-byte) overrun
46** area after the page content buffer. The header serves as that overrun
47** area. Therefore SQLITE_PCACHE_SEPARATE_HEADER was discontinued to avoid
48** any possibility of a memory error.
49**
50** This module tracks pointers to PgHdr1 objects. Only pcache.c communicates
51** with this module. Information is passed back and forth as PgHdr1 pointers.
52**
53** The pcache.c and pager.c modules deal pointers to PgHdr objects.
54** The btree.c module deals with pointers to MemPage objects.
55**
56** SOURCE OF PAGE CACHE MEMORY:
57**
58** Memory for a page might come from any of three sources:
59**
60** (1) The general-purpose memory allocator - sqlite3Malloc()
61** (2) Global page-cache memory provided using sqlite3_config() with
62** SQLITE_CONFIG_PAGECACHE.
63** (3) PCache-local bulk allocation.
64**
65** The third case is a chunk of heap memory (defaulting to 100 pages worth)
66** that is allocated when the page cache is created. The size of the local
67** bulk allocation can be adjusted using
68**
69** sqlite3_config(SQLITE_CONFIG_PAGECACHE, (void*)0, 0, N).
70**
71** If N is positive, then N pages worth of memory are allocated using a single
72** sqlite3Malloc() call and that memory is used for the first N pages allocated.
73** Or if N is negative, then -1024*N bytes of memory are allocated and used
74** for as many pages as can be accomodated.
75**
76** Only one of (2) or (3) can be used. Once the memory available to (2) or
77** (3) is exhausted, subsequent allocations fail over to the general-purpose
78** memory allocator (1).
79**
80** Earlier versions of SQLite used only methods (1) and (2). But experiments
81** show that method (3) with N==100 provides about a 5% performance boost for
82** common workloads.
83*/
84#include "sqliteInt.h"
85
86typedef struct PCache1 PCache1;
87typedef struct PgHdr1 PgHdr1;
88typedef struct PgFreeslot PgFreeslot;
89typedef struct PGroup PGroup;
90
91/*
92** Each cache entry is represented by an instance of the following
93** structure. A buffer of PgHdr1.pCache->szPage bytes is allocated
94** directly before this structure and is used to cache the page content.
95**
96** When reading a corrupt database file, it is possible that SQLite might
97** read a few bytes (no more than 16 bytes) past the end of the page buffer.
98** It will only read past the end of the page buffer, never write. This
99** object is positioned immediately after the page buffer to serve as an
100** overrun area, so that overreads are harmless.
101**
102** Variables isBulkLocal and isAnchor were once type "u8". That works,
103** but causes a 2-byte gap in the structure for most architectures (since
104** pointers must be either 4 or 8-byte aligned). As this structure is located
105** in memory directly after the associated page data, if the database is
106** corrupt, code at the b-tree layer may overread the page buffer and
107** read part of this structure before the corruption is detected. This
108** can cause a valgrind error if the unitialized gap is accessed. Using u16
109** ensures there is no such gap, and therefore no bytes of uninitialized
110** memory in the structure.
111**
112** The pLruNext and pLruPrev pointers form a double-linked circular list
113** of all pages that are unpinned. The PGroup.lru element (which should be
114** the only element on the list with PgHdr1.isAnchor set to 1) forms the
115** beginning and the end of the list.
116*/
117struct PgHdr1 {
118 sqlite3_pcache_page page; /* Base class. Must be first. pBuf & pExtra */
119 unsigned int iKey; /* Key value (page number) */
120 u16 isBulkLocal; /* This page from bulk local storage */
121 u16 isAnchor; /* This is the PGroup.lru element */
122 PgHdr1 *pNext; /* Next in hash table chain */
123 PCache1 *pCache; /* Cache that currently owns this page */
124 PgHdr1 *pLruNext; /* Next in circular LRU list of unpinned pages */
125 PgHdr1 *pLruPrev; /* Previous in LRU list of unpinned pages */
126 /* NB: pLruPrev is only valid if pLruNext!=0 */
127};
128
129/*
130** A page is pinned if it is not on the LRU list. To be "pinned" means
131** that the page is in active use and must not be deallocated.
132*/
133#define PAGE_IS_PINNED(p) ((p)->pLruNext==0)
134#define PAGE_IS_UNPINNED(p) ((p)->pLruNext!=0)
135
136/* Each page cache (or PCache) belongs to a PGroup. A PGroup is a set
137** of one or more PCaches that are able to recycle each other's unpinned
138** pages when they are under memory pressure. A PGroup is an instance of
139** the following object.
140**
141** This page cache implementation works in one of two modes:
142**
143** (1) Every PCache is the sole member of its own PGroup. There is
144** one PGroup per PCache.
145**
146** (2) There is a single global PGroup that all PCaches are a member
147** of.
148**
149** Mode 1 uses more memory (since PCache instances are not able to rob
150** unused pages from other PCaches) but it also operates without a mutex,
151** and is therefore often faster. Mode 2 requires a mutex in order to be
152** threadsafe, but recycles pages more efficiently.
153**
154** For mode (1), PGroup.mutex is NULL. For mode (2) there is only a single
155** PGroup which is the pcache1.grp global variable and its mutex is
156** SQLITE_MUTEX_STATIC_LRU.
157*/
158struct PGroup {
159 sqlite3_mutex *mutex; /* MUTEX_STATIC_LRU or NULL */
160 unsigned int nMaxPage; /* Sum of nMax for purgeable caches */
161 unsigned int nMinPage; /* Sum of nMin for purgeable caches */
162 unsigned int mxPinned; /* nMaxpage + 10 - nMinPage */
163 unsigned int nPurgeable; /* Number of purgeable pages allocated */
164 PgHdr1 lru; /* The beginning and end of the LRU list */
165};
166
167/* Each page cache is an instance of the following object. Every
168** open database file (including each in-memory database and each
169** temporary or transient database) has a single page cache which
170** is an instance of this object.
171**
172** Pointers to structures of this type are cast and returned as
173** opaque sqlite3_pcache* handles.
174*/
175struct PCache1 {
176 /* Cache configuration parameters. Page size (szPage) and the purgeable
177 ** flag (bPurgeable) and the pnPurgeable pointer are all set when the
178 ** cache is created and are never changed thereafter. nMax may be
179 ** modified at any time by a call to the pcache1Cachesize() method.
180 ** The PGroup mutex must be held when accessing nMax.
181 */
182 PGroup *pGroup; /* PGroup this cache belongs to */
183 unsigned int *pnPurgeable; /* Pointer to pGroup->nPurgeable */
184 int szPage; /* Size of database content section */
185 int szExtra; /* sizeof(MemPage)+sizeof(PgHdr) */
186 int szAlloc; /* Total size of one pcache line */
187 int bPurgeable; /* True if cache is purgeable */
188 unsigned int nMin; /* Minimum number of pages reserved */
189 unsigned int nMax; /* Configured "cache_size" value */
190 unsigned int n90pct; /* nMax*9/10 */
191 unsigned int iMaxKey; /* Largest key seen since xTruncate() */
192 unsigned int nPurgeableDummy; /* pnPurgeable points here when not used*/
193
194 /* Hash table of all pages. The following variables may only be accessed
195 ** when the accessor is holding the PGroup mutex.
196 */
197 unsigned int nRecyclable; /* Number of pages in the LRU list */
198 unsigned int nPage; /* Total number of pages in apHash */
199 unsigned int nHash; /* Number of slots in apHash[] */
200 PgHdr1 **apHash; /* Hash table for fast lookup by key */
201 PgHdr1 *pFree; /* List of unused pcache-local pages */
202 void *pBulk; /* Bulk memory used by pcache-local */
203};
204
205/*
206** Free slots in the allocator used to divide up the global page cache
207** buffer provided using the SQLITE_CONFIG_PAGECACHE mechanism.
208*/
209struct PgFreeslot {
210 PgFreeslot *pNext; /* Next free slot */
211};
212
213/*
214** Global data used by this cache.
215*/
216static SQLITE_WSD struct PCacheGlobal {
217 PGroup grp; /* The global PGroup for mode (2) */
218
219 /* Variables related to SQLITE_CONFIG_PAGECACHE settings. The
220 ** szSlot, nSlot, pStart, pEnd, nReserve, and isInit values are all
221 ** fixed at sqlite3_initialize() time and do not require mutex protection.
222 ** The nFreeSlot and pFree values do require mutex protection.
223 */
224 int isInit; /* True if initialized */
225 int separateCache; /* Use a new PGroup for each PCache */
226 int nInitPage; /* Initial bulk allocation size */
227 int szSlot; /* Size of each free slot */
228 int nSlot; /* The number of pcache slots */
229 int nReserve; /* Try to keep nFreeSlot above this */
230 void *pStart, *pEnd; /* Bounds of global page cache memory */
231 /* Above requires no mutex. Use mutex below for variable that follow. */
232 sqlite3_mutex *mutex; /* Mutex for accessing the following: */
233 PgFreeslot *pFree; /* Free page blocks */
234 int nFreeSlot; /* Number of unused pcache slots */
235 /* The following value requires a mutex to change. We skip the mutex on
236 ** reading because (1) most platforms read a 32-bit integer atomically and
237 ** (2) even if an incorrect value is read, no great harm is done since this
238 ** is really just an optimization. */
239 int bUnderPressure; /* True if low on PAGECACHE memory */
240} pcache1_g;
241
242/*
243** All code in this file should access the global structure above via the
244** alias "pcache1". This ensures that the WSD emulation is used when
245** compiling for systems that do not support real WSD.
246*/
247#define pcache1 (GLOBAL(struct PCacheGlobal, pcache1_g))
248
249/*
250** Macros to enter and leave the PCache LRU mutex.
251*/
252#if !defined(SQLITE_ENABLE_MEMORY_MANAGEMENT) || SQLITE_THREADSAFE==0
253# define pcache1EnterMutex(X) assert((X)->mutex==0)
254# define pcache1LeaveMutex(X) assert((X)->mutex==0)
255# define PCACHE1_MIGHT_USE_GROUP_MUTEX 0
256#else
257# define pcache1EnterMutex(X) sqlite3_mutex_enter((X)->mutex)
258# define pcache1LeaveMutex(X) sqlite3_mutex_leave((X)->mutex)
259# define PCACHE1_MIGHT_USE_GROUP_MUTEX 1
260#endif
261
262/******************************************************************************/
263/******** Page Allocation/SQLITE_CONFIG_PCACHE Related Functions **************/
264
265
266/*
267** This function is called during initialization if a static buffer is
268** supplied to use for the page-cache by passing the SQLITE_CONFIG_PAGECACHE
269** verb to sqlite3_config(). Parameter pBuf points to an allocation large
270** enough to contain 'n' buffers of 'sz' bytes each.
271**
272** This routine is called from sqlite3_initialize() and so it is guaranteed
273** to be serialized already. There is no need for further mutexing.
274*/
275void sqlite3PCacheBufferSetup(void *pBuf, int sz, int n){
276 if( pcache1.isInit ){
277 PgFreeslot *p;
278 if( pBuf==0 ) sz = n = 0;
279 if( n==0 ) sz = 0;
280 sz = ROUNDDOWN8(sz);
281 pcache1.szSlot = sz;
282 pcache1.nSlot = pcache1.nFreeSlot = n;
283 pcache1.nReserve = n>90 ? 10 : (n/10 + 1);
284 pcache1.pStart = pBuf;
285 pcache1.pFree = 0;
286 pcache1.bUnderPressure = 0;
287 while( n-- ){
288 p = (PgFreeslot*)pBuf;
289 p->pNext = pcache1.pFree;
290 pcache1.pFree = p;
291 pBuf = (void*)&((char*)pBuf)[sz];
292 }
293 pcache1.pEnd = pBuf;
294 }
295}
296
297/*
298** Try to initialize the pCache->pFree and pCache->pBulk fields. Return
299** true if pCache->pFree ends up containing one or more free pages.
300*/
301static int pcache1InitBulk(PCache1 *pCache){
302 i64 szBulk;
303 char *zBulk;
304 if( pcache1.nInitPage==0 ) return 0;
305 /* Do not bother with a bulk allocation if the cache size very small */
306 if( pCache->nMax<3 ) return 0;
307 sqlite3BeginBenignMalloc();
308 if( pcache1.nInitPage>0 ){
309 szBulk = pCache->szAlloc * (i64)pcache1.nInitPage;
310 }else{
311 szBulk = -1024 * (i64)pcache1.nInitPage;
312 }
313 if( szBulk > pCache->szAlloc*(i64)pCache->nMax ){
314 szBulk = pCache->szAlloc*(i64)pCache->nMax;
315 }
316 zBulk = pCache->pBulk = sqlite3Malloc( szBulk );
317 sqlite3EndBenignMalloc();
318 if( zBulk ){
319 int nBulk = sqlite3MallocSize(zBulk)/pCache->szAlloc;
320 do{
321 PgHdr1 *pX = (PgHdr1*)&zBulk[pCache->szPage];
322 pX->page.pBuf = zBulk;
323 pX->page.pExtra = &pX[1];
324 pX->isBulkLocal = 1;
325 pX->isAnchor = 0;
326 pX->pNext = pCache->pFree;
327 pX->pLruPrev = 0; /* Initializing this saves a valgrind error */
328 pCache->pFree = pX;
329 zBulk += pCache->szAlloc;
330 }while( --nBulk );
331 }
332 return pCache->pFree!=0;
333}
334
335/*
336** Malloc function used within this file to allocate space from the buffer
337** configured using sqlite3_config(SQLITE_CONFIG_PAGECACHE) option. If no
338** such buffer exists or there is no space left in it, this function falls
339** back to sqlite3Malloc().
340**
341** Multiple threads can run this routine at the same time. Global variables
342** in pcache1 need to be protected via mutex.
343*/
344static void *pcache1Alloc(int nByte){
345 void *p = 0;
346 assert( sqlite3_mutex_notheld(pcache1.grp.mutex) );
347 if( nByte<=pcache1.szSlot ){
348 sqlite3_mutex_enter(pcache1.mutex);
349 p = (PgHdr1 *)pcache1.pFree;
350 if( p ){
351 pcache1.pFree = pcache1.pFree->pNext;
352 pcache1.nFreeSlot--;
353 pcache1.bUnderPressure = pcache1.nFreeSlot<pcache1.nReserve;
354 assert( pcache1.nFreeSlot>=0 );
355 sqlite3StatusHighwater(SQLITE_STATUS_PAGECACHE_SIZE, nByte);
356 sqlite3StatusUp(SQLITE_STATUS_PAGECACHE_USED, 1);
357 }
358 sqlite3_mutex_leave(pcache1.mutex);
359 }
360 if( p==0 ){
361 /* Memory is not available in the SQLITE_CONFIG_PAGECACHE pool. Get
362 ** it from sqlite3Malloc instead.
363 */
364 p = sqlite3Malloc(nByte);
365#ifndef SQLITE_DISABLE_PAGECACHE_OVERFLOW_STATS
366 if( p ){
367 int sz = sqlite3MallocSize(p);
368 sqlite3_mutex_enter(pcache1.mutex);
369 sqlite3StatusHighwater(SQLITE_STATUS_PAGECACHE_SIZE, nByte);
370 sqlite3StatusUp(SQLITE_STATUS_PAGECACHE_OVERFLOW, sz);
371 sqlite3_mutex_leave(pcache1.mutex);
372 }
373#endif
374 sqlite3MemdebugSetType(p, MEMTYPE_PCACHE);
375 }
376 return p;
377}
378
379/*
380** Free an allocated buffer obtained from pcache1Alloc().
381*/
382static void pcache1Free(void *p){
383 if( p==0 ) return;
384 if( SQLITE_WITHIN(p, pcache1.pStart, pcache1.pEnd) ){
385 PgFreeslot *pSlot;
386 sqlite3_mutex_enter(pcache1.mutex);
387 sqlite3StatusDown(SQLITE_STATUS_PAGECACHE_USED, 1);
388 pSlot = (PgFreeslot*)p;
389 pSlot->pNext = pcache1.pFree;
390 pcache1.pFree = pSlot;
391 pcache1.nFreeSlot++;
392 pcache1.bUnderPressure = pcache1.nFreeSlot<pcache1.nReserve;
393 assert( pcache1.nFreeSlot<=pcache1.nSlot );
394 sqlite3_mutex_leave(pcache1.mutex);
395 }else{
396 assert( sqlite3MemdebugHasType(p, MEMTYPE_PCACHE) );
397 sqlite3MemdebugSetType(p, MEMTYPE_HEAP);
398#ifndef SQLITE_DISABLE_PAGECACHE_OVERFLOW_STATS
399 {
400 int nFreed = 0;
401 nFreed = sqlite3MallocSize(p);
402 sqlite3_mutex_enter(pcache1.mutex);
403 sqlite3StatusDown(SQLITE_STATUS_PAGECACHE_OVERFLOW, nFreed);
404 sqlite3_mutex_leave(pcache1.mutex);
405 }
406#endif
407 sqlite3_free(p);
408 }
409}
410
411#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
412/*
413** Return the size of a pcache allocation
414*/
415static int pcache1MemSize(void *p){
416 if( p>=pcache1.pStart && p<pcache1.pEnd ){
417 return pcache1.szSlot;
418 }else{
419 int iSize;
420 assert( sqlite3MemdebugHasType(p, MEMTYPE_PCACHE) );
421 sqlite3MemdebugSetType(p, MEMTYPE_HEAP);
422 iSize = sqlite3MallocSize(p);
423 sqlite3MemdebugSetType(p, MEMTYPE_PCACHE);
424 return iSize;
425 }
426}
427#endif /* SQLITE_ENABLE_MEMORY_MANAGEMENT */
428
429/*
430** Allocate a new page object initially associated with cache pCache.
431*/
432static PgHdr1 *pcache1AllocPage(PCache1 *pCache, int benignMalloc){
433 PgHdr1 *p = 0;
434 void *pPg;
435
436 assert( sqlite3_mutex_held(pCache->pGroup->mutex) );
437 if( pCache->pFree || (pCache->nPage==0 && pcache1InitBulk(pCache)) ){
438 assert( pCache->pFree!=0 );
439 p = pCache->pFree;
440 pCache->pFree = p->pNext;
441 p->pNext = 0;
442 }else{
443#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
444 /* The group mutex must be released before pcache1Alloc() is called. This
445 ** is because it might call sqlite3_release_memory(), which assumes that
446 ** this mutex is not held. */
447 assert( pcache1.separateCache==0 );
448 assert( pCache->pGroup==&pcache1.grp );
449 pcache1LeaveMutex(pCache->pGroup);
450#endif
451 if( benignMalloc ){ sqlite3BeginBenignMalloc(); }
452 pPg = pcache1Alloc(pCache->szAlloc);
453 if( benignMalloc ){ sqlite3EndBenignMalloc(); }
454#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
455 pcache1EnterMutex(pCache->pGroup);
456#endif
457 if( pPg==0 ) return 0;
458 p = (PgHdr1 *)&((u8 *)pPg)[pCache->szPage];
459 p->page.pBuf = pPg;
460 p->page.pExtra = &p[1];
461 p->isBulkLocal = 0;
462 p->isAnchor = 0;
463 p->pLruPrev = 0; /* Initializing this saves a valgrind error */
464 }
465 (*pCache->pnPurgeable)++;
466 return p;
467}
468
469/*
470** Free a page object allocated by pcache1AllocPage().
471*/
472static void pcache1FreePage(PgHdr1 *p){
473 PCache1 *pCache;
474 assert( p!=0 );
475 pCache = p->pCache;
476 assert( sqlite3_mutex_held(p->pCache->pGroup->mutex) );
477 if( p->isBulkLocal ){
478 p->pNext = pCache->pFree;
479 pCache->pFree = p;
480 }else{
481 pcache1Free(p->page.pBuf);
482 }
483 (*pCache->pnPurgeable)--;
484}
485
486/*
487** Malloc function used by SQLite to obtain space from the buffer configured
488** using sqlite3_config(SQLITE_CONFIG_PAGECACHE) option. If no such buffer
489** exists, this function falls back to sqlite3Malloc().
490*/
491void *sqlite3PageMalloc(int sz){
492 assert( sz<=65536+8 ); /* These allocations are never very large */
493 return pcache1Alloc(sz);
494}
495
496/*
497** Free an allocated buffer obtained from sqlite3PageMalloc().
498*/
499void sqlite3PageFree(void *p){
500 pcache1Free(p);
501}
502
503
504/*
505** Return true if it desirable to avoid allocating a new page cache
506** entry.
507**
508** If memory was allocated specifically to the page cache using
509** SQLITE_CONFIG_PAGECACHE but that memory has all been used, then
510** it is desirable to avoid allocating a new page cache entry because
511** presumably SQLITE_CONFIG_PAGECACHE was suppose to be sufficient
512** for all page cache needs and we should not need to spill the
513** allocation onto the heap.
514**
515** Or, the heap is used for all page cache memory but the heap is
516** under memory pressure, then again it is desirable to avoid
517** allocating a new page cache entry in order to avoid stressing
518** the heap even further.
519*/
520static int pcache1UnderMemoryPressure(PCache1 *pCache){
521 if( pcache1.nSlot && (pCache->szPage+pCache->szExtra)<=pcache1.szSlot ){
522 return pcache1.bUnderPressure;
523 }else{
524 return sqlite3HeapNearlyFull();
525 }
526}
527
528/******************************************************************************/
529/******** General Implementation Functions ************************************/
530
531/*
532** This function is used to resize the hash table used by the cache passed
533** as the first argument.
534**
535** The PCache mutex must be held when this function is called.
536*/
537static void pcache1ResizeHash(PCache1 *p){
538 PgHdr1 **apNew;
539 unsigned int nNew;
540 unsigned int i;
541
542 assert( sqlite3_mutex_held(p->pGroup->mutex) );
543
544 nNew = p->nHash*2;
545 if( nNew<256 ){
546 nNew = 256;
547 }
548
549 pcache1LeaveMutex(p->pGroup);
550 if( p->nHash ){ sqlite3BeginBenignMalloc(); }
551 apNew = (PgHdr1 **)sqlite3MallocZero(sizeof(PgHdr1 *)*nNew);
552 if( p->nHash ){ sqlite3EndBenignMalloc(); }
553 pcache1EnterMutex(p->pGroup);
554 if( apNew ){
555 for(i=0; i<p->nHash; i++){
556 PgHdr1 *pPage;
557 PgHdr1 *pNext = p->apHash[i];
558 while( (pPage = pNext)!=0 ){
559 unsigned int h = pPage->iKey % nNew;
560 pNext = pPage->pNext;
561 pPage->pNext = apNew[h];
562 apNew[h] = pPage;
563 }
564 }
565 sqlite3_free(p->apHash);
566 p->apHash = apNew;
567 p->nHash = nNew;
568 }
569}
570
571/*
572** This function is used internally to remove the page pPage from the
573** PGroup LRU list, if is part of it. If pPage is not part of the PGroup
574** LRU list, then this function is a no-op.
575**
576** The PGroup mutex must be held when this function is called.
577*/
578static PgHdr1 *pcache1PinPage(PgHdr1 *pPage){
579 assert( pPage!=0 );
580 assert( PAGE_IS_UNPINNED(pPage) );
581 assert( pPage->pLruNext );
582 assert( pPage->pLruPrev );
583 assert( sqlite3_mutex_held(pPage->pCache->pGroup->mutex) );
584 pPage->pLruPrev->pLruNext = pPage->pLruNext;
585 pPage->pLruNext->pLruPrev = pPage->pLruPrev;
586 pPage->pLruNext = 0;
587 /* pPage->pLruPrev = 0;
588 ** No need to clear pLruPrev as it is never accessed if pLruNext is 0 */
589 assert( pPage->isAnchor==0 );
590 assert( pPage->pCache->pGroup->lru.isAnchor==1 );
591 pPage->pCache->nRecyclable--;
592 return pPage;
593}
594
595
596/*
597** Remove the page supplied as an argument from the hash table
598** (PCache1.apHash structure) that it is currently stored in.
599** Also free the page if freePage is true.
600**
601** The PGroup mutex must be held when this function is called.
602*/
603static void pcache1RemoveFromHash(PgHdr1 *pPage, int freeFlag){
604 unsigned int h;
605 PCache1 *pCache = pPage->pCache;
606 PgHdr1 **pp;
607
608 assert( sqlite3_mutex_held(pCache->pGroup->mutex) );
609 h = pPage->iKey % pCache->nHash;
610 for(pp=&pCache->apHash[h]; (*pp)!=pPage; pp=&(*pp)->pNext);
611 *pp = (*pp)->pNext;
612
613 pCache->nPage--;
614 if( freeFlag ) pcache1FreePage(pPage);
615}
616
617/*
618** If there are currently more than nMaxPage pages allocated, try
619** to recycle pages to reduce the number allocated to nMaxPage.
620*/
621static void pcache1EnforceMaxPage(PCache1 *pCache){
622 PGroup *pGroup = pCache->pGroup;
623 PgHdr1 *p;
624 assert( sqlite3_mutex_held(pGroup->mutex) );
625 while( pGroup->nPurgeable>pGroup->nMaxPage
626 && (p=pGroup->lru.pLruPrev)->isAnchor==0
627 ){
628 assert( p->pCache->pGroup==pGroup );
629 assert( PAGE_IS_UNPINNED(p) );
630 pcache1PinPage(p);
631 pcache1RemoveFromHash(p, 1);
632 }
633 if( pCache->nPage==0 && pCache->pBulk ){
634 sqlite3_free(pCache->pBulk);
635 pCache->pBulk = pCache->pFree = 0;
636 }
637}
638
639/*
640** Discard all pages from cache pCache with a page number (key value)
641** greater than or equal to iLimit. Any pinned pages that meet this
642** criteria are unpinned before they are discarded.
643**
644** The PCache mutex must be held when this function is called.
645*/
646static void pcache1TruncateUnsafe(
647 PCache1 *pCache, /* The cache to truncate */
648 unsigned int iLimit /* Drop pages with this pgno or larger */
649){
650 TESTONLY( int nPage = 0; ) /* To assert pCache->nPage is correct */
651 unsigned int h, iStop;
652 assert( sqlite3_mutex_held(pCache->pGroup->mutex) );
653 assert( pCache->iMaxKey >= iLimit );
654 assert( pCache->nHash > 0 );
655 if( pCache->iMaxKey - iLimit < pCache->nHash ){
656 /* If we are just shaving the last few pages off the end of the
657 ** cache, then there is no point in scanning the entire hash table.
658 ** Only scan those hash slots that might contain pages that need to
659 ** be removed. */
660 h = iLimit % pCache->nHash;
661 iStop = pCache->iMaxKey % pCache->nHash;
662 TESTONLY( nPage = -10; ) /* Disable the pCache->nPage validity check */
663 }else{
664 /* This is the general case where many pages are being removed.
665 ** It is necessary to scan the entire hash table */
666 h = pCache->nHash/2;
667 iStop = h - 1;
668 }
669 for(;;){
670 PgHdr1 **pp;
671 PgHdr1 *pPage;
672 assert( h<pCache->nHash );
673 pp = &pCache->apHash[h];
674 while( (pPage = *pp)!=0 ){
675 if( pPage->iKey>=iLimit ){
676 pCache->nPage--;
677 *pp = pPage->pNext;
678 if( PAGE_IS_UNPINNED(pPage) ) pcache1PinPage(pPage);
679 pcache1FreePage(pPage);
680 }else{
681 pp = &pPage->pNext;
682 TESTONLY( if( nPage>=0 ) nPage++; )
683 }
684 }
685 if( h==iStop ) break;
686 h = (h+1) % pCache->nHash;
687 }
688 assert( nPage<0 || pCache->nPage==(unsigned)nPage );
689}
690
691/******************************************************************************/
692/******** sqlite3_pcache Methods **********************************************/
693
694/*
695** Implementation of the sqlite3_pcache.xInit method.
696*/
697static int pcache1Init(void *NotUsed){
698 UNUSED_PARAMETER(NotUsed);
699 assert( pcache1.isInit==0 );
700 memset(&pcache1, 0, sizeof(pcache1));
701
702
703 /*
704 ** The pcache1.separateCache variable is true if each PCache has its own
705 ** private PGroup (mode-1). pcache1.separateCache is false if the single
706 ** PGroup in pcache1.grp is used for all page caches (mode-2).
707 **
708 ** * Always use a unified cache (mode-2) if ENABLE_MEMORY_MANAGEMENT
709 **
710 ** * Use a unified cache in single-threaded applications that have
711 ** configured a start-time buffer for use as page-cache memory using
712 ** sqlite3_config(SQLITE_CONFIG_PAGECACHE, pBuf, sz, N) with non-NULL
713 ** pBuf argument.
714 **
715 ** * Otherwise use separate caches (mode-1)
716 */
717#if defined(SQLITE_ENABLE_MEMORY_MANAGEMENT)
718 pcache1.separateCache = 0;
719#elif SQLITE_THREADSAFE
720 pcache1.separateCache = sqlite3GlobalConfig.pPage==0
721 || sqlite3GlobalConfig.bCoreMutex>0;
722#else
723 pcache1.separateCache = sqlite3GlobalConfig.pPage==0;
724#endif
725
726#if SQLITE_THREADSAFE
727 if( sqlite3GlobalConfig.bCoreMutex ){
728 pcache1.grp.mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_LRU);
729 pcache1.mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_PMEM);
730 }
731#endif
732 if( pcache1.separateCache
733 && sqlite3GlobalConfig.nPage!=0
734 && sqlite3GlobalConfig.pPage==0
735 ){
736 pcache1.nInitPage = sqlite3GlobalConfig.nPage;
737 }else{
738 pcache1.nInitPage = 0;
739 }
740 pcache1.grp.mxPinned = 10;
741 pcache1.isInit = 1;
742 return SQLITE_OK;
743}
744
745/*
746** Implementation of the sqlite3_pcache.xShutdown method.
747** Note that the static mutex allocated in xInit does
748** not need to be freed.
749*/
750static void pcache1Shutdown(void *NotUsed){
751 UNUSED_PARAMETER(NotUsed);
752 assert( pcache1.isInit!=0 );
753 memset(&pcache1, 0, sizeof(pcache1));
754}
755
756/* forward declaration */
757static void pcache1Destroy(sqlite3_pcache *p);
758
759/*
760** Implementation of the sqlite3_pcache.xCreate method.
761**
762** Allocate a new cache.
763*/
764static sqlite3_pcache *pcache1Create(int szPage, int szExtra, int bPurgeable){
765 PCache1 *pCache; /* The newly created page cache */
766 PGroup *pGroup; /* The group the new page cache will belong to */
767 int sz; /* Bytes of memory required to allocate the new cache */
768
769 assert( (szPage & (szPage-1))==0 && szPage>=512 && szPage<=65536 );
770 assert( szExtra < 300 );
771
772 sz = sizeof(PCache1) + sizeof(PGroup)*pcache1.separateCache;
773 pCache = (PCache1 *)sqlite3MallocZero(sz);
774 if( pCache ){
775 if( pcache1.separateCache ){
776 pGroup = (PGroup*)&pCache[1];
777 pGroup->mxPinned = 10;
778 }else{
779 pGroup = &pcache1.grp;
780 }
781 pcache1EnterMutex(pGroup);
782 if( pGroup->lru.isAnchor==0 ){
783 pGroup->lru.isAnchor = 1;
784 pGroup->lru.pLruPrev = pGroup->lru.pLruNext = &pGroup->lru;
785 }
786 pCache->pGroup = pGroup;
787 pCache->szPage = szPage;
788 pCache->szExtra = szExtra;
789 pCache->szAlloc = szPage + szExtra + ROUND8(sizeof(PgHdr1));
790 pCache->bPurgeable = (bPurgeable ? 1 : 0);
791 pcache1ResizeHash(pCache);
792 if( bPurgeable ){
793 pCache->nMin = 10;
794 pGroup->nMinPage += pCache->nMin;
795 pGroup->mxPinned = pGroup->nMaxPage + 10 - pGroup->nMinPage;
796 pCache->pnPurgeable = &pGroup->nPurgeable;
797 }else{
798 pCache->pnPurgeable = &pCache->nPurgeableDummy;
799 }
800 pcache1LeaveMutex(pGroup);
801 if( pCache->nHash==0 ){
802 pcache1Destroy((sqlite3_pcache*)pCache);
803 pCache = 0;
804 }
805 }
806 return (sqlite3_pcache *)pCache;
807}
808
809/*
810** Implementation of the sqlite3_pcache.xCachesize method.
811**
812** Configure the cache_size limit for a cache.
813*/
814static void pcache1Cachesize(sqlite3_pcache *p, int nMax){
815 PCache1 *pCache = (PCache1 *)p;
816 u32 n;
817 assert( nMax>=0 );
818 if( pCache->bPurgeable ){
819 PGroup *pGroup = pCache->pGroup;
820 pcache1EnterMutex(pGroup);
821 n = (u32)nMax;
822 if( n > 0x7fff0000 - pGroup->nMaxPage + pCache->nMax ){
823 n = 0x7fff0000 - pGroup->nMaxPage + pCache->nMax;
824 }
825 pGroup->nMaxPage += (n - pCache->nMax);
826 pGroup->mxPinned = pGroup->nMaxPage + 10 - pGroup->nMinPage;
827 pCache->nMax = n;
828 pCache->n90pct = pCache->nMax*9/10;
829 pcache1EnforceMaxPage(pCache);
830 pcache1LeaveMutex(pGroup);
831 }
832}
833
834/*
835** Implementation of the sqlite3_pcache.xShrink method.
836**
837** Free up as much memory as possible.
838*/
839static void pcache1Shrink(sqlite3_pcache *p){
840 PCache1 *pCache = (PCache1*)p;
841 if( pCache->bPurgeable ){
842 PGroup *pGroup = pCache->pGroup;
843 unsigned int savedMaxPage;
844 pcache1EnterMutex(pGroup);
845 savedMaxPage = pGroup->nMaxPage;
846 pGroup->nMaxPage = 0;
847 pcache1EnforceMaxPage(pCache);
848 pGroup->nMaxPage = savedMaxPage;
849 pcache1LeaveMutex(pGroup);
850 }
851}
852
853/*
854** Implementation of the sqlite3_pcache.xPagecount method.
855*/
856static int pcache1Pagecount(sqlite3_pcache *p){
857 int n;
858 PCache1 *pCache = (PCache1*)p;
859 pcache1EnterMutex(pCache->pGroup);
860 n = pCache->nPage;
861 pcache1LeaveMutex(pCache->pGroup);
862 return n;
863}
864
865
866/*
867** Implement steps 3, 4, and 5 of the pcache1Fetch() algorithm described
868** in the header of the pcache1Fetch() procedure.
869**
870** This steps are broken out into a separate procedure because they are
871** usually not needed, and by avoiding the stack initialization required
872** for these steps, the main pcache1Fetch() procedure can run faster.
873*/
874static SQLITE_NOINLINE PgHdr1 *pcache1FetchStage2(
875 PCache1 *pCache,
876 unsigned int iKey,
877 int createFlag
878){
879 unsigned int nPinned;
880 PGroup *pGroup = pCache->pGroup;
881 PgHdr1 *pPage = 0;
882
883 /* Step 3: Abort if createFlag is 1 but the cache is nearly full */
884 assert( pCache->nPage >= pCache->nRecyclable );
885 nPinned = pCache->nPage - pCache->nRecyclable;
886 assert( pGroup->mxPinned == pGroup->nMaxPage + 10 - pGroup->nMinPage );
887 assert( pCache->n90pct == pCache->nMax*9/10 );
888 if( createFlag==1 && (
889 nPinned>=pGroup->mxPinned
890 || nPinned>=pCache->n90pct
891 || (pcache1UnderMemoryPressure(pCache) && pCache->nRecyclable<nPinned)
892 )){
893 return 0;
894 }
895
896 if( pCache->nPage>=pCache->nHash ) pcache1ResizeHash(pCache);
897 assert( pCache->nHash>0 && pCache->apHash );
898
899 /* Step 4. Try to recycle a page. */
900 if( pCache->bPurgeable
901 && !pGroup->lru.pLruPrev->isAnchor
902 && ((pCache->nPage+1>=pCache->nMax) || pcache1UnderMemoryPressure(pCache))
903 ){
904 PCache1 *pOther;
905 pPage = pGroup->lru.pLruPrev;
906 assert( PAGE_IS_UNPINNED(pPage) );
907 pcache1RemoveFromHash(pPage, 0);
908 pcache1PinPage(pPage);
909 pOther = pPage->pCache;
910 if( pOther->szAlloc != pCache->szAlloc ){
911 pcache1FreePage(pPage);
912 pPage = 0;
913 }else{
914 pGroup->nPurgeable -= (pOther->bPurgeable - pCache->bPurgeable);
915 }
916 }
917
918 /* Step 5. If a usable page buffer has still not been found,
919 ** attempt to allocate a new one.
920 */
921 if( !pPage ){
922 pPage = pcache1AllocPage(pCache, createFlag==1);
923 }
924
925 if( pPage ){
926 unsigned int h = iKey % pCache->nHash;
927 pCache->nPage++;
928 pPage->iKey = iKey;
929 pPage->pNext = pCache->apHash[h];
930 pPage->pCache = pCache;
931 pPage->pLruNext = 0;
932 /* pPage->pLruPrev = 0;
933 ** No need to clear pLruPrev since it is not accessed when pLruNext==0 */
934 *(void **)pPage->page.pExtra = 0;
935 pCache->apHash[h] = pPage;
936 if( iKey>pCache->iMaxKey ){
937 pCache->iMaxKey = iKey;
938 }
939 }
940 return pPage;
941}
942
943/*
944** Implementation of the sqlite3_pcache.xFetch method.
945**
946** Fetch a page by key value.
947**
948** Whether or not a new page may be allocated by this function depends on
949** the value of the createFlag argument. 0 means do not allocate a new
950** page. 1 means allocate a new page if space is easily available. 2
951** means to try really hard to allocate a new page.
952**
953** For a non-purgeable cache (a cache used as the storage for an in-memory
954** database) there is really no difference between createFlag 1 and 2. So
955** the calling function (pcache.c) will never have a createFlag of 1 on
956** a non-purgeable cache.
957**
958** There are three different approaches to obtaining space for a page,
959** depending on the value of parameter createFlag (which may be 0, 1 or 2).
960**
961** 1. Regardless of the value of createFlag, the cache is searched for a
962** copy of the requested page. If one is found, it is returned.
963**
964** 2. If createFlag==0 and the page is not already in the cache, NULL is
965** returned.
966**
967** 3. If createFlag is 1, and the page is not already in the cache, then
968** return NULL (do not allocate a new page) if any of the following
969** conditions are true:
970**
971** (a) the number of pages pinned by the cache is greater than
972** PCache1.nMax, or
973**
974** (b) the number of pages pinned by the cache is greater than
975** the sum of nMax for all purgeable caches, less the sum of
976** nMin for all other purgeable caches, or
977**
978** 4. If none of the first three conditions apply and the cache is marked
979** as purgeable, and if one of the following is true:
980**
981** (a) The number of pages allocated for the cache is already
982** PCache1.nMax, or
983**
984** (b) The number of pages allocated for all purgeable caches is
985** already equal to or greater than the sum of nMax for all
986** purgeable caches,
987**
988** (c) The system is under memory pressure and wants to avoid
989** unnecessary pages cache entry allocations
990**
991** then attempt to recycle a page from the LRU list. If it is the right
992** size, return the recycled buffer. Otherwise, free the buffer and
993** proceed to step 5.
994**
995** 5. Otherwise, allocate and return a new page buffer.
996**
997** There are two versions of this routine. pcache1FetchWithMutex() is
998** the general case. pcache1FetchNoMutex() is a faster implementation for
999** the common case where pGroup->mutex is NULL. The pcache1Fetch() wrapper
1000** invokes the appropriate routine.
1001*/
1002static PgHdr1 *pcache1FetchNoMutex(
1003 sqlite3_pcache *p,
1004 unsigned int iKey,
1005 int createFlag
1006){
1007 PCache1 *pCache = (PCache1 *)p;
1008 PgHdr1 *pPage = 0;
1009
1010 /* Step 1: Search the hash table for an existing entry. */
1011 pPage = pCache->apHash[iKey % pCache->nHash];
1012 while( pPage && pPage->iKey!=iKey ){ pPage = pPage->pNext; }
1013
1014 /* Step 2: If the page was found in the hash table, then return it.
1015 ** If the page was not in the hash table and createFlag is 0, abort.
1016 ** Otherwise (page not in hash and createFlag!=0) continue with
1017 ** subsequent steps to try to create the page. */
1018 if( pPage ){
1019 if( PAGE_IS_UNPINNED(pPage) ){
1020 return pcache1PinPage(pPage);
1021 }else{
1022 return pPage;
1023 }
1024 }else if( createFlag ){
1025 /* Steps 3, 4, and 5 implemented by this subroutine */
1026 return pcache1FetchStage2(pCache, iKey, createFlag);
1027 }else{
1028 return 0;
1029 }
1030}
1031#if PCACHE1_MIGHT_USE_GROUP_MUTEX
1032static PgHdr1 *pcache1FetchWithMutex(
1033 sqlite3_pcache *p,
1034 unsigned int iKey,
1035 int createFlag
1036){
1037 PCache1 *pCache = (PCache1 *)p;
1038 PgHdr1 *pPage;
1039
1040 pcache1EnterMutex(pCache->pGroup);
1041 pPage = pcache1FetchNoMutex(p, iKey, createFlag);
1042 assert( pPage==0 || pCache->iMaxKey>=iKey );
1043 pcache1LeaveMutex(pCache->pGroup);
1044 return pPage;
1045}
1046#endif
1047static sqlite3_pcache_page *pcache1Fetch(
1048 sqlite3_pcache *p,
1049 unsigned int iKey,
1050 int createFlag
1051){
1052#if PCACHE1_MIGHT_USE_GROUP_MUTEX || defined(SQLITE_DEBUG)
1053 PCache1 *pCache = (PCache1 *)p;
1054#endif
1055
1056 assert( offsetof(PgHdr1,page)==0 );
1057 assert( pCache->bPurgeable || createFlag!=1 );
1058 assert( pCache->bPurgeable || pCache->nMin==0 );
1059 assert( pCache->bPurgeable==0 || pCache->nMin==10 );
1060 assert( pCache->nMin==0 || pCache->bPurgeable );
1061 assert( pCache->nHash>0 );
1062#if PCACHE1_MIGHT_USE_GROUP_MUTEX
1063 if( pCache->pGroup->mutex ){
1064 return (sqlite3_pcache_page*)pcache1FetchWithMutex(p, iKey, createFlag);
1065 }else
1066#endif
1067 {
1068 return (sqlite3_pcache_page*)pcache1FetchNoMutex(p, iKey, createFlag);
1069 }
1070}
1071
1072
1073/*
1074** Implementation of the sqlite3_pcache.xUnpin method.
1075**
1076** Mark a page as unpinned (eligible for asynchronous recycling).
1077*/
1078static void pcache1Unpin(
1079 sqlite3_pcache *p,
1080 sqlite3_pcache_page *pPg,
1081 int reuseUnlikely
1082){
1083 PCache1 *pCache = (PCache1 *)p;
1084 PgHdr1 *pPage = (PgHdr1 *)pPg;
1085 PGroup *pGroup = pCache->pGroup;
1086
1087 assert( pPage->pCache==pCache );
1088 pcache1EnterMutex(pGroup);
1089
1090 /* It is an error to call this function if the page is already
1091 ** part of the PGroup LRU list.
1092 */
1093 assert( pPage->pLruNext==0 );
1094 assert( PAGE_IS_PINNED(pPage) );
1095
1096 if( reuseUnlikely || pGroup->nPurgeable>pGroup->nMaxPage ){
1097 pcache1RemoveFromHash(pPage, 1);
1098 }else{
1099 /* Add the page to the PGroup LRU list. */
1100 PgHdr1 **ppFirst = &pGroup->lru.pLruNext;
1101 pPage->pLruPrev = &pGroup->lru;
1102 (pPage->pLruNext = *ppFirst)->pLruPrev = pPage;
1103 *ppFirst = pPage;
1104 pCache->nRecyclable++;
1105 }
1106
1107 pcache1LeaveMutex(pCache->pGroup);
1108}
1109
1110/*
1111** Implementation of the sqlite3_pcache.xRekey method.
1112*/
1113static void pcache1Rekey(
1114 sqlite3_pcache *p,
1115 sqlite3_pcache_page *pPg,
1116 unsigned int iOld,
1117 unsigned int iNew
1118){
1119 PCache1 *pCache = (PCache1 *)p;
1120 PgHdr1 *pPage = (PgHdr1 *)pPg;
1121 PgHdr1 **pp;
1122 unsigned int hOld, hNew;
1123 assert( pPage->iKey==iOld );
1124 assert( pPage->pCache==pCache );
1125 assert( iOld!=iNew ); /* The page number really is changing */
1126
1127 pcache1EnterMutex(pCache->pGroup);
1128
1129 assert( pcache1FetchNoMutex(p, iOld, 0)==pPage ); /* pPg really is iOld */
1130 hOld = iOld%pCache->nHash;
1131 pp = &pCache->apHash[hOld];
1132 while( (*pp)!=pPage ){
1133 pp = &(*pp)->pNext;
1134 }
1135 *pp = pPage->pNext;
1136
1137 assert( pcache1FetchNoMutex(p, iNew, 0)==0 ); /* iNew not in cache */
1138 hNew = iNew%pCache->nHash;
1139 pPage->iKey = iNew;
1140 pPage->pNext = pCache->apHash[hNew];
1141 pCache->apHash[hNew] = pPage;
1142 if( iNew>pCache->iMaxKey ){
1143 pCache->iMaxKey = iNew;
1144 }
1145
1146 pcache1LeaveMutex(pCache->pGroup);
1147}
1148
1149/*
1150** Implementation of the sqlite3_pcache.xTruncate method.
1151**
1152** Discard all unpinned pages in the cache with a page number equal to
1153** or greater than parameter iLimit. Any pinned pages with a page number
1154** equal to or greater than iLimit are implicitly unpinned.
1155*/
1156static void pcache1Truncate(sqlite3_pcache *p, unsigned int iLimit){
1157 PCache1 *pCache = (PCache1 *)p;
1158 pcache1EnterMutex(pCache->pGroup);
1159 if( iLimit<=pCache->iMaxKey ){
1160 pcache1TruncateUnsafe(pCache, iLimit);
1161 pCache->iMaxKey = iLimit-1;
1162 }
1163 pcache1LeaveMutex(pCache->pGroup);
1164}
1165
1166/*
1167** Implementation of the sqlite3_pcache.xDestroy method.
1168**
1169** Destroy a cache allocated using pcache1Create().
1170*/
1171static void pcache1Destroy(sqlite3_pcache *p){
1172 PCache1 *pCache = (PCache1 *)p;
1173 PGroup *pGroup = pCache->pGroup;
1174 assert( pCache->bPurgeable || (pCache->nMax==0 && pCache->nMin==0) );
1175 pcache1EnterMutex(pGroup);
1176 if( pCache->nPage ) pcache1TruncateUnsafe(pCache, 0);
1177 assert( pGroup->nMaxPage >= pCache->nMax );
1178 pGroup->nMaxPage -= pCache->nMax;
1179 assert( pGroup->nMinPage >= pCache->nMin );
1180 pGroup->nMinPage -= pCache->nMin;
1181 pGroup->mxPinned = pGroup->nMaxPage + 10 - pGroup->nMinPage;
1182 pcache1EnforceMaxPage(pCache);
1183 pcache1LeaveMutex(pGroup);
1184 sqlite3_free(pCache->pBulk);
1185 sqlite3_free(pCache->apHash);
1186 sqlite3_free(pCache);
1187}
1188
1189/*
1190** This function is called during initialization (sqlite3_initialize()) to
1191** install the default pluggable cache module, assuming the user has not
1192** already provided an alternative.
1193*/
1194void sqlite3PCacheSetDefault(void){
1195 static const sqlite3_pcache_methods2 defaultMethods = {
1196 1, /* iVersion */
1197 0, /* pArg */
1198 pcache1Init, /* xInit */
1199 pcache1Shutdown, /* xShutdown */
1200 pcache1Create, /* xCreate */
1201 pcache1Cachesize, /* xCachesize */
1202 pcache1Pagecount, /* xPagecount */
1203 pcache1Fetch, /* xFetch */
1204 pcache1Unpin, /* xUnpin */
1205 pcache1Rekey, /* xRekey */
1206 pcache1Truncate, /* xTruncate */
1207 pcache1Destroy, /* xDestroy */
1208 pcache1Shrink /* xShrink */
1209 };
1210 sqlite3_config(SQLITE_CONFIG_PCACHE2, &defaultMethods);
1211}
1212
1213/*
1214** Return the size of the header on each page of this PCACHE implementation.
1215*/
1216int sqlite3HeaderSizePcache1(void){ return ROUND8(sizeof(PgHdr1)); }
1217
1218/*
1219** Return the global mutex used by this PCACHE implementation. The
1220** sqlite3_status() routine needs access to this mutex.
1221*/
1222sqlite3_mutex *sqlite3Pcache1Mutex(void){
1223 return pcache1.mutex;
1224}
1225
1226#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
1227/*
1228** This function is called to free superfluous dynamically allocated memory
1229** held by the pager system. Memory in use by any SQLite pager allocated
1230** by the current thread may be sqlite3_free()ed.
1231**
1232** nReq is the number of bytes of memory required. Once this much has
1233** been released, the function returns. The return value is the total number
1234** of bytes of memory released.
1235*/
1236int sqlite3PcacheReleaseMemory(int nReq){
1237 int nFree = 0;
1238 assert( sqlite3_mutex_notheld(pcache1.grp.mutex) );
1239 assert( sqlite3_mutex_notheld(pcache1.mutex) );
1240 if( sqlite3GlobalConfig.pPage==0 ){
1241 PgHdr1 *p;
1242 pcache1EnterMutex(&pcache1.grp);
1243 while( (nReq<0 || nFree<nReq)
1244 && (p=pcache1.grp.lru.pLruPrev)!=0
1245 && p->isAnchor==0
1246 ){
1247 nFree += pcache1MemSize(p->page.pBuf);
1248 assert( PAGE_IS_UNPINNED(p) );
1249 pcache1PinPage(p);
1250 pcache1RemoveFromHash(p, 1);
1251 }
1252 pcache1LeaveMutex(&pcache1.grp);
1253 }
1254 return nFree;
1255}
1256#endif /* SQLITE_ENABLE_MEMORY_MANAGEMENT */
1257
1258#ifdef SQLITE_TEST
1259/*
1260** This function is used by test procedures to inspect the internal state
1261** of the global cache.
1262*/
1263void sqlite3PcacheStats(
1264 int *pnCurrent, /* OUT: Total number of pages cached */
1265 int *pnMax, /* OUT: Global maximum cache size */
1266 int *pnMin, /* OUT: Sum of PCache1.nMin for purgeable caches */
1267 int *pnRecyclable /* OUT: Total number of pages available for recycling */
1268){
1269 PgHdr1 *p;
1270 int nRecyclable = 0;
1271 for(p=pcache1.grp.lru.pLruNext; p && !p->isAnchor; p=p->pLruNext){
1272 assert( PAGE_IS_UNPINNED(p) );
1273 nRecyclable++;
1274 }
1275 *pnCurrent = pcache1.grp.nPurgeable;
1276 *pnMax = (int)pcache1.grp.nMaxPage;
1277 *pnMin = (int)pcache1.grp.nMinPage;
1278 *pnRecyclable = nRecyclable;
1279}
1280#endif
1281