Return to speedtest16.c CVS log

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

Annotation of embedaddon/sqlite3/tool/speedtest16.c, revision 1.1.1.1

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