source: proto/xmlschema/validation_template_onevec.cpp @ 3319

Last change on this file since 3319 was 3319, checked in by shiyangy, 6 years ago

template modified

File size: 45.0 KB
Line 
1
2#include <simd-lib/bitblock.hpp>
3#include <simd-lib/carryQ.hpp>
4#include <simd-lib/pabloSupport.hpp>
5
6#define LocalCarryDeclare(name, count)\
7CarryArray<count, 0> name;\
8
9#define assert_0_error(errkind, errstrm)
10
11BitBlock EOF_mask = simd<1>::constant<1>();
12
13//#define USE_FUNCTION_TEMPLATES
14//#define TEMPLATED_SIMD_LIB
15
16#define DEBUG 1
17//#define BLOCK_SIZE (sizeof(SIMD_type) * 8)
18//#define SEGMENT_BLOCKS 12
19//#define BUFFER_SIZE (BLOCK_SIZE * SEGMENT_BLOCKS)
20//#define OVERLAP_BUFSIZE 2*(sizeof(SIMD_type))
21
22#define VECTOR_WIDTH 8
23#define VECTOR_TYPE (char)
24
25#include <stdio.h>
26#include <stdlib.h>
27#include <errno.h>
28#include <sys/types.h>
29#include <sys/stat.h>
30#include <limits.h>
31
32#include <simd-lib/s2p.hpp>
33#include <simd-lib/buffer.hpp>
34#include <simd-lib/bitblock_iterator.hpp>
35#include <simd-lib/perflib/perfsec.h>
36
37//#include "../lib/lib_simd.h"
38#include "../symtab/pbgs_identity_symbol_table.h"
39
40#include <stack>
41#include <map>
42#include <vector>
43
44#include <queue>
45#include <string>
46
47typedef long ScanBlock;
48typedef BytePack BitBlock;
49
50using namespace std;
51
52//#include "../lib/carryQ.h"
53#include <xmldecl.h>
54//#include "xml_error.c"
55//#include "xmldecl.c"
56#include <namechars.h>
57#include <LineColTracker.hpp>
58#include <XMLTestSuiteError.h>
59
60// Define the mappings for pablo.assert_0(strm, errkind) statements which
61// compile to the the form assert_0_error(errkind, strm)
62#include <ErrorTracker.h>
63
64ErrorTracker error_tracker;
65#define assert_0_error(errkind, errstrm) error_tracker.NoteError(errkind, errstrm);
66
67#ifndef STL_ALIGNED_VECTOR
68#include <TagMatcher.hpp>
69#endif
70
71#ifdef STL_ALIGNED_VECTOR // experimental, comment out TagMatcher code to use STL aligned memory vector
72#warning "Compiling with experimental STL_ALIGNED_VECTOR."
73#include <vector>
74#include <simd-lib/stl_aligned_allocator.hpp>
75#endif
76
77#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);
87#else
88        void * parser_timer;
89#endif
90
91//////////////////////////////////////////////////////////////////////////////////////////
92// Buffer Management // WARNING: Do Not update #defines. Results in TagMatcher errors.
93//////////////////////////////////////////////////////////////////////////////////////////
94#define PADDING_BLOCKS 0
95#define PADDING_SIZE (BLOCK_SIZE * PADDING_BLOCKS)
96#define COPYBACK_BLOCKS 2
97#define COPYBACK_SIZE (BLOCK_SIZE * COPYBACK_BLOCKS)
98#define LOOKAHEAD_BLOCKS 1
99#define LOOKAHEAD_SIZE (BLOCK_SIZE * LOOKAHEAD_BLOCKS)
100#define SEGMENT_BLOCKS  12 // WARNING: TagMatcher.hpp causes xmlconf test suite failures for SEGMENT_BLOCKS < 3.
101#define SEGMENT_SIZE (BLOCK_SIZE * SEGMENT_BLOCKS)
102#define BUFFER_SIZE (COPYBACK_SIZE + SEGMENT_SIZE + LOOKAHEAD_SIZE + PADDING_SIZE)
103
104
105
106//int block_base=0;
107//int buffer_base=0;
108int buffer_last;
109FILE *gid_writein;
110#define ELEMENT_BUFFER_SIZE 30
111char element_name_buffer[ELEMENT_BUFFER_SIZE];
112int cross_buffer_flag = 0;
113//char * source;
114LineColTracker tracker;
115
116static inline int cfzl(long x){
117        unsigned long ux = x;
118        if (x<0){
119                ux = ULONG_MAX + x + 1;
120        }
121        if (ux==0)
122                return 8*sizeof(long);
123        int n;
124        n = 0;
125        while (1){
126                if ((ux%2) == 1){
127                        if(n==64){
128                                cout << ux <<endl;
129                        }
130                        return n;               
131                }
132                n ++;
133                ux = ux >> 1;
134                //cout << "x = " << x << endl;
135        } 
136}
137
138static inline void print_gid_vec();
139/*
140static inline int cfzl(long x){
141 if (x ==0)
142  return 32;
143 int n=0;
144 if ((x & 0xFFFF0000) == 0) { n += 16; x =x << 16;} //1111 1111 1111 1111 0000 0000 0000 0000 // 16 bits from left are zero! so we omit 16left bits
145 if ((x & 0xFF000000) == 0){ n = n +  8; x = x <<  8;} // 8 left bits are 0
146 if ((x & 0xF0000000) ==0){ n = n +  4; x = x <<  4;} // 4 left bits are 0
147 if ((x & 0xC0000000) == 0){ n =n +  2, x = x <<  2;}  // 110000....0 2 left bits are zero
148 if ((x & 0x80000000) == 0){n = n +  1, x = x <<  1;} // first left bit is zero
149 return n;
150
151}
152*/
153static inline void ReportError(const char * error_msg, int error_pos_in_block) {
154  int error_line, error_column;
155  tracker.get_Line_and_Column(error_pos_in_block, error_line, error_column);
156  fprintf(stderr, "%s at line %i, column %i\n", error_msg, error_line, error_column);
157}
158/*
159class ErrorTracker {
160public:
161    ErrorTracker() { noted_pos_in_block = -1;}
162
163    inline void NoteError(const char * error_msg, BitBlock err_strm) {
164      int pos_in_block = count_forward_zeroes(err_strm);
165      if ((noted_pos_in_block == -1) || (noted_pos_in_block > pos_in_block)) {
166        noted_pos_in_block = pos_in_block;
167        noted_error = error_msg;
168      }
169    }
170
171    inline void If_Error_Report_First() {
172      if (noted_pos_in_block > -1) {
173              int error_line, error_column;
174              ReportError(noted_error, noted_pos_in_block);
175              exit(-1);
176      }
177    }
178
179private:
180  const char * noted_error;
181  int noted_pos_in_block;
182};
183*/
184
185
186//BitBlock EOF_mask = simd_const_1(1);
187
188//ErrorTracker error_tracker;
189BitBlock elem_starts;
190int previous_block_last_elem_start;
191BytePack hashvalues[2];
192
193vector <int> gids;
194PBGSIdentitySymbolTable pbgs_symbol_table;
195
196vector <char> gid_vec;
197
198stack <vector<char>* > elem_vec_stack;
199map<char, vector<char>* > elem_vec_map;
200
201static inline int ScanBackwardPos(BitBlock * block, int pos)
202{
203        cout << "pos " << pos << endl;
204    BitBlock s = block[0];
205    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))) );
208        }
209    BitBlock temp = simd_and( s, simd_not(simd<128>::sll(simd<1>::constant<1>(), convert(pos))) );
210//      print_register("zero",simd_not(simd<128>::sll(simd<1>::constant<1>());
211                print_register("temp",temp);
212    if (bitblock::any(temp))
213    {
214        // sizeof (BitBlock)*8 - cbzl( s & ~(~0 << pos)) - 1;
215//      cout << "block_size" << BLOCK_SIZE << endl;
216        return BLOCK_SIZE - count_reverse_zeroes(temp) - 1;
217    }
218    else
219    {
220        //handle boundary case
221        return previous_block_last_elem_start - 1;
222    }
223}
224
225static inline int StreamScan(ScanBlock * stream, int blk_count, int ProcessPos(int)) {
226        int blk;
227        int block_pos = 0;
228        for (blk = 0; blk < blk_count; blk++) {
229                ScanBlock s = stream[blk];
230                while(s) {
231                        int code = (ProcessPos(cfzl(s) + block_pos));
232                        if (code) return code;
233                        s = s & (s-1);  // clear rightmost bit.
234                }
235                block_pos += 8 * sizeof(ScanBlock);
236        }
237        return 0;
238}
239
240static inline int compute_hash_value2(char *str,int lgth){
241        int hash = 5381;
242    int c;
243//      while (c = *str++){
244        for (int i = 0;i<lgth;i++){
245                c=*str++; 
246        hash = ((hash << 5) + hash) + c; /* hash * 33 + c */
247    }
248
249    return hash;
250}
251
252static inline int compute_hash_value (int lgth, int start)
253{
254    unsigned int offset_bit = start + 128;
255    uint64_t stream = *((uint64_t*)(((uint32_t*)hashvalues)+(offset_bit>>5)));
256    return stream >> (offset_bit & 0x1F) & ~(~0 << lgth);
257}
258/*
259template <int L>
260static inline int ElemEnd_grouping(int pos) {
261    int end = block_base + pos;
262    int start = end - L;
263    int hashvalue = compute_hash_value(L, start - block_base);
264    int gid = pbgs_symbol_table.Lookup_or_Insert_Name<L>(source + start, hashvalue);
265    gids.push_back(gid);
266#if DEBUG
267    char* symbol = new char[L+1];
268    strncpy ( symbol, source + start, L );
269    symbol[L] ='\0';
270    printf ("%s | start: %i[%i] | end: %i[%i] | gid: %i | hashvalue: %i | symbol: %s\n", __FUNCTION__, start, start-buffer_base, end, end-buffer_base, gid, hashvalue, symbol );
271    delete symbol; symbol = 0;
272#endif
273    return gid;
274}
275
276template<>
277inline int ElemEnd_grouping<17>(int pos) {
278    int end = block_base + pos;
279    int start = ScanBackwardPos (&elem_starts, pos) + block_base;
280    int lgth = end - start;
281    int hashvalue = compute_hash_value(lgth, start - block_base);
282    int gid = 0;
283
284//    if (lgth < 32)
285//    {
286//      gid = pbgs_symbol_table.Lookup_or_Insert_Name_32(source + start, hashvalue, lgth);
287//    }
288//    else
289    {
290        gid = pbgs_symbol_table.Lookup_or_Insert_Name(source + start, hashvalue, lgth);
291    }
292    gids.push_back(gid);
293#if DEBUG
294    char* symbol = new char[lgth+1];
295    strncpy ( symbol, source + start, lgth );
296    symbol[lgth] ='\0';
297    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);
298#endif
299    return gid;
300}
301*/
302
303inline char ElemEnd_grouping(char *source,int block_base,int pos) {
304    int end = block_base + pos;
305    int start = ScanBackwardPos(&elem_starts, pos) + block_base;
306    ///////////////////////
307    //start could be negitive
308    //the element name falls in two buffers
309    ///////////////////////
310    char *name = source + start;
311    char name_buffer[50];
312   
313    if (start<0){
314        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);
316        name = name_buffer;
317    }
318//    cout << end << "  " << start << endl;
319    int lgth = end - start;
320//    int hashvalue = compute_hash_value(lgth,start-block_base);
321        int hashvalue = compute_hash_value2(name,lgth);
322    char gid = 0;
323
324
325//    if (lgth < 32)
326//    {
327//      gid = pbgs_symbol_table.Lookup_or_Insert_Name_32(source + start, hashvalue, lgth);
328//    }
329//    else
330
331        switch (lgth)
332    {
333    case 1:
334        gid = pbgs_symbol_table.Lookup_or_Insert_Name<1>(source + start, hashvalue);
335        break;
336    case 2:
337        gid = pbgs_symbol_table.Lookup_or_Insert_Name<2>(source + start, hashvalue);
338        break;
339    case 3:
340        gid = pbgs_symbol_table.Lookup_or_Insert_Name<3>(source + start, hashvalue);
341        break;
342    case 4:
343        gid = pbgs_symbol_table.Lookup_or_Insert_Name<4>(source + start, hashvalue);
344        break;
345    case 5:
346        gid = pbgs_symbol_table.Lookup_or_Insert_Name<5>(source + start, hashvalue);
347        break;
348    case 6:
349        gid = pbgs_symbol_table.Lookup_or_Insert_Name<6>(source + start, hashvalue);
350        break;
351    case 7:
352        gid = pbgs_symbol_table.Lookup_or_Insert_Name<7>(source + start, hashvalue);
353        break;
354    case 8:
355        gid = pbgs_symbol_table.Lookup_or_Insert_Name<8>(source + start, hashvalue);
356        break;
357    case 9:
358        gid = pbgs_symbol_table.Lookup_or_Insert_Name<9>(source + start, hashvalue);
359        break;
360    case 10:
361        gid = pbgs_symbol_table.Lookup_or_Insert_Name<10>(source + start, hashvalue);
362        break;
363    case 11:
364        gid = pbgs_symbol_table.Lookup_or_Insert_Name<11>(source + start, hashvalue);
365        break;
366    case 12:
367        gid = pbgs_symbol_table.Lookup_or_Insert_Name<12>(source + start, hashvalue);
368        break;
369    case 13:
370        gid = pbgs_symbol_table.Lookup_or_Insert_Name<13>(source + start, hashvalue);
371        break;
372    case 14:
373        gid = pbgs_symbol_table.Lookup_or_Insert_Name<14>(source + start, hashvalue);
374        break;
375    case 15:
376        gid = pbgs_symbol_table.Lookup_or_Insert_Name<15>(source + start, hashvalue);
377        break;
378    case 16:
379        gid = pbgs_symbol_table.Lookup_or_Insert_Name<16>(source + start, hashvalue);
380        break;
381    default:
382        gid = pbgs_symbol_table.Lookup_or_Insert_Name(source + start, hashvalue, lgth);
383        break;
384    }
385/*
386    {
387        gid = (char)pbgs_symbol_table.Lookup_or_Insert_Name(source + start, hashvalue, lgth);
388    }
389*/
390    gids.push_back(gid);
391#if DEBUG
392    char* symbol = new char[lgth+1];
393    strncpy ( symbol, source + start, lgth );
394    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);
396    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);
397#endif
398    return gid;
399}
400
401//template <int L>
402static inline int StreamScanLengthGrouping(char *source,int block_base,ScanBlock * stream, ScanBlock * stream2, int blk_count) {
403    int blk;
404    int block_pos = 0;
405//    cout << "cfzl():" << cfzl() << endl;
406//      long test = 6;
407//      test = (test & (test - 1));
408//      cout << test << endl;
409    for (blk = 0; blk < blk_count; blk++) {
410        cout << "blk:" << blk << endl;
411   
412                ScanBlock s = stream[blk];
413                ScanBlock s2 = stream2[blk];
414//              cout << s << "  " << s2 << endl;
415//              print_register("s:",((BitBlock*)stream)[0]);
416                while(s | s2) {
417                        cout << "cfzl(s):" << cfzl(s)<<endl;
418                    int end_pos = cfzl(s) + block_pos;
419//                  cout << "s2 " << s2 << endl;
420                    int end_tag = cfzl(s2) + block_pos;
421//              cout << "cfzl(s):" << cfzl(s)<<endl;
422//              cout << "cfzl(s2):" << cfzl(s2)<<endl;
423//                      cout << (end_tag < end_pos && s2 != 0)<< "||" <<(s == 0 && s2 != 0)  << endl;
424                        if ((end_tag < end_pos && s2 != 0) | (s == 0 && s2 != 0)){
425                        cout << "here" << endl;
426                        cout << "closing tag" << endl;
427//                      cout << "endtag:" << end_tag << " " << end_pos<<endl;
428//                      cout << "1"<< endl;
429//                      cout << elem_vec_stack.size()<<endl;
430//                      cout << "2" << endl;
431//                      cout << elem_vec_stack.top()<<endl;
432                                if(!(gid_vec.empty())){
433//                                      if(gid_vec.back() != 0){
434                                                gid_vec.push_back(0);
435//                                      }
436                                }
437                                cout << "before" << s2 << endl;
438                                s2 = s2 & (s2 - 1);
439                                cout << "after" << s2 << endl;
440//                      cout << "s2 = " << s2 << endl;
441                }else{
442                        cout << " end_pos == " << end_pos<<endl;
443                        cout << " end_tag_pos == " << end_tag << endl;
444                        char gid = ElemEnd_grouping(source,block_base,end_pos);
445                        if (s!=0){
446                                s = s & (s-1);  // clear rightmost bit.
447                        }
448                        //else{
449                        //      s2 = s2 & (s2 - 1);
450                        //}
451                                if (gid != 0){
452                                        gid_vec.push_back(gid);                 
453                                }
454                                cout << "here1" << endl;
455                }
456                }
457                block_pos += 8 * sizeof(ScanBlock);
458                print_gid_vec();
459    }
460    return 0;
461}
462
463void print_gid_vec(){
464        for (int i = 0; i < gid_vec.size(); i++){
465                cout << (int)gid_vec[i] << " ";
466        }
467        cout << endl;
468/*     
469        int i = 1;
470        int lst[256] = {0};
471        cout << elem_vec_map.size() << " vectors" << endl;
472        for (int i = 0;i < gids.size(); i++){
473                if (lst[gids[i]] == 0){
474                        cout << "gid: " << gids[i] << endl;
475                        lst[gids[i]] = 1;
476                        vector<char> *tmp = elem_vec_map[gids[i]];
477                        cout << "vector size:"<< (*tmp).size()<<endl;
478                        if ((*tmp).size()!=0){
479                                cout << "elements: ";
480                                for (int j = 0; j < (*tmp).size();j++){
481                                        cout << (int)(*tmp)[j] << " ";
482                                }
483                                cout << endl;
484                        }
485                        cout << endl;
486                }
487        }
488*/
489}
490/*
491static inline int NameStrt_check(int pos) {
492        int block_pos = block_base + pos;
493        if(XML_10_UTF8_NameStrt_bytes((unsigned char*)&source[block_pos]) == 0){
494              ReportError("name start error", pos);
495              exit(-1);
496        }
497        return 0;
498}
499
500static inline int Name_check(int pos) {
501        int block_pos = block_base + pos;
502        if(XML_10_UTF8_NameChar_bytes((unsigned char*)&source[block_pos]) == 0){
503              ReportError("name error", pos);
504              exit(-1);
505        }
506        return 0;
507}
508
509static inline int PIName_check(int pos) {
510        int block_pos = block_base + pos;
511        int file_pos = block_pos+buffer_base;
512        printf ("%s:%i\n",__FUNCTION__,pos);
513        if (at_XxMmLll<ASCII>((unsigned char*)&source[block_pos]) && (source[block_pos+3]=='?' || source[block_pos+3]<= ' ')) {
514              // "<?xml" legal at start of file.
515              if ((file_pos == 2) && at_XmlDecl_start<ASCII>((unsigned char*)&source[0])) return 0;
516              ReportError("[Xx][Mm][Ll] illegal as PI name", pos);
517              exit(-1);
518        }
519        return 0;
520}
521
522static inline int CD_check(int pos) {
523        int block_pos = block_base + pos;
524        if (!at_CDATA1<ASCII>((unsigned char*)&source[block_pos])){
525              ReportError("CDATA error", pos);
526              exit(-1);
527        }
528        return 0;
529}
530
531static inline int GenRef_check(int pos) {
532        int block_pos = block_base + pos;
533        unsigned char* s = (unsigned char*)&source[block_pos];
534        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))){
535                        cout << pos << endl;
536              ReportError("Undefined reference", pos);
537              exit(-1);
538        }
539        return 0;
540}
541
542static inline int HexRef_check(int pos) {
543        int block_pos = block_base + pos;
544        unsigned char* s = (unsigned char*)&source[block_pos];
545        int ch_val = 0;
546        while(at_HexDigit<ASCII>(s)){
547          ch_val = HexVal<ASCII>(s[0]) + (ch_val<<4);
548          if (ch_val> 0x10FFFF ){
549            ReportError("Illegal character reference", pos);
550            exit(-1);
551          }
552          s++;
553        }
554        if ((ch_val == 0x0) || ((ch_val | 0x7FF) == 0xDFFF)|| ((ch_val | 0x1) == 0xFFFF)){
555          ReportError("Illegal character reference", pos);
556          exit(-1);
557        }
558        else if (((ch_val < 0x20) && (ch_val != 0x9) && (ch_val != 0xD) && (ch_val != 0xA))){
559          ReportError("Illegal XML 1.0 character reference", pos);
560          exit(-1);
561        }
562        return 0;
563}
564
565static inline int DecRef_check(int pos) {
566        int block_pos = block_base + pos;
567        unsigned char* s = (unsigned char*)&source[block_pos];
568        int ch_val = 0;
569        while(at_HexDigit<ASCII>(s)){
570          ch_val = DigitVal<ASCII>(s[0]) + ch_val*10;
571          if (ch_val> 0x10FFFF ){
572            ReportError("Illegal character reference", pos);
573            exit(-1);
574          }
575          s++;
576        }
577        if ((ch_val == 0x0) || ((ch_val | 0x7FF) == 0xDFFF)|| ((ch_val | 0x1) == 0xFFFF)){
578          ReportError("Illegal character reference", pos);
579          exit(-1);
580        }
581        else if (((ch_val < 0x20) && (ch_val != 0x9) && (ch_val != 0xD) && (ch_val != 0xA))){
582          ReportError("Illegal XML 1.0 character reference", pos);
583          exit(-1);
584        }
585        return 0;
586}
587
588static inline int AttRef_check(int pos) {
589        int block_pos = block_base + pos;
590        unsigned char* s = (unsigned char*)&source[block_pos];
591        int ch_val = 0;
592        if(s[0]=='#'){
593          s++;
594          if(s[0]=='x' || s[0]=='X'){
595            s++;
596            while(at_HexDigit<ASCII>(s)){
597              ch_val = HexVal<ASCII>(s[0]) + (ch_val<<4);
598              s++;
599            }
600          }
601          else{
602            while(at_HexDigit<ASCII>(s)){
603              ch_val = DigitVal<ASCII>(s[0]) + ch_val*10;
604              s++;
605            }
606          }
607          if (ch_val==60){
608            ReportError("Attribute values contain '<' characters after reference expansion", pos);
609            exit(-1);
610          }
611        }
612        else if(at_Ref_lt<ASCII>(s)){
613          ReportError("Attribute values contain '<' characters after reference expansion", pos);
614          exit(-1);
615        }
616        return 0;
617}
618*/
619
620
621
622@global
623
624#include <simd-lib/transpose.hpp>
625#include <post_process.hpp>
626/*
627static inline void s2p_do_block(BytePack U8[], Basis_bits & basis_bits) {
628  s2p(U8[0], U8[1], U8[2], U8[3], U8[4], U8[5], U8[6], U8[7],
629        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);
630}
631
632static inline void s2p_do_final_block(BytePack U8[], Basis_bits & basis_bits, BitBlock EOF_mask) {
633  s2p_do_block(U8, basis_bits);
634  basis_bits.bit_0 = simd_and(basis_bits.bit_0, EOF_mask);
635  basis_bits.bit_1 = simd_and(basis_bits.bit_1, EOF_mask);
636  basis_bits.bit_2 = simd_and(basis_bits.bit_2, EOF_mask);
637  basis_bits.bit_3 = simd_and(basis_bits.bit_3, EOF_mask);
638  basis_bits.bit_4 = simd_and(basis_bits.bit_4, EOF_mask);
639  basis_bits.bit_5 = simd_and(basis_bits.bit_5, EOF_mask);
640  basis_bits.bit_6 = simd_and(basis_bits.bit_6, EOF_mask);
641  basis_bits.bit_7 = simd_and(basis_bits.bit_7, EOF_mask);
642}
643*/
644static inline void print_basis_bits(Basis_bits & basis_bits){
645        print_register("bit0:",basis_bits.bit_0);
646        print_register("bit1:",basis_bits.bit_1);
647        print_register("bit2:",basis_bits.bit_2);
648        print_register("bit3:",basis_bits.bit_3);
649        print_register("bit4:",basis_bits.bit_4);
650        print_register("bit5:",basis_bits.bit_5);
651        print_register("bit6:",basis_bits.bit_6);
652        print_register("bit7:",basis_bits.bit_7);                                       
653}
654
655static inline void print_elem_vec(vector<char>* vec, int size){
656        cout << "vector: ";
657        for (int i = 0; i<size ; i++){
658                cout << (int)(*vec)[i] <<" ";
659        }
660        cout << endl;
661}
662
663static inline void vec_scan(BitStreamScanner<BitBlock, uint64_t,uint64_t, 32> match_scanner,BitStreamScanner<BitBlock, uint64_t,uint64_t, 32> f_vec_scanner){
664        int current_pos = 0;
665        int next_pos = 0;
666        int match_pos = 0;
667        if(f_vec_scanner.has_next()){
668                current_pos = f_vec_scanner.scan_to_next();
669        }else{
670                return;
671        }
672        if (match_scanner.has_next()){
673                match_pos = match_scanner.scan_to_next();
674        }else{
675                while(f_vec_scanner.has_next()){
676                        current_pos = f_vec_scanner.scan_to_next();
677                        printf("Mismatch found at pos: %d.\n",current_pos);
678                }
679                return;
680        }
681        while(1){
682                if(f_vec_scanner.has_next()){
683                        next_pos = f_vec_scanner.scan_to_next();
684                }else{
685                        next_pos = -1;
686                }
687                if (match_pos > next_pos && next_pos != -1){
688                        printf("Mismatch found at pos: %d.\n",current_pos);
689                }else if (next_pos == -1){
690                        break;
691                }else{
692                        if(match_scanner.has_next()){
693                                match_pos = match_scanner.scan_to_next();
694                        }else{
695                                printf("Mismatch found at pos: %d.\n",next_pos);
696                                while(f_vec_scanner.has_next()){
697                                        current_pos = f_vec_scanner.scan_to_next();
698                                        printf("Mismatch found at pos: %d.\n",current_pos);
699                                }
700                                return;
701                        }
702                }
703                current_pos = next_pos;
704        }
705}
706
707static inline void validate_mul_block(){
708        struct Elem elem;
709        Validation_1 validation_1;
710        struct Lex lex;
711        struct Output output;
712        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;
718       
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);
729                       
730                        classify_bytes.do_block(temp_basis_bits,lex);
731                        validation_1.do_block(lex,output);
732                       
733                        match_scanner.load_block(output.matches,i);
734                        f_vec_scanner.load_block(lex.cc1,i);
735                }
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
754static inline void validate(){
755        struct Elem elem;
756        Validation_1 validation_1;
757        struct Lex lex;
758        struct Output output;
759        Classify_bytes classify_bytes;
760        cout << "vector size " << gid_vec.size() << endl;
761        int lgth = gid_vec.size();
762        int remaining = 0;
763        int current_pos = 0;
764        Basis_bits temp_basis_bits;
765
766        ForwardScanner<BitBlock, ScanWord> match_scanner;
767        ReverseScanner<BitBlock, ScanWord> vec_scanner;
768        ForwardScanner<BitBlock, ScanWord> f_vec_scanner;
769        int block_base = 0;
770        if (lgth != 0){
771                int i = 0;
772                int num_block = lgth /(BLOCK_SIZE *8 / VECTOR_WIDTH);
773                remaining = lgth %(BLOCK_SIZE *8 / VECTOR_WIDTH);
774                for (i = 0;i < num_block; i++){
775//                      s2p_do_block((BytePack*)(vector_11[i]),temp_basis_bits);
776                        s2p_do_block((BytePack*)(&(gid_vec[i])), temp_basis_bits);
777                        print_elem_vec(&(gid_vec),lgth);
778                        print_basis_bits(temp_basis_bits);
779                       
780                        classify_bytes.do_block(temp_basis_bits,lex);
781                        validation_1.do_block(lex,output);
782                       
783                        match_scanner.init(&output.matches);
784                        vec_scanner.init(&lex.cc1);
785                        match_scanner.scan_to_next();
786                        f_vec_scanner.init(&lex.cc1);
787                        match_scanner.scan_to_next();
788                        f_vec_scanner.scan_to_next();
789                        current_pos = f_vec_scanner.get_pos();
790                        vec_scanner.move_to(match_scanner.get_pos());
791                        vec_scanner.scan_to_next();
792//                      cout << "vec_scanner_pos = " << vec_scanner.get_pos() << endl;
793                        if (vec_scanner.get_pos() != current_pos){
794                                printf("#Mismatch found at pos: %d.\n",current_pos+block_base);
795                        }
796//                      out = simd_or(out,lex.cc1);
797//                      print_register("out",out);
798                       
799                        while(!(match_scanner.is_done() || f_vec_scanner.is_done())){
800                                f_vec_scanner.scan_to_next();
801                                while(!(match_scanner.is_done())){
802                                        match_scanner.scan_to_next();
803                                        if(match_scanner.get_pos()>0){
804                                                vec_scanner.move_to(match_scanner.get_pos());
805                                                vec_scanner.scan_to_next();
806                                        }
807                                        if (vec_scanner.get_pos() != current_pos){
808                                                        break;
809                                        }
810                                }
811                                cout << "vec_scanner_pos = " << vec_scanner.get_pos() << endl;
812                                if (f_vec_scanner.get_pos()>0){
813                                        current_pos = f_vec_scanner.get_pos();
814                                }
815                                if (vec_scanner.get_pos() != current_pos){
816                                        printf("Mismatch found at pos: %d.\n",current_pos+block_base);
817                                }
818//                              out = simd_or(out,lex.cc1);
819//                              cout << "match_scanner_pos = " << match_scanner.get_pos() << endl;
820//                              cout << "vec_scanner_pos = " << vec_scanner.get_pos() << endl;
821//                              if(match_scanner.get_pos() == vec_scanner.get_pos()){
822//                                      printf("Match found of element with id of '1'\n");                             
823//                              }
824                        }
825                               
826                       
827//                      (BytePack*)(iter->second)
828//                      validate_Elem_Vec.do_block(elem, temp_basis_bits);
829                        cout << i ;
830                        block_base += BLOCK_SIZE;
831                }
832                if (remaining !=0){
833                        BitBlock EOF_mask = bitblock::srl(simd<1>::constant<1>(),convert(BLOCK_SIZE-remaining));
834                        s2p_do_final_block((BytePack*)(&(gid_vec[i])), temp_basis_bits,EOF_mask);
835                        print_elem_vec(&(gid_vec),lgth);
836                        print_basis_bits(temp_basis_bits);
837                       
838                        classify_bytes.do_block(temp_basis_bits,lex);
839                        validation_1.do_block(lex,output);
840                        print_register("output.matches",output.matches);
841                        print_register("lex.cc1",lex.cc1);
842                        match_scanner.init(&output.matches);
843                        vec_scanner.init(&lex.cc1);
844                        f_vec_scanner.init(&lex.cc1);
845                        match_scanner.scan_to_next();
846                        f_vec_scanner.scan_to_next();
847                        current_pos = f_vec_scanner.get_pos();
848                        cout << "current_pos = " << current_pos << endl;
849//                      cout << "match_scanner_pos = " << match_scanner.get_pos()<< endl;
850//                      cout << "vec_scanner_pos = " << vec_scanner.get_pos() << endl;
851                        vec_scanner.move_to(match_scanner.get_pos());
852                        vec_scanner.scan_to_next();
853                        cout << "vec_scanner_pos = " << vec_scanner.get_pos() << endl;
854                        if (vec_scanner.get_pos() != current_pos){
855                                printf("#Mismatch found at pos: %d.\n",current_pos+block_base);
856                        }
857//                      out = simd_or(out,lex.cc1);
858//                      print_register("out",out);
859                       
860                        while(!(match_scanner.is_done() || f_vec_scanner.is_done())){
861                                f_vec_scanner.scan_to_next();
862                                while(!(match_scanner.is_done())){
863                                        match_scanner.scan_to_next();
864                                        if(match_scanner.get_pos()>0){
865                                                vec_scanner.move_to(match_scanner.get_pos());
866                                                vec_scanner.scan_to_next();
867                                        }
868                                        if (vec_scanner.get_pos() != current_pos){
869                                                        break;
870                                        }
871                                }
872                                cout << "vec_scanner_pos = " << vec_scanner.get_pos() << endl;
873                                if (f_vec_scanner.get_pos()>0){
874                                        current_pos = f_vec_scanner.get_pos();
875                                }
876                                if (vec_scanner.get_pos() != current_pos){
877                                        printf("Mismatch found at pos: %d.\n",current_pos+block_base);
878                                }
879//                              out = simd_or(out,lex.cc1);
880//                              cout << "match_scanner_pos = " << match_scanner.get_pos() << endl;
881//                              cout << "vec_scanner_pos = " << vec_scanner.get_pos() << endl;
882//                              if(match_scanner.get_pos() == vec_scanner.get_pos()){
883//                                      printf("Match found of element with id of '1'\n");                             
884//                              }
885                        }
886//                      validate_Elem_Vec.do_final_block(elem, temp_basis_bits, EOF_mask);
887                }
888        }
889/*
890        vector<int> test;
891        for(int i = 1;i <12; i++){
892                test.push_back(i);
893        }
894//      int test[] = {1,2,3,4,5,6,7,8,9,10,11};
895        Basis_bits temp_basis_bits;
896        BitBlock EOF_mask = sisd_srl(simd_const_1(1),sisd_from_int(BLOCK_SIZE-44));
897        s2p_do_final_block((BytePack*)(&(test[0])), temp_basis_bits,EOF_mask);
898        print_basis_bits(temp_basis_bits);
899*/
900/*
901        for (map<char, vector<char>* > ::const_iterator iter = elem_vec_map.begin(); iter!= elem_vec_map.end(); ++iter){
902                int i = 0;
903                int lgth = (*(iter->second)).size();
904                int remaining;
905                if (lgth != 0){
906                        cout <<"vector key "<< (int)iter->first << endl;
907//                      cout <<"vector ptr" << iter->second<<endl;
908               
909                        cout <<"vector size: " << lgth << endl;
910                        int num_block = lgth /(BLOCK_SIZE *8 / VECTOR_WIDTH);
911                        remaining = lgth %(BLOCK_SIZE *8 / VECTOR_WIDTH);
912                        for (i = 0;i < num_block; i++){
913                                Basis_bits temp_basis_bits;
914                                s2p_do_block(((BytePack*)(&(*(iter->second))[i])), temp_basis_bits);
915                                print_elem_vec(iter->second,lgth);
916                                print_basis_bits(temp_basis_bits);
917//                              (BytePack*)(iter->second)
918                                cout << i ;
919                        }
920                        cout << endl;
921                        if (remaining !=0){
922                                BitBlock EOF_mask = sisd_srl(simd_const_1(1),sisd_from_int(BLOCK_SIZE-remaining));
923                                Basis_bits temp_basis_bits;
924                                s2p_do_final_block(((BytePack*)(&(*(iter->second))[i])), temp_basis_bits,EOF_mask);
925                                print_elem_vec((iter->second)+i,lgth);
926                                print_basis_bits(temp_basis_bits);
927                        }
928                }                       
929        }
930*/
931}
932
933static inline void vectoring(Tag_Callouts & tag_Callouts, Hash_data & hash_data,char *source,int block_base){
934
935        elem_starts = tag_Callouts.ElemName_starts;
936    hashvalues[1] = hash_data.Hash_value;
937   
938        StreamScanLengthGrouping(source,block_base,(ScanBlock *) &tag_Callouts.ElemName_ends,(ScanBlock *) &tag_Callouts.Tag_closing, sizeof(BitBlock)/sizeof(ScanBlock));
939       
940        // Store the last starting position in case we hit boundary case
941    previous_block_last_elem_start = - count_reverse_zeroes(elem_starts);
942
943    //copy current hash value data as previous one.
944    memmove (&hashvalues[0], &hashvalues[1], 16);
945}
946/*
947static inline void postprocess_do_block(Lex & lex, CtCDPI_Callouts & ctCDPI_Callouts, Ref_Callouts & ref_Callouts, Check_streams & check_streams, Tag_Callouts & tag_Callouts, Hash_data & hash_data, int chars_avail){
948
949
950    //NOTE: We are NOT handling the case for an extremely long symbol name (length > 1541).
951    //      TagMatcher will crash if we feed a long symbol name.
952    //      Sample file: test/long_sym_name.xml
953
954    tracker.StoreNewlines(lex.LF);
955    elem_starts = tag_Callouts.ElemName_starts;
956    hashvalues[1] = hash_data.Hash_value;
957
958        StreamScanLengthGrouping((ScanBlock *) &tag_Callouts.ElemName_ends,(ScanBlock *) &tag_Callouts.Tag_closing, sizeof(BitBlock)/sizeof(ScanBlock));
959       
960/*
961    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_1) )
962    {
963        StreamScanLengthGrouping<1>((ScanBlock *) &tag_Callouts.ElemName_ends_1,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
964    }
965
966    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_2) )
967    {
968        StreamScanLengthGrouping<2>((ScanBlock *) &tag_Callouts.ElemName_ends_2,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
969    }
970
971    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_3) )
972    {
973        StreamScanLengthGrouping<3>((ScanBlock *) &tag_Callouts.ElemName_ends_3,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
974    }
975
976    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_4) )
977    {
978        StreamScanLengthGrouping<4>((ScanBlock *) &tag_Callouts.ElemName_ends_4,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
979    }
980
981    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_5) )
982    {
983        StreamScanLengthGrouping<5>((ScanBlock *) &tag_Callouts.ElemName_ends_5,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
984    }
985
986    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_6) )
987    {
988        StreamScanLengthGrouping<6>((ScanBlock *) &tag_Callouts.ElemName_ends_6,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
989    }
990
991    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_7) )
992    {
993        StreamScanLengthGrouping<7>((ScanBlock *) &tag_Callouts.ElemName_ends_7,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
994    }
995
996    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_8) )
997    {
998        StreamScanLengthGrouping<8>((ScanBlock *) &tag_Callouts.ElemName_ends_8,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
999    }
1000
1001    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_9) )
1002    {
1003        StreamScanLengthGrouping<9>((ScanBlock *) &tag_Callouts.ElemName_ends_9,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
1004    }
1005
1006    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_10) )
1007    {
1008        StreamScanLengthGrouping<10>((ScanBlock *) &tag_Callouts.ElemName_ends_10,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
1009    }
1010
1011    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_11) )
1012    {
1013        StreamScanLengthGrouping<11>((ScanBlock *) &tag_Callouts.ElemName_ends_11,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
1014    }
1015
1016    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_12) )
1017    {
1018        StreamScanLengthGrouping<12>((ScanBlock *) &tag_Callouts.ElemName_ends_12,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
1019    }
1020
1021    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_13) )
1022    {
1023        StreamScanLengthGrouping<13>((ScanBlock *) &tag_Callouts.ElemName_ends_13,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
1024    }
1025
1026    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_14) )
1027    {
1028        StreamScanLengthGrouping<14>((ScanBlock *) &tag_Callouts.ElemName_ends_14,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
1029    }
1030
1031    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_15) )
1032    {
1033        StreamScanLengthGrouping<15>((ScanBlock *) &tag_Callouts.ElemName_ends_15,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
1034    }
1035
1036    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_16) )
1037    {
1038        StreamScanLengthGrouping<16>((ScanBlock *) &tag_Callouts.ElemName_ends_16,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
1039    }
1040
1041    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_17_and_longer) )
1042    {
1043        StreamScanLengthGrouping<17>((ScanBlock *) &tag_Callouts.ElemName_ends_17_and_longer,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
1044    }
1045
1046*/
1047
1048
1049/*
1050    // Store the last starting position in case we hit boundary case
1051    previous_block_last_elem_start = - count_reverse_zeroes(elem_starts);
1052
1053    //copy current hash value data as previous one.
1054    memmove (&hashvalues[0], &hashvalues[1], 16);
1055
1056    if (bitblock::any(simd_or(check_streams.non_ascii_name_starts, check_streams.non_ascii_names))) {
1057      StreamScan((ScanBlock *) &check_streams.non_ascii_name_starts, sizeof(BitBlock)/sizeof(ScanBlock), NameStrt_check);
1058      StreamScan((ScanBlock *) &check_streams.non_ascii_names, sizeof(BitBlock)/sizeof(ScanBlock), Name_check);
1059    }
1060
1061    if (bitblock::any(ctCDPI_Callouts.PI_name_starts)){
1062      StreamScan((ScanBlock *) &ctCDPI_Callouts.PI_name_starts, sizeof(BitBlock)/sizeof(ScanBlock), PIName_check);
1063    }
1064
1065    if (bitblock::any(ctCDPI_Callouts.CD_starts)){
1066      StreamScan((ScanBlock *) &ctCDPI_Callouts.CD_starts, sizeof(BitBlock)/sizeof(ScanBlock), CD_check);
1067    }
1068
1069    if (bitblock::any(ref_Callouts.GenRef_starts)){
1070      StreamScan((ScanBlock *) &ref_Callouts.GenRef_starts, sizeof(BitBlock)/sizeof(ScanBlock), GenRef_check);
1071    }
1072
1073    if (bitblock::any(ref_Callouts.DecRef_starts)){
1074      StreamScan((ScanBlock *) &ref_Callouts.DecRef_starts, sizeof(BitBlock)/sizeof(ScanBlock), DecRef_check);
1075    }
1076
1077    if (bitblock::any(ref_Callouts.HexRef_starts)){
1078      StreamScan((ScanBlock *) &ref_Callouts.HexRef_starts, sizeof(BitBlock)/sizeof(ScanBlock), HexRef_check);
1079    }
1080
1081    if (bitblock::any(check_streams.att_refs)){
1082      StreamScan((ScanBlock *) &check_streams.att_refs, sizeof(BitBlock)/sizeof(ScanBlock), AttRef_check);
1083    }
1084
1085//    error_tracker.If_Error_Report_First();
1086/*
1087    matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
1088    tracker.AdvanceBlock();
1089    */
1090    /*
1091}
1092*/
1093
1094static inline void print_GIDS()
1095{
1096    int span_count = gids.size();
1097    for(int i=0;i<span_count;i++) {
1098             cout << gids[i] << " ";
1099    }
1100    cout << endl;
1101}
1102
1103static inline int test(int)
1104{
1105    return 0;
1106}
1107
1108void do_process(FILE *infile, FILE *outfile) {
1109
1110        ///////////////
1111        //gid file
1112        ///////////////
1113        gid_writein = fopen("gid.out","w");
1114@decl
1115        #ifndef STL_ALIGNED_VECTOR
1116                TagMatcher<SEGMENT_SIZE,LOOKAHEAD_SIZE> matcher;
1117        #endif
1118        ///////////////////////////////////////////////////
1119        //preload element_IDs into symbol table from schema
1120        ///////////////////////////////////////////////////
1121        FILE *element_ID_in = fopen("../test/element_ID","r");
1122        char symbol[50];
1123        int index;
1124        if(element_ID_in == NULL){
1125                printf("Error opening element_ID file.\n");
1126                exit(0);
1127        }
1128        hashvalues[1] = hash_data.Hash_value;
1129        while(fscanf(element_ID_in,"%s %d\n",&symbol[0],&index)==2){
1130                int lgth = strlen(symbol);
1131                int hashvalue = compute_hash_value2(symbol,lgth);
1132                cout << symbol <<" "<< lgth<<" "<<hashvalue << endl;
1133                int gid = 0;
1134                switch (lgth)
1135        {
1136                        case 1:
1137                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<1>(symbol, hashvalue);
1138                        break;
1139                        case 2:
1140                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<2>(symbol, hashvalue);
1141                        break;
1142                        case 3:
1143                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<3>(symbol, hashvalue);
1144                        break;
1145                        case 4:
1146                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<4>(symbol, hashvalue);
1147                        break;
1148                        case 5:
1149                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<5>(symbol, hashvalue);
1150                        break;
1151                        case 6:
1152                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<6>(symbol, hashvalue);
1153                        break;
1154                        case 7:
1155                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<7>(symbol, hashvalue);
1156                        break;
1157                        case 8:
1158                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<8>(symbol, hashvalue);
1159                        break;
1160                        case 9:
1161                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<9>(symbol, hashvalue);
1162                        break;
1163                        case 10:
1164                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<10>(symbol, hashvalue);
1165                        break;
1166                        case 11:
1167                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<11>(symbol, hashvalue);
1168                        break;
1169                        case 12:
1170                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<12>(symbol, hashvalue);
1171                        break;
1172                        case 13:
1173                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<13>(symbol, hashvalue);
1174                        break;
1175                        case 14:
1176                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<14>(symbol, hashvalue);
1177                        break;
1178                        case 15:
1179                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<15>(symbol, hashvalue);
1180                        break;
1181                        case 16:
1182                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<16>(symbol, hashvalue);
1183                        break;
1184                        default:
1185                        gid = pbgs_symbol_table.Lookup_or_Insert_Name(symbol, hashvalue, lgth);
1186                        break;         
1187                }
1188                fprintf (gid_writein,"%s |  lgth: %i | hashvalue: %i | gid: %i | symbol: %s\n", __FUNCTION__,  lgth, hashvalue, gid, symbol);
1189        }       
1190        fclose(element_ID_in);
1191//      return;
1192
1193        int buffer_base = 0;
1194        int block_base = 0;
1195        int buffer_pos = 0;
1196        int block_pos = 0;
1197        int errpos = 0;
1198        int chars_avail = 0;
1199        int check_pos = 0;
1200        int chars_read = 0;
1201 
1202        //////////////////////////////////////////////////////////////////////////////////////////
1203    // Buffer Management
1204    //////////////////////////////////////////////////////////////////////////////////////////
1205                //      BitBlock buf[(BUFFER_SIZE)/sizeof(BitBlock)];
1206                //      uint8_t * src_buffer = (uint8_t *)buf + COPYBACK_SIZE;
1207
1208                #ifdef STL_ALIGNED_VECTOR
1209                        std::vector<uint8_t, AAllocator<uint8_t> > src_buffer;
1210                        src_buffer.reserve(BUFFER_SIZE);
1211                #else
1212                        char * COPYBACK;
1213                        char * src_buffer;
1214                        ALLOC_STATIC_ALIGNED_BYTE_BUFFER_WITH_COPYBACK(COPYBACK, src_buffer);
1215                #endif
1216  /*
1217  BytePack buf[(BUFFER_SIZE+BLOCK_SIZE+LOOKAHEAD_SIZE*2)/sizeof(SIMD_type)];
1218
1219  char * srcbuf = ((char *) buf) + LOOKAHEAD_SIZE;
1220  buffer_base = buf_pos;
1221  source = srcbuf;
1222  */
1223  chars_read = fread((void *)&src_buffer[0], 1, SEGMENT_SIZE, infile);
1224  chars_avail = chars_read;
1225  if (chars_avail > BUFFER_SIZE) chars_avail = SEGMENT_SIZE;
1226
1227  if(chars_read<4){
1228    fprintf(stderr,"File is too short. Not well formed.\n");
1229    exit(-1);
1230  }
1231
1232  Entity_Info * e = new Entity_Info;
1233  e->AnalyzeSignature((unsigned char *)&src_buffer[0]);
1234
1235  if (e->code_unit_base == ASCII) {
1236
1237    XML_Decl_Parser<ASCII> decl_parser((unsigned char *)&src_buffer[0]);
1238
1239    decl_parser.ReadXMLInfo(*e);
1240
1241    if (e->code_unit_size != SingleByte || (e->has_encoding_decl && (!at_UTF_8(e->encoding)))){
1242        fprintf(stderr,"Sorry, this xmlwf demo only works for UTF-8.\n");
1243        exit(-1);
1244    }
1245  }
1246  else {
1247    fprintf(stderr,"Sorry, this xmlwf demo does not process EBCDIC.\n");
1248        exit(-1);
1249  }
1250
1251  if (e->content_start != 0) {
1252        memmove(&src_buffer[0], &src_buffer[e->content_start], chars_read - e->content_start);
1253        buffer_pos = e->content_start;
1254//      buffer_base = buffer_pos;
1255        if ((chars_avail-e->content_start) < SEGMENT_SIZE) {
1256                        chars_read = chars_avail - e->content_start + fread(&src_buffer[chars_avail-e->content_start], 1, e->content_start, infile);
1257                        chars_avail = chars_read;
1258                }
1259                if (chars_avail >= SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
1260  }
1261
1262        //////////////////////////////////////////////////////////////////////////////////////////
1263        // Read OVERLAP bytes to support post processing validation lookahead.
1264        //////////////////////////////////////////////////////////////////////////////////////////
1265        chars_read = chars_avail + fread(&src_buffer[chars_avail], 1, LOOKAHEAD_SIZE, infile);
1266        chars_avail = chars_read;
1267        if (chars_avail >= SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
1268
1269@stream_stmts
1270
1271        #ifndef STL_ALIGNED_VECTOR
1272        matcher.setSrc((char *)&src_buffer[0]);
1273        #endif
1274
1275/* Full Buffers */
1276    int block_segment_num = 0;
1277    while (chars_avail >= SEGMENT_SIZE) {
1278      PERF_SEC_START(parser_timer);
1279      for (int blk = 0; blk < SEGMENT_BLOCKS; blk++) {
1280        cout << "loops" << ends;
1281                block_base = blk*BLOCK_SIZE;
1282        s2p_do_block((BytePack *) &src_buffer[block_base], basis_bits);
1283     
1284                @block_stmts
1285         
1286                tracker.StoreNewlines(lex.LF);
1287                cout << "post start" << endl;
1288//              postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, tag_Callouts, hash_data, chars_avail);
1289                postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, (char *)&src_buffer[0], buffer_base, block_base, chars_avail, tracker);
1290                vectoring(tag_Callouts,hash_data,(char *)&src_buffer[0],block_base);
1291                cout << "post done" << endl;
1292                #ifndef STL_ALIGNED_VECTOR
1293                matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
1294                #endif
1295                tracker.AdvanceBlock();
1296                cout << "loop" << endl;
1297      }
1298      #ifndef STL_ALIGNED_VECTOR
1299      matcher.StreamScan(chars_avail);
1300      matcher.Advance_buffer();
1301      #endif
1302      cout << "11111" << endl;
1303      PERF_SEC_END(parser_timer, chars_avail);
1304          cout << "here" << endl;
1305      int bytes_left = chars_read - chars_avail;
1306      //////////////////
1307      //element name buffer, for scanning element name backwards
1308      /////////////////
1309      memmove(&element_name_buffer[0],&src_buffer[SEGMENT_SIZE-ELEMENT_BUFFER_SIZE],ELEMENT_BUFFER_SIZE);
1310      cross_buffer_flag = 1;
1311     
1312      memmove(&src_buffer[0], &src_buffer[SEGMENT_SIZE], LOOKAHEAD_SIZE);
1313      chars_read = fread(&src_buffer[LOOKAHEAD_SIZE],1,SEGMENT_SIZE, infile) + LOOKAHEAD_SIZE;
1314      chars_avail = chars_read;
1315      cout << "here" << endl;
1316      if (chars_avail > SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
1317      buffer_pos += chars_avail;
1318      buffer_base = buffer_pos;
1319      block_segment_num++;
1320
1321  }
1322       
1323/* Final Partial Buffer */
1324    PERF_SEC_START(parser_timer);
1325
1326    block_pos = 0;
1327    int remaining = chars_avail;
1328
1329
1330
1331/* Full Blocks */
1332    while (remaining >= BLOCK_SIZE) {
1333          block_base = block_pos;
1334          s2p_do_block((BytePack *) &src_buffer[block_pos], basis_bits);
1335         
1336          @block_stmts
1337         
1338          tracker.StoreNewlines(lex.LF);
1339          cout << "post start1" << endl;
1340         
1341//        postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, tag_Callouts, hash_data, chars_avail);
1342          postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, (char *)&src_buffer[0], buffer_base, block_base, chars_avail, tracker);
1343          vectoring(tag_Callouts,hash_data,(char *)&src_buffer[0],block_base);
1344          cout << "post end2" << endl;
1345          #ifndef STL_ALIGNED_VECTOR
1346          matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
1347          #endif
1348          tracker.AdvanceBlock();
1349          block_pos += BLOCK_SIZE;
1350          remaining -= BLOCK_SIZE;
1351    }
1352    block_base = block_pos;
1353        #ifdef USE_ANY_CARRY_TEST
1354    if (remaining > 0 || @any_carry) {
1355        #endif
1356          EOF_mask = bitblock::srl(simd<1>::constant<1>(),convert(BLOCK_SIZE-remaining));
1357          s2p_do_final_block((BytePack *) &src_buffer[block_pos], basis_bits, EOF_mask);
1358          @final_block_stmts
1359          cout << "post start3" << endl;
1360//        postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, tag_Callouts, hash_data, chars_avail);
1361          postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, (char *)&src_buffer[0], buffer_base, block_base, chars_avail, tracker);
1362          vectoring(tag_Callouts,hash_data,(char *)&src_buffer[0],block_base);
1363          cout << "post end3" << endl;
1364          #ifndef STL_ALIGNED_VECTOR
1365      matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
1366          #endif
1367          tracker.AdvanceBlock();
1368        #ifdef USE_ANY_CARRY_TEST
1369    }
1370    #endif
1371    buffer_pos += chars_avail;
1372    buffer_base = buffer_pos;
1373        #ifndef STL_ALIGNED_VECTOR
1374    matcher.StreamScan(chars_avail);
1375    matcher.Advance_buffer();
1376//    tracker.Advance_buffer();
1377
1378   
1379    if (matcher.depth != 0) {
1380      fprintf(stderr, "tag matching error (depth %i) at position %i\n", matcher.depth, buffer_base);
1381      exit(-1);
1382     
1383     
1384    }
1385    #endif
1386    PERF_SEC_END(parser_timer, chars_avail);
1387//  print_GIDS();
1388//    pbgs_symbol_table.Print_Symbol_Table_Distribution();
1389}
1390
1391
1392
1393int
1394main(int argc, char * argv[]) {
1395        char * infilename, * outfilename;
1396        FILE *infile, *outfile;
1397        struct stat fileinfo;
1398
1399        if (argc < 2) {
1400                printf("Usage: %s <filename> [<outputfile>]\n", argv[0]);
1401                exit(-1);
1402        }
1403
1404        infilename = argv[1];
1405        stat(infilename, &fileinfo);
1406        infile = fopen(infilename, "rb");
1407        if (!infile) {
1408                fprintf(stderr, "Error: cannot open %s for input.\n", infilename);
1409                exit(-1);
1410        }
1411
1412        if (argc < 3) outfile = stdout;
1413        else {
1414                outfilename = argv[2];
1415                outfile = fopen(outfilename, "wb");
1416                if (!outfile) {
1417                        fprintf(stderr, "Error: cannot open %s for writing.\n", outfilename);
1418                        exit(-1);
1419                }
1420        }
1421
1422//      PERF_SEC_BIND(1);
1423
1424        PERF_SEC_INIT(parser_timer);
1425
1426        do_process(infile, outfile);
1427       
1428#if DEBUG
1429print_gid_vec();
1430#endif
1431        //cout << "validate start" << endl;
1432        //validate();
1433        validate_mul_block();
1434
1435        PERF_SEC_DUMP(parser_timer);
1436
1437        PERF_SEC_DESTROY(parser_timer);
1438
1439        fclose(infile);
1440        fclose(outfile);
1441
1442        printf ("Done procressing\n");
1443        return(0);
1444}
Note: See TracBrowser for help on using the repository browser.