Return to speedtest16.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / tool

sqlite3

    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: }