source: proto/SymbolTable/symtab_hash_template.cpp @ 1766

Last change on this file since 1766 was 1721, checked in by vla24, 8 years ago

SymbolTable?: completed dictionary implementation and refactored templates

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