source: proto/xmlschema/pablo_template.cpp @ 4857

Last change on this file since 4857 was 3227, checked in by shiyangy, 6 years ago

project updated

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