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