source: proto/parabix2/pablo_template_symbol_table.cpp @ 2186

Last change on this file since 2186 was 2186, checked in by ksherdy, 7 years ago

Added initial XMLWF symbol table port. Known bug wrt boundary/memory/buffer. Exact cause TBD.

File size: 13.2 KB
Line 
1#include <stdio.h>
2#include <stdlib.h>
3#include <errno.h>
4#include <sys/types.h>
5#include <sys/stat.h>
6
7#define LocalCarryDeclare(name, count)\
8CarryArray<count> name;\
9
10#include "../lib/bitblock.hpp"
11#include "../lib/carryQ.hpp"
12#include "../lib/bitstream_iterator.hpp"
13#include "../lib/bitblock_iterator.hpp"
14#include "../lib/s2p.hpp"
15#include "../lib/perflib/perfsec.h"
16
17#include <xmldecl.h>
18#include <namechars.h>
19#include <TagMatcher.hpp>
20#include <LineColTracker.hpp>
21#include <ErrorUtil.h>
22#include <ErrorTracker.h>
23#include <XMLTestSuiteError.h>
24
25// #define SYMBOL_TABLE
26// #define DUMP_SYMBOLS
27
28#ifdef BUFFER_PROFILING
29        BOM_Table * parser_timer;
30#elif CODE_CLOCKER
31        //#define NUM_EVENTS 1
32        //int Events[NUM_EVENTS] = {PAPI_TOT_CYC};
33        //int Events[NUM_EVENTS] = {PAPI_L2_DCM};
34        #define NUM_EVENTS 2
35        int Events[NUM_EVENTS] = {PAPI_TOT_CYC, PAPI_BR_MSP};
36        int cal_size = 20;
37        CC * parser_timer = new CC(Events,NUM_EVENTS,cal_size);
38#else
39        void * parser_timer;
40#endif
41
42ErrorTracker error_tracker;
43BitBlock EOF_mask = simd<1>::constant<1>();
44
45//////////////////////////////////////////////////////////////////////////////////////////
46// Buffer Management
47//////////////////////////////////////////////////////////////////////////////////////////
48#define PADDING_BLOCKS 0
49#define PADDING_SIZE (BLOCK_SIZE * PADDING_BLOCKS)
50#define COPYBACK_BLOCKS 3
51#define COPYBACK_SIZE (BLOCK_SIZE * COPYBACK_BLOCKS)
52#define LOOKAHEAD_BLOCKS 1
53#define LOOKAHEAD_SIZE (BLOCK_SIZE * LOOKAHEAD_BLOCKS)
54#define SEGMENT_BLOCKS  12
55#define SEGMENT_SIZE (BLOCK_SIZE * SEGMENT_BLOCKS)
56#define BUFFER_SIZE (COPYBACK_SIZE + SEGMENT_SIZE + LOOKAHEAD_SIZE + PADDING_SIZE)
57
58//////////////////////////////////////////////////////////////////////////////////////////
59// @ global depends on 'error_tracker' and 'EOF_mask' definitions.
60//////////////////////////////////////////////////////////////////////////////////////////
61@global
62
63#ifdef SYMBOL_TABLE
64        @marker_strms_global // glue
65        @hash_strms_global
66        @group_strms_global
67#endif
68
69
70#ifdef SYMBOL_TABLE
71
72#include "../lib/symbol_table/src/symbol_table.hpp"
73#include "../lib/symbol_table/src/gid.hpp"
74
75#endif
76
77//////////////////////////////////////////////////////////////////////////////////////////
78// Headers that depend @ global stream struct types.
79//////////////////////////////////////////////////////////////////////////////////////////
80#include "../lib/transpose.hpp"
81#include <post_process.hpp>
82
83static void do_process(FILE *infile, FILE *outfile);
84
85int main(int argc, char * argv[]) {
86
87        char * infilename, * outfilename;
88        FILE *infile, *outfile;
89        struct stat fileinfo;
90
91        if (argc < 2) {
92                printf("Usage: %s <filename> [<outputfile>]\n", argv[0]);
93                exit(-1);
94        }
95
96        infilename = argv[1];
97        stat(infilename, &fileinfo);
98        infile = fopen(infilename, "rb");
99        if (!infile) {
100                fprintf(stderr, "Error: cannot open %s for input.\n", infilename);
101                exit(-1);
102        }
103
104        if (argc < 3) outfile = stdout;
105        else {
106                outfilename = argv[2];
107                outfile = fopen(outfilename, "wb");
108                if (!outfile) {
109                        fprintf(stderr, "Error: cannot open %s for writing.\n", outfilename);
110                        exit(-1);
111                }
112        }
113
114        PERF_SEC_BIND(1);
115
116        PERF_SEC_INIT(parser_timer);
117
118        do_process(infile, outfile);
119
120        PERF_SEC_DUMP(parser_timer);
121
122        PERF_SEC_DESTROY(parser_timer);
123
124        fclose(infile);
125        fclose(outfile);
126
127        return(0);
128}
129
130void do_process(FILE *infile, FILE *outfile) {
131        @decl
132
133#ifdef SYMBOL_TABLE // @ decl
134        @marker_strms_decl // glue xmlwf / symbol table
135        @hash_strms_decl
136        @group_strms_decl
137#endif
138
139        LineColTracker tracker;
140        TagMatcher<SEGMENT_SIZE,LOOKAHEAD_SIZE> matcher;
141
142        int block_base=0;
143        int block_pos = 0;
144        int buffer_base=0;
145        int buffer_pos = 0;
146        int chars_avail = 0;
147        int chars_read = 0;
148
149        //////////////////////////////////////////////////////////////////////////////////////////
150        // Buffer Management
151        //////////////////////////////////////////////////////////////////////////////////////////
152        //      BitBlock buf[(BUFFER_SIZE)/sizeof(BitBlock)];
153        //      uint8_t * src_buffer = (uint8_t *)buf + COPYBACK_SIZE;
154
155        #include "../lib/buffer.hpp"
156        uint8_t * COPYBACK;
157        uint8_t * src_buffer;
158        ALLOC_STATIC_ALIGNED_BYTE_BUFFER_WITH_COPYBACK(COPYBACK, src_buffer);
159
160#ifdef SYMBOL_TABLE
161        ///////////////////////////////////////////////////////////////////////////
162        // Parallel Data Streams with optional CopyBack
163        ///////////////////////////////////////////////////////////////////////////
164
165        // hash 0
166        BitBlock * COPYBACK_h0;
167        BitBlock * h0;
168        ALLOC_STATIC_ALIGNED_BITBLOCK_BUFFER_WITH_COPYBACK(COPYBACK_h0, h0);
169
170        // hash 1
171        BitBlock * COPYBACK_h1;
172        BitBlock * h1;
173        ALLOC_STATIC_ALIGNED_BITBLOCK_BUFFER_WITH_COPYBACK(COPYBACK_h1, h1);
174
175        // starts
176        BitBlock * COPYBACK_starts;
177        BitBlock * starts;
178        ALLOC_STATIC_ALIGNED_BITBLOCK_BUFFER_WITH_COPYBACK(COPYBACK_starts, starts);
179
180        // follows_0 - Arbitrary length symbols
181        BitBlock * COPYBACK_follows_0;
182        BitBlock * follows_0;
183        ALLOC_STATIC_ALIGNED_BITBLOCK_BUFFER_WITH_COPYBACK(COPYBACK_follows_0, follows_0);
184
185        ///////////////////////////////////////////////////////////////////////////
186        // Parallel Data Streams - No CopyBack
187        ///////////////////////////////////////////////////////////////////////////
188
189        // Basis_bits basis_bits_segment[SEGMENT_BLOCKS];
190        // Markers markers_segment[SEGMENT_BLOCKS];
191        // Hash hash[SEGMENT_BLOCKS];
192        Groups groups_segment[SEGMENT_BLOCKS];
193
194        ///////////////////////////////////////////////////////////////////////////
195        // Symbol Table
196        ///////////////////////////////////////////////////////////////////////////
197        gid<SEGMENT_SIZE> gids;
198        symbol_table<gid<SEGMENT_SIZE>, fast_pool_allocator<1024> > st;
199#endif
200
201        //////////////////////////////////////////////////////////////////////////////////////////
202        // XML Validation / Content Model
203        //////////////////////////////////////////////////////////////////////////////////////////
204        chars_read = fread((void *)src_buffer, 1, SEGMENT_SIZE, infile);
205        chars_avail = chars_read;
206        if (chars_avail >= SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
207
208        if(chars_read<4){
209                fprintf(stderr,"File is too short. Not well formed.\n");
210                exit(-1);
211        }
212
213        Entity_Info * e = new Entity_Info;
214        e->AnalyzeSignature((unsigned char *)src_buffer);
215
216        if (e->code_unit_base == ASCII) {
217
218                XML_Decl_Parser<ASCII> decl_parser((unsigned char *)src_buffer);
219
220                decl_parser.ReadXMLInfo(*e);
221
222                if (e->code_unit_size != SingleByte || (e->has_encoding_decl && (!at_UTF_8(e->encoding)))){
223                        fprintf(stderr,"Sorry, this xmlwf demo only works for UTF-8.\n");
224                        exit(-1);
225                }
226        }
227        else {
228                fprintf(stderr,"Sorry, this xmlwf demo does not process EBCDIC.\n");
229                exit(-1);
230        }
231
232        if (e->content_start != 0) {
233
234                memmove(&src_buffer[0], &src_buffer[e->content_start], chars_avail - e->content_start);
235                buffer_pos = e->content_start;
236                if ((chars_avail-e->content_start) < SEGMENT_SIZE) {
237                        chars_read = chars_avail - e->content_start + fread(&src_buffer[chars_avail-e->content_start], 1, e->content_start, infile);
238                        chars_avail = chars_read;
239                }
240                if (chars_avail >= SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
241        }
242
243        //////////////////////////////////////////////////////////////////////////////////////////
244        // Read OVERLAP bytes to support post processing validation lookahead.
245        //////////////////////////////////////////////////////////////////////////////////////////
246        chars_read = chars_avail + fread(&src_buffer[chars_avail], 1, LOOKAHEAD_SIZE, infile);
247        chars_avail = chars_read;
248        if (chars_avail >= SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
249
250        @stream_stmts
251
252        #ifdef SYMBOL_TABLE // @ stream_stmts
253                @marker_strms_stream_stmts // glue xmlwf / symbol table
254                @hash_strms_stream_stmts
255                @group_strms_stream_stmts
256        #endif
257
258        //////////////////////////////////////////////////////////////////////////////////////////
259        // Full Segments
260        //////////////////////////////////////////////////////////////////////////////////////////
261        matcher.setSrc((char *)src_buffer);
262        while (chars_avail >= SEGMENT_SIZE) {
263          PERF_SEC_START(parser_timer);
264          for (int blk = 0; blk < SEGMENT_BLOCKS; blk++) {
265                  block_base = blk*BLOCK_SIZE;
266                  s2p_do_block((BytePack *) &src_buffer[block_base], basis_bits);
267
268                  @block_stmts
269
270                  #ifdef SYMBOL_TABLE
271                          @marker_strms_block_stmts // glue
272                          @hash_strms_block_stmts
273                          @group_strms_block_stmts
274
275                          // for(int blk=0;blk<SEGMENT_BLOCKS;blk++) {  // write contiguous bit streams
276                                h0[blk] = hash.h0;
277                                h1[blk] = hash.h1;
278                                starts[blk] = groups.starts;
279                                follows_0[blk] = groups.follows_0;
280
281                                groups_segment[blk] = groups;
282                          //}
283                  #endif
284
285                  tracker.StoreNewlines(lex.LF);
286                  postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, (char *)src_buffer, buffer_base, block_base, chars_avail, tracker);
287                  matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
288                  tracker.AdvanceBlock();
289
290          }
291                #ifdef SYMBOL_TABLE
292                        st.resolve(src_buffer, groups_segment, starts, follows_0, h0, h1, SEGMENT_BLOCKS, gids);
293
294                  #ifdef DUMP_SYMBOLS
295                                uint32_t blk_offset;
296                                for(int blk=0;blk<SEGMENT_BLOCKS;blk++) {
297                                        blk_offset = blk * BLOCK_SIZE;
298                                        gid_type gid;
299
300                                        #ifdef INDEX_AT_STARTS
301                                                        ForwardScanner<BitBlock, scanword_t> scanner(&(groups_segment[blk].starts));
302                                        #else
303                                                        ForwardScanner<BitBlock, scanword_t> scanner(&(groups_segment[blk].follows));
304                                        #endif
305
306                                        scanner.scan_to_next();
307                                        while(!scanner.is_done()) {
308                                                gid = gids.at[scanner.get_pos() + blk_offset];
309                                                cout << string((char *)st.get_raw_data(gid), st.get_lgth(gid)) << endl;
310                                                scanner.scan_to_next();
311                                        }
312                        }
313                  #endif
314
315                #endif
316
317          matcher.StreamScan(chars_avail);
318          matcher.Advance_buffer();
319          PERF_SEC_END(parser_timer, chars_avail);
320
321          memmove(src_buffer, &src_buffer[SEGMENT_SIZE], LOOKAHEAD_SIZE); // CopyBack Trailing Padding
322          #ifdef SYMBOL_TABLE
323                  //COPY_BACK_BYTE_BUFFER(COPYBACK, src_buffer);
324                        COPY_BACK_BITBLOCK_BUFFER(COPYBACK_h0,h0);
325                        COPY_BACK_BITBLOCK_BUFFER(COPYBACK_h1,h1);
326                        COPY_BACK_BITBLOCK_BUFFER(COPYBACK_starts,starts);
327                        COPY_BACK_BITBLOCK_BUFFER(COPYBACK_follows_0,follows_0);
328                #endif
329       
330          chars_read = fread(&src_buffer[LOOKAHEAD_SIZE], 1, SEGMENT_SIZE, infile) + LOOKAHEAD_SIZE;
331          chars_avail = chars_read;
332          if (chars_avail >= SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
333          buffer_pos += chars_avail;
334          buffer_base = buffer_pos;
335        }
336
337        //////////////////////////////////////////////////////////////////////////////////////////
338        // Final Partial Segment
339        //////////////////////////////////////////////////////////////////////////////////////////
340        PERF_SEC_START(parser_timer);
341
342        block_pos = 0;
343        int remaining = chars_avail;
344
345        /* Full Blocks */
346        uint32_t blk = 0;
347        while (remaining >= BLOCK_SIZE) {
348                  block_base = block_pos;
349                  s2p_do_block((BytePack *) &src_buffer[block_pos], basis_bits);
350                  @block_stmts
351
352                  #ifdef SYMBOL_TABLE
353                          @marker_strms_block_stmts // glue
354                          @hash_strms_block_stmts
355                          @group_strms_block_stmts
356
357
358                                h0[blk] = hash.h0;
359                                h1[blk] = hash.h1;
360                                starts[blk] = groups.starts;
361                                follows_0[blk] = groups.follows_0;
362
363                                groups_segment[blk].follows = groups.follows;
364
365                  #endif
366
367                  tracker.StoreNewlines(lex.LF);
368                  postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, (char *)src_buffer, buffer_base, block_base, chars_avail, tracker);
369                  matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
370                  tracker.AdvanceBlock();
371                  block_pos += BLOCK_SIZE;
372                  remaining -= BLOCK_SIZE;
373                  blk++;
374        }
375        block_base = block_pos;
376
377        /* Partial Block or Any Carry */
378        if (remaining > 0 || @any_carry
379#ifdef SYMBOL_TABLE
380                || @marker_strms_any_carry || @group_strms_any_carry || @hash_strms_any_carry
381#endif
382           ) {
383                  EOF_mask = bitblock::srl(simd<1>::constant<1>(), convert(BLOCK_SIZE-remaining));
384                  s2p_do_final_block((BytePack *) &src_buffer[block_pos], basis_bits, EOF_mask);
385                  @final_block_stmts
386
387                  #ifdef SYMBOL_TABLE
388                          @marker_strms_final_block_stmts // glue
389                          @hash_strms_final_block_stmts
390                          @group_strms_final_block_stmts
391
392                                h0[blk] = hash.h0;
393                                h1[blk] = hash.h1;
394                                starts[blk] = groups.starts;
395                                follows_0[blk] = groups.follows_0;
396
397                                groups_segment[blk] = groups;                   
398                  #endif
399
400                  tracker.StoreNewlines(lex.LF);
401                  postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, (char *)src_buffer, buffer_base, block_base, chars_avail, tracker);
402                  matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
403                  tracker.AdvanceBlock();
404                  blk++;
405        }
406
407        buffer_pos += chars_avail;
408        buffer_base = buffer_pos;
409
410        matcher.StreamScan(chars_avail);
411        matcher.Advance_buffer();
412
413        #ifdef SYMBOL_TABLE
414                uint32_t segment_blocks = blk;
415                st.resolve(src_buffer, groups_segment, starts, follows_0, h0, h1, segment_blocks, gids);
416
417                #ifdef DUMP_SYMBOLS
418                        uint32_t blk_offset;
419                        for(int blk=0;blk<segment_blocks;blk++) {
420                                blk_offset = blk * BLOCK_SIZE;
421                                gid_type gid;
422
423                                #ifdef INDEX_AT_STARTS
424                                        ForwardScanner<BitBlock, scanword_t> scanner(&(groups_segment[blk].starts));
425                                #else
426                                        ForwardScanner<BitBlock, scanword_t> scanner(&(groups_segment[blk].follows));
427                                #endif
428
429                                scanner.scan_to_next();
430                                while(!scanner.is_done()) {
431                                        gid = gids.at[scanner.get_pos() + blk_offset];
432                                        cout << string((char *)st.get_raw_data(gid), st.get_lgth(gid)) << endl;
433                                        scanner.scan_to_next();
434                                }
435                        }
436
437                #endif
438
439        #endif
440
441        if (matcher.depth != 0) {
442          fprintf(stderr, "tag matching error (depth %i) at position %i\n", matcher.depth, buffer_base);
443          exit(-1);
444        }
445        PERF_SEC_END(parser_timer, chars_avail);
446}
447
Note: See TracBrowser for help on using the repository browser.