source: proto/SymbolTable/symtab_identity_template.cpp @ 1787

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

Added some code to support performance tests using PAPI

File size: 11.5 KB
Line 
1#include "../common_definitions.h"
2#include <pbgs_identity_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;
25int buffer_last;
26
27TagMatcher matcher;
28
29BitBlock elem_ends;
30int last_elem_start;
31bool block_boundary_case = false;
32BytePack hashvalues[2];
33
34vector <int> gids;
35PBGSIdentitySymbolTable pbgs_symbol_table;
36
37static inline void postprocess_do_block(Lex & lex, CtCDPI_Callouts & ctCDPI_Callouts, Ref_Callouts & ref_Callouts, Check_streams & check_streams, Tag_Callouts & tag_Callouts, Hash_data & hash_data, int chars_avail);
38
39void do_process(FILE *infile, FILE *outfile);
40
41static inline void validate_block_length_grouping(BitBlockForwardIterator & start, int block_base);
42
43static inline int ElemStart_grouping(int start_pos, int L) ;
44
45int main(int argc, char * argv[]) {
46    char * infilename, * outfilename;
47    FILE *infile, *outfile;
48
49    getFilenames(argc, argv, infilename, outfilename);
50    openInputOutputFiles(infilename, outfilename,
51                         infile, outfile);
52
53//      PERF_SEC_BIND(1);
54
55    PERF_SEC_INIT(parser_timer);
56
57    // store symbols form text to Symbol Table
58    do_process(infile, outfile);
59
60    PERF_SEC_DUMP(parser_timer);
61
62    PERF_SEC_DESTROY(parser_timer);
63
64    fclose(infile);
65    fclose(outfile);
66
67#if PRINT_SYMBOL_DISTRIBUTION
68//    print_GIDS();
69    pbgs_symbol_table.Print_Symbol_Table_Distribution();
70#endif
71
72    return(0);
73}
74
75static inline int ElemStart_grouping(int start_pos, int L) {
76    int hashvalue = compute_hash_value(L, start_pos - block_base, hashvalues);
77    int gid = 0;
78
79    switch (L)
80    {
81    case 1:
82        gid = pbgs_symbol_table.Lookup_or_Insert_Name<1>(source + start_pos, hashvalue);
83        break;
84    case 2:
85        gid = pbgs_symbol_table.Lookup_or_Insert_Name<2>(source + start_pos, hashvalue);
86        break;
87    case 3:
88        gid = pbgs_symbol_table.Lookup_or_Insert_Name<3>(source + start_pos, hashvalue);
89        break;
90    case 4:
91        gid = pbgs_symbol_table.Lookup_or_Insert_Name<4>(source + start_pos, hashvalue);
92        break;
93    case 5:
94        gid = pbgs_symbol_table.Lookup_or_Insert_Name<5>(source + start_pos, hashvalue);
95        break;
96    case 6:
97        gid = pbgs_symbol_table.Lookup_or_Insert_Name<6>(source + start_pos, hashvalue);
98        break;
99    case 7:
100        gid = pbgs_symbol_table.Lookup_or_Insert_Name<7>(source + start_pos, hashvalue);
101        break;
102    case 8:
103        gid = pbgs_symbol_table.Lookup_or_Insert_Name<8>(source + start_pos, hashvalue);
104        break;
105    case 9:
106        gid = pbgs_symbol_table.Lookup_or_Insert_Name<9>(source + start_pos, hashvalue);
107        break;
108    case 10:
109        gid = pbgs_symbol_table.Lookup_or_Insert_Name<10>(source + start_pos, hashvalue);
110        break;
111    case 11:
112        gid = pbgs_symbol_table.Lookup_or_Insert_Name<11>(source + start_pos, hashvalue);
113        break;
114    case 12:
115        gid = pbgs_symbol_table.Lookup_or_Insert_Name<12>(source + start_pos, hashvalue);
116        break;
117    case 13:
118        gid = pbgs_symbol_table.Lookup_or_Insert_Name<13>(source + start_pos, hashvalue);
119        break;
120    case 14:
121        gid = pbgs_symbol_table.Lookup_or_Insert_Name<14>(source + start_pos, hashvalue);
122        break;
123    case 15:
124        gid = pbgs_symbol_table.Lookup_or_Insert_Name<15>(source + start_pos, hashvalue);
125        break;
126    case 16:
127        gid = pbgs_symbol_table.Lookup_or_Insert_Name<16>(source + start_pos, hashvalue);
128        break;
129    default:
130        gid = pbgs_symbol_table.Lookup_or_Insert_Name(source + start_pos, hashvalue, L);
131        break;
132    }
133
134    gids.push_back(gid);
135#if DEBUG
136    int end = start_pos + L;
137    char* symbol = new char[L+1];
138    strncpy ( symbol, source + start_pos, L );
139    symbol[L] ='\0';
140    printf ("%s | L: %i | start: %i[%i] | end: %i[%i] | gid: %i | hashvalue: %i | symbol: %s\n", __FUNCTION__, L, start_pos, start_pos-buffer_base, end, end-buffer_base, gid, hashvalue, symbol );
141    delete symbol; symbol = 0;
142#endif
143    return 0;
144}
145
146inline void validate_block_length_grouping(BitBlockForwardIterator & start, int block_base) {
147
148    BitBlockForwardIterator end;
149    int start_pos, end_pos, lgth;
150
151    while(start != end) {
152        start_pos = *start;
153        end_pos = ScanForwardPos (&elem_ends, start_pos);
154        if (end_pos)
155        {
156            lgth = end_pos - start_pos;
157            start_pos += block_base;
158            ElemStart_grouping(start_pos, lgth);
159        }
160        else
161        {
162            //handle boundary case
163            block_boundary_case = true;
164            last_elem_start = start_pos - BLOCK_SIZE;
165        }
166        start++;
167    }
168}
169
170static inline void postprocess_do_block(Lex & lex, CtCDPI_Callouts & ctCDPI_Callouts, Ref_Callouts & ref_Callouts, Check_streams & check_streams, Tag_Callouts & tag_Callouts, Hash_data & hash_data, int chars_avail){
171
172    tracker.StoreNewlines(lex.LF);
173    elem_ends = tag_Callouts.ElemName_ends;
174    hashvalues[1] = hash_data.Hash_value;
175
176    if (block_boundary_case)
177    {
178        int end_pos = count_forward_zeroes(elem_ends);
179        ElemStart_grouping (last_elem_start + block_base, end_pos-last_elem_start);
180        block_boundary_case = false;
181    }
182
183    if ( bitblock_has_bit(tag_Callouts.ElemName_starts) )
184    {
185        BitBlockForwardIterator iter_length_grouping(&tag_Callouts.ElemName_starts);
186        validate_block_length_grouping(iter_length_grouping, block_base);
187    }
188
189    //copy current hash value data as previous one.
190    memmove (&hashvalues[0], &hashvalues[1], 16);
191
192    if (bitblock_has_bit(simd_or(check_streams.non_ascii_name_starts, check_streams.non_ascii_names))) {
193        BitBlockForwardIterator iter_NameStrt_check(&check_streams.non_ascii_name_starts);
194        validate_block(iter_NameStrt_check, block_base, NameStrt_check);
195        BitBlockForwardIterator iter_Name_check(&check_streams.non_ascii_names);
196        validate_block(iter_Name_check, block_base, Name_check);
197    }
198    if (bitblock_has_bit(ctCDPI_Callouts.PI_name_starts)){
199        BitBlockForwardIterator iter_PI_name_starts(&(ctCDPI_Callouts.PI_name_starts));
200        validate_block(iter_PI_name_starts, block_base, buffer_base, PIName_check);
201    }
202    if (bitblock_has_bit(ctCDPI_Callouts.CD_starts)){
203        BitBlockForwardIterator iter_CD_check(&ctCDPI_Callouts.CD_starts);
204        validate_block(iter_CD_check, block_base, CD_check);
205    }
206    if(bitblock_has_bit(ref_Callouts.GenRef_starts)){
207        BitBlockForwardIterator iter_GenRef_check(&ref_Callouts.GenRef_starts);
208        validate_block(iter_GenRef_check, block_base, GenRef_check);
209    }
210    if(bitblock_has_bit(ref_Callouts.DecRef_starts)){
211        BitBlockForwardIterator iter_DecRef_check(&ref_Callouts.DecRef_starts);
212        validate_block(iter_DecRef_check, block_base, DecRef_check);
213    }
214    if(bitblock_has_bit(ref_Callouts.HexRef_starts)){
215        BitBlockForwardIterator iter_HexRef_check(&ref_Callouts.HexRef_starts);
216        validate_block(iter_HexRef_check, block_base, HexRef_check);
217    }
218    if(bitblock_has_bit(check_streams.att_refs)){
219        BitBlockForwardIterator iter_AttRef_check(&check_streams.att_refs);
220        validate_block(iter_AttRef_check, block_base, AttRef_check);
221    }
222
223    if(error_tracker.Has_Noted_Error()){
224        int error_line, error_column;
225        tracker.get_Line_and_Column(error_tracker.Noted_Pos_In_Block(), error_line, error_column);
226        ReportError(error_tracker.Noted_Error_Msg(), error_line, error_column);
227        exit(-1);
228    }
229
230    matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
231    tracker.AdvanceBlock();
232}
233
234
235static inline void print_GIDS()
236{
237    int span_count = gids.size();
238    for(int i=0;i<span_count;i++) {
239             cout << gids[i] << " ";
240    }
241    cout << endl;
242}
243
244void do_process(FILE *infile, FILE *outfile) {   
245@decl
246  int buf_pos = 0;
247  int block_pos = 0;
248  int errpos = 0;
249  int chars_avail = 0;
250  int check_pos = 0;
251  int chars_read = 0;
252  BytePack buf[(BUFFER_SIZE+BLOCK_SIZE+OVERLAP_BUFSIZE*2)/sizeof(SIMD_type)];
253
254  char * srcbuf = ((char *) buf) + OVERLAP_BUFSIZE;
255  buffer_base = buf_pos;
256  source = srcbuf;
257  chars_read = fread((void *)srcbuf, 1, BUFFER_SIZE + OVERLAP_BUFSIZE, infile);
258  chars_avail = chars_read;
259  if (chars_avail > BUFFER_SIZE) chars_avail = BUFFER_SIZE;
260
261  matcher.setSrc(srcbuf);
262
263  if(chars_read<4){
264    fprintf(stderr,"File is too short. Not well formed.\n");
265    exit(-1);
266  }
267
268  Entity_Info * e = new Entity_Info;
269  e->AnalyzeSignature((unsigned char *)srcbuf);
270
271  if (e->code_unit_base == ASCII) {
272
273    XML_Decl_Parser<ASCII> decl_parser((unsigned char *)srcbuf);
274
275    decl_parser.ReadXMLInfo(*e);
276
277    if (e->code_unit_size != SingleByte || (e->has_encoding_decl && (!at_UTF_8(e->encoding)))){
278        fprintf(stderr,"Sorry, this xmlwf demo only works for UTF-8.\n");
279        exit(-1);
280    }
281  }
282  else {
283    fprintf(stderr,"Sorry, this xmlwf demo does not process EBCDIC.\n");
284        exit(-1);
285  }
286
287  if (e->content_start != 0) {
288        memmove(&srcbuf[0], &srcbuf[e->content_start], chars_read - e->content_start);
289        buf_pos = e->content_start;
290        buffer_base = buf_pos;
291        if (chars_avail == BUFFER_SIZE) {
292                chars_read = chars_read - e->content_start +
293                             fread(&srcbuf[chars_read-e->content_start], 1, e->content_start, infile);
294                chars_avail = chars_read;
295                if (chars_avail > BUFFER_SIZE) chars_avail = BUFFER_SIZE;
296        }
297        else {
298          chars_read -=e->content_start;
299          chars_avail -=e->content_start;
300        }
301  }
302
303@stream_stmts
304
305
306/* Full Buffers */
307    while (chars_avail == BUFFER_SIZE) {
308      PERF_SEC_START(parser_timer);
309      for (int blk = 0; blk < SEGMENT_BLOCKS; blk++) {
310          block_base = blk*BLOCK_SIZE;
311          s2p_do_block((BytePack *) &srcbuf[block_base], basis_bits);
312          @block_stmts
313          postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, tag_Callouts, hash_data, chars_avail);
314      }
315      matcher.StreamScan(chars_avail);
316      matcher.Advance_buffer();
317      tracker.Advance_buffer();
318#ifndef CACHE_PERF
319    PERF_SEC_END(parser_timer, chars_avail);
320#else
321    PERF_SEC_END(parser_timer, 1);
322#endif
323
324      int bytes_left = chars_read - chars_avail;
325      memmove(buf, &srcbuf[BUFFER_SIZE - OVERLAP_BUFSIZE], bytes_left + OVERLAP_BUFSIZE);
326      chars_read = fread(&srcbuf[bytes_left],1, BUFFER_SIZE + OVERLAP_BUFSIZE - bytes_left, infile) + bytes_left;
327
328      chars_avail = chars_read;
329      if (chars_avail > BUFFER_SIZE) chars_avail = BUFFER_SIZE;
330      buf_pos += chars_avail;
331      buffer_base = buf_pos;
332
333  }
334/* Final Partial Buffer */
335    PERF_SEC_START(parser_timer);
336
337    block_pos = 0;
338    int remaining = chars_avail;
339/* Full Blocks */
340    while (remaining >= BLOCK_SIZE) {
341          block_base = block_pos;
342          s2p_do_block((BytePack *) &srcbuf[block_pos], basis_bits);
343          @block_stmts
344          postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, tag_Callouts, hash_data, chars_avail);
345          block_pos += BLOCK_SIZE;
346          remaining -= BLOCK_SIZE;
347    }
348    block_base = block_pos;
349    if (remaining > 0 || @any_carry) {
350          EOF_mask = bitblock::srl(simd<1>::constant<1>(), convert(BLOCK_SIZE-remaining));
351          s2p_do_final_block((BytePack *) &srcbuf[block_pos], basis_bits, EOF_mask);
352          @final_block_stmts
353          postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, tag_Callouts, hash_data, chars_avail);
354    }
355    buf_pos += chars_avail;
356    buffer_base = buf_pos;
357
358    matcher.StreamScan(chars_avail);
359    matcher.Advance_buffer();
360    tracker.Advance_buffer();
361
362#ifndef CACHE_PERF
363    PERF_SEC_END(parser_timer, chars_avail);
364#else
365    PERF_SEC_END(parser_timer, 1);
366#endif
367    if (matcher.depth != 0) {
368      fprintf(stderr, "tag matching error (depth %i) at position %i\n", matcher.depth, buffer_base);
369      exit(-1);
370    }
371//  print_GIDS();
372#if PRINT_SYMBOL_DISTRIBUTION
373    pbgs_symbol_table.Print_Symbol_Table_Distribution();
374#endif
375}
Note: See TracBrowser for help on using the repository browser.