source: proto/SymbolTable/symtab_symbol_stat_gather.cpp @ 1766

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

Fixed Makefile and added s2p include

File size: 21.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#include <limits.h>
7
8//#define STREAMSCAN
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        //int Events[NUM_EVENTS] = {PAPI_L2_DCM};
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_starts;
30int previous_block_last_elem_start;
31BytePack hashvalues[2];
32
33vector <int> gids;
34vector <int> symbol_lgth;
35vector <int> density_starts;
36vector <int> density_ends;
37PBGSIdentitySymbolTable pbgs_symbol_table;
38
39
40#ifdef STREAMSCAN
41static inline int NameStrt_check(int pos);
42static inline int Name_check(int pos);
43static inline int PIName_check(int pos);
44static inline int CD_check(int pos);
45static inline int GenRef_check(int pos);
46static inline int HexRef_check(int pos);
47static inline int DecRef_check(int pos);
48static inline int AttRef_check(int pos);
49#endif
50
51static inline void postprocess_do_block(Lex & lex, CtCDPI_Callouts & ctCDPI_Callouts, Ref_Callouts & ref_Callouts, Check_streams & check_streams, int chars_avail);
52
53void do_process(FILE *infile, FILE *outfile);
54
55template <int L> static inline void validate_block_length_grouping(BitBlockForwardIterator & start, int block_base);
56
57template <int L> static inline int ElemEnd_grouping(int pos);
58
59void symbol_statistic_gathering();
60void store_symbol_density(int symbol_start, int symbol_end);
61vector<int> compute_symbol_density(vector<int> density_starts, vector<int> density_ends);
62
63int main(int argc, char * argv[]) {
64
65    char * infilename, * outfilename;
66    FILE *infile, *outfile;
67
68    getFilenames(argc, argv, infilename, outfilename);
69    openInputOutputFiles(infilename, outfilename,
70                         infile, outfile);
71
72//      PERF_SEC_BIND(1);
73
74    PERF_SEC_INIT(parser_timer);
75
76    // store symbols form text to Symbol Table
77    do_process(infile, outfile);
78
79    PERF_SEC_DUMP(parser_timer);
80
81    PERF_SEC_DESTROY(parser_timer);
82
83    symbol_statistic_gathering();
84
85#if PRINT_SYMBOL_DISTRIBUTION
86//    print_GIDS();
87    pbgs_symbol_table.Print_Symbol_Table_Distribution();
88#endif
89
90    fclose(infile);
91    fclose(outfile);
92
93    return 0;
94}
95
96template <int L>
97static inline int ElemEnd_grouping(int end) {
98    int start = end - L;
99    int hashvalue = compute_hash_value(L, start - block_base, hashvalues);
100    int gid = pbgs_symbol_table.Lookup_or_Insert_Name<L>(source + start, hashvalue);
101    gids.push_back(gid);
102    symbol_lgth.push_back(L);
103    store_symbol_density(start, end);
104#if DEBUG
105    char* symbol = new char[L+1];
106    strncpy ( symbol, source + start, L );
107    symbol[L] ='\0';
108    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 );
109    delete symbol; symbol = 0;
110#endif
111    return 0;
112}
113
114template<>
115inline int ElemEnd_grouping<17>(int end) {
116    int start = ScanBackwardPos (&elem_starts, end - block_base, previous_block_last_elem_start) + block_base;
117    int lgth = end - start;
118    int hashvalue = compute_hash_value(lgth, start - block_base, hashvalues);
119    int gid = 0;
120
121//    if (lgth < 32)
122//    {
123//      gid = pbgs_symbol_table.Lookup_or_Insert_Name_32(source + start, hashvalue, lgth);
124//    }
125//    else
126    {
127        gid = pbgs_symbol_table.Lookup_or_Insert_Name(source + start, hashvalue, lgth);
128        symbol_lgth.push_back(lgth);
129        store_symbol_density(start, end);
130    }
131    gids.push_back(gid);
132#if DEBUG
133    char* symbol = new char[lgth+1];
134    strncpy ( symbol, source + start, lgth );
135    symbol[lgth] ='\0';
136    printf ("%s | start: %i[%i] | end: %i[%i] | lgth: %i | hashvalue: %i | gid: %i | symbol: %s\n", __FUNCTION__, start, start - block_base, end, end - block_base, lgth, hashvalue, gid, symbol);
137#endif
138    return 0;
139}
140
141template <int L>
142static inline void validate_block_length_grouping(BitBlockForwardIterator & start, int block_base) {
143
144    BitBlockForwardIterator end;
145    int block_pos;
146
147    while(start != end) {
148        block_pos = block_base + *start;
149        ElemEnd_grouping<L>(block_pos);
150        start++;
151    }
152}
153
154int min(vector<int> v)
155{
156    int result = INT_MAX;
157    for (vector<int>::iterator it = v.begin(); it < v.end(); it++)
158    {
159        int number = *it;
160
161        if (number < result)
162        {
163            result = number;
164        }
165    }
166    return result;
167}
168
169int max(vector<int> v)
170{
171    int result = INT_MIN;
172    for (vector<int>::iterator it = v.begin(); it < v.end(); it++)
173    {
174        int number = *it;
175
176        if (number > result)
177        {
178            result = number;
179        }
180    }
181    return result;
182}
183
184double average(vector<int> v)
185{
186    double result = 0.0;
187    for (vector<int>::iterator it = v.begin(); it < v.end(); it++)
188    {
189        int number = *it;
190
191        result += number;
192    }
193    return result/v.size();
194}
195
196vector<int> compute_symbol_density(vector<int> density_starts, vector<int> density_ends)
197{
198    vector<int> symbol_density;
199    int size = density_starts.size();
200
201    for(int i = 0; i < size; i++)
202    {
203        int start, end, density;
204        start = density_starts[i];
205        end = density_ends[i];
206        density = end - start;
207
208        symbol_density.push_back(density);
209    }
210    return symbol_density;
211}
212
213void store_symbol_density(int symbol_start, int symbol_end)
214{
215    if (!density_starts.size())
216    {
217        density_starts.push_back(0);
218    }
219
220    density_ends.push_back(symbol_start);
221
222    if (symbol_end > -1)
223    {
224        density_starts.push_back(symbol_end);
225    }
226}
227
228void symbol_statistic_gathering()
229{
230//    symbol counts
231    printf ("Total symbols: %i\n", gids.size());
232
233//    symbol length
234    printf ("Min length: %i \n", min(symbol_lgth));
235    printf ("Max length: %i \n", max(symbol_lgth));
236    printf ("Avg length: %f \n", average(symbol_lgth));
237
238//    frequency of unique symbols
239    printf ("Total unique symbols: %i\n", max(gids));
240
241//    symbol density (symbol separation distance)
242    vector<int> symbol_density = compute_symbol_density(density_starts, density_ends);
243    printf ("Avg symbol density: %f\n", average(symbol_density));
244}
245
246static 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){
247    tracker.StoreNewlines(lex.LF);
248
249    elem_starts = tag_Callouts.ElemName_starts;
250    hashvalues[1] = hash_data.Hash_value;
251
252#ifdef USE_ITER
253    BitBlockForwardIterator iter;
254
255    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_1) )
256    {
257        iter.init(&tag_Callouts.ElemName_ends_1);
258        validate_block_length_grouping<1>(iter, block_base);
259    }
260
261    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_2) )
262    {
263        iter.init(&tag_Callouts.ElemName_ends_2);
264        validate_block_length_grouping<2>(iter, block_base);
265    }
266
267    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_3) )
268    {
269        iter.init(&tag_Callouts.ElemName_ends_3);
270        validate_block_length_grouping<3>(iter, block_base);
271    }
272
273    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_4) )
274    {
275        iter.init(&tag_Callouts.ElemName_ends_4);
276        validate_block_length_grouping<4>(iter, block_base);
277    }
278
279    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_5) )
280    {
281        iter.init(&tag_Callouts.ElemName_ends_5);
282        validate_block_length_grouping<5>(iter, block_base);
283    }
284
285    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_6) )
286    {
287        iter.init(&tag_Callouts.ElemName_ends_6);
288        validate_block_length_grouping<6>(iter, block_base);
289    }
290
291    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_7) )
292    {
293        iter.init(&tag_Callouts.ElemName_ends_7);
294        validate_block_length_grouping<7>(iter, block_base);
295    }
296
297    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_8) )
298    {
299        iter.init(&tag_Callouts.ElemName_ends_8);
300        validate_block_length_grouping<8>(iter, block_base);
301    }
302
303    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_9) )
304    {
305        iter.init(&tag_Callouts.ElemName_ends_9);
306        validate_block_length_grouping<9>(iter, block_base);
307    }
308
309    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_10) )
310    {
311        iter.init(&tag_Callouts.ElemName_ends_10);
312        validate_block_length_grouping<10>(iter, block_base);
313    }
314
315    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_11) )
316    {
317        iter.init(&tag_Callouts.ElemName_ends_11);
318        validate_block_length_grouping<11>(iter, block_base);
319    }
320
321    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_12) )
322    {
323        iter.init(&tag_Callouts.ElemName_ends_12);
324        validate_block_length_grouping<12>(iter, block_base);
325    }
326
327    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_13) )
328    {
329        iter.init(&tag_Callouts.ElemName_ends_13);
330        validate_block_length_grouping<13>(iter, block_base);
331    }
332
333    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_14) )
334    {
335        iter.init(&tag_Callouts.ElemName_ends_14);
336        validate_block_length_grouping<14>(iter, block_base);
337    }
338
339    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_15) )
340    {
341        iter.init(&tag_Callouts.ElemName_ends_15);
342        validate_block_length_grouping<15>(iter, block_base);
343    }
344
345    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_16) )
346    {
347        iter.init(&tag_Callouts.ElemName_ends_16);
348        validate_block_length_grouping<16>(iter, block_base);
349    }
350
351    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_17_and_longer) )
352    {
353        iter.init(&tag_Callouts.ElemName_ends_17_and_longer);
354        validate_block_length_grouping<17>(iter, block_base);
355    }
356
357    // Store the last starting position in case we hit boundary case
358    previous_block_last_elem_start = - count_reverse_zeroes (elem_starts);
359
360    //copy current hash value data as previous one.
361    memmove (&hashvalues[0], &hashvalues[1], 16);
362
363    if (bitblock_has_bit(simd_or(check_streams.non_ascii_name_starts, check_streams.non_ascii_names))) {
364            iter.init(&check_streams.non_ascii_name_starts);
365            validate_block(iter, block_base, NameStrt_check);
366            iter.init(&check_streams.non_ascii_names);
367            validate_block(iter, block_base, Name_check);
368    }
369    if (bitblock_has_bit(ctCDPI_Callouts.PI_name_starts)){
370            iter.init(&(ctCDPI_Callouts.PI_name_starts));
371            validate_block(iter, block_base, buffer_base, PIName_check);
372    }
373    if (bitblock_has_bit(ctCDPI_Callouts.CD_starts)){
374            iter.init(&ctCDPI_Callouts.CD_starts);
375            validate_block(iter, block_base, CD_check);
376    }
377    if(bitblock_has_bit(ref_Callouts.GenRef_starts)){
378            iter.init(&ref_Callouts.GenRef_starts);
379            validate_block(iter, block_base, GenRef_check);
380    }
381    if(bitblock_has_bit(ref_Callouts.DecRef_starts)){
382            iter.init(&ref_Callouts.DecRef_starts);
383            validate_block(iter, block_base, DecRef_check);
384    }
385    if(bitblock_has_bit(ref_Callouts.HexRef_starts)){
386            iter.init(&ref_Callouts.HexRef_starts);
387            validate_block(iter, block_base, HexRef_check);
388    }
389    if(bitblock_has_bit(check_streams.att_refs)){
390            iter.init(&check_streams.att_refs);
391            validate_block(iter, block_base, AttRef_check);
392    }
393
394    if(error_tracker.Has_Noted_Error()){
395        int error_line, error_column;
396        tracker.get_Line_and_Column(error_tracker.Noted_Pos_In_Block(), error_line, error_column);
397        ReportError(error_tracker.Noted_Error_Msg(), error_line, error_column);
398        exit(-1);
399    }
400
401    matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
402    tracker.AdvanceBlock();
403#else
404    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_1) )
405    {
406        BitBlockForwardIterator iter_length_grouping_1(&tag_Callouts.ElemName_ends_1);
407        validate_block_length_grouping<1>(iter_length_grouping_1, block_base);
408    }
409
410    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_2) )
411    {
412        BitBlockForwardIterator iter_length_grouping_2(&tag_Callouts.ElemName_ends_2);
413        validate_block_length_grouping<2>(iter_length_grouping_2, block_base);
414    }
415
416    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_3) )
417    {
418        BitBlockForwardIterator iter_length_grouping_3(&tag_Callouts.ElemName_ends_3);
419        validate_block_length_grouping<3>(iter_length_grouping_3, block_base);
420    }
421
422    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_4) )
423    {
424        BitBlockForwardIterator iter_length_grouping_4(&tag_Callouts.ElemName_ends_4);
425        validate_block_length_grouping<4>(iter_length_grouping_4, block_base);
426    }
427
428    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_5) )
429    {
430        BitBlockForwardIterator iter_length_grouping_5(&tag_Callouts.ElemName_ends_5);
431        validate_block_length_grouping<5>(iter_length_grouping_5, block_base);
432    }
433
434    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_6) )
435    {
436        BitBlockForwardIterator iter_length_grouping_6(&tag_Callouts.ElemName_ends_6);
437        validate_block_length_grouping<6>(iter_length_grouping_6, block_base);
438    }
439
440    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_7) )
441    {
442        BitBlockForwardIterator iter_length_grouping_7(&tag_Callouts.ElemName_ends_7);
443        validate_block_length_grouping<7>(iter_length_grouping_7, block_base);
444    }
445
446    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_8) )
447    {
448        BitBlockForwardIterator iter_length_grouping_8(&tag_Callouts.ElemName_ends_8);
449        validate_block_length_grouping<8>(iter_length_grouping_8, block_base);
450    }
451
452    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_9) )
453    {
454        BitBlockForwardIterator iter_length_grouping_9(&tag_Callouts.ElemName_ends_9);
455        validate_block_length_grouping<9>(iter_length_grouping_9, block_base);
456    }
457
458    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_10) )
459    {
460        BitBlockForwardIterator iter_length_grouping_10(&tag_Callouts.ElemName_ends_10);
461        validate_block_length_grouping<10>(iter_length_grouping_10, block_base);
462    }
463
464    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_11) )
465    {
466        BitBlockForwardIterator iter_length_grouping_11(&tag_Callouts.ElemName_ends_11);
467        validate_block_length_grouping<11>(iter_length_grouping_11, block_base);
468    }
469
470    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_12) )
471    {
472        BitBlockForwardIterator iter_length_grouping_12(&tag_Callouts.ElemName_ends_12);
473        validate_block_length_grouping<12>(iter_length_grouping_12, block_base);
474    }
475
476    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_13) )
477    {
478        BitBlockForwardIterator iter_length_grouping_13(&tag_Callouts.ElemName_ends_13);
479        validate_block_length_grouping<13>(iter_length_grouping_13, block_base);
480    }
481
482    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_14) )
483    {
484        BitBlockForwardIterator iter_length_grouping_14(&tag_Callouts.ElemName_ends_14);
485        validate_block_length_grouping<14>(iter_length_grouping_14, block_base);
486    }
487
488    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_15) )
489    {
490        BitBlockForwardIterator iter_length_grouping_15(&tag_Callouts.ElemName_ends_15);
491        validate_block_length_grouping<15>(iter_length_grouping_15, block_base);
492    }
493
494    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_16) )
495    {
496        BitBlockForwardIterator iter_length_grouping_16(&tag_Callouts.ElemName_ends_16);
497        validate_block_length_grouping<16>(iter_length_grouping_16, block_base);
498    }
499
500    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_17_and_longer) )
501    {
502        BitBlockForwardIterator iter_length_grouping_remaining(&tag_Callouts.ElemName_ends_17_and_longer);
503        validate_block_length_grouping<17>(iter_length_grouping_remaining, block_base);
504    }
505
506    // Store the last starting position in case we hit boundary case
507    previous_block_last_elem_start = - count_reverse_zeroes (elem_starts);
508
509    //copy current hash value data as previous one.
510    memmove (&hashvalues[0], &hashvalues[1], 16);
511
512    if (bitblock_has_bit(simd_or(check_streams.non_ascii_name_starts, check_streams.non_ascii_names))) {
513        BitBlockForwardIterator iter_NameStrt_check(&check_streams.non_ascii_name_starts);
514        validate_block(iter_NameStrt_check, block_base, NameStrt_check);
515        BitBlockForwardIterator iter_Name_check(&check_streams.non_ascii_names);
516        validate_block(iter_Name_check, block_base, Name_check);
517    }
518    if (bitblock_has_bit(ctCDPI_Callouts.PI_name_starts)){
519        BitBlockForwardIterator iter_PI_name_starts(&(ctCDPI_Callouts.PI_name_starts));
520        validate_block(iter_PI_name_starts, block_base, buffer_base, PIName_check);
521
522    }
523    if (bitblock_has_bit(ctCDPI_Callouts.CD_starts)){
524        BitBlockForwardIterator iter_CD_check(&ctCDPI_Callouts.CD_starts);
525        validate_block(iter_CD_check, block_base, CD_check);
526    }
527    if(bitblock_has_bit(ref_Callouts.GenRef_starts)){
528        BitBlockForwardIterator iter_GenRef_check(&ref_Callouts.GenRef_starts);
529        validate_block(iter_GenRef_check, block_base, GenRef_check);
530    }
531    if(bitblock_has_bit(ref_Callouts.DecRef_starts)){
532        BitBlockForwardIterator iter_DecRef_check(&ref_Callouts.DecRef_starts);
533        validate_block(iter_DecRef_check, block_base, DecRef_check);
534    }
535    if(bitblock_has_bit(ref_Callouts.HexRef_starts)){
536        BitBlockForwardIterator iter_HexRef_check(&ref_Callouts.HexRef_starts);
537        validate_block(iter_HexRef_check, block_base, HexRef_check);
538    }
539    if(bitblock_has_bit(check_streams.att_refs)){
540        BitBlockForwardIterator iter_AttRef_check(&check_streams.att_refs);
541        validate_block(iter_AttRef_check, block_base, AttRef_check);
542    }
543
544    if(error_tracker.Has_Noted_Error()){
545        int error_line, error_column;
546        tracker.get_Line_and_Column(error_tracker.Noted_Pos_In_Block(), error_line, error_column);
547        ReportError(error_tracker.Noted_Error_Msg(), error_line, error_column);
548        exit(-1);
549    }
550
551    matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
552    tracker.AdvanceBlock();
553#endif
554}
555
556void do_process(FILE *infile, FILE *outfile) {
557
558@decl
559  int buf_pos = 0;
560  int block_pos = 0;
561  int chars_avail = 0;
562  int check_pos = 0;
563  int chars_read = 0;
564  BytePack buf[(BUFFER_SIZE+BLOCK_SIZE+OVERLAP_BUFSIZE*2)/sizeof(BitBlock)];
565
566  char * srcbuf = ((char *) buf) + OVERLAP_BUFSIZE;
567  buffer_base = buf_pos;
568  source = srcbuf;
569  chars_read = fread((void *)srcbuf, 1, BUFFER_SIZE + OVERLAP_BUFSIZE, infile);
570  chars_avail = chars_read;
571  if (chars_avail > BUFFER_SIZE) chars_avail = BUFFER_SIZE;
572
573  matcher.setSrc(srcbuf);
574
575  if(chars_read<4){
576    fprintf(stderr,"File is too short. Not well formed.\n");
577    exit(-1);
578  }
579
580  Entity_Info * e = new Entity_Info;
581  e->AnalyzeSignature((unsigned char *)srcbuf);
582
583  if (e->code_unit_base == ASCII) {
584
585    XML_Decl_Parser<ASCII> decl_parser((unsigned char *)srcbuf);
586
587    decl_parser.ReadXMLInfo(*e);
588
589    if (e->code_unit_size != SingleByte || (e->has_encoding_decl && (!at_UTF_8(e->encoding)))){
590        fprintf(stderr,"Sorry, this xmlwf demo only works for UTF-8.\n");
591        exit(-1);
592    }
593  }
594  else {
595    fprintf(stderr,"Sorry, this xmlwf demo does not process EBCDIC.\n");
596        exit(-1);
597  }
598
599  if (e->content_start != 0) {
600        memmove(&srcbuf[0], &srcbuf[e->content_start], chars_read - e->content_start);
601        buf_pos = e->content_start;
602        buffer_base = buf_pos;
603        if (chars_avail == BUFFER_SIZE) {
604                chars_read = chars_read - e->content_start +
605                             fread(&srcbuf[chars_read-e->content_start], 1, e->content_start, infile);
606                chars_avail = chars_read;
607                if (chars_avail > BUFFER_SIZE) chars_avail = BUFFER_SIZE;
608        }
609        else {
610          chars_read -=e->content_start;
611          chars_avail -=e->content_start;
612        }
613  }
614
615@stream_stmts
616
617/* Full Buffers */
618    while (chars_avail == BUFFER_SIZE) {
619      PERF_SEC_START(parser_timer);
620      for (int blk = 0; blk < SEGMENT_BLOCKS; blk++) {
621          block_base = blk*BLOCK_SIZE;
622          s2p_do_block((BytePack *) &srcbuf[block_base], basis_bits);
623          @block_stmts
624          postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, tag_Callouts, hash_data, chars_avail);
625      }
626      matcher.StreamScan(chars_avail);
627      matcher.Advance_buffer();
628      tracker.Advance_buffer();
629      PERF_SEC_END(parser_timer, chars_avail);
630
631      int bytes_left = chars_read - chars_avail;
632      memmove(buf, &srcbuf[BUFFER_SIZE - OVERLAP_BUFSIZE], bytes_left + OVERLAP_BUFSIZE);
633      chars_read = fread(&srcbuf[bytes_left],1, BUFFER_SIZE + OVERLAP_BUFSIZE - bytes_left, infile) + bytes_left;
634
635      chars_avail = chars_read;
636      if (chars_avail > BUFFER_SIZE) chars_avail = BUFFER_SIZE;
637      buf_pos += chars_avail;
638      buffer_base = buf_pos;
639
640  }
641/* Final Partial Buffer */
642    PERF_SEC_START(parser_timer);
643
644    block_pos = 0;
645    int remaining = chars_avail;
646/* Full Blocks */
647    while (remaining >= BLOCK_SIZE) {
648          block_base = block_pos;
649          s2p_do_block((BytePack *) &srcbuf[block_pos], basis_bits);
650          @block_stmts
651          postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, tag_Callouts, hash_data, chars_avail);
652          block_pos += BLOCK_SIZE;
653          remaining -= BLOCK_SIZE;
654    }
655    block_base = block_pos;
656    if (remaining > 0 || @any_carry) {
657          EOF_mask = bitblock::srl(simd<1>::constant<1>(), convert(BLOCK_SIZE-remaining));
658          s2p_do_final_block((BytePack *) &srcbuf[block_pos], basis_bits, EOF_mask);
659          @final_block_stmts
660          postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, tag_Callouts, hash_data, chars_avail);
661    }
662    buf_pos += chars_avail;
663    buffer_base = buf_pos;
664
665    store_symbol_density(buffer_base, -1);
666
667    matcher.StreamScan(chars_avail);
668    matcher.Advance_buffer();
669    tracker.Advance_buffer();
670
671    PERF_SEC_END(parser_timer, chars_avail);
672    if (matcher.depth != 0) {
673      fprintf(stderr, "tag matching error (depth %i) at position %i\n", matcher.depth, buffer_base);
674      exit(-1);
675    }
676}
677
678
Note: See TracBrowser for help on using the repository browser.