Ignore:
Timestamp:
Nov 21, 2011, 4:09:54 PM (8 years ago)
Author:
vla24
Message:

SymbolTable?: completed dictionary implementation and refactored templates

File:
1 edited

Legend:

Unmodified
Added
Removed
  • proto/SymbolTable/symtab_pbgs_identity_template.cpp

    r1684 r1721  
    1 #include "../symtab_global.h"
     1#include "../common_definitions.h"
    22#include <pbgs_identity_symbol_table.h>
     3
     4#include "../symtab_common_functions.h"
     5#include "../xmlwf_common_functions.h"
     6
    37//#define STREAMSCAN
    48#ifdef BUFFER_PROFILING
     
    1822int block_base=0;
    1923int buffer_base=0;
    20 char * source;
    2124int buffer_last;
    2225
    23 LineColTracker tracker;
    2426TagMatcher matcher;
    25 ErrorTracker error_tracker;
    26 BitBlock EOF_mask = simd<1>::constant<1>();
    2727
    2828BitBlock elem_starts;
     
    3434
    3535
     36#ifdef STREAMSCAN
    3637static inline int NameStrt_check(int pos);
    3738static inline int Name_check(int pos);
     
    4243static inline int DecRef_check(int pos);
    4344static inline int AttRef_check(int pos);
    44 
    45 @global
    46 
    47 static inline void s2p_do_block(BytePack U8[], Basis_bits & basis_bits);
    48 static inline void s2p_do_final_block(BytePack U8[], Basis_bits & basis_bits, BitBlock EOF_mask);
     45#endif
     46
    4947static inline void postprocess_do_block(Lex & lex, CtCDPI_Callouts & ctCDPI_Callouts, Ref_Callouts & ref_Callouts, Check_streams & check_streams, int chars_avail);
    5048
    5149void do_process(FILE *infile, FILE *outfile);
    5250
    53 static inline void validate_block(BitBlockForwardIterator & start, int block_base, int is_valid(int));
    54 static inline void validate_block(BitBlockForwardIterator & start, int block_base, int is_valid(int,int));
    5551template <int L> static inline void validate_block_length_grouping(BitBlockForwardIterator & start, int block_base);
    5652
    57 static inline int ScanBackwardPos(BitBlock * block, int pos);
    58 static inline int compute_hash_value (int lgth, int start);
    5953template <int L> static inline int ElemEnd_grouping(int pos);
    6054
    6155int main(int argc, char * argv[]) {
    6256
    63         char * infilename, * outfilename;
    64         FILE *infile, *outfile;
    65         struct stat fileinfo;
    66 
    67         if (argc < 2) {
    68                 printf("Usage: %s <filename> [<outputfile>]\n", argv[0]);
    69                 exit(-1);
    70         }
    71 
    72         infilename = argv[1];
    73         stat(infilename, &fileinfo);
    74         infile = fopen(infilename, "rb");
    75         if (!infile) {
    76                 fprintf(stderr, "Error: cannot open %s for input.\n", infilename);
    77                 exit(-1);
    78         }
    79 
    80         if (argc < 3) outfile = stdout;
    81         else {
    82                 outfilename = argv[2];
    83                 outfile = fopen(outfilename, "wb");
    84                 if (!outfile) {
    85                         fprintf(stderr, "Error: cannot open %s for writing.\n", outfilename);
    86                         exit(-1);
    87                 }
    88         }
     57    char * infilename, * outfilename;
     58    FILE *infile, *outfile;
     59
     60    getFilenames(argc, argv, infilename, outfilename);
     61    openInputOutputFiles(infilename, outfilename,
     62                         infile, outfile);
    8963
    9064//      PERF_SEC_BIND(1);
    9165
    92         PERF_SEC_INIT(parser_timer);
    93 
    94         do_process(infile, outfile);
    95 
    96         PERF_SEC_DUMP(parser_timer);
    97 
    98         PERF_SEC_DESTROY(parser_timer);
    99 
    100         fclose(infile);
    101         fclose(outfile);
    102 
    103         return(0);
    104 }
    105 
    106 /* s2p Definitions */
    107 static inline void s2p_do_block(BytePack U8[], Basis_bits & basis_bits) {
    108   s2p(U8[0], U8[1], U8[2], U8[3], U8[4], U8[5], U8[6], U8[7],
    109         basis_bits.bit_0, basis_bits.bit_1, basis_bits.bit_2, basis_bits.bit_3, basis_bits.bit_4, basis_bits.bit_5, basis_bits.bit_6, basis_bits.bit_7);
    110 }
    111 
    112 static inline void s2p_do_final_block(BytePack U8[], Basis_bits & basis_bits, BitBlock EOF_mask) {
    113   s2p_do_block(U8, basis_bits);
    114   basis_bits.bit_0 = simd_and(basis_bits.bit_0, EOF_mask);
    115   basis_bits.bit_1 = simd_and(basis_bits.bit_1, EOF_mask);
    116   basis_bits.bit_2 = simd_and(basis_bits.bit_2, EOF_mask);
    117   basis_bits.bit_3 = simd_and(basis_bits.bit_3, EOF_mask);
    118   basis_bits.bit_4 = simd_and(basis_bits.bit_4, EOF_mask);
    119   basis_bits.bit_5 = simd_and(basis_bits.bit_5, EOF_mask);
    120   basis_bits.bit_6 = simd_and(basis_bits.bit_6, EOF_mask);
    121   basis_bits.bit_7 = simd_and(basis_bits.bit_7, EOF_mask);
    122 }
    123 
    124 static inline int ScanBackwardPos(BitBlock * block, int pos)
    125 {
    126     BitBlock s = block[0];
    127     BitBlock temp = simd_and( s, simd_not(simd<128>::sll(simd<2>::constant<3>(), convert(pos))) );
    128 
    129     if (bitblock_has_bit(temp))
    130     {
    131         // sizeof (BitBlock)*8 - cbzl( s & ~(~0 << pos)) - 1;
    132         return BLOCK_SIZE - count_reverse_zeroes (temp) - 1;
    133     }
    134     else
    135     {
    136         //handle boundary case
    137         return previous_block_last_elem_start - 1;
    138     }
    139 }
    140 
    141 static inline int compute_hash_value (int lgth, int start)
    142 {
    143     unsigned int offset_bit = start + 128;
    144     uint64_t stream = *((uint64_t*)(((uint32_t*)hashvalues)+(offset_bit>>5)));
    145     return stream >> (offset_bit & 0x1F) & ~(~0 << lgth);
     66    PERF_SEC_INIT(parser_timer);
     67
     68    // store symbols form text to Symbol Table
     69    do_process(infile, outfile);
     70
     71    PERF_SEC_DUMP(parser_timer);
     72
     73    PERF_SEC_DESTROY(parser_timer);
     74
     75    fclose(infile);
     76    fclose(outfile);
     77
     78#if PRINT_SYMBOL_DISTRIBUTION
     79//    print_GIDS();
     80    pbgs_symbol_table.Print_Symbol_Table_Distribution();
     81#endif
     82
     83    return 0;
    14684}
    14785
     
    14987static inline int ElemEnd_grouping(int end) {
    15088    int start = end - L;
    151     int hashvalue = compute_hash_value(L, start - block_base);
     89    int hashvalue = compute_hash_value(L, start - block_base, hashvalues);
    15290    int gid = pbgs_symbol_table.Lookup_or_Insert_Name<L>(source + start, hashvalue);
    15391    gids.push_back(gid);
     
    164102template<>
    165103inline int ElemEnd_grouping<17>(int end) {
    166     int start = ScanBackwardPos (&elem_starts, end - block_base) + block_base;
     104    int start = ScanBackwardPos (&elem_starts, end - block_base, previous_block_last_elem_start) + block_base;
    167105    int lgth = end - start;
    168     int hashvalue = compute_hash_value(lgth, start - block_base);
     106    int hashvalue = compute_hash_value(lgth, start - block_base, hashvalues);
    169107    int gid = 0;
    170108
     
    325263}
    326264#else
    327 static inline int NameStrt_check(int pos) {
    328         if(XML_10_UTF8_NameStrt_bytes((unsigned char*)&source[pos]) == 0){
    329               return XMLTestSuiteError::NAME_START;
    330         }
    331         return 0;
    332 }
    333 
    334 static inline int Name_check(int pos) {
    335         if(XML_10_UTF8_NameChar_bytes((unsigned char*)&source[pos]) == 0){
    336                   return XMLTestSuiteError::NAME;
    337         }
    338         return 0;
    339 }
    340 
    341 static inline int PIName_check(int pos, int file_pos) {
    342         if (at_XxMmLll<ASCII>((unsigned char*)&source[pos]) && (source[pos+3]=='?' || source[pos+3]<= ' ')) {
    343               // "<?xml" legal at start of file.
    344               if (!((file_pos == 2) && at_XmlDecl_start<ASCII>((unsigned char*)&source[0]))) {
    345                   return XMLTestSuiteError::XMLPINAME;
    346               }
    347         }
    348         return 0;
    349 }
    350 
    351 static inline int CD_check(int pos) {
    352         if (!at_CDATA1<ASCII>((unsigned char*)&source[pos])){
    353                   return XMLTestSuiteError::CDATA;
    354         }
    355         return 0;
    356 }
    357 
    358 static inline int GenRef_check(int pos) {
    359         unsigned char* s = (unsigned char*)&source[pos];
    360         if (!(at_Ref_gt<ASCII>(s)||at_Ref_lt<ASCII>(s)||at_Ref_amp<ASCII>(s)||at_Ref_quot<ASCII>(s)||at_Ref_apos<ASCII>(s))){
    361               return XMLTestSuiteError::UNDEFREF;
    362         }
    363         return 0;
    364 }
    365 
    366 static inline int HexRef_check(int pos) {
    367         unsigned char* s = (unsigned char*)&source[pos];
    368         int ch_val = 0;
    369         while(at_HexDigit<ASCII>(s)){
    370           ch_val = HexVal<ASCII>(s[0]) + (ch_val<<4);
    371           if (ch_val> 0x10FFFF ){
    372                 return XMLTestSuiteError::CHARREF;
    373           }
    374           s++;
    375         }
    376         if ((ch_val == 0x0) || ((ch_val | 0x7FF) == 0xDFFF)|| ((ch_val | 0x1) == 0xFFFF)){
    377           return XMLTestSuiteError::CHARREF;
    378         }
    379         else if (((ch_val < 0x20) && (ch_val != 0x9) && (ch_val != 0xD) && (ch_val != 0xA))){
    380           return XMLTestSuiteError::XML10CHARREF;
    381         }
    382         return 0;
    383 }
    384 
    385 static inline int DecRef_check(int pos) {
    386         unsigned char* s = (unsigned char*)&source[pos];
    387         int ch_val = 0;
    388         while(at_HexDigit<ASCII>(s)){
    389           ch_val = DigitVal<ASCII>(s[0]) + ch_val*10;
    390           if (ch_val> 0x10FFFF ){
    391                         return XMLTestSuiteError::CHARREF;
    392           }
    393           s++;
    394         }
    395         if ((ch_val == 0x0) || ((ch_val | 0x7FF) == 0xDFFF)|| ((ch_val | 0x1) == 0xFFFF)){
    396                   return XMLTestSuiteError::CHARREF;
    397         }
    398         else if (((ch_val < 0x20) && (ch_val != 0x9) && (ch_val != 0xD) && (ch_val != 0xA))){
    399                   return XMLTestSuiteError::XML10CHARREF;
    400         }
    401         return 0;
    402 }
    403 
    404 static inline int AttRef_check(int pos) {
    405         unsigned char* s = (unsigned char*)&source[pos];
    406         int ch_val = 0;
    407         if(s[0]=='#'){
    408           s++;
    409           if(s[0]=='x' || s[0]=='X'){
    410             s++;
    411             while(at_HexDigit<ASCII>(s)){
    412               ch_val = HexVal<ASCII>(s[0]) + (ch_val<<4);
    413               s++;
    414             }
    415           }
    416           else{
    417             while(at_HexDigit<ASCII>(s)){
    418               ch_val = DigitVal<ASCII>(s[0]) + ch_val*10;
    419               s++;
    420             }
    421           }
    422           if (ch_val==60){
    423             return XMLTestSuiteError::ATTREF;
    424           }
    425         }
    426         else if(at_Ref_lt<ASCII>(s)){
    427           return XMLTestSuiteError::ATTREF;
    428         }
    429         return 0;
    430 }
    431 
    432 static inline void validate_block(BitBlockForwardIterator & start, int block_base, int is_valid(int)) {
    433 
    434         BitBlockForwardIterator end;
    435         int pos, block_pos;
    436 
    437         while(start != end) {
    438 
    439                 block_pos = block_base + *start;
    440                 int rv = is_valid(block_pos);
    441 
    442                 if (rv) {
    443                         int error_line, error_column;
    444                         tracker.get_Line_and_Column(block_pos, error_line, error_column);
    445                         ReportError(XMLTestSuiteError::get_msg(rv), error_line, error_column);
    446                         exit(-1);
    447                 }
    448                 start++;
    449         }
    450 }
    451 
    452 static 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 }
     265
     266
    474267#endif
    475268
     
    482275
    483276    while(start != end) {
    484         block_pos = block_base + *start;
     277        block_pos = block_base + *start;
    485278        ElemEnd_grouping<L>(block_pos);
    486         start++;
     279        start++;
    487280    }
    488281}
     
    883676#endif
    884677#endif
    885 }
    886 
    887 static inline void print_GIDS()
    888 {
    889     int span_count = gids.size();
    890     for(int i=0;i<span_count;i++) {
    891              cout << gids[i] << " ";
    892     }
    893     cout << endl;
    894 }
    895 
    896 static inline int test(int)
    897 {
    898     return 0;
    899678}
    900679
     
    1017796      exit(-1);
    1018797    }
    1019 //  print_GIDS();
    1020 #if DEBUG
    1021     pbgs_symbol_table.Print_Symbol_Table_Distribution();
    1022 #endif
    1023 }
    1024 
    1025 
     798}
     799
     800
Note: See TracChangeset for help on using the changeset viewer.