source: proto/SymbolTable/wcd_hash_template.cpp @ 5735

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

Fixed macro names. I got L1 and L2 mixed up

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