[sql] Import reference version of SQLite 3.10.2.

third_party/sqlite/sqlite-src-3100200/src/threads.c

 /*
 ** 2012 July 21
 **
 ** 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.
 **
 ******************************************************************************
 **
 ** This file presents a simple cross-platform threading interface for
 ** use internally by SQLite.
 **
 ** A "thread" can be created using sqlite3ThreadCreate().  This thread
 ** runs independently of its creator until it is joined using
 ** sqlite3ThreadJoin(), at which point it terminates.
 **
 ** Threads do not have to be real.  It could be that the work of the
 ** "thread" is done by the main thread at either the sqlite3ThreadCreate()
 ** or sqlite3ThreadJoin() call.  This is, in fact, what happens in
 ** single threaded systems.  Nothing in SQLite requires multiple threads.
 ** This interface exists so that applications that want to take advantage
 ** of multiple cores can do so, while also allowing applications to stay
 ** single-threaded if desired.
 */
 #include "sqliteInt.h"
+#if SQLITE_OS_WIN
+#  include "os_win.h"
+#endif
 
 #if SQLITE_MAX_WORKER_THREADS>0
 
 /********************************* Unix Pthreads ****************************/
 #if SQLITE_OS_UNIX && defined(SQLITE_MUTEX_PTHREADS) && SQLITE_THREADSAFE>0
 
 #define SQLITE_THREADS_IMPLEMENTED 1  /* Prevent the single-thread code below */
 #include <pthread.h>
 
 /* A running thread */
@@ skipping 18 matching lines @@
   assert( xTask!=0 );
   /* This routine is never used in single-threaded mode */
   assert( sqlite3GlobalConfig.bCoreMutex!=0 );
 
   *ppThread = 0;
   p = sqlite3Malloc(sizeof(*p));
   if( p==0 ) return SQLITE_NOMEM;
   memset(p, 0, sizeof(*p));
   p->xTask = xTask;
   p->pIn = pIn;
+  /* If the SQLITE_TESTCTRL_FAULT_INSTALL callback is registered to a 
+  ** function that returns SQLITE_ERROR when passed the argument 200, that
+  ** forces worker threads to run sequentially and deterministically 
+  ** for testing purposes. */
   if( sqlite3FaultSim(200) ){
     rc = 1;
   }else{    
     rc = pthread_create(&p->tid, 0, xTask, pIn);
   }
   if( rc ){
     p->done = 1;
     p->pOut = xTask(pIn);
   }
   *ppThread = p;
@@ skipping 14 matching lines @@
   }
   sqlite3_free(p);
   return rc;
 }
 
 #endif /* SQLITE_OS_UNIX && defined(SQLITE_MUTEX_PTHREADS) */
 /******************************** End Unix Pthreads *************************/
 
 
 /********************************* Win32 Threads ****************************/
-#if SQLITE_OS_WIN && !SQLITE_OS_WINCE && !SQLITE_OS_WINRT && SQLITE_THREADSAFE>0
+#if SQLITE_OS_WIN_THREADS
 
 #define SQLITE_THREADS_IMPLEMENTED 1  /* Prevent the single-thread code below */
 #include <process.h>
 
 /* A running thread */
 struct SQLiteThread {
   void *tid;               /* The thread handle */
   unsigned id;             /* The thread identifier */
   void *(*xTask)(void*);   /* The routine to run as a thread */
   void *pIn;               /* Argument to xTask */
@@ skipping 29 matching lines @@
   void *(*xTask)(void*),    /* Routine to run in a separate thread */
   void *pIn                 /* Argument passed into xTask() */
 ){
   SQLiteThread *p;
 
   assert( ppThread!=0 );
   assert( xTask!=0 );
   *ppThread = 0;
   p = sqlite3Malloc(sizeof(*p));
   if( p==0 ) return SQLITE_NOMEM;
-  if( sqlite3GlobalConfig.bCoreMutex==0 ){
+  /* If the SQLITE_TESTCTRL_FAULT_INSTALL callback is registered to a 
+  ** function that returns SQLITE_ERROR when passed the argument 200, that
+  ** forces worker threads to run sequentially and deterministically 
+  ** (via the sqlite3FaultSim() term of the conditional) for testing
+  ** purposes. */
+  if( sqlite3GlobalConfig.bCoreMutex==0 || sqlite3FaultSim(200) ){
     memset(p, 0, sizeof(*p));
   }else{
     p->xTask = xTask;
     p->pIn = pIn;
     p->tid = (void*)_beginthreadex(0, 0, sqlite3ThreadProc, p, 0, &p->id);
     if( p->tid==0 ){
       memset(p, 0, sizeof(*p));
     }
   }
   if( p->xTask==0 ){
     p->id = GetCurrentThreadId();
     p->pResult = xTask(pIn);
   }
   *ppThread = p;
   return SQLITE_OK;
 }
 
 DWORD sqlite3Win32Wait(HANDLE hObject); /* os_win.c */
 
 /* Get the results of the thread */
 int sqlite3ThreadJoin(SQLiteThread *p, void **ppOut){
   DWORD rc;
   BOOL bRc;
 
   assert( ppOut!=0 );
   if( NEVER(p==0) ) return SQLITE_NOMEM;
   if( p->xTask==0 ){
-    assert( p->id==GetCurrentThreadId() );
+    /* assert( p->id==GetCurrentThreadId() ); */
     rc = WAIT_OBJECT_0;
     assert( p->tid==0 );
   }else{
     assert( p->id!=0 && p->id!=GetCurrentThreadId() );
     rc = sqlite3Win32Wait((HANDLE)p->tid);
     assert( rc!=WAIT_IO_COMPLETION );
     bRc = CloseHandle((HANDLE)p->tid);
     assert( bRc );
   }
   if( rc==WAIT_OBJECT_0 ) *ppOut = p->pResult;
   sqlite3_free(p);
   return (rc==WAIT_OBJECT_0) ? SQLITE_OK : SQLITE_ERROR;
 }
 
-#endif /* SQLITE_OS_WIN && !SQLITE_OS_WINCE && !SQLITE_OS_WINRT */
+#endif /* SQLITE_OS_WIN_THREADS */
 /******************************** End Win32 Threads *************************/
 
 
 /********************************* Single-Threaded **************************/
 #ifndef SQLITE_THREADS_IMPLEMENTED
 /*
 ** This implementation does not actually create a new thread.  It does the
 ** work of the thread in the main thread, when either the thread is created
 ** or when it is joined
 */
@@ skipping 48 matching lines @@
     sqlite3_free(pTstAlloc);
   }
 #endif
 
   return SQLITE_OK;
 }
 
 #endif /* !defined(SQLITE_THREADS_IMPLEMENTED) */
 /****************************** End Single-Threaded *************************/
 #endif /* SQLITE_MAX_WORKER_THREADS>0 */