source: proto/parabix2/pablo_template.cpp @ 2704

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

Updated template/Makefile for STL memory aligned vector.

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