Partially fix TestThread4.

	modified:   generator.go
	modified:   internal/sqlite.org/sqlite-src-3190300/test/threadtest1.c
	new file:   internal/sqlite.org/sqlite-src-3190300/test/threadtest4.c
	modified:   internal/threadtest1/threadtest1_linux_amd64.go
	modified:   internal/threadtest4/threadtest4_linux_amd64.go
	modified:   z_linux_test.go

6 files changed, 575 insertions, 17 deletions

diff --git a/generator.go b/generator.go
index 106fe43..e699f47 100644
--- a/generator.go
+++ b/generator.go
@@ -540,7 +540,7 @@ func threadTest1() {
 	unconvert(dst)
 }
 
-func threadTest(n int) {
+func threadTest2() {
 	repo := findRepo(sqliteRepo)
 	if repo == "" {
 		log.Fatalf("repository not found: %v", sqliteRepo)
@@ -549,7 +549,7 @@ func threadTest(n int) {
 
 	sqlitePth := filepath.Join(repo, "sqlite-amalgamation-"+version)
 	pth := filepath.Join(repo, "sqlite-src-"+version, "test")
-	tag := fmt.Sprintf("threadtest%v", n)
+	tag := "threadtest2"
 	test := filepath.Join(pth, tag+".c")
 	_, src := build(
 		defines,
@@ -633,6 +633,50 @@ func threadTest3() {
 	unconvert(dst)
 }
 
+func threadTest4() {
+	repo := findRepo(sqliteRepo)
+	if repo == "" {
+		log.Fatalf("repository not found: %v", sqliteRepo)
+		return
+	}
+
+	sqlitePth := filepath.Join(repo, "sqlite-amalgamation-"+version)
+	tag := "threadtest4"
+	test := filepath.Join("internal", "sqlite.org", "sqlite-src-3190300", "test", "threadtest4.c")
+	_, src := build(
+		defines,
+		[][]string{
+			{filepath.Join(sqlitePth, "sqlite3.c")},
+			{test},
+		},
+		[]string{"bin"},
+		cc.EnableAnonymousStructFields(),
+		cc.IncludePaths([]string{".", sqlitePth, filepath.Join(repo, "sqlite-src-"+version, "src")}),
+	)
+
+	var b bytes.Buffer
+	fmt.Fprintf(&b, prologueTest, tidyComments(header(test)))
+	b.Write(src)
+	b2, err := format.Source(b.Bytes())
+	if err != nil {
+		b2 = b.Bytes()
+	}
+	if err := os.MkdirAll(filepath.Join("internal", tag), 0775); err != nil {
+		log.Fatal(err)
+	}
+
+	if err := os.MkdirAll(filepath.Join("testdata", tag), 0775); err != nil {
+		log.Fatal(err)
+	}
+
+	dst := fmt.Sprintf(filepath.Join("internal", tag, tag+"_%s_%s.go"), runtime.GOOS, runtime.GOARCH)
+	if err := ioutil.WriteFile(dst, b2, 0664); err != nil {
+		log.Fatal(err)
+	}
+
+	unconvert(dst)
+}
+
 func main() {
 	log.SetFlags(log.Lshortfile | log.Lmicroseconds)
 	var err error
@@ -645,7 +689,7 @@ func main() {
 	sqlite()
 	mpTest()
 	threadTest1()
-	threadTest(2)
+	threadTest2()
 	threadTest3()
-	threadTest(4)
+	threadTest4()
 }
diff --git a/internal/sqlite.org/sqlite-src-3190300/test/threadtest1.c b/internal/sqlite.org/sqlite-src-3190300/test/threadtest1.c
index f7e90c5..04be149 100644
--- a/internal/sqlite.org/sqlite-src-3190300/test/threadtest1.c
+++ b/internal/sqlite.org/sqlite-src-3190300/test/threadtest1.c
@@ -51,7 +51,7 @@ 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<20000;
+  return iCount<40000;
 }
 
 /*
diff --git a/internal/sqlite.org/sqlite-src-3190300/test/threadtest4.c b/internal/sqlite.org/sqlite-src-3190300/test/threadtest4.c
new file mode 100644
index 0000000..bdbddd7
--- /dev/null
+++ b/internal/sqlite.org/sqlite-src-3190300/test/threadtest4.c
@@ -0,0 +1,494 @@
+/*
+** 2014-12-11
+**
+** 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 stress the
+** SQLite library when accessing the same set of databases simultaneously
+** from multiple threads in shared-cache mode.
+**
+** This test program runs on unix-like systems only.  It uses pthreads.
+** To compile:
+**
+**     gcc -g -Wall -I. threadtest4.c sqlite3.c -ldl -lpthread
+**
+** To run:
+**
+**     ./a.out 10
+**
+** The argument is the number of threads.  There are also options, such
+** as -wal and -multithread and -serialized.
+**
+** Consider also compiling with clang instead of gcc and adding the
+** -fsanitize=thread option.
+*/
+#include "sqlite3.h"
+#include <pthread.h>
+#include <sched.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <stdarg.h>
+
+/*
+** An instance of the following structure is passed into each worker
+** thread.
+*/
+typedef struct WorkerInfo WorkerInfo;
+struct WorkerInfo {
+  int tid;                    /* Thread ID */
+  int nWorker;                /* Total number of workers */
+  unsigned wkrFlags;          /* Flags */
+  sqlite3 *mainDb;            /* Database connection of the main thread */
+  sqlite3 *db;                /* Database connection of this thread */
+  int nErr;                   /* Number of errors seen by this thread */
+  int nTest;                  /* Number of tests run by this thread */
+  char *zMsg;                 /* Message returned by this thread */
+  pthread_t id;               /* Thread id */
+  pthread_mutex_t *pWrMutex;  /* Hold this mutex while writing */
+};
+
+/*
+** Allowed values for WorkerInfo.wkrFlags
+*/
+#define TT4_SERIALIZED    0x0000001   /* The --serialized option is used */
+#define TT4_WAL           0x0000002   /* WAL mode in use */
+#define TT4_TRACE         0x0000004   /* Trace activity */
+
+
+/*
+** Report an OOM error and die if the argument is NULL
+*/
+static void check_oom(void *x){
+  if( x==0 ){
+    fprintf(stderr, "out of memory\n");
+    exit(1);
+  }
+}
+
+/*
+** Allocate memory.  If the allocation fails, print an error message and
+** kill the process.
+*/
+static void *safe_malloc(int sz){
+  void *x = sqlite3_malloc(sz>0?sz:1);
+  check_oom(x);
+  return x;
+}
+
+/*
+** Print a trace message for a worker
+*/
+static void worker_trace(WorkerInfo *p, const char *zFormat, ...){
+  va_list ap;
+  char *zMsg;
+  if( (p->wkrFlags & TT4_TRACE)==0 ) return;
+  va_start(ap, zFormat);
+  zMsg = sqlite3_vmprintf(zFormat, ap);
+  check_oom(zMsg);
+  va_end(ap);
+  fprintf(stderr, "TRACE(%02d): %s\n", p->tid, zMsg);
+  sqlite3_free(zMsg);
+}
+
+/*
+** Prepare a single SQL query
+*/
+static sqlite3_stmt *prep_sql(sqlite3 *db, const char *zFormat, ...){
+  va_list ap;
+  char *zSql;
+  int rc, i;
+  sqlite3_stmt *pStmt = 0;
+
+  va_start(ap, zFormat);
+  zSql = sqlite3_vmprintf(zFormat, ap);
+  va_end(ap);
+  check_oom(zSql);
+  for (i = 0; i < 1000; i++) {
+	  rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0);
+	  if (rc == SQLITE_OK) {
+		  break;
+	  }
+  }
+  if( rc!=SQLITE_OK ){
+    fprintf(stderr, "SQL error (%d,%d): %s\nWhile preparing: [%s]\n",
+            rc, sqlite3_extended_errcode(db), sqlite3_errmsg(db), zSql);
+    exit(1);
+  }
+  sqlite3_free(zSql);
+  return pStmt;
+}
+
+/*
+** Run a SQL statements.  Panic if unable.
+*/
+static void run_sql(WorkerInfo *p, const char *zFormat, ...){
+  va_list ap;
+  char *zSql;
+  int rc, i;
+  sqlite3_stmt *pStmt = 0;
+  int nRetry = 0;
+
+  va_start(ap, zFormat);
+  zSql = sqlite3_vmprintf(zFormat, ap);
+  va_end(ap);
+  check_oom(zSql);
+  for (i = 0; i < 1000; i++) {
+  	rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
+	if (rc == SQLITE_OK) {
+		break;
+	}
+  }
+  if( rc!=SQLITE_OK ){
+    fprintf(stderr, "SQL error (%d,%d): %s\nWhile preparing: [%s]\n",
+            rc, sqlite3_extended_errcode(p->db), sqlite3_errmsg(p->db), zSql);
+    exit(1);
+  }
+  worker_trace(p, "running [%s]", zSql);
+  while( (rc = sqlite3_step(pStmt))!=SQLITE_DONE ){
+    if( (rc&0xff)==SQLITE_BUSY || (rc&0xff)==SQLITE_LOCKED ){
+      sqlite3_reset(pStmt);
+      nRetry++;
+      if( nRetry<10 ){
+        worker_trace(p, "retry %d for [%s]", nRetry, zSql);
+        sched_yield();
+        continue;
+      }else{
+        fprintf(stderr, "Deadlock in thread %d while running [%s]\n",
+                p->tid, zSql);
+        exit(1);
+      }
+    }
+    if( rc!=SQLITE_ROW ){
+      fprintf(stderr, "SQL error (%d,%d): %s\nWhile running [%s]\n",
+              rc, sqlite3_extended_errcode(p->db), sqlite3_errmsg(p->db), zSql);
+      exit(1);
+    }
+  }
+  sqlite3_free(zSql);
+  sqlite3_finalize(pStmt);
+}
+
+
+/*
+** Open the database connection for WorkerInfo.  The order in which
+** the files are opened is a function of the tid value.
+*/
+static void worker_open_connection(WorkerInfo *p, int iCnt){
+  char *zFile;
+  int x;
+  int rc;
+  static const unsigned char aOrder[6][3] = {
+    { 1, 2, 3},
+    { 1, 3, 2},
+    { 2, 1, 3},
+    { 2, 3, 1},
+    { 3, 1, 2},
+    { 3, 2, 1}
+  };
+  x = (p->tid + iCnt) % 6;
+  zFile = sqlite3_mprintf("tt4-test%d.db", aOrder[x][0]);
+  check_oom(zFile);
+  worker_trace(p, "open %s", zFile);
+  rc = sqlite3_open_v2(zFile, &p->db,
+                       SQLITE_OPEN_READWRITE|SQLITE_OPEN_SHAREDCACHE, 0);
+  if( rc!=SQLITE_OK ){
+    fprintf(stderr, "sqlite_open_v2(%s) failed on thread %d\n",
+            zFile, p->tid);
+    exit(1);
+  }
+  sqlite3_free(zFile);
+  run_sql(p, "PRAGMA read_uncommitted=ON;");
+  sqlite3_busy_timeout(p->db, 10000);
+  run_sql(p, "PRAGMA synchronous=OFF;");
+  run_sql(p, "ATTACH 'tt4-test%d.db' AS aux1", aOrder[x][1]);
+  run_sql(p, "ATTACH 'tt4-test%d.db' AS aux2", aOrder[x][2]);
+}
+
+/*
+** Close the worker database connection
+*/
+static void worker_close_connection(WorkerInfo *p){
+  if( p->db ){
+    worker_trace(p, "close");
+    sqlite3_close(p->db);
+    p->db = 0;
+  }
+}
+
+/*
+** Delete all content in the three databases associated with a
+** single thread.  Make this happen all in a single transaction if
+** inTrans is true, or separately for each database if inTrans is
+** false.
+*/
+static void worker_delete_all_content(WorkerInfo *p, int inTrans){
+  if( inTrans ){
+    pthread_mutex_lock(p->pWrMutex);
+    run_sql(p, "BEGIN");
+    run_sql(p, "DELETE FROM t1 WHERE tid=%d", p->tid);
+    run_sql(p, "DELETE FROM t2 WHERE tid=%d", p->tid);
+    run_sql(p, "DELETE FROM t3 WHERE tid=%d", p->tid);
+    run_sql(p, "COMMIT");
+    pthread_mutex_unlock(p->pWrMutex);
+    p->nTest++;
+  }else{
+    pthread_mutex_lock(p->pWrMutex);
+    run_sql(p, "DELETE FROM t1 WHERE tid=%d", p->tid);
+    pthread_mutex_unlock(p->pWrMutex);
+    p->nTest++;
+    pthread_mutex_lock(p->pWrMutex);
+    run_sql(p, "DELETE FROM t2 WHERE tid=%d", p->tid);
+    pthread_mutex_unlock(p->pWrMutex);
+    p->nTest++;
+    pthread_mutex_lock(p->pWrMutex);
+    run_sql(p, "DELETE FROM t3 WHERE tid=%d", p->tid);
+    pthread_mutex_unlock(p->pWrMutex);
+    p->nTest++;
+  }
+}
+
+/*
+** Create rows mn through mx in table iTab for the given worker
+*/
+static void worker_add_content(WorkerInfo *p, int mn, int mx, int iTab){
+  char *zTabDef;
+  switch( iTab ){
+    case 1:  zTabDef = "t1(tid,sp,a,b,c)";  break;
+    case 2:  zTabDef = "t2(tid,sp,d,e,f)";  break;
+    case 3:  zTabDef = "t3(tid,sp,x,y,z)";  break;
+  }
+  pthread_mutex_lock(p->pWrMutex);
+  run_sql(p, 
+     "WITH RECURSIVE\n"
+     " c(i) AS (VALUES(%d) UNION ALL SELECT i+1 FROM c WHERE i<%d)\n"
+     "INSERT INTO %s SELECT %d, zeroblob(3000), i, printf('%%d',i), i FROM c;",
+     mn, mx, zTabDef, p->tid
+  );
+  pthread_mutex_unlock(p->pWrMutex);
+  p->nTest++;
+}
+
+/*
+** Set an error message on a worker
+*/
+static void worker_error(WorkerInfo *p, const char *zFormat, ...){
+  va_list ap;
+  p->nErr++;
+  sqlite3_free(p->zMsg);
+  va_start(ap, zFormat);
+  p->zMsg = sqlite3_vmprintf(zFormat, ap);
+  va_end(ap);
+}
+
+/*
+** Each thread runs the following function.
+*/
+static void *worker_thread(void *pArg){
+  WorkerInfo *p = (WorkerInfo*)pArg;
+  int iOuter;
+  int i;
+  int rc;
+  sqlite3_stmt *pStmt;
+
+  printf("worker %d startup\n", p->tid);  fflush(stdout);
+  for(iOuter=1; iOuter<=p->nWorker; iOuter++){
+    worker_open_connection(p, iOuter);
+    for(i=0; i<4; i++){
+      worker_add_content(p, i*100+1, (i+1)*100, (p->tid+iOuter)%3 + 1);
+      worker_add_content(p, i*100+1, (i+1)*100, (p->tid+iOuter+1)%3 + 1);
+      worker_add_content(p, i*100+1, (i+1)*100, (p->tid+iOuter+2)%3 + 1);
+    }
+
+    pStmt = prep_sql(p->db, "SELECT count(a) FROM t1 WHERE tid=%d", p->tid);
+    worker_trace(p, "query [%s]", sqlite3_sql(pStmt));
+    rc = sqlite3_step(pStmt);
+    if( rc!=SQLITE_ROW ){
+      worker_error(p, "Failed to step: %s", sqlite3_sql(pStmt));
+    }else if( sqlite3_column_int(pStmt, 0)!=400 ){
+      worker_error(p, "Wrong result: %d", sqlite3_column_int(pStmt,0));
+    }
+    sqlite3_finalize(pStmt);
+    if( p->nErr ) break;
+
+    if( ((iOuter+p->tid)%3)==0 ){
+      sqlite3_db_release_memory(p->db);
+      p->nTest++;
+    }
+
+    pthread_mutex_lock(p->pWrMutex);
+    run_sql(p, "BEGIN;");
+    run_sql(p, "UPDATE t1 SET c=NULL WHERE a=55");
+    run_sql(p, "UPDATE t2 SET f=NULL WHERE d=42");
+    run_sql(p, "UPDATE t3 SET z=NULL WHERE x=31");
+    run_sql(p, "ROLLBACK;");
+    p->nTest++;
+    pthread_mutex_unlock(p->pWrMutex);
+
+
+    if( iOuter==p->tid ){
+      pthread_mutex_lock(p->pWrMutex);
+      run_sql(p, "VACUUM");
+      pthread_mutex_unlock(p->pWrMutex);
+    }
+
+    pStmt = prep_sql(p->db,
+       "SELECT t1.rowid, t2.rowid, t3.rowid"
+       "  FROM t1, t2, t3"
+       " WHERE t1.tid=%d AND t2.tid=%d AND t3.tid=%d"
+       "   AND t1.a<>t2.d AND t2.d<>t3.x"
+       " ORDER BY 1, 2, 3"
+       ,p->tid, p->tid, p->tid);
+    worker_trace(p, "query [%s]", sqlite3_sql(pStmt));
+    for(i=0; i<p->nWorker; i++){
+      rc = sqlite3_step(pStmt);
+      if( rc!=SQLITE_ROW ){
+        worker_error(p, "Failed to step: %s", sqlite3_sql(pStmt));
+        break;
+      }
+      sched_yield();
+    }
+    sqlite3_finalize(pStmt);
+    if( p->nErr ) break;
+
+    worker_delete_all_content(p, (p->tid+iOuter)%2);
+    worker_close_connection(p);
+    p->db = 0;
+  }
+  worker_close_connection(p);
+  printf("worker %d finished\n", p->tid); fflush(stdout);
+  return 0;
+}
+
+int main(int argc, char **argv){
+  int nWorker = 0;         /* Number of worker threads */
+  int i;                   /* Loop counter */
+  WorkerInfo *aInfo;       /* Information for each worker */
+  unsigned wkrFlags = 0;   /* Default worker flags */
+  int nErr = 0;            /* Number of errors */
+  int nTest = 0;           /* Number of tests */
+  int rc;                  /* Return code */
+  sqlite3 *db = 0;         /* Main database connection */
+  pthread_mutex_t wrMutex; /* The write serialization mutex */
+  WorkerInfo infoTop;      /* WorkerInfo for the main thread */
+  WorkerInfo *p;           /* Pointer to infoTop */
+
+  sqlite3_config(SQLITE_CONFIG_MULTITHREAD);
+  for(i=1; i<argc; i++){
+    const char *z = argv[i];
+    if( z[0]=='-' ){
+      if( z[1]=='-' && z[2]!=0 ) z++;
+      if( strcmp(z,"-multithread")==0 ){
+        sqlite3_config(SQLITE_CONFIG_MULTITHREAD);
+        wkrFlags &= ~TT4_SERIALIZED;
+      }else if( strcmp(z,"-serialized")==0 ){
+        sqlite3_config(SQLITE_CONFIG_SERIALIZED);
+        wkrFlags |= TT4_SERIALIZED;
+      }else if( strcmp(z,"-wal")==0 ){
+        wkrFlags |= TT4_WAL;
+      }else if( strcmp(z,"-trace")==0 ){
+        wkrFlags |= TT4_TRACE;
+      }else{
+        fprintf(stderr, "unknown command-line option: %s\n", argv[i]);
+        exit(1);
+      }
+    }else if( z[0]>='1' && z[0]<='9' && nWorker==0 ){
+      nWorker = atoi(z);
+      if( nWorker<2 ){
+        fprintf(stderr, "minimum of 2 threads\n");
+        exit(1);
+      }
+    }else{
+      fprintf(stderr, "extra command-line argument: \"%s\"\n", argv[i]);
+      exit(1);
+    }
+  }
+  if( nWorker==0 ){ 
+    fprintf(stderr,
+       "usage:  %s ?OPTIONS? N\n"
+       "N is the number of threads and must be at least 2.\n"
+       "Options:\n"
+       "  --serialized\n"
+       "  --multithread\n"
+       "  --wal\n"
+       "  --trace\n"
+       ,argv[0]
+    );
+    exit(1);
+  }
+  if( !sqlite3_threadsafe() ){
+    fprintf(stderr, "requires a threadsafe build of SQLite\n");
+    exit(1);
+  }
+  sqlite3_initialize();
+  sqlite3_enable_shared_cache(1);
+  pthread_mutex_init(&wrMutex, 0);
+
+  /* Initialize the test database files */
+  (void)unlink("tt4-test1.db");
+  (void)unlink("tt4-test2.db");
+  (void)unlink("tt4-test3.db");
+  rc = sqlite3_open("tt4-test1.db", &db);
+  if( rc!=SQLITE_OK ){
+    fprintf(stderr, "Unable to open test database: tt4-test2.db\n");
+    exit(1);
+  }
+  memset(&infoTop, 0, sizeof(infoTop));
+  infoTop.db = db;
+  infoTop.wkrFlags = wkrFlags;
+  p = &infoTop;
+  if( wkrFlags & TT4_WAL ){
+    run_sql(p, "PRAGMA journal_mode=WAL");
+  }
+  run_sql(p, "PRAGMA synchronous=OFF");
+  run_sql(p, "CREATE TABLE IF NOT EXISTS t1(tid INTEGER, sp, a, b, c)");
+  run_sql(p, "CREATE INDEX t1tid ON t1(tid)");
+  run_sql(p, "CREATE INDEX t1ab ON t1(a,b)");
+  run_sql(p, "ATTACH 'tt4-test2.db' AS 'test2'");
+  run_sql(p, "CREATE TABLE IF NOT EXISTS test2.t2(tid INTEGER, sp, d, e, f)");
+  run_sql(p, "CREATE INDEX test2.t2tid ON t2(tid)");
+  run_sql(p, "CREATE INDEX test2.t2de ON t2(d,e)");
+  run_sql(p, "ATTACH 'tt4-test3.db' AS 'test3'");
+  run_sql(p, "CREATE TABLE IF NOT EXISTS test3.t3(tid INTEGER, sp, x, y, z)");
+  run_sql(p, "CREATE INDEX test3.t3tid ON t3(tid)");
+  run_sql(p, "CREATE INDEX test3.t3xy ON t3(x,y)");
+  aInfo = safe_malloc( sizeof(*aInfo)*nWorker );
+  memset(aInfo, 0, sizeof(*aInfo)*nWorker);
+  for(i=0; i<nWorker; i++){
+    aInfo[i].tid = i+1;
+    aInfo[i].nWorker = nWorker;
+    aInfo[i].wkrFlags = wkrFlags;
+    aInfo[i].mainDb = db;
+    aInfo[i].pWrMutex = &wrMutex;
+    rc = pthread_create(&aInfo[i].id, 0, worker_thread, &aInfo[i]);
+    if( rc!=0 ){
+      fprintf(stderr, "thread creation failed for thread %d\n", i+1);
+      exit(1);
+    }
+    sched_yield();
+  }
+  for(i=0; i<nWorker; i++){
+    pthread_join(aInfo[i].id, 0);
+    printf("Joined thread %d: %d errors in %d tests",
+           aInfo[i].tid, aInfo[i].nErr, aInfo[i].nTest);
+    if( aInfo[i].zMsg ){
+      printf(": %s\n", aInfo[i].zMsg);
+    }else{
+      printf("\n");
+    }
+    nErr += aInfo[i].nErr;
+    nTest += aInfo[i].nTest;
+    fflush(stdout);
+  }
+  sqlite3_close(db);
+  sqlite3_free(aInfo);
+  printf("Total %d errors in %d tests\n", nErr, nTest);
+  return nErr;
+}
diff --git a/internal/threadtest1/threadtest1_linux_amd64.go b/internal/threadtest1/threadtest1_linux_amd64.go
index c7b2d23..abd6721 100644
--- a/internal/threadtest1/threadtest1_linux_amd64.go
+++ b/internal/threadtest1/threadtest1_linux_amd64.go
@@ -228,7 +228,7 @@ func _db_is_locked(tls *crt.TLS, _NotUsed unsafe.Pointer, _iCount int32) (r0 int
 		crt.Xprintf(tls, str(305), unsafe.Pointer((*int8)(_NotUsed)), _iCount)
 	}
 	crt.Xusleep(tls, uint32(i32(100)))
-	return bool2int(_iCount < i32(20000))
+	return bool2int(_iCount < i32(40000))
 }
 
 // Execute an SQL statement.
diff --git a/internal/threadtest4/threadtest4_linux_amd64.go b/internal/threadtest4/threadtest4_linux_amd64.go
index d8e4f9d..1819620 100644
--- a/internal/threadtest4/threadtest4_linux_amd64.go
+++ b/internal/threadtest4/threadtest4_linux_amd64.go
@@ -257,7 +257,7 @@ _33:
 
 // Run a SQL statements.  Panic if unable.
 func _run_sql(tls *crt.TLS, _p *XWorkerInfo, _zFormat *int8, args ...interface{}) {
-	var _rc, _nRetry int32
+	var _rc, _i, _nRetry int32
 	var _zSql *int8
 	var _pStmt unsafe.Pointer
 	var _ap []interface{}
@@ -267,35 +267,46 @@ func _run_sql(tls *crt.TLS, _p *XWorkerInfo, _zFormat *int8, args ...interface{}
 	_zSql = bin.Xsqlite3_vmprintf(tls, _zFormat, _ap)
 	_ap = nil
 	_check_oom(tls, (unsafe.Pointer)(_zSql))
+	_i = i32(0)
+_0:
+	if _i >= i32(1000) {
+		goto _3
+	}
 	_rc = bin.Xsqlite3_prepare_v2(tls, (*bin.Xsqlite3)(_p.X4), _zSql, i32(-1), &_pStmt, nil)
+	if _rc == i32(0) {
+		goto _3
+	}
+	_i += 1
+	goto _0
+_3:
 	if _rc != i32(0) {
 		crt.Xfprintf(tls, (*crt.XFILE)(Xstderr), str(991), _rc, bin.Xsqlite3_extended_errcode(tls, (*bin.Xsqlite3)(_p.X4)), unsafe.Pointer(bin.Xsqlite3_errmsg(tls, (*bin.Xsqlite3)(_p.X4))), unsafe.Pointer(_zSql))
 		crt.Xexit(tls, i32(1))
 	}
 	_worker_trace(tls, _p, str(1036), unsafe.Pointer(_zSql))
-_1:
+_6:
 	if store1(&_rc, bin.Xsqlite3_step(tls, _pStmt)) == i32(101) {
-		goto _2
+		goto _7
 	}
 	if (_rc&i32(255)) != i32(5) && (_rc&i32(255)) != i32(6) {
-		goto _4
+		goto _9
 	}
 	bin.Xsqlite3_reset(tls, _pStmt)
 	_nRetry += 1
 	if _nRetry < i32(10) {
 		_worker_trace(tls, _p, str(1049), _nRetry, unsafe.Pointer(_zSql))
 		crt.Xsched_yield(tls)
-		goto _1
+		goto _6
 	}
 	crt.Xfprintf(tls, (*crt.XFILE)(Xstderr), str(1067), _p.X0, unsafe.Pointer(_zSql))
 	crt.Xexit(tls, i32(1))
-_4:
+_9:
 	if _rc != i32(100) {
 		crt.Xfprintf(tls, (*crt.XFILE)(Xstderr), str(1109), _rc, bin.Xsqlite3_extended_errcode(tls, (*bin.Xsqlite3)(_p.X4)), unsafe.Pointer(bin.Xsqlite3_errmsg(tls, (*bin.Xsqlite3)(_p.X4))), unsafe.Pointer(_zSql))
 		crt.Xexit(tls, i32(1))
 	}
-	goto _1
-_2:
+	goto _6
+_7:
 	bin.Xsqlite3_free(tls, (unsafe.Pointer)(_zSql))
 	bin.Xsqlite3_finalize(tls, _pStmt)
 }
@@ -486,7 +497,7 @@ _4:
 
 // Prepare a single SQL query
 func _prep_sql(tls *crt.TLS, _db unsafe.Pointer, _zFormat *int8, args ...interface{}) (r0 unsafe.Pointer) {
-	var _rc int32
+	var _rc, _i int32
 	var _zSql *int8
 	var _pStmt unsafe.Pointer
 	var _ap []interface{}
@@ -495,7 +506,18 @@ func _prep_sql(tls *crt.TLS, _db unsafe.Pointer, _zFormat *int8, args ...interfa
 	_zSql = bin.Xsqlite3_vmprintf(tls, _zFormat, _ap)
 	_ap = nil
 	_check_oom(tls, (unsafe.Pointer)(_zSql))
+	_i = i32(0)
+_0:
+	if _i >= i32(1000) {
+		goto _3
+	}
 	_rc = bin.Xsqlite3_prepare_v2(tls, (*bin.Xsqlite3)(_db), _zSql, i32(-1), &_pStmt, nil)
+	if _rc == i32(0) {
+		goto _3
+	}
+	_i += 1
+	goto _0
+_3:
 	if _rc != i32(0) {
 		crt.Xfprintf(tls, (*crt.XFILE)(Xstderr), str(991), _rc, bin.Xsqlite3_extended_errcode(tls, (*bin.Xsqlite3)(_db)), unsafe.Pointer(bin.Xsqlite3_errmsg(tls, (*bin.Xsqlite3)(_db))), unsafe.Pointer(_zSql))
 		crt.Xexit(tls, i32(1))
diff --git a/z_linux_test.go b/z_linux_test.go
index 73d157b..122aeeb 100644
--- a/z_linux_test.go
+++ b/z_linux_test.go
@@ -197,7 +197,6 @@ func TestThread3(t *testing.T) {
 		{"stress2"},
 	} {
 		out, err := exec.Command("./threadtest3", opts...).CombinedOutput()
-		dbg("%v\n%s", opts, out)
 		t.Logf("%v\n%s", opts, out)
 		if err != nil {
 			t.Fatal(err)
@@ -258,7 +257,6 @@ func TestThread4(t *testing.T) {
 		{"--multithread", "-serialized", "-wal"},
 	} {
 		out, err := exec.Command("./threadtest4", append(opts, "5")...).CombinedOutput()
-		dbg("%v\n%s", opts, out)
 		t.Logf("%v\n%s", opts, out)
 		if err != nil {
 			t.Fatal(err)