/xmlbench/trunk

To get this branch, use:
bzr branch http://darksoft.org/webbzr/xmlbench/trunk

« back to all changes in this revision

Viewing changes to parse/tools.h

  • Committer: Suren A. Chilingaryan
  • Date: 2009-02-16 09:27:17 UTC
  • Revision ID: csa@dside.dyndns.org-20090216092717-wipyvaaw2srxhgns
Initial import

Show diffs side-by-side

added added

removed removed

Lines of Context:
parse/tools.h
 
1
#include <stdlib.h>
 
2
#include <unistd.h>
 
3
#include <sys/types.h>
 
4
#include <sys/stat.h>
 
5
 
 
6
#include "../tools/disp.h"
 
7
#include "../xmlgen/xmlgen.h"
 
8
#include "../xmlgen/opcgen.h"
 
9
 
 
10
#ifdef GENERATOR_XMARK
 
11
#include "../xmlgen/xmark.h"
 
12
#endif /* GENERATOR_XMARK */
 
13
 
 
14
struct TestData {
 
15
    unsigned long iterations;
 
16
    unsigned long size;
 
17
    
 
18
    char *fn;
 
19
    char *xml;
 
20
    unsigned long xmllen;
 
21
};
 
22
 
 
23
char *ReadFile(char *fn) {
 
24
    FILE *f;
 
25
    struct stat st;
 
26
    char *buf;
 
27
    
 
28
    f=fopen(fn,"r");
 
29
    if (!f) {
 
30
        printf("Can't open XML file!\n");
 
31
        exit(1);
 
32
    }
 
33
    fstat(f->_fileno,&st);
 
34
    buf=(char*)malloc(st.st_size+1+sizeof(unsigned long));
 
35
    if (!buf) {
 
36
        printf("Can't allocate memory!\n");
 
37
        exit(1);
 
38
    }
 
39
    ((unsigned long*)buf)[0]=st.st_size;
 
40
    fread(buf+sizeof(unsigned long),st.st_size,1,f);
 
41
    fclose(f);
 
42
    buf[st.st_size+sizeof(unsigned long)]=0;
 
43
    return buf;
 
44
}
 
45
 
 
46
void ReadConfig(struct TestData *td) {
 
47
    FILE *f;
 
48
    f=fopen("config","r");
 
49
    if (!f) {
 
50
        printf("Error opening config file!\n");
 
51
        exit(1);
 
52
    }
 
53
    fscanf(f,"%lu",&(td->iterations));
 
54
    fclose(f);
 
55
}
 
56
 
 
57
void initXML(struct TestData *td);
 
58
void releaseXML(struct TestData *td);
 
59
void parseXML(struct TestData *td, unsigned long iter);
 
60
 
 
61
void Usage(char *myname) {
 
62
 
 
63
    printf("Usage:\n\t%s <iterations> [<xml file>|xmlgen|opcgen",myname);
 
64
#ifdef GENERATOR_XMARK
 
65
    printf("|xmark");
 
66
#ifdef DTD_VALIDATION
 
67
#ifdef DTD_VALIDATION_SUPPORTED
 
68
    printf("|xmarkdtd");
 
69
#endif
 
70
#endif
 
71
#endif /* GENERATOR_XMARK */
 
72
    printf("] <size>\n");
 
73
    exit(0);
 
74
}
 
