1: /*
2: ** Performance test for SQLite.
3: **
4: ** This program reads ASCII text from a file named on the command-line
5: ** and submits that text to SQLite for evaluation. A new database
6: ** is created at the beginning of the program. All statements are
7: ** timed using the high-resolution timer built into Intel-class processors.
8: **
9: ** To compile this program, first compile the SQLite library separately
10: ** will full optimizations. For example:
11: **
12: ** gcc -c -O6 -DSQLITE_THREADSAFE=0 sqlite3.c
13: **
14: ** Then link against this program. But to do optimize this program
15: ** because that defeats the hi-res timer.
16: **
17: ** gcc speedtest8.c sqlite3.o -ldl -I../src
18: **
19: ** Then run this program with a single argument which is the name of
20: ** a file containing SQL script that you want to test:
21: **
22: ** ./a.out test.db test.sql
23: */
24: #include <stdio.h>
25: #include <string.h>
26: #include <stdlib.h>
27: #include <ctype.h>
28: #include <time.h>
29:
30: #if defined(_MSC_VER)
31: #include <windows.h>
32: #else
33: #include <unistd.h>
34: #include <sys/times.h>
35: #include <sched.h>
36: #endif
37:
38: #include "sqlite3.h"
39:
40: /*
41: ** hwtime.h contains inline assembler code for implementing
42: ** high-performance timing routines.
43: */
44: #include "hwtime.h"
45:
46: /*
47: ** Timers
48: */
49: static sqlite_uint64 prepTime = 0;
50: static sqlite_uint64 runTime = 0;
51: static sqlite_uint64 finalizeTime = 0;
52:
53: /*
54: ** Prepare and run a single statement of SQL.
55: */
56: static void prepareAndRun(sqlite3 *db, const char *zSql, int bQuiet){
57: sqlite3_stmt *pStmt;
58: const char *stmtTail;
59: sqlite_uint64 iStart, iElapse;
60: int rc;
61:
62: if (!bQuiet){
63: printf("***************************************************************\n");
64: }
65: if (!bQuiet) printf("SQL statement: [%s]\n", zSql);
66: iStart = sqlite3Hwtime();
67: rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, &stmtTail);
68: iElapse = sqlite3Hwtime() - iStart;
69: prepTime += iElapse;
70: if (!bQuiet){
71: printf("sqlite3_prepare_v2() returns %d in %llu cycles\n", rc, iElapse);
72: }
73: if( rc==SQLITE_OK ){
74: int nRow = 0;
75: iStart = sqlite3Hwtime();
76: while( (rc=sqlite3_step(pStmt))==SQLITE_ROW ){ nRow++; }
77: iElapse = sqlite3Hwtime() - iStart;
78: runTime += iElapse;
79: if (!bQuiet){
80: printf("sqlite3_step() returns %d after %d rows in %llu cycles\n",
81: rc, nRow, iElapse);
82: }
83: iStart = sqlite3Hwtime();
84: rc = sqlite3_finalize(pStmt);
85: iElapse = sqlite3Hwtime() - iStart;
86: finalizeTime += iElapse;
87: if (!bQuiet){
88: printf("sqlite3_finalize() returns %d in %llu cycles\n", rc, iElapse);
89: }
90: }
91: }
92:
93: int main(int argc, char **argv){
94: sqlite3 *db;
95: int rc;
96: int nSql;
97: char *zSql;
98: int i, j;
99: FILE *in;
100: sqlite_uint64 iStart, iElapse;
101: sqlite_uint64 iSetup = 0;
102: int nStmt = 0;
103: int nByte = 0;
104: const char *zArgv0 = argv[0];
105: int bQuiet = 0;
106: #if !defined(_MSC_VER)
107: struct tms tmsStart, tmsEnd;
108: clock_t clkStart, clkEnd;
109: #endif
110:
111: #ifdef HAVE_OSINST
112: extern sqlite3_vfs *sqlite3_instvfs_binarylog(char *, char *, char *);
113: extern void sqlite3_instvfs_destroy(sqlite3_vfs *);
114: sqlite3_vfs *pVfs = 0;
115: #endif
116:
117: while (argc>3)
118: {
119: #ifdef HAVE_OSINST
120: if( argc>4 && (strcmp(argv[1], "-log")==0) ){
121: pVfs = sqlite3_instvfs_binarylog("oslog", 0, argv[2]);
122: sqlite3_vfs_register(pVfs, 1);
123: argv += 2;
124: argc -= 2;
125: continue;
126: }
127: #endif
128:
129: /*
130: ** Increasing the priority slightly above normal can help with
131: ** repeatability of testing. Note that with Cygwin, -5 equates
132: ** to "High", +5 equates to "Low", and anything in between
133: ** equates to "Normal".
134: */
135: if( argc>4 && (strcmp(argv[1], "-priority")==0) ){
136: #if defined(_MSC_VER)
137: int new_priority = atoi(argv[2]);
138: if(!SetPriorityClass(GetCurrentProcess(),
139: (new_priority<=-5) ? HIGH_PRIORITY_CLASS :
140: (new_priority<=0) ? ABOVE_NORMAL_PRIORITY_CLASS :
141: (new_priority==0) ? NORMAL_PRIORITY_CLASS :
142: (new_priority<5) ? BELOW_NORMAL_PRIORITY_CLASS :
143: IDLE_PRIORITY_CLASS)){
144: printf ("error setting priority\n");
145: exit(2);
146: }
147: #else
148: struct sched_param myParam;
149: sched_getparam(0, &myParam);
150: printf ("Current process priority is %d.\n", (int)myParam.sched_priority);
151: myParam.sched_priority = atoi(argv[2]);
152: printf ("Setting process priority to %d.\n", (int)myParam.sched_priority);
153: if (sched_setparam (0, &myParam) != 0){
154: printf ("error setting priority\n");
155: exit(2);
156: }
157: #endif
158: argv += 2;
159: argc -= 2;
160: continue;
161: }
162:
163: if( argc>3 && strcmp(argv[1], "-quiet")==0 ){
164: bQuiet = -1;
165: argv++;
166: argc--;
167: continue;
168: }
169:
170: break;
171: }
172:
173: if( argc!=3 ){
174: fprintf(stderr, "Usage: %s [options] FILENAME SQL-SCRIPT\n"
175: "Runs SQL-SCRIPT against a UTF8 database\n"
176: "\toptions:\n"
177: #ifdef HAVE_OSINST
178: "\t-log <log>\n"
179: #endif
180: "\t-priority <value> : set priority of task\n"
181: "\t-quiet : only display summary results\n",
182: zArgv0);
183: exit(1);
184: }
185:
186: in = fopen(argv[2], "r");
187: fseek(in, 0L, SEEK_END);
188: nSql = ftell(in);
189: zSql = malloc( nSql+1 );
190: fseek(in, 0L, SEEK_SET);
191: nSql = fread(zSql, 1, nSql, in);
192: zSql[nSql] = 0;
193:
194: printf("SQLite version: %d\n", sqlite3_libversion_number());
195: unlink(argv[1]);
196: #if !defined(_MSC_VER)
197: clkStart = times(&tmsStart);
198: #endif
199: iStart = sqlite3Hwtime();
200: rc = sqlite3_open(argv[1], &db);
201: iElapse = sqlite3Hwtime() - iStart;
202: iSetup = iElapse;
203: if (!bQuiet) printf("sqlite3_open() returns %d in %llu cycles\n", rc, iElapse);
204: for(i=j=0; j<nSql; j++){
205: if( zSql[j]==';' ){
206: int isComplete;
207: char c = zSql[j+1];
208: zSql[j+1] = 0;
209: isComplete = sqlite3_complete(&zSql[i]);
210: zSql[j+1] = c;
211: if( isComplete ){
212: zSql[j] = 0;
213: while( i<j && isspace(zSql[i]) ){ i++; }
214: if( i<j ){
215: int n = j - i;
216: if( n>=6 && memcmp(&zSql[i], ".crash",6)==0 ) exit(1);
217: nStmt++;
218: nByte += n;
219: prepareAndRun(db, &zSql[i], bQuiet);
220: }
221: zSql[j] = ';';
222: i = j+1;
223: }
224: }
225: }
226: iStart = sqlite3Hwtime();
227: sqlite3_close(db);
228: iElapse = sqlite3Hwtime() - iStart;
229: #if !defined(_MSC_VER)
230: clkEnd = times(&tmsEnd);
231: #endif
232: iSetup += iElapse;
233: if (!bQuiet) printf("sqlite3_close() returns in %llu cycles\n", iElapse);
234:
235: printf("\n");
236: printf("Statements run: %15d stmts\n", nStmt);
237: printf("Bytes of SQL text: %15d bytes\n", nByte);
238: printf("Total prepare time: %15llu cycles\n", prepTime);
239: printf("Total run time: %15llu cycles\n", runTime);
240: printf("Total finalize time: %15llu cycles\n", finalizeTime);
241: printf("Open/Close time: %15llu cycles\n", iSetup);
242: printf("Total time: %15llu cycles\n",
243: prepTime + runTime + finalizeTime + iSetup);
244:
245: #if !defined(_MSC_VER)
246: printf("\n");
247: printf("Total user CPU time: %15.3g secs\n", (tmsEnd.tms_utime - tmsStart.tms_utime)/(double)CLOCKS_PER_SEC );
248: printf("Total system CPU time: %15.3g secs\n", (tmsEnd.tms_stime - tmsStart.tms_stime)/(double)CLOCKS_PER_SEC );
249: printf("Total real time: %15.3g secs\n", (clkEnd -clkStart)/(double)CLOCKS_PER_SEC );
250: #endif
251:
252: #ifdef HAVE_OSINST
253: if( pVfs ){
254: sqlite3_instvfs_destroy(pVfs);
255: printf("vfs log written to %s\n", argv[0]);
256: }
257: #endif
258:
259: return 0;
260: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to speedtest8.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / tool