Changeset 1497


Ignore:
Timestamp:
Sep 30, 2011, 11:47:49 AM (8 years ago)
Author:
cameron
Message:

AVX template update

File:
1 edited

Legend:

Unmodified
Added
Removed
  • proto/parabix2/pablo_template_avx.cpp

    r1468 r1497  
    1111#define OVERLAP_BUFSIZE (sizeof(SIMD_type))
    1212
     13#include "xmldecl.h"
     14#include "namechars.h"
    1315#include "../lib/carryQ_avx.h"
    14 #include "xmldecl.h"
    15 #include "xml_error.c"
    16 #include "xmldecl.c"
    17 #include "namechars.h"
    18 
    1916#include "../lib/perflib/perfsec.h"
    2017#include "../lib/s2p.h"
     
    2219#include "TagMatcher_avx.h"
    2320#include "LineColTracker.h"
     21#include "ErrorUtil.h"
     22#include "ErrorTracker.h"
     23#include "XMLTestSuiteError.h"
    2424
    2525#ifdef BUFFER_PROFILING
     
    3939int block_base=0;
    4040int buffer_base=0;
    41 int buffer_last;
    4241char * source;
     42
    4343LineColTracker tracker;
    4444TagMatcher matcher;
     45ErrorTracker error_tracker;
    4546BitBlock EOF_mask = simd_const_1(1);
    4647
    47 
    48 static inline int StreamScan(ScanBlock * stream, int blk_count, int ProcessPos(int)) {
     48/* StreamScan & Post Process Declarations */
     49//      static inline int StreamScanToFirst(ScanBlock * stream, int blk_count, int ProcessPos(int), int * error_pos_in_block)
     50static inline int StreamScan(ScanBlock * stream, int blk_count, int ProcessPos(int), int * error_pos_in_block);
     51
     52static inline int NameStrt_check(int pos);
     53static inline int Name_check(int pos);
     54static inline int PIName_check(int pos);
     55static inline int CD_check(int pos);
     56static inline int GenRef_check(int pos);
     57static inline int HexRef_check(int pos);
     58static inline int DecRef_check(int pos);
     59static inline int AttRef_check(int pos);
     60
     61@global
     62
     63static inline void s2p_do_block(BytePack U8[], Basis_bits & basis_bits);
     64static inline void s2p_do_final_block(BytePack U8[], Basis_bits & basis_bits, BitBlock EOF_mask);
     65static inline void postprocess_do_block(Lex & lex, CtCDPI_Callouts & ctCDPI_Callouts, Ref_Callouts & ref_Callouts, Check_streams & check_streams, int chars_avail);
     66
     67void do_process(FILE *infile, FILE *outfile);
     68
     69int main(int argc, char * argv[]) {
     70        char * infilename, * outfilename;
     71        FILE *infile, *outfile;
     72        struct stat fileinfo;
     73
     74        if (argc < 2) {
     75                printf("Usage: %s <filename> [<outputfile>]\n", argv[0]);
     76                exit(-1);
     77        }
     78
     79        infilename = argv[1];
     80        stat(infilename, &fileinfo);
     81        infile = fopen(infilename, "rb");
     82        if (!infile) {
     83                fprintf(stderr, "Error: cannot open %s for input.\n", infilename);
     84                exit(-1);
     85        }
     86
     87        if (argc < 3) outfile = stdout;
     88        else {
     89                outfilename = argv[2];
     90                outfile = fopen(outfilename, "wb");
     91                if (!outfile) {
     92                        fprintf(stderr, "Error: cannot open %s for writing.\n", outfilename);
     93                        exit(-1);
     94                }
     95        }
     96
     97//      PERF_SEC_BIND(1);
     98
     99        PERF_SEC_INIT(parser_timer);
     100
     101        do_process(infile, outfile);
     102
     103        PERF_SEC_DUMP(parser_timer);
     104
     105        PERF_SEC_DESTROY(parser_timer);
     106
     107        fclose(infile);
     108        fclose(outfile);
     109
     110        return(0);
     111}
     112
     113/* s2p Definitions */
     114static inline void s2p_do_block(BytePack U8[], Basis_bits & basis_bits) {
     115  s2p(U8[0], U8[1], U8[2], U8[3], U8[4], U8[5], U8[6], U8[7],
     116        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);
     117}
     118
     119static inline void s2p_do_final_block(BytePack U8[], Basis_bits & basis_bits, BitBlock EOF_mask) {
     120  s2p_do_block(U8, basis_bits);
     121  basis_bits.bit_0 = simd_and(basis_bits.bit_0, EOF_mask);
     122  basis_bits.bit_1 = simd_and(basis_bits.bit_1, EOF_mask);
     123  basis_bits.bit_2 = simd_and(basis_bits.bit_2, EOF_mask);
     124  basis_bits.bit_3 = simd_and(basis_bits.bit_3, EOF_mask);
     125  basis_bits.bit_4 = simd_and(basis_bits.bit_4, EOF_mask);
     126  basis_bits.bit_5 = simd_and(basis_bits.bit_5, EOF_mask);
     127  basis_bits.bit_6 = simd_and(basis_bits.bit_6, EOF_mask);
     128  basis_bits.bit_7 = simd_and(basis_bits.bit_7, EOF_mask);
     129}
     130
     131
     132/* StreamScan & Post Process Definitions */
     133static inline int StreamScan(ScanBlock * stream, int blk_count, int ProcessPos(int), int * error_pos_in_block) {
     134
    49135        int blk;
    50136        int block_pos = 0;
     137        int pos;
    51138
    52139        for (blk = 0; blk < blk_count; blk++) {
    53140                ScanBlock s = stream[blk];
    54141                while(s) {
    55                         int code = (ProcessPos(cfzl(s) + block_pos));
    56                         if (code) return code;
     142                        pos = (cfzl(s) + block_pos);
     143                        int code = (ProcessPos(pos));
     144                        if (code) {
     145                                *error_pos_in_block = pos;
     146                                return code; // error code
     147                        }
    57148                        s = s & (s-1);  // clear rightmost bit.
    58149                }
     
    62153}
    63154
    64 
    65 static inline void ReportError(const char * error_msg, int error_pos_in_block) {
    66   int error_line, error_column;
    67   tracker.get_Line_and_Column(error_pos_in_block, error_line, error_column);
    68   fprintf(stderr, "%s at line %i, column %i\n", error_msg, error_line, error_column);
    69 }
    70 
    71 
    72155static inline int NameStrt_check(int pos) {
    73156        int block_pos = block_base + pos;
    74157        if(XML_10_UTF8_NameStrt_bytes((unsigned char*)&source[block_pos]) == 0){
    75               ReportError("name start error", pos);
    76               exit(-1);
     158              return XMLTestSuiteError::NAME_START;
    77159        }
    78160        return 0;
     
    82164        int block_pos = block_base + pos;
    83165        if(XML_10_UTF8_NameChar_bytes((unsigned char*)&source[block_pos]) == 0){
    84               ReportError("name error", pos);
    85               exit(-1);
     166                  return XMLTestSuiteError::NAME;
    86167        }
    87168        return 0;
     
    93174        if (at_XxMmLll<ASCII>((unsigned char*)&source[block_pos]) && (source[block_pos+3]=='?' || source[block_pos+3]<= ' ')) {
    94175              // "<?xml" legal at start of file.
    95               if ((file_pos == 2) && at_XmlDecl_start<ASCII>((unsigned char*)&source[0])) return 0;
    96               ReportError("[Xx][Mm][Ll] illegal as PI name", pos);
    97               exit(-1);
     176              if (!((file_pos == 2) && at_XmlDecl_start<ASCII>((unsigned char*)&source[0]))) {
     177                  return XMLTestSuiteError::XMLPINAME;
     178              }
    98179        }
    99180        return 0;
     
    103184        int block_pos = block_base + pos;
    104185        if (!at_CDATA1<ASCII>((unsigned char*)&source[block_pos])){
    105               ReportError("CDATA error", pos);
    106               exit(-1);
     186                  return XMLTestSuiteError::CDATA;
    107187        }
    108188        return 0;
     
    113193        unsigned char* s = (unsigned char*)&source[block_pos];
    114194        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))){
    115               ReportError("Undefined reference", pos);
    116               exit(-1);
     195              return XMLTestSuiteError::UNDEFREF;
    117196        }
    118197        return 0;
     
    126205          ch_val = HexVal<ASCII>(s[0]) + (ch_val<<4);
    127206          if (ch_val> 0x10FFFF ){
    128             ReportError("Illegal character reference", pos);
    129             exit(-1);
     207                return XMLTestSuiteError::CHARREF;
    130208          }
    131209          s++;
    132210        }
    133211        if ((ch_val == 0x0) || ((ch_val | 0x7FF) == 0xDFFF)|| ((ch_val | 0x1) == 0xFFFF)){
    134           ReportError("Illegal character reference", pos);
    135           exit(-1);
     212          return XMLTestSuiteError::CHARREF;
    136213        }
    137214        else if (((ch_val < 0x20) && (ch_val != 0x9) && (ch_val != 0xD) && (ch_val != 0xA))){
    138           ReportError("Illegal XML 1.0 character reference", pos);
    139           exit(-1);
     215          return XMLTestSuiteError::XML10CHARREF;
    140216        }
    141217        return 0;
     
    149225          ch_val = DigitVal<ASCII>(s[0]) + ch_val*10;
    150226          if (ch_val> 0x10FFFF ){
    151             ReportError("Illegal character reference", pos);
    152             exit(-1);
     227                        return XMLTestSuiteError::CHARREF;
    153228          }
    154229          s++;
    155230        }
    156231        if ((ch_val == 0x0) || ((ch_val | 0x7FF) == 0xDFFF)|| ((ch_val | 0x1) == 0xFFFF)){
    157           ReportError("Illegal character reference", pos);
    158           exit(-1);
     232                  return XMLTestSuiteError::CHARREF;
    159233        }
    160234        else if (((ch_val < 0x20) && (ch_val != 0x9) && (ch_val != 0xD) && (ch_val != 0xA))){
    161           ReportError("Illegal XML 1.0 character reference", pos);
    162           exit(-1);
     235                  return XMLTestSuiteError::XML10CHARREF;
    163236        }
    164237        return 0;
     
    185258          }
    186259          if (ch_val==60){
    187             ReportError("Attribute values contain '<' characters after reference expansion", pos);
    188             exit(-1);
     260            return XMLTestSuiteError::ATTREF;
    189261          }
    190262        }
    191263        else if(at_Ref_lt<ASCII>(s)){
    192           ReportError("Attribute values contain '<' characters after reference expansion", pos);
    193           exit(-1);
    194         }
    195         return 0;
    196 }
    197 
    198 
    199 
    200 @global
    201 
    202 static inline void s2p_do_block(BytePack U8[], Basis_bits & basis_bits) {
    203   s2p(U8[0], U8[1], U8[2], U8[3], U8[4], U8[5], U8[6], U8[7],
    204         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);
    205 }
    206 
    207 static inline void s2p_do_final_block(BytePack U8[], Basis_bits & basis_bits, BitBlock EOF_mask) {
    208   s2p_do_block(U8, basis_bits);
    209   basis_bits.bit_0 = simd_and(basis_bits.bit_0, EOF_mask);
    210   basis_bits.bit_1 = simd_and(basis_bits.bit_1, EOF_mask);
    211   basis_bits.bit_2 = simd_and(basis_bits.bit_2, EOF_mask);
    212   basis_bits.bit_3 = simd_and(basis_bits.bit_3, EOF_mask);
    213   basis_bits.bit_4 = simd_and(basis_bits.bit_4, EOF_mask);
    214   basis_bits.bit_5 = simd_and(basis_bits.bit_5, EOF_mask);
    215   basis_bits.bit_6 = simd_and(basis_bits.bit_6, EOF_mask);
    216   basis_bits.bit_7 = simd_and(basis_bits.bit_7, EOF_mask);
     264          return XMLTestSuiteError::ATTREF;
     265        }
     266        return 0;
    217267}
    218268
    219269static inline void postprocess_do_block(Lex & lex, CtCDPI_Callouts & ctCDPI_Callouts, Ref_Callouts & ref_Callouts, Check_streams & check_streams, int chars_avail){
    220270            tracker.StoreNewlines(lex.LF);
     271            int rv, error_pos_in_block, error_line, error_column;
    221272
    222273                if (bitblock_has_bit(simd_or(check_streams.non_ascii_name_starts, check_streams.non_ascii_names))) {
    223                   StreamScan((ScanBlock *) &check_streams.non_ascii_name_starts, sizeof(BitBlock)/sizeof(ScanBlock), NameStrt_check);
    224                   StreamScan((ScanBlock *) &check_streams.non_ascii_names, sizeof(BitBlock)/sizeof(ScanBlock), Name_check);
     274                  rv = StreamScan((ScanBlock *) &check_streams.non_ascii_name_starts, sizeof(BitBlock)/sizeof(ScanBlock), NameStrt_check, &error_pos_in_block);
     275                  if (rv) {
     276                          tracker.get_Line_and_Column(error_pos_in_block, error_line, error_column);
     277                          ReportError(XMLTestSuiteError::get_msg(rv), error_line, error_column);
     278                          exit(-1);
     279                  }
     280
     281                  rv = StreamScan((ScanBlock *) &check_streams.non_ascii_names, sizeof(BitBlock)/sizeof(ScanBlock), Name_check, &error_pos_in_block);
     282                  if (rv) {
     283                          tracker.get_Line_and_Column(error_pos_in_block, error_line, error_column);
     284                          ReportError(XMLTestSuiteError::get_msg(rv), error_line, error_column);
     285                          exit(-1);
     286                  }
    225287                }
    226288
    227289                if (bitblock_has_bit(ctCDPI_Callouts.PI_name_starts)){
    228                   StreamScan((ScanBlock *) &ctCDPI_Callouts.PI_name_starts, sizeof(BitBlock)/sizeof(ScanBlock), PIName_check);
     290                  rv = StreamScan((ScanBlock *) &ctCDPI_Callouts.PI_name_starts, sizeof(BitBlock)/sizeof(ScanBlock), PIName_check, &error_pos_in_block);
     291                  if (rv) {
     292                          tracker.get_Line_and_Column(error_pos_in_block, error_line, error_column);
     293                          ReportError(XMLTestSuiteError::get_msg(rv), error_line, error_column);
     294                          exit(-1);
     295                  }
    229296                }
    230297
    231298                if (bitblock_has_bit(ctCDPI_Callouts.CD_starts)){
    232                   StreamScan((ScanBlock *) &ctCDPI_Callouts.CD_starts, sizeof(BitBlock)/sizeof(ScanBlock), CD_check);
     299                  rv = StreamScan((ScanBlock *) &ctCDPI_Callouts.CD_starts, sizeof(BitBlock)/sizeof(ScanBlock), CD_check, &error_pos_in_block);
     300                  if (rv) {
     301                          tracker.get_Line_and_Column(error_pos_in_block, error_line, error_column);
     302                          ReportError(XMLTestSuiteError::get_msg(rv), error_line, error_column);
     303                          exit(-1);
     304                  }
    233305                }
    234306
    235307                if (bitblock_has_bit(ref_Callouts.GenRef_starts)){
    236                   StreamScan((ScanBlock *) &ref_Callouts.GenRef_starts, sizeof(BitBlock)/sizeof(ScanBlock), GenRef_check);
     308                  rv = StreamScan((ScanBlock *) &ref_Callouts.GenRef_starts, sizeof(BitBlock)/sizeof(ScanBlock), GenRef_check, &error_pos_in_block);
     309                  if (rv) {
     310                          tracker.get_Line_and_Column(error_pos_in_block, error_line, error_column);
     311                          ReportError(XMLTestSuiteError::get_msg(rv), error_line, error_column);
     312                          exit(-1);
     313                  }
    237314                }
    238315
    239316                if (bitblock_has_bit(ref_Callouts.DecRef_starts)){
    240                   StreamScan((ScanBlock *) &ref_Callouts.DecRef_starts, sizeof(BitBlock)/sizeof(ScanBlock), DecRef_check);
     317                  rv = StreamScan((ScanBlock *) &ref_Callouts.DecRef_starts, sizeof(BitBlock)/sizeof(ScanBlock), DecRef_check, &error_pos_in_block);
     318                  if (rv) {
     319                          tracker.get_Line_and_Column(error_pos_in_block, error_line, error_column);
     320                          ReportError(XMLTestSuiteError::get_msg(rv), error_line, error_column);
     321                          exit(-1);
     322                  }
    241323                }
    242324
    243325                if (bitblock_has_bit(ref_Callouts.HexRef_starts)){
    244                   StreamScan((ScanBlock *) &ref_Callouts.HexRef_starts, sizeof(BitBlock)/sizeof(ScanBlock), HexRef_check);
     326                  rv = StreamScan((ScanBlock *) &ref_Callouts.HexRef_starts, sizeof(BitBlock)/sizeof(ScanBlock), HexRef_check, &error_pos_in_block);
     327                  if (rv) {
     328                          tracker.get_Line_and_Column(error_pos_in_block, error_line, error_column);
     329                          ReportError(XMLTestSuiteError::get_msg(rv), error_line, error_column);
     330                          exit(-1);
     331                  }
    245332                }
    246333
    247334                if (bitblock_has_bit(check_streams.att_refs)){
    248                   StreamScan((ScanBlock *) &check_streams.att_refs, sizeof(BitBlock)/sizeof(ScanBlock), AttRef_check);
    249                 }
    250 
    251                 if (bitblock_has_bit(check_streams.error_mask)) {
    252                   int errpos = count_forward_zeroes(check_streams.error_mask);
    253                   ReportError("error found", errpos);
    254               exit(-1);
    255                 }
    256 
    257                 matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
     335                  rv = StreamScan((ScanBlock *) &check_streams.att_refs, sizeof(BitBlock)/sizeof(ScanBlock), AttRef_check, &error_pos_in_block);
     336                  if (rv) {
     337                          tracker.get_Line_and_Column(error_pos_in_block, error_line, error_column);
     338                          ReportError(XMLTestSuiteError::get_msg(rv), error_line, error_column);
     339                          exit(-1);
     340                  }
     341                }
     342
     343                if(error_tracker.Has_Noted_Error()){
     344                        tracker.get_Line_and_Column(error_tracker.Noted_Pos_In_Block(), error_line, error_column);
     345                        ReportError(error_tracker.Noted_Error_Msg(), error_line, error_column);
     346                        exit(-1);
     347                }
     348
     349                matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
    258350                tracker.AdvanceBlock();
    259351}
     
    330422          s2p_do_block((BytePack *) &srcbuf[block_base], basis_bits);
    331423          @block_stmts
    332           postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, chars_avail);
     424          postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, chars_avail);
    333425      }
    334426      matcher.StreamScan(chars_avail);
     
    336428      tracker.Advance_buffer();
    337429      PERF_SEC_END(parser_timer, chars_avail);
    338            
     430
    339431      int bytes_left = chars_read - chars_avail;
    340432      memmove(srcbuf, &srcbuf[BUFFER_SIZE], bytes_left);
     
    381473}
    382474
    383 
    384 
    385 int
    386 main(int argc, char * argv[]) {
    387         char * infilename, * outfilename;
    388         FILE *infile, *outfile;
    389         struct stat fileinfo;
    390 
    391         if (argc < 2) {
    392                 printf("Usage: %s <filename> [<outputfile>]\n", argv[0]);
    393                 exit(-1);
    394         }
    395 
    396         infilename = argv[1];
    397         stat(infilename, &fileinfo);
    398         infile = fopen(infilename, "rb");
    399         if (!infile) {
    400                 fprintf(stderr, "Error: cannot open %s for input.\n", infilename);
    401                 exit(-1);
    402         }
    403 
    404         if (argc < 3) outfile = stdout;
    405         else {
    406                 outfilename = argv[2];
    407                 outfile = fopen(outfilename, "wb");
    408                 if (!outfile) {
    409                         fprintf(stderr, "Error: cannot open %s for writing.\n", outfilename);
    410                         exit(-1);
    411                 }
    412         }
    413 
    414 //      PERF_SEC_BIND(1);
    415 
    416         PERF_SEC_INIT(parser_timer);
    417 
    418         do_process(infile, outfile);
    419 
    420         PERF_SEC_DUMP(parser_timer);
    421 
    422         PERF_SEC_DESTROY(parser_timer);
    423 
    424         fclose(infile);
    425         fclose(outfile);
    426         return(0);
    427 }
Note: See TracChangeset for help on using the changeset viewer.