Changeset 3532 for proto/xmlschema


Ignore:
Timestamp:
Oct 21, 2013, 5:14:38 PM (6 years ago)
Author:
shiyangy
Message:

check in template file

File:
1 edited

Legend:

Unmodified
Added
Removed
  • proto/xmlschema/validation_template_onevec.cpp

    r3353 r3532  
    1414//#define TEMPLATED_SIMD_LIB
    1515
    16 #define DEBUG 1
    1716//#define BLOCK_SIZE (sizeof(SIMD_type) * 8)
    1817//#define SEGMENT_BLOCKS 12
     
    2221#define VECTOR_WIDTH 8
    2322#define VECTOR_TYPE (char)
     23
     24#define DEBUG 1
     25
    2426
    2527#include <stdio.h>
     
    7678
    7779#ifdef BUFFER_PROFILING
    78         BOM_Table * parser_timer;
    79 
    80 #elif CODE_CLOCKER
    81         #define NUM_EVENTS 1
    82         int Events[NUM_EVENTS] = {PAPI_TOT_CYC};
    83         //int Events[NUM_EVENTS] = {PAPI_L2_DCM};
    84         //int Events[NUM_EVENTS] = {PAPI_TOT_CYC, PAPI_BR_MSP};
    85         int cal_size = 20;
    86         CC * parser_timer = new CC(Events,NUM_EVENTS,cal_size);
     80    BOM_Table * parser_timer;
     81#elif PAPI
     82                #define PAPI_EVENTS_COUNT 2
     83                int PAPI_EVENTS[PAPI_EVENTS_COUNT] = {PAPI_TOT_CYC, PAPI_BR_MSP};       
     84    CC * parser_timer;
    8785#else
    88         void * parser_timer;
     86    void * parser_timer;
    8987#endif
    9088
     
    113111//char * source;
    114112LineColTracker tracker;
     113
     114#define CONTENT_BUFFER_SIZE BLOCK_SIZE
     115char content_buffer[CONTENT_BUFFER_SIZE];
     116char content_lookahead_buffer[CONTENT_BUFFER_SIZE];
     117int content_buffer_pos = 0;
     118int content_carry = 0;
     119char gid;
     120
     121#define CONTENT_INDEX 13
    115122
    116123static inline int cfzl(long x){
     
    202209map<char, vector<char>* > elem_vec_map;
    203210
     211@global
     212
     213#include <simd-lib/transpose.hpp>
     214#include <post_process.hpp>
     215
    204216static inline int ScanBackwardPos(BitBlock * block, int pos)
    205217{
     
    258270    uint64_t stream = *((uint64_t*)(((uint32_t*)hashvalues)+(offset_bit>>5)));
    259271    return stream >> (offset_bit & 0x1F) & ~(~0 << lgth);
     272}
     273
     274static inline void print_basis_bits(Basis_bits & basis_bits){
     275        print_register("bit0:",basis_bits.bit_0);
     276        print_register("bit1:",basis_bits.bit_1);
     277        print_register("bit2:",basis_bits.bit_2);
     278        print_register("bit3:",basis_bits.bit_3);
     279        print_register("bit4:",basis_bits.bit_4);
     280        print_register("bit5:",basis_bits.bit_5);
     281        print_register("bit6:",basis_bits.bit_6);
     282        print_register("bit7:",basis_bits.bit_7);                                       
    260283}
    261284/*
     
    304327*/
    305328
    306 inline char ElemEnd_grouping(char *source,int block_base,int pos) {
     329static inline char ElemEnd_grouping(char *source,int block_base,int pos) {
    307330    int end = block_base + pos;
    308331    int start = ScanBackwardPos(&elem_starts, pos) + block_base;
     
    315338   
    316339    if (start<0){
     340#ifdef DEBUG
    317341            fprintf(gid_writein,"name_buffer %s\n",element_name_buffer);
     342#endif
    318343        memmove (&name_buffer[0],&element_name_buffer[ELEMENT_BUFFER_SIZE+start],-start);       
    319344        memmove (&name_buffer[-start],&source[0],50+start);
    320345        name = name_buffer;
    321346        //fprintf (gid_writein,"name_buffer %s",name);
     347#ifdef DEBUG
    322348        fprintf(gid_writein,"name_buffer %s\n",name);
     349#endif
    323350    }
    324351//    cout << end << "  " << start << endl;
     
    395422*/
    396423    gids.push_back(gid);
    397 #if DEBUG
     424#ifdef DEBUG
    398425    char* symbol = new char[lgth+1];
    399426    strncpy ( symbol, source + start, lgth );
     
    405432}
    406433
     434static inline int print_source(char* source, int lgth ,int seg){
     435        char ret[128];
     436        int j;
     437        for (int i=0;i<seg;i++){
     438                for(j=0;j<lgth;j++){
     439                        if(source[i*lgth+j]!='\n')
     440                                ret[j] = source[i*lgth + j];
     441                        else
     442                                ret[j] = ' ';
     443                }
     444                ret[j] = '\0';
     445//              cout << ret << endl;
     446        }
     447        return 0;
     448}
     449
     450static inline void validate_data_type(int char_aval, int gid_index){
     451        struct Lex lex;
     452        struct Output output;
     453        Classify_bytes_Validate_utf8 classify_bytes_Validate_utf8;
     454        U8 u8;
     455        Basis_bits temp_basis_bits;
     456        Validate_content_5 validate_content_5;
     457       
     458        if(char_aval == BLOCK_SIZE){
     459                s2p_do_block((BytePack*)(&content_buffer), temp_basis_bits);
     460#ifdef DEBUG
     461                print_basis_bits(temp_basis_bits);
     462#endif
     463                classify_bytes_Validate_utf8.do_block(temp_basis_bits,lex,u8);
     464#ifdef  DEBUG
     465                cout << content_buffer << endl;
     466               
     467                print_register("digit:",lex.Digit);
     468                print_register("dot:",lex.Dot);
     469                print_register("namescan:",lex.NameScan);
     470                print_register("P_N:",lex.P_H_sign);
     471                print_register("content_end:",lex.content_end);
     472#endif
     473                validate_content_5.do_block(lex,output);
     474#ifdef DEBUG
     475                print_register("output:",output.matches);
     476                print_register("output.tem:",output.tem);
     477#endif
     478        }else{
     479                int remaining = BLOCK_SIZE -char_aval;
     480                BitBlock EOF_mask = bitblock::srl(simd<1>::constant<1>(),convert(BLOCK_SIZE-remaining));
     481                s2p_do_final_block((BytePack*)(&content_buffer), temp_basis_bits,EOF_mask);
     482                classify_bytes_Validate_utf8.do_final_block(temp_basis_bits,lex,u8,EOF_mask);
     483                validate_content_5.do_final_block(lex,output,EOF_mask);
     484        }
     485}
     486
    407487//template <int L>
    408 static inline int StreamScanLengthGrouping(char *source,int block_base,ScanBlock * stream, ScanBlock * stream2, int blk_count) {
     488static inline int StreamScanLengthGrouping(char *source,int block_base,ScanBlock * stream, ScanBlock * stream2, int blk_count,ScanBlock * stream3,ScanBlock * stream4) {
    409489    int blk;
    410490    int block_pos = 0;
     
    418498                ScanBlock s = stream[blk];
    419499                ScanBlock s2 = stream2[blk];
     500                ScanBlock s3 = stream3[blk];
     501                ScanBlock s4 = stream4[blk];
     502                int end_content;
     503                int start_content;
     504                int content_lgth;
     505                int content_aval = CONTENT_BUFFER_SIZE - content_buffer_pos;
     506
     507                if (content_carry == 1){
     508                end_content = cfzl(s4) + block_pos;
     509                start_content = block_pos-1;
     510                content_lgth = end_content-block_pos;
     511                int buffer_full = 0;
     512                if(content_aval > content_lgth-1 && content_lgth > 1 && gid == CONTENT_INDEX){
     513//                      cout << "lgth " << content_lgth << endl;
     514                        memmove(&content_buffer[content_buffer_pos],&source[block_pos+block_base],content_lgth-1);
     515                        char temp = '#';
     516                        content_buffer_pos += content_lgth-1;
     517                        memmove(&content_buffer[content_buffer_pos],&temp,1);
     518                        content_buffer_pos ++;
     519                        content_buffer[content_buffer_pos] = '\0';
     520//                      cout << "^^^" << endl;
     521//                      cout << content_buffer_pos << "         " << CONTENT_BUFFER_SIZE << "           "<< content_lgth-1 << endl;
     522//                      cout << content_buffer << endl;
     523                                s4 = s4 & (s4-1);
     524                }else if (content_lgth == 0 && gid == CONTENT_INDEX){
     525//                      cout << "!!!" << endl;
     526                        content_buffer[content_buffer_pos-1] = '#';
     527                }else if (content_aval > 0 && content_lgth == 1 && gid == CONTENT_INDEX){
     528                        content_buffer[content_buffer_pos] = '#';
     529                        content_buffer_pos++;
     530                        if(content_buffer_pos == CONTENT_BUFFER_SIZE){
     531                                validate_data_type(CONTENT_BUFFER_SIZE,5);
     532                                content_buffer_pos = 0;
     533                        }
     534                }else if (content_aval <= content_lgth-1 && gid == CONTENT_INDEX){
     535//                      cout << "@@@@@@@@@@@@@@@@@@" << endl;
     536                        memmove(&content_buffer[content_buffer_pos],&source[block_pos+block_base],content_aval);
     537                        memmove(&content_lookahead_buffer[0],&source[block_pos+block_base+content_aval],content_lgth-1-content_aval);
     538//                      cout << "$$$" << endl;
     539                        content_buffer_pos = content_lgth-1-content_aval;
     540//                      cout << content_buffer_pos << "         " << CONTENT_BUFFER_SIZE << "           "<< content_aval << endl;
     541//                              content_buffer[CONTENT_BUFFER_SIZE-1] = '\0';
     542//                              cout << content_buffer << endl << endl;
     543                        validate_data_type(CONTENT_BUFFER_SIZE,5);
     544                        memmove(&content_buffer[0],&content_lookahead_buffer[0],content_buffer_pos);
     545                        if (content_lgth-1 < CONTENT_BUFFER_SIZE){
     546                                content_buffer[content_buffer_pos] = '#';
     547                                content_buffer_pos ++;
     548                        }
     549                }
     550                content_carry = 0;
     551            }
     552//              print_source(&source[block_base],sizeof(ScanBlock)*8,2);
     553//              print_register("start_content:",((BitBlock*)stream3)[0]);
     554//              print_register("end_content:",((BitBlock*)stream4)[0]);
    420555//              cout << s << "  " << s2 << endl;
    421556//              print_register("s:",((BitBlock*)stream)[0]);
     
    442577                                                        current_depth = pre_index.back();
    443578                                                        pre_index.pop_back();
     579#ifdef DEBUG
    444580                                                        fprintf (gid_writein,"%d\n",current_depth);
     581#endif
    445582                                                        gid_vec[current_depth].push_back(0);
    446583                                                }
     
    450587                                s2 = s2 & (s2 - 1);
    451588//                              cout << "after" << s2 << endl;
    452 //                      cout << "s2 = " << s2 << endl;
     589//                              cout << "s2 = " << s2 << endl;
    453590                }else{
    454591//                      cout << " end_pos == " << end_pos<<endl;
    455592//                      cout << " end_tag_pos == " << end_tag << endl;
    456                         char gid = ElemEnd_grouping(source,block_base,end_pos);
     593                        gid = ElemEnd_grouping(source,block_base,end_pos);
     594                        start_content = cfzl(s3) + block_pos;
     595                        while(start_content < end_pos){
     596                                s3 = s3 & (s3-1);
     597                                start_content = cfzl(s3) + block_pos;
     598                        }
     599//                      cout << "end_pos " << end_pos <<endl;
     600//                      char temp[20];
     601//                      memmove(temp,&source[end_pos+block_base],20);
     602//                      cout << "source: " << temp << endl;
     603                        //cout << "start_content " << start_content << endl;
     604                       
     605                        end_content = cfzl(s4) + block_pos;
     606                        while(end_content < start_content){
     607                                s4 = s4 & (s4-1);
     608                                end_content = cfzl(s4) + block_pos;
     609                        }
     610//                      cout << "cfzl" << cfzl(s4) << " " <<sizeof(ScanBlock) <<endl;
     611                        if(cfzl(s4)==8*sizeof(ScanBlock)){
     612                                content_carry = 1;
     613//                              cout << "end_of_block" << endl;
     614                        }
     615                        content_lgth = end_content - start_content;
     616//                      cout << "lgth: " << content_lgth << endl;
     617                        content_aval = CONTENT_BUFFER_SIZE - content_buffer_pos;
     618                        int full_content = 0;
     619                        int buffer_full = 0;
     620                        if(content_carry != 1){
     621                                if(content_aval > content_lgth-2 && content_lgth > 2 && gid == CONTENT_INDEX){
     622                                        memmove(&content_buffer[content_buffer_pos],&source[start_content+block_base+1],content_lgth-2);
     623                                        char temp = '#';
     624                                        content_buffer_pos += content_lgth-2;
     625                                        memmove(&content_buffer[content_buffer_pos],&temp,1);
     626                                        content_buffer_pos ++;
     627//                                      cout << content_buffer_pos << "         " << CONTENT_BUFFER_SIZE << endl;
     628//                                              cout << content_buffer_pos << "         " << CONTENT_BUFFER_SIZE << "           "<< content_lgth-2 << endl;
     629                                }else if(gid == CONTENT_INDEX){
     630                                                memmove(&content_buffer[content_buffer_pos],&source[start_content+block_base+1],content_aval);
     631                                                full_content = 1;
     632                                               
     633                                                content_buffer_pos += content_aval;
     634                                                memmove(&content_lookahead_buffer[0],&source[start_content+block_base+1+content_aval],content_lgth-2-content_aval);
     635//                                              cout << content_buffer_pos << "         " << CONTENT_BUFFER_SIZE << "           "<< content_aval << endl;       
     636                                                content_buffer_pos = content_lgth-2-content_aval;
     637                                                buffer_full = 1;
     638                                }
     639                        }else{
     640                                if(content_aval > content_lgth-1 && content_lgth > 1 && gid == CONTENT_INDEX){
     641                                        memmove(&content_buffer[content_buffer_pos],&source[start_content+block_base+1],content_lgth-1);
     642                                        content_buffer_pos += content_lgth-1;
     643                                        full_content = 1;
     644//                                      cout << content_carry << endl;
     645//                                      cout << content_buffer << endl << endl;
     646//                                      cout << content_buffer_pos << "         " << CONTENT_BUFFER_SIZE<< "            "<< content_lgth-1 << endl;             
     647                                }else if(content_aval < content_lgth-1 && gid == CONTENT_INDEX){
     648                                                memmove(&content_buffer[content_buffer_pos],&source[start_content+block_base+1],content_aval);
     649                                               
     650                                                content_buffer_pos += content_aval;
     651//                                              cout << "***" << endl;
     652//                                              cout << content_aval << "   " << content_lgth << endl;
     653                                                memmove(&content_lookahead_buffer[0],&source[start_content+block_base+1+content_aval],content_lgth-1-content_aval);
     654//                                              full_content = 1;
     655//                                              cout << content_buffer_pos << "         " << CONTENT_BUFFER_SIZE << "           "<< content_aval << endl;       
     656                                                content_buffer_pos = content_lgth-1-content_aval;
     657                                                buffer_full = 1;
     658                                }
     659                        }
     660                        if (buffer_full == 1){
     661//                              cout << "buffer_full" << endl;
     662//                                  content_buffer[CONTENT_BUFFER_SIZE-1] = '\0';
     663//                              cout << content_buffer << endl << endl;
     664                                validate_data_type(CONTENT_BUFFER_SIZE,5);
     665                                memmove(&content_buffer[0],&content_lookahead_buffer[0],content_buffer_pos);
     666                                if (full_content == 1){
     667                                        char temp = '#';
     668                                        memmove(&content_buffer[content_buffer_pos],&temp,1);
     669                                        content_buffer_pos ++;
     670                                        full_content = 0;
     671                                }
     672                                buffer_full = 0;
     673                        }
     674                       
     675//                      content_buffer[content_buffer_pos] = '\0';
     676//                      cout << content_buffer << endl;
    457677                        if (s!=0){
    458678                                s = s & (s-1);  // clear rightmost bit.
     
    463683                                if (gid != 0){
    464684                                        gid_vec[current_depth].push_back(gid);
     685#ifdef DEBUG
    465686                                        fprintf (gid_writein,"%d\n",current_depth);
     687#endif
    466688                                        pre_index.push_back(current_depth);
    467689                                        current_depth = (int)gid;
    468690                                        gid_vec[current_depth].push_back(gid);
     691#ifdef DEBUG
    469692                                        fprintf (gid_writein,"%d\n",current_depth);                     
     693#endif
    470694                                }
    471                 }
     695                }       
    472696                }
    473697                block_pos += 8 * sizeof(ScanBlock);
     
    642866
    643867
    644 @global
    645 
    646 #include <simd-lib/transpose.hpp>
    647 #include <post_process.hpp>
     868
    648869/*
    649870static inline void s2p_do_block(BytePack U8[], Basis_bits & basis_bits) {
     
    664885}
    665886*/
    666 static inline void print_basis_bits(Basis_bits & basis_bits){
    667         print_register("bit0:",basis_bits.bit_0);
    668         print_register("bit1:",basis_bits.bit_1);
    669         print_register("bit2:",basis_bits.bit_2);
    670         print_register("bit3:",basis_bits.bit_3);
    671         print_register("bit4:",basis_bits.bit_4);
    672         print_register("bit5:",basis_bits.bit_5);
    673         print_register("bit6:",basis_bits.bit_6);
    674         print_register("bit7:",basis_bits.bit_7);                                       
    675 }
    676887
    677888static inline void print_elem_vec(vector<char>* vec, int size, int depth){
     
    687898        int next_pos = 0;
    688899        int match_pos = 0;
    689         cout << str <<" = " << index <<endl;
     900//      cout << str <<" = " << index <<endl;
    690901//      cout << "vec_scan" << endl;
     902        cout << f_vec_scanner.get_final_pos() << "&&" << endl;
    691903        if(f_vec_scanner.has_next()){
    692904                current_pos = f_vec_scanner.scan_to_next();
     
    705917                return;
    706918        }
     919        while(1){
     920                if(f_vec_scanner.has_next()){
     921                        next_pos = f_vec_scanner.scan_to_next();
     922                }else{
     923                        next_pos = -1;
     924                }
     925                if(next_pos > match_pos){
     926                        cout <<"##" << next_pos << "  " << match_pos << endl;
     927                        current_pos = next_pos;
     928                        match_pos = match_scanner.scan_to_next();
     929                        continue;
     930                }else if(next_pos == -1){
     931                        break;
     932                }else if(next_pos < match_pos){
     933                        cout << next_pos << "  " << match_pos << endl;
     934                        printf("Mismatch found at pos of %s %d: %d.\n",str,index,current_pos);
     935                        current_pos = next_pos;
     936                }
     937        }
     938/*     
    707939        while(1){
    708940                if(f_vec_scanner.has_next()){
     
    729961                current_pos = next_pos;
    730962        }
     963*/
    731964}
    732965
    733966static inline void validate_mul_block(){
    734967        struct Elem elem;
    735         Validation_1 validation_1;
    736 //      Validation_2 validation_2;
    737 //      Validation_3 validation_3;
    738 //      Validation_4 validation_4;     
    739         Validation_5 validation_5;
    740         Validation_24 validation_24;
    741         Validation_25 validation_25;
    742         Validation_27 validation_27;
    743         Validation_35 validation_35;
    744         Validation_41 validation_41;
    745         Validation_45 validation_45;
     968        Validation_2 validation_2;
     969        Validation_4 validation_4;
     970        Validation_9 validation_9;
    746971       
    747972        struct Lex lex;
     
    751976        Classify_bytes classify_bytes;
    752977        int j;
     978#ifdef DEBUG
    753979        for(j=0;j<MAX_COUNT;j++){
    754980        int lgth = gid_vec[j].size();
     
    756982                        print_elem_vec(&(gid_vec[j]),lgth,j);
    757983        }
     984#endif
     985
     986        int lgth;
    758987        for(j=0;j<MAX_COUNT;j++){
    759                 int lgth = gid_vec[j].size();
     988                lgth = gid_vec[j].size();
     989                int remaining = 0;
     990                Basis_bits temp_basis_bits;
     991                const int num_block = lgth /(BLOCK_SIZE *8 / VECTOR_WIDTH);
     992                int i = 0;
     993                int block_base;
     994                if(lgth != 0){ 
     995                        remaining = lgth %(BLOCK_SIZE *8 / VECTOR_WIDTH);
     996                        for(i = 0;i < num_block; i++){
     997                                block_base = i*BLOCK_SIZE;
     998                               
     999                                s2p_do_block((BytePack*)(&(gid_vec[j][block_base])), temp_basis_bits);
     1000                                classify_bytes.do_block(temp_basis_bits,lex);
     1001                                switch (j){
     1002                                        case 2:
     1003                                        validation_2.do_block(lex,output);
     1004#ifdef DEBUG                           
     1005                                        print_register("cc2",lex.cc2);
     1006                                        print_register("match_2",output.matches);
     1007#endif
     1008                                        break;
     1009                                        case 4:
     1010                                        validation_4.do_block(lex,output);
     1011#ifdef DEBUG
     1012                                        print_register("cc4",lex.cc4);
     1013                                        print_register("match_4",output.matches);
     1014#endif
     1015                                        break;
     1016                                        case 9:
     1017                                        validation_9.do_block(lex,output);
     1018#ifdef DEBUG
     1019                                        print_register("cc9",lex.cc9);
     1020                                        print_register("match_9",output.matches);
     1021#endif
     1022                                        break;
     1023                                }
     1024                        }
     1025                        if (remaining !=0){
     1026                                block_base = i*BLOCK_SIZE;
     1027                                //cout << "block_base " << block_base << endl;
     1028                                BitBlock EOF_mask = bitblock::srl(simd<1>::constant<1>(),convert(BLOCK_SIZE-remaining));
     1029                                s2p_do_final_block((BytePack*)(&(gid_vec[j][block_base])), temp_basis_bits,EOF_mask);
     1030                                classify_bytes.do_final_block(temp_basis_bits,lex,EOF_mask);
     1031                                switch (j){
     1032                                        case 2:
     1033                                        validation_2.do_final_block(lex,output,EOF_mask);
     1034#ifdef DEBUG
     1035//                                      cout << remaining << endl;
     1036                                        print_register("cc2",lex.cc2);
     1037//                                      print_register("cc3",lex.cc3);
     1038//                                      print_register("cc4",lex.cc4);
     1039//                                      print_register("cc9",lex.cc9);
     1040                                        print_register("match_2",output.matches);
     1041#endif
     1042                                        break;
     1043                                        case 4:
     1044                                        validation_4.do_final_block(lex,output,EOF_mask);
     1045#ifdef DEBUG
     1046                                        print_register("cc4",lex.cc4);
     1047                                        print_register("match_4",output.matches);
     1048#endif
     1049                                        break;
     1050                                        case 9:
     1051                                        validation_9.do_final_block(lex,output,EOF_mask);
     1052#ifdef DEBUG
     1053                                        print_register("cc9",lex.cc9);
     1054                                        print_register("match_9",output.matches);
     1055#endif
     1056                                        break;
     1057                                }
     1058                        }
     1059                }
     1060        }
     1061}
     1062
     1063
     1064
     1065/*
     1066
     1067static inline void validate_mul_block(){
     1068        struct Elem elem;
     1069        Validation_2 validation_2;
     1070//      Validation_2 validation_2;
     1071        Validation_4 validation_4;
     1072        Validation_9 validation_9;
     1073//      Validation_4 validation_4;     
     1074//      Validation_5 validation_5;
     1075//      Validation_24 validation_24;
     1076//      Validation_25 validation_25;
     1077//      Validation_27 validation_27;
     1078//      Validation_35 validation_35;
     1079//      Validation_41 validation_41;
     1080//      Validation_45 validation_45;
     1081       
     1082        struct Lex lex;
     1083       
     1084        struct Output output;
     1085
     1086        Classify_bytes classify_bytes;
     1087        int j;
     1088#ifdef DEBUG
     1089        for(j=0;j<MAX_COUNT;j++){
     1090        int lgth = gid_vec[j].size();
     1091                if(!gid_vec[j].empty())
     1092                        print_elem_vec(&(gid_vec[j]),lgth,j);
     1093        }
     1094#endif
     1095        BitStreamScanner<BitBlock, uint64_t,uint64_t, 32> match_scanner;
     1096        BitStreamScanner<BitBlock, uint64_t,uint64_t, 32> f_vec_scanner;
     1097        match_scanner.init();
     1098        f_vec_scanner.init();
     1099        int lgth;
     1100        for(j=0;j<MAX_COUNT;j++){
     1101                lgth = gid_vec[j].size();
    7601102                int remaining = 0;
    7611103                Basis_bits temp_basis_bits;
     
    7641106                int block_base;
    7651107               
    766                 BitStreamScanner<BitBlock, uint64_t,uint64_t, 32> match_scanner;
    767                 BitStreamScanner<BitBlock, uint64_t,uint64_t, 32> f_vec_scanner;
    768                 match_scanner.init();
    769                 f_vec_scanner.init();
    770                
    7711108                if(lgth != 0){ 
    7721109                        remaining = lgth %(BLOCK_SIZE *8 / VECTOR_WIDTH);
    7731110                        for(i = 0;i < num_block; i++){
    7741111                                block_base = i*BLOCK_SIZE;
     1112                                //cout << "block_base " << block_base << endl;
    7751113                       
    7761114                                s2p_do_block((BytePack*)(&(gid_vec[j][block_base])), temp_basis_bits);
    777                                 //print_elem_vec(&(gid_vec[j]),lgth,j);
     1115                                //print_elem_vec(&((vector*)(gid_vec[j][block_base])),BLOCK_SIZE,j);
    7781116                                //print_basis_bits(temp_basis_bits);
    7791117
    7801118                                classify_bytes.do_block(temp_basis_bits,lex);
    7811119                                switch (j){
    782                                         case 1:
    783                                         validation_1.do_block(lex,output);
    784                                         f_vec_scanner.load_block(lex.cc1,i);
    785                                         break;
    786                                         /*
    7871120                                        case 2:
    7881121                                        validation_2.do_block(lex,output);
    7891122                                        f_vec_scanner.load_block(lex.cc2,i);
    790                                         break;
    791                                         case 3:
    792                                         validation_3.do_block(lex,output);
    793                                         f_vec_scanner.load_block(lex.cc3,i);
     1123#ifdef DEBUG                           
     1124                                        print_register("cc2",lex.cc2);
     1125                                        print_register("match_2",output.matches);
     1126#endif
    7941127                                        break;
    7951128                                        case 4:
    7961129                                        validation_4.do_block(lex,output);
    7971130                                        f_vec_scanner.load_block(lex.cc4,i);
     1131#ifdef DEBUG
     1132                                        print_register("cc4",lex.cc4);
     1133                                        print_register("match_4",output.matches);
     1134#endif
    7981135                                        break;
    799                                         */
    800                                         case 5:
    801                                         validation_5.do_block(lex,output);
    802                                         f_vec_scanner.load_block(lex.cc5,i);
    803                                         break;
    804                                         case 24:
    805                                         validation_24.do_block(lex,output);
    806                                         f_vec_scanner.load_block(lex.cc24,i);
    807                                         print_register("cc24",lex.cc24);
    808                                         print_register("match_24",output.matches);
    809                                         break;
    810                                         case 25:
    811                                         validation_25.do_block(lex,output);
    812                                         f_vec_scanner.load_block(lex.cc25,i);
    813                                         break;
    814                                         case 27:
    815                                         validation_27.do_block(lex,output);
    816                                         f_vec_scanner.load_block(lex.cc27,i);
    817                                         break;
    818                                         case 35:
    819                                         validation_35.do_block(lex,output);
    820                                         f_vec_scanner.load_block(lex.cc35,i);
    821                                         break;
    822                                         case 41:
    823                                         validation_41.do_block(lex,output);
    824                                         f_vec_scanner.load_block(lex.cc41,i);
    825                                         break;
    826                                         case 45:
    827                                         validation_45.do_block(lex,output);
    828                                         f_vec_scanner.load_block(lex.cc45,i);
     1136                                        case 9:
     1137                                        validation_9.do_block(lex,output);
     1138                                        f_vec_scanner.load_block(lex.cc9,i);
     1139#ifdef DEBUG
     1140                                        print_register("cc9",lex.cc9);
     1141                                        print_register("match_9",output.matches);
     1142#endif
    8291143                                        break;
    8301144                                }
    8311145
    8321146                                match_scanner.load_block(output.matches,i);
    833                                 /*
    834                                 switch (j){
    835                                         case 1:
    836                                         f_vec_scanner.load_block(lex.cc1,i);
    837                                         break;
    838                                         case 5:
    839                                         f_vec_scanner.load_block(lex.cc5,i);
    840                                         break;
    841                                 }
    842                                 */
    8431147
    8441148                        }
    8451149                        if (remaining !=0){
     1150                                block_base = i*BLOCK_SIZE;
     1151                                //cout << "block_base " << block_base << endl;
    8461152                                BitBlock EOF_mask = bitblock::srl(simd<1>::constant<1>(),convert(BLOCK_SIZE-remaining));
    8471153                                s2p_do_final_block((BytePack*)(&(gid_vec[j][block_base])), temp_basis_bits,EOF_mask);
    848                                 //print_elem_vec(&(gid_vec[j]),lgth,j);
     1154                                //print_elem_vec(&((vector*)(gid_vec[j][block_base])),BLOCK_SIZE,j);
    8491155                                //print_basis_bits(temp_basis_bits);
     1156                                //print_elem_vec((vector<char>*)(gid_vec[j][block_base]),remaining,j);
    8501157                       
    8511158                                classify_bytes.do_final_block(temp_basis_bits,lex,EOF_mask);
    8521159                                switch (j){
    853                                         case 1:
    854                                         validation_1.do_final_block(lex,output,EOF_mask);
    855                                         f_vec_scanner.load_block(lex.cc1,i);
    856                                         print_register("cc1",lex.cc1);
    857                                         print_register("match_1",output.matches);
     1160                                        case 2:
     1161                                        validation_2.do_final_block(lex,output,EOF_mask);
     1162                                        f_vec_scanner.load_block(lex.cc2,i);
     1163#ifdef DEBUG
     1164//                                      cout << remaining << endl;
     1165                                        print_register("cc2",lex.cc2);
     1166//                                      print_register("cc3",lex.cc3);
     1167//                                      print_register("cc4",lex.cc4);
     1168//                                      print_register("cc9",lex.cc9);
     1169                                        print_register("match_2",output.matches);
     1170#endif
    8581171                                        break;
    859                                         case 5:
    860                                         validation_5.do_final_block(lex,output,EOF_mask);
    861                                         f_vec_scanner.load_block(lex.cc5,i);
    862                                         print_register("cc5",lex.cc5);
    863                                         print_register("match_5",output.matches);
     1172                                        case 4:
     1173                                        validation_4.do_final_block(lex,output,EOF_mask);
     1174                                        f_vec_scanner.load_block(lex.cc4,i);
     1175#ifdef DEBUG
     1176                                        print_register("cc4",lex.cc4);
     1177                                        print_register("match_4",output.matches);
     1178#endif
    8641179                                        break;
    865                                         case 24:
    866                                         validation_24.do_final_block(lex,output,EOF_mask);
    867                                         f_vec_scanner.load_block(lex.cc24,i);
    868                                         print_register("cc24",lex.cc24);
    869                                         print_register("match_24",output.matches);
    870                                         break;
    871                                         case 25:
    872                                         validation_25.do_final_block(lex,output,EOF_mask);
    873                                         f_vec_scanner.load_block(lex.cc25,i);
    874                                         break;
    875                                         case 27:
    876                                         validation_27.do_final_block(lex,output,EOF_mask);
    877                                         f_vec_scanner.load_block(lex.cc27,i);
    878                                         break;
    879                                         case 35:
    880                                         validation_35.do_final_block(lex,output,EOF_mask);
    881                                         f_vec_scanner.load_block(lex.cc35,i);
    882                                         break;
    883                                         case 41:
    884                                         validation_41.do_final_block(lex,output,EOF_mask);
    885                                         f_vec_scanner.load_block(lex.cc41,i);
    886                                         break;
    887                                         case 45:
    888                                         validation_45.do_final_block(lex,output,EOF_mask);
    889                                         f_vec_scanner.load_block(lex.cc45,i);
     1180                                        case 9:
     1181                                        validation_9.do_final_block(lex,output,EOF_mask);
     1182                                        f_vec_scanner.load_block(lex.cc9,i);
     1183#ifdef DEBUG
     1184                                        print_register("cc9",lex.cc9);
     1185                                        print_register("match_9",output.matches);
     1186#endif
    8901187                                        break;
    8911188                                }
    892 
     1189                               
    8931190                                match_scanner.load_block(output.matches,i);
    8941191                        }
    8951192                }
    896                 if(lgth != 0){
     1193        }
     1194        if(lgth != 0){
    8971195                        vec_scan(match_scanner,f_vec_scanner,"Element",j);     
    898                 }
    8991196        }
    9001197       
    901 /*     
    902         for(j=0;j<MAX_COUNT;j++){
    903                 int lgth = gid_vec[j].size();
    904                 int remaining = 0;
    905                 Basis_bits temp_basis_bits;
    906                 const int num_block = lgth /(BLOCK_SIZE *8 / VECTOR_WIDTH);
    907                 int i = 0;
    908                 int block_base;
    909        
    910                 BitStreamScanner<BitBlock, uint64_t,uint64_t, 32> match_scanner_1;
    911                 BitStreamScanner<BitBlock, uint64_t,uint64_t, 32> f_vec_scanner_1;
    912                 match_scanner_1.init();
    913                 f_vec_scanner_1.init();
    914                 BitStreamScanner<BitBlock, uint64_t,uint64_t, 32> match_scanner_5;
    915                 BitStreamScanner<BitBlock, uint64_t,uint64_t, 32> f_vec_scanner_5;
    916                 match_scanner_5.init();
    917                 f_vec_scanner_5.init();
    918                 BitStreamScanner<BitBlock, uint64_t,uint64_t, 32> match_scanner_25;
    919                 BitStreamScanner<BitBlock, uint64_t,uint64_t, 32> f_vec_scanner_25;
    920                 match_scanner_25.init();
    921                 f_vec_scanner_25.init();
    922        
    923                 if(lgth != 0){ 
    924                         remaining = lgth %(BLOCK_SIZE *8 / VECTOR_WIDTH);
    925                         for(i = 0;i < num_block; i++){
    926                                 block_base = i*BLOCK_SIZE;
    927                        
    928                                 s2p_do_block((BytePack*)(&(gid_vec[j][block_base])), temp_basis_bits);
    929                                 print_elem_vec(&(gid_vec[j]),lgth,j);
    930                                 print_basis_bits(temp_basis_bits);
    931 
    932                                 classify_bytes.do_block(temp_basis_bits,lex);
    933                                 validation_1.do_block(lex,output_1);
    934                                 validation_5.do_block(lex,output_5);
    935                                 validation_25.do_block(lex,output_25);
    936 
    937                                 match_scanner_1.load_block(output_1.matches,i);
    938                                 f_vec_scanner_1.load_block(lex.cc1,i);
    939                                 match_scanner_5.load_block(output_5.matches,i);
    940                                 f_vec_scanner_5.load_block(lex.cc5,i);
    941                                 match_scanner_25.load_block(output_25.matches,i);
    942                                 f_vec_scanner_25.load_block(lex.cc25,i);
    943                                 print_register("cc5",lex.cc5);
    944                                 print_register("cc25",lex.cc25);
    945                                 print_register("match_25",output_25.matches);
    946 
    947                         }
    948                         if (remaining !=0){
    949                                 BitBlock EOF_mask = bitblock::srl(simd<1>::constant<1>(),convert(BLOCK_SIZE-remaining));
    950                                 s2p_do_final_block((BytePack*)(&(gid_vec[j][block_base])), temp_basis_bits,EOF_mask);
    951                                 print_elem_vec(&(gid_vec[j]),lgth,j);
    952                                 print_basis_bits(temp_basis_bits);
    953                        
    954                                 classify_bytes.do_block(temp_basis_bits,lex);
    955                                 validation_1.do_block(lex,output_1);
    956                                 validation_5.do_block(lex,output_5);
    957                                 validation_25.do_block(lex,output_25);
    958                        
    959                                 match_scanner_1.load_block(output_1.matches,i);
    960                                 f_vec_scanner_1.load_block(lex.cc1,i);
    961                                 match_scanner_5.load_block(output_5.matches,i);
    962                                 f_vec_scanner_5.load_block(lex.cc5,i);
    963                                 match_scanner_25.load_block(output_25.matches,i);
    964                                 f_vec_scanner_25.load_block(lex.cc25,i);
    965                                 print_register("cc25",lex.cc25);
    966                         }
    967                 }
    968                 vec_scan(match_scanner_1,f_vec_scanner_1,"Element_1");
    969                 vec_scan(match_scanner_5,f_vec_scanner_5,"Element_5");
    970                 vec_scan(match_scanner_25,f_vec_scanner_25,"Element_25");
    971         }
     1198
     1199}
     1200
     1201
    9721202*/
    973 }
    974 
    9751203
    9761204/*
     
    11631391//    pre_index.push(0);
    11641392   
    1165         StreamScanLengthGrouping(source,block_base,(ScanBlock *) &tag_Callouts.ElemName_ends,(ScanBlock *) &tag_Callouts.Tag_closing, sizeof(BitBlock)/sizeof(ScanBlock));
     1393        StreamScanLengthGrouping(source,block_base,(ScanBlock *) &tag_Callouts.ElemName_ends,(ScanBlock *) &tag_Callouts.Tag_closing, sizeof(BitBlock)/sizeof(ScanBlock),(ScanBlock *) &tag_Callouts.Content_starts,(ScanBlock *) &tag_Callouts.EndTag_marks);
    11661394       
    11671395        // Store the last starting position in case we hit boundary case
     
    14131641                        break;         
    14141642                }
     1643#ifdef DEBUG
    14151644                fprintf (gid_writein,"%s |  lgth: %i | hashvalue: %i | gid: %i | symbol: %s\n", __FUNCTION__,  lgth, hashvalue, gid, symbol);
     1645#endif
    14161646        }       
    14171647        fclose(element_ID_in);
     
    16591889        //cout << "validate start" << endl;
    16601890        //validate();
    1661         validate_mul_block();
     1891//      validate_mul_block();
    16621892
    16631893        PERF_SEC_DUMP(parser_timer);
Note: See TracChangeset for help on using the changeset viewer.