Add //third_party/sqlite to dirs_to_snapshot, remove net_sql.patch

third_party/sqlite/sqlite-src-3070603/tool/speedtest8.c

+/*
+** Performance test for SQLite.
+**
+** This program reads ASCII text from a file named on the command-line
+** and submits that text  to SQLite for evaluation.  A new database
+** is created at the beginning of the program.  All statements are
+** timed using the high-resolution timer built into Intel-class processors.
+**
+** To compile this program, first compile the SQLite library separately
+** will full optimizations.  For example:
+**
+**     gcc -c -O6 -DSQLITE_THREADSAFE=0 sqlite3.c
+**
+** Then link against this program.  But to do optimize this program
+** because that defeats the hi-res timer.
+**
+**     gcc speedtest8.c sqlite3.o -ldl -I../src
+**
+** Then run this program with a single argument which is the name of
+** a file containing SQL script that you want to test:
+**
+**     ./a.out test.db  test.sql
+*/
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <time.h>
+
+#if defined(_MSC_VER)
+#include <windows.h>
+#else
+#include <unistd.h>
+#include <sys/times.h>
+#include <sched.h>
+#endif
+
+#include "sqlite3.h"
+
+/* 
+** hwtime.h contains inline assembler code for implementing 
+** high-performance timing routines.
+*/
+#include "hwtime.h"
+
+/*
+** Timers
+*/
+static sqlite_uint64 prepTime = 0;
+static sqlite_uint64 runTime = 0;
+static sqlite_uint64 finalizeTime = 0;
+
+/*
+** Prepare and run a single statement of SQL.
+*/
+static void prepareAndRun(sqlite3 *db, const char *zSql, int bQuiet){
+  sqlite3_stmt *pStmt;
+  const char *stmtTail;
+  sqlite_uint64 iStart, iElapse;
+  int rc;
+  
+  if (!bQuiet){
+    printf("***************************************************************\n");
+  }
+  if (!bQuiet) printf("SQL statement: [%s]\n", zSql);
+  iStart = sqlite3Hwtime();
+  rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, &stmtTail);
+  iElapse = sqlite3Hwtime() - iStart;
+  prepTime += iElapse;
+  if (!bQuiet){
+    printf("sqlite3_prepare_v2() returns %d in %llu cycles\n", rc, iElapse);
+  }
+  if( rc==SQLITE_OK ){
+    int nRow = 0;
+    iStart = sqlite3Hwtime();
+    while( (rc=sqlite3_step(pStmt))==SQLITE_ROW ){ nRow++; }
+    iElapse = sqlite3Hwtime() - iStart;
+    runTime += iElapse;
+    if (!bQuiet){
+      printf("sqlite3_step() returns %d after %d rows in %llu cycles\n",
+             rc, nRow, iElapse);
+    }
+    iStart = sqlite3Hwtime();
+    rc = sqlite3_finalize(pStmt);
+    iElapse = sqlite3Hwtime() - iStart;
+    finalizeTime += iElapse;
+    if (!bQuiet){
+      printf("sqlite3_finalize() returns %d in %llu cycles\n", rc, iElapse);
+    }
+  }
+}
+
+int main(int argc, char **argv){
+  sqlite3 *db;
+  int rc;
+  int nSql;
+  char *zSql;
+  int i, j;
+  FILE *in;
+  sqlite_uint64 iStart, iElapse;
+  sqlite_uint64 iSetup = 0;
+  int nStmt = 0;
+  int nByte = 0;
+  const char *zArgv0 = argv[0];
+  int bQuiet = 0;
+#if !defined(_MSC_VER)
+  struct tms tmsStart, tmsEnd;
+  clock_t clkStart, clkEnd;
+#endif
+
+#ifdef HAVE_OSINST
+  extern sqlite3_vfs *sqlite3_instvfs_binarylog(char *, char *, char *);
+  extern void sqlite3_instvfs_destroy(sqlite3_vfs *);
+  sqlite3_vfs *pVfs = 0;
+#endif
+
+  while (argc>3)
+  {
+#ifdef HAVE_OSINST
+    if( argc>4 && (strcmp(argv[1], "-log")==0) ){
+     pVfs = sqlite3_instvfs_binarylog("oslog", 0, argv[2]);
+     sqlite3_vfs_register(pVfs, 1);
+     argv += 2;
+     argc -= 2;
+     continue;
+    }
+#endif
+
+    /*
+    ** Increasing the priority slightly above normal can help with
+    ** repeatability of testing.  Note that with Cygwin, -5 equates
+    ** to "High", +5 equates to "Low", and anything in between
+    ** equates to "Normal".
+    */
+    if( argc>4 && (strcmp(argv[1], "-priority")==0) ){
+#if defined(_MSC_VER)
+      int new_priority = atoi(argv[2]);
+      if(!SetPriorityClass(GetCurrentProcess(), 
+        (new_priority<=-5) ? HIGH_PRIORITY_CLASS : 
+        (new_priority<=0)  ? ABOVE_NORMAL_PRIORITY_CLASS : 
+        (new_priority==0)  ? NORMAL_PRIORITY_CLASS : 
+        (new_priority<5)   ? BELOW_NORMAL_PRIORITY_CLASS : 
+        IDLE_PRIORITY_CLASS)){
+        printf ("error setting priority\n"); 
+        exit(2); 
+      }
+#else
+      struct sched_param myParam;
+      sched_getparam(0, &myParam);
+      printf ("Current process priority is %d.\n", (int)myParam.sched_priority); 
+      myParam.sched_priority = atoi(argv[2]);
+      printf ("Setting process priority to %d.\n", (int)myParam.sched_priority); 
+      if (sched_setparam (0, &myParam) != 0){
+        printf ("error setting priority\n"); 
+        exit(2); 
+      }
+#endif
+      argv += 2;
+      argc -= 2;
+      continue;
+    }
+
+    if( argc>3 && strcmp(argv[1], "-quiet")==0 ){
+     bQuiet = -1;
+     argv++;
+     argc--;
+     continue;
+    }
+
+    break;
+  }
+
+  if( argc!=3 ){
+   fprintf(stderr, "Usage: %s [options] FILENAME SQL-SCRIPT\n"
+              "Runs SQL-SCRIPT against a UTF8 database\n"
+              "\toptions:\n"
+#ifdef HAVE_OSINST
+              "\t-log <log>\n"
+#endif
+              "\t-priority <value> : set priority of task\n"
+              "\t-quiet : only display summary results\n",
+              zArgv0);
+   exit(1);
+  }
+
+  in = fopen(argv[2], "r");
+  fseek(in, 0L, SEEK_END);
+  nSql = ftell(in);
+  zSql = malloc( nSql+1 );
+  fseek(in, 0L, SEEK_SET);
+  nSql = fread(zSql, 1, nSql, in);
+  zSql[nSql] = 0;
+
+  printf("SQLite version: %d\n", sqlite3_libversion_number());
+  unlink(argv[1]);
+#if !defined(_MSC_VER)
+  clkStart = times(&tmsStart);
+#endif
+  iStart = sqlite3Hwtime();
+  rc = sqlite3_open(argv[1], &db);
+  iElapse = sqlite3Hwtime() - iStart;
+  iSetup = iElapse;
+  if (!bQuiet) printf("sqlite3_open() returns %d in %llu cycles\n", rc, iElapse);
+  for(i=j=0; j<nSql; j++){
+    if( zSql[j]==';' ){
+      int isComplete;
+      char c = zSql[j+1];
+      zSql[j+1] = 0;
+      isComplete = sqlite3_complete(&zSql[i]);
+      zSql[j+1] = c;
+      if( isComplete ){
+        zSql[j] = 0;
+        while( i<j && isspace(zSql[i]) ){ i++; }
+        if( i<j ){
+          int n = j - i;
+          if( n>=6 && memcmp(&zSql[i], ".crash",6)==0 ) exit(1);
+          nStmt++;
+          nByte += n;
+          prepareAndRun(db, &zSql[i], bQuiet);
+        }
+        zSql[j] = ';';
+        i = j+1;
+      }
+    }
+  }
+  iStart = sqlite3Hwtime();
+  sqlite3_close(db);
+  iElapse = sqlite3Hwtime() - iStart;
+#if !defined(_MSC_VER)
+  clkEnd = times(&tmsEnd);
+#endif
+  iSetup += iElapse;
+  if (!bQuiet) printf("sqlite3_close() returns in %llu cycles\n", iElapse);
+
+  printf("\n");
+  printf("Statements run:        %15d stmts\n", nStmt);
+  printf("Bytes of SQL text:     %15d bytes\n", nByte);
+  printf("Total prepare time:    %15llu cycles\n", prepTime);
+  printf("Total run time:        %15llu cycles\n", runTime);
+  printf("Total finalize time:   %15llu cycles\n", finalizeTime);
+  printf("Open/Close time:       %15llu cycles\n", iSetup);
+  printf("Total time:            %15llu cycles\n",
+      prepTime + runTime + finalizeTime + iSetup);
+
+#if !defined(_MSC_VER)
+  printf("\n");
+  printf("Total user CPU time:   %15.3g secs\n", (tmsEnd.tms_utime - tmsStart.tms_utime)/(double)CLOCKS_PER_SEC );
+  printf("Total system CPU time: %15.3g secs\n", (tmsEnd.tms_stime - tmsStart.tms_stime)/(double)CLOCKS_PER_SEC );
+  printf("Total real time:       %15.3g secs\n", (clkEnd -clkStart)/(double)CLOCKS_PER_SEC );
+#endif
+
+#ifdef HAVE_OSINST
+  if( pVfs ){
+    sqlite3_instvfs_destroy(pVfs);
+    printf("vfs log written to %s\n", argv[0]);
+  }
+#endif
+
+  return 0;
+}