source: proto/parabix2/pablo_template_lsst.cpp @ 2351

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

Updated #includes.

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