Ignore:
Timestamp:
Nov 15, 2011, 1:19:24 AM (8 years ago)
Author:
vla24
Message:

SymbolTable?: updated templates implementation to use BitBlockForwardIterator?. Fixed block boundary case handling for div2 grouping strategy.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • proto/SymbolTable/symtab_pbgs_identity_template.cpp

    r1683 r1684  
    1818int block_base=0;
    1919int buffer_base=0;
     20char * source;
    2021int buffer_last;
    21 char * source;
     22
    2223LineColTracker tracker;
    2324TagMatcher matcher;
     25ErrorTracker error_tracker;
    2426BitBlock EOF_mask = simd<1>::constant<1>();
    25 ErrorTracker error_tracker;
    2627
    2728BitBlock elem_starts;
     
    3132vector <int> gids;
    3233PBGSIdentitySymbolTable pbgs_symbol_table;
     34
    3335
    3436static inline int NameStrt_check(int pos);
     
    4143static inline int AttRef_check(int pos);
    4244
    43 
    44 
    4545@global
    4646
    4747static inline void s2p_do_block(BytePack U8[], Basis_bits & basis_bits);
    4848static inline void s2p_do_final_block(BytePack U8[], Basis_bits & basis_bits, BitBlock EOF_mask);
    49 static 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);
     49static inline void postprocess_do_block(Lex & lex, CtCDPI_Callouts & ctCDPI_Callouts, Ref_Callouts & ref_Callouts, Check_streams & check_streams, int chars_avail);
     50
    5051void do_process(FILE *infile, FILE *outfile);
     52
     53static inline void validate_block(BitBlockForwardIterator & start, int block_base, int is_valid(int));
     54static inline void validate_block(BitBlockForwardIterator & start, int block_base, int is_valid(int,int));
     55template <int L> static inline void validate_block_length_grouping(BitBlockForwardIterator & start, int block_base);
     56
    5157static inline int ScanBackwardPos(BitBlock * block, int pos);
    5258static inline int compute_hash_value (int lgth, int start);
    5359template <int L> static inline int ElemEnd_grouping(int pos);
    54 template <int L> static inline void validate_block_length_grouping(BitBlockForwardIterator & start, int block_base);
    5560
    5661int main(int argc, char * argv[]) {
     62
    5763        char * infilename, * outfilename;
    5864        FILE *infile, *outfile;
     
    141147
    142148template <int L>
    143 static inline int ElemEnd_grouping(int pos) {
    144     int end = pos;
     149static inline int ElemEnd_grouping(int end) {
    145150    int start = end - L;
    146151    int hashvalue = compute_hash_value(L, start - block_base);
     
    158163
    159164template<>
    160 inline int ElemEnd_grouping<17>(int pos) {
    161     int end = pos;
    162     int start = ScanBackwardPos (&elem_starts, pos - block_base) + block_base;
     165inline int ElemEnd_grouping<17>(int end) {
     166    int start = ScanBackwardPos (&elem_starts, end - block_base) + block_base;
    163167    int lgth = end - start;
    164168    int hashvalue = compute_hash_value(lgth, start - block_base);
     
    298302}
    299303
     304/* StreamScan & Post Process Definitions */
     305static inline int StreamScan(ScanBlock * stream, int blk_count, int ProcessPos(int), int * error_pos_in_block) {
     306
     307        int blk;
     308        int block_pos = 0;
     309        int pos;
     310
     311        for (blk = 0; blk < blk_count; blk++) {
     312                ScanBlock s = stream[blk];
     313                while(s) {
     314                        pos = (cfzl(s) + block_pos);
     315                        int code = (ProcessPos(pos));
     316                        if (code) {
     317                                *error_pos_in_block = pos;
     318                                return code; // error code
     319                        }
     320                        s = s & (s-1);  // clear rightmost bit.
     321                }
     322                block_pos += 8 * sizeof(ScanBlock);
     323        }
     324        return 0;
     325}
    300326#else
    301 
    302 
    303 
    304327static inline int NameStrt_check(int pos) {
    305     if(XML_10_UTF8_NameStrt_bytes((unsigned char*)&source[pos]) == 0){
    306         return XMLTestSuiteError::NAME_START;
    307     }
    308     return 0;
     328        if(XML_10_UTF8_NameStrt_bytes((unsigned char*)&source[pos]) == 0){
     329              return XMLTestSuiteError::NAME_START;
     330        }
     331        return 0;
    309332}
    310333
    311334static inline int Name_check(int pos) {
    312     if(XML_10_UTF8_NameChar_bytes((unsigned char*)&source[pos]) == 0){
    313         return XMLTestSuiteError::NAME;
    314     }
    315     return 0;
     335        if(XML_10_UTF8_NameChar_bytes((unsigned char*)&source[pos]) == 0){
     336                  return XMLTestSuiteError::NAME;
     337        }
     338        return 0;
    316339}
    317340
     
    406429        return 0;
    407430}
    408 #endif
    409 
    410 /* StreamScan & Post Process Definitions */
    411 static inline int StreamScan(ScanBlock * stream, int blk_count, int ProcessPos(int), int * error_pos_in_block) {
    412 
    413         int blk;
    414         int block_pos = 0;
    415         int pos;
    416 
    417         for (blk = 0; blk < blk_count; blk++) {
    418                 ScanBlock s = stream[blk];
    419                 while(s) {
    420                         pos = (cfzl(s) + block_pos);
    421                         int code = (ProcessPos(pos));
    422                         if (code) {
    423                                 *error_pos_in_block = pos;
    424                                 return code; // error code
    425                         }
    426                         s = s & (s-1);  // clear rightmost bit.
    427                 }
    428                 block_pos += 8 * sizeof(ScanBlock);
    429         }
    430         return 0;
    431 }
    432 
    433 template <int L>
    434 static inline void validate_block_length_grouping(BitBlockForwardIterator & start, int block_base) {
    435 
    436     BitBlockForwardIterator end;
    437     int block_pos;
    438 
    439     while(start != end) {
    440         block_pos = block_base + *start;
    441         ElemEnd_grouping<L>(block_pos);
    442         start++;
    443     }
    444 }
    445431
    446432static inline void validate_block(BitBlockForwardIterator & start, int block_base, int is_valid(int)) {
    447433
    448     BitBlockForwardIterator end;
    449     int pos, block_pos;
    450 
    451     while(start != end) {
    452 
    453         block_pos = block_base + *start;
    454         int rv = is_valid(block_pos);
    455 
    456         if (rv) {
    457                 int error_line, error_column;
    458                 tracker.get_Line_and_Column(block_pos, error_line, error_column);
    459                 ReportError(XMLTestSuiteError::get_msg(rv), error_line, error_column);
    460                 exit(-1);
    461         }
    462         start++;
    463     }
    464 }
    465 
    466 static inline void validate_block(BitBlockForwardIterator & start, int block_base, int buffer_base, int is_valid(int,int)) {
    467 
    468434        BitBlockForwardIterator end;
    469         int pos, block_pos, file_pos;
     435        int pos, block_pos;
    470436
    471437        while(start != end) {
    472438
    473439                block_pos = block_base + *start;
    474                 file_pos = block_pos+buffer_base;
    475 
    476 
    477                 int rv = is_valid(block_pos, file_pos);
     440                int rv = is_valid(block_pos);
    478441
    479442                if (rv) {
     
    487450}
    488451
     452static inline void validate_block(BitBlockForwardIterator & start, int block_base, int buffer_base, int is_valid(int,int)) {
     453
     454        BitBlockForwardIterator end;
     455        int pos, block_pos, file_pos;
     456
     457        while(start != end) {
     458
     459                block_pos = block_base + *start;
     460                file_pos = block_pos+buffer_base;
     461
     462
     463                int rv = is_valid(block_pos, file_pos);
     464
     465                if (rv) {
     466                        int error_line, error_column;
     467                        tracker.get_Line_and_Column(block_pos, error_line, error_column);
     468                        ReportError(XMLTestSuiteError::get_msg(rv), error_line, error_column);
     469                        exit(-1);
     470                }
     471                start++;
     472        }
     473}
     474#endif
     475
     476
     477template <int L>
     478static inline void validate_block_length_grouping(BitBlockForwardIterator & start, int block_base) {
     479
     480    BitBlockForwardIterator end;
     481    int block_pos;
     482
     483    while(start != end) {
     484        block_pos = block_base + *start;
     485        ElemEnd_grouping<L>(block_pos);
     486        start++;
     487    }
     488}
     489
    489490static 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){
    490491    tracker.StoreNewlines(lex.LF);
     
    493494    hashvalues[1] = hash_data.Hash_value;
    494495
     496#ifdef USE_ITER
    495497    BitBlockForwardIterator iter;
    496498
     
    595597        iter.init(&tag_Callouts.ElemName_ends_17_and_longer);
    596598        validate_block_length_grouping<17>(iter, block_base);
     599    }
     600
     601    // Store the last starting position in case we hit boundary case
     602    previous_block_last_elem_start = - count_reverse_zeroes (elem_starts);
     603
     604    //copy current hash value data as previous one.
     605    memmove (&hashvalues[0], &hashvalues[1], 16);
     606
     607    if (bitblock_has_bit(simd_or(check_streams.non_ascii_name_starts, check_streams.non_ascii_names))) {
     608            iter.init(&check_streams.non_ascii_name_starts);
     609            validate_block(iter, block_base, NameStrt_check);
     610            iter.init(&check_streams.non_ascii_names);
     611            validate_block(iter, block_base, Name_check);
     612    }
     613    if (bitblock_has_bit(ctCDPI_Callouts.PI_name_starts)){
     614            iter.init(&(ctCDPI_Callouts.PI_name_starts));
     615            validate_block(iter, block_base, buffer_base, PIName_check);
     616    }
     617    if (bitblock_has_bit(ctCDPI_Callouts.CD_starts)){
     618            iter.init(&ctCDPI_Callouts.CD_starts);
     619            validate_block(iter, block_base, CD_check);
     620    }
     621    if(bitblock_has_bit(ref_Callouts.GenRef_starts)){
     622            iter.init(&ref_Callouts.GenRef_starts);
     623            validate_block(iter, block_base, GenRef_check);
     624    }
     625    if(bitblock_has_bit(ref_Callouts.DecRef_starts)){
     626            iter.init(&ref_Callouts.DecRef_starts);
     627            validate_block(iter, block_base, DecRef_check);
     628    }
     629    if(bitblock_has_bit(ref_Callouts.HexRef_starts)){
     630            iter.init(&ref_Callouts.HexRef_starts);
     631            validate_block(iter, block_base, HexRef_check);
     632    }
     633    if(bitblock_has_bit(check_streams.att_refs)){
     634            iter.init(&check_streams.att_refs);
     635            validate_block(iter, block_base, AttRef_check);
     636    }
     637
     638    if(error_tracker.Has_Noted_Error()){
     639        int error_line, error_column;
     640        tracker.get_Line_and_Column(error_tracker.Noted_Pos_In_Block(), error_line, error_column);
     641        ReportError(error_tracker.Noted_Error_Msg(), error_line, error_column);
     642        exit(-1);
     643    }
     644
     645    matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
     646    tracker.AdvanceBlock();
     647#else
     648    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_1) )
     649    {
     650        BitBlockForwardIterator iter_length_grouping_1(&tag_Callouts.ElemName_ends_1);
     651        validate_block_length_grouping<1>(iter_length_grouping_1, block_base);
     652    }
     653
     654    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_2) )
     655    {
     656        BitBlockForwardIterator iter_length_grouping_2(&tag_Callouts.ElemName_ends_2);
     657        validate_block_length_grouping<2>(iter_length_grouping_2, block_base);
     658    }
     659
     660    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_3) )
     661    {
     662        BitBlockForwardIterator iter_length_grouping_3(&tag_Callouts.ElemName_ends_3);
     663        validate_block_length_grouping<3>(iter_length_grouping_3, block_base);
     664    }
     665
     666    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_4) )
     667    {
     668        BitBlockForwardIterator iter_length_grouping_4(&tag_Callouts.ElemName_ends_4);
     669        validate_block_length_grouping<4>(iter_length_grouping_4, block_base);
     670    }
     671
     672    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_5) )
     673    {
     674        BitBlockForwardIterator iter_length_grouping_5(&tag_Callouts.ElemName_ends_5);
     675        validate_block_length_grouping<5>(iter_length_grouping_5, block_base);
     676    }
     677
     678    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_6) )
     679    {
     680        BitBlockForwardIterator iter_length_grouping_6(&tag_Callouts.ElemName_ends_6);
     681        validate_block_length_grouping<6>(iter_length_grouping_6, block_base);
     682    }
     683
     684    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_7) )
     685    {
     686        BitBlockForwardIterator iter_length_grouping_7(&tag_Callouts.ElemName_ends_7);
     687        validate_block_length_grouping<7>(iter_length_grouping_7, block_base);
     688    }
     689
     690    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_8) )
     691    {
     692        BitBlockForwardIterator iter_length_grouping_8(&tag_Callouts.ElemName_ends_8);
     693        validate_block_length_grouping<8>(iter_length_grouping_8, block_base);
     694    }
     695
     696    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_9) )
     697    {
     698        BitBlockForwardIterator iter_length_grouping_9(&tag_Callouts.ElemName_ends_9);
     699        validate_block_length_grouping<9>(iter_length_grouping_9, block_base);
     700    }
     701
     702    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_10) )
     703    {
     704        BitBlockForwardIterator iter_length_grouping_10(&tag_Callouts.ElemName_ends_10);
     705        validate_block_length_grouping<10>(iter_length_grouping_10, block_base);
     706    }
     707
     708    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_11) )
     709    {
     710        BitBlockForwardIterator iter_length_grouping_11(&tag_Callouts.ElemName_ends_11);
     711        validate_block_length_grouping<11>(iter_length_grouping_11, block_base);
     712    }
     713
     714    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_12) )
     715    {
     716        BitBlockForwardIterator iter_length_grouping_12(&tag_Callouts.ElemName_ends_12);
     717        validate_block_length_grouping<12>(iter_length_grouping_12, block_base);
     718    }
     719
     720    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_13) )
     721    {
     722        BitBlockForwardIterator iter_length_grouping_13(&tag_Callouts.ElemName_ends_13);
     723        validate_block_length_grouping<13>(iter_length_grouping_13, block_base);
     724    }
     725
     726    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_14) )
     727    {
     728        BitBlockForwardIterator iter_length_grouping_14(&tag_Callouts.ElemName_ends_14);
     729        validate_block_length_grouping<14>(iter_length_grouping_14, block_base);
     730    }
     731
     732    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_15) )
     733    {
     734        BitBlockForwardIterator iter_length_grouping_15(&tag_Callouts.ElemName_ends_15);
     735        validate_block_length_grouping<15>(iter_length_grouping_15, block_base);
     736    }
     737
     738    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_16) )
     739    {
     740        BitBlockForwardIterator iter_length_grouping_16(&tag_Callouts.ElemName_ends_16);
     741        validate_block_length_grouping<16>(iter_length_grouping_16, block_base);
     742    }
     743
     744    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_17_and_longer) )
     745    {
     746        BitBlockForwardIterator iter_length_grouping_remaining(&tag_Callouts.ElemName_ends_17_and_longer);
     747        validate_block_length_grouping<17>(iter_length_grouping_remaining, block_base);
    597748    }
    598749
     
    688839#else
    689840    if (bitblock_has_bit(simd_or(check_streams.non_ascii_name_starts, check_streams.non_ascii_names))) {
    690             iter.init(&check_streams.non_ascii_name_starts);
    691             validate_block(iter, block_base, NameStrt_check);
    692             iter.init(&check_streams.non_ascii_names);
    693             validate_block(iter, block_base, Name_check);
     841        BitBlockForwardIterator iter_NameStrt_check(&check_streams.non_ascii_name_starts);
     842        validate_block(iter_NameStrt_check, block_base, NameStrt_check);
     843        BitBlockForwardIterator iter_Name_check(&check_streams.non_ascii_names);
     844        validate_block(iter_Name_check, block_base, Name_check);
    694845    }
    695846    if (bitblock_has_bit(ctCDPI_Callouts.PI_name_starts)){
    696             iter.init(&(ctCDPI_Callouts.PI_name_starts));
    697             validate_block(iter, block_base, buffer_base, PIName_check);
     847        BitBlockForwardIterator iter_PI_name_starts(&(ctCDPI_Callouts.PI_name_starts));
     848        validate_block(iter_PI_name_starts, block_base, buffer_base, PIName_check);
     849
    698850    }
    699851    if (bitblock_has_bit(ctCDPI_Callouts.CD_starts)){
    700             iter.init(&ctCDPI_Callouts.CD_starts);
    701             validate_block(iter, block_base, CD_check);
     852        BitBlockForwardIterator iter_CD_check(&ctCDPI_Callouts.CD_starts);
     853        validate_block(iter_CD_check, block_base, CD_check);
    702854    }
    703855    if(bitblock_has_bit(ref_Callouts.GenRef_starts)){
    704             iter.init(&ref_Callouts.GenRef_starts);
    705             validate_block(iter, block_base, GenRef_check);
     856        BitBlockForwardIterator iter_GenRef_check(&ref_Callouts.GenRef_starts);
     857        validate_block(iter_GenRef_check, block_base, GenRef_check);
    706858    }
    707859    if(bitblock_has_bit(ref_Callouts.DecRef_starts)){
    708             iter.init(&ref_Callouts.DecRef_starts);
    709             validate_block(iter, block_base, DecRef_check);
     860        BitBlockForwardIterator iter_DecRef_check(&ref_Callouts.DecRef_starts);
     861        validate_block(iter_DecRef_check, block_base, DecRef_check);
    710862    }
    711863    if(bitblock_has_bit(ref_Callouts.HexRef_starts)){
    712             iter.init(&ref_Callouts.HexRef_starts);
    713             validate_block(iter, block_base, HexRef_check);
     864        BitBlockForwardIterator iter_HexRef_check(&ref_Callouts.HexRef_starts);
     865        validate_block(iter_HexRef_check, block_base, HexRef_check);
    714866    }
    715867    if(bitblock_has_bit(check_streams.att_refs)){
    716             iter.init(&check_streams.att_refs);
    717             validate_block(iter, block_base, AttRef_check);
     868        BitBlockForwardIterator iter_AttRef_check(&check_streams.att_refs);
     869        validate_block(iter_AttRef_check, block_base, AttRef_check);
    718870    }
    719871
    720872    if(error_tracker.Has_Noted_Error()){
    721             int error_line, error_column;
    722             tracker.get_Line_and_Column(error_tracker.Noted_Pos_In_Block(), error_line, error_column);
    723             ReportError(error_tracker.Noted_Error_Msg(), error_line, error_column);
    724             exit(-1);
     873        int error_line, error_column;
     874        tracker.get_Line_and_Column(error_tracker.Noted_Pos_In_Block(), error_line, error_column);
     875        ReportError(error_tracker.Noted_Error_Msg(), error_line, error_column);
     876        exit(-1);
    725877    }
    726878
     
    730882
    731883#endif
    732 
     884#endif
    733885}
    734886
Note: See TracChangeset for help on using the changeset viewer.