[sql] Import reference version of SQLite 3.8.7.4.

third_party/sqlite/sqlite-src-3080704/src/btmutex.c

 /*
 ** 2007 August 27
 **
 ** The author disclaims copyright to this source code.  In place of
 ** a legal notice, here is a blessing:
 **
 **    May you do good and not evil.
 **    May you find forgiveness for yourself and forgive others.
 **    May you share freely, never taking more than you give.
 **
@@ skipping 20 matching lines @@
 
   sqlite3_mutex_enter(p->pBt->mutex);
   p->pBt->db = p->db;
   p->locked = 1;
 }
 
 /*
 ** Release the BtShared mutex associated with B-Tree handle p and
 ** clear the p->locked boolean.
 */
-static void unlockBtreeMutex(Btree *p){
+static void SQLITE_NOINLINE unlockBtreeMutex(Btree *p){
   BtShared *pBt = p->pBt;
   assert( p->locked==1 );
   assert( sqlite3_mutex_held(pBt->mutex) );
   assert( sqlite3_mutex_held(p->db->mutex) );
   assert( p->db==pBt->db );
 
   sqlite3_mutex_leave(pBt->mutex);
   p->locked = 0;
 }
 
+/* Forward reference */
+static void SQLITE_NOINLINE btreeLockCarefully(Btree *p);
+
 /*
 ** Enter a mutex on the given BTree object.
 **
 ** If the object is not sharable, then no mutex is ever required
 ** and this routine is a no-op.  The underlying mutex is non-recursive.
 ** But we keep a reference count in Btree.wantToLock so the behavior
 ** of this interface is recursive.
 **
 ** To avoid deadlocks, multiple Btrees are locked in the same order
 ** by all database connections.  The p->pNext is a list of other
 ** Btrees belonging to the same database connection as the p Btree
 ** which need to be locked after p.  If we cannot get a lock on
 ** p, then first unlock all of the others on p->pNext, then wait
 ** for the lock to become available on p, then relock all of the
 ** subsequent Btrees that desire a lock.
 */
 void sqlite3BtreeEnter(Btree *p){
-  Btree *pLater;
-
   /* Some basic sanity checking on the Btree.  The list of Btrees
   ** connected by pNext and pPrev should be in sorted order by
   ** Btree.pBt value. All elements of the list should belong to
   ** the same connection. Only shared Btrees are on the list. */
   assert( p->pNext==0 || p->pNext->pBt>p->pBt );
   assert( p->pPrev==0 || p->pPrev->pBt<p->pBt );
   assert( p->pNext==0 || p->pNext->db==p->db );
   assert( p->pPrev==0 || p->pPrev->db==p->db );
   assert( p->sharable || (p->pNext==0 && p->pPrev==0) );
 
   /* Check for locking consistency */
   assert( !p->locked || p->wantToLock>0 );
   assert( p->sharable || p->wantToLock==0 );
 
   /* We should already hold a lock on the database connection */
   assert( sqlite3_mutex_held(p->db->mutex) );
 
   /* Unless the database is sharable and unlocked, then BtShared.db
   ** should already be set correctly. */
   assert( (p->locked==0 && p->sharable) || p->pBt->db==p->db );
 
   if( !p->sharable ) return;
   p->wantToLock++;
   if( p->locked ) return;
+  btreeLockCarefully(p);
+}
+
+/* This is a helper function for sqlite3BtreeLock(). By moving
+** complex, but seldom used logic, out of sqlite3BtreeLock() and
+** into this routine, we avoid unnecessary stack pointer changes
+** and thus help the sqlite3BtreeLock() routine to run much faster
+** in the common case.
+*/
+static void SQLITE_NOINLINE btreeLockCarefully(Btree *p){
+  Btree *pLater;
 
   /* In most cases, we should be able to acquire the lock we
-  ** want without having to go throught the ascending lock
+  ** want without having to go through the ascending lock
   ** procedure that follows.  Just be sure not to block.
   */
   if( sqlite3_mutex_try(p->pBt->mutex)==SQLITE_OK ){
     p->pBt->db = p->db;
     p->locked = 1;
     return;
   }
 
   /* To avoid deadlock, first release all locks with a larger
   ** BtShared address.  Then acquire our lock.  Then reacquire
   ** the other BtShared locks that we used to hold in ascending
   ** order.
   */
   for(pLater=p->pNext; pLater; pLater=pLater->pNext){
     assert( pLater->sharable );
     assert( pLater->pNext==0 || pLater->pNext->pBt>pLater->pBt );
     assert( !pLater->locked || pLater->wantToLock>0 );
     if( pLater->locked ){
       unlockBtreeMutex(pLater);
     }
   }
   lockBtreeMutex(p);
   for(pLater=p->pNext; pLater; pLater=pLater->pNext){
     if( pLater->wantToLock ){
       lockBtreeMutex(pLater);
     }
   }
 }
 
+
 /*
 ** Exit the recursive mutex on a Btree.
 */
 void sqlite3BtreeLeave(Btree *p){
   if( p->sharable ){
     assert( p->wantToLock>0 );
     p->wantToLock--;
     if( p->wantToLock==0 ){
       unlockBtreeMutex(p);
     }
@@ skipping 141 matching lines @@
   int i;
   for(i=0; i<db->nDb; i++){
     Btree *p = db->aDb[i].pBt;
     if( p ){
       p->pBt->db = p->db;
     }
   }
 }
 #endif /* if SQLITE_THREADSAFE */
 #endif /* ifndef SQLITE_OMIT_SHARED_CACHE */