source: proto/parabix2/pablo_template_lsst.cpp @ 2698

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

Fixes for advance_n support in experimental mode

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