source: proto/parabix2/pablo_template.cpp @ 3024

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

Clean ups

File size: 10.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
10BitBlock EOF_mask = simd<1>::constant<1>();
11
12// XMLWF application headers and definitions
13#include <stdio.h>
14#include <stdlib.h>
15#include <errno.h>
16#include <sys/types.h>
17#include <sys/stat.h>
18
19#include <simd-lib/s2p.hpp>
20#include <simd-lib/buffer.hpp>
21#include <simd-lib/bitblock_iterator.hpp>
22#include <simd-lib/perflib/perfsec.h>
23
24#include <xmldecl.h>
25#include <namechars.h>
26#include <LineColTracker.hpp>
27#include <XMLTestSuiteError.h>
28
29// Define the mappings for pablo.assert_0(strm, errkind) statements which
30// compile to the the form assert_0_error(errkind, strm)
31#include <ErrorTracker.h>
32
33ErrorTracker error_tracker;
34#define assert_0_error(errkind, errstrm) error_tracker.NoteError(errkind, errstrm);
35
36//#define STL_ALIGNED_VECTOR // experimental STL Aligned Vector
37#ifndef STL_ALIGNED_VECTOR
38#include <TagMatcher.hpp>
39#endif
40
41#ifdef STL_ALIGNED_VECTOR // experimental, comment out TagMatcher code to use STL aligned memory vector
42#warning "Compiling with experimental STL_ALIGNED_VECTOR."
43#include <vector>
44#include <simd-lib/stl_aligned_allocator.hpp>
45#endif
46
47#ifdef BUFFER_PROFILING
48    BOM_Table * parser_timer;
49#elif PAPI
50                #define PAPI_EVENTS_COUNT 2
51                int PAPI_EVENTS[PAPI_EVENTS_COUNT] = {PAPI_TOT_CYC, PAPI_BR_MSP};       
52    CC * parser_timer;
53#else
54    void * parser_timer;
55#endif
56
57//////////////////////////////////////////////////////////////////////////////////////////
58// Buffer Management // WARNING: Do Not update #defines. Results in TagMatcher errors.
59//////////////////////////////////////////////////////////////////////////////////////////
60#define PADDING_BLOCKS 0
61#define PADDING_SIZE (BLOCK_SIZE * PADDING_BLOCKS)
62#define COPYBACK_BLOCKS 2
63#define COPYBACK_SIZE (BLOCK_SIZE * COPYBACK_BLOCKS)
64#define LOOKAHEAD_BLOCKS 1
65#define LOOKAHEAD_SIZE (BLOCK_SIZE * LOOKAHEAD_BLOCKS)
66#define SEGMENT_BLOCKS  12 // WARNING: TagMatcher.hpp causes xmlconf test suite failures for SEGMENT_BLOCKS < 3.
67#define SEGMENT_SIZE (BLOCK_SIZE * SEGMENT_BLOCKS)
68#define BUFFER_SIZE (COPYBACK_SIZE + SEGMENT_SIZE + LOOKAHEAD_SIZE + PADDING_SIZE)
69
70//////////////////////////////////////////////////////////////////////////////////////////
71// @ global depends on 'error_tracker' and 'EOF_mask' definitions.
72//////////////////////////////////////////////////////////////////////////////////////////
73@global
74
75//////////////////////////////////////////////////////////////////////////////////////////
76// Headers that depend @ global stream struct types.
77//////////////////////////////////////////////////////////////////////////////////////////
78#include <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
130    @decl
131
132    LineColTracker tracker;
133                #ifndef STL_ALIGNED_VECTOR
134                        TagMatcher<SEGMENT_SIZE,LOOKAHEAD_SIZE> matcher;
135                #endif
136
137    int block_base  = 0;
138                int block_pos   = 0;
139    int buffer_base = 0;
140    int buffer_pos  = 0;
141    int chars_avail = 0;
142                int chars_read  = 0;
143
144    //////////////////////////////////////////////////////////////////////////////////////////
145    // Buffer Management
146    //////////////////////////////////////////////////////////////////////////////////////////
147                //      BitBlock buf[(BUFFER_SIZE)/sizeof(BitBlock)];
148                //      uint8_t * src_buffer = (uint8_t *)buf + COPYBACK_SIZE;
149
150                #ifdef STL_ALIGNED_VECTOR
151                        std::vector<uint8_t, AAllocator<uint8_t> > src_buffer;
152                        src_buffer.reserve(BUFFER_SIZE);
153                #else
154                        uint8_t * COPYBACK;
155                        uint8_t * src_buffer;
156                        ALLOC_STATIC_ALIGNED_BYTE_BUFFER_WITH_COPYBACK(COPYBACK, src_buffer);
157                #endif
158       
159    //////////////////////////////////////////////////////////////////////////////////////////
160    // XML Validation / Content Model
161    //////////////////////////////////////////////////////////////////////////////////////////
162                chars_read = fread((void *)&src_buffer[0], 1, SEGMENT_SIZE, infile);
163                chars_avail = chars_read;
164                if (chars_avail >= SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
165
166    if(chars_read<4){
167                fprintf(stderr,"File is too short. Not well formed.\n");
168                exit(-1);
169    }
170
171    Entity_Info * e = new Entity_Info;
172                e->AnalyzeSignature((unsigned char *)&src_buffer[0]);
173
174    if (e->code_unit_base == ASCII) {
175
176                XML_Decl_Parser<ASCII> decl_parser((unsigned char *)&src_buffer[0]);
177
178                decl_parser.ReadXMLInfo(*e);
179
180                if (e->code_unit_size != SingleByte || (e->has_encoding_decl && (!at_UTF_8(e->encoding)))){
181                        fprintf(stderr,"Sorry, this xmlwf demo only works for UTF-8.\n");
182                        exit(-1);
183                }
184    }
185    else {
186        fprintf(stderr,"Sorry, this xmlwf demo does not process EBCDIC.\n");
187        exit(-1);
188    }
189
190    if (e->content_start != 0) {
191
192                memmove(&src_buffer[0], &src_buffer[e->content_start], chars_avail - e->content_start);
193                buffer_pos = e->content_start;
194                if ((chars_avail-e->content_start) < SEGMENT_SIZE) {
195                        chars_read = chars_avail - e->content_start + fread(&src_buffer[chars_avail-e->content_start], 1, e->content_start, infile);
196                        chars_avail = chars_read;
197                }
198                if (chars_avail >= SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
199    }
200
201        //////////////////////////////////////////////////////////////////////////////////////////
202        // Read OVERLAP bytes to support post processing validation lookahead.
203        //////////////////////////////////////////////////////////////////////////////////////////
204        chars_read = chars_avail + fread(&src_buffer[chars_avail], 1, LOOKAHEAD_SIZE, infile);
205        chars_avail = chars_read;
206        if (chars_avail >= SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
207
208    @stream_stmts
209
210    //////////////////////////////////////////////////////////////////////////////////////////
211    // Full Segments
212    //////////////////////////////////////////////////////////////////////////////////////////
213        #ifndef STL_ALIGNED_VECTOR
214        matcher.setSrc((char *)&src_buffer[0]);
215        #endif
216        while (chars_avail >= SEGMENT_SIZE) {
217      PERF_SEC_START(parser_timer);
218      for (int blk = 0; blk < SEGMENT_BLOCKS; blk++) {
219          block_base = blk*BLOCK_SIZE;
220                  s2p_do_block((BytePack *) &src_buffer[block_base], basis_bits);
221
222          @block_stmts
223
224          tracker.StoreNewlines(lex.LF);
225                  postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, (char *)&src_buffer[0], buffer_base, block_base, chars_avail, tracker);
226                                        #ifndef STL_ALIGNED_VECTOR
227          matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
228                                        #endif
229          tracker.AdvanceBlock();
230      }
231                        #ifndef STL_ALIGNED_VECTOR
232      matcher.StreamScan(chars_avail);
233      matcher.Advance_buffer();
234                        #endif                 
235      PERF_SEC_END(parser_timer, chars_avail);
236
237          memmove(&src_buffer[0], &src_buffer[SEGMENT_SIZE], LOOKAHEAD_SIZE); // CopyBack Trailing Padding
238
239          chars_read = fread(&src_buffer[LOOKAHEAD_SIZE], 1, SEGMENT_SIZE, infile) + LOOKAHEAD_SIZE;
240          chars_avail = chars_read;
241          if (chars_avail >= SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
242          buffer_pos += chars_avail;
243          buffer_base = buffer_pos;
244    }
245
246    //////////////////////////////////////////////////////////////////////////////////////////
247    // Final Partial Segment
248    //////////////////////////////////////////////////////////////////////////////////////////
249    PERF_SEC_START(parser_timer);
250
251    block_pos = 0;
252    int remaining = chars_avail;
253
254    /* Full Blocks */
255    while (remaining >= BLOCK_SIZE) {
256          block_base = block_pos;
257                                s2p_do_block((BytePack *) &src_buffer[block_pos], basis_bits);
258          @block_stmts
259          tracker.StoreNewlines(lex.LF);
260                                postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, (char *)&src_buffer[0], buffer_base, block_base, chars_avail, tracker);
261                                        #ifndef STL_ALIGNED_VECTOR
262                                                matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
263                                        #endif
264          tracker.AdvanceBlock();
265          block_pos += BLOCK_SIZE;
266          remaining -= BLOCK_SIZE;
267    }
268    block_base = block_pos;
269
270//    Partial Block or Any Carry
271//
272//    Eliminating the @anycarry test simplifies dependencies. - RDC Nov. 6, 2012
273//
274#ifdef USE_ANY_CARRY_TEST
275   if (remaining > 0 || @any_carry) {
276#endif
277          EOF_mask = bitblock::srl(simd<1>::constant<1>(), convert(BLOCK_SIZE-remaining));
278                                s2p_do_final_block((BytePack *) &src_buffer[block_pos], basis_bits, EOF_mask);
279          @final_block_stmts
280          tracker.StoreNewlines(lex.LF);
281                                postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, (char *)&src_buffer[0], buffer_base, block_base, chars_avail, tracker);
282                                        #ifndef STL_ALIGNED_VECTOR
283          matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
284                                        #endif
285          tracker.AdvanceBlock();
286
287#ifdef USE_ANY_CARRY_TEST
288   }
289#endif
290
291    buffer_pos += chars_avail;
292    buffer_base = buffer_pos;
293                #ifndef STL_ALIGNED_VECTOR
294    matcher.StreamScan(chars_avail);
295    matcher.Advance_buffer();
296
297    if (matcher.depth != 0) {
298      fprintf(stderr, "tag matching error (depth %i) at position %i\n", matcher.depth, buffer_base);
299      exit(-1);
300    }
301                #endif
302                PERF_SEC_END(parser_timer, chars_avail);
303}
304
Note: See TracBrowser for help on using the repository browser.