source: proto/SymbolTable/symtab_hash_template.cpp @ 1786

Last change on this file since 1786 was 1786, checked in by vla24, 8 years ago

Added some code to support performance tests using PAPI

File size: 9.4 KB
Line 
1#include "../common_definitions.h"
2#include <hash_symbol_table.h>
3
4#include "../symtab_common_functions.h"
5#include "../xmlwf_common_functions.h"
6
7#ifdef BUFFER_PROFILING
8        BOM_Table * parser_timer;
9
10#elif CODE_CLOCKER
11        #define NUM_EVENTS 1
12//      int Events[NUM_EVENTS] = {PAPI_TOT_CYC};
13//      int Events[NUM_EVENTS] = {PAPI_L2_DCM};
14        int Events[NUM_EVENTS] = {PAPI_L1_DCM};
15//      int Events[NUM_EVENTS] = {PAPI_BR_MSP};
16        //int Events[NUM_EVENTS] = {PAPI_TOT_CYC, PAPI_BR_MSP};
17        int cal_size = 20;
18        CC * parser_timer = new CC(Events,NUM_EVENTS,cal_size);
19#else
20        void * parser_timer;
21#endif
22
23int block_base=0;
24int buffer_base=0;
25
26TagMatcher matcher;
27
28queue <size_t> elem_starts_buf;
29queue <size_t> elem_ends_buf;
30vector <int> gids;
31HashSymbolTable symbol_table;
32
33static inline void postprocess_do_block(Lex & lex, CtCDPI_Callouts & ctCDPI_Callouts, Ref_Callouts & ref_Callouts, Check_streams & check_streams, Tag_Callouts & tag_Callouts, int chars_avail);
34void do_process(FILE *infile, FILE *outfile);
35
36static inline void do_symbol_table_lookup();
37
38int main(int argc, char * argv[]) {
39    char * infilename, * outfilename;
40    FILE *infile, *outfile;
41
42    getFilenames(argc, argv, infilename, outfilename);
43    openInputOutputFiles(infilename, outfilename,
44                         infile, outfile);
45
46//      PERF_SEC_BIND(1);
47
48    PERF_SEC_INIT(parser_timer);
49
50    // store symbols form text to Symbol Table
51    do_process(infile, outfile);
52
53    PERF_SEC_DUMP(parser_timer);
54
55    PERF_SEC_DESTROY(parser_timer);
56
57#if PRINT_SYMBOL_DISTRIBUTION
58    symbol_table.Print_Symbol_Table_Distribution();
59#endif
60
61    fclose(infile);
62    fclose(outfile);
63    return(0);
64}
65
66static inline int ElemStrt_check(int pos) {
67        elem_starts_buf.push(buffer_base + pos);
68        return 0;
69}
70
71static inline int ElemEnd_check(int pos) {
72        elem_ends_buf.push(buffer_base + pos);
73        return 0;
74}
75
76static inline void do_symbol_table_lookup()
77{
78    while( !elem_starts_buf.empty() && !elem_ends_buf.empty() )
79    {
80        int start = elem_starts_buf.front();
81        int end = elem_ends_buf.front();
82        elem_starts_buf.pop();
83        elem_ends_buf.pop();
84        int length = end - start;
85
86        //lookup or insert to symbol table
87#if DEBUG
88        char* symbol = new char[length+1];
89        strncpy ( symbol, source + start - buffer_base, length );
90        symbol[length] ='\0';
91        printf ("start: %i[%i] | end: %i[%i] | length: %i | symbol: %s\n", start, start-buffer_base, end, end-buffer_base, length, symbol );
92
93        delete symbol; symbol = 0;
94#endif
95
96        int gid = symbol_table.Lookup_or_Insert_Name(source + start - buffer_base, length);
97        gids.push_back(gid);
98    }
99}
100
101static inline void postprocess_do_block(Lex & lex, CtCDPI_Callouts & ctCDPI_Callouts, Ref_Callouts & ref_Callouts, Check_streams & check_streams, Tag_Callouts & tag_Callouts, int chars_avail){
102
103    tracker.StoreNewlines(lex.LF);
104
105    if ( bitblock_has_bit(tag_Callouts.ElemName_starts))
106    {
107        BitBlockForwardIterator iter_length_grouping_starts(&tag_Callouts.ElemName_starts);
108        validate_block(iter_length_grouping_starts, block_base, ElemStrt_check);
109    }
110
111    if ( bitblock_has_bit(tag_Callouts.ElemName_ends) )
112    {
113        BitBlockForwardIterator iter_length_grouping_ends(&tag_Callouts.ElemName_ends);
114        validate_block(iter_length_grouping_ends, block_base, ElemEnd_check);
115    }
116
117    do_symbol_table_lookup();
118
119
120    if (bitblock_has_bit(simd_or(check_streams.non_ascii_name_starts, check_streams.non_ascii_names))) {
121        BitBlockForwardIterator iter_NameStrt_check(&check_streams.non_ascii_name_starts);
122        validate_block(iter_NameStrt_check, block_base, NameStrt_check);
123        BitBlockForwardIterator iter_Name_check(&check_streams.non_ascii_names);
124        validate_block(iter_Name_check, block_base, Name_check);
125    }
126    if (bitblock_has_bit(ctCDPI_Callouts.PI_name_starts)){
127        BitBlockForwardIterator iter_PI_name_starts(&(ctCDPI_Callouts.PI_name_starts));
128        validate_block(iter_PI_name_starts, block_base, buffer_base, PIName_check);
129    }
130    if (bitblock_has_bit(ctCDPI_Callouts.CD_starts)){
131        BitBlockForwardIterator iter_CD_check(&ctCDPI_Callouts.CD_starts);
132        validate_block(iter_CD_check, block_base, CD_check);
133    }
134    if(bitblock_has_bit(ref_Callouts.GenRef_starts)){
135        BitBlockForwardIterator iter_GenRef_check(&ref_Callouts.GenRef_starts);
136        validate_block(iter_GenRef_check, block_base, GenRef_check);
137    }
138    if(bitblock_has_bit(ref_Callouts.DecRef_starts)){
139        BitBlockForwardIterator iter_DecRef_check(&ref_Callouts.DecRef_starts);
140        validate_block(iter_DecRef_check, block_base, DecRef_check);
141    }
142    if(bitblock_has_bit(ref_Callouts.HexRef_starts)){
143        BitBlockForwardIterator iter_HexRef_check(&ref_Callouts.HexRef_starts);
144        validate_block(iter_HexRef_check, block_base, HexRef_check);
145    }
146    if(bitblock_has_bit(check_streams.att_refs)){
147        BitBlockForwardIterator iter_AttRef_check(&check_streams.att_refs);
148        validate_block(iter_AttRef_check, block_base, AttRef_check);
149    }
150
151    if(error_tracker.Has_Noted_Error()){
152        int error_line, error_column;
153        tracker.get_Line_and_Column(error_tracker.Noted_Pos_In_Block(), error_line, error_column);
154        ReportError(error_tracker.Noted_Error_Msg(), error_line, error_column);
155        exit(-1);
156    }
157
158    matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
159    tracker.AdvanceBlock();
160}
161
162static inline void print_GIDS()
163{
164    int span_count = gids.size();
165    for(int i=0;i<span_count;i++) {
166             cout << gids[i] << " ";
167    }
168    cout << endl;
169}
170
171void do_process(FILE *infile, FILE *outfile) {
172
173@decl
174
175  int buf_pos = 0;
176  int block_pos = 0;
177  int errpos = 0;
178  int chars_avail = 0;
179  int check_pos = 0;
180  int chars_read = 0;
181  BytePack buf[(BUFFER_SIZE+BLOCK_SIZE+OVERLAP_BUFSIZE*2)/sizeof(SIMD_type)];
182
183  char * srcbuf = ((char *) buf) + OVERLAP_BUFSIZE;
184  buffer_base = buf_pos;
185  source = srcbuf;
186  chars_read = fread((void *)srcbuf, 1, BUFFER_SIZE + OVERLAP_BUFSIZE, infile);
187  chars_avail = chars_read;
188  if (chars_avail > BUFFER_SIZE) chars_avail = BUFFER_SIZE;
189
190  matcher.setSrc(srcbuf);
191
192  if(chars_read<4){
193    fprintf(stderr,"File is too short. Not well formed.\n");
194    exit(-1);
195  }
196
197  Entity_Info * e = new Entity_Info;
198  e->AnalyzeSignature((unsigned char *)srcbuf);
199
200  if (e->code_unit_base == ASCII) {
201
202    XML_Decl_Parser<ASCII> decl_parser((unsigned char *)srcbuf);
203
204    decl_parser.ReadXMLInfo(*e);
205
206    if (e->code_unit_size != SingleByte || (e->has_encoding_decl && (!at_UTF_8(e->encoding)))){
207        fprintf(stderr,"Sorry, this xmlwf demo only works for UTF-8.\n");
208        exit(-1);
209    }
210  }
211  else {
212    fprintf(stderr,"Sorry, this xmlwf demo does not process EBCDIC.\n");
213        exit(-1);
214  }
215
216  if (e->content_start != 0) {
217        memmove(&srcbuf[0], &srcbuf[e->content_start], chars_read - e->content_start);
218        buf_pos = e->content_start;
219        buffer_base = buf_pos;
220        if (chars_avail == BUFFER_SIZE) {
221                chars_read = chars_read - e->content_start +
222                             fread(&srcbuf[chars_read-e->content_start], 1, e->content_start, infile);
223                chars_avail = chars_read;
224                if (chars_avail > BUFFER_SIZE) chars_avail = BUFFER_SIZE;
225        }
226        else {
227          chars_read -=e->content_start;
228          chars_avail -=e->content_start;
229        }
230  }
231
232@stream_stmts
233
234/* Full Buffers */
235    while (chars_avail == BUFFER_SIZE) {
236      PERF_SEC_START(parser_timer);
237      for (int blk = 0; blk < SEGMENT_BLOCKS; blk++) {
238          block_base = blk*BLOCK_SIZE;
239          s2p_do_block((BytePack *) &srcbuf[block_base], basis_bits);
240          @block_stmts
241          postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, tag_Callouts, chars_avail);
242      }
243
244      matcher.StreamScan(chars_avail);
245      matcher.Advance_buffer();
246      tracker.Advance_buffer();
247
248#ifndef CACHE_PERF
249    PERF_SEC_END(parser_timer, chars_avail);
250#else
251    PERF_SEC_END(parser_timer, 1);
252#endif
253           
254      int bytes_left = chars_read - chars_avail;
255      memmove(buf, &srcbuf[BUFFER_SIZE - OVERLAP_BUFSIZE], bytes_left + OVERLAP_BUFSIZE);
256      chars_read = fread(&srcbuf[bytes_left],1, BUFFER_SIZE + OVERLAP_BUFSIZE - bytes_left, infile) + bytes_left;
257      chars_avail = chars_read;
258      if (chars_avail > BUFFER_SIZE) chars_avail = BUFFER_SIZE;
259      buf_pos += chars_avail;
260      if (!elem_starts_buf.size() == elem_ends_buf.size())
261      {
262          int start = elem_starts_buf.front();
263          start = (start - buffer_base) - BUFFER_SIZE + buf_pos;
264          elem_starts_buf.pop();
265          elem_starts_buf.push(start);
266      }
267      buffer_base = buf_pos;
268    }
269/* Final Partial Buffer */
270    PERF_SEC_START(parser_timer);
271
272    block_pos = 0;
273    int remaining = chars_avail;
274/* Full Blocks */
275    while (remaining >= BLOCK_SIZE) {
276          block_base = block_pos;
277          s2p_do_block((BytePack *) &srcbuf[block_pos], basis_bits);
278          @block_stmts
279          postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, tag_Callouts, chars_avail);
280          block_pos += BLOCK_SIZE;
281          remaining -= BLOCK_SIZE;
282    }
283    block_base = block_pos;
284    if (remaining > 0 || @any_carry) {
285          EOF_mask = bitblock::srl(simd<1>::constant<1>(), convert(BLOCK_SIZE-remaining));
286          s2p_do_final_block((BytePack *) &srcbuf[block_pos], basis_bits, EOF_mask);
287          @final_block_stmts
288          postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, tag_Callouts, chars_avail);
289    }
290    buf_pos += chars_avail;
291    buffer_base = buf_pos;
292
293    matcher.StreamScan(chars_avail);
294    matcher.Advance_buffer();
295    tracker.Advance_buffer();
296#ifndef CACHE_PERF
297    PERF_SEC_END(parser_timer, chars_avail);
298#else
299    PERF_SEC_END(parser_timer, 1);
300#endif
301    if (matcher.depth != 0) {
302      fprintf(stderr, "tag matching error (depth %i) at position %i\n", matcher.depth, buffer_base);
303      exit(-1);
304    }
305}
Note: See TracBrowser for help on using the repository browser.