source: proto/SymbolTable/wcd_ls_template.cpp @ 1787

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

SymbolTable?: completed dictionary implementation and refactored templates

File size: 8.4 KB
Line 
1// WARNING: This implementation does not run, it will give the wrong result and crash.
2#error "This implementation does not run, it will give the wrong result and/or crash."
3
4#define USE_LS_SYMBOL_TABLE
5
6#include "../common_definitions.h"
7#include <ls_symbol_table.h>
8
9#include "../wcd_common_functions.h"
10#include "../symtab_common_functions.h"
11#include "parser_common_functions_generated.h"
12
13#ifdef BUFFER_PROFILING
14        BOM_Table * parser_timer;
15
16#elif CODE_CLOCKER
17        #define NUM_EVENTS 1
18        int Events[NUM_EVENTS] = {PAPI_TOT_CYC};
19        //int Events[NUM_EVENTS] = {PAPI_L2_DCM};
20        //int Events[NUM_EVENTS] = {PAPI_TOT_CYC, PAPI_BR_MSP};
21        int cal_size = 20;
22        CC * parser_timer = new CC(Events,NUM_EVENTS,cal_size);
23#else
24        void * parser_timer;
25#endif
26
27int block_base=0;
28int buffer_base=0;
29char * source;
30BitBlock EOF_mask = simd<1>::constant<1>();
31
32queue <size_t> elem_starts_buf;
33queue <size_t> elem_ends_buf;
34vector <int> gids;
35LSSymbolTable ls_symbol_table;
36LineColTracker tracker;
37
38static inline void postprocess_do_block(Dictionary& dictionary);
39
40template<bool allow_performance_check, bool finalize_gids> void do_process(FILE *infile, FILE *outfile);
41
42static inline void validate_block(BitBlockForwardIterator & start, int block_base, int is_valid(int));
43static inline void validate_block(BitBlockForwardIterator & start, int block_base, int is_valid(int,int));
44static inline void do_symbol_table_lookup();
45
46int main(int argc, char * argv[]) {
47    char * dictionaryfilename, * infilename, * outfilename;
48    FILE * dictionaryfile, *infile, *outfile;
49
50    getFilenames(argc, argv, dictionaryfilename, infilename, outfilename);
51    openInputOutputFiles(dictionaryfilename, infilename, outfilename,
52                         dictionaryfile, infile, outfile);
53    int greatest_GID_in_dictionary;
54    populateDictionary(dictionaryfile, outfile, gids, greatest_GID_in_dictionary);
55
56    ls_symbol_table.clear();
57    rewind (dictionaryfile);
58    do_process<true, false>(dictionaryfile, outfile);
59
60//      PERF_SEC_BIND(1);
61
62    PERF_SEC_INIT(parser_timer);
63
64    // store symbols form text to Symbol Table
65    do_process<true, true>(infile, outfile);
66
67    PERF_SEC_DUMP(parser_timer);
68
69    PERF_SEC_DESTROY(parser_timer);
70
71    //print_GIDS(ls_symbol_table);
72
73    // gather dictionary statistics
74    int totalKnownWordsInDictionary, totalUnknownWordsInDictionary;
75    wordCountInDictionary(greatest_GID_in_dictionary, gids, totalUnknownWordsInDictionary, totalKnownWordsInDictionary);
76    printWordCountInDictionary(totalUnknownWordsInDictionary, totalKnownWordsInDictionary);
77
78    fclose(dictionaryfile);
79    fclose(infile);
80    fclose(outfile);
81
82#if PRINT_SYMBOL_DISTRIBUTION
83        print_GIDS(ls_symbol_table);
84#endif
85
86        return(0);
87}
88
89static inline int ElemStrt_check(int pos) {
90        elem_starts_buf.push(buffer_base + pos);
91        return 0;
92}
93
94static inline int ElemEnd_check(int pos) {
95        elem_ends_buf.push(buffer_base + pos);
96        return 0;
97}
98
99static inline void do_symbol_table_lookup()
100{
101    while( !elem_starts_buf.empty() && !elem_ends_buf.empty() )
102    {
103        int start = elem_starts_buf.front();
104        int end = elem_ends_buf.front();
105        elem_starts_buf.pop();
106        elem_ends_buf.pop();
107        int length = end - start;
108
109        //lookup or insert to symbol table
110#if DEBUG
111        char* symbol = new char[length+1];
112        strncpy ( symbol, source + start - buffer_base, length );
113        symbol[length] ='\0';
114        printf ("start: %i[%i] | end: %i[%i] | length: %i | symbol: %s\n", start, start-buffer_base, end, end-buffer_base, length, symbol );
115
116        delete symbol; symbol = 0;
117#endif
118
119        ls_symbol_table.put((unsigned char*)source + start - buffer_base, length);
120    }
121}
122
123static inline void validate_block(BitBlockForwardIterator & start, int block_base, int is_valid(int)) {
124
125        BitBlockForwardIterator end;
126        int pos, block_pos;
127
128        while(start != end) {
129
130                block_pos = block_base + *start;
131                int rv = is_valid(block_pos);
132
133                if (rv) {
134                        int error_line, error_column;
135                        tracker.get_Line_and_Column(block_pos, error_line, error_column);
136                        ReportError(XMLTestSuiteError::get_msg(rv), error_line, error_column);
137                        exit(-1);
138                }
139                start++;
140        }
141}
142
143static inline void validate_block(BitBlockForwardIterator & start, int block_base, int buffer_base, int is_valid(int,int)) {
144
145        BitBlockForwardIterator end;
146        int pos, block_pos, file_pos;
147
148        while(start != end) {
149
150                block_pos = block_base + *start;
151                file_pos = block_pos+buffer_base;
152
153
154                int rv = is_valid(block_pos, file_pos);
155
156                if (rv) {
157                        int error_line, error_column;
158                        tracker.get_Line_and_Column(block_pos, error_line, error_column);
159                        ReportError(XMLTestSuiteError::get_msg(rv), error_line, error_column);
160                        exit(-1);
161                }
162                start++;
163        }
164}
165
166static inline void postprocess_do_block(Dictionary& dictionary){
167
168    if ( bitblock_has_bit(dictionary.Word_starts))
169    {
170        BitBlockForwardIterator iter_length_grouping_starts(&dictionary.Word_starts);
171        validate_block(iter_length_grouping_starts, block_base, ElemStrt_check);
172    }
173
174    if ( bitblock_has_bit(dictionary.Word_ends) )
175    {
176        BitBlockForwardIterator iter_length_grouping_ends(&dictionary.Word_ends);
177        validate_block(iter_length_grouping_ends, block_base, ElemEnd_check);
178    }
179
180    do_symbol_table_lookup();
181}
182
183template<bool allow_performance_check, bool finalize_gids> void do_process(FILE *infile, FILE *outfile) {
184
185@decl
186
187  int buf_pos = 0;
188  int block_pos = 0;
189  int errpos = 0;
190  int chars_avail = 0;
191  int check_pos = 0;
192  int chars_read = 0;
193  BytePack buf[(BUFFER_SIZE+BLOCK_SIZE+OVERLAP_BUFSIZE*2)/sizeof(SIMD_type)];
194
195  char * srcbuf = ((char *) buf) + OVERLAP_BUFSIZE;
196  buffer_base = buf_pos;
197  source = srcbuf;
198
199  chars_read = fread((void *)srcbuf, 1, BUFFER_SIZE + OVERLAP_BUFSIZE, infile);
200  chars_avail = chars_read;
201  if (chars_avail > BUFFER_SIZE) chars_avail = BUFFER_SIZE;
202
203  Entity_Info * e = new Entity_Info;
204  e->AnalyzeSignature((unsigned char *)srcbuf);
205
206  if (e->content_start != 0) {
207        memmove(&srcbuf[0], &srcbuf[e->content_start], chars_read - e->content_start);
208        buf_pos = e->content_start;
209        buffer_base = buf_pos;
210        if (chars_avail == BUFFER_SIZE) {
211                chars_read = chars_read - e->content_start +
212                             fread(&srcbuf[chars_read-e->content_start], 1, e->content_start, infile);
213                chars_avail = chars_read;
214                if (chars_avail > BUFFER_SIZE) chars_avail = BUFFER_SIZE;
215        }
216        else {
217          chars_read -=e->content_start;
218          chars_avail -=e->content_start;
219        }
220  }
221
222@stream_stmts
223
224/* Full Buffers */
225
226    while (chars_avail == BUFFER_SIZE) {
227      if (allow_performance_check)
228      {
229        PERF_SEC_START(parser_timer);
230      }
231      for (int blk = 0; blk < SEGMENT_BLOCKS; blk++) {
232          block_base = blk*BLOCK_SIZE;
233          s2p_do_block((BytePack *) &srcbuf[block_base], basis_bits);
234          @block_stmts
235          postprocess_do_block(dictionary);
236      }
237      if (allow_performance_check)
238      {
239        PERF_SEC_END(parser_timer, chars_avail);
240      }
241
242      int bytes_left = chars_read - chars_avail;
243      memmove(buf, &srcbuf[BUFFER_SIZE - OVERLAP_BUFSIZE], bytes_left + OVERLAP_BUFSIZE);
244      chars_read = fread(&srcbuf[bytes_left],1, BUFFER_SIZE + OVERLAP_BUFSIZE - bytes_left, infile) + bytes_left;
245      chars_avail = chars_read;
246      if (chars_avail > BUFFER_SIZE) chars_avail = BUFFER_SIZE;
247      buf_pos += chars_avail;
248      buffer_base = buf_pos;
249    }
250/* Final Partial Buffer */
251    if (allow_performance_check)
252    {
253      PERF_SEC_START(parser_timer);
254    }
255
256    block_pos = 0;
257    int remaining = chars_avail;
258/* Full Blocks */
259    while (remaining >= BLOCK_SIZE) {
260          block_base = block_pos;
261          s2p_do_block((BytePack *) &srcbuf[block_pos], basis_bits);
262          @block_stmts
263          postprocess_do_block(dictionary);
264          block_pos += BLOCK_SIZE;
265          remaining -= BLOCK_SIZE;
266    }
267    block_base = block_pos;
268    if (remaining > 0 || @any_carry) {
269          EOF_mask = bitblock::srl(simd<1>::constant<1>(), convert(BLOCK_SIZE-remaining));
270          s2p_do_final_block((BytePack *) &srcbuf[block_pos], basis_bits, EOF_mask);
271          @final_block_stmts
272          postprocess_do_block(dictionary);
273    }
274    buf_pos += chars_avail;
275    buffer_base = buf_pos;
276
277    if (finalize_gids)
278    {
279        ls_symbol_table.bind();
280        ls_symbol_table.finalize();
281    }
282
283    if (allow_performance_check)
284    {
285      PERF_SEC_END(parser_timer, chars_avail);
286    }
287
288    // get gids
289    if (finalize_gids)
290    {
291        gids = ls_symbol_table.get_flattened_gids();
292    }
293}
Note: See TracBrowser for help on using the repository browser.