source: proto/xmlschema/validation_template_mulvec.cpp @ 3592

Last change on this file since 3592 was 2256, checked in by shiyangy, 7 years ago
File size: 34.2 KB
Line 
1#include <stdio.h>
2#include <stdlib.h>
3#include <errno.h>
4#include <sys/types.h>
5#include <sys/stat.h>
6#include <vector>
7#include <map>
8#include <stack>
9
10#define LocalCarryDeclare(name, count)\
11CarryArray<count> name;\
12
13#include "../lib/bitblock.hpp"
14#include "../lib/carryQ.hpp"
15#include "../lib/bitstream_iterator.hpp"
16#include "../lib/bitblock_iterator.hpp"
17#include "../lib/perflib/perfsec.h"
18#include "../lib/s2p.hpp"
19
20// Define the mappings for pablo.assert_0(strm, errkind) statements which
21// compile to the the form assert_0_error(errkind, strm)
22#define assert_0_error(errkind, errstrm) error_tracker.NoteError(errkind, errstrm);
23
24#define VECTOR_WIDTH 8
25#define VECTOR_TYPE (char)
26#define DEBUG 0
27
28#define ScanBlock long long int
29
30#include "xmldecl.h"
31#include "namechars.h"
32#include "TagMatcher.hpp"
33#include "LineColTracker.hpp"
34#include "ErrorUtil.h"
35#include "ErrorTracker.h"
36#include "XMLTestSuiteError.h"
37#include "../symtab/pbgs_identity_symbol_table.h"
38
39#include "../lib/buffer.hpp"
40
41#define OVERLAP_BUFSIZE PADDING_SIZE //sizeof(BitBlock)
42
43#ifdef BUFFER_PROFILING
44        BOM_Table * parser_timer;
45
46#elif CODE_CLOCKER
47        #define NUM_EVENTS 1
48        int Events[NUM_EVENTS] = {PAPI_TOT_CYC};
49        //int Events[NUM_EVENTS] = {PAPI_L2_DCM};
50        //int Events[NUM_EVENTS] = {PAPI_TOT_CYC, PAPI_BR_MSP};
51        int cal_size = 20;
52        CC * parser_timer = new CC(Events,NUM_EVENTS,cal_size);
53#else
54        void * parser_timer;
55#endif
56
57int block_base=0;
58int buffer_base=0;
59char * source;
60int previous_block_last_elem_start;
61
62ErrorTracker error_tracker;
63BitBlock EOF_mask = simd<1>::constant<1>();
64
65//////////////////////////////////////////////////////////////////////////////////////////
66// Buffer Management // WARNING: Do Not update #defines. Results in TagMatcher errors.
67//////////////////////////////////////////////////////////////////////////////////////////
68#define PADDING_BLOCKS 0
69#define PADDING_SIZE (BLOCK_SIZE * PADDING_BLOCKS)
70#define COPYBACK_BLOCKS 2
71#define COPYBACK_SIZE (BLOCK_SIZE * COPYBACK_BLOCKS)
72#define LOOKAHEAD_BLOCKS 1
73#define LOOKAHEAD_SIZE (BLOCK_SIZE * LOOKAHEAD_BLOCKS)
74#define SEGMENT_BLOCKS  12 // WARNING: TagMatcher.hpp causes xmlconf test suite failures for SEGMENT_BLOCKS < 3.
75#define SEGMENT_SIZE (BLOCK_SIZE * SEGMENT_BLOCKS)
76#define BUFFER_SIZE (COPYBACK_SIZE + SEGMENT_SIZE + LOOKAHEAD_SIZE + PADDING_SIZE)
77
78BitBlock elem_starts;
79BytePack hashvalues[2];
80
81vector <int> gids;
82PBGSIdentitySymbolTable pbgs_symbol_table;
83
84stack <vector<char>* > elem_vec_stack;
85map<char, vector<char>* > elem_vec_map;
86map<char, vector<int>* > elem_pos_map;
87
88//file of all the gids
89FILE * ofile;
90
91//buffer for double_list data validation
92int val_buf_curser = 0;
93int content_start_pos = 0;
94int content_start_flag = 0; //-1 if the content_start is not in the current block, need to search for the comming blocks; 1 if content_start is in the former block; 0 content_start and content_end are both in current block
95int content_end_flag = 0; // content_end flag
96int val_buf_avail = sizeof(BitBlock)*8; // char available of val_buf
97//BytePack val_buf[(BUFFER_SIZE+BLOCK_SIZE+OVERLAP_BUFSIZE*2)/sizeof(BitBlock)];
98char val_buf[sizeof(BitBlock)*8];
99
100int counter = 0;
101
102static inline int NameStrt_check(int pos);
103static inline int Name_check(int pos);
104static inline int PIName_check(int pos);
105static inline int CD_check(int pos);
106static inline int GenRef_check(int pos);
107static inline int HexRef_check(int pos);
108static inline int DecRef_check(int pos);
109static inline int AttRef_check(int pos);
110
111@global
112
113//////////////////////////////////////////////////////////////////////////////////////////
114// Headers that depend @ global stream struct types.
115//////////////////////////////////////////////////////////////////////////////////////////
116#include "../lib/transpose.hpp"
117#include <post_process.hpp>
118
119static inline void s2p_do_block(BytePack U8[], Basis_bits & basis_bits);
120static inline void s2p_do_final_block(BytePack U8[], Basis_bits & basis_bits, BitBlock EOF_mask);
121static inline void postprocess_do_block(Lex & lex, CtCDPI_Callouts & ctCDPI_Callouts, Ref_Callouts & ref_Callouts, Check_streams & check_streams, int chars_avail);
122
123static inline void do_process(FILE *infile, FILE *outfile);
124
125static inline void validate_block(BitBlockForwardIterator & start, int block_base, int is_valid(int));
126static inline void validate_block(BitBlockForwardIterator & start, int block_base, int is_valid(int,int));
127
128static inline int ScanBackwardPos(BitBlock * block, int pos,int previous_block_last_elem_start);
129static inline int compute_hash_value (int lgth, int start);
130static inline char ElemEnd_grouping(int pos);
131//static inline int StreamScanLengthGrouping(ScanBlock * stream, ScanBlock * stream2, int blk_count);
132static inline int StreamScanLengthGrouping(Tag_Callouts & tag_Callouts, int blk_count);
133static inline void print_vecs();
134static inline void print_elem_vec(vector<char>* vec, int size);
135static inline void validation_do_block(Lex & lex, Tag_Callouts & tag_Callouts, Hash_data & hash_data, int chars_avail);
136static inline void print_basis_bits(Basis_bits & basis_bits);
137static inline void validate_city_gml();
138static inline void print_streams(char * s1,BitBlock & block, char * name);
139static inline void print_buffer(char * block, char * name);
140static inline void val_double_list(Tag_Callouts & tag_Callouts,int end_pos,int block_pos,int blk);
141static inline void val_dl_block();
142
143struct Citygml citygml;
144Validation_Vec_2 validation_Vec_2;
145
146int main(int argc, char * argv[]) {
147
148        char * infilename, * outfilename;
149        FILE *infile, *outfile;
150        struct stat fileinfo;
151       
152        ofile = fopen("gids.out","w");
153
154        if (argc < 2) {
155                printf("Usage: %s <filename> [<outputfile>]\n", argv[0]);
156                exit(-1);
157        }
158
159        infilename = argv[1];
160        stat(infilename, &fileinfo);
161        infile = fopen(infilename, "rb");
162        if (!infile) {
163                fprintf(stderr, "Error: cannot open %s for input.\n", infilename);
164                exit(-1);
165        }
166
167        if (argc < 3) outfile = stdout;
168        else {
169                outfilename = argv[2];
170                outfile = fopen(outfilename, "wb");
171                if (!outfile) {
172                        fprintf(stderr, "Error: cannot open %s for writing.\n", outfilename);
173                        exit(-1);
174                }
175        }
176
177//      PERF_SEC_BIND(1);
178
179        PERF_SEC_INIT(parser_timer);
180
181        do_process(infile, outfile);
182       
183        validate_city_gml();
184
185        PERF_SEC_DUMP(parser_timer);
186
187        PERF_SEC_DESTROY(parser_timer);
188
189        fclose(infile);
190        fclose(outfile);
191
192        return(0);
193}
194
195/* s2p Definitions */
196static inline void s2p_do_block(BytePack U8[], Basis_bits & basis_bits) {
197  s2p(U8[0], U8[1], U8[2], U8[3], U8[4], U8[5], U8[6], U8[7],
198        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);
199}
200
201static inline void s2p_do_final_block(BytePack U8[], Basis_bits & basis_bits, BitBlock EOF_mask) {
202  s2p_do_block(U8, basis_bits);
203  basis_bits.bit_0 = simd_and(basis_bits.bit_0, EOF_mask);
204  basis_bits.bit_1 = simd_and(basis_bits.bit_1, EOF_mask);
205  basis_bits.bit_2 = simd_and(basis_bits.bit_2, EOF_mask);
206  basis_bits.bit_3 = simd_and(basis_bits.bit_3, EOF_mask);
207  basis_bits.bit_4 = simd_and(basis_bits.bit_4, EOF_mask);
208  basis_bits.bit_5 = simd_and(basis_bits.bit_5, EOF_mask);
209  basis_bits.bit_6 = simd_and(basis_bits.bit_6, EOF_mask);
210  basis_bits.bit_7 = simd_and(basis_bits.bit_7, EOF_mask);
211}
212
213
214static inline int NameStrt_check(int pos) {
215        if(XML_10_UTF8_NameStrt_bytes((unsigned char*)&source[pos]) == 0){
216              return XMLTestSuiteError::NAME_START;
217        }
218        return 0;
219}
220
221static inline int Name_check(int pos) {
222        if(XML_10_UTF8_NameChar_bytes((unsigned char*)&source[pos]) == 0){
223                  return XMLTestSuiteError::NAME;
224        }
225        return 0;
226}
227
228static inline int PIName_check(int pos, int file_pos) {
229        if (at_XxMmLll<ASCII>((unsigned char*)&source[pos]) && (source[pos+3]=='?' || source[pos+3]<= ' ')) {
230              // "<?xml" legal at start of file.
231              if (!((file_pos == 2) && at_XmlDecl_start<ASCII>((unsigned char*)&source[0]))) {
232                  return XMLTestSuiteError::XMLPINAME;
233              }
234        }
235        return 0;
236}
237
238static inline int CD_check(int pos) {
239        if (!at_CDATA1<ASCII>((unsigned char*)&source[pos])){
240                  return XMLTestSuiteError::CDATA;
241        }
242        return 0;
243}
244
245static inline int GenRef_check(int pos) {
246        unsigned char* s = (unsigned char*)&source[pos];
247        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))){
248              return XMLTestSuiteError::UNDEFREF;
249        }
250        return 0;
251}
252
253static inline int HexRef_check(int pos) {
254        unsigned char* s = (unsigned char*)&source[pos];
255        int ch_val = 0;
256        while(at_HexDigit<ASCII>(s)){
257          ch_val = HexVal<ASCII>(s[0]) + (ch_val<<4);
258          if (ch_val> 0x10FFFF ){
259                return XMLTestSuiteError::CHARREF;
260          }
261          s++;
262        }
263        if ((ch_val == 0x0) || ((ch_val | 0x7FF) == 0xDFFF)|| ((ch_val | 0x1) == 0xFFFF)){
264          return XMLTestSuiteError::CHARREF;
265        }
266        else if (((ch_val < 0x20) && (ch_val != 0x9) && (ch_val != 0xD) && (ch_val != 0xA))){
267          return XMLTestSuiteError::XML10CHARREF;
268        }
269        return 0;
270}
271
272static inline int DecRef_check(int pos) {
273        unsigned char* s = (unsigned char*)&source[pos];
274        int ch_val = 0;
275        while(at_HexDigit<ASCII>(s)){
276          ch_val = DigitVal<ASCII>(s[0]) + ch_val*10;
277          if (ch_val> 0x10FFFF ){
278                        return XMLTestSuiteError::CHARREF;
279          }
280          s++;
281        }
282        if ((ch_val == 0x0) || ((ch_val | 0x7FF) == 0xDFFF)|| ((ch_val | 0x1) == 0xFFFF)){
283                  return XMLTestSuiteError::CHARREF;
284        }
285        else if (((ch_val < 0x20) && (ch_val != 0x9) && (ch_val != 0xD) && (ch_val != 0xA))){
286                  return XMLTestSuiteError::XML10CHARREF;
287        }
288        return 0;
289}
290
291static inline int AttRef_check(int pos) {
292        unsigned char* s = (unsigned char*)&source[pos];
293        int ch_val = 0;
294        if(s[0]=='#'){
295          s++;
296          if(s[0]=='x' || s[0]=='X'){
297            s++;
298            while(at_HexDigit<ASCII>(s)){
299              ch_val = HexVal<ASCII>(s[0]) + (ch_val<<4);
300              s++;
301            }
302          }
303          else{
304            while(at_HexDigit<ASCII>(s)){
305              ch_val = DigitVal<ASCII>(s[0]) + ch_val*10;
306              s++;
307            }
308          }
309          if (ch_val==60){
310            return XMLTestSuiteError::ATTREF;
311          }
312        }
313        else if(at_Ref_lt<ASCII>(s)){
314          return XMLTestSuiteError::ATTREF;
315        }
316        return 0;
317}
318
319static inline void validate_block(BitBlockForwardIterator & start, int block_base, int is_valid(int)) {
320
321        int pos, block_pos;
322        BitBlockForwardIterator end;
323        while(start != end) {
324
325                block_pos = block_base + *start;
326                int rv = is_valid(block_pos);
327
328                if (rv) {
329                        int error_line, error_column;
330                        tracker.get_Line_and_Column(block_pos, error_line, error_column);
331                        ReportError(XMLTestSuiteError::get_msg(rv), error_line, error_column);
332                        exit(-1);
333                }
334                start++;
335        }
336}
337
338static inline void validate_block(BitBlockForwardIterator & start, int block_base, int buffer_base, int is_valid(int,int)) {
339
340        int pos, block_pos, file_pos;
341        BitBlockForwardIterator end;
342        while(start != end) {
343
344                block_pos = block_base + *start;
345                file_pos = block_pos+buffer_base;
346
347
348                int rv = is_valid(block_pos, file_pos);
349
350                if (rv) {
351                        int error_line, error_column;
352                        tracker.get_Line_and_Column(block_pos, error_line, error_column);
353                        ReportError(XMLTestSuiteError::get_msg(rv), error_line, error_column);
354                        exit(-1);
355                }
356                start++;
357        }
358}
359
360static inline void postprocess_do_block(Lex & lex, CtCDPI_Callouts & ctCDPI_Callouts, Ref_Callouts & ref_Callouts, Check_streams & check_streams, int chars_avail){
361BitBlockForwardIterator iter;
362
363tracker.StoreNewlines(lex.LF);
364/*
365if (bitblock_has_bit(simd_or(check_streams.non_ascii_name_starts, check_streams.non_ascii_names))) {
366        iter.init(&check_streams.non_ascii_name_starts);
367        validate_block(iter, block_base, NameStrt_check);
368        iter.init(&check_streams.non_ascii_names);
369        validate_block(iter, block_base, Name_check);
370}
371if (bitblock_has_bit(ctCDPI_Callouts.PI_name_starts)){
372        iter.init(&(ctCDPI_Callouts.PI_name_starts));
373        validate_block(iter, block_base, buffer_base, PIName_check);
374}
375if (bitblock_has_bit(ctCDPI_Callouts.CD_starts)){
376        iter.init(&ctCDPI_Callouts.CD_starts);
377        validate_block(iter, block_base, CD_check);
378}
379if(bitblock_has_bit(ref_Callouts.GenRef_starts)){
380        iter.init(&ref_Callouts.GenRef_starts);
381        validate_block(iter, block_base, GenRef_check);
382}
383if(bitblock_has_bit(ref_Callouts.DecRef_starts)){
384        iter.init(&ref_Callouts.DecRef_starts);
385        validate_block(iter, block_base, DecRef_check);
386}
387if(bitblock_has_bit(ref_Callouts.HexRef_starts)){
388        iter.init(&ref_Callouts.HexRef_starts);
389        validate_block(iter, block_base, HexRef_check);
390}
391if(bitblock_has_bit(check_streams.att_refs)){
392        iter.init(&check_streams.att_refs);
393        validate_block(iter, block_base, AttRef_check);
394}
395*/
396if(error_tracker.Has_Noted_Error()){
397        int error_line, error_column;
398        tracker.get_Line_and_Column(error_tracker.Noted_Pos_In_Block(), error_line, error_column);
399        ReportError(error_tracker.Noted_Error_Msg(), error_line, error_column);
400        exit(-1);
401}
402
403matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
404tracker.AdvanceBlock();
405
406}
407
408void do_process(FILE *infile, FILE *outfile) {
409
410@decl
411
412  int buf_pos = 0;
413  int block_pos = 0;
414  int chars_avail = 0;
415  int check_pos = 0;
416  int chars_read = 0;
417  BytePack buf[(BUFFER_SIZE+BLOCK_SIZE+OVERLAP_BUFSIZE*2)/sizeof(BitBlock)];
418
419  char * srcbuf = ((char *) buf) + OVERLAP_BUFSIZE;
420  buffer_base = buf_pos;
421  source = srcbuf;
422
423  chars_read = fread((void *)srcbuf, 1, BUFFER_SIZE + OVERLAP_BUFSIZE, infile);
424  chars_avail = chars_read;
425  if (chars_avail > BUFFER_SIZE) chars_avail = BUFFER_SIZE;
426 
427
428  matcher.setSrc(srcbuf);
429
430  if(chars_read<4){
431    fprintf(stderr,"File is too short. Not well formed.\n");
432    exit(-1);
433  }
434
435  Entity_Info * e = new Entity_Info;
436  e->AnalyzeSignature((unsigned char *)srcbuf);
437
438  if (e->code_unit_base == ASCII) {
439
440    XML_Decl_Parser<ASCII> decl_parser((unsigned char *)srcbuf);
441
442    decl_parser.ReadXMLInfo(*e);
443
444    if (e->code_unit_size != SingleByte || (e->has_encoding_decl && (!at_UTF_8(e->encoding)))){
445        fprintf(stderr,"Sorry, this xmlwf demo only works for UTF-8.\n");
446        exit(-1);
447    }
448  }
449  else {
450    fprintf(stderr,"Sorry, this xmlwf demo does not process EBCDIC.\n");
451        exit(-1);
452  }
453
454  if (e->content_start != 0) {
455        memmove(&srcbuf[0], &srcbuf[e->content_start], chars_read - e->content_start);
456        buf_pos = e->content_start;
457        if (chars_avail == BUFFER_SIZE) {
458                chars_read = chars_read - e->content_start +
459                             fread(&srcbuf[chars_read-e->content_start], 1, e->content_start, infile);
460                chars_avail = chars_read;
461                if (chars_avail > BUFFER_SIZE) chars_avail = BUFFER_SIZE;
462        }
463        else {
464          chars_read -=e->content_start;
465          chars_avail -=e->content_start;
466        }
467  }
468
469@stream_stmts
470/* push root into the vector stack*/
471        vector<char> *root = new vector<char>;
472        elem_vec_stack.push(root);
473//      cout<<"root_size "<<elem_vec_stack.size()<<endl;
474       
475        elem_vec_map[0] = root;
476
477/* Full Buffers */
478
479//      validation block counter
480       
481        int counter_max = 602000;
482
483    while (chars_avail == BUFFER_SIZE) {
484      PERF_SEC_START(parser_timer);
485      for (int blk = 0; blk < SEGMENT_BLOCKS; blk++) {
486          block_base = blk*BLOCK_SIZE;
487          s2p_do_block((BytePack *) &srcbuf[block_base], basis_bits);
488          @block_stmts
489          postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, chars_avail);
490          if (counter < counter_max){
491          //print_basis_bits(basis_bits);
492          // print source stream
493          //print_streams(&srcbuf[block_base],tag_Callouts.ElemContent_starts,"elem_content_starts");
494          //print_streams(&srcbuf[block_base],tag_Callouts.ElemContent_ends,"elem_content_ends");
495          validation_do_block(lex, tag_Callouts, hash_data, chars_avail);
496          counter ++;
497          //cout << "\t" << counter << endl;
498          }
499      }
500      matcher.StreamScan(chars_avail);
501      matcher.Advance_buffer();
502      tracker.Advance_buffer();
503      PERF_SEC_END(parser_timer, chars_avail);
504
505      int bytes_left = chars_read - chars_avail;
506      memmove(srcbuf, &srcbuf[BUFFER_SIZE], bytes_left);
507      chars_read = fread(&srcbuf[bytes_left],1, BUFFER_SIZE + OVERLAP_BUFSIZE - bytes_left, infile) + bytes_left;
508      chars_avail = chars_read;
509      if (chars_avail > BUFFER_SIZE) chars_avail = BUFFER_SIZE;
510      buf_pos += chars_avail;
511      buffer_base = buf_pos;
512    }
513/* Final Partial Buffer */
514    PERF_SEC_START(parser_timer);
515
516    block_pos = 0;
517    int remaining = chars_avail;
518/* Full Blocks */
519    while (remaining >= BLOCK_SIZE) {
520          block_base = block_pos;
521          s2p_do_block((BytePack *) &srcbuf[block_pos], basis_bits);
522          @block_stmts
523                postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, chars_avail);
524                if (counter < counter_max){
525                        //print_basis_bits( basis_bits);
526                //print_streams(&srcbuf[block_base],tag_Callouts.ElemContent_starts,"elem_content_starts");
527                //print_streams(&srcbuf[block_base],tag_Callouts.ElemContent_ends,"elem_content_ends");
528                  validation_do_block(lex, tag_Callouts, hash_data, chars_avail);
529                  counter ++;
530                }
531          block_pos += BLOCK_SIZE;
532          remaining -= BLOCK_SIZE;
533    }
534    block_base = block_pos;
535    if (remaining > 0 || @any_carry) {
536          EOF_mask = bitblock::srl(simd<1>::constant<1>(), convert(BLOCK_SIZE-remaining));
537          s2p_do_final_block((BytePack *) &srcbuf[block_pos], basis_bits, EOF_mask);
538          @final_block_stmts
539          postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, chars_avail);
540          //print_basis_bits(basis_bits);
541          //print_streams(&srcbuf[block_base],tag_Callouts.ElemContent_starts,"elem_content_starts");
542          //print_streams(&srcbuf[block_base],tag_Callouts.ElemContent_ends,"elem_content_ends");
543          validation_do_block(lex, tag_Callouts, hash_data, chars_avail);
544    }
545    buf_pos += chars_avail;
546    buffer_base = buf_pos;
547
548    matcher.StreamScan(chars_avail);
549    matcher.Advance_buffer();
550    tracker.Advance_buffer();
551
552
553    PERF_SEC_END(parser_timer, chars_avail);
554    if (matcher.depth != 0) {
555      fprintf(stderr, "tag matching error (depth %i) at position %i\n", matcher.depth, buffer_base);
556      exit(-1);
557    }
558}
559
560static inline int bitblock_has_bit(BitBlock block){
561        if (count_forward_zeroes(block) == sizeof(block)*8){
562                return 0;
563        }else{
564                return 1;
565        }
566}
567
568static inline int ScanBackwardPos(BitBlock * block, int pos, int previous_block_last_elem_start)
569{
570    BitBlock s = block[0];
571    BitBlock temp = simd_and( s, simd_not(simd<128>::sll(simd<1>::constant<1>(), convert(pos))) );
572
573    if (bitblock_has_bit(temp))
574    {
575        // sizeof (BitBlock)*8 - cbzl( s & ~(~0 << pos)) - 1;
576        return BLOCK_SIZE - count_reverse_zeroes (temp) - 1;
577    }
578    else
579    {
580        //handle boundary case
581        return previous_block_last_elem_start - 1;
582    }
583}
584
585static inline int compute_hash_value (int lgth, int start)
586{
587    unsigned int offset_bit = start + 128;
588    uint64_t stream = *((uint64_t*)(((uint32_t*)hashvalues)+(offset_bit>>5)));
589    return stream >> (offset_bit & 0x1F) & ~(~0 << lgth);
590}
591
592static inline char ElemEnd_grouping(int pos) {
593    int end = block_base + pos;
594    int start = ScanBackwardPos (&elem_starts, pos,previous_block_last_elem_start) + block_base;
595    int lgth = end - start;
596    int hashvalue = compute_hash_value(lgth, start - block_base);
597    char gid = 0;
598//    if (lgth >16){
599//      cout << "length = " << lgth << endl;
600//      cout << "hashvalue = " << hashvalue << endl;
601//    }
602
603//    if (lgth < 32)
604//    {
605//      gid = pbgs_symbol_table.Lookup_or_Insert_Name_32(source + start, hashvalue, lgth);
606//    }
607//    else
608
609        switch (lgth)
610    {
611    case 1:
612        gid = pbgs_symbol_table.Lookup_or_Insert_Name<1>(source + start, hashvalue);
613        break;
614    case 2:
615        gid = pbgs_symbol_table.Lookup_or_Insert_Name<2>(source + start, hashvalue);
616        break;
617    case 3:
618        gid = pbgs_symbol_table.Lookup_or_Insert_Name<3>(source + start, hashvalue);
619        break;
620    case 4:
621        gid = pbgs_symbol_table.Lookup_or_Insert_Name<4>(source + start, hashvalue);
622        break;
623    case 5:
624        gid = pbgs_symbol_table.Lookup_or_Insert_Name<5>(source + start, hashvalue);
625        break;
626    case 6:
627        gid = pbgs_symbol_table.Lookup_or_Insert_Name<6>(source + start, hashvalue);
628        break;
629    case 7:
630        gid = pbgs_symbol_table.Lookup_or_Insert_Name<7>(source + start, hashvalue);
631        break;
632    case 8:
633        gid = pbgs_symbol_table.Lookup_or_Insert_Name<8>(source + start, hashvalue);
634        break;
635    case 9:
636        gid = pbgs_symbol_table.Lookup_or_Insert_Name<9>(source + start, hashvalue);
637        break;
638    case 10:
639        gid = pbgs_symbol_table.Lookup_or_Insert_Name<10>(source + start, hashvalue);
640        break;
641    case 11:
642        gid = pbgs_symbol_table.Lookup_or_Insert_Name<11>(source + start, hashvalue);
643        break;
644    case 12:
645        gid = pbgs_symbol_table.Lookup_or_Insert_Name<12>(source + start, hashvalue);
646        break;
647    case 13:
648        gid = pbgs_symbol_table.Lookup_or_Insert_Name<13>(source + start, hashvalue);
649        break;
650    case 14:
651        gid = pbgs_symbol_table.Lookup_or_Insert_Name<14>(source + start, hashvalue);
652        break;
653    case 15:
654        gid = pbgs_symbol_table.Lookup_or_Insert_Name<15>(source + start, hashvalue);
655        break;
656    case 16:
657        gid = pbgs_symbol_table.Lookup_or_Insert_Name<16>(source + start, hashvalue);
658        break;
659    default:
660        gid = pbgs_symbol_table.Lookup_or_Insert_Name(source + start, hashvalue, lgth);
661        break;
662    }
663/*
664    {
665        gid = (char)pbgs_symbol_table.Lookup_or_Insert_Name(source + start, hashvalue, lgth);
666    }
667*/
668    gids.push_back(gid);
669#if DEBUG
670    char* symbol = new char[lgth+1];
671    strncpy ( symbol, source + start, lgth );
672    symbol[lgth] ='\0';
673    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);
674#endif
675        char* symbol = new char[lgth+1];
676    strncpy ( symbol, source + start, lgth );
677    symbol[lgth] ='\0';
678        fprintf(ofile,"%i\t%s\n",gid,symbol); 
679    return gid;
680}
681
682static inline int StreamScanLengthGrouping(Tag_Callouts & tag_Callouts, int blk_count) {
683    int blk;
684    int block_pos = 0;
685    ScanBlock *stream, *stream2;
686    stream = (ScanBlock *) &tag_Callouts.ElemName_ends;
687    stream2 = (ScanBlock *) &tag_Callouts.Tag_closing;
688    for (blk = 0; blk < blk_count; blk++) {
689//      if (counter >= 600){
690//              print_buffer(val_buf,"buffer");
691//              cout << val_buf_curser << endl;
692//              cout << "flag = " << content_start_flag << endl;
693//      }
694        //cout << "flag = " << content_start_flag << endl;
695        ScanBlock s = stream[blk];
696        ScanBlock s2 = stream2[blk];
697        if (content_start_flag == 1){           //content_start is in the incomming blocks
698                //cout << "curser=" << val_buf_curser;
699                //cout << "block_pos=" << block_pos;
700//              val_double_list(tag_Callouts,-2,block_pos+block_base,blk);
701                //print_buffer(val_buf,"buffer");
702        }else if (content_start_flag == -1){            //content_start already occured in the former block
703                //cout << "curser=" << val_buf_curser;
704                //cout << "block_pos=" << block_pos;
705//              val_double_list(tag_Callouts,-1,block_pos+block_base,blk);
706                //print_buffer(val_buf,"buffer");
707        }
708        while(s | s2) {
709//              cout << "end_pos:"<<s<<endl;
710//              cout << "end_tag_marks:"<<s2<<endl;
711            int end_pos = __builtin_ctzll(s) + block_pos;
712            int end_tag = __builtin_ctzll(s2) + block_pos;
713//          cout << "count_forward_zeroes(s):" << count_forward_zeroes(s)<<endl;
714//          cout << "count_forward_zeroes(s2):" << count_forward_zeroes(s2)<<endl;
715//              cout << (end_tag < end_pos && s2 != 0)<< "||" <<(s == 0 && s2 != 0)  << endl;
716            if ((end_tag < end_pos && s2 != 0) | (s == 0 && s2 != 0)){
717//          cout << "closing tag" << endl;
718//              cout << "endtag:" << end_tag << " " << end_pos<<endl;
719//              cout << "1"<< endl;
720//              cout << elem_vec_stack.size()<<endl;
721//              cout << "2" << endl;
722//              cout << elem_vec_stack.top()<<endl;
723                        if (!(*elem_vec_stack.top()).empty()){
724                                if ((*elem_vec_stack.top()).back() != 0 ){
725                                        (*elem_vec_stack.top()).push_back(0);   
726                                }
727                        }
728                        elem_vec_stack.pop();
729//              cout<<"poped\n";
730                        s2 = s2 & (s2 - 1);
731                        content_start_flag = 0;
732            }else{
733//              cout << " end_pos == " << end_pos<<endl;
734                char gid = ElemEnd_grouping(end_pos);
735                // if the gid == 12, the element content is of doublelist type, should do memcpy
736                if (gid == 13){
737                        //cout << "gid = 12" << endl; 
738                        //cout << "curser=" << val_buf_curser<<endl;
739                        //cout << "block_pos=" << block_pos<<endl;
740//                      val_double_list(tag_Callouts,end_pos,block_pos+block_base,blk);
741                        //print_buffer(val_buf,"buffer");
742                }
743//              cout << gid << endl;
744                s = s & (s-1);  // clear rightmost bit.
745                        if (gid != 0){
746//                              cout << "gid " << gid<< endl;
747                                if(elem_vec_map.find(gid) != elem_vec_map.end()){
748//                                      cout << "found vector" << gid << endl;
749                                        (*elem_vec_stack.top()).push_back(gid);
750//                                      cout << "top vector size: " << (*elem_vec_map[gid]).size() << endl;
751                                        elem_vec_stack.push(elem_vec_map[gid]);
752//                                      cout << "pushed in" << endl;
753//                                      cout << "found " << gid << endl;
754                                }else{
755//                                      cout << "size :" << elem_vec_stack.size()<<endl;
756//                                      cout << endl;
757//                                      cout << elem_vec_stack.top()<<endl;
758                               
759//                                      cout << "size before " <<(*elem_vec_stack.top()).size() << endl;
760                                        (*elem_vec_stack.top()).push_back(gid); 
761//                                      cout << "size after " <<(*elem_vec_stack.top()).size() << endl;
762                               
763                                        vector<char> *tmp = new vector<char>;
764                                        elem_vec_map[gid] = tmp;
765                                        elem_vec_stack.push(tmp);
766                                        //cout << "size after :" << elem_vec_stack.size()<<endl;
767                                }
768                        }
769
770            }
771        }
772        block_pos += 8 * sizeof(ScanBlock);
773    }
774    return 0;
775}
776
777static inline void print_vecs(){
778        int i = 1;
779        int lst[256] = {0};
780        cout << elem_vec_map.size() << " vectors" << endl; 
781        for (int i = 0;i < gids.size(); i++){
782                if (lst[gids[i]] == 0){
783                        cout << "gid: " << gids[i] << endl;
784                        lst[gids[i]] = 1;
785                        vector<char> *tmp = elem_vec_map[gids[i]];
786                        cout << "vector size:"<< (*tmp).size()<<endl;
787                        if ((*tmp).size()!=0){
788                                cout << "elements: ";
789                                for (int j = 0; j < (*tmp).size();j++){
790                                        cout << (int)(*tmp)[j] << " ";
791                                }
792                                cout << endl;
793                        }
794                        cout << endl;
795                }
796        }
797/*
798        for(int i = 0;i < gids.size();i++){
799                cout << " i : " << i << endl;
800                vector<short int> *tmp = elem_vec_map[gids[i]];
801                cout << "found" << endl;
802                cout << "map size:" << elem_vec_map.size()<< endl;
803                for (map<short int, vector<short int>* >::iterator pos = elem_vec_map.begin(); pos != elem_vec_map.end(); pos++){
804                        cout << "vector size" << (pos->second)->size() << endl;
805                }
806                cout << "size:" << tmp->size()<< endl;
807               
808                for (int j = 0;j < tmp->size();j++){
809                        cout <<tmp[j]<<" ";
810                }
811
812        }
813*/
814}
815
816static inline void print_elem_vec(vector<char>* vec, int size){
817        cout << "vector: ";
818        for (int i = 0; i<size ; i++){
819                cout << (int)(*vec)[i] <<" ";
820        }
821        cout << endl;
822}
823
824static inline void validation_do_block(Lex & lex, Tag_Callouts & tag_Callouts, Hash_data & hash_data, int chars_avail){
825        elem_starts = tag_Callouts.ElemName_starts_no_ns;
826//      print_register("starts",tag_Callouts.ElemName_starts_no_ns);
827//      print_register("ends",tag_Callouts.ElemName_ends);
828//      print_register("cont start",tag_Callouts.ElemContent_starts);
829        hashvalues[1] = hash_data.Hash_value;
830        StreamScanLengthGrouping(tag_Callouts,sizeof(BitBlock)/sizeof(ScanBlock));
831//      StreamScanLengthGrouping((ScanBlock *) &tag_Callouts.ElemName_ends,(ScanBlock *) &tag_Callouts.Tag_closing, sizeof(BitBlock)/sizeof(ScanBlock));
832       
833        previous_block_last_elem_start = - count_reverse_zeroes (elem_starts);
834//      cout << previous_block_last_elem_start << endl;
835}
836
837static inline void print_basis_bits(Basis_bits & basis_bits){
838        print_register("bit0:",basis_bits.bit_0);
839        print_register("bit1:",basis_bits.bit_1);
840        print_register("bit2:",basis_bits.bit_2);
841        print_register("bit3:",basis_bits.bit_3);
842        print_register("bit4:",basis_bits.bit_4);
843        print_register("bit5:",basis_bits.bit_5);
844        print_register("bit6:",basis_bits.bit_6);
845        print_register("bit7:",basis_bits.bit_7);                                       
846}
847
848static inline void validate_city_gml(){
849        vector<char>* vector_11 = elem_vec_map[2];
850        cout << "vector_11 size " << (*vector_11).size() << endl;
851        print_elem_vec(vector_11, (*vector_11).size());
852        int lgth = (*vector_11).size();
853        int remaining = 0;
854        Basis_bits basis_bits;
855        if (lgth != 0){
856                int i = 0;
857                int num_block = lgth /(BLOCK_SIZE *8 / VECTOR_WIDTH);
858                remaining = lgth %(BLOCK_SIZE *8 / VECTOR_WIDTH);
859                cout << "num_block " << num_block << " remaining " << remaining << endl;
860                for (i = 0;i < num_block;){
861//                      s2p_do_block((BytePack*)(vector_11[i]),temp_basis_bits);
862                        s2p_do_block(((BytePack*)(&(*vector_11)[i])), basis_bits);
863                        Citygml citygml;
864                        validation_Vec_2.do_block(citygml, basis_bits);
865                        print_elem_vec(vector_11,lgth);
866                        print_basis_bits(basis_bits);
867//                      (BytePack*)(iter->second)
868                        i += (BLOCK_SIZE *8 / VECTOR_WIDTH);
869                        cout << i ;
870                }
871                cout << i << endl;
872                if (remaining !=0){
873                        EOF_mask = bitblock::srl(simd<1>::constant<1>(), convert(BLOCK_SIZE-remaining));
874                        print_register("eof", EOF_mask);
875                        s2p_do_final_block(((BytePack*)(&(*vector_11)[i])), basis_bits,EOF_mask);
876                        validation_Vec_2.do_final_block(citygml,basis_bits,EOF_mask);
877                        print_elem_vec((vector_11)+i,lgth);
878                        print_basis_bits(basis_bits);
879                }
880        }
881//      print_bit_block("error",error);
882        cout << "validation vec_11 done" << endl;
883}
884
885
886
887
888static inline void print_streams(char * s1,BitBlock & block,char * name){
889        int lgth = 2;
890        int step = 128/lgth;
891        char tmp[step+1];
892        char test = s1[0];
893       
894        for (int i = 0;i<128;i=i+step){
895                printf("%20s = ","Source");
896                for (int j = 0;j<step;j++){
897                        if (s1[i+j]!='\n' && s1[i+j]!='\r'){
898                                cout << s1[i+j];
899                        }else{
900                                cout << " ";
901                        }
902                }
903                cout << endl;
904                printf("%20s = ",name);
905                for (int j = 0;j<step;j++){
906                        BitBlock temp = simd_and(bitblock::srl(block,convert(i+j)),convert(1));
907                        if (bitblock::any(temp)){
908                                cout << 1;
909                        }else{
910                                cout << "_";
911                        }
912                }
913                cout << endl;
914                cout << endl;
915        }
916}
917
918static inline void print_buffer(char * block, char * name){
919        int step = 128/2;
920        char *ptr = (char*)block;
921        for (int i = 0;i<128;i=i+step){
922                printf("%20s = ",name);
923                for (int j = 0;j<step;j++){
924                        if (ptr[i+j]!='\n' && ptr[i+j]!='\r'){
925                                cout << ptr[i+j];
926                        }else{
927                                cout << " ";
928                        }
929                }
930                cout << endl;
931               
932        }
933        cout << endl;
934}
935
936static inline void val_double_list(Tag_Callouts & tag_Callouts,int elem_end,int block_pos,int blk){
937        ScanBlock *content_start = (ScanBlock *) &tag_Callouts.ElemContent_starts;
938        ScanBlock start_blk =content_start[blk];
939        ScanBlock *content_end = (ScanBlock *) &tag_Callouts.ElemContent_ends;
940        ScanBlock end_blk = content_end[blk];
941        int sb_size = sizeof(ScanBlock)*8;
942        //print_streams(&srcbuf[block_base],tag_Callouts.ElemContent_starts,"elem_content_starts");
943        //print_streams(&srcbuf[block_base],tag_Callouts.ElemContent_ends,"elem_content_ends");
944        //cout << "block num = " << blk << endl;
945        //cout << "elem_end="<<elem_end<<endl<<endl;
946        //cout << "flag = " << content_start_flag << endl;
947        if (elem_end == -1){//content_start_pos has occured
948                if (end_blk == 0){ 
949                        //print_buffer(val_buf,"buffer");
950                        if (sb_size < val_buf_avail){
951                                memcpy(&val_buf[val_buf_curser],source+block_pos,sb_size);
952                                val_buf_avail -= sb_size;
953                                val_buf_curser += sb_size;
954                        }else{
955                                //cout << "buf_avail = " << val_buf_avail << endl;
956                                memcpy(&val_buf[val_buf_curser],source+block_pos,val_buf_avail);
957                                int char_left = sb_size - val_buf_avail;
958                                val_dl_block();
959                                memcpy(val_buf,source+block_pos+val_buf_avail, char_left);
960                                val_buf_avail = sizeof(BitBlock)*8 - char_left;
961                                val_buf_curser = char_left;
962                        }
963                }else{
964                        //cout << "HHHHHHHHHH" << endl;
965                        int end_pos = __builtin_ctzll(end_blk);
966                        //cout << "end_pos = "<<end_pos << endl;
967                        //cout <<"buf_avail = "<<val_buf_avail<<endl;
968                        if (end_pos > val_buf_avail){
969                                memcpy(&val_buf[val_buf_curser],source+block_pos,val_buf_avail);
970                                int char_left = end_pos - val_buf_avail;
971                                val_dl_block();
972                                if (char_left != 0){
973                                        memcpy(val_buf,source+block_pos+val_buf_avail, char_left);
974                                }
975                                val_buf_avail = sizeof(BitBlock)*8 - char_left;
976                                val_buf_curser = char_left;
977                        }else{
978                                memcpy(&val_buf[val_buf_curser],source+block_pos,end_pos);
979                                //cout <<"source "<< source[block_pos]<<source[block_pos+1]<<source[block_pos+2]<<endl;
980                                val_buf_avail = val_buf_avail - end_pos;
981                                val_buf_curser = val_buf_curser + end_pos;
982                        }
983                        content_start_flag = 0;
984                        //print_buffer(val_buf,"buffer");
985                        //cout << "s = " << sizeof(val_buf) << endl;
986                        //cout << "curser = " << val_buf_curser << endl;
987                }
988        }else if(elem_end == -2){
989                if (start_blk != 0){
990                        int start_pos = __builtin_ctzll(start_blk);
991                        int end_pos = 0;
992                        if (end_blk == 0){
993                                end_pos = sb_size;
994                        }else{
995                                end_pos = __builtin_ctzll(end_blk);
996                        //cout << "s_p:e_p" << start_pos << " " << end_pos << endl;
997                                while(end_pos < start_pos){
998                                        end_blk = end_blk & (end_blk - 1);
999                                        end_pos = __builtin_ctzll(end_blk);
1000                                }
1001                        }
1002                        //cout << "s_p:e_p" << start_pos << " " << end_pos << endl;
1003                        int char_left = end_pos - start_pos;
1004                        //cout << "buf_avail " << val_buf_avail<< endl;
1005                        //cout << "char left " << char_left << endl;
1006                        if (val_buf_avail > char_left){
1007                                memcpy(&val_buf[val_buf_curser],source+block_pos+start_pos,char_left);
1008                                val_buf_avail = val_buf_avail - char_left;
1009                                val_buf_curser = val_buf_curser + char_left;
1010                        }else{
1011                                memcpy(&val_buf[val_buf_curser],source+block_pos+start_pos,val_buf_avail);
1012                                val_dl_block();
1013                                char_left -= val_buf_avail;
1014                                val_buf_avail = sb_size - char_left + val_buf_avail;
1015                                if (char_left != 0){
1016                                        memcpy(val_buf,source+block_pos+start_pos+ val_buf_avail,char_left);
1017                                }
1018                                val_buf_curser = char_left;
1019                        }
1020                        if (end_pos != sb_size){
1021                                content_start_flag = 0;
1022                        }else{
1023                                content_start_flag = -1;
1024                        }                       
1025                }else{
1026                        content_start_flag = 1;
1027                        return;
1028                }
1029                //print_buffer(val_buf,"buffer");
1030        }else{
1031                //cout << "buf_avail " << val_buf_avail<< endl;
1032                if (start_blk == 0){
1033                        content_start_flag = 1;
1034                        return;
1035                }else{
1036                        //cout << "#curser=" << val_buf_curser<<endl;
1037                        //cout << "#block_pos=" << block_pos<<endl;
1038                        int start_pos = __builtin_ctzll(start_blk);
1039                        while(start_pos <= elem_end){                           //?
1040                                start_blk = start_blk & (start_blk -1);
1041                                start_pos = __builtin_ctzll(start_blk);
1042                        }
1043                        if (start_pos == sb_size){
1044                                content_start_flag = -1;
1045                                return;
1046                        }
1047                        int end_pos = 0;
1048                        if (end_blk == 0){
1049                                end_pos = sb_size;
1050                        }else{
1051                                end_pos = __builtin_ctzll(end_blk);
1052                                while(end_pos < start_pos){
1053                                        end_blk = end_blk & (end_blk - 1);
1054                                        end_pos = __builtin_ctzll(end_blk);
1055                                }
1056                        }
1057                        int char_left = end_pos - start_pos;
1058                        if (val_buf_avail > char_left){
1059                                memcpy(&val_buf[val_buf_curser],source+block_pos+start_pos,char_left);
1060                                val_buf_avail = val_buf_avail - char_left;
1061                                val_buf_curser = val_buf_curser + char_left;
1062                        }else{
1063                                memcpy(&val_buf[val_buf_curser],source+block_pos+start_pos,val_buf_avail);
1064                                val_dl_block();
1065                                char_left -= val_buf_avail;
1066                                val_buf_avail = sb_size - char_left + val_buf_avail;
1067                                val_buf_curser = 0;
1068                                if(char_left != 0){
1069                                        memcpy(val_buf,source+block_pos+start_pos+ val_buf_avail,char_left);
1070                                }
1071                                val_buf_curser = char_left;
1072                        }
1073                        if (end_pos == sb_size){
1074                                content_start_flag = 1;
1075                        }
1076                        //cout << "start" << start_pos << endl;
1077                        //print_buffer(val_buf,"buffer");
1078                }
1079        }
1080}
1081
1082static inline void val_dl_block(){
1083        print_buffer(val_buf,"buffer");
1084        //cout << "vvvvvvvvvvvvvvv"<< endl;
1085}
1086
1087
Note: See TracBrowser for help on using the repository browser.