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