From: danielk1977 Date: Thu, 28 Aug 2008 10:21:16 +0000 (+0000) Subject: Enable the disabled asserts added by (5629). Add extra tests to thread003.test. And... X-Git-Tag: version-3.6.10~546 X-Git-Url: http://git.ipfire.org/?a=commitdiff_plain;h=f599a1994c884a2674cf2cd821b65bd603cb1964;p=thirdparty%2Fsqlite.git Enable the disabled asserts added by (5629). Add extra tests to thread003.test. And the required modifications to pcache.c. (CVS 5631) FossilOrigin-Name: 473c09fac22ed2f56ea86150a60b9f0f2263c889 --- diff --git a/manifest b/manifest index db5ca1a7dd..6f2a4be59e 100644 --- a/manifest +++ b/manifest @@ -1,5 +1,5 @@ -C Fix\sa\sthreads/mutex\sproblem\sin\spcache.c.\s(CVS\s5630) -D 2008-08-28T08:31:48 +C Enable\sthe\sdisabled\sasserts\sadded\sby\s(5629).\sAdd\sextra\stests\sto\sthread003.test.\sAnd\sthe\srequired\smodifications\sto\spcache.c.\s(CVS\s5631) +D 2008-08-28T10:21:17 F Makefile.arm-wince-mingw32ce-gcc fcd5e9cd67fe88836360bb4f9ef4cb7f8e2fb5a0 F Makefile.in 689e14735f862a5553bceef206d8c13e29504e44 F Makefile.linux-gcc d53183f4aa6a9192d249731c90dbdffbd2c68654 @@ -137,7 +137,7 @@ F src/os_win.c aefe9ee26430678a19a058a874e4e2bd91398142 F src/pager.c 032d11049af4ec49bdbaa3584e7ce9887098b66a F src/pager.h 914103bb62dbcc3d8e9f14baec812d027264d457 F src/parse.y d0f76d2cb8d6883d5600dc20beb961a6022b94b8 -F src/pcache.c 8a2d92fb12ede40cfc8532f062763f353ba2868a +F src/pcache.c 23dba1a9f262946c931e3f122bf3ebfe8a6f3013 F src/pcache.h bd373ee3e4db310d6bbe7fa6d8d971de9678edd8 F src/pragma.c f5b271b090af7fcedd308d7c5807a5503f7a853d F src/prepare.c c197041e0c4770672cda75e6bfe10242f885e510 @@ -503,7 +503,7 @@ F test/temptable.test 19b851b9e3e64d91e9867619b2a3f5fffee6e125 F test/tester.tcl 12fd8394caeb71f7d961707da8668756389bc9d3 F test/thread001.test 3fb08080e1fe84d1bb7ec7bbc9e13743a77e5bc5 F test/thread002.test ed9b800460df01e3cf9428ee11dc4e3f04b9b896 -F test/thread003.test 6e612660f31c49f70bbe2e6c78af1eed54d89968 +F test/thread003.test d78038bf0ec882b61bd5d05c4e77affb23f5033f F test/thread1.test 776c9e459b75ba905193b351926ac4019b049f35 F test/thread2.test 6d7b30102d600f51b4055ee3a5a19228799049fb F test/thread_common.tcl 8a9d7a4500dfdbbd36679c977831b62c130b76b1 @@ -625,7 +625,7 @@ F tool/speedtest16.c c8a9c793df96db7e4933f0852abb7a03d48f2e81 F tool/speedtest2.tcl ee2149167303ba8e95af97873c575c3e0fab58ff F tool/speedtest8.c 1dbced29de5f59ba2ebf877edcadf171540374d1 F tool/speedtest8inst1.c 293327bc76823f473684d589a8160bde1f52c14e -P da1777259f53c2e20c7ced06bf6f2a550f0ea0fc -R 825acac92c02335d51391b9bead07be1 +P 1928f15b78eee0fbf0a8ecdbbdd38dbbde2942b8 +R 166d531ec6ddd69fe2db8781062339d3 U danielk1977 -Z ccfb17e90f1b78b85072c08441535cfa +Z 853ee09750f4e2c171d372d7dd09456a diff --git a/manifest.uuid b/manifest.uuid index 88121b9c3d..80d019cb75 100644 --- a/manifest.uuid +++ b/manifest.uuid @@ -1 +1 @@ -1928f15b78eee0fbf0a8ecdbbdd38dbbde2942b8 \ No newline at end of file +473c09fac22ed2f56ea86150a60b9f0f2263c889 \ No newline at end of file diff --git a/src/pcache.c b/src/pcache.c index 6a9c8b48ba..fce2c862aa 100644 --- a/src/pcache.c +++ b/src/pcache.c @@ -11,7 +11,7 @@ ************************************************************************* ** This file implements that page cache. ** -** @(#) $Id: pcache.c,v 1.20 2008/08/28 08:31:48 danielk1977 Exp $ +** @(#) $Id: pcache.c,v 1.21 2008/08/28 10:21:17 danielk1977 Exp $ */ #include "sqliteInt.h" @@ -173,7 +173,6 @@ static int pcacheCheckSynced(PCache *pCache){ assert( p->nRef || (p->flags&PGHDR_NEED_SYNC) ); } return (p==0 || p->nRef || (p->flags&PGHDR_NEED_SYNC)==0); - return 1; } #endif /* !NDEBUG && SQLITE_ENABLE_EXPENSIVE_ASSERT */ @@ -183,7 +182,7 @@ static int pcacheCheckSynced(PCache *pCache){ ** Remove a page from its hash table (PCache.apHash[]). */ static void pcacheRemoveFromHash(PgHdr *pPage){ - /* assert( pcacheMutexHeld() ); *** FIXME ****/ + assert( pcacheMutexHeld() ); if( pPage->pPrevHash ){ pPage->pPrevHash->pNextHash = pPage->pNextHash; }else{ @@ -207,7 +206,7 @@ static void pcacheRemoveFromHash(PgHdr *pPage){ static void pcacheAddToHash(PgHdr *pPage){ PCache *pCache = pPage->pCache; u32 h = pPage->pgno % pCache->nHash; - /* assert( pcacheMutexHeld() ); *** FIXME *****/ + assert( pcacheMutexHeld() ); pPage->pNextHash = pCache->apHash[h]; pPage->pPrevHash = 0; if( pCache->apHash[h] ){ @@ -225,13 +224,15 @@ static void pcacheAddToHash(PgHdr *pPage){ static int pcacheResizeHash(PCache *pCache, int nHash){ PgHdr *p; PgHdr **pNew; - /* assert( pcacheMutexHeld() ); **** FIXME *****/ + assert( pcacheMutexHeld() ); #ifdef SQLITE_MALLOC_SOFT_LIMIT if( nHash*sizeof(PgHdr*)>SQLITE_MALLOC_SOFT_LIMIT ){ nHash = SQLITE_MALLOC_SOFT_LIMIT/sizeof(PgHdr *); } #endif - pNew = (PgHdr **)sqlite3_malloc(sizeof(PgHdr*)*nHash); + pcacheExitMutex(); + pNew = (PgHdr **)sqlite3Malloc(sizeof(PgHdr*)*nHash); + pcacheEnterMutex(); if( !pNew ){ return SQLITE_NOMEM; } @@ -257,7 +258,7 @@ static int pcacheResizeHash(PCache *pCache, int nHash){ static void pcacheRemoveFromList(PgHdr **ppHead, PgHdr *pPage){ int isDirtyList = (ppHead==&pPage->pCache->pDirty); assert( ppHead==&pPage->pCache->pClean || ppHead==&pPage->pCache->pDirty ); - /* assert( pcacheMutexHeld() || ppHead!=&pPage->pCache->pClean ); *** FIXME */ + assert( pcacheMutexHeld() || ppHead!=&pPage->pCache->pClean ); if( pPage->pPrev ){ pPage->pPrev->pNext = pPage->pNext; @@ -543,10 +544,9 @@ static int pcacheRecycleOrAlloc(PCache *pCache, PgHdr **ppPage){ int szExtra = pCache->szExtra; assert( pcache.isInit ); - assert( sqlite3_mutex_notheld(pcache.mutex) ); + assert( sqlite3_mutex_held(pcache.mutex) ); *ppPage = 0; - pcacheEnterMutex(); /* If we have reached the limit for pinned/dirty pages, and there is at ** least one dirty page, invoke the xStress callback to cause a page to @@ -594,7 +594,6 @@ static int pcacheRecycleOrAlloc(PCache *pCache, PgHdr **ppPage){ p = pcachePageAlloc(pCache); } - pcacheExitMutex(); *ppPage = p; return (p?SQLITE_OK:SQLITE_NOMEM); } @@ -676,16 +675,19 @@ int sqlite3PcacheFetch( int createFlag, /* If true, create page if it does not exist already */ PgHdr **ppPage /* Write the page here */ ){ - PgHdr *pPage; + int rc = SQLITE_OK; + PgHdr *pPage = 0; + assert( pcache.isInit ); assert( pCache!=0 ); assert( pgno>0 ); expensive_assert( pCache->nPinned==pcachePinnedCount(pCache) ); + pcacheEnterMutex(); + /* Search the hash table for the requested page. Exit early if it is found. */ if( pCache->apHash ){ u32 h = pgno % pCache->nHash; - pcacheEnterMutex(); for(pPage=pCache->apHash[h]; pPage; pPage=pPage->pNextHash){ if( pPage->pgno==pgno ){ if( pPage->nRef==0 ){ @@ -696,44 +698,38 @@ int sqlite3PcacheFetch( pCache->nRef++; } pPage->nRef++; - *ppPage = pPage; - pcacheExitMutex(); - return SQLITE_OK; + break; } } - pcacheExitMutex(); } - if( createFlag ){ - int rc = SQLITE_OK; + if( !pPage && createFlag ){ if( pCache->nHash<=pCache->nPage ){ rc = pcacheResizeHash(pCache, pCache->nHash<256 ? 256 : pCache->nHash*2); - if( rc!=SQLITE_OK ){ - return rc; - } } - - rc = pcacheRecycleOrAlloc(pCache, ppPage); - if( rc!=SQLITE_OK ){ - return rc; + if( rc==SQLITE_OK ){ + rc = pcacheRecycleOrAlloc(pCache, &pPage); + } + if( rc==SQLITE_OK ){ + pPage->pPager = 0; + pPage->flags = 0; + pPage->pDirty = 0; + pPage->pgno = pgno; + pPage->pCache = pCache; + pPage->nRef = 1; + pCache->nRef++; + pCache->nPinned++; + pcacheAddToList(&pCache->pClean, pPage); + pcacheAddToHash(pPage); } - pPage = *ppPage; - pPage->pPager = 0; - pPage->flags = 0; - pPage->pDirty = 0; - pPage->pgno = pgno; - pPage->pCache = pCache; - pPage->nRef = 1; - pCache->nRef++; - pCache->nPinned++; - pcacheAddToList(&pCache->pClean, pPage); - pcacheAddToHash(pPage); - }else{ - *ppPage = 0; } + pcacheExitMutex(); + + *ppPage = pPage; expensive_assert( pCache->nPinned==pcachePinnedCount(pCache) ); - return SQLITE_OK; + assert( pPage || !createFlag || rc!=SQLITE_OK ); + return rc; } /* @@ -779,9 +775,9 @@ void sqlite3PcacheDrop(PgHdr *p){ pCache = p->pCache; pCache->nRef--; pCache->nPinned--; + pcacheEnterMutex(); pcacheRemoveFromList(&pCache->pClean, p); pcacheRemoveFromHash(p); - pcacheEnterMutex(); pcachePageFree(p); pcacheExitMutex(); } @@ -797,23 +793,18 @@ void sqlite3PcacheMakeDirty(PgHdr *p){ assert( (p->flags & PGHDR_DIRTY)==0 ); assert( p->nRef>0 ); pCache = p->pCache; + pcacheEnterMutex(); pcacheRemoveFromList(&pCache->pClean, p); pcacheAddToList(&pCache->pDirty, p); + pcacheExitMutex(); p->flags |= PGHDR_DIRTY; } -/* -** Make sure the page is marked as clean. If it isn't clean already, -** make it so. -*/ -void sqlite3PcacheMakeClean(PgHdr *p){ - PCache *pCache; - if( (p->flags & PGHDR_DIRTY)==0 ) return; +void pcacheMakeClean(PgHdr *p){ + PCache *pCache = p->pCache; assert( p->apSave[0]==0 && p->apSave[1]==0 ); assert( p->flags & PGHDR_DIRTY ); - pCache = p->pCache; pcacheRemoveFromList(&pCache->pDirty, p); - pcacheEnterMutex(); pcacheAddToList(&pCache->pClean, p); p->flags &= ~PGHDR_DIRTY; if( p->nRef==0 ){ @@ -821,7 +812,18 @@ void sqlite3PcacheMakeClean(PgHdr *p){ pCache->nPinned--; } expensive_assert( pCache->nPinned==pcachePinnedCount(pCache) ); - pcacheExitMutex(); +} + +/* +** Make sure the page is marked as clean. If it isn't clean already, +** make it so. +*/ +void sqlite3PcacheMakeClean(PgHdr *p){ + if( (p->flags & PGHDR_DIRTY) ){ + pcacheEnterMutex(); + pcacheMakeClean(p); + pcacheExitMutex(); + } } /* @@ -852,19 +854,21 @@ void sqlite3PcacheCleanAll(PCache *pCache){ */ void sqlite3PcacheMove(PgHdr *p, Pgno newPgno){ assert( p->nRef>0 ); + pcacheEnterMutex(); pcacheRemoveFromHash(p); p->pgno = newPgno; if( newPgno==0 ){ p->flags |= PGHDR_REUSE_UNLIKELY; - pcacheEnterMutex(); pcacheFree(p->apSave[0]); pcacheFree(p->apSave[1]); - pcacheExitMutex(); p->apSave[0] = 0; p->apSave[1] = 0; - sqlite3PcacheMakeClean(p); + if( (p->flags & PGHDR_DIRTY) ){ + pcacheMakeClean(p); + } } pcacheAddToHash(p); + pcacheExitMutex(); } /* diff --git a/test/thread003.test b/test/thread003.test index 22882b1c41..8e3fbd312c 100644 --- a/test/thread003.test +++ b/test/thread003.test @@ -12,7 +12,7 @@ # This file contains tests that attempt to break the pcache module # by bombarding it with simultaneous requests from multiple threads. # -# $Id: thread003.test,v 1.1 2008/08/28 08:31:48 danielk1977 Exp $ +# $Id: thread003.test,v 1.2 2008/08/28 10:21:17 danielk1977 Exp $ set testdir [file dirname $argv0] @@ -110,6 +110,84 @@ do_test thread003.2 { expr 0 } {0} +# This test is the same as the test above, except that each thread also +# writes to the database. This causes pages to be moved back and forth +# between the caches internal dirty and clean lists, which is another +# opportunity for a thread-related bug to present itself. +# +set nSecond 30 +puts "Starting thread003.3 (should run for ~$nSecond seconds)" +do_test thread003.3 { + foreach zFile {test.db test2.db} { + set SCRIPT [format { + set iStart [clock seconds] + set iEnd [expr {[clock seconds] + %d}] + set ::DB [sqlthread open %s] + + # Set the cache size to 15 pages per cache. 30 available globally. + execsql { PRAGMA cache_size = 15 } + + while {[clock seconds] < $iEnd} { + set iQuery [expr {int(rand()*5000)}] + execsql "SELECT * FROM t1 WHERE a = $iQuery" + execsql "UPDATE t1 SET b = randomblob(200) + WHERE a < $iQuery AND a > $iQuery + 20 + " + } + + sqlite3_close $::DB + expr 1 + } $nSecond $zFile] + + unset -nocomplain finished($zFile) + thread_spawn finished($zFile) $thread_procs $SCRIPT + } + foreach zFile {test.db test2.db} { + if {![info exists finished($zFile)]} { + vwait finished($zFile) + } + } + expr 0 +} {0} + +# In this test case, one thread is continually querying the database. +# The other thread does not have a database connection, but calls +# sqlite3_release_memory() over and over again. +# +set nSecond 30 +puts "Starting thread003.3 (should run for ~$nSecond seconds)" +do_test thread003.4 { + thread_spawn finished(1) $thread_procs [format { + set iEnd [expr {[clock seconds] + %d}] + set ::DB [sqlthread open test.db] + + # Set the cache size to 15 pages per cache. 30 available globally. + execsql { PRAGMA cache_size = 15 } + + while {[clock seconds] < $iEnd} { + set iQuery [expr {int(rand()*5000)}] + execsql "SELECT * FROM t1 WHERE a = $iQuery" + } + + sqlite3_close $::DB + expr 1 + } $nSecond] + thread_spawn finished(2) [format { + set iEnd [expr {[clock seconds] + %d}] + + while {[clock seconds] < $iEnd} { + sqlite3_release_memory 1000 + } + } $nSecond] + + foreach ii {1 2} { + if {![info exists finished($ii)]} { + vwait finished($ii) + } + } + expr 0 +} {0} + finish_test