source: proto/parabix2/s2k_template.cpp @ 3683

Last change on this file since 3683 was 3683, checked in by ksherdy, 5 years ago

Updated PabloJ name to s2k.

File size: 12.7 KB
Line 
1// PabloJ generated headers
2#include "/home/ken/workspace/pabloj/output/cpplang/parabix2_pablo_definitions.hpp"
3
4// CPP standard headers
5#include <stdio.h>
6#include <stdlib.h>
7#include <errno.h>
8#include <sys/types.h>
9#include <sys/stat.h>
10
11// Parabix support libraries
12#include <simd-lib/s2p.hpp>
13#include <simd-lib/buffer.hpp>
14#include <simd-lib/bitblock_iterator.hpp>
15#include <simd-lib/perflib/perfsec.h>
16
17// Application specific headers and definitions
18#include <xmldecl.h>
19#include <namechars.h>
20#include <LineColTracker.hpp>
21#include <XMLTestSuiteError.h>
22
23//#define STL_ALIGNED_VECTOR // experimental STL Aligned Vector
24#ifndef STL_ALIGNED_VECTOR
25#include <TagMatcher.hpp>
26#endif
27
28#ifdef STL_ALIGNED_VECTOR // experimental, comment out TagMatcher code to use STL aligned memory vector
29#warning "Compiling with experimental STL_ALIGNED_VECTOR."
30#include <vector>
31#include <simd-lib/stl_aligned_allocator.hpp>
32#endif
33
34#ifdef BUFFER_PROFILING
35    BOM_Table * parser_timer;
36#elif PAPI
37                #define PAPI_EVENTS_COUNT 2
38                int PAPI_EVENTS[PAPI_EVENTS_COUNT] = {PAPI_TOT_CYC, PAPI_BR_MSP};       
39    CC * parser_timer;
40#else
41    void * parser_timer;
42#endif
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//////////////////////////////////////////////////////////////////////////////////////////
63// Headers that depend @ global stream struct types.
64//////////////////////////////////////////////////////////////////////////////////////////
65#include <simd-lib/transpose.hpp>
66#include <post_process.hpp>
67
68static void do_process(FILE *infile, FILE *outfile);
69
70int main(int argc, char * argv[]) {
71
72        char * infilename, * outfilename;
73        FILE *infile, *outfile;
74        struct stat fileinfo;
75
76        if (argc < 2) {
77                printf("Usage: %s <filename> [<outputfile>]\n", argv[0]);
78                exit(-1);
79        }
80
81        infilename = argv[1];
82        stat(infilename, &fileinfo);
83        infile = fopen(infilename, "rb");
84        if (!infile) {
85                fprintf(stderr, "Error: cannot open %s for input.\n", infilename);
86                exit(-1);
87        }
88
89        if (argc < 3) outfile = stdout;
90        else {
91                outfilename = argv[2];
92                outfile = fopen(outfilename, "wb");
93                if (!outfile) {
94                        fprintf(stderr, "Error: cannot open %s for writing.\n", outfilename);
95                        exit(-1);
96                }
97        }
98
99        PERF_SEC_BIND(1);
100
101        PERF_SEC_INIT(parser_timer);
102
103        do_process(infile, outfile);
104
105        PERF_SEC_DUMP(parser_timer);
106
107        PERF_SEC_DESTROY(parser_timer);
108
109        fclose(infile);
110        fclose(outfile);
111
112        return(0);
113}
114
115void do_process(FILE *infile, FILE *outfile) {
116
117    //////////////////////////////////////////////////////////////////////////////////////////
118                // NOT GENERATED
119    //////////////////////////////////////////////////////////////////////////////////////////
120      struct Basis_bits basis_bits;
121
122  struct U8 u8;
123
124  struct Lex lex;
125
126  struct Marker marker;
127
128  struct CtCDPI_Callouts ctCDPI_Callouts;
129
130  struct Ref_Callouts ref_Callouts;
131
132  struct Tag_Callouts tag_Callouts;
133
134  struct Check_streams check_streams;
135
136
137
138
139    LineColTracker tracker;
140                #ifndef STL_ALIGNED_VECTOR
141                        TagMatcher<SEGMENT_SIZE,LOOKAHEAD_SIZE> matcher;
142                #endif
143
144    int block_base  = 0;
145                int block_pos   = 0;
146    int buffer_base = 0;
147    int buffer_pos  = 0;
148    int chars_avail = 0;
149                int chars_read  = 0;
150
151    //////////////////////////////////////////////////////////////////////////////////////////
152    // Buffer Management
153    //////////////////////////////////////////////////////////////////////////////////////////
154                //      BitBlock buf[(BUFFER_SIZE)/sizeof(BitBlock)];
155                //      char * src_buffer = (char *)buf + COPYBACK_SIZE;
156
157                #ifdef STL_ALIGNED_VECTOR
158                        std::vector<char, AAllocator<char> > src_buffer;
159                        src_buffer.reserve(BUFFER_SIZE);
160                #else
161                        char * COPYBACK;
162                        char * src_buffer;
163                        ALLOC_STATIC_ALIGNED_BYTE_BUFFER_WITH_COPYBACK(COPYBACK, src_buffer);
164                #endif
165       
166    //////////////////////////////////////////////////////////////////////////////////////////
167    // XML Validation / Content Model
168    //////////////////////////////////////////////////////////////////////////////////////////
169                chars_read = fread((void *)&src_buffer[0], 1, SEGMENT_SIZE, infile);
170                chars_avail = chars_read;
171                if (chars_avail >= SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
172
173    if(chars_read<4){
174                fprintf(stderr,"File is too short. Not well formed.\n");
175                exit(-1);
176    }
177
178    Entity_Info * e = new Entity_Info;
179                e->AnalyzeSignature((unsigned char *)&src_buffer[0]);
180
181    if (e->code_unit_base == ASCII) {
182
183                XML_Decl_Parser<ASCII> decl_parser((unsigned char *)&src_buffer[0]);
184
185                decl_parser.ReadXMLInfo(*e);
186
187                if (e->code_unit_size != SingleByte || (e->has_encoding_decl && (!at_UTF_8(e->encoding)))){
188                        fprintf(stderr,"Sorry, this xmlwf demo only works for UTF-8.\n");
189                        exit(-1);
190                }
191    }
192    else {
193        fprintf(stderr,"Sorry, this xmlwf demo does not process EBCDIC.\n");
194        exit(-1);
195    }
196
197    if (e->content_start != 0) {
198
199                memmove(&src_buffer[0], &src_buffer[e->content_start], chars_avail - e->content_start);
200                buffer_pos = e->content_start;
201                if ((chars_avail-e->content_start) < SEGMENT_SIZE) {
202                        chars_read = chars_avail - e->content_start + fread(&src_buffer[chars_avail-e->content_start], 1, e->content_start, infile);
203                        chars_avail = chars_read;
204                }
205                if (chars_avail >= SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
206    }
207
208        //////////////////////////////////////////////////////////////////////////////////////////
209        // Read OVERLAP bytes to support post processing validation lookahead.
210        //////////////////////////////////////////////////////////////////////////////////////////
211        chars_read = chars_avail + fread(&src_buffer[chars_avail], 1, LOOKAHEAD_SIZE, infile);
212        chars_avail = chars_read;
213        if (chars_avail >= SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
214
215    //////////////////////////////////////////////////////////////////////////////////////////
216                // NOT GENERATED
217    //////////////////////////////////////////////////////////////////////////////////////////
218      Parse_refs parse_refs;
219  Parse_tags parse_tags;
220  Classify_bytes_Validate_utf8 classify_bytes_Validate_utf8;
221  Parse_CtCDPI parse_CtCDPI;
222  Do_check_streams do_check_streams;
223  Validate_xml_names validate_xml_names;
224
225
226    //////////////////////////////////////////////////////////////////////////////////////////
227    // Full Segments
228    //////////////////////////////////////////////////////////////////////////////////////////
229        #ifndef STL_ALIGNED_VECTOR
230        matcher.setSrc((char *)&src_buffer[0]);
231        #endif
232        while (chars_avail >= SEGMENT_SIZE) {
233      PERF_SEC_START(parser_timer);
234      for (int blk = 0; blk < SEGMENT_BLOCKS; blk++) {
235          block_base = blk*BLOCK_SIZE;
236                  s2p_do_block((BytePack *) &src_buffer[block_base], basis_bits);
237
238                                        //////////////////////////////////////////////////////////////////////////////////////////
239                                        // NOT GENERATED
240                                        //////////////////////////////////////////////////////////////////////////////////////////
241         
242  classify_bytes_Validate_utf8.do_block(basis_bits, lex, u8);
243  parse_CtCDPI.do_block(lex, marker, ctCDPI_Callouts, check_streams);
244  parse_tags.do_block(lex, marker, tag_Callouts);
245  parse_refs.do_block(lex, marker, ref_Callouts);
246  validate_xml_names.do_block(ctCDPI_Callouts, ref_Callouts, tag_Callouts, lex, u8, check_streams);
247  do_check_streams.do_block(marker, tag_Callouts, check_streams);
248
249          tracker.StoreNewlines(lex.LF);
250                  postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, (char *)&src_buffer[0], buffer_base, block_base, chars_avail, tracker);
251                                        #ifndef STL_ALIGNED_VECTOR
252          matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
253                                        #endif
254          tracker.AdvanceBlock();
255      }
256                        #ifndef STL_ALIGNED_VECTOR
257      matcher.StreamScan(chars_avail);
258      matcher.Advance_buffer();
259                        #endif                 
260      PERF_SEC_END(parser_timer, chars_avail);
261
262          memmove(&src_buffer[0], &src_buffer[SEGMENT_SIZE], LOOKAHEAD_SIZE); // CopyBack Trailing Padding
263
264          chars_read = fread(&src_buffer[LOOKAHEAD_SIZE], 1, SEGMENT_SIZE, infile) + LOOKAHEAD_SIZE;
265          chars_avail = chars_read;
266          if (chars_avail >= SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
267          buffer_pos += chars_avail;
268          buffer_base = buffer_pos;
269    }
270
271    //////////////////////////////////////////////////////////////////////////////////////////
272    // Final Partial Segment
273    //////////////////////////////////////////////////////////////////////////////////////////
274    PERF_SEC_START(parser_timer);
275
276    block_pos = 0;
277    int remaining = chars_avail;
278
279    /* Full Blocks */
280    while (remaining >= BLOCK_SIZE) {
281          block_base = block_pos;
282                                s2p_do_block((BytePack *) &src_buffer[block_pos], basis_bits);
283                                        //////////////////////////////////////////////////////////////////////////////////////////
284                                        // NOT GENERATED
285                                        //////////////////////////////////////////////////////////////////////////////////////////
286         
287  classify_bytes_Validate_utf8.do_block(basis_bits, lex, u8);
288  parse_CtCDPI.do_block(lex, marker, ctCDPI_Callouts, check_streams);
289  parse_tags.do_block(lex, marker, tag_Callouts);
290  parse_refs.do_block(lex, marker, ref_Callouts);
291  validate_xml_names.do_block(ctCDPI_Callouts, ref_Callouts, tag_Callouts, lex, u8, check_streams);
292  do_check_streams.do_block(marker, tag_Callouts, check_streams);
293          tracker.StoreNewlines(lex.LF);
294                                postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, (char *)&src_buffer[0], buffer_base, block_base, chars_avail, tracker);
295                                        #ifndef STL_ALIGNED_VECTOR
296                                                matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
297                                        #endif
298          tracker.AdvanceBlock();
299          block_pos += BLOCK_SIZE;
300          remaining -= BLOCK_SIZE;
301    }
302    block_base = block_pos;
303
304//    Partial Block or Any Carry
305//
306//    Eliminatinthe @anycarry test simplifies dependencies. - RDC Nov. 6, 2012
307//
308#ifdef USE_ANY_CARRY_TEST
309                //////////////////////////////////////////////////////////////////////////////////////////
310                // NOT GENERATED
311                //////////////////////////////////////////////////////////////////////////////////////////
312   if (remaining > 0 || parse_refs.carryQ.CarryTest(0, 6) || parse_tags.carryQ.CarryTest(0, 13) || classify_bytes_Validate_utf8.carryQ.CarryTest(0, 10) || parse_CtCDPI.carryQ.CarryTest(0, 19) || 0 || validate_xml_names.carryQ.CarryTest(0, 9)) {
313#endif
314          EOF_mask = bitblock::srl(simd<1>::constant<1>(), convert(BLOCK_SIZE-remaining));
315                                s2p_do_final_block((BytePack *) &src_buffer[block_pos], basis_bits, EOF_mask);
316                                        //////////////////////////////////////////////////////////////////////////////////////////
317                                        // NOT GENERATED
318                                        //////////////////////////////////////////////////////////////////////////////////////////
319         
320  classify_bytes_Validate_utf8.do_final_block(basis_bits, lex, u8, EOF_mask);
321  parse_CtCDPI.do_final_block(lex, marker, ctCDPI_Callouts, check_streams, EOF_mask);
322  parse_tags.do_final_block(lex, marker, tag_Callouts, EOF_mask);
323  parse_refs.do_final_block(lex, marker, ref_Callouts, EOF_mask);
324  validate_xml_names.do_final_block(ctCDPI_Callouts, ref_Callouts, tag_Callouts, lex, u8, check_streams, EOF_mask);
325  do_check_streams.do_final_block(marker, tag_Callouts, check_streams, EOF_mask);
326          tracker.StoreNewlines(lex.LF);
327                                postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, (char *)&src_buffer[0], buffer_base, block_base, chars_avail, tracker);
328                                        #ifndef STL_ALIGNED_VECTOR
329          matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
330                                        #endif
331          tracker.AdvanceBlock();
332
333#ifdef USE_ANY_CARRY_TEST
334   }
335#endif
336
337    buffer_pos += chars_avail;
338    buffer_base = buffer_pos;
339                #ifndef STL_ALIGNED_VECTOR
340    matcher.StreamScan(chars_avail);
341    matcher.Advance_buffer();
342
343    if (matcher.depth != 0) {
344      fprintf(stderr, "tag matching error (depth %i) at position %i\n", matcher.depth, buffer_base);
345      exit(-1);
346    }
347                #endif
348                PERF_SEC_END(parser_timer, chars_avail);
349}
350
Note: See TracBrowser for help on using the repository browser.