source: proto/parabix2/pablo_template_lsst.cpp @ 3024

Last change on this file since 3024 was 3024, checked in by cameron, 6 years ago

Clean ups

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