source: proto/SymbolTable/symtab_hash_template.cpp @ 4740

Last change on this file since 4740 was 1792, checked in by vla24, 7 years ago

Fixed macro names. I got L1 and L2 mixed up

File size: 9.4 KB
Line 
1#include "../common_definitions.h"
2#include <hash_symbol_table.h>
3
4#include "../symtab_common_functions.h"
5#include "../xmlwf_common_functions.h"
6
7#ifdef BUFFER_PROFILING
8        BOM_Table * parser_timer;
9
10#elif CODE_CLOCKER
11        #define NUM_EVENTS 1
12//      int Events[NUM_EVENTS] = {PAPI_TOT_CYC};
13
14#ifdef L2_PERF
15        int Events[NUM_EVENTS] = {PAPI_L2_DCM};
16#elif L1_PERF
17        int Events[NUM_EVENTS] = {PAPI_L1_DCM};
18#else
19        int Events[NUM_EVENTS] = {PAPI_BR_MSP};
20#endif
21        //int Events[NUM_EVENTS] = {PAPI_TOT_CYC, PAPI_BR_MSP};
22        int cal_size = 20;
23        CC * parser_timer = new CC(Events,NUM_EVENTS,cal_size);
24#else
25        void * parser_timer;
26#endif
27
28int block_base=0;
29int buffer_base=0;
30
31TagMatcher matcher;
32
33queue <size_t> elem_starts_buf;
34queue <size_t> elem_ends_buf;
35vector <int> gids;
36HashSymbolTable symbol_table;
37
38static inline void postprocess_do_block(Lex & lex, CtCDPI_Callouts & ctCDPI_Callouts, Ref_Callouts & ref_Callouts, Check_streams & check_streams, Tag_Callouts & tag_Callouts, int chars_avail);
39void do_process(FILE *infile, FILE *outfile);
40
41static inline void do_symbol_table_lookup();
42
43int main(int argc, char * argv[]) {
44    char * infilename, * outfilename;
45    FILE *infile, *outfile;
46
47    getFilenames(argc, argv, infilename, outfilename);
48    openInputOutputFiles(infilename, outfilename,
49                         infile, outfile);
50
51//      PERF_SEC_BIND(1);
52
53    PERF_SEC_INIT(parser_timer);
54
55    // store symbols form text to Symbol Table
56    do_process(infile, outfile);
57
58    PERF_SEC_DUMP(parser_timer);
59
60    PERF_SEC_DESTROY(parser_timer);
61
62#if PRINT_SYMBOL_DISTRIBUTION
63    symbol_table.Print_Symbol_Table_Distribution();
64#endif
65
66    fclose(infile);
67    fclose(outfile);
68    return(0);
69}
70
71static inline int ElemStrt_check(int pos) {
72        elem_starts_buf.push(buffer_base + pos);
73        return 0;
74}
75
76static inline int ElemEnd_check(int pos) {
77        elem_ends_buf.push(buffer_base + pos);
78        return 0;
79}
80
81static inline void do_symbol_table_lookup()
82{
83    while( !elem_starts_buf.empty() && !elem_ends_buf.empty() )
84    {
85        int start = elem_starts_buf.front();
86        int end = elem_ends_buf.front();
87        elem_starts_buf.pop();
88        elem_ends_buf.pop();
89        int length = end - start;
90
91        //lookup or insert to symbol table
92#if DEBUG
93        char* symbol = new char[length+1];
94        strncpy ( symbol, source + start - buffer_base, length );
95        symbol[length] ='\0';
96        printf ("start: %i[%i] | end: %i[%i] | length: %i | symbol: %s\n", start, start-buffer_base, end, end-buffer_base, length, symbol );
97
98        delete symbol; symbol = 0;
99#endif
100
101        int gid = symbol_table.Lookup_or_Insert_Name(source + start - buffer_base, length);
102        gids.push_back(gid);
103    }
104}
105
106static inline void postprocess_do_block(Lex & lex, CtCDPI_Callouts & ctCDPI_Callouts, Ref_Callouts & ref_Callouts, Check_streams & check_streams, Tag_Callouts & tag_Callouts, int chars_avail){
107
108    tracker.StoreNewlines(lex.LF);
109
110    if ( bitblock_has_bit(tag_Callouts.ElemName_starts))
111    {
112        BitBlockForwardIterator iter_length_grouping_starts(&tag_Callouts.ElemName_starts);
113        validate_block(iter_length_grouping_starts, block_base, ElemStrt_check);
114    }
115
116    if ( bitblock_has_bit(tag_Callouts.ElemName_ends) )
117    {
118        BitBlockForwardIterator iter_length_grouping_ends(&tag_Callouts.ElemName_ends);
119        validate_block(iter_length_grouping_ends, block_base, ElemEnd_check);
120    }
121
122    do_symbol_table_lookup();
123
124
125    if (bitblock_has_bit(simd_or(check_streams.non_ascii_name_starts, check_streams.non_ascii_names))) {
126        BitBlockForwardIterator iter_NameStrt_check(&check_streams.non_ascii_name_starts);
127        validate_block(iter_NameStrt_check, block_base, NameStrt_check);
128        BitBlockForwardIterator iter_Name_check(&check_streams.non_ascii_names);
129        validate_block(iter_Name_check, block_base, Name_check);
130    }
131    if (bitblock_has_bit(ctCDPI_Callouts.PI_name_starts)){
132        BitBlockForwardIterator iter_PI_name_starts(&(ctCDPI_Callouts.PI_name_starts));
133        validate_block(iter_PI_name_starts, block_base, buffer_base, PIName_check);
134    }
135    if (bitblock_has_bit(ctCDPI_Callouts.CD_starts)){
136        BitBlockForwardIterator iter_CD_check(&ctCDPI_Callouts.CD_starts);
137        validate_block(iter_CD_check, block_base, CD_check);
138    }
139    if(bitblock_has_bit(ref_Callouts.GenRef_starts)){
140        BitBlockForwardIterator iter_GenRef_check(&ref_Callouts.GenRef_starts);
141        validate_block(iter_GenRef_check, block_base, GenRef_check);
142    }
143    if(bitblock_has_bit(ref_Callouts.DecRef_starts)){
144        BitBlockForwardIterator iter_DecRef_check(&ref_Callouts.DecRef_starts);
145        validate_block(iter_DecRef_check, block_base, DecRef_check);
146    }
147    if(bitblock_has_bit(ref_Callouts.HexRef_starts)){
148        BitBlockForwardIterator iter_HexRef_check(&ref_Callouts.HexRef_starts);
149        validate_block(iter_HexRef_check, block_base, HexRef_check);
150    }
151    if(bitblock_has_bit(check_streams.att_refs)){
152        BitBlockForwardIterator iter_AttRef_check(&check_streams.att_refs);
153        validate_block(iter_AttRef_check, block_base, AttRef_check);
154    }
155
156    if(error_tracker.Has_Noted_Error()){
157        int error_line, error_column;
158        tracker.get_Line_and_Column(error_tracker.Noted_Pos_In_Block(), error_line, error_column);
159        ReportError(error_tracker.Noted_Error_Msg(), error_line, error_column);
160        exit(-1);
161    }
162
163    matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
164    tracker.AdvanceBlock();
165}
166
167static inline void print_GIDS()
168{
169    int span_count = gids.size();
170    for(int i=0;i<span_count;i++) {
171             cout << gids[i] << " ";
172    }
173    cout << endl;
174}
175
176void do_process(FILE *infile, FILE *outfile) {
177
178@decl
179
180  int buf_pos = 0;
181  int block_pos = 0;
182  int errpos = 0;
183  int chars_avail = 0;
184  int check_pos = 0;
185  int chars_read = 0;
186  BytePack buf[(BUFFER_SIZE+BLOCK_SIZE+OVERLAP_BUFSIZE*2)/sizeof(SIMD_type)];
187
188  char * srcbuf = ((char *) buf) + OVERLAP_BUFSIZE;
189  buffer_base = buf_pos;
190  source = srcbuf;
191  chars_read = fread((void *)srcbuf, 1, BUFFER_SIZE + OVERLAP_BUFSIZE, infile);
192  chars_avail = chars_read;
193  if (chars_avail > BUFFER_SIZE) chars_avail = BUFFER_SIZE;
194
195  matcher.setSrc(srcbuf);
196
197  if(chars_read<4){
198    fprintf(stderr,"File is too short. Not well formed.\n");
199    exit(-1);
200  }
201
202  Entity_Info * e = new Entity_Info;
203  e->AnalyzeSignature((unsigned char *)srcbuf);
204
205  if (e->code_unit_base == ASCII) {
206
207    XML_Decl_Parser<ASCII> decl_parser((unsigned char *)srcbuf);
208
209    decl_parser.ReadXMLInfo(*e);
210
211    if (e->code_unit_size != SingleByte || (e->has_encoding_decl && (!at_UTF_8(e->encoding)))){
212        fprintf(stderr,"Sorry, this xmlwf demo only works for UTF-8.\n");
213        exit(-1);
214    }
215  }
216  else {
217    fprintf(stderr,"Sorry, this xmlwf demo does not process EBCDIC.\n");
218        exit(-1);
219  }
220
221  if (e->content_start != 0) {
222        memmove(&srcbuf[0], &srcbuf[e->content_start], chars_read - e->content_start);
223        buf_pos = e->content_start;
224        buffer_base = buf_pos;
225        if (chars_avail == BUFFER_SIZE) {
226                chars_read = chars_read - e->content_start +
227                             fread(&srcbuf[chars_read-e->content_start], 1, e->content_start, infile);
228                chars_avail = chars_read;
229                if (chars_avail > BUFFER_SIZE) chars_avail = BUFFER_SIZE;
230        }
231        else {
232          chars_read -=e->content_start;
233          chars_avail -=e->content_start;
234        }
235  }
236
237@stream_stmts
238
239/* Full Buffers */
240    while (chars_avail == BUFFER_SIZE) {
241      PERF_SEC_START(parser_timer);
242      for (int blk = 0; blk < SEGMENT_BLOCKS; blk++) {
243          block_base = blk*BLOCK_SIZE;
244          s2p_do_block((BytePack *) &srcbuf[block_base], basis_bits);
245          @block_stmts
246          postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, tag_Callouts, chars_avail);
247      }
248
249      matcher.StreamScan(chars_avail);
250      matcher.Advance_buffer();
251      tracker.Advance_buffer();
252
253#ifndef CACHE_PERF
254    PERF_SEC_END(parser_timer, chars_avail);
255#else
256    PERF_SEC_END(parser_timer, 1);
257#endif
258           
259      int bytes_left = chars_read - chars_avail;
260      memmove(buf, &srcbuf[BUFFER_SIZE - OVERLAP_BUFSIZE], bytes_left + OVERLAP_BUFSIZE);
261      chars_read = fread(&srcbuf[bytes_left],1, BUFFER_SIZE + OVERLAP_BUFSIZE - bytes_left, infile) + bytes_left;
262      chars_avail = chars_read;
263      if (chars_avail > BUFFER_SIZE) chars_avail = BUFFER_SIZE;
264      buf_pos += chars_avail;
265      if (!elem_starts_buf.size() == elem_ends_buf.size())
266      {
267          int start = elem_starts_buf.front();
268          start = (start - buffer_base) - BUFFER_SIZE + buf_pos;
269          elem_starts_buf.pop();
270          elem_starts_buf.push(start);
271      }
272      buffer_base = buf_pos;
273    }
274/* Final Partial Buffer */
275    PERF_SEC_START(parser_timer);
276
277    block_pos = 0;
278    int remaining = chars_avail;
279/* Full Blocks */
280    while (remaining >= BLOCK_SIZE) {
281          block_base = block_pos;
282          s2p_do_block((BytePack *) &srcbuf[block_pos], basis_bits);
283          @block_stmts
284          postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, tag_Callouts, chars_avail);
285          block_pos += BLOCK_SIZE;
286          remaining -= BLOCK_SIZE;
287    }
288    block_base = block_pos;
289    if (remaining > 0 || @any_carry) {
290          EOF_mask = bitblock::srl(simd<1>::constant<1>(), convert(BLOCK_SIZE-remaining));
291          s2p_do_final_block((BytePack *) &srcbuf[block_pos], basis_bits, EOF_mask);
292          @final_block_stmts
293          postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, tag_Callouts, chars_avail);
294    }
295    buf_pos += chars_avail;
296    buffer_base = buf_pos;
297
298    matcher.StreamScan(chars_avail);
299    matcher.Advance_buffer();
300    tracker.Advance_buffer();
301#ifndef CACHE_PERF
302    PERF_SEC_END(parser_timer, chars_avail);
303#else
304    PERF_SEC_END(parser_timer, 1);
305#endif
306    if (matcher.depth != 0) {
307      fprintf(stderr, "tag matching error (depth %i) at position %i\n", matcher.depth, buffer_base);
308      exit(-1);
309    }
310}
Note: See TracBrowser for help on using the repository browser.