source: proto/parabix2/pablo_template_lsst.cpp @ 2806

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

Re-oranganized headers to provide a clear separation between application specific and stream struct / function headers.

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