source: proto/parabix2/pablo_template_lsst.cpp @ 2307

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

Updated symbol_table to lsst.

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