source: proto/SymbolTable/wcd_stl_template.cpp @ 4204

Last change on this file since 4204 was 1792, checked in by vla24, 8 years ago

Fixed macro names. I got L1 and L2 mixed up

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