From 7bb481fda9ecb134804b49c2ce77ca28f7eea583 Mon Sep 17 00:00:00 2001 From: Hans-Christoph Steiner Date: Fri, 30 Mar 2012 20:42:12 -0400 Subject: Imported Upstream version 2.0.3 --- test/threadtest1.c | 289 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 289 insertions(+) create mode 100644 test/threadtest1.c (limited to 'test/threadtest1.c') diff --git a/test/threadtest1.c b/test/threadtest1.c new file mode 100644 index 0000000..56fcce3 --- /dev/null +++ b/test/threadtest1.c @@ -0,0 +1,289 @@ +/* +** 2002 January 15 +** +** 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 implements a simple standalone program used to test whether +** or not the SQLite library is threadsafe. +** +** Testing the thread safety of SQLite is difficult because there are very +** few places in the code that are even potentially unsafe, and those +** places execute for very short periods of time. So even if the library +** is compiled with its mutexes disabled, it is likely to work correctly +** in a multi-threaded program most of the time. +** +** This file is NOT part of the standard SQLite library. It is used for +** testing only. +*/ +#include "sqlite.h" +#include +#include +#include +#include +#include +#include + +/* +** Enable for tracing +*/ +static int verbose = 0; + +/* +** Come here to die. +*/ +static void Exit(int rc){ + exit(rc); +} + +extern char *sqlite3_mprintf(const char *zFormat, ...); +extern char *sqlite3_vmprintf(const char *zFormat, va_list); + +/* +** When a lock occurs, yield. +*/ +static int db_is_locked(void *NotUsed, int iCount){ + /* sched_yield(); */ + if( verbose ) printf("BUSY %s #%d\n", (char*)NotUsed, iCount); + usleep(100); + return iCount<25; +} + +/* +** Used to accumulate query results by db_query() +*/ +struct QueryResult { + const char *zFile; /* Filename - used for error reporting */ + int nElem; /* Number of used entries in azElem[] */ + int nAlloc; /* Number of slots allocated for azElem[] */ + char **azElem; /* The result of the query */ +}; + +/* +** The callback function for db_query +*/ +static int db_query_callback( + void *pUser, /* Pointer to the QueryResult structure */ + int nArg, /* Number of columns in this result row */ + char **azArg, /* Text of data in all columns */ + char **NotUsed /* Names of the columns */ +){ + struct QueryResult *pResult = (struct QueryResult*)pUser; + int i; + if( pResult->nElem + nArg >= pResult->nAlloc ){ + if( pResult->nAlloc==0 ){ + pResult->nAlloc = nArg+1; + }else{ + pResult->nAlloc = pResult->nAlloc*2 + nArg + 1; + } + pResult->azElem = realloc( pResult->azElem, pResult->nAlloc*sizeof(char*)); + if( pResult->azElem==0 ){ + fprintf(stdout,"%s: malloc failed\n", pResult->zFile); + return 1; + } + } + if( azArg==0 ) return 0; + for(i=0; iazElem[pResult->nElem++] = + sqlite3_mprintf("%s",azArg[i] ? azArg[i] : ""); + } + return 0; +} + +/* +** Execute a query against the database. NULL values are returned +** as an empty string. The list is terminated by a single NULL pointer. +*/ +char **db_query(sqlite *db, const char *zFile, const char *zFormat, ...){ + char *zSql; + int rc; + char *zErrMsg = 0; + va_list ap; + struct QueryResult sResult; + va_start(ap, zFormat); + zSql = sqlite3_vmprintf(zFormat, ap); + va_end(ap); + memset(&sResult, 0, sizeof(sResult)); + sResult.zFile = zFile; + if( verbose ) printf("QUERY %s: %s\n", zFile, zSql); + rc = sqlite3_exec(db, zSql, db_query_callback, &sResult, &zErrMsg); + if( rc==SQLITE_SCHEMA ){ + if( zErrMsg ) free(zErrMsg); + rc = sqlite3_exec(db, zSql, db_query_callback, &sResult, &zErrMsg); + } + if( verbose ) printf("DONE %s %s\n", zFile, zSql); + if( zErrMsg ){ + fprintf(stdout,"%s: query failed: %s - %s\n", zFile, zSql, zErrMsg); + free(zErrMsg); + free(zSql); + Exit(1); + } + sqlite3_free(zSql); + if( sResult.azElem==0 ){ + db_query_callback(&sResult, 0, 0, 0); + } + sResult.azElem[sResult.nElem] = 0; + return sResult.azElem; +} + +/* +** Execute an SQL statement. +*/ +void db_execute(sqlite *db, const char *zFile, const char *zFormat, ...){ + char *zSql; + int rc; + char *zErrMsg = 0; + va_list ap; + va_start(ap, zFormat); + zSql = sqlite3_vmprintf(zFormat, ap); + va_end(ap); + if( verbose ) printf("EXEC %s: %s\n", zFile, zSql); + do{ + rc = sqlite3_exec(db, zSql, 0, 0, &zErrMsg); + }while( rc==SQLITE_BUSY ); + if( verbose ) printf("DONE %s: %s\n", zFile, zSql); + if( zErrMsg ){ + fprintf(stdout,"%s: command failed: %s - %s\n", zFile, zSql, zErrMsg); + free(zErrMsg); + sqlite3_free(zSql); + Exit(1); + } + sqlite3_free(zSql); +} + +/* +** Free the results of a db_query() call. +*/ +void db_query_free(char **az){ + int i; + for(i=0; az[i]; i++){ + sqlite3_free(az[i]); + } + free(az); +} + +/* +** Check results +*/ +void db_check(const char *zFile, const char *zMsg, char **az, ...){ + va_list ap; + int i; + char *z; + va_start(ap, az); + for(i=0; (z = va_arg(ap, char*))!=0; i++){ + if( az[i]==0 || strcmp(az[i],z)!=0 ){ + fprintf(stdout,"%s: %s: bad result in column %d: %s\n", + zFile, zMsg, i+1, az[i]); + db_query_free(az); + Exit(1); + } + } + va_end(ap); + db_query_free(az); +} + +pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER; +pthread_cond_t sig = PTHREAD_COND_INITIALIZER; +int thread_cnt = 0; + +static void *worker_bee(void *pArg){ + const char *zFilename = (char*)pArg; + char *azErr; + int i, cnt; + int t = atoi(zFilename); + char **az; + sqlite *db; + + pthread_mutex_lock(&lock); + thread_cnt++; + pthread_mutex_unlock(&lock); + printf("%s: START\n", zFilename); + fflush(stdout); + for(cnt=0; cnt<10; cnt++){ + sqlite3_open(&zFilename[2], &db); + if( db==0 ){ + fprintf(stdout,"%s: can't open\n", zFilename); + Exit(1); + } + sqlite3_busy_handler(db, db_is_locked, zFilename); + db_execute(db, zFilename, "CREATE TABLE t%d(a,b,c);", t); + for(i=1; i<=100; i++){ + db_execute(db, zFilename, "INSERT INTO t%d VALUES(%d,%d,%d);", + t, i, i*2, i*i); + } + az = db_query(db, zFilename, "SELECT count(*) FROM t%d", t); + db_check(zFilename, "tX size", az, "100", 0); + az = db_query(db, zFilename, "SELECT avg(b) FROM t%d", t); + db_check(zFilename, "tX avg", az, "101", 0); + db_execute(db, zFilename, "DELETE FROM t%d WHERE a>50", t); + az = db_query(db, zFilename, "SELECT avg(b) FROM t%d", t); + db_check(zFilename, "tX avg2", az, "51", 0); + for(i=1; i<=50; i++){ + char z1[30], z2[30]; + az = db_query(db, zFilename, "SELECT b, c FROM t%d WHERE a=%d", t, i); + sprintf(z1, "%d", i*2); + sprintf(z2, "%d", i*i); + db_check(zFilename, "readback", az, z1, z2, 0); + } + db_execute(db, zFilename, "DROP TABLE t%d;", t); + sqlite3_close(db); + } + printf("%s: END\n", zFilename); + /* unlink(zFilename); */ + fflush(stdout); + pthread_mutex_lock(&lock); + thread_cnt--; + if( thread_cnt<=0 ){ + pthread_cond_signal(&sig); + } + pthread_mutex_unlock(&lock); + return 0; +} + +int main(int argc, char **argv){ + char *zFile; + int i, n; + pthread_t id; + if( argc>2 && strcmp(argv[1], "-v")==0 ){ + verbose = 1; + argc--; + argv++; + } + if( argc<2 || (n=atoi(argv[1]))<1 ) n = 10; + for(i=0; i0 ){ + pthread_cond_wait(&sig, &lock); + } + pthread_mutex_unlock(&lock); + for(i=0; i