source: proto/parabix2/pablo_template_lsst.cpp @ 2547

Last change on this file since 2547 was 2547, checked in by ksherdy, 6 years ago

Updated templates for new perfsec.h

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