source: proto/parabix2/pablo_template_lsst.cpp @ 2820

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

LSST fix.

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