1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/persistentdata/persistentstorage/sql/SQLite364/pcache.c Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,1283 @@
1.4 +/*
1.5 +** 2008 August 05
1.6 +**
1.7 +** The author disclaims copyright to this source code. In place of
1.8 +** a legal notice, here is a blessing:
1.9 +**
1.10 +** May you do good and not evil.
1.11 +** May you find forgiveness for yourself and forgive others.
1.12 +** May you share freely, never taking more than you give.
1.13 +**
1.14 +*************************************************************************
1.15 +** This file implements that page cache.
1.16 +**
1.17 +** @(#) $Id: pcache.c,v 1.33 2008/09/29 11:49:48 danielk1977 Exp $
1.18 +*/
1.19 +#include "sqliteInt.h"
1.20 +
1.21 +/*
1.22 +** A complete page cache is an instance of this structure.
1.23 +**
1.24 +** A cache may only be deleted by its owner and while holding the
1.25 +** SQLITE_MUTEX_STATUS_LRU mutex.
1.26 +*/
1.27 +struct PCache {
1.28 + /*********************************************************************
1.29 + ** The first group of elements may be read or written at any time by
1.30 + ** the cache owner without holding the mutex. No thread other than the
1.31 + ** cache owner is permitted to access these elements at any time.
1.32 + */
1.33 + PgHdr *pDirty, *pDirtyTail; /* List of dirty pages in LRU order */
1.34 + PgHdr *pSynced; /* Last synced page in dirty page list */
1.35 + int nRef; /* Number of pinned pages */
1.36 + int nPinned; /* Number of pinned and/or dirty pages */
1.37 + int nMax; /* Configured cache size */
1.38 + int nMin; /* Configured minimum cache size */
1.39 + /**********************************************************************
1.40 + ** The next group of elements are fixed when the cache is created and
1.41 + ** may not be changed afterwards. These elements can read at any time by
1.42 + ** the cache owner or by any thread holding the the mutex. Non-owner
1.43 + ** threads must hold the mutex when reading these elements to prevent
1.44 + ** the entire PCache object from being deleted during the read.
1.45 + */
1.46 + int szPage; /* Size of every page in this cache */
1.47 + int szExtra; /* Size of extra space for each page */
1.48 + int bPurgeable; /* True if pages are on backing store */
1.49 + int (*xStress)(void*,PgHdr*); /* Call to try make a page clean */
1.50 + void *pStress; /* Argument to xStress */
1.51 + /**********************************************************************
1.52 + ** The final group of elements can only be accessed while holding the
1.53 + ** mutex. Both the cache owner and any other thread must hold the mutex
1.54 + ** to read or write any of these elements.
1.55 + */
1.56 + int nPage; /* Total number of pages in apHash */
1.57 + int nHash; /* Number of slots in apHash[] */
1.58 + PgHdr **apHash; /* Hash table for fast lookup by pgno */
1.59 + PgHdr *pClean; /* List of clean pages in use */
1.60 +};
1.61 +
1.62 +/*
1.63 +** Free slots in the page block allocator
1.64 +*/
1.65 +typedef struct PgFreeslot PgFreeslot;
1.66 +struct PgFreeslot {
1.67 + PgFreeslot *pNext; /* Next free slot */
1.68 +};
1.69 +
1.70 +/*
1.71 +** Global data for the page cache.
1.72 +*/
1.73 +static SQLITE_WSD struct PCacheGlobal {
1.74 + int isInit; /* True when initialized */
1.75 + sqlite3_mutex *mutex; /* static mutex MUTEX_STATIC_LRU */
1.76 +
1.77 + int nMaxPage; /* Sum of nMaxPage for purgeable caches */
1.78 + int nMinPage; /* Sum of nMinPage for purgeable caches */
1.79 + int nCurrentPage; /* Number of purgeable pages allocated */
1.80 + PgHdr *pLruHead, *pLruTail; /* LRU list of unused clean pgs */
1.81 +
1.82 + /* Variables related to SQLITE_CONFIG_PAGECACHE settings. */
1.83 + int szSlot; /* Size of each free slot */
1.84 + void *pStart, *pEnd; /* Bounds of pagecache malloc range */
1.85 + PgFreeslot *pFree; /* Free page blocks */
1.86 +} pcache = {0};
1.87 +
1.88 +/*
1.89 +** All code in this file should access the global pcache structure via the
1.90 +** alias "pcache_g". This ensures that the WSD emulation is used when
1.91 +** compiling for systems that do not support real WSD.
1.92 +*/
1.93 +#define pcache_g (GLOBAL(struct PCacheGlobal, pcache))
1.94 +
1.95 +/*
1.96 +** All global variables used by this module (all of which are grouped
1.97 +** together in global structure "pcache" above) are protected by the static
1.98 +** SQLITE_MUTEX_STATIC_LRU mutex. A pointer to this mutex is stored in
1.99 +** variable "pcache.mutex".
1.100 +**
1.101 +** Some elements of the PCache and PgHdr structures are protected by the
1.102 +** SQLITE_MUTEX_STATUS_LRU mutex and other are not. The protected
1.103 +** elements are grouped at the end of the structures and are clearly
1.104 +** marked.
1.105 +**
1.106 +** Use the following macros must surround all access (read or write)
1.107 +** of protected elements. The mutex is not recursive and may not be
1.108 +** entered more than once. The pcacheMutexHeld() macro should only be
1.109 +** used within an assert() to verify that the mutex is being held.
1.110 +*/
1.111 +#define pcacheEnterMutex() sqlite3_mutex_enter(pcache_g.mutex)
1.112 +#define pcacheExitMutex() sqlite3_mutex_leave(pcache_g.mutex)
1.113 +#define pcacheMutexHeld() sqlite3_mutex_held(pcache_g.mutex)
1.114 +
1.115 +/*
1.116 +** Some of the assert() macros in this code are too expensive to run
1.117 +** even during normal debugging. Use them only rarely on long-running
1.118 +** tests. Enable the expensive asserts using the
1.119 +** -DSQLITE_ENABLE_EXPENSIVE_ASSERT=1 compile-time option.
1.120 +*/
1.121 +#ifdef SQLITE_ENABLE_EXPENSIVE_ASSERT
1.122 +# define expensive_assert(X) assert(X)
1.123 +#else
1.124 +# define expensive_assert(X)
1.125 +#endif
1.126 +
1.127 +/********************************** Linked List Management ********************/
1.128 +
1.129 +#if !defined(NDEBUG) && defined(SQLITE_ENABLE_EXPENSIVE_ASSERT)
1.130 +/*
1.131 +** This routine verifies that the number of entries in the hash table
1.132 +** is pCache->nPage. This routine is used within assert() statements
1.133 +** only and is therefore disabled during production builds.
1.134 +*/
1.135 +static int pcacheCheckHashCount(PCache *pCache){
1.136 + int i;
1.137 + int nPage = 0;
1.138 + for(i=0; i<pCache->nHash; i++){
1.139 + PgHdr *p;
1.140 + for(p=pCache->apHash[i]; p; p=p->pNextHash){
1.141 + nPage++;
1.142 + }
1.143 + }
1.144 + assert( nPage==pCache->nPage );
1.145 + return 1;
1.146 +}
1.147 +#endif /* !NDEBUG && SQLITE_ENABLE_EXPENSIVE_ASSERT */
1.148 +
1.149 +
1.150 +#if !defined(NDEBUG) && defined(SQLITE_ENABLE_EXPENSIVE_ASSERT)
1.151 +/*
1.152 +** Based on the current value of PCache.nRef and the contents of the
1.153 +** PCache.pDirty list, return the expected value of the PCache.nPinned
1.154 +** counter. This is only used in debugging builds, as follows:
1.155 +**
1.156 +** expensive_assert( pCache->nPinned==pcachePinnedCount(pCache) );
1.157 +*/
1.158 +static int pcachePinnedCount(PCache *pCache){
1.159 + PgHdr *p;
1.160 + int nPinned = pCache->nRef;
1.161 + for(p=pCache->pDirty; p; p=p->pNext){
1.162 + if( p->nRef==0 ){
1.163 + nPinned++;
1.164 + }
1.165 + }
1.166 + return nPinned;
1.167 +}
1.168 +#endif /* !NDEBUG && SQLITE_ENABLE_EXPENSIVE_ASSERT */
1.169 +
1.170 +
1.171 +#if !defined(NDEBUG) && defined(SQLITE_ENABLE_EXPENSIVE_ASSERT)
1.172 +/*
1.173 +** Check that the pCache->pSynced variable is set correctly. If it
1.174 +** is not, either fail an assert or return zero. Otherwise, return
1.175 +** non-zero. This is only used in debugging builds, as follows:
1.176 +**
1.177 +** expensive_assert( pcacheCheckSynced(pCache) );
1.178 +*/
1.179 +static int pcacheCheckSynced(PCache *pCache){
1.180 + PgHdr *p = pCache->pDirtyTail;
1.181 + for(p=pCache->pDirtyTail; p!=pCache->pSynced; p=p->pPrev){
1.182 + assert( p->nRef || (p->flags&PGHDR_NEED_SYNC) );
1.183 + }
1.184 + return (p==0 || p->nRef || (p->flags&PGHDR_NEED_SYNC)==0);
1.185 +}
1.186 +#endif /* !NDEBUG && SQLITE_ENABLE_EXPENSIVE_ASSERT */
1.187 +
1.188 +
1.189 +
1.190 +/*
1.191 +** Remove a page from its hash table (PCache.apHash[]).
1.192 +*/
1.193 +static void pcacheRemoveFromHash(PgHdr *pPage){
1.194 + assert( pcacheMutexHeld() );
1.195 + if( pPage->pPrevHash ){
1.196 + pPage->pPrevHash->pNextHash = pPage->pNextHash;
1.197 + }else{
1.198 + PCache *pCache = pPage->pCache;
1.199 + u32 h = pPage->pgno % pCache->nHash;
1.200 + assert( pCache->apHash[h]==pPage );
1.201 + pCache->apHash[h] = pPage->pNextHash;
1.202 + }
1.203 + if( pPage->pNextHash ){
1.204 + pPage->pNextHash->pPrevHash = pPage->pPrevHash;
1.205 + }
1.206 + pPage->pCache->nPage--;
1.207 + expensive_assert( pcacheCheckHashCount(pPage->pCache) );
1.208 +}
1.209 +
1.210 +/*
1.211 +** Insert a page into the hash table
1.212 +**
1.213 +** The mutex must be held by the caller.
1.214 +*/
1.215 +static void pcacheAddToHash(PgHdr *pPage){
1.216 + PCache *pCache = pPage->pCache;
1.217 + u32 h = pPage->pgno % pCache->nHash;
1.218 + assert( pcacheMutexHeld() );
1.219 + pPage->pNextHash = pCache->apHash[h];
1.220 + pPage->pPrevHash = 0;
1.221 + if( pCache->apHash[h] ){
1.222 + pCache->apHash[h]->pPrevHash = pPage;
1.223 + }
1.224 + pCache->apHash[h] = pPage;
1.225 + pCache->nPage++;
1.226 + expensive_assert( pcacheCheckHashCount(pCache) );
1.227 +}
1.228 +
1.229 +/*
1.230 +** Attempt to increase the size the hash table to contain
1.231 +** at least nHash buckets.
1.232 +*/
1.233 +static int pcacheResizeHash(PCache *pCache, int nHash){
1.234 + PgHdr *p;
1.235 + PgHdr **pNew;
1.236 + assert( pcacheMutexHeld() );
1.237 +#ifdef SQLITE_MALLOC_SOFT_LIMIT
1.238 + if( nHash*sizeof(PgHdr*)>SQLITE_MALLOC_SOFT_LIMIT ){
1.239 + nHash = SQLITE_MALLOC_SOFT_LIMIT/sizeof(PgHdr *);
1.240 + }
1.241 +#endif
1.242 + pcacheExitMutex();
1.243 + pNew = (PgHdr **)sqlite3Malloc(sizeof(PgHdr*)*nHash);
1.244 + pcacheEnterMutex();
1.245 + if( !pNew ){
1.246 + return SQLITE_NOMEM;
1.247 + }
1.248 + memset(pNew, 0, sizeof(PgHdr *)*nHash);
1.249 + sqlite3_free(pCache->apHash);
1.250 + pCache->apHash = pNew;
1.251 + pCache->nHash = nHash;
1.252 + pCache->nPage = 0;
1.253 +
1.254 + for(p=pCache->pClean; p; p=p->pNext){
1.255 + pcacheAddToHash(p);
1.256 + }
1.257 + for(p=pCache->pDirty; p; p=p->pNext){
1.258 + pcacheAddToHash(p);
1.259 + }
1.260 + return SQLITE_OK;
1.261 +}
1.262 +
1.263 +/*
1.264 +** Remove a page from a linked list that is headed by *ppHead.
1.265 +** *ppHead is either PCache.pClean or PCache.pDirty.
1.266 +*/
1.267 +static void pcacheRemoveFromList(PgHdr **ppHead, PgHdr *pPage){
1.268 + int isDirtyList = (ppHead==&pPage->pCache->pDirty);
1.269 + assert( ppHead==&pPage->pCache->pClean || ppHead==&pPage->pCache->pDirty );
1.270 + assert( pcacheMutexHeld() || ppHead!=&pPage->pCache->pClean );
1.271 +
1.272 + if( pPage->pPrev ){
1.273 + pPage->pPrev->pNext = pPage->pNext;
1.274 + }else{
1.275 + assert( *ppHead==pPage );
1.276 + *ppHead = pPage->pNext;
1.277 + }
1.278 + if( pPage->pNext ){
1.279 + pPage->pNext->pPrev = pPage->pPrev;
1.280 + }
1.281 +
1.282 + if( isDirtyList ){
1.283 + PCache *pCache = pPage->pCache;
1.284 + assert( pPage->pNext || pCache->pDirtyTail==pPage );
1.285 + if( !pPage->pNext ){
1.286 + pCache->pDirtyTail = pPage->pPrev;
1.287 + }
1.288 + if( pCache->pSynced==pPage ){
1.289 + PgHdr *pSynced = pPage->pPrev;
1.290 + while( pSynced && (pSynced->flags&PGHDR_NEED_SYNC) ){
1.291 + pSynced = pSynced->pPrev;
1.292 + }
1.293 + pCache->pSynced = pSynced;
1.294 + }
1.295 + }
1.296 +}
1.297 +
1.298 +/*
1.299 +** Add a page from a linked list that is headed by *ppHead.
1.300 +** *ppHead is either PCache.pClean or PCache.pDirty.
1.301 +*/
1.302 +static void pcacheAddToList(PgHdr **ppHead, PgHdr *pPage){
1.303 + int isDirtyList = (ppHead==&pPage->pCache->pDirty);
1.304 + assert( ppHead==&pPage->pCache->pClean || ppHead==&pPage->pCache->pDirty );
1.305 +
1.306 + if( (*ppHead) ){
1.307 + (*ppHead)->pPrev = pPage;
1.308 + }
1.309 + pPage->pNext = *ppHead;
1.310 + pPage->pPrev = 0;
1.311 + *ppHead = pPage;
1.312 +
1.313 + if( isDirtyList ){
1.314 + PCache *pCache = pPage->pCache;
1.315 + if( !pCache->pDirtyTail ){
1.316 + assert( pPage->pNext==0 );
1.317 + pCache->pDirtyTail = pPage;
1.318 + }
1.319 + if( !pCache->pSynced && 0==(pPage->flags&PGHDR_NEED_SYNC) ){
1.320 + pCache->pSynced = pPage;
1.321 + }
1.322 + }
1.323 +}
1.324 +
1.325 +/*
1.326 +** Remove a page from the global LRU list
1.327 +*/
1.328 +static void pcacheRemoveFromLruList(PgHdr *pPage){
1.329 + assert( sqlite3_mutex_held(pcache_g.mutex) );
1.330 + assert( (pPage->flags&PGHDR_DIRTY)==0 );
1.331 + if( pPage->pCache->bPurgeable==0 ) return;
1.332 + if( pPage->pNextLru ){
1.333 + assert( pcache_g.pLruTail!=pPage );
1.334 + pPage->pNextLru->pPrevLru = pPage->pPrevLru;
1.335 + }else{
1.336 + assert( pcache_g.pLruTail==pPage );
1.337 + pcache_g.pLruTail = pPage->pPrevLru;
1.338 + }
1.339 + if( pPage->pPrevLru ){
1.340 + assert( pcache_g.pLruHead!=pPage );
1.341 + pPage->pPrevLru->pNextLru = pPage->pNextLru;
1.342 + }else{
1.343 + assert( pcache_g.pLruHead==pPage );
1.344 + pcache_g.pLruHead = pPage->pNextLru;
1.345 + }
1.346 +}
1.347 +
1.348 +/*
1.349 +** Add a page to the global LRU list. The page is normally added
1.350 +** to the front of the list so that it will be the last page recycled.
1.351 +** However, if the PGHDR_REUSE_UNLIKELY bit is set, the page is added
1.352 +** to the end of the LRU list so that it will be the next to be recycled.
1.353 +*/
1.354 +static void pcacheAddToLruList(PgHdr *pPage){
1.355 + assert( sqlite3_mutex_held(pcache_g.mutex) );
1.356 + assert( (pPage->flags&PGHDR_DIRTY)==0 );
1.357 + if( pPage->pCache->bPurgeable==0 ) return;
1.358 + if( pcache_g.pLruTail && (pPage->flags & PGHDR_REUSE_UNLIKELY)!=0 ){
1.359 + /* If reuse is unlikely. Put the page at the end of the LRU list
1.360 + ** where it will be recycled sooner rather than later.
1.361 + */
1.362 + assert( pcache_g.pLruHead );
1.363 + pPage->pNextLru = 0;
1.364 + pPage->pPrevLru = pcache_g.pLruTail;
1.365 + pcache_g.pLruTail->pNextLru = pPage;
1.366 + pcache_g.pLruTail = pPage;
1.367 + pPage->flags &= ~PGHDR_REUSE_UNLIKELY;
1.368 + }else{
1.369 + /* If reuse is possible. the page goes at the beginning of the LRU
1.370 + ** list so that it will be the last to be recycled.
1.371 + */
1.372 + if( pcache_g.pLruHead ){
1.373 + pcache_g.pLruHead->pPrevLru = pPage;
1.374 + }
1.375 + pPage->pNextLru = pcache_g.pLruHead;
1.376 + pcache_g.pLruHead = pPage;
1.377 + pPage->pPrevLru = 0;
1.378 + if( pcache_g.pLruTail==0 ){
1.379 + pcache_g.pLruTail = pPage;
1.380 + }
1.381 + }
1.382 +}
1.383 +
1.384 +/*********************************************** Memory Allocation ***********
1.385 +**
1.386 +** Initialize the page cache memory pool.
1.387 +**
1.388 +** This must be called at start-time when no page cache lines are
1.389 +** checked out. This function is not threadsafe.
1.390 +*/
1.391 +void sqlite3PCacheBufferSetup(void *pBuf, int sz, int n){
1.392 + PgFreeslot *p;
1.393 + sz &= ~7;
1.394 + pcache_g.szSlot = sz;
1.395 + pcache_g.pStart = pBuf;
1.396 + pcache_g.pFree = 0;
1.397 + while( n-- ){
1.398 + p = (PgFreeslot*)pBuf;
1.399 + p->pNext = pcache_g.pFree;
1.400 + pcache_g.pFree = p;
1.401 + pBuf = (void*)&((char*)pBuf)[sz];
1.402 + }
1.403 + pcache_g.pEnd = pBuf;
1.404 +}
1.405 +
1.406 +/*
1.407 +** Allocate a page cache line. Look in the page cache memory pool first
1.408 +** and use an element from it first if available. If nothing is available
1.409 +** in the page cache memory pool, go to the general purpose memory allocator.
1.410 +*/
1.411 +static void *pcacheMalloc(int sz, PCache *pCache){
1.412 + assert( sqlite3_mutex_held(pcache_g.mutex) );
1.413 + if( sz<=pcache_g.szSlot && pcache_g.pFree ){
1.414 + PgFreeslot *p = pcache_g.pFree;
1.415 + pcache_g.pFree = p->pNext;
1.416 + sqlite3StatusSet(SQLITE_STATUS_PAGECACHE_SIZE, sz);
1.417 + sqlite3StatusAdd(SQLITE_STATUS_PAGECACHE_USED, 1);
1.418 + return (void*)p;
1.419 + }else{
1.420 + void *p;
1.421 +
1.422 + /* Allocate a new buffer using sqlite3Malloc. Before doing so, exit the
1.423 + ** global pcache mutex and unlock the pager-cache object pCache. This is
1.424 + ** so that if the attempt to allocate a new buffer causes the the
1.425 + ** configured soft-heap-limit to be breached, it will be possible to
1.426 + ** reclaim memory from this pager-cache.
1.427 + */
1.428 + pcacheExitMutex();
1.429 + p = sqlite3Malloc(sz);
1.430 + pcacheEnterMutex();
1.431 +
1.432 + if( p ){
1.433 + sz = sqlite3MallocSize(p);
1.434 + sqlite3StatusAdd(SQLITE_STATUS_PAGECACHE_OVERFLOW, sz);
1.435 + }
1.436 + return p;
1.437 + }
1.438 +}
1.439 +void *sqlite3PageMalloc(int sz){
1.440 + void *p;
1.441 + pcacheEnterMutex();
1.442 + p = pcacheMalloc(sz, 0);
1.443 + pcacheExitMutex();
1.444 + return p;
1.445 +}
1.446 +
1.447 +/*
1.448 +** Release a pager memory allocation
1.449 +*/
1.450 +static void pcacheFree(void *p){
1.451 + assert( sqlite3_mutex_held(pcache_g.mutex) );
1.452 + if( p==0 ) return;
1.453 + if( p>=pcache_g.pStart && p<pcache_g.pEnd ){
1.454 + PgFreeslot *pSlot;
1.455 + sqlite3StatusAdd(SQLITE_STATUS_PAGECACHE_USED, -1);
1.456 + pSlot = (PgFreeslot*)p;
1.457 + pSlot->pNext = pcache_g.pFree;
1.458 + pcache_g.pFree = pSlot;
1.459 + }else{
1.460 + int iSize = sqlite3MallocSize(p);
1.461 + sqlite3StatusAdd(SQLITE_STATUS_PAGECACHE_OVERFLOW, -iSize);
1.462 + sqlite3_free(p);
1.463 + }
1.464 +}
1.465 +void sqlite3PageFree(void *p){
1.466 + pcacheEnterMutex();
1.467 + pcacheFree(p);
1.468 + pcacheExitMutex();
1.469 +}
1.470 +
1.471 +/*
1.472 +** Allocate a new page.
1.473 +*/
1.474 +static PgHdr *pcachePageAlloc(PCache *pCache){
1.475 + PgHdr *p;
1.476 + int sz = sizeof(*p) + pCache->szPage + pCache->szExtra;
1.477 + assert( sqlite3_mutex_held(pcache_g.mutex) );
1.478 + p = pcacheMalloc(sz, pCache);
1.479 + if( p==0 ) return 0;
1.480 + memset(p, 0, sizeof(PgHdr));
1.481 + p->pData = (void*)&p[1];
1.482 + p->pExtra = (void*)&((char*)p->pData)[pCache->szPage];
1.483 + if( pCache->bPurgeable ){
1.484 + pcache_g.nCurrentPage++;
1.485 + }
1.486 + return p;
1.487 +}
1.488 +
1.489 +/*
1.490 +** Deallocate a page
1.491 +*/
1.492 +static void pcachePageFree(PgHdr *p){
1.493 + assert( sqlite3_mutex_held(pcache_g.mutex) );
1.494 + if( p->pCache->bPurgeable ){
1.495 + pcache_g.nCurrentPage--;
1.496 + }
1.497 + pcacheFree(p->apSave[0]);
1.498 + pcacheFree(p->apSave[1]);
1.499 + pcacheFree(p);
1.500 +}
1.501 +
1.502 +#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
1.503 +/*
1.504 +** Return the number of bytes that will be returned to the heap when
1.505 +** the argument is passed to pcachePageFree().
1.506 +*/
1.507 +static int pcachePageSize(PgHdr *p){
1.508 + assert( sqlite3_mutex_held(pcache_g.mutex) );
1.509 + assert( !pcache_g.pStart );
1.510 + assert( p->apSave[0]==0 );
1.511 + assert( p->apSave[1]==0 );
1.512 + assert( p && p->pCache );
1.513 + return sqlite3MallocSize(p);
1.514 +}
1.515 +#endif
1.516 +
1.517 +/*
1.518 +** Attempt to 'recycle' a page from the global LRU list. Only clean,
1.519 +** unreferenced pages from purgeable caches are eligible for recycling.
1.520 +**
1.521 +** This function removes page pcache.pLruTail from the global LRU list,
1.522 +** and from the hash-table and PCache.pClean list of the owner pcache.
1.523 +** There should be no other references to the page.
1.524 +**
1.525 +** A pointer to the recycled page is returned, or NULL if no page is
1.526 +** eligible for recycling.
1.527 +*/
1.528 +static PgHdr *pcacheRecyclePage(void){
1.529 + PgHdr *p = 0;
1.530 + assert( sqlite3_mutex_held(pcache_g.mutex) );
1.531 +
1.532 + if( (p=pcache_g.pLruTail) ){
1.533 + assert( (p->flags&PGHDR_DIRTY)==0 );
1.534 + pcacheRemoveFromLruList(p);
1.535 + pcacheRemoveFromHash(p);
1.536 + pcacheRemoveFromList(&p->pCache->pClean, p);
1.537 + }
1.538 +
1.539 + return p;
1.540 +}
1.541 +
1.542 +/*
1.543 +** Obtain space for a page. Try to recycle an old page if the limit on the
1.544 +** number of pages has been reached. If the limit has not been reached or
1.545 +** there are no pages eligible for recycling, allocate a new page.
1.546 +**
1.547 +** Return a pointer to the new page, or NULL if an OOM condition occurs.
1.548 +*/
1.549 +static int pcacheRecycleOrAlloc(PCache *pCache, PgHdr **ppPage){
1.550 + PgHdr *p = 0;
1.551 +
1.552 + int szPage = pCache->szPage;
1.553 + int szExtra = pCache->szExtra;
1.554 +
1.555 + assert( pcache_g.isInit );
1.556 + assert( sqlite3_mutex_held(pcache_g.mutex) );
1.557 +
1.558 + *ppPage = 0;
1.559 +
1.560 + /* If we have reached either the global or the local limit for
1.561 + ** pinned+dirty pages, and there is at least one dirty page,
1.562 + ** invoke the xStress callback to cause a page to become clean.
1.563 + */
1.564 + expensive_assert( pCache->nPinned==pcachePinnedCount(pCache) );
1.565 + expensive_assert( pcacheCheckSynced(pCache) );
1.566 + if( pCache->xStress
1.567 + && pCache->pDirty
1.568 + && (pCache->nPinned>=(pcache_g.nMaxPage+pCache->nMin-pcache_g.nMinPage)
1.569 + || pCache->nPinned>=pCache->nMax)
1.570 + ){
1.571 + PgHdr *pPg;
1.572 + assert(pCache->pDirtyTail);
1.573 +
1.574 + for(pPg=pCache->pSynced;
1.575 + pPg && (pPg->nRef || (pPg->flags&PGHDR_NEED_SYNC));
1.576 + pPg=pPg->pPrev
1.577 + );
1.578 + if( !pPg ){
1.579 + for(pPg=pCache->pDirtyTail; pPg && pPg->nRef; pPg=pPg->pPrev);
1.580 + }
1.581 + if( pPg ){
1.582 + int rc;
1.583 + pcacheExitMutex();
1.584 + rc = pCache->xStress(pCache->pStress, pPg);
1.585 + pcacheEnterMutex();
1.586 + if( rc!=SQLITE_OK && rc!=SQLITE_BUSY ){
1.587 + return rc;
1.588 + }
1.589 + }
1.590 + }
1.591 +
1.592 + /* If either the local or the global page limit has been reached,
1.593 + ** try to recycle a page.
1.594 + */
1.595 + if( pCache->bPurgeable && (pCache->nPage>=pCache->nMax-1 ||
1.596 + pcache_g.nCurrentPage>=pcache_g.nMaxPage) ){
1.597 + p = pcacheRecyclePage();
1.598 + }
1.599 +
1.600 + /* If a page has been recycled but it is the wrong size, free it. */
1.601 + if( p && (p->pCache->szPage!=szPage || p->pCache->szPage!=szExtra) ){
1.602 + pcachePageFree(p);
1.603 + p = 0;
1.604 + }
1.605 +
1.606 + if( !p ){
1.607 + p = pcachePageAlloc(pCache);
1.608 + }
1.609 +
1.610 + *ppPage = p;
1.611 + return (p?SQLITE_OK:SQLITE_NOMEM);
1.612 +}
1.613 +
1.614 +/*************************************************** General Interfaces ******
1.615 +**
1.616 +** Initialize and shutdown the page cache subsystem. Neither of these
1.617 +** functions are threadsafe.
1.618 +*/
1.619 +int sqlite3PcacheInitialize(void){
1.620 + assert( pcache_g.isInit==0 );
1.621 + memset(&pcache_g, 0, sizeof(pcache));
1.622 + if( sqlite3GlobalConfig.bCoreMutex ){
1.623 + /* No need to check the return value of sqlite3_mutex_alloc().
1.624 + ** Allocating a static mutex cannot fail.
1.625 + */
1.626 + pcache_g.mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_LRU);
1.627 + }
1.628 + pcache_g.isInit = 1;
1.629 + return SQLITE_OK;
1.630 +}
1.631 +void sqlite3PcacheShutdown(void){
1.632 + memset(&pcache_g, 0, sizeof(pcache));
1.633 +}
1.634 +
1.635 +/*
1.636 +** Return the size in bytes of a PCache object.
1.637 +*/
1.638 +int sqlite3PcacheSize(void){ return sizeof(PCache); }
1.639 +
1.640 +/*
1.641 +** Create a new PCache object. Storage space to hold the object
1.642 +** has already been allocated and is passed in as the p pointer.
1.643 +*/
1.644 +void sqlite3PcacheOpen(
1.645 + int szPage, /* Size of every page */
1.646 + int szExtra, /* Extra space associated with each page */
1.647 + int bPurgeable, /* True if pages are on backing store */
1.648 + int (*xStress)(void*,PgHdr*),/* Call to try to make pages clean */
1.649 + void *pStress, /* Argument to xStress */
1.650 + PCache *p /* Preallocated space for the PCache */
1.651 +){
1.652 + assert( pcache_g.isInit );
1.653 + memset(p, 0, sizeof(PCache));
1.654 + p->szPage = szPage;
1.655 + p->szExtra = szExtra;
1.656 + p->bPurgeable = bPurgeable;
1.657 + p->xStress = xStress;
1.658 + p->pStress = pStress;
1.659 + p->nMax = 100;
1.660 + p->nMin = 10;
1.661 +
1.662 + pcacheEnterMutex();
1.663 + if( bPurgeable ){
1.664 + pcache_g.nMaxPage += p->nMax;
1.665 + pcache_g.nMinPage += p->nMin;
1.666 + }
1.667 +
1.668 + pcacheExitMutex();
1.669 +}
1.670 +
1.671 +/*
1.672 +** Change the page size for PCache object. This can only happen
1.673 +** when the cache is empty.
1.674 +*/
1.675 +void sqlite3PcacheSetPageSize(PCache *pCache, int szPage){
1.676 + assert(pCache->nPage==0);
1.677 + pCache->szPage = szPage;
1.678 +}
1.679 +
1.680 +/*
1.681 +** Try to obtain a page from the cache.
1.682 +*/
1.683 +int sqlite3PcacheFetch(
1.684 + PCache *pCache, /* Obtain the page from this cache */
1.685 + Pgno pgno, /* Page number to obtain */
1.686 + int createFlag, /* If true, create page if it does not exist already */
1.687 + PgHdr **ppPage /* Write the page here */
1.688 +){
1.689 + int rc = SQLITE_OK;
1.690 + PgHdr *pPage = 0;
1.691 +
1.692 + assert( pcache_g.isInit );
1.693 + assert( pCache!=0 );
1.694 + assert( pgno>0 );
1.695 + expensive_assert( pCache->nPinned==pcachePinnedCount(pCache) );
1.696 +
1.697 + pcacheEnterMutex();
1.698 +
1.699 + /* Search the hash table for the requested page. Exit early if it is found. */
1.700 + if( pCache->apHash ){
1.701 + u32 h = pgno % pCache->nHash;
1.702 + for(pPage=pCache->apHash[h]; pPage; pPage=pPage->pNextHash){
1.703 + if( pPage->pgno==pgno ){
1.704 + if( pPage->nRef==0 ){
1.705 + if( 0==(pPage->flags&PGHDR_DIRTY) ){
1.706 + pcacheRemoveFromLruList(pPage);
1.707 + pCache->nPinned++;
1.708 + }
1.709 + pCache->nRef++;
1.710 + }
1.711 + pPage->nRef++;
1.712 + break;
1.713 + }
1.714 + }
1.715 + }
1.716 +
1.717 + if( !pPage && createFlag ){
1.718 + if( pCache->nHash<=pCache->nPage ){
1.719 + rc = pcacheResizeHash(pCache, pCache->nHash<256 ? 256 : pCache->nHash*2);
1.720 + }
1.721 + if( rc==SQLITE_OK ){
1.722 + rc = pcacheRecycleOrAlloc(pCache, &pPage);
1.723 + }
1.724 + if( rc==SQLITE_OK ){
1.725 + pPage->pPager = 0;
1.726 + pPage->flags = 0;
1.727 + pPage->pDirty = 0;
1.728 + pPage->pgno = pgno;
1.729 + pPage->pCache = pCache;
1.730 + pPage->nRef = 1;
1.731 + pCache->nRef++;
1.732 + pCache->nPinned++;
1.733 + pcacheAddToList(&pCache->pClean, pPage);
1.734 + pcacheAddToHash(pPage);
1.735 + }
1.736 + }
1.737 +
1.738 + pcacheExitMutex();
1.739 +
1.740 + *ppPage = pPage;
1.741 + expensive_assert( pCache->nPinned==pcachePinnedCount(pCache) );
1.742 + assert( pPage || !createFlag || rc!=SQLITE_OK );
1.743 + return rc;
1.744 +}
1.745 +
1.746 +/*
1.747 +** Dereference a page. When the reference count reaches zero,
1.748 +** move the page to the LRU list if it is clean.
1.749 +*/
1.750 +void sqlite3PcacheRelease(PgHdr *p){
1.751 + assert( p->nRef>0 );
1.752 + p->nRef--;
1.753 + if( p->nRef==0 ){
1.754 + PCache *pCache = p->pCache;
1.755 + pCache->nRef--;
1.756 + if( (p->flags&PGHDR_DIRTY)==0 ){
1.757 + pCache->nPinned--;
1.758 + pcacheEnterMutex();
1.759 + if( pcache_g.nCurrentPage>pcache_g.nMaxPage ){
1.760 + pcacheRemoveFromList(&pCache->pClean, p);
1.761 + pcacheRemoveFromHash(p);
1.762 + pcachePageFree(p);
1.763 + }else{
1.764 + pcacheAddToLruList(p);
1.765 + }
1.766 + pcacheExitMutex();
1.767 + }else{
1.768 + /* Move the page to the head of the caches dirty list. */
1.769 + pcacheRemoveFromList(&pCache->pDirty, p);
1.770 + pcacheAddToList(&pCache->pDirty, p);
1.771 + }
1.772 + }
1.773 +}
1.774 +
1.775 +void sqlite3PcacheRef(PgHdr *p){
1.776 + assert(p->nRef>0);
1.777 + p->nRef++;
1.778 +}
1.779 +
1.780 +/*
1.781 +** Drop a page from the cache. There must be exactly one reference to the
1.782 +** page. This function deletes that reference, so after it returns the
1.783 +** page pointed to by p is invalid.
1.784 +*/
1.785 +void sqlite3PcacheDrop(PgHdr *p){
1.786 + PCache *pCache;
1.787 + assert( p->nRef==1 );
1.788 + assert( 0==(p->flags&PGHDR_DIRTY) );
1.789 + pCache = p->pCache;
1.790 + pCache->nRef--;
1.791 + pCache->nPinned--;
1.792 + pcacheEnterMutex();
1.793 + pcacheRemoveFromList(&pCache->pClean, p);
1.794 + pcacheRemoveFromHash(p);
1.795 + pcachePageFree(p);
1.796 + pcacheExitMutex();
1.797 +}
1.798 +
1.799 +/*
1.800 +** Make sure the page is marked as dirty. If it isn't dirty already,
1.801 +** make it so.
1.802 +*/
1.803 +void sqlite3PcacheMakeDirty(PgHdr *p){
1.804 + PCache *pCache;
1.805 + p->flags &= ~PGHDR_DONT_WRITE;
1.806 + if( p->flags & PGHDR_DIRTY ) return;
1.807 + assert( (p->flags & PGHDR_DIRTY)==0 );
1.808 + assert( p->nRef>0 );
1.809 + pCache = p->pCache;
1.810 + pcacheEnterMutex();
1.811 + pcacheRemoveFromList(&pCache->pClean, p);
1.812 + pcacheAddToList(&pCache->pDirty, p);
1.813 + pcacheExitMutex();
1.814 + p->flags |= PGHDR_DIRTY;
1.815 +}
1.816 +
1.817 +static void pcacheMakeClean(PgHdr *p){
1.818 + PCache *pCache = p->pCache;
1.819 + assert( p->apSave[0]==0 && p->apSave[1]==0 );
1.820 + assert( p->flags & PGHDR_DIRTY );
1.821 + pcacheRemoveFromList(&pCache->pDirty, p);
1.822 + pcacheAddToList(&pCache->pClean, p);
1.823 + p->flags &= ~PGHDR_DIRTY;
1.824 + if( p->nRef==0 ){
1.825 + pcacheAddToLruList(p);
1.826 + pCache->nPinned--;
1.827 + }
1.828 + expensive_assert( pCache->nPinned==pcachePinnedCount(pCache) );
1.829 +}
1.830 +
1.831 +/*
1.832 +** Make sure the page is marked as clean. If it isn't clean already,
1.833 +** make it so.
1.834 +*/
1.835 +void sqlite3PcacheMakeClean(PgHdr *p){
1.836 + if( (p->flags & PGHDR_DIRTY) ){
1.837 + pcacheEnterMutex();
1.838 + pcacheMakeClean(p);
1.839 + pcacheExitMutex();
1.840 + }
1.841 +}
1.842 +
1.843 +/*
1.844 +** Make every page in the cache clean.
1.845 +*/
1.846 +void sqlite3PcacheCleanAll(PCache *pCache){
1.847 + PgHdr *p;
1.848 + pcacheEnterMutex();
1.849 + while( (p = pCache->pDirty)!=0 ){
1.850 + assert( p->apSave[0]==0 && p->apSave[1]==0 );
1.851 + pcacheRemoveFromList(&pCache->pDirty, p);
1.852 + p->flags &= ~PGHDR_DIRTY;
1.853 + pcacheAddToList(&pCache->pClean, p);
1.854 + if( p->nRef==0 ){
1.855 + pcacheAddToLruList(p);
1.856 + pCache->nPinned--;
1.857 + }
1.858 + }
1.859 + sqlite3PcacheAssertFlags(pCache, 0, PGHDR_DIRTY);
1.860 + expensive_assert( pCache->nPinned==pcachePinnedCount(pCache) );
1.861 + pcacheExitMutex();
1.862 +}
1.863 +
1.864 +/*
1.865 +** Change the page number of page p to newPgno. If newPgno is 0, then the
1.866 +** page object is added to the clean-list and the PGHDR_REUSE_UNLIKELY
1.867 +** flag set.
1.868 +*/
1.869 +void sqlite3PcacheMove(PgHdr *p, Pgno newPgno){
1.870 + assert( p->nRef>0 );
1.871 + pcacheEnterMutex();
1.872 + pcacheRemoveFromHash(p);
1.873 + p->pgno = newPgno;
1.874 + if( newPgno==0 ){
1.875 + pcacheFree(p->apSave[0]);
1.876 + pcacheFree(p->apSave[1]);
1.877 + p->apSave[0] = 0;
1.878 + p->apSave[1] = 0;
1.879 + if( (p->flags & PGHDR_DIRTY) ){
1.880 + pcacheMakeClean(p);
1.881 + }
1.882 + p->flags = PGHDR_REUSE_UNLIKELY;
1.883 + }
1.884 + pcacheAddToHash(p);
1.885 + pcacheExitMutex();
1.886 +}
1.887 +
1.888 +/*
1.889 +** Remove all content from a page cache
1.890 +*/
1.891 +static void pcacheClear(PCache *pCache){
1.892 + PgHdr *p, *pNext;
1.893 + assert( sqlite3_mutex_held(pcache_g.mutex) );
1.894 + for(p=pCache->pClean; p; p=pNext){
1.895 + pNext = p->pNext;
1.896 + pcacheRemoveFromLruList(p);
1.897 + pcachePageFree(p);
1.898 + }
1.899 + for(p=pCache->pDirty; p; p=pNext){
1.900 + pNext = p->pNext;
1.901 + pcachePageFree(p);
1.902 + }
1.903 + pCache->pClean = 0;
1.904 + pCache->pDirty = 0;
1.905 + pCache->pDirtyTail = 0;
1.906 + pCache->nPage = 0;
1.907 + pCache->nPinned = 0;
1.908 + memset(pCache->apHash, 0, pCache->nHash*sizeof(pCache->apHash[0]));
1.909 +}
1.910 +
1.911 +
1.912 +/*
1.913 +** Drop every cache entry whose page number is greater than "pgno".
1.914 +*/
1.915 +void sqlite3PcacheTruncate(PCache *pCache, Pgno pgno){
1.916 + PgHdr *p, *pNext;
1.917 + PgHdr *pDirty = pCache->pDirty;
1.918 + pcacheEnterMutex();
1.919 + for(p=pCache->pClean; p||pDirty; p=pNext){
1.920 + if( !p ){
1.921 + p = pDirty;
1.922 + pDirty = 0;
1.923 + }
1.924 + pNext = p->pNext;
1.925 + if( p->pgno>pgno ){
1.926 + if( p->nRef==0 ){
1.927 + pcacheRemoveFromHash(p);
1.928 + if( p->flags&PGHDR_DIRTY ){
1.929 + pcacheRemoveFromList(&pCache->pDirty, p);
1.930 + pCache->nPinned--;
1.931 + }else{
1.932 + pcacheRemoveFromList(&pCache->pClean, p);
1.933 + pcacheRemoveFromLruList(p);
1.934 + }
1.935 + pcachePageFree(p);
1.936 + }else{
1.937 + /* If there are references to the page, it cannot be freed. In this
1.938 + ** case, zero the page content instead.
1.939 + */
1.940 + memset(p->pData, 0, pCache->szPage);
1.941 + }
1.942 + }
1.943 + }
1.944 + pcacheExitMutex();
1.945 +}
1.946 +
1.947 +/*
1.948 +** If there are currently more than pcache.nMaxPage pages allocated, try
1.949 +** to recycle pages to reduce the number allocated to pcache.nMaxPage.
1.950 +*/
1.951 +static void pcacheEnforceMaxPage(void){
1.952 + PgHdr *p;
1.953 + assert( sqlite3_mutex_held(pcache_g.mutex) );
1.954 + while( pcache_g.nCurrentPage>pcache_g.nMaxPage && (p = pcacheRecyclePage()) ){
1.955 + pcachePageFree(p);
1.956 + }
1.957 +}
1.958 +
1.959 +/*
1.960 +** Close a cache.
1.961 +*/
1.962 +void sqlite3PcacheClose(PCache *pCache){
1.963 + pcacheEnterMutex();
1.964 +
1.965 + /* Free all the pages used by this pager and remove them from the LRU list. */
1.966 + pcacheClear(pCache);
1.967 + if( pCache->bPurgeable ){
1.968 + pcache_g.nMaxPage -= pCache->nMax;
1.969 + pcache_g.nMinPage -= pCache->nMin;
1.970 + pcacheEnforceMaxPage();
1.971 + }
1.972 + sqlite3_free(pCache->apHash);
1.973 + pcacheExitMutex();
1.974 +}
1.975 +
1.976 +/*
1.977 +** Preserve the content of the page. It is assumed that the content
1.978 +** has not been preserved already.
1.979 +**
1.980 +** If idJournal==0 then this is for the overall transaction.
1.981 +** If idJournal==1 then this is for the statement journal.
1.982 +**
1.983 +** This routine is used for in-memory databases only.
1.984 +**
1.985 +** Return SQLITE_OK or SQLITE_NOMEM if a memory allocation fails.
1.986 +*/
1.987 +int sqlite3PcachePreserve(PgHdr *p, int idJournal){
1.988 + void *x;
1.989 + int sz;
1.990 + assert( p->pCache->bPurgeable==0 );
1.991 + assert( p->apSave[idJournal]==0 );
1.992 + sz = p->pCache->szPage;
1.993 + p->apSave[idJournal] = x = sqlite3PageMalloc( sz );
1.994 + if( x==0 ) return SQLITE_NOMEM;
1.995 + memcpy(x, p->pData, sz);
1.996 + return SQLITE_OK;
1.997 +}
1.998 +
1.999 +/*
1.1000 +** Commit a change previously preserved.
1.1001 +*/
1.1002 +void sqlite3PcacheCommit(PCache *pCache, int idJournal){
1.1003 + PgHdr *p;
1.1004 + int mask = idJournal==0 ? ~PGHDR_IN_JOURNAL : 0xffffff;
1.1005 + pcacheEnterMutex(); /* Mutex is required to call pcacheFree() */
1.1006 + for(p=pCache->pDirty; p; p=p->pNext){
1.1007 + if( p->apSave[idJournal] ){
1.1008 + pcacheFree(p->apSave[idJournal]);
1.1009 + p->apSave[idJournal] = 0;
1.1010 + }
1.1011 + p->flags &= mask;
1.1012 + }
1.1013 + pcacheExitMutex();
1.1014 +}
1.1015 +
1.1016 +/*
1.1017 +** Rollback a change previously preserved.
1.1018 +*/
1.1019 +void sqlite3PcacheRollback(
1.1020 + PCache *pCache, /* Pager cache */
1.1021 + int idJournal, /* Which copy to rollback to */
1.1022 + void (*xReiniter)(PgHdr*) /* Called on each rolled back page */
1.1023 +){
1.1024 + PgHdr *p;
1.1025 + int sz;
1.1026 + int mask = idJournal==0 ? ~PGHDR_IN_JOURNAL : 0xffffff;
1.1027 + pcacheEnterMutex(); /* Mutex is required to call pcacheFree() */
1.1028 + sz = pCache->szPage;
1.1029 + for(p=pCache->pDirty; p; p=p->pNext){
1.1030 + if( p->apSave[idJournal] ){
1.1031 + memcpy(p->pData, p->apSave[idJournal], sz);
1.1032 + pcacheFree(p->apSave[idJournal]);
1.1033 + p->apSave[idJournal] = 0;
1.1034 + if( xReiniter ){
1.1035 + xReiniter(p);
1.1036 + }
1.1037 + }
1.1038 + p->flags &= mask;
1.1039 + }
1.1040 + pcacheExitMutex();
1.1041 +}
1.1042 +
1.1043 +#ifndef NDEBUG
1.1044 +/*
1.1045 +** Assert flags settings on all pages. Debugging only.
1.1046 +*/
1.1047 +void sqlite3PcacheAssertFlags(PCache *pCache, int trueMask, int falseMask){
1.1048 + PgHdr *p;
1.1049 + for(p=pCache->pDirty; p; p=p->pNext){
1.1050 + assert( (p->flags&trueMask)==trueMask );
1.1051 + assert( (p->flags&falseMask)==0 );
1.1052 + }
1.1053 + for(p=pCache->pClean; p; p=p->pNext){
1.1054 + assert( (p->flags&trueMask)==trueMask );
1.1055 + assert( (p->flags&falseMask)==0 );
1.1056 + }
1.1057 +}
1.1058 +#endif
1.1059 +
1.1060 +/*
1.1061 +** Discard the contents of the cache.
1.1062 +*/
1.1063 +int sqlite3PcacheClear(PCache *pCache){
1.1064 + assert(pCache->nRef==0);
1.1065 + pcacheEnterMutex();
1.1066 + pcacheClear(pCache);
1.1067 + pcacheExitMutex();
1.1068 + return SQLITE_OK;
1.1069 +}
1.1070 +
1.1071 +/*
1.1072 +** Merge two lists of pages connected by pDirty and in pgno order.
1.1073 +** Do not both fixing the pPrevDirty pointers.
1.1074 +*/
1.1075 +static PgHdr *pcacheMergeDirtyList(PgHdr *pA, PgHdr *pB){
1.1076 + PgHdr result, *pTail;
1.1077 + pTail = &result;
1.1078 + while( pA && pB ){
1.1079 + if( pA->pgno<pB->pgno ){
1.1080 + pTail->pDirty = pA;
1.1081 + pTail = pA;
1.1082 + pA = pA->pDirty;
1.1083 + }else{
1.1084 + pTail->pDirty = pB;
1.1085 + pTail = pB;
1.1086 + pB = pB->pDirty;
1.1087 + }
1.1088 + }
1.1089 + if( pA ){
1.1090 + pTail->pDirty = pA;
1.1091 + }else if( pB ){
1.1092 + pTail->pDirty = pB;
1.1093 + }else{
1.1094 + pTail->pDirty = 0;
1.1095 + }
1.1096 + return result.pDirty;
1.1097 +}
1.1098 +
1.1099 +/*
1.1100 +** Sort the list of pages in accending order by pgno. Pages are
1.1101 +** connected by pDirty pointers. The pPrevDirty pointers are
1.1102 +** corrupted by this sort.
1.1103 +*/
1.1104 +#define N_SORT_BUCKET_ALLOC 25
1.1105 +#define N_SORT_BUCKET 25
1.1106 +#ifdef SQLITE_TEST
1.1107 + int sqlite3_pager_n_sort_bucket = 0;
1.1108 + #undef N_SORT_BUCKET
1.1109 + #define N_SORT_BUCKET \
1.1110 + (sqlite3_pager_n_sort_bucket?sqlite3_pager_n_sort_bucket:N_SORT_BUCKET_ALLOC)
1.1111 +#endif
1.1112 +static PgHdr *pcacheSortDirtyList(PgHdr *pIn){
1.1113 + PgHdr *a[N_SORT_BUCKET_ALLOC], *p;
1.1114 + int i;
1.1115 + memset(a, 0, sizeof(a));
1.1116 + while( pIn ){
1.1117 + p = pIn;
1.1118 + pIn = p->pDirty;
1.1119 + p->pDirty = 0;
1.1120 + for(i=0; i<N_SORT_BUCKET-1; i++){
1.1121 + if( a[i]==0 ){
1.1122 + a[i] = p;
1.1123 + break;
1.1124 + }else{
1.1125 + p = pcacheMergeDirtyList(a[i], p);
1.1126 + a[i] = 0;
1.1127 + }
1.1128 + }
1.1129 + if( i==N_SORT_BUCKET-1 ){
1.1130 + /* Coverage: To get here, there need to be 2^(N_SORT_BUCKET)
1.1131 + ** elements in the input list. This is possible, but impractical.
1.1132 + ** Testing this line is the point of global variable
1.1133 + ** sqlite3_pager_n_sort_bucket.
1.1134 + */
1.1135 + a[i] = pcacheMergeDirtyList(a[i], p);
1.1136 + }
1.1137 + }
1.1138 + p = a[0];
1.1139 + for(i=1; i<N_SORT_BUCKET; i++){
1.1140 + p = pcacheMergeDirtyList(p, a[i]);
1.1141 + }
1.1142 + return p;
1.1143 +}
1.1144 +
1.1145 +/*
1.1146 +** Return a list of all dirty pages in the cache, sorted by page number.
1.1147 +*/
1.1148 +PgHdr *sqlite3PcacheDirtyList(PCache *pCache){
1.1149 + PgHdr *p;
1.1150 + for(p=pCache->pDirty; p; p=p->pNext){
1.1151 + p->pDirty = p->pNext;
1.1152 + }
1.1153 + return pcacheSortDirtyList(pCache->pDirty);
1.1154 +}
1.1155 +
1.1156 +/*
1.1157 +** Return the total number of outstanding page references.
1.1158 +*/
1.1159 +int sqlite3PcacheRefCount(PCache *pCache){
1.1160 + return pCache->nRef;
1.1161 +}
1.1162 +
1.1163 +int sqlite3PcachePageRefcount(PgHdr *p){
1.1164 + return p->nRef;
1.1165 +}
1.1166 +
1.1167 +/*
1.1168 +** Return the total number of pages in the cache.
1.1169 +*/
1.1170 +int sqlite3PcachePagecount(PCache *pCache){
1.1171 + assert( pCache->nPage>=0 );
1.1172 + return pCache->nPage;
1.1173 +}
1.1174 +
1.1175 +#ifdef SQLITE_CHECK_PAGES
1.1176 +/*
1.1177 +** This function is used by the pager.c module to iterate through all
1.1178 +** pages in the cache. At present, this is only required if the
1.1179 +** SQLITE_CHECK_PAGES macro (used for debugging) is specified.
1.1180 +*/
1.1181 +void sqlite3PcacheIterate(PCache *pCache, void (*xIter)(PgHdr *)){
1.1182 + PgHdr *p;
1.1183 + for(p=pCache->pClean; p; p=p->pNext){
1.1184 + xIter(p);
1.1185 + }
1.1186 + for(p=pCache->pDirty; p; p=p->pNext){
1.1187 + xIter(p);
1.1188 + }
1.1189 +}
1.1190 +#endif
1.1191 +
1.1192 +/*
1.1193 +** Set flags on all pages in the page cache
1.1194 +*/
1.1195 +void sqlite3PcacheClearFlags(PCache *pCache, int mask){
1.1196 + PgHdr *p;
1.1197 +
1.1198 + /* Obtain the global mutex before modifying any PgHdr.flags variables
1.1199 + ** or traversing the LRU list.
1.1200 + */
1.1201 + pcacheEnterMutex();
1.1202 +
1.1203 + mask = ~mask;
1.1204 + for(p=pCache->pDirty; p; p=p->pNext){
1.1205 + p->flags &= mask;
1.1206 + }
1.1207 + for(p=pCache->pClean; p; p=p->pNext){
1.1208 + p->flags &= mask;
1.1209 + }
1.1210 +
1.1211 + if( 0==(mask&PGHDR_NEED_SYNC) ){
1.1212 + pCache->pSynced = pCache->pDirtyTail;
1.1213 + assert( !pCache->pSynced || (pCache->pSynced->flags&PGHDR_NEED_SYNC)==0 );
1.1214 + }
1.1215 +
1.1216 + pcacheExitMutex();
1.1217 +}
1.1218 +
1.1219 +/*
1.1220 +** Set the suggested cache-size value.
1.1221 +*/
1.1222 +int sqlite3PcacheGetCachesize(PCache *pCache){
1.1223 + return pCache->nMax;
1.1224 +}
1.1225 +
1.1226 +/*
1.1227 +** Set the suggested cache-size value.
1.1228 +*/
1.1229 +void sqlite3PcacheSetCachesize(PCache *pCache, int mxPage){
1.1230 + if( mxPage<10 ){
1.1231 + mxPage = 10;
1.1232 + }
1.1233 + if( pCache->bPurgeable ){
1.1234 + pcacheEnterMutex();
1.1235 + pcache_g.nMaxPage -= pCache->nMax;
1.1236 + pcache_g.nMaxPage += mxPage;
1.1237 + pcacheEnforceMaxPage();
1.1238 + pcacheExitMutex();
1.1239 + }
1.1240 + pCache->nMax = mxPage;
1.1241 +}
1.1242 +
1.1243 +#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
1.1244 +/*
1.1245 +** This function is called to free superfluous dynamically allocated memory
1.1246 +** held by the pager system. Memory in use by any SQLite pager allocated
1.1247 +** by the current thread may be sqlite3_free()ed.
1.1248 +**
1.1249 +** nReq is the number of bytes of memory required. Once this much has
1.1250 +** been released, the function returns. The return value is the total number
1.1251 +** of bytes of memory released.
1.1252 +*/
1.1253 +int sqlite3PcacheReleaseMemory(int nReq){
1.1254 + int nFree = 0;
1.1255 + if( pcache_g.pStart==0 ){
1.1256 + PgHdr *p;
1.1257 + pcacheEnterMutex();
1.1258 + while( (nReq<0 || nFree<nReq) && (p=pcacheRecyclePage()) ){
1.1259 + nFree += pcachePageSize(p);
1.1260 + pcachePageFree(p);
1.1261 + }
1.1262 + pcacheExitMutex();
1.1263 + }
1.1264 + return nFree;
1.1265 +}
1.1266 +#endif /* SQLITE_ENABLE_MEMORY_MANAGEMENT */
1.1267 +
1.1268 +#ifdef SQLITE_TEST
1.1269 +void sqlite3PcacheStats(
1.1270 + int *pnCurrent,
1.1271 + int *pnMax,
1.1272 + int *pnMin,
1.1273 + int *pnRecyclable
1.1274 +){
1.1275 + PgHdr *p;
1.1276 + int nRecyclable = 0;
1.1277 + for(p=pcache_g.pLruHead; p; p=p->pNextLru){
1.1278 + nRecyclable++;
1.1279 + }
1.1280 +
1.1281 + *pnCurrent = pcache_g.nCurrentPage;
1.1282 + *pnMax = pcache_g.nMaxPage;
1.1283 + *pnMin = pcache_g.nMinPage;
1.1284 + *pnRecyclable = nRecyclable;
1.1285 +}
1.1286 +#endif