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