source: proto/RE/output/pablo_template.cpp @ 3022

Last change on this file since 3022 was 3022, checked in by bhull, 6 years ago

RE changes

File size: 9.5 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
27#ifdef BUFFER_PROFILING
28    BOM_Table * parser_timer;
29#elif PAPI
30                #define PAPI_EVENTS_COUNT 2
31                int PAPI_EVENTS[PAPI_EVENTS_COUNT] = {PAPI_TOT_CYC, PAPI_BR_MSP};       
32    CC * parser_timer;
33#else
34    void * parser_timer;
35#endif
36
37//////////////////////////////////////////////////////////////////////////////////////////
38// Buffer Management // WARNING: Do Not update #defines. Results in TagMatcher errors.
39//////////////////////////////////////////////////////////////////////////////////////////
40#define PADDING_BLOCKS 0
41#define PADDING_SIZE (BLOCK_SIZE * PADDING_BLOCKS)
42#define COPYBACK_BLOCKS 2
43#define COPYBACK_SIZE (BLOCK_SIZE * COPYBACK_BLOCKS)
44#define LOOKAHEAD_BLOCKS 1
45#define LOOKAHEAD_SIZE (BLOCK_SIZE * LOOKAHEAD_BLOCKS)
46#define SEGMENT_BLOCKS  12 // WARNING: TagMatcher.hpp causes xmlconf test suite failures for SEGMENT_BLOCKS < 3.
47#define SEGMENT_SIZE (BLOCK_SIZE * SEGMENT_BLOCKS)
48#define BUFFER_SIZE (COPYBACK_SIZE + SEGMENT_SIZE + LOOKAHEAD_SIZE + PADDING_SIZE)
49
50//////////////////////////////////////////////////////////////////////////////////////////
51// @ global depends on 'error_tracker' and 'EOF_mask' definitions.
52//////////////////////////////////////////////////////////////////////////////////////////
53@global
54
55//////////////////////////////////////////////////////////////////////////////////////////
56// Headers that depend @ global stream struct types.
57//////////////////////////////////////////////////////////////////////////////////////////
58#include <simd-lib/transpose.hpp>
59
60
61
62
63void print_register2(const char * var_name, BitBlock v, int length) {
64        unsigned char c;
65        printf("%10s = ", var_name);
66        for(int i=0;i<=(length+7)/8; i++) {
67                c = *(((unsigned char *)&v)+i);
68                int count = 0;
69                while (count < 8) {
70                        if ((c % 2)==1)
71                        {
72                                printf("1");
73                        }
74                        else {
75                                printf("0");
76                        }
77                        c = c / 2;
78                        count+=1;
79                }
80        }
81        printf("\n");
82}
83
84
85
86static void do_process(FILE *infile, FILE *outfile);
87
88int main(int argc, char * argv[]) {
89
90        char * infilename, * outfilename;
91        FILE *infile, *outfile;
92        struct stat fileinfo;
93
94        if (argc < 2) {
95                printf("Usage: %s <filename> [<outputfile>]\n", argv[0]);
96                exit(-1);
97        }
98
99        infilename = argv[1];
100        stat(infilename, &fileinfo);
101        infile = fopen(infilename, "rb");
102        if (!infile) {
103                fprintf(stderr, "Error: cannot open %s for input.\n", infilename);
104                exit(-1);
105        }
106
107        if (argc < 3) outfile = stdout;
108        else {
109                outfilename = argv[2];
110                outfile = fopen(outfilename, "wb");
111                if (!outfile) {
112                        fprintf(stderr, "Error: cannot open %s for writing.\n", outfilename);
113                        exit(-1);
114                }
115        }
116
117        PERF_SEC_BIND(1);
118
119        PERF_SEC_INIT(parser_timer);
120
121        do_process(infile, outfile);
122
123        PERF_SEC_DUMP(parser_timer);
124
125        PERF_SEC_DESTROY(parser_timer);
126
127        fclose(infile);
128        fclose(outfile);
129
130        return(0);
131}
132
133void do_process(FILE *infile, FILE *outfile) {
134
135    @decl
136        ForwardScanner<BitBlock, ScanWord> match_scanner;
137        ForwardScanner<BitBlock, ScanWord> line_scanner;
138bool line_match_found=false;
139
140
141        int match_count=0;
142    int block_base  = 0;
143                int block_pos   = 0;
144    int buffer_base = 0;
145    int buffer_pos  = 0;
146    int chars_avail = 0;
147                int chars_read  = 0;
148
149    //////////////////////////////////////////////////////////////////////////////////////////
150    // Buffer Management
151    //////////////////////////////////////////////////////////////////////////////////////////
152                //      BitBlock buf[(BUFFER_SIZE)/sizeof(BitBlock)];
153                //      uint8_t * src_buffer = (uint8_t *)buf + COPYBACK_SIZE;
154
155                #ifdef STL_ALIGNED_VECTOR
156                        std::vector<uint8_t, AAllocator<uint8_t> > src_buffer;
157                        src_buffer.reserve(BUFFER_SIZE);
158                #else
159                        uint8_t * COPYBACK;
160                        uint8_t * src_buffer;
161                        ALLOC_STATIC_ALIGNED_BYTE_BUFFER_WITH_COPYBACK(COPYBACK, src_buffer);
162                #endif
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
169        //////////////////////////////////////////////////////////////////////////////////////////
170        // Read OVERLAP bytes to support post processing validation lookahead.
171        //////////////////////////////////////////////////////////////////////////////////////////
172        chars_read = chars_avail + fread(&src_buffer[chars_avail], 1, LOOKAHEAD_SIZE, infile);
173        chars_avail = chars_read;
174        if (chars_avail >= SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
175
176    @stream_stmts
177
178    //////////////////////////////////////////////////////////////////////////////////////////
179    // Full Segments
180    //////////////////////////////////////////////////////////////////////////////////////////
181       
182        while (chars_avail >= SEGMENT_SIZE) {
183      PERF_SEC_START(parser_timer);
184      for (int blk = 0; blk < SEGMENT_BLOCKS; blk++) {
185          block_base = blk*BLOCK_SIZE;
186                  s2p_do_block((BytePack *) &src_buffer[block_base], basis_bits);
187
188          @block_stmts
189//print_register2("Matches",output.matches,128);
190
191match_scanner.init(&output.matches);
192line_scanner.init(&lex.LF);
193match_scanner.scan_to_next();
194line_scanner.scan_to_next();
195while(!(match_scanner.is_done() || line_scanner.is_done())) {
196        if (line_scanner.get_pos()<match_scanner.get_pos()-1) {
197                line_match_found=false;
198                line_scanner.scan_to_next();
199        } else {
200                if (!line_match_found) {
201                        match_count++;
202                        //printf("Match7 at: %d\n",match_scanner.get_pos());
203                        line_match_found=true;
204                }
205                match_scanner.scan_to_next();
206        }
207
208}
209if (!line_scanner.is_done()) {
210        line_match_found=false;
211} else if (!match_scanner.is_done()) {
212        if (!line_match_found) {
213                match_count++;
214                        //printf("Match8 at: %d\n",match_scanner.get_pos());
215                line_match_found=true;
216        }
217
218}
219
220//print_register2("Matches",output.matches, 128);
221      }
222      PERF_SEC_END(parser_timer, chars_avail);
223
224          memmove(&src_buffer[0], &src_buffer[SEGMENT_SIZE], LOOKAHEAD_SIZE); // CopyBack Trailing Padding
225
226          chars_read = fread(&src_buffer[LOOKAHEAD_SIZE], 1, SEGMENT_SIZE, infile) + LOOKAHEAD_SIZE;
227          chars_avail = chars_read;
228          if (chars_avail >= SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
229          buffer_pos += chars_avail;
230          buffer_base = buffer_pos;
231    }
232
233    //////////////////////////////////////////////////////////////////////////////////////////
234    // Final Partial Segment
235    //////////////////////////////////////////////////////////////////////////////////////////
236    PERF_SEC_START(parser_timer);
237
238    block_pos = 0;
239    int remaining = chars_avail;
240
241    /* Full Blocks */
242    while (remaining >= BLOCK_SIZE) {
243          block_base = block_pos;
244                                s2p_do_block((BytePack *) &src_buffer[block_pos], basis_bits);
245                                @block_stmts
246//print_register2("Matches",output.matches,128);
247match_scanner.init(&output.matches);
248line_scanner.init(&lex.LF);
249match_scanner.scan_to_next();
250line_scanner.scan_to_next();
251while(!(match_scanner.is_done() || line_scanner.is_done())) {
252        if (line_scanner.get_pos()<match_scanner.get_pos()-1) {
253                line_match_found=false;
254                line_scanner.scan_to_next();
255        } else {
256                if (!line_match_found) {
257                        match_count++;
258                        //printf("Match3 at: %d\n",match_scanner.get_pos());
259                        line_match_found=true;
260                }
261                match_scanner.scan_to_next();
262        }
263
264}
265if (!line_scanner.is_done()) {
266        line_match_found=false;
267} else if (!match_scanner.is_done()) {
268        if (!line_match_found) {
269                match_count++;
270                        //printf("Match5 at: %d\n",match_scanner.get_pos());
271                line_match_found=true;
272        }
273
274}
275
276
277
278                                //print_register2("Matches",output.matches,128);
279       block_pos += BLOCK_SIZE;
280          remaining -= BLOCK_SIZE;
281    }
282    block_base = block_pos;
283
284//    Partial Block or Any Carry
285//
286//    Eliminatinthe @anycarry test simplifies dependencies. - RDC Nov. 6, 2012
287//
288#ifdef USE_ANY_CARRY_TEST
289   if (remaining > 0 || @any_carry) {
290#endif
291          EOF_mask = bitblock::srl(simd<1>::constant<1>(), convert(BLOCK_SIZE-remaining));
292                                s2p_do_final_block((BytePack *) &src_buffer[block_pos], basis_bits, EOF_mask);
293          @final_block_stmts
294//print_register2("Matches",output.matches,128);
295match_scanner.init(&output.matches);
296line_scanner.init(&lex.LF);
297match_scanner.scan_to_next();
298line_scanner.scan_to_next();
299while(!(match_scanner.is_done() || line_scanner.is_done())) {
300        if (line_scanner.get_pos()<match_scanner.get_pos()-1) {
301                line_match_found=false;
302                line_scanner.scan_to_next();
303        } else {
304                if (!line_match_found) {
305                        match_count++;
306                        //printf("Match at: %d\n",match_scanner.get_pos());
307                        line_match_found=true;
308                }
309                match_scanner.scan_to_next();
310        }
311
312}
313if (!line_scanner.is_done()) {
314        line_match_found=false;
315} else if (!match_scanner.is_done()) {
316        if (!line_match_found) {
317                match_count++;
318                        //printf("Match2 at: %d\n",match_scanner.get_pos());
319                line_match_found=true;
320        }
321
322}
323
324//print_register2("Matches",output.matches,128);
325#ifdef USE_ANY_CARRY_TEST
326   }
327#endif
328
329    buffer_pos += chars_avail;
330    buffer_base = buffer_pos;
331
332                PERF_SEC_END(parser_timer, chars_avail);
333printf("Matching Lines:%d\n",match_count);
334}
335
Note: See TracBrowser for help on using the repository browser.