| OLD | NEW | 
 | (Empty) | 
|    1 /* |  | 
|    2 ** Performance test for SQLite. |  | 
|    3 ** |  | 
|    4 ** This program reads ASCII text from a file named on the command-line. |  | 
|    5 ** It converts each SQL statement into UTF16 and submits it to SQLite |  | 
|    6 ** for evaluation.  A new UTF16 database is created at the beginning of |  | 
|    7 ** the program.  All statements are timed using the high-resolution timer |  | 
|    8 ** built into Intel-class processors. |  | 
|    9 ** |  | 
|   10 ** To compile this program, first compile the SQLite library separately |  | 
|   11 ** will full optimizations.  For example: |  | 
|   12 ** |  | 
|   13 **     gcc -c -O6 -DSQLITE_THREADSAFE=0 sqlite3.c |  | 
|   14 ** |  | 
|   15 ** Then link against this program.  But to do optimize this program |  | 
|   16 ** because that defeats the hi-res timer. |  | 
|   17 ** |  | 
|   18 **     gcc speedtest16.c sqlite3.o -ldl -I../src |  | 
|   19 ** |  | 
|   20 ** Then run this program with a single argument which is the name of |  | 
|   21 ** a file containing SQL script that you want to test: |  | 
|   22 ** |  | 
|   23 **     ./a.out database.db test.sql |  | 
|   24 */ |  | 
|   25 #include <stdio.h> |  | 
|   26 #include <string.h> |  | 
|   27 #include <stdlib.h> |  | 
|   28 #include <ctype.h> |  | 
|   29 #include <unistd.h> |  | 
|   30 #include "sqlite3.h" |  | 
|   31  |  | 
|   32 /*  |  | 
|   33 ** hwtime.h contains inline assembler code for implementing  |  | 
|   34 ** high-performance timing routines. |  | 
|   35 */ |  | 
|   36 #include "hwtime.h" |  | 
|   37  |  | 
|   38 /* |  | 
|   39 ** Convert a zero-terminated ASCII string into a zero-terminated |  | 
|   40 ** UTF-16le string.  Memory to hold the returned string comes  |  | 
|   41 ** from malloc() and should be freed by the caller. |  | 
|   42 */ |  | 
|   43 static void *asciiToUtf16le(const char *z){ |  | 
|   44   int n = strlen(z); |  | 
|   45   char *z16; |  | 
|   46   int i, j; |  | 
|   47  |  | 
|   48   z16 = malloc( n*2 + 2 ); |  | 
|   49   for(i=j=0; i<=n; i++){ |  | 
|   50     z16[j++] = z[i]; |  | 
|   51     z16[j++] = 0; |  | 
|   52   } |  | 
|   53   return (void*)z16; |  | 
|   54 } |  | 
|   55  |  | 
|   56 /* |  | 
|   57 ** Timers |  | 
|   58 */ |  | 
|   59 static sqlite_uint64 prepTime = 0; |  | 
|   60 static sqlite_uint64 runTime = 0; |  | 
|   61 static sqlite_uint64 finalizeTime = 0; |  | 
|   62  |  | 
|   63 /* |  | 
|   64 ** Prepare and run a single statement of SQL. |  | 
|   65 */ |  | 
|   66 static void prepareAndRun(sqlite3 *db, const char *zSql){ |  | 
|   67   void *utf16; |  | 
|   68   sqlite3_stmt *pStmt; |  | 
|   69   const void *stmtTail; |  | 
|   70   sqlite_uint64 iStart, iElapse; |  | 
|   71   int rc; |  | 
|   72    |  | 
|   73   printf("****************************************************************\n"); |  | 
|   74   printf("SQL statement: [%s]\n", zSql); |  | 
|   75   utf16 = asciiToUtf16le(zSql); |  | 
|   76   iStart = sqlite3Hwtime(); |  | 
|   77   rc = sqlite3_prepare16_v2(db, utf16, -1, &pStmt, &stmtTail); |  | 
|   78   iElapse = sqlite3Hwtime() - iStart; |  | 
|   79   prepTime += iElapse; |  | 
|   80   printf("sqlite3_prepare16_v2() returns %d in %llu cycles\n", rc, iElapse); |  | 
|   81   if( rc==SQLITE_OK ){ |  | 
|   82     int nRow = 0; |  | 
|   83     iStart = sqlite3Hwtime(); |  | 
|   84     while( (rc=sqlite3_step(pStmt))==SQLITE_ROW ){ nRow++; } |  | 
|   85     iElapse = sqlite3Hwtime() - iStart; |  | 
|   86     runTime += iElapse; |  | 
|   87     printf("sqlite3_step() returns %d after %d rows in %llu cycles\n", |  | 
|   88            rc, nRow, iElapse); |  | 
|   89     iStart = sqlite3Hwtime(); |  | 
|   90     rc = sqlite3_finalize(pStmt); |  | 
|   91     iElapse = sqlite3Hwtime() - iStart; |  | 
|   92     finalizeTime += iElapse; |  | 
|   93     printf("sqlite3_finalize() returns %d in %llu cycles\n", rc, iElapse); |  | 
|   94   } |  | 
|   95   free(utf16); |  | 
|   96 } |  | 
|   97  |  | 
|   98 int main(int argc, char **argv){ |  | 
|   99   void *utf16; |  | 
|  100   sqlite3 *db; |  | 
|  101   int rc; |  | 
|  102   int nSql; |  | 
|  103   char *zSql; |  | 
|  104   int i, j; |  | 
|  105   FILE *in; |  | 
|  106   sqlite_uint64 iStart, iElapse; |  | 
|  107   sqlite_uint64 iSetup = 0; |  | 
|  108   int nStmt = 0; |  | 
|  109   int nByte = 0; |  | 
|  110  |  | 
|  111   if( argc!=3 ){ |  | 
|  112     fprintf(stderr, "Usage: %s FILENAME SQL-SCRIPT\n" |  | 
|  113                     "Runs SQL-SCRIPT as UTF16 against a UTF16 database\n", |  | 
|  114                     argv[0]); |  | 
|  115     exit(1); |  | 
|  116   } |  | 
|  117   in = fopen(argv[2], "r"); |  | 
|  118   fseek(in, 0L, SEEK_END); |  | 
|  119   nSql = ftell(in); |  | 
|  120   zSql = malloc( nSql+1 ); |  | 
|  121   fseek(in, 0L, SEEK_SET); |  | 
|  122   nSql = fread(zSql, 1, nSql, in); |  | 
|  123   zSql[nSql] = 0; |  | 
|  124  |  | 
|  125   printf("SQLite version: %d\n", sqlite3_libversion_number()); |  | 
|  126   unlink(argv[1]); |  | 
|  127   utf16 = asciiToUtf16le(argv[1]); |  | 
|  128   iStart = sqlite3Hwtime(); |  | 
|  129   rc = sqlite3_open16(utf16, &db); |  | 
|  130   iElapse = sqlite3Hwtime() - iStart; |  | 
|  131   iSetup = iElapse; |  | 
|  132   printf("sqlite3_open16() returns %d in %llu cycles\n", rc, iElapse); |  | 
|  133   free(utf16); |  | 
|  134   for(i=j=0; j<nSql; j++){ |  | 
|  135     if( zSql[j]==';' ){ |  | 
|  136       int isComplete; |  | 
|  137       char c = zSql[j+1]; |  | 
|  138       zSql[j+1] = 0; |  | 
|  139       isComplete = sqlite3_complete(&zSql[i]); |  | 
|  140       zSql[j+1] = c; |  | 
|  141       if( isComplete ){ |  | 
|  142         zSql[j] = 0; |  | 
|  143         while( i<j && isspace(zSql[i]) ){ i++; } |  | 
|  144         if( i<j ){ |  | 
|  145           nStmt++; |  | 
|  146           nByte += j-i; |  | 
|  147           prepareAndRun(db, &zSql[i]); |  | 
|  148         } |  | 
|  149         zSql[j] = ';'; |  | 
|  150         i = j+1; |  | 
|  151       } |  | 
|  152     } |  | 
|  153   } |  | 
|  154   iStart = sqlite3Hwtime(); |  | 
|  155   sqlite3_close(db); |  | 
|  156   iElapse = sqlite3Hwtime() - iStart; |  | 
|  157   iSetup += iElapse; |  | 
|  158   printf("sqlite3_close() returns in %llu cycles\n", iElapse); |  | 
|  159   printf("\n"); |  | 
|  160   printf("Statements run:       %15d\n", nStmt); |  | 
|  161   printf("Bytes of SQL text:    %15d\n", nByte); |  | 
|  162   printf("Total prepare time:   %15llu cycles\n", prepTime); |  | 
|  163   printf("Total run time:       %15llu cycles\n", runTime); |  | 
|  164   printf("Total finalize time:  %15llu cycles\n", finalizeTime); |  | 
|  165   printf("Open/Close time:      %15llu cycles\n", iSetup); |  | 
|  166   printf("Total Time:           %15llu cycles\n", |  | 
|  167       prepTime + runTime + finalizeTime + iSetup); |  | 
|  168   return 0; |  | 
|  169 } |  | 
| OLD | NEW |