source: proto/SymbolTable/symtab_pbgs_log_template.cpp @ 4373

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

Fixed macro names. I got L1 and L2 mixed up

File size: 15.3 KB
Line 
1#define USE_MASK_COMPARE    //Comparison using masking technique.
2
3#include "../common_definitions.h"
4#include <pbgs_log_symbol_table.h>
5
6#include "../symtab_common_functions.h"
7#include "../xmlwf_common_functions.h"
8
9#ifdef BUFFER_PROFILING
10        BOM_Table * parser_timer;
11
12#elif CODE_CLOCKER
13        #define NUM_EVENTS 1
14//      int Events[NUM_EVENTS] = {PAPI_TOT_CYC};
15#ifdef L2_PERF
16        int Events[NUM_EVENTS] = {PAPI_L2_DCM};
17#elif L1_PERF
18        int Events[NUM_EVENTS] = {PAPI_L1_DCM};
19#else
20        int Events[NUM_EVENTS] = {PAPI_BR_MSP};
21#endif
22        int cal_size = 20;
23        CC * parser_timer = new CC(Events,NUM_EVENTS,cal_size);
24#else
25        void * parser_timer;
26#endif
27
28int block_base=0;
29int buffer_base=0;
30int buffer_last;
31
32TagMatcher matcher;
33
34BitBlock elem_starts;
35int previous_block_last_elem_start;
36BytePack hashvalues[2];
37
38vector <int> gids;
39PBGSLogSymbolTable 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
45template <int L> static inline void validate_block_length_grouping(BitBlockForwardIterator & start, int block_base);
46
47template <int L> static inline int ElemEnd_grouping(int pos, int length);
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    return 0;
76}
77
78template <int L>
79static inline int ElemEnd_grouping(int pos, int length) {
80    return 0;
81}
82
83// length = 1
84template <>
85inline int ElemEnd_grouping<1>(int pos, int length) {
86    int start = block_base + pos - length;
87    int hashvalue = compute_hash_value(length, start - block_base, hashvalues);
88    int gid = pbgs_symbol_table.Lookup_or_Insert_Name_1(source + start, hashvalue);
89    gids.push_back(gid);
90#if DEBUG
91    int L = length;
92    int end = start - L;
93    char* symbol = new char[L+1];
94    strncpy ( symbol, source + start, L );
95    symbol[L] ='\0';
96    printf ("%s | start: %i[%i] | end: %i[%i] | gid: %i | hashvalue: %i | symbol: %s\n", __FUNCTION__, start, start-buffer_base, end, end-buffer_base, gid, hashvalue, symbol );
97    delete symbol; symbol = 0;
98#endif
99    return 0;
100}
101
102// length = 2
103template <>
104inline int ElemEnd_grouping<2>(int pos, int length) {
105    int start = block_base + pos - length;
106    int hashvalue = compute_hash_value(length, start - block_base, hashvalues);
107    int gid = pbgs_symbol_table.Lookup_or_Insert_Name_2(source + start, hashvalue);
108    gids.push_back(gid);
109#if DEBUG
110    int L = 2;
111    int end = start - L;
112    char* symbol = new char[L+1];
113    strncpy ( symbol, source + start, L );
114    symbol[L] ='\0';
115    printf ("%s | start: %i[%i] | end: %i[%i] | gid: %i | hashvalue: %i | symbol: %s\n", __FUNCTION__, start, start-buffer_base, end, end-buffer_base, gid, hashvalue, symbol );
116    delete symbol; symbol = 0;
117#endif
118    return 0;
119}
120
121
122// length in [3,4]
123template <>
124inline int ElemEnd_grouping<4>(int pos, int L) {
125    int start = pos + block_base;
126    int hashvalue = compute_hash_value(L, pos, hashvalues);
127    int gid = pbgs_symbol_table.Lookup_or_Insert_Name_4(source + start, hashvalue, L);
128    gids.push_back(gid);
129#if DEBUG
130    int end = start + L;
131    char* symbol = new char[L+1];
132    strncpy ( symbol, source + start, L );
133    symbol[L] ='\0';
134    printf ("%s | start: %i[%i] | end: %i[%i] | gid: %i | hashvalue: %i | symbol: %s\n", __FUNCTION__, start, start-buffer_base, end, end-buffer_base, gid, hashvalue, symbol );
135    delete symbol; symbol = 0;
136#endif
137    return 0;
138}
139
140// length in [5,8]
141template <>
142inline int ElemEnd_grouping<8>(int pos,  int L) {
143    int start = pos + block_base;
144    int hashvalue = compute_hash_value(L, pos, hashvalues);
145    int gid = pbgs_symbol_table.Lookup_or_Insert_Name_8(source + start, hashvalue, L);
146    gids.push_back(gid);
147#if DEBUG
148    int end = start + L;
149    char* symbol = new char[L+1];
150    strncpy ( symbol, source + start, L );
151    symbol[L] ='\0';
152    printf ("%s | start: %i[%i] | end: %i[%i] | gid: %i | hashvalue: %i | symbol: %s\n", __FUNCTION__, start, start-buffer_base, end, end-buffer_base, gid, hashvalue, symbol );
153    delete symbol; symbol = 0;
154#endif
155    return 0;
156}
157
158// length in [9,16]
159template <>
160inline int ElemEnd_grouping<16>(int pos, int L) {
161    int start = pos + block_base;
162    int hashvalue = compute_hash_value(L, pos, hashvalues);
163    int gid = pbgs_symbol_table.Lookup_or_Insert_Name_16(source + start, hashvalue, L);
164    gids.push_back(gid);
165#if DEBUG
166    int end = start + L;
167    char* symbol = new char[L+1];
168    strncpy ( symbol, source + start, L );
169    symbol[L] ='\0';
170    printf ("%s | start: %i[%i] | end: %i[%i] | gid: %i | hashvalue: %i | symbol: %s\n", __FUNCTION__, start, start-buffer_base, end, end-buffer_base, gid, hashvalue, symbol );
171    delete symbol; symbol = 0;
172#endif
173    return 0;
174}
175
176// length > 16
177template <>
178inline int ElemEnd_grouping<17>(int pos, int lgth) {
179    int start = pos + block_base;
180    int hashvalue = compute_hash_value(lgth, start - block_base, hashvalues);
181    int gid = 0;
182
183//    if (lgth < 32)
184//    {
185//      gid = pbgs_symbol_table.Lookup_or_Insert_Name_32(source + start, hashvalue, lgth);
186//    }
187//    else
188    {
189        gid = pbgs_symbol_table.Lookup_or_Insert_Name(source + start, hashvalue, lgth);
190    }
191    gids.push_back(gid);
192#if DEBUG
193    char* symbol = new char[lgth+1];
194    strncpy ( symbol, source + start, lgth );
195    symbol[lgth] ='\0';
196    printf ("%s | start: %i[%i] | lgth: %i | hashvalue: %i | gid: %i | symbol: %s\n", __FUNCTION__, start, start - block_base, lgth, hashvalue, gid, symbol);
197#endif
198    return 0;
199}
200
201// L = 4, pass in bitstream for symbols length [3,4]
202// L = 8, pass in bitstream for symbols length [5,8]
203// L = 16, pass in bitstream for symbols length [9,16]
204// L = 17, pass in bitstream for symbols length longer than 16
205template <int L>
206static inline void validate_block_length_grouping(BitBlockForwardIterator & start, int block_base) {
207
208    BitBlockForwardIterator end;
209    int end_pos, start_pos, length;
210
211    while(start != end) {
212        end_pos = /*block_base + */*start;
213        start_pos = ScanBackwardPos (&elem_starts, end_pos, previous_block_last_elem_start);
214        length = end_pos - start_pos;
215        ElemEnd_grouping<L>(start_pos, length);
216        start++;
217    }
218}
219
220// pass in bitstream for symbols length 1
221template <>
222inline void validate_block_length_grouping<1>(BitBlockForwardIterator & start, int block_base) {
223
224    BitBlockForwardIterator end;
225    int end_pos, start_pos, length;
226
227    while(start != end) {
228        end_pos = /*block_base + */*start;
229        start_pos = ScanBackwardPos (&elem_starts, end_pos, previous_block_last_elem_start);
230        length = end_pos - start_pos;
231        ElemEnd_grouping<1>(end_pos, 1);
232        start++;
233    }
234}
235
236// pass in bitstream for symbols length 2
237template <>
238inline void validate_block_length_grouping<2>(BitBlockForwardIterator & start, int block_base) {
239
240    BitBlockForwardIterator end;
241    int end_pos, start_pos, length;
242
243    while(start != end) {
244        end_pos = /*block_base + */*start;
245        start_pos = ScanBackwardPos (&elem_starts, end_pos, previous_block_last_elem_start);
246        length = end_pos - start_pos;
247        ElemEnd_grouping<2>(end_pos, 2);
248        start++;
249    }
250}
251
252static 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){
253
254    tracker.StoreNewlines(lex.LF);
255
256    elem_starts = tag_Callouts.ElemName_starts;
257    hashvalues[1] = hash_data.Hash_value;
258
259    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_1) )
260    {
261        BitBlockForwardIterator iter_length_grouping_1(&tag_Callouts.ElemName_ends_1);
262        validate_block_length_grouping<1>(iter_length_grouping_1, block_base);
263    }
264
265    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_2) )
266    {
267        BitBlockForwardIterator iter_length_grouping_2(&tag_Callouts.ElemName_ends_2);
268        validate_block_length_grouping<2>(iter_length_grouping_2, block_base);
269    }
270
271    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_3_to_4) )
272    {
273        BitBlockForwardIterator iter_length_grouping_4(&tag_Callouts.ElemName_ends_3_to_4);
274        validate_block_length_grouping<4>(iter_length_grouping_4, block_base);
275    }
276
277    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_5_to_8) )
278    {
279        BitBlockForwardIterator iter_length_grouping_8(&tag_Callouts.ElemName_ends_5_to_8);
280        validate_block_length_grouping<8>(iter_length_grouping_8, block_base);
281    }
282
283    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_9_to_16) )
284    {
285        BitBlockForwardIterator iter_length_grouping_16(&tag_Callouts.ElemName_ends_9_to_16);
286        validate_block_length_grouping<16>(iter_length_grouping_16, block_base);
287    }
288
289    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_17_and_longer) )
290    {
291        BitBlockForwardIterator iter_length_grouping_remaining(&tag_Callouts.ElemName_ends_17_and_longer);
292        validate_block_length_grouping<17>(iter_length_grouping_remaining, block_base);
293    }
294
295    // Store the last starting position in case we hit boundary case
296    previous_block_last_elem_start = - count_reverse_zeroes (elem_starts);
297
298    //copy current hash value data as previous one.
299    memmove (&hashvalues[0], &hashvalues[1], 16);
300
301    if (bitblock_has_bit(simd_or(check_streams.non_ascii_name_starts, check_streams.non_ascii_names))) {
302        BitBlockForwardIterator iter_NameStrt_check(&check_streams.non_ascii_name_starts);
303        validate_block(iter_NameStrt_check, block_base, NameStrt_check);
304        BitBlockForwardIterator iter_Name_check(&check_streams.non_ascii_names);
305        validate_block(iter_Name_check, block_base, Name_check);
306    }
307    if (bitblock_has_bit(ctCDPI_Callouts.PI_name_starts)){
308        BitBlockForwardIterator iter_PI_name_starts(&(ctCDPI_Callouts.PI_name_starts));
309        validate_block(iter_PI_name_starts, block_base, buffer_base, PIName_check);
310    }
311    if (bitblock_has_bit(ctCDPI_Callouts.CD_starts)){
312        BitBlockForwardIterator iter_CD_check(&ctCDPI_Callouts.CD_starts);
313        validate_block(iter_CD_check, block_base, CD_check);
314    }
315    if(bitblock_has_bit(ref_Callouts.GenRef_starts)){
316        BitBlockForwardIterator iter_GenRef_check(&ref_Callouts.GenRef_starts);
317        validate_block(iter_GenRef_check, block_base, GenRef_check);
318    }
319    if(bitblock_has_bit(ref_Callouts.DecRef_starts)){
320        BitBlockForwardIterator iter_DecRef_check(&ref_Callouts.DecRef_starts);
321        validate_block(iter_DecRef_check, block_base, DecRef_check);
322    }
323    if(bitblock_has_bit(ref_Callouts.HexRef_starts)){
324        BitBlockForwardIterator iter_HexRef_check(&ref_Callouts.HexRef_starts);
325        validate_block(iter_HexRef_check, block_base, HexRef_check);
326    }
327    if(bitblock_has_bit(check_streams.att_refs)){
328        BitBlockForwardIterator iter_AttRef_check(&check_streams.att_refs);
329        validate_block(iter_AttRef_check, block_base, AttRef_check);
330    }
331
332    if(error_tracker.Has_Noted_Error()){
333        int error_line, error_column;
334        tracker.get_Line_and_Column(error_tracker.Noted_Pos_In_Block(), error_line, error_column);
335        ReportError(error_tracker.Noted_Error_Msg(), error_line, error_column);
336        exit(-1);
337    }
338
339    matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
340    tracker.AdvanceBlock();
341
342}
343
344void do_process(FILE *infile, FILE *outfile) {
345
346@decl
347  int buf_pos = 0;
348  int block_pos = 0;
349  int errpos = 0;
350  int chars_avail = 0;
351  int check_pos = 0;
352  int chars_read = 0;
353  BytePack buf[(BUFFER_SIZE+BLOCK_SIZE+OVERLAP_BUFSIZE*2)/sizeof(SIMD_type)];
354
355  char * srcbuf = ((char *) buf) + OVERLAP_BUFSIZE;
356  buffer_base = buf_pos;
357  source = srcbuf;
358  chars_read = fread((void *)srcbuf, 1, BUFFER_SIZE + OVERLAP_BUFSIZE, infile);
359  chars_avail = chars_read;
360  if (chars_avail > BUFFER_SIZE) chars_avail = BUFFER_SIZE;
361
362  matcher.setSrc(srcbuf);
363
364  if(chars_read<4){
365    fprintf(stderr,"File is too short. Not well formed.\n");
366    exit(-1);
367  }
368
369  Entity_Info * e = new Entity_Info;
370  e->AnalyzeSignature((unsigned char *)srcbuf);
371
372  if (e->code_unit_base == ASCII) {
373
374    XML_Decl_Parser<ASCII> decl_parser((unsigned char *)srcbuf);
375
376    decl_parser.ReadXMLInfo(*e);
377
378    if (e->code_unit_size != SingleByte || (e->has_encoding_decl && (!at_UTF_8(e->encoding)))){
379        fprintf(stderr,"Sorry, this xmlwf demo only works for UTF-8.\n");
380        exit(-1);
381    }
382  }
383  else {
384    fprintf(stderr,"Sorry, this xmlwf demo does not process EBCDIC.\n");
385        exit(-1);
386  }
387
388  if (e->content_start != 0) {
389        memmove(&srcbuf[0], &srcbuf[e->content_start], chars_read - e->content_start);
390        buf_pos = e->content_start;
391        buffer_base = buf_pos;
392        if (chars_avail == BUFFER_SIZE) {
393                chars_read = chars_read - e->content_start +
394                             fread(&srcbuf[chars_read-e->content_start], 1, e->content_start, infile);
395                chars_avail = chars_read;
396                if (chars_avail > BUFFER_SIZE) chars_avail = BUFFER_SIZE;
397        }
398        else {
399          chars_read -=e->content_start;
400          chars_avail -=e->content_start;
401        }
402  }
403
404@stream_stmts
405
406/* Full Buffers */
407    while (chars_avail == BUFFER_SIZE) {
408      PERF_SEC_START(parser_timer);
409      for (int blk = 0; blk < SEGMENT_BLOCKS; blk++) {
410          block_base = blk*BLOCK_SIZE;
411          s2p_do_block((BytePack *) &srcbuf[block_base], basis_bits);
412          @block_stmts
413          postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, tag_Callouts, hash_data, chars_avail);
414      }
415      matcher.StreamScan(chars_avail);
416      matcher.Advance_buffer();
417      tracker.Advance_buffer();
418#ifndef CACHE_PERF
419    PERF_SEC_END(parser_timer, chars_avail);
420#else
421    PERF_SEC_END(parser_timer, 1);
422#endif
423
424      int bytes_left = chars_read - chars_avail;
425      //memmove(srcbuf, &srcbuf[BUFFER_SIZE], bytes_left);
426      memmove(buf, &srcbuf[BUFFER_SIZE - OVERLAP_BUFSIZE], bytes_left + OVERLAP_BUFSIZE);
427      chars_read = fread(&srcbuf[bytes_left],1, BUFFER_SIZE + OVERLAP_BUFSIZE - bytes_left, infile) + bytes_left;
428
429      chars_avail = chars_read;
430      if (chars_avail > BUFFER_SIZE) chars_avail = BUFFER_SIZE;
431      buf_pos += chars_avail;
432      buffer_base = buf_pos;
433
434  }
435/* Final Partial Buffer */
436    PERF_SEC_START(parser_timer);
437    block_pos = 0;
438    int remaining = chars_avail;
439/* Full Blocks */
440    while (remaining >= BLOCK_SIZE) {
441          block_base = block_pos;
442          s2p_do_block((BytePack *) &srcbuf[block_pos], basis_bits);
443          @block_stmts
444          postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, tag_Callouts, hash_data, chars_avail);
445          block_pos += BLOCK_SIZE;
446          remaining -= BLOCK_SIZE;
447    }
448    block_base = block_pos;
449    if (remaining > 0 || @any_carry) {
450          EOF_mask = bitblock::srl(simd<1>::constant<1>(), convert(BLOCK_SIZE-remaining));
451          s2p_do_final_block((BytePack *) &srcbuf[block_pos], basis_bits, EOF_mask);
452          @final_block_stmts
453          postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, tag_Callouts, hash_data, chars_avail);
454    }
455    buf_pos += chars_avail;
456    buffer_base = buf_pos;
457
458    matcher.StreamScan(chars_avail);
459    matcher.Advance_buffer();
460    tracker.Advance_buffer();
461#ifndef CACHE_PERF
462    PERF_SEC_END(parser_timer, chars_avail);
463#else
464    PERF_SEC_END(parser_timer, 1);
465#endif
466    if (matcher.depth != 0) {
467      fprintf(stderr, "tag matching error (depth %i) at position %i\n", matcher.depth, buffer_base);
468      exit(-1);
469    }
470
471}
Note: See TracBrowser for help on using the repository browser.