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