| /* |
| ** 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 */ |
| struct SQLiteThread { |
| pthread_t tid; /* Thread ID */ |
| int done; /* Set to true when thread finishes */ |
| void *pOut; /* Result returned by the thread */ |
| void *(*xTask)(void*); /* The thread routine */ |
| void *pIn; /* Argument to the thread */ |
| }; |
| |
| /* Create a new thread */ |
| int sqlite3ThreadCreate( |
| SQLiteThread **ppThread, /* OUT: Write the thread object here */ |
| void *(*xTask)(void*), /* Routine to run in a separate thread */ |
| void *pIn /* Argument passed into xTask() */ |
| ){ |
| SQLiteThread *p; |
| int rc; |
| |
| assert( ppThread!=0 ); |
| 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_BKPT; |
| 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; |
| return SQLITE_OK; |
| } |
| |
| /* Get the results of the thread */ |
| int sqlite3ThreadJoin(SQLiteThread *p, void **ppOut){ |
| int rc; |
| |
| assert( ppOut!=0 ); |
| if( NEVER(p==0) ) return SQLITE_NOMEM_BKPT; |
| if( p->done ){ |
| *ppOut = p->pOut; |
| rc = SQLITE_OK; |
| }else{ |
| rc = pthread_join(p->tid, ppOut) ? SQLITE_ERROR : SQLITE_OK; |
| } |
| sqlite3_free(p); |
| return rc; |
| } |
| |
| #endif /* SQLITE_OS_UNIX && defined(SQLITE_MUTEX_PTHREADS) */ |
| /******************************** End Unix Pthreads *************************/ |
| |
| |
| /********************************* Win32 Threads ****************************/ |
| #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 */ |
| void *pResult; /* Result of xTask */ |
| }; |
| |
| /* Thread procedure Win32 compatibility shim */ |
| static unsigned __stdcall sqlite3ThreadProc( |
| void *pArg /* IN: Pointer to the SQLiteThread structure */ |
| ){ |
| SQLiteThread *p = (SQLiteThread *)pArg; |
| |
| assert( p!=0 ); |
| #if 0 |
| /* |
| ** This assert appears to trigger spuriously on certain |
| ** versions of Windows, possibly due to _beginthreadex() |
| ** and/or CreateThread() not fully setting their thread |
| ** ID parameter before starting the thread. |
| */ |
| assert( p->id==GetCurrentThreadId() ); |
| #endif |
| assert( p->xTask!=0 ); |
| p->pResult = p->xTask(p->pIn); |
| |
| _endthreadex(0); |
| return 0; /* NOT REACHED */ |
| } |
| |
| /* Create a new thread */ |
| int sqlite3ThreadCreate( |
| SQLiteThread **ppThread, /* OUT: Write the thread object here */ |
| 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_BKPT; |
| /* 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_BKPT; |
| if( p->xTask==0 ){ |
| /* 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_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 |
| */ |
| |
| /* A running thread */ |
| struct SQLiteThread { |
| void *(*xTask)(void*); /* The routine to run as a thread */ |
| void *pIn; /* Argument to xTask */ |
| void *pResult; /* Result of xTask */ |
| }; |
| |
| /* Create a new thread */ |
| int sqlite3ThreadCreate( |
| SQLiteThread **ppThread, /* OUT: Write the thread object here */ |
| 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_BKPT; |
| if( (SQLITE_PTR_TO_INT(p)/17)&1 ){ |
| p->xTask = xTask; |
| p->pIn = pIn; |
| }else{ |
| p->xTask = 0; |
| p->pResult = xTask(pIn); |
| } |
| *ppThread = p; |
| return SQLITE_OK; |
| } |
| |
| /* Get the results of the thread */ |
| int sqlite3ThreadJoin(SQLiteThread *p, void **ppOut){ |
| |
| assert( ppOut!=0 ); |
| if( NEVER(p==0) ) return SQLITE_NOMEM_BKPT; |
| if( p->xTask ){ |
| *ppOut = p->xTask(p->pIn); |
| }else{ |
| *ppOut = p->pResult; |
| } |
| sqlite3_free(p); |
| |
| #if defined(SQLITE_TEST) |
| { |
| void *pTstAlloc = sqlite3Malloc(10); |
| if (!pTstAlloc) return SQLITE_NOMEM_BKPT; |
| sqlite3_free(pTstAlloc); |
| } |
| #endif |
| |
| return SQLITE_OK; |
| } |
| |
| #endif /* !defined(SQLITE_THREADS_IMPLEMENTED) */ |
| /****************************** End Single-Threaded *************************/ |
| #endif /* SQLITE_MAX_WORKER_THREADS>0 */ |