75
 
 
76
int Test(int argc, char *argv[]) {
 
77
    int i,j;
 
78
    struct timeval pre_time,post_time;
 
79
    struct timezone tz;
 
80
    unsigned long init_time,init_time2,time;
 
81
    double init_dtime,init_d;
 
82
    unsigned char mode=0;       /* 0 - file, 1 - xmlgen, 2 - opcgen */
 
83
    struct TestData td;
 
84
    char *xmlbuf;
 
85
    FILE *f;
 
86
    
 
87
    if ((argc<3)||(argc>4)) Usage(argv[0]);
 
88
    
 
89
    td.iterations = atol(argv[1]);
 
90
    if (td.iterations<=0) Usage(argv[0]);
 
91
 
 
92
#ifdef DTD_VALIDATION
 
93
#ifndef DTD_VALIDATION_SUPPORTED
 
94
    fprintf(stderr,"DTD validation not implemented yet or not supported by parser!\n");
 
95
    exit(1);
 
96
#endif
 
97
#endif
 
98
 
 
99
    if (!strncmp(argv[2],"xmlgen",6)) mode=1;
 
100
    else if (!strncmp(argv[2],"opcgen",6)) mode=2;
 
101
#ifdef GENERATOR_XMARK
 
102
    else if (!strncmp(argv[2],"xmark",8)) mode=3;
 
103
#ifdef DTD_VALIDATION
 
104
    else if (!strncmp(argv[2],"xmarkdtd",8)) mode=4;
 
105
#endif
 
106
#endif /* GENERATOR_XMARK */
 
107
 
 
108
    td.fn=argv[2];
 
109
    
 
110
    if (mode) {
 
111
        if (argc==4) td.size = atol(argv[3]);
 
112
        else Usage(argv[0]);
 
113
        if (td.size<1) Usage(argv[0]);
 
114
 
 
115
        rnd_init();     /* Initialising Random Generator */
 
116
    }
 
117
    
 
118
//    ReadConfig(&td);
 
119
    
 
120
    switch (mode) {
 
121
        case 0:
 
122
            xmlbuf=ReadFile(argv[2]);
 
123
            if (!xmlbuf) {
 
124
                fprintf(stderr,"Can't read XML file!\n");
 
125
                exit(0);
 
126
            }
 
127
            td.xml=xmlbuf+sizeof(unsigned long);
 
128
            td.xmllen=((unsigned long*)xmlbuf)[0];
 
129
        break;
 
130
        case 1:
 
131
            xmlbuf=xmlgen_init(td.size);
 
132
            td.xml=xmlbuf;
 
133
            td.xmllen=xmlgen();
 
134
        break;
 
135
        case 2:
 
136
            xmlbuf=opcgen_init(td.size);
 
137
            td.xml=xmlbuf;
 
138
            td.xmllen=opcgen();
 
139
        break;
 
140
#ifdef GENERATOR_XMARK
 
141
        case 3:
 
142
            xmlbuf=xmark_init(td.size);
 
143
            td.xml=xmlbuf;
 
144
            td.xmllen=xmark(0);
 
145
        break;
 
146
        case 4:
 
147
            xmlbuf=xmark_init(td.size);
 
148
            td.xml=xmlbuf;
 
149
            td.xmllen=xmark(1);
 
150
        break;
 
151
#endif /* GENERATOR_XMARK */
 
152
 
 
153
    }
 
154
 
 
155
    gettimeofday(&pre_time,NULL);
 
156
    initXML(&td);
 
157
    gettimeofday(&post_time,NULL);
 
158
    init_time=(post_time.tv_sec-pre_time.tv_sec)*1000000+(post_time.tv_usec-pre_time.tv_usec);
 
159
 
 
160
#ifdef PARABIX_PARSER_FIX
 
161
        f = fopen("/tmp/parabix.test", "w");
 
162
        fwrite(td.xml, td.xmllen, 1, f);
 
163
        fclose(f);
 
164
#endif
 
165
 
 
166
    gettimeofday(&pre_time,NULL);
 
167
    parseXML(&td,0);
 
168
    gettimeofday(&post_time,NULL);
 
169
    init_time2=(post_time.tv_sec-pre_time.tv_sec)*1000000+(post_time.tv_usec-pre_time.tv_usec);
 
170
        
 
171
    disp_init();
 
172
    for (i=1;i<=td.iterations;i++) {
 
173
        switch (mode) {
 
174
            case 1:
 
175
                td.xmllen=xmlgen();
 
176
            break;
 
177
            case 2:
 
178
                td.xmllen=opcgen();
 
179
            break;
 
180
#ifdef GENERATOR_XMARK
 
181
            case 3:
 
182
                td.xmllen=xmark(0);
 
183
            break;
 
184
            case 4:
 
185
                td.xmllen=xmark(1);
 
186
            break;
 
187
#endif /* GENERATOR_XMARK */
 
188
        }
 
189
 
 
190
#ifdef PARABIX_PARSER_FIX
 
191
        f = fopen("/tmp/parabix.test", "w");
 
192
        fwrite(td.xml, td.xmllen, 1, f);
 
193
        fclose(f);
 
194
#endif
 
195
        
 
196
        gettimeofday(&pre_time,NULL);
 
197
        parseXML(&td,i);
 
198
        gettimeofday(&post_time,NULL);
 
199
        time=(post_time.tv_sec-pre_time.tv_sec)*1000000+(post_time.tv_usec-pre_time.tv_usec);
 
200
        disp_event(time);
 
201
//      printf("%lu\n",time);
 
202
    }
 
203
    disp_post();
 
204
    releaseXML(&td);
 
205
    
 
206
    switch (mode) {
 
207
        case 0:
 
208
            free(xmlbuf);
 
209
        break;
 
210
        case 1:
 
211
            xmlgen_deinit();
 
212
        break;
 
213
        case 2:
 
214
            opcgen_deinit();
 
215
        break;
 
216
#ifdef GENERATOR_XMARK
 
217
            case 3:
 
218
            case 4:
 
219
                xmark_deinit();
 
220
            break;
 
221
#endif /* GENERATOR_XMARK */
 
222
    }
 
223
 
 
224
    if (mode==2) 
 
225
        printf("Parsing Time %lf ms for %lu messages\n", ((double)disp_s) / 1000,td.iterations);
 
226
    else {
 
227
        if ((init_time2 - disp_m)<10) {
 
228
            init_d=0;
 
229
            init_dtime=0;
 
230
        } else {
 
231
            init_d=300 * disp_d / fabs(init_time2 - disp_m);
 
232
            init_dtime=(init_time2 - disp_m)/1000;
 
233
        }
 
234
        printf("Initialisation time %.3lf + %.3lf(%.2lf%) ms, Parsing Time %.3lf(%.2lf%) ms\n",(1. * init_time) / 1000, init_dtime, init_d, disp_m / 1000, 300*disp_d/disp_m);
 
235
    }
 
236
 
 
237
    return 0;
 
238
}
 
239