Changeset 3353


Ignore:
Timestamp:
Jun 24, 2013, 2:56:08 PM (6 years ago)
Author:
shiyangy
Message:

template modified, validation_functions file added

Location:
proto/xmlschema
Files:
3 added
2 edited

Legend:

Unmodified
Added
Removed
  • proto/xmlschema/validation_template_onevec.cpp

    r3319 r3353  
    126126                if ((ux%2) == 1){
    127127                        if(n==64){
    128                                 cout << ux <<endl;
     128//                              cout << ux <<endl;
    129129                        }
    130130                        return n;               
     
    194194PBGSIdentitySymbolTable pbgs_symbol_table;
    195195
    196 vector <char> gid_vec;
     196#define MAX_COUNT 128
     197vector <char> gid_vec[MAX_COUNT];
     198int current_depth = 0;
     199vector <int> pre_index;
    197200
    198201stack <vector<char>* > elem_vec_stack;
     
    201204static inline int ScanBackwardPos(BitBlock * block, int pos)
    202205{
    203         cout << "pos " << pos << endl;
     206//      cout << "pos " << pos << endl;
    204207    BitBlock s = block[0];
    205208    if (bitblock::any(block[0])){
    206         print_register("zero",block[0]);
    207         print_register("t",simd_not(simd<128>::sll(simd<1>::constant<1>(), convert(pos))) );
     209//      print_register("zero",block[0]);
     210//      print_register("t",simd_not(simd<128>::sll(simd<1>::constant<1>(), convert(pos))) );
    208211        }
    209212    BitBlock temp = simd_and( s, simd_not(simd<128>::sll(simd<1>::constant<1>(), convert(pos))) );
    210213//      print_register("zero",simd_not(simd<128>::sll(simd<1>::constant<1>());
    211                 print_register("temp",temp);
     214//              print_register("temp",temp);
    212215    if (bitblock::any(temp))
    213216    {
     
    312315   
    313316    if (start<0){
     317            fprintf(gid_writein,"name_buffer %s\n",element_name_buffer);
    314318        memmove (&name_buffer[0],&element_name_buffer[ELEMENT_BUFFER_SIZE+start],-start);       
    315         memmove (&element_name_buffer[ELEMENT_BUFFER_SIZE+start],&source[0],50+start);
     319        memmove (&name_buffer[-start],&source[0],50+start);
    316320        name = name_buffer;
     321        //fprintf (gid_writein,"name_buffer %s",name);
     322        fprintf(gid_writein,"name_buffer %s\n",name);
    317323    }
    318324//    cout << end << "  " << start << endl;
     
    332338    {
    333339    case 1:
    334         gid = pbgs_symbol_table.Lookup_or_Insert_Name<1>(source + start, hashvalue);
     340        gid = pbgs_symbol_table.Lookup_or_Insert_Name<1>(name, hashvalue);
    335341        break;
    336342    case 2:
    337         gid = pbgs_symbol_table.Lookup_or_Insert_Name<2>(source + start, hashvalue);
     343        gid = pbgs_symbol_table.Lookup_or_Insert_Name<2>(name, hashvalue);
    338344        break;
    339345    case 3:
    340         gid = pbgs_symbol_table.Lookup_or_Insert_Name<3>(source + start, hashvalue);
     346        gid = pbgs_symbol_table.Lookup_or_Insert_Name<3>(name, hashvalue);
    341347        break;
    342348    case 4:
    343         gid = pbgs_symbol_table.Lookup_or_Insert_Name<4>(source + start, hashvalue);
     349        gid = pbgs_symbol_table.Lookup_or_Insert_Name<4>(name, hashvalue);
    344350        break;
    345351    case 5:
    346         gid = pbgs_symbol_table.Lookup_or_Insert_Name<5>(source + start, hashvalue);
     352        gid = pbgs_symbol_table.Lookup_or_Insert_Name<5>(name, hashvalue);
    347353        break;
    348354    case 6:
    349         gid = pbgs_symbol_table.Lookup_or_Insert_Name<6>(source + start, hashvalue);
     355        gid = pbgs_symbol_table.Lookup_or_Insert_Name<6>(name, hashvalue);
    350356        break;
    351357    case 7:
    352         gid = pbgs_symbol_table.Lookup_or_Insert_Name<7>(source + start, hashvalue);
     358        gid = pbgs_symbol_table.Lookup_or_Insert_Name<7>(name, hashvalue);
    353359        break;
    354360    case 8:
    355         gid = pbgs_symbol_table.Lookup_or_Insert_Name<8>(source + start, hashvalue);
     361        gid = pbgs_symbol_table.Lookup_or_Insert_Name<8>(name, hashvalue);
    356362        break;
    357363    case 9:
    358         gid = pbgs_symbol_table.Lookup_or_Insert_Name<9>(source + start, hashvalue);
     364        gid = pbgs_symbol_table.Lookup_or_Insert_Name<9>(name, hashvalue);
    359365        break;
    360366    case 10:
    361         gid = pbgs_symbol_table.Lookup_or_Insert_Name<10>(source + start, hashvalue);
     367        gid = pbgs_symbol_table.Lookup_or_Insert_Name<10>(name, hashvalue);
    362368        break;
    363369    case 11:
    364         gid = pbgs_symbol_table.Lookup_or_Insert_Name<11>(source + start, hashvalue);
     370        gid = pbgs_symbol_table.Lookup_or_Insert_Name<11>(name, hashvalue);
    365371        break;
    366372    case 12:
    367         gid = pbgs_symbol_table.Lookup_or_Insert_Name<12>(source + start, hashvalue);
     373        gid = pbgs_symbol_table.Lookup_or_Insert_Name<12>(name, hashvalue);
    368374        break;
    369375    case 13:
    370         gid = pbgs_symbol_table.Lookup_or_Insert_Name<13>(source + start, hashvalue);
     376        gid = pbgs_symbol_table.Lookup_or_Insert_Name<13>(name, hashvalue);
    371377        break;
    372378    case 14:
    373         gid = pbgs_symbol_table.Lookup_or_Insert_Name<14>(source + start, hashvalue);
     379        gid = pbgs_symbol_table.Lookup_or_Insert_Name<14>(name, hashvalue);
    374380        break;
    375381    case 15:
    376         gid = pbgs_symbol_table.Lookup_or_Insert_Name<15>(source + start, hashvalue);
     382        gid = pbgs_symbol_table.Lookup_or_Insert_Name<15>(name, hashvalue);
    377383        break;
    378384    case 16:
    379         gid = pbgs_symbol_table.Lookup_or_Insert_Name<16>(source + start, hashvalue);
     385        gid = pbgs_symbol_table.Lookup_or_Insert_Name<16>(name, hashvalue);
    380386        break;
    381387    default:
    382         gid = pbgs_symbol_table.Lookup_or_Insert_Name(source + start, hashvalue, lgth);
     388        gid = pbgs_symbol_table.Lookup_or_Insert_Name(name, hashvalue, lgth);
    383389        break;
    384390    }
     
    393399    strncpy ( symbol, source + start, lgth );
    394400    symbol[lgth] ='\0';
    395     printf ("%s | start: %i[%i] | end: %i[%i] | lgth: %i | hashvalue: %i | gid: %i | symbol: %s\n", __FUNCTION__, start, start - block_base, end, end - block_base, lgth, hashvalue, gid, symbol);
     401//    printf ("%s | start: %i[%i] | end: %i[%i] | lgth: %i | hashvalue: %i | gid: %i | symbol: %s\n", __FUNCTION__, start, start - block_base, end, end - block_base, lgth, hashvalue, gid, symbol);
    396402    fprintf (gid_writein,"%s | start: %i[%i] | end: %i[%i] | lgth: %i | hashvalue: %i | gid: %i | symbol: %s\n", __FUNCTION__, start, start - block_base, end, end - block_base, lgth, hashvalue, gid, symbol);
    397403#endif
     
    406412//      long test = 6;
    407413//      test = (test & (test - 1));
    408 //      cout << test << endl;
     414//      cout << "test" << endl;
    409415    for (blk = 0; blk < blk_count; blk++) {
    410         cout << "blk:" << blk << endl;
     416//      cout << "blk:" << blk << endl;
    411417   
    412418                ScanBlock s = stream[blk];
     
    415421//              print_register("s:",((BitBlock*)stream)[0]);
    416422                while(s | s2) {
    417                         cout << "cfzl(s):" << cfzl(s)<<endl;
     423//                      cout << "cfzl(s):" << cfzl(s)<<endl;
    418424                    int end_pos = cfzl(s) + block_pos;
    419425//                  cout << "s2 " << s2 << endl;
     
    423429//                      cout << (end_tag < end_pos && s2 != 0)<< "||" <<(s == 0 && s2 != 0)  << endl;
    424430                        if ((end_tag < end_pos && s2 != 0) | (s == 0 && s2 != 0)){
    425                         cout << "here" << endl;
    426                         cout << "closing tag" << endl;
     431//                      cout << "here" << endl;
     432//                      cout << "closing tag" << endl;
    427433//                      cout << "endtag:" << end_tag << " " << end_pos<<endl;
    428434//                      cout << "1"<< endl;
     
    430436//                      cout << "2" << endl;
    431437//                      cout << elem_vec_stack.top()<<endl;
    432                                 if(!(gid_vec.empty())){
     438                                if(!(gid_vec[current_depth].empty())){
    433439//                                      if(gid_vec.back() != 0){
    434                                                 gid_vec.push_back(0);
     440                                                gid_vec[current_depth].push_back(0);
     441                                                if(current_depth !=0){
     442                                                        current_depth = pre_index.back();
     443                                                        pre_index.pop_back();
     444                                                        fprintf (gid_writein,"%d\n",current_depth);
     445                                                        gid_vec[current_depth].push_back(0);
     446                                                }
    435447//                                      }
    436448                                }
    437                                 cout << "before" << s2 << endl;
     449//                              cout << "before" << s2 << endl;
    438450                                s2 = s2 & (s2 - 1);
    439                                 cout << "after" << s2 << endl;
     451//                              cout << "after" << s2 << endl;
    440452//                      cout << "s2 = " << s2 << endl;
    441453                }else{
    442                         cout << " end_pos == " << end_pos<<endl;
    443                         cout << " end_tag_pos == " << end_tag << endl;
     454//                      cout << " end_pos == " << end_pos<<endl;
     455//                      cout << " end_tag_pos == " << end_tag << endl;
    444456                        char gid = ElemEnd_grouping(source,block_base,end_pos);
    445457                        if (s!=0){
     
    450462                        //}
    451463                                if (gid != 0){
    452                                         gid_vec.push_back(gid);                 
     464                                        gid_vec[current_depth].push_back(gid);
     465                                        fprintf (gid_writein,"%d\n",current_depth);
     466                                        pre_index.push_back(current_depth);
     467                                        current_depth = (int)gid;
     468                                        gid_vec[current_depth].push_back(gid);
     469                                        fprintf (gid_writein,"%d\n",current_depth);                     
    453470                                }
    454                                 cout << "here1" << endl;
    455471                }
    456472                }
    457473                block_pos += 8 * sizeof(ScanBlock);
    458                 print_gid_vec();
     474//              print_gid_vec();
    459475    }
    460476    return 0;
     
    462478
    463479void print_gid_vec(){
    464         for (int i = 0; i < gid_vec.size(); i++){
    465                 cout << (int)gid_vec[i] << " ";
     480        for (int j = 0; j < MAX_DEPTH; j++){
     481                if(gid_vec[j].empty()){
     482                        return;
     483                }
     484                for (int i = 0; i < gid_vec[j].size(); i++){
     485                        cout << j << ":" << endl;
     486                        cout << (int)gid_vec[j][i] << " ";
     487                }
    466488        }
    467489        cout << endl;
     
    653675}
    654676
    655 static inline void print_elem_vec(vector<char>* vec, int size){
    656         cout << "vector: ";
     677static inline void print_elem_vec(vector<char>* vec, int size, int depth){
     678        cout << "vector " << depth << ":";
    657679        for (int i = 0; i<size ; i++){
    658680                cout << (int)(*vec)[i] <<" ";
     
    661683}
    662684
    663 static inline void vec_scan(BitStreamScanner<BitBlock, uint64_t,uint64_t, 32> match_scanner,BitStreamScanner<BitBlock, uint64_t,uint64_t, 32> f_vec_scanner){
     685static inline void vec_scan(BitStreamScanner<BitBlock, uint64_t,uint64_t, 32> match_scanner,BitStreamScanner<BitBlock, uint64_t,uint64_t, 32> f_vec_scanner,char* str,int index){
    664686        int current_pos = 0;
    665687        int next_pos = 0;
    666688        int match_pos = 0;
     689        cout << str <<" = " << index <<endl;
     690//      cout << "vec_scan" << endl;
    667691        if(f_vec_scanner.has_next()){
    668692                current_pos = f_vec_scanner.scan_to_next();
     693//              cout << current_pos << endl;
    669694        }else{
    670695                return;
     
    673698                match_pos = match_scanner.scan_to_next();
    674699        }else{
     700                printf("Mismatch found at pos of %s %d: %d.\n",str,index,current_pos);
    675701                while(f_vec_scanner.has_next()){
    676702                        current_pos = f_vec_scanner.scan_to_next();
    677                         printf("Mismatch found at pos: %d.\n",current_pos);
     703                        printf("Mismatch found at pos of %s %d: %d.\n",str,index,current_pos);
    678704                }
    679705                return;
     
    686712                }
    687713                if (match_pos > next_pos && next_pos != -1){
    688                         printf("Mismatch found at pos: %d.\n",current_pos);
     714                        printf("Mismatch found at pos of %s %d: %d.\n",str,index,current_pos);
    689715                }else if (next_pos == -1){
    690716                        break;
     
    693719                                match_pos = match_scanner.scan_to_next();
    694720                        }else{
    695                                 printf("Mismatch found at pos: %d.\n",next_pos);
     721                                printf("Mismatch found at pos of %s %d: %d.\n",str,index,next_pos);
    696722                                while(f_vec_scanner.has_next()){
    697723                                        current_pos = f_vec_scanner.scan_to_next();
    698                                         printf("Mismatch found at pos: %d.\n",current_pos);
     724                                        printf("Mismatch found at pos of %s %d: %d.\n",str,index,current_pos);
    699725                                }
    700726                                return;
     
    708734        struct Elem elem;
    709735        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;
     746       
    710747        struct Lex lex;
     748       
    711749        struct Output output;
     750
    712751        Classify_bytes classify_bytes;
    713         int lgth = gid_vec.size();
    714         int remaining = 0;
    715         Basis_bits temp_basis_bits;
    716         const int num_block = lgth /(BLOCK_SIZE *8 / VECTOR_WIDTH);
    717         int i = 0;
     752        int j;
     753        for(j=0;j<MAX_COUNT;j++){
     754        int lgth = gid_vec[j].size();
     755                if(!gid_vec[j].empty())
     756                        print_elem_vec(&(gid_vec[j]),lgth,j);
     757        }
     758        for(j=0;j<MAX_COUNT;j++){
     759                int lgth = gid_vec[j].size();
     760                int remaining = 0;
     761                Basis_bits temp_basis_bits;
     762                const int num_block = lgth /(BLOCK_SIZE *8 / VECTOR_WIDTH);
     763                int i = 0;
     764                int block_base;
     765               
     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               
     771                if(lgth != 0){ 
     772                        remaining = lgth %(BLOCK_SIZE *8 / VECTOR_WIDTH);
     773                        for(i = 0;i < num_block; i++){
     774                                block_base = i*BLOCK_SIZE;
     775                       
     776                                s2p_do_block((BytePack*)(&(gid_vec[j][block_base])), temp_basis_bits);
     777                                //print_elem_vec(&(gid_vec[j]),lgth,j);
     778                                //print_basis_bits(temp_basis_bits);
     779
     780                                classify_bytes.do_block(temp_basis_bits,lex);
     781                                switch (j){
     782                                        case 1:
     783                                        validation_1.do_block(lex,output);
     784                                        f_vec_scanner.load_block(lex.cc1,i);
     785                                        break;
     786                                        /*
     787                                        case 2:
     788                                        validation_2.do_block(lex,output);
     789                                        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);
     794                                        break;
     795                                        case 4:
     796                                        validation_4.do_block(lex,output);
     797                                        f_vec_scanner.load_block(lex.cc4,i);
     798                                        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);
     829                                        break;
     830                                }
     831
     832                                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                                */
     843
     844                        }
     845                        if (remaining !=0){
     846                                BitBlock EOF_mask = bitblock::srl(simd<1>::constant<1>(),convert(BLOCK_SIZE-remaining));
     847                                s2p_do_final_block((BytePack*)(&(gid_vec[j][block_base])), temp_basis_bits,EOF_mask);
     848                                //print_elem_vec(&(gid_vec[j]),lgth,j);
     849                                //print_basis_bits(temp_basis_bits);
     850                       
     851                                classify_bytes.do_final_block(temp_basis_bits,lex,EOF_mask);
     852                                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);
     858                                        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);
     864                                        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);
     890                                        break;
     891                                }
     892
     893                                match_scanner.load_block(output.matches,i);
     894                        }
     895                }
     896                if(lgth != 0){
     897                        vec_scan(match_scanner,f_vec_scanner,"Element",j);     
     898                }
     899        }
    718900       
    719         BitStreamScanner<BitBlock, uint64_t,uint64_t, 32> match_scanner;
    720         BitStreamScanner<BitBlock, uint64_t,uint64_t, 32> f_vec_scanner;
    721         match_scanner.init();
    722         f_vec_scanner.init();
    723         if(lgth != 0){ 
    724                 remaining = lgth %(BLOCK_SIZE *8 / VECTOR_WIDTH);
    725                 for(i = 0;i < num_block; i++){
    726                         s2p_do_block((BytePack*)(&(gid_vec[i])), temp_basis_bits);
    727                         print_elem_vec(&(gid_vec),lgth);
    728                         print_basis_bits(temp_basis_bits);
     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;
    729927                       
    730                         classify_bytes.do_block(temp_basis_bits,lex);
    731                         validation_1.do_block(lex,output);
     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);
    732953                       
    733                         match_scanner.load_block(output.matches,i);
    734                         f_vec_scanner.load_block(lex.cc1,i);
     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                        }
    735967                }
    736                 if (remaining !=0){
    737                         BitBlock EOF_mask = bitblock::srl(simd<1>::constant<1>(),convert(BLOCK_SIZE-remaining));
    738                         s2p_do_final_block((BytePack*)(&(gid_vec[i])), temp_basis_bits,EOF_mask);
    739                         print_elem_vec(&(gid_vec),lgth);
    740                         print_basis_bits(temp_basis_bits);
    741                        
    742                         classify_bytes.do_block(temp_basis_bits,lex);
    743                         validation_1.do_block(lex,output);
    744                        
    745                         match_scanner.load_block(output.matches,i);
    746                         f_vec_scanner.load_block(lex.cc1,i);
    747                 }
    748         }
    749         vec_scan(match_scanner,f_vec_scanner);
    750 }
    751 
    752 
    753 
     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        }
     972*/
     973}
     974
     975
     976/*
    754977static inline void validate(){
    755978        struct Elem elem;
     
    9291152        }
    9301153*/
    931 }
     1154/*
     1155}
     1156*/
    9321157
    9331158static inline void vectoring(Tag_Callouts & tag_Callouts, Hash_data & hash_data,char *source,int block_base){
     
    9351160        elem_starts = tag_Callouts.ElemName_starts;
    9361161    hashvalues[1] = hash_data.Hash_value;
     1162   
     1163//    pre_index.push(0);
    9371164   
    9381165        StreamScanLengthGrouping(source,block_base,(ScanBlock *) &tag_Callouts.ElemName_ends,(ScanBlock *) &tag_Callouts.Tag_closing, sizeof(BitBlock)/sizeof(ScanBlock));
     
    11301357                int lgth = strlen(symbol);
    11311358                int hashvalue = compute_hash_value2(symbol,lgth);
    1132                 cout << symbol <<" "<< lgth<<" "<<hashvalue << endl;
     1359//              cout << symbol <<" "<< lgth<<" "<<hashvalue << endl;
    11331360                int gid = 0;
    11341361                switch (lgth)
     
    12781505      PERF_SEC_START(parser_timer);
    12791506      for (int blk = 0; blk < SEGMENT_BLOCKS; blk++) {
    1280         cout << "loops" << ends;
     1507//              cout << "loops" << ends;
    12811508                block_base = blk*BLOCK_SIZE;
    12821509        s2p_do_block((BytePack *) &src_buffer[block_base], basis_bits);
     
    12851512         
    12861513                tracker.StoreNewlines(lex.LF);
    1287                 cout << "post start" << endl;
     1514//              cout << "post start" << endl;
    12881515//              postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, tag_Callouts, hash_data, chars_avail);
    12891516                postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, (char *)&src_buffer[0], buffer_base, block_base, chars_avail, tracker);
    12901517                vectoring(tag_Callouts,hash_data,(char *)&src_buffer[0],block_base);
    1291                 cout << "post done" << endl;
     1518//              cout << "post done" << endl;
    12921519                #ifndef STL_ALIGNED_VECTOR
    12931520                matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
    12941521                #endif
    12951522                tracker.AdvanceBlock();
    1296                 cout << "loop" << endl;
     1523//              cout << "loop" << endl;
    12971524      }
    12981525      #ifndef STL_ALIGNED_VECTOR
     
    13001527      matcher.Advance_buffer();
    13011528      #endif
    1302       cout << "11111" << endl;
    13031529      PERF_SEC_END(parser_timer, chars_avail);
    1304           cout << "here" << endl;
     1530//        cout << "here" << endl;
    13051531      int bytes_left = chars_read - chars_avail;
     1532     
    13061533      //////////////////
    13071534      //element name buffer, for scanning element name backwards
    13081535      /////////////////
    13091536      memmove(&element_name_buffer[0],&src_buffer[SEGMENT_SIZE-ELEMENT_BUFFER_SIZE],ELEMENT_BUFFER_SIZE);
     1537//      fprintf(gid_writein,"name_buffer\n");
    13101538      cross_buffer_flag = 1;
    13111539     
     
    13131541      chars_read = fread(&src_buffer[LOOKAHEAD_SIZE],1,SEGMENT_SIZE, infile) + LOOKAHEAD_SIZE;
    13141542      chars_avail = chars_read;
    1315       cout << "here" << endl;
     1543//      cout << "here" << endl;
    13161544      if (chars_avail > SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
    13171545      buffer_pos += chars_avail;
     
    13371565         
    13381566          tracker.StoreNewlines(lex.LF);
    1339           cout << "post start1" << endl;
     1567//        cout << "post start1" << endl;
    13401568         
    13411569//        postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, tag_Callouts, hash_data, chars_avail);
    13421570          postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, (char *)&src_buffer[0], buffer_base, block_base, chars_avail, tracker);
    13431571          vectoring(tag_Callouts,hash_data,(char *)&src_buffer[0],block_base);
    1344           cout << "post end2" << endl;
     1572//        cout << "post end2" << endl;
    13451573          #ifndef STL_ALIGNED_VECTOR
    13461574          matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
     
    13571585          s2p_do_final_block((BytePack *) &src_buffer[block_pos], basis_bits, EOF_mask);
    13581586          @final_block_stmts
    1359           cout << "post start3" << endl;
     1587//        cout << "post start3" << endl;
    13601588//        postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, tag_Callouts, hash_data, chars_avail);
    13611589          postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, (char *)&src_buffer[0], buffer_base, block_base, chars_avail, tracker);
    13621590          vectoring(tag_Callouts,hash_data,(char *)&src_buffer[0],block_base);
    1363           cout << "post end3" << endl;
     1591//        cout << "post end3" << endl;
    13641592          #ifndef STL_ALIGNED_VECTOR
    13651593      matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
     
    14271655       
    14281656#if DEBUG
    1429 print_gid_vec();
     1657//print_gid_vec();
    14301658#endif
    14311659        //cout << "validate start" << endl;
  • proto/xmlschema/xform_make.sh

    r3319 r3353  
    22cd src
    33make all
    4 ./xmlwf ../test/eg-01_1.xml
     4./xmlwf ../test/calculator
    55cd ..
    66
Note: See TracChangeset for help on using the changeset viewer.