| Adds a new API function sqlite3_preload(). This fills the page cache | |
| with the first pages of the database. | |
| Index: src/build.c | |
| =================================================================== | |
| --- src/build.c 2009-09-11 07:02:46.000000000 -0700 | |
| +++ src/build.c 2009-09-14 18:16:46.000000000 -0700 | |
| @@ -26,6 +26,9 @@ | |
| */ | |
| #include "sqliteInt.h" | |
| +#include "pager.h" | |
| +#include "btree.h" | |
| + | |
| /* | |
| ** This routine is called when a new SQL statement is beginning to | |
| ** be parsed. Initialize the pParse structure as needed. | |
| @@ -3659,3 +3662,30 @@ | |
| } | |
| return pKey; | |
| } | |
| + | |
| +/* Begin preload-cache.patch for Chromium */ | |
| +/* See declaration in sqlite3.h for information */ | |
| +int sqlite3_preload(sqlite3 *db) | |
| +{ | |
| + Pager *pPager; | |
| + Btree *pBt; | |
| + int rc; | |
| + int i; | |
| + int dbsLoaded = 0; | |
| + | |
| + for(i=0; i<db->nDb; i++) { | |
| + pBt = db->aDb[i].pBt; | |
| + if( !pBt ) | |
| + continue; | |
| + pPager = sqlite3BtreePager(pBt); | |
| + if( pPager ) { | |
| + rc = sqlite3PagerLoadall(pPager); | |
| + if (rc == SQLITE_OK) | |
| + dbsLoaded++; | |
| + } | |
| + } | |
| + if (dbsLoaded == 0) | |
| + return SQLITE_ERROR; | |
| + return SQLITE_OK; | |
| +} | |
| +/* End preload-cache.patch for Chromium */ | |
| Index: src/sqlite3.h.in | |
| =================================================================== | |
| --- src/sqlite.h.in 2009-09-09 07:03:20.000000000 -0700 | |
| +++ src/sqlite.h.in 2009-09-15 11:34:26.000000000 -0700 | |
| @@ -4677,6 +4677,21 @@ | |
| */ | |
| int sqlite3_blob_write(sqlite3_blob *, const void *z, int n, int iOffset); | |
| +/* Begin preload-cache.patch for Chromium */ | |
| +/* | |
| +** Preload the databases into the pager cache, up to the maximum size of the | |
| +** pager cache. | |
| +** | |
| +** For a database to be loaded successfully, the pager must be active. That is, | |
| +** there must be an open statement on that database. See sqlite3pager_loadall | |
| +** | |
| +** There might be many databases attached to the given connection. We iterate | |
| +** them all and try to load them. If none are loadable successfully, we return | |
| +** an error. Otherwise, we return OK. | |
| +*/ | |
| +int sqlite3_preload(sqlite3 *db); | |
| +/* End preload-cache.patch for Chromium */ | |
| + | |
| /* | |
| ** CAPI3REF: Virtual File System Objects {H11200} <S20100> | |
| ** | |
| Index: src/pager.c | |
| =================================================================== | |
| --- src/pager.c 2009-09-07 08:58:09.000000000 -0700 | |
| +++ src/pager.c 2009-09-15 16:43:07.000000000 -0700 | |
| @@ -388,6 +388,16 @@ | |
| */ | |
| #define PAGER_MAX_PGNO 2147483647 | |
| +/* Begin preload-cache.patch for Chromium */ | |
| +/* See comments above the definition. */ | |
| +int sqlite3PagerAcquire2( | |
| + Pager *pPager, | |
| + Pgno pgno, | |
| + DbPage **ppPage, | |
| + int noContent, | |
| + unsigned char *pDataToFill); | |
| +/* End preload-cache.patch for Chromium */ | |
| + | |
| #ifndef NDEBUG | |
| /* | |
| ** Usage: | |
| @@ -3788,6 +3798,25 @@ | |
| DbPage **ppPage, /* Write a pointer to the page here */ | |
| int noContent /* Do not bother reading content from disk if true */ | |
| ){ | |
| + /* This just passes through to our modified version with NULL data. */ | |
| + return sqlite3PagerAcquire2(pPager, pgno, ppPage, noContent, 0); | |
| +} | |
| + | |
| +/* | |
| +** This is an internal version of sqlite3PagerAcquire that takes an extra | |
| +** parameter of data to use to fill the page with. This allows more efficient | |
| +** filling for preloaded data. If this extra parameter is NULL, we'll go to | |
| +** the file. | |
| +** | |
| +** See sqlite3PagerLoadall which uses this function. | |
| +*/ | |
| +int sqlite3PagerAcquire2( | |
| + Pager *pPager, /* The pager open on the database file */ | |
| + Pgno pgno, /* Page number to fetch */ | |
| + DbPage **ppPage, /* Write a pointer to the page here */ | |
| + int noContent, /* Do not bother reading content from disk if true */ | |
| + unsigned char* pDataToFill | |
| +){ | |
| int rc; | |
| PgHdr *pPg; | |
| @@ -3870,9 +3899,17 @@ | |
| IOTRACE(("ZERO %p %d\n", pPager, pgno)); | |
| }else{ | |
| assert( pPg->pPager==pPager ); | |
| - rc = readDbPage(pPg); | |
| - if( rc!=SQLITE_OK ){ | |
| - goto pager_acquire_err; | |
| + if( pDataToFill ){ | |
| + /* Just copy from the given memory */ | |
| + memcpy(pPg->pData, pDataToFill, pPager->pageSize); | |
| + CODEC1(pPager, pPg->pData, pPg->pgno, 3, rc = SQLITE_NOMEM; | |
| + goto pager_acquire_err); | |
| + }else{ | |
| + /* Load from disk (old regular sqlite code path) */ | |
| + rc = readDbPage(pPg); | |
| + if( rc!=SQLITE_OK ){ | |
| + goto pager_acquire_err; | |
| + } | |
| } | |
| } | |
| #ifdef SQLITE_CHECK_PAGES | |
| @@ -5221,6 +5258,91 @@ | |
| } | |
| #endif | |
| +/* Begin preload-cache.patch for Chromium */ | |
| +/** | |
| +** When making large allocations, there is no need to stress the heap and | |
| +** potentially hold its lock while we allocate a bunch of memory. If we know | |
| +** the allocation will be large, go directly to the OS instead of the heap. | |
| +**/ | |
| +static void* allocLarge(size_t size) { | |
| +#if SQLITE_OS_WIN | |
| + return VirtualAlloc(NULL, size, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE); | |
| +#else | |
| + return sqlite3Malloc(size); | |
| +#endif | |
| +} | |
| + | |
| +static void freeLarge(void* ptr) { | |
| +#if SQLITE_OS_WIN | |
| + VirtualFree(ptr, 0, MEM_RELEASE); | |
| +#else | |
| + sqlite3_free(ptr); | |
| +#endif | |
| +} | |
| + | |
| +/** | |
| +** Addition: This will attempt to populate the database cache with | |
| +** the first N bytes of the file, where N is the total size of the cache. | |
| +** Because we can load this as one chunk from the disk, this is much faster | |
| +** than loading a subset of the pages one at a time in random order. | |
| +** | |
| +** The pager must be initialized before this function is called. This means a | |
| +* statement must be open that has initialized the pager and is keeping the | |
| +** cache in memory. | |
| +**/ | |
| +int sqlite3PagerLoadall(Pager* pPager) | |
| +{ | |
| + int i; | |
| + int rc; | |
| + int nMax; | |
| + int loadSize; | |
| + int loadPages; | |
| + unsigned char *fileData; | |
| + | |
| + if (pPager->dbSize < 0 || pPager->pageSize < 0) { | |
| + /* pager not initialized, this means a statement is not open */ | |
| + return SQLITE_MISUSE; | |
| + } | |
| + | |
| + /* compute sizes */ | |
| + nMax = sqlite3PcacheGetCachesize(pPager->pPCache); | |
| + if (nMax < pPager->dbSize) | |
| + loadPages = nMax; | |
| + else | |
| + loadPages = pPager->dbSize; | |
| + loadSize = loadPages * pPager->pageSize; | |
| + | |
| + /* load the file as one chunk */ | |
| + fileData = allocLarge(loadSize); | |
| + if (! fileData) | |
| + return SQLITE_NOMEM; | |
| + rc = sqlite3OsRead(pPager->fd, fileData, loadSize, 0); | |
| + if (rc != SQLITE_OK) { | |
| + freeLarge(fileData); | |
| + return rc; | |
| + } | |
| + | |
| + /* Copy the data to each page. Note that the page numbers we pass to _get | |
| + * are one-based, 0 is a marker for no page. We also need to check that we | |
| + * haven't loaded more pages than the cache can hold total. There may have | |
| + * already been a few pages loaded before, so we may fill the cache before | |
| + * loading all of the pages we want to. | |
| + */ | |
| + for(i=1; | |
| + i <= loadPages && sqlite3PcachePagecount(pPager->pPCache) < nMax; | |
| + i++) { | |
| + DbPage *pPage = 0; | |
| + rc = sqlite3PagerAcquire2(pPager, i, &pPage, 0, | |
| + &fileData[(i-1)*(i64)pPager->pageSize]); | |
| + if (rc != SQLITE_OK) | |
| + break; | |
| + sqlite3PagerUnref(pPage); | |
| + } | |
| + freeLarge(fileData); | |
| + return SQLITE_OK; | |
| +} | |
| +/* End preload-cache.patch for Chromium */ | |
| + | |
| /* | |
| ** Return a pointer to the data for the specified page. | |
| */ | |
| Index: src/pager.h | |
| =================================================================== | |
| --- src/pager.h 2009-09-04 13:37:42.000000000 -0700 | |
| +++ src/pager.h 2009-09-15 11:31:55.000000000 -0700 | |
| @@ -143,6 +143,8 @@ | |
| sqlite3_file *sqlite3PagerFile(Pager*); | |
| const char *sqlite3PagerJournalname(Pager*); | |
| int sqlite3PagerNosync(Pager*); | |
| +/* This function is for preload-cache.patch for Chromium: */ | |
| +int sqlite3PagerLoadall(Pager*); | |
| void *sqlite3PagerTempSpace(Pager*); | |
| int sqlite3PagerIsMemdb(Pager*); | |
| Index: src/pcache.c | |
| =================================================================== | |
| --- src/pcache.c 2009-09-04 13:37:42.000000000 -0700 | |
| +++ src/pcache.c 2009-09-15 16:41:55.000000000 -0700 | |
| @@ -542,14 +542,12 @@ | |
| return nPage; | |
| } | |
| -#ifdef SQLITE_TEST | |
| /* | |
| ** Get the suggested cache-size value. | |
| */ | |
| int sqlite3PcacheGetCachesize(PCache *pCache){ | |
| return pCache->nMax; | |
| } | |
| -#endif | |
| /* | |
| ** Set the suggested cache-size value. | |
| Index: src/pcache.h | |
| =================================================================== | |
| --- src/pcache.h 2009-09-04 13:37:42.000000000 -0700 | |
| +++ src/pcache.h 2009-09-15 16:41:52.000000000 -0700 | |
| @@ -139,9 +139,7 @@ | |
| ** of the suggested cache-sizes. | |
| */ | |
| void sqlite3PcacheSetCachesize(PCache *, int); | |
| -#ifdef SQLITE_TEST | |
| int sqlite3PcacheGetCachesize(PCache *); | |
| -#endif | |
| #ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT | |
| /* Try to return memory used by the pcache module to the main memory heap */ |