source: proto/SymbolTable/symtab_identity_template.cpp @ 4740

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

Fixed macro names. I got L1 and L2 mixed up

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