source: proto/parabix2/pablo_template.cpp @ 2351

Last change on this file since 2351 was 2351, checked in by ksherdy, 7 years ago

Updated #includes.

File size: 9.2 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 "../lib/simd-lib/bitblock.hpp"
11#include "../lib/simd-lib/carryQ.hpp"
12#include "../lib/simd-lib/bitblock_iterator.hpp"
13#include "../lib/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#ifdef BUFFER_PROFILING
29    BOM_Table * parser_timer;
30#elif CODE_CLOCKER
31    //#define NUM_EVENTS 1
32    //int Events[NUM_EVENTS] = {PAPI_TOT_CYC};
33    //int Events[NUM_EVENTS] = {PAPI_L2_DCM};
34    #define NUM_EVENTS 2
35    int Events[NUM_EVENTS] = {PAPI_TOT_CYC, PAPI_BR_MSP};
36    int cal_size = 20;
37    CC * parser_timer = new CC(Events,NUM_EVENTS,cal_size);
38#else
39    void * parser_timer;
40#endif
41
42ErrorTracker error_tracker;
43BitBlock EOF_mask = simd<1>::constant<1>();
44
45//////////////////////////////////////////////////////////////////////////////////////////
46// Buffer Management // WARNING: Do Not update #defines. Results in TagMatcher errors.
47//////////////////////////////////////////////////////////////////////////////////////////
48#define PADDING_BLOCKS 0
49#define PADDING_SIZE (BLOCK_SIZE * PADDING_BLOCKS)
50#define COPYBACK_BLOCKS 2
51#define COPYBACK_SIZE (BLOCK_SIZE * COPYBACK_BLOCKS)
52#define LOOKAHEAD_BLOCKS 1
53#define LOOKAHEAD_SIZE (BLOCK_SIZE * LOOKAHEAD_BLOCKS)
54#define SEGMENT_BLOCKS  12 // WARNING: TagMatcher.hpp causes xmlconf test suite failures for SEGMENT_BLOCKS < 3.
55#define SEGMENT_SIZE (BLOCK_SIZE * SEGMENT_BLOCKS)
56#define BUFFER_SIZE (COPYBACK_SIZE + SEGMENT_SIZE + LOOKAHEAD_SIZE + PADDING_SIZE)
57
58//////////////////////////////////////////////////////////////////////////////////////////
59// @ global depends on 'error_tracker' and 'EOF_mask' definitions.
60//////////////////////////////////////////////////////////////////////////////////////////
61@global
62
63//////////////////////////////////////////////////////////////////////////////////////////
64// Headers that depend @ global stream struct types.
65//////////////////////////////////////////////////////////////////////////////////////////
66#include "../lib/simd-lib/transpose.hpp"
67#include <post_process.hpp>
68
69static void do_process(FILE *infile, FILE *outfile);
70
71int main(int argc, char * argv[]) {
72
73        char * infilename, * outfilename;
74        FILE *infile, *outfile;
75        struct stat fileinfo;
76
77        if (argc < 2) {
78                printf("Usage: %s <filename> [<outputfile>]\n", argv[0]);
79                exit(-1);
80        }
81
82        infilename = argv[1];
83        stat(infilename, &fileinfo);
84        infile = fopen(infilename, "rb");
85        if (!infile) {
86                fprintf(stderr, "Error: cannot open %s for input.\n", infilename);
87                exit(-1);
88        }
89
90        if (argc < 3) outfile = stdout;
91        else {
92                outfilename = argv[2];
93                outfile = fopen(outfilename, "wb");
94                if (!outfile) {
95                        fprintf(stderr, "Error: cannot open %s for writing.\n", outfilename);
96                        exit(-1);
97                }
98        }
99
100        PERF_SEC_BIND(1);
101
102        PERF_SEC_INIT(parser_timer);
103
104        do_process(infile, outfile);
105
106        PERF_SEC_DUMP(parser_timer);
107
108        PERF_SEC_DESTROY(parser_timer);
109
110        fclose(infile);
111        fclose(outfile);
112
113        return(0);
114}
115
116void do_process(FILE *infile, FILE *outfile) {
117
118    @decl
119
120    LineColTracker tracker;
121        TagMatcher<SEGMENT_SIZE,LOOKAHEAD_SIZE> matcher;
122
123    int block_base=0;
124        int block_pos = 0;
125    int buffer_base=0;
126    int buffer_pos = 0;
127    int chars_avail = 0;
128        int chars_read = 0;
129
130    //////////////////////////////////////////////////////////////////////////////////////////
131    // Buffer Management
132    //////////////////////////////////////////////////////////////////////////////////////////
133        //      BitBlock buf[(BUFFER_SIZE)/sizeof(BitBlock)];
134        //      uint8_t * src_buffer = (uint8_t *)buf + COPYBACK_SIZE;
135
136        #include "../lib/simd-lib/buffer.hpp"
137        uint8_t * COPYBACK;
138        uint8_t * src_buffer;
139        ALLOC_STATIC_ALIGNED_BYTE_BUFFER_WITH_COPYBACK(COPYBACK, src_buffer);
140       
141    //////////////////////////////////////////////////////////////////////////////////////////
142    // XML Validation / Content Model
143    //////////////////////////////////////////////////////////////////////////////////////////
144        chars_read = fread((void *)src_buffer, 1, SEGMENT_SIZE, infile);
145        chars_avail = chars_read;
146        if (chars_avail >= SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
147
148    if(chars_read<4){
149                fprintf(stderr,"File is too short. Not well formed.\n");
150                exit(-1);
151    }
152
153    Entity_Info * e = new Entity_Info;
154        e->AnalyzeSignature((unsigned char *)src_buffer);
155
156    if (e->code_unit_base == ASCII) {
157
158                XML_Decl_Parser<ASCII> decl_parser((unsigned char *)src_buffer);
159
160                decl_parser.ReadXMLInfo(*e);
161
162                if (e->code_unit_size != SingleByte || (e->has_encoding_decl && (!at_UTF_8(e->encoding)))){
163                        fprintf(stderr,"Sorry, this xmlwf demo only works for UTF-8.\n");
164                        exit(-1);
165                }
166    }
167    else {
168        fprintf(stderr,"Sorry, this xmlwf demo does not process EBCDIC.\n");
169        exit(-1);
170    }
171
172    if (e->content_start != 0) {
173
174                memmove(&src_buffer[0], &src_buffer[e->content_start], chars_avail - e->content_start);
175                buffer_pos = e->content_start;
176                if ((chars_avail-e->content_start) < SEGMENT_SIZE) {
177                        chars_read = chars_avail - e->content_start + fread(&src_buffer[chars_avail-e->content_start], 1, e->content_start, infile);
178                        chars_avail = chars_read;
179                }
180                if (chars_avail >= SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
181    }
182
183        //////////////////////////////////////////////////////////////////////////////////////////
184        // Read OVERLAP bytes to support post processing validation lookahead.
185        //////////////////////////////////////////////////////////////////////////////////////////
186        chars_read = chars_avail + fread(&src_buffer[chars_avail], 1, LOOKAHEAD_SIZE, infile);
187        chars_avail = chars_read;
188        if (chars_avail >= SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
189
190    @stream_stmts
191
192    //////////////////////////////////////////////////////////////////////////////////////////
193    // Full Segments
194    //////////////////////////////////////////////////////////////////////////////////////////
195        matcher.setSrc((char *)src_buffer);
196        while (chars_avail >= SEGMENT_SIZE) {
197      PERF_SEC_START(parser_timer);
198      for (int blk = 0; blk < SEGMENT_BLOCKS; blk++) {
199          block_base = blk*BLOCK_SIZE;
200                  s2p_do_block((BytePack *) &src_buffer[block_base], basis_bits);
201
202          @block_stmts
203
204          tracker.StoreNewlines(lex.LF);
205                  postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, (char *)src_buffer, buffer_base, block_base, chars_avail, tracker);
206          matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
207          tracker.AdvanceBlock();
208      }
209      matcher.StreamScan(chars_avail);
210      matcher.Advance_buffer();
211      PERF_SEC_END(parser_timer, chars_avail);
212
213          memmove(src_buffer, &src_buffer[SEGMENT_SIZE], LOOKAHEAD_SIZE); // CopyBack Trailing Padding
214
215          // memmove(src_base, &src_buf[SEGMENT_SIZE-COPYBACK_SIZE], COPYBACK_SIZE); // Symbol Table CopyBack
216          chars_read = fread(&src_buffer[LOOKAHEAD_SIZE], 1, SEGMENT_SIZE, infile) + LOOKAHEAD_SIZE;
217          chars_avail = chars_read;
218          if (chars_avail >= SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
219          buffer_pos += chars_avail;
220          buffer_base = buffer_pos;
221    }
222
223    //////////////////////////////////////////////////////////////////////////////////////////
224    // Final Partial Segment
225    //////////////////////////////////////////////////////////////////////////////////////////
226    PERF_SEC_START(parser_timer);
227
228    block_pos = 0;
229    int remaining = chars_avail;
230
231    /* Full Blocks */
232    while (remaining >= BLOCK_SIZE) {
233          block_base = block_pos;
234                  s2p_do_block((BytePack *) &src_buffer[block_pos], basis_bits);
235          @block_stmts
236          tracker.StoreNewlines(lex.LF);
237                  postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, (char *)src_buffer, buffer_base, block_base, chars_avail, tracker);
238                  matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
239          tracker.AdvanceBlock();
240          block_pos += BLOCK_SIZE;
241          remaining -= BLOCK_SIZE;
242    }
243    block_base = block_pos;
244
245    /* Partial Block or Any Carry */
246    if (remaining > 0 || @any_carry) {
247          EOF_mask = bitblock::srl(simd<1>::constant<1>(), convert(BLOCK_SIZE-remaining));
248                  s2p_do_final_block((BytePack *) &src_buffer[block_pos], basis_bits, EOF_mask);
249          @final_block_stmts
250          tracker.StoreNewlines(lex.LF);
251                  postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, (char *)src_buffer, buffer_base, block_base, chars_avail, tracker);
252          matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
253          tracker.AdvanceBlock();
254
255    }
256
257    buffer_pos += chars_avail;
258    buffer_base = buffer_pos;
259
260    matcher.StreamScan(chars_avail);
261    matcher.Advance_buffer();
262
263    if (matcher.depth != 0) {
264      fprintf(stderr, "tag matching error (depth %i) at position %i\n", matcher.depth, buffer_base);
265      exit(-1);
266    }
267        PERF_SEC_END(parser_timer, chars_avail);
268}
269
Note: See TracBrowser for help on using the repository browser.