source: trunk/markup_stats.cxx @ 183

Last change on this file since 183 was 183, checked in by cameron, 11 years ago

SIMD templated library - restructuring.

File size: 15.1 KB
Line 
1/*  markup_stats.c - parabix demo program
2    Copyright (c) 2007, Robert D. Cameron.
3    Licensed to the public under the Open Software License 3.0.
4    Licensed to International Characters, Inc., under the Academic
5    Free License 3.0.
6
7*/
8
9#include <stdio.h>
10#include <stdlib.h>
11#include <string.h>
12#include <errno.h>
13#include <sys/types.h>
14#include <sys/stat.h>
15#include <string>
16#include <iostream>
17using namespace std;
18
19#define ON 1
20#define OFF 2
21
22#define TEMPLATED_SIMD_LIB
23
24#define VALIDATION_MODE OFF
25
26#ifdef PAPI
27#include "../code_clocker/clocker/cc.h"
28#include "../code_clocker/clocker/cc.cxx"
29
30CC * code_clocker;
31
32#define NONE 0
33#define END_TAG_MATCHING 1
34#define ATTRIBUTE_UNIQUENESS 2
35#define NAME_VALIDATION 3
36#define NAME_LOOKUP 4
37
38#define OMISSION NONE
39
40
41#define CHARSET_VALIDATION 1
42#define WS_CONTROL 2
43#define MARKUP_STREAMS 3
44#define BITLEX_ALL 4
45#define BITPLEX 5
46#define BYTEPLEX 6
47#define ADVANCE_BUFFERS 7
48#define BUFFER_TOTAL 8
49#define FILE_READING 9
50
51#define CODE_CLOCKING BUFFER_TOTAL
52
53#endif
54
55//#include "src/ilax.h"
56#include "src/engine.h"
57
58#ifndef REPEAT_RUNS
59#define REPEAT_RUNS 1
60#endif
61
62/* Internals */
63#include "src/xmlmodel.h"
64#include "src/xml_error.h"
65#include "src/bitplex.h"
66#include "src/byteplex.h"
67#include "src/xmldecl.h"
68#include "src/bitlex.h"
69
70
71#include "src/xmlmodel.c"
72#include "src/xml_error.c"
73#include "src/bitplex.c"
74#include "src/byteplex.c"
75#include "src/xmldecl.c"
76#include "src/bitlex.c"
77#include "src/engine.c"
78#include "src/symtab.c"
79
80/* Global declarations of parsing engine. */
81Parser_Interface * parser;
82
83/* Global declarations for statistics. */
84
85int comment_count = 0;
86int comment_length = 0;
87int CDATA_start_count = 0;
88int CDATA_start_pos = 0;
89int CDATA_length = 0;
90int CDATA_end_count = 0;
91int PI_count = 0;
92int PI_length = 0;
93int empty_elem_count = 0;
94int empty_elem_length = 0;
95int start_tag_count = 0;
96int start_tag_length = 0;
97int attribute_count = 0;
98int end_tag_count = 0;
99int end_tag_length = 0;
100int reference_count = 0;
101int reference_length = 0;
102int text_item_count = 0;
103int text_item_length = 0;
104int error_item_count = 0;
105int error_item_length = 0;
106int nesting_depth = 0;
107int max_nesting_depth = 0;
108int total_attribute_count = 0;
109int total_att_name_length = 0;
110int total_att_value_length = 0;
111int namespace_count = 0;
112int total_namespace_name_length = 0;
113int total_namespace_URI_length = 0;
114
115int last_item_start = 0;
116int last_item_stop = 0;
117int last_buffer_rel_pos = 0;
118
119
120/* Action routine for an XML comment in "<!--"  "-->" brackets. */
121template <class B>
122inline void ParsingEngine<B>::Comment_action(unsigned char * item, int lgth) {
123        comment_count +=1;
124       
125        #if defined(CALC_AVG)
126                comment_length += lgth;
127        #endif
128}
129
130/* Action routine called upon recognizing "<![CDATA[" to start a CDATA section. */
131template <class B>
132inline void ParsingEngine<B>::CDATA_start_action(unsigned char * CDATA_ptr){
133        CDATA_start_pos = AbsPos() - 9;
134        CDATA_start_count +=1;
135}
136
137/* Action routine called upon recognizing "]]>" to end a CDATA section. */
138template <class B>
139inline void ParsingEngine<B>::CDATA_end_action(unsigned char * CDATA_end_ptr) {
140        CDATA_end_count +=1;
141       
142        #if defined(CALC_AVG)
143                CDATA_length += AbsPos() - CDATA_start_pos;
144        #endif
145}
146
147/* Action routine for an XML processing instruction enclosed in "<?" and "?>" brackets. */
148template <class B>
149inline void ParsingEngine<B>::PI_action(unsigned char * item, int lgth) {
150        PI_count +=1;
151       
152        #if defined(CALC_AVG)
153                PI_length += lgth;
154        #endif
155}
156
157/* Action routine for an empty element enclosed in "<" and "/>" brackets. */
158template <class B>
159inline void ParsingEngine<B>::EmptyElement_action(unsigned char * item, int lgth) {
160        empty_elem_count +=1;
161       
162        #if defined(CALC_AVG)
163                empty_elem_length += lgth;
164        #endif
165}
166
167/* Action routine for a start tag enclosed in "<" and ">" brackets. */
168template <class B>
169inline void ParsingEngine<B>::StartTag_action(unsigned char * item, int lgth) {
170        start_tag_count +=1;
171       
172        #if defined(CALC_AVG)
173                start_tag_length += lgth;
174        #endif
175       
176        nesting_depth += 1;
177        if (nesting_depth > max_nesting_depth) max_nesting_depth = nesting_depth;
178//      cout << string((char *) item, lgth) << endl;
179}
180
181/* Action routine for an end tag enclosed in "</" and ">" brackets. */
182template <class B>
183inline void ParsingEngine<B>::EndTag_action(unsigned char * item, int lgth) {
184        end_tag_count +=1;
185       
186        #if defined(CALC_AVG)
187                end_tag_length += lgth;
188        #endif
189       
190        nesting_depth -= 1;
191}
192
193/* Action routine for an error item */
194template <class B>
195inline void ParsingEngine<B>::Error_action(unsigned char * item, int lgth) {
196        error_item_count +=1;
197       
198        #if defined(CALC_AVG)
199                error_item_length += lgth;
200        #endif
201       
202        fprintf(stderr, "Error: illegal markup at positions %i of length %i.\n", AbsPos()-lgth, lgth);
203        cerr << string((char *) item, lgth) << endl;
204}
205
206/* Action routine for a text item */
207template <class B>
208inline void ParsingEngine<B>::Text_action(unsigned char * item, int lgth, bool more) {
209        text_item_count +=1;
210       
211        #if defined(CALC_AVG)
212                text_item_length += lgth;
213        #endif
214}
215
216template <class B>
217inline void ParsingEngine<B>::Reference_action(unsigned char * item, int lgth) {
218        reference_count +=1;
219       
220        #if defined(CALC_AVG)
221                reference_length += lgth;
222        #endif
223}
224
225
226
227
228/* Three action routines for markup components are defined as follows.
229|ElementName_action| is the action routine called upon recognition of
230an element name immediately after the opening angle bracket of a start
231tag or empty element tag.  {\bf OR MAYBE THIS SHOULD BE DEFERRED UNTIL
232AFTER ATTRIBUTE PROCESSING SO THAT NAMESPACES ARE SET?}
233It is called with two parameters identifying the
234first and last character positions of the expected XML_name.
235Similarly, |PI_Target_action| is the action routine called upon recognition
236of the XML Name that occurs immediately after the opening "<?"
237delimiter of a processing instruction.
238
239 The third action routine for markup components is Attribute_Value_action,
240which takes three parameters rather than two.  {\bf OR POSSIBLY JUST
241THE QUOTE MARK ITEMS, RELYING ON THE END OF THE LAST COMPONENT PROCESSED
242TO MARK THE SPACE BEFORE THE ATT NAME.- REQUIRES ELEMENT_NAME_ACTION}
243*/
244
245/* Semantic action routines for markup components. */
246/* Action routine for an element name occurring immediately after the
247   opening "<" of a start tag or empty element tag. */
248template <class B>
249inline void ParsingEngine<B>::ElementName_action(unsigned char * item, int lgth) {
250}
251
252/* Action routine for a processing instruction target name occurring immediately
253   after the opening "<?" of a processing instruction. */
254template <class B>
255inline void ParsingEngine<B>::PI_Target_action(unsigned char * item, int lgth) {
256}
257
258/* Action routine for an individual attribute/value pair occurring in
259   a element start tag or an empty element tag. */
260template <class B>
261inline void ParsingEngine<B>::AttributeValue_action(unsigned char * name, int name_lgth, 
262                                 unsigned char * val, int val_lgth) {
263        total_attribute_count+=1;
264       
265        #if defined(CALC_AVG)
266                total_att_name_length += name_lgth;
267                total_att_value_length += val_lgth;
268        #endif
269}
270
271/* Action routine for an individual attribute/value pair occurring in
272   a element start tag or an empty element tag. */
273template <class B>
274inline void ParsingEngine<B>::Namespace_action(unsigned char * name, int name_lgth,
275                             unsigned char * URI, int URI_lgth) {
276        namespace_count+=1;
277       
278        #if defined(CALC_AVG)
279                total_namespace_name_length += name_lgth;
280                total_namespace_URI_length += URI_lgth;
281        #endif
282}
283
284
285template <class B>
286void ParsingEngine<B>::FinalizeBuffer_action() {
287       
288       
289#ifdef DEBUG
290        printf ("FinalizeBuffer; last 16 bytes + lookahead 16 =\n");
291        cout << string((char *) GetCodeUnitPtr(AbsPos()-16), 16) << "::" << string((char *) GetCodeUnitPtr(AbsPos()), 16) << endl;
292#endif
293        #if defined(PAPI) and defined(CODE_CLOCKING) and (CODE_CLOCKING == BUFFER_TOTAL)
294                code_clocker->cc_end_interval(BUFFER_SIZE);
295        #endif
296        #if defined(PAPI) and defined(CODE_CLOCKING) and (CODE_CLOCKING == BUFFER_TOTAL)
297                code_clocker->cc_start_interval();
298        #endif
299       
300}
301
302
303template <class B>
304inline void ParsingEngine<B>::DocumentStart_action() {
305        #if defined(PAPI) and defined(CODE_CLOCKING) and (CODE_CLOCKING == BUFFER_TOTAL)
306                code_clocker->cc_start_interval();
307        #endif
308}
309
310template <class B>
311inline void ParsingEngine<B>::DocumentEnd_action() {
312        #if defined(PAPI) and defined(CODE_CLOCKING) and (CODE_CLOCKING == BUFFER_TOTAL)
313                code_clocker->cc_end_interval(buffer_rel_pos);
314        #endif
315}
316
317template <class B>
318inline void ParsingEngine<B>::Doctype_action(unsigned char * item, int lgth) {
319#ifdef SHOW_DTD_ACTIONS
320        printf("Document Type:\n");
321        cout << string((char *) item, lgth) <<endl;
322#endif
323}
324
325template <class B>
326inline void ParsingEngine<B>::PEReference_action(unsigned char * item, int lgth) {
327}
328
329
330template <class B>
331inline void ParsingEngine<B>::ExtSubsetDecl_action(unsigned char * item, int lgth) {
332#ifdef SHOW_DTD_ACTIONS
333        printf("ExtSubsetDecl:\n");
334        cout << string((char *) item, lgth) <<endl;
335#endif
336}
337
338template <class B>
339inline void ParsingEngine<B>::Prolog_action(unsigned char * item, int lgth) {
340#ifdef SHOW_DTD_ACTIONS
341        printf("Prolog:\n");
342        cout << string((char *) item, lgth) <<endl;
343#endif
344}
345
346#define print_stats(stat_string, count, total_lgth) \
347        printf("%i %s", count, stat_string);\
348        if (count == 0) printf("s.\n");\
349        else if (count == 1) printf(" of length %i.\n", total_lgth);\
350        else printf("s of avg. lgth %i.\n", total_lgth/count);
351
352
353#include <sched.h>
354
355int
356main(int argc, char * argv[]) {
357
358#ifdef SET_AFFINITY
359cpu_set_t mask;
360
361
362unsigned int len = sizeof(mask);
363if (sched_getaffinity(0, len, &mask) < 0) {
364    perror("sched_getaffinity");
365    return -1;
366    }
367printf("Original affinity mask is: %08lx\n", mask);
368
369CPU_CLR(0, &mask);
370
371if (sched_setaffinity(0, len, &mask) < 0) {
372    perror("sched_setaffinity");
373}
374if (sched_getaffinity(0, len, &mask) < 0) {
375    perror("sched_getaffinity");
376    return -1;
377    }
378printf("Modified affinity mask is:  %08lx\n", mask);
379#endif
380
381
382
383
384        if (argc != 2) {
385        printf("Usage: %s <filename>\n", argv[0]);
386                exit(-1);
387        }
388       
389        char * src_filename = argv[1];
390        char * cmdline = new char[strlen(argv[0]) + strlen(argv[1]) +1 +1]; 
391        strcat(cmdline, argv[0]);
392        strcat(cmdline," ");
393        strcat(cmdline,argv[1]);
394
395        #ifdef PAPI
396                #define NUM_EVENTS 2
397                int Events[NUM_EVENTS] = {PAPI_TOT_CYC, PAPI_BR_MSP};
398//              int Events[NUM_EVENTS] = {PAPI_TOT_CYC, PAPI_L1_DCM};
399//              int Events[NUM_EVENTS] = {PAPI_L2_DCM};
400                int cal_size = 1000;
401                code_clocker = new CC(Events,NUM_EVENTS,cal_size);
402                code_clocker->cc_set_cmd(cmdline);
403        #endif
404
405        // Read the entire file into a memory buffer   
406        FILE * src_file;
407        struct stat fileinfo;
408        int src_filesize;
409
410        // open file and fstat 
411        src_file = fopen ( src_filename , "rb" );
412        if (!src_file) {
413                fprintf(stderr, "Cannot open '%s'. Terminating the process ...\n", src_filename); 
414                exit(-1);
415        }
416        if(fstat(fileno(src_file), &fileinfo)!=0) {
417                fprintf(stderr, "Cannot fstat '%s'. Terminating the process ...\n", src_filename); 
418                exit(-1);
419        }
420       
421        src_filesize = fileinfo.st_size;
422       
423        // close file
424        fclose (src_file);
425       
426        for (int run = 0; run < REPEAT_RUNS; run++) {
427
428                #ifdef PAPI
429                        code_clocker->cc_start_interval();
430                #endif
431
432                parser = Parser_Interface::ParserFactory(src_filename);
433       
434               
435                if (!parser->has_ByteOrderMark()) printf("No ");
436                printf("Byte Order Mark found.\n");
437       
438                if (parser->get_version() == XML_1_0) printf("XML version 1.0 declared.\n");
439                else if (parser->get_version() == XML_1_1) printf("XML version 1.1 declared.\n");
440                else printf ("XML version 1.0 implied by default.\n");
441                if (parser->has_EncodingDecl()) {
442                        printf("XML encoding declared:  %s\n", parser->get_Encoding());
443                }
444                if (parser->standalone_status() == Standalone_yes) 
445                        printf("XML standalone = yes declared.\n");
446                else if (parser->standalone_status() == Standalone_no) 
447                        printf("XML standalone = no declared.\n");
448                else printf ("XML standalone = no by default.\n");
449               
450
451//              #ifdef PAPI
452//                      code_clocker->cc_start_interval();
453//              #endif
454               
455                parser->Parse_Prolog();
456                parser->Parse_DocumentContent();
457
458//              #ifdef PAPI
459//                      int elems = src_filesize;
460//                      code_clocker->cc_end_interval(elems);
461//              #endif
462
463                parser->~Parser_Interface();
464                printf("Run %i complete.\n", run);
465
466        }
467
468        #ifdef PAPI
469       
470        #if defined(CODE_CLOCKING) and (CODE_CLOCKING == CHARSET_VALIDATION)
471                code_clocker->cc_set_param("CODE_CLOCKING", "CHARSET_VALIDATION");
472        #endif 
473        #if defined(CODE_CLOCKING) and (CODE_CLOCKING == WS_CONTROL)
474                code_clocker->cc_set_param("CODE_CLOCKING", "WS_CONTROL");
475        #endif
476        #if defined(CODE_CLOCKING) and (CODE_CLOCKING == MARKUP_STREAMS)
477                code_clocker->cc_set_param("CODE_CLOCKING", "MARKUP_STREAMS");
478        #endif
479        #if defined(CODE_CLOCKING) and (CODE_CLOCKING == BITLEX_ALL)
480                code_clocker->cc_set_param("CODE_CLOCKING", "BITLEX_ALL");
481        #endif
482        #if defined(CODE_CLOCKING) and (CODE_CLOCKING == BITPLEX)
483                code_clocker->cc_set_param("CODE_CLOCKING", "BITPLEX");
484        #endif
485        #if defined(CODE_CLOCKING) and (CODE_CLOCKING == BYTEPLEX)
486                code_clocker->cc_set_param("CODE_CLOCKING", "BYTEPLEX");
487        #endif
488        #if defined(CODE_CLOCKING) and (CODE_CLOCKING == ADVANCE_BUFFERS)
489                code_clocker->cc_set_param("CODE_CLOCKING", "ADVANCE_BUFFERS");
490        #endif
491        #if defined(CODE_CLOCKING) and (CODE_CLOCKING == BUFFER_TOTAL)
492                code_clocker->cc_set_param("CODE_CLOCKING", "BUFFER_TOTAL");
493        #endif
494        #if defined(CODE_CLOCKING) and (CODE_CLOCKING == FILE_READING)
495                code_clocker->cc_set_param("CODE_CLOCKING", "FILE_READING");
496        #endif
497        #if defined(OMISSION) and (OMISSION == NONE)
498                code_clocker->cc_set_param("OMISSION", "NONE");
499        #endif
500        #if defined(OMISSION) and (OMISSION == END_TAG_MATCHING)
501                code_clocker->cc_set_param("OMISSION", "END_TAG_MATCHING");
502        #endif
503        #if defined(OMISSION) and (OMISSION == ATTRIBUTE_UNIQUENESS)
504                code_clocker->cc_set_param("OMISSION", "ATTRIBUTE_UNIQUENESS");
505        #endif
506        #if defined(OMISSION) and (OMISSION == NAME_VALIDATION)
507                code_clocker->cc_set_param("OMISSION", "NAME_VALIDATION");
508        #endif
509        #if defined(OMISSION) and (OMISSION == NAME_LOOKUP)
510                code_clocker->cc_set_param("OMISSION", "NAME_LOOKUP");
511        #endif
512        #if defined(VALIDATION_MODE) and (VALIDATION_MODE == ON)
513                code_clocker->cc_set_param("VALIDATION_MODE", "ON");
514        #endif
515        #if defined(VALIDATION_MODE) and (VALIDATION_MODE == OFF)
516                code_clocker->cc_set_param("VALIDATION_MODE", "OFF");
517        #endif
518       
519                code_clocker->cc_write_xml_file();
520                code_clocker->cc_display();
521                delete code_clocker;
522        #endif 
523       
524        print_stats("comment", comment_count, comment_length);
525        print_stats("CDATA section", CDATA_end_count, CDATA_length);
526        print_stats("processing instruction", PI_count, PI_length);
527        print_stats("empty element", empty_elem_count, empty_elem_length);
528        print_stats("start tag", start_tag_count, start_tag_length);
529        printf("%i total attributes\n", total_attribute_count);
530        print_stats("attribute name", total_attribute_count, total_att_name_length);
531        print_stats("attribute value", total_attribute_count, total_att_value_length);
532        print_stats("namespace name", namespace_count, total_namespace_name_length);
533        print_stats("namespace URI", namespace_count, total_namespace_URI_length);
534        print_stats("end tag", end_tag_count, end_tag_length);
535        print_stats("text item", text_item_count, text_item_length);
536        print_stats("reference", reference_count, reference_length);
537        print_stats("error item", error_item_count, error_item_length);
538        printf("Maximum nesting depth = %i\n", max_nesting_depth);
539       
540        return(0);
541}
Note: See TracBrowser for help on using the repository browser.