source: proto/RE2PBS/src/demo.cpp @ 1906

Last change on this file since 1906 was 1906, checked in by cameron, 7 years ago

Clear out cfzl/cfbl.

File size: 12.8 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#include "../lib/lib_simd.h"
7
8#define BLOCK_SIZE (sizeof(SIMD_type) * 8)
9#define SEGMENT_BLOCKS 12
10#define BUFFER_SIZE (BLOCK_SIZE * SEGMENT_BLOCKS)
11#define OVERLAP_BUFSIZE (sizeof(SIMD_type))
12
13#include "../lib/builtins.hpp"
14#include "../lib/carryQ.h"
15#include "../lib/perflib/perfsec.h"
16#include "../lib/s2p.h"
17//#include "LineColTracker.h"
18
19#ifdef BUFFER_PROFILING
20        BOM_Table * parser_timer;
21
22#elif CODE_CLOCKER
23        #define NUM_EVENTS 1
24        int Events[NUM_EVENTS] = {PAPI_TOT_CYC};
25        //int Events[NUM_EVENTS] = {PAPI_L2_DCM};
26        //int Events[NUM_EVENTS] = {PAPI_TOT_CYC, PAPI_BR_MSP};
27        int cal_size = 20;
28        CC * parser_timer = new CC(Events,NUM_EVENTS,cal_size);
29#else
30        void * parser_timer;
31#endif
32
33int block_base=0;
34int buffer_base=0;
35int buffer_last;
36char * source;
37LineColTracker tracker;
38BitBlock EOF_mask = simd_const_1(1);
39
40static inline int StreamScan(ScanBlock * stream, int blk_count, int ProcessPos(int)) {
41        int blk;
42        int block_pos = 0;
43
44        for (blk = 0; blk < blk_count; blk++) {
45                scanword_t s = stream[blk];
46                while(s) {
47                        int code = (ProcessPos(scan_forward_zeroes(s) + block_pos));
48                        if (code) return code;
49                        s = s & (s-1);  // clear rightmost bit.
50                }
51                block_pos += 8 * sizeof(ScanBlock);
52        }
53        return 0;
54}
55
56static inline void ReportError(const char * error_msg, int error_pos_in_block) {
57  int error_line, error_column;
58  tracker.get_Line_and_Column(error_pos_in_block, error_line, error_column);
59  fprintf(stderr, "%s at line %i, column %i\n", error_msg, error_line, error_column);
60}
61
62  struct Basis_bits {
63  BitBlock bit_0;
64  BitBlock bit_1;
65  BitBlock bit_2;
66  BitBlock bit_3;
67  BitBlock bit_4;
68  BitBlock bit_5;
69  BitBlock bit_6;
70  BitBlock bit_7;
71};
72
73  struct Lex {
74  BitBlock s35;
75  BitBlock s48__57;
76  BitBlock s120;
77  BitBlock s38;
78  BitBlock s59;
79};
80
81  struct Classify_bytes {
82 
83  void do_block(Basis_bits & basis_bits, Lex & lex) {
84                BitBlock temp1, temp2, temp3, temp4, temp5, temp6, temp7, temp8, temp9, temp10;
85                BitBlock temp11, temp12, temp13, temp14, temp15, temp16, temp17, temp18;
86                BitBlock temp19;
87
88
89        temp1 = simd_or(basis_bits.bit_0, basis_bits.bit_1);
90        temp2 = simd_andc(basis_bits.bit_2, basis_bits.bit_3);
91        temp3 = simd_andc(temp2, temp1);
92        temp4 = simd_or(basis_bits.bit_4, basis_bits.bit_5);
93        temp5 = simd_and(basis_bits.bit_6, basis_bits.bit_7);
94        temp6 = simd_andc(temp5, temp4);
95        lex.s35 = simd_and(temp3, temp6);
96        temp7 = simd_and(basis_bits.bit_2, basis_bits.bit_3);
97        temp8 = simd_andc(temp7, temp1);
98        temp9 = simd_or(basis_bits.bit_5, basis_bits.bit_6);
99        temp10 = simd_and(basis_bits.bit_4, temp9);
100        lex.s48__57 = simd_andc(temp8, temp10);
101        temp11 = simd_andc(basis_bits.bit_1, basis_bits.bit_0);
102        temp12 = simd_and(temp11, temp7);
103        temp13 = simd_andc(basis_bits.bit_4, basis_bits.bit_5);
104        temp14 = simd_or(basis_bits.bit_6, basis_bits.bit_7);
105        temp15 = simd_andc(temp13, temp14);
106        lex.s120 = simd_and(temp12, temp15);
107        temp16 = simd_andc(basis_bits.bit_5, basis_bits.bit_4);
108        temp17 = simd_andc(basis_bits.bit_6, basis_bits.bit_7);
109        temp18 = simd_and(temp16, temp17);
110        lex.s38 = simd_and(temp3, temp18);
111        temp19 = simd_and(temp13, temp5);
112        lex.s59 = simd_and(temp8, temp19);
113        return lex;
114  }
115  void do_final_block(Basis_bits & basis_bits, Lex & lex, BitBlock EOF_mask) {
116                BitBlock temp1, temp2, temp3, temp4, temp5, temp6, temp7, temp8, temp9, temp10;
117                BitBlock temp11, temp12, temp13, temp14, temp15, temp16, temp17, temp18;
118                BitBlock temp19;
119
120
121        temp1 = simd_or(basis_bits.bit_0, basis_bits.bit_1);
122        temp2 = simd_andc(basis_bits.bit_2, basis_bits.bit_3);
123        temp3 = simd_andc(temp2, temp1);
124        temp4 = simd_or(basis_bits.bit_4, basis_bits.bit_5);
125        temp5 = simd_and(basis_bits.bit_6, basis_bits.bit_7);
126        temp6 = simd_andc(temp5, temp4);
127        lex.s35 = simd_and(temp3, temp6);
128        temp7 = simd_and(basis_bits.bit_2, basis_bits.bit_3);
129        temp8 = simd_andc(temp7, temp1);
130        temp9 = simd_or(basis_bits.bit_5, basis_bits.bit_6);
131        temp10 = simd_and(basis_bits.bit_4, temp9);
132        lex.s48__57 = simd_andc(temp8, temp10);
133        temp11 = simd_andc(basis_bits.bit_1, basis_bits.bit_0);
134        temp12 = simd_and(temp11, temp7);
135        temp13 = simd_andc(basis_bits.bit_4, basis_bits.bit_5);
136        temp14 = simd_or(basis_bits.bit_6, basis_bits.bit_7);
137        temp15 = simd_andc(temp13, temp14);
138        lex.s120 = simd_and(temp12, temp15);
139        temp16 = simd_andc(basis_bits.bit_5, basis_bits.bit_4);
140        temp17 = simd_andc(basis_bits.bit_6, basis_bits.bit_7);
141        temp18 = simd_and(temp16, temp17);
142        lex.s38 = simd_and(temp3, temp18);
143        temp19 = simd_and(temp13, temp5);
144        lex.s59 = simd_and(temp8, temp19);
145        return lex;
146  }
147  void do_segment(Basis_bits basis_bits[], Lex lex[]) {
148  for (int i = 0; i < SEGMENT_BLOCKS; i++)
149    do_block(basis_bits[i], lex[i]);
150  }
151 
152  };
153
154  struct Demo {
155  Demo() { CarryInit(carryQ, 7); }
156  void do_block(U8data & u8data, Lex & lex) {
157                BitBlock error_1_0, cursor_1_0, error_1_1, cursor_1_1, cursor_1_2, error_1_2;
158                BitBlock cursor_1_3, cursor_1_4, error_1_3, cursor_1_5, cursor_1_6, error_1_4;
159                BitBlock cursor_1_7, cursor_1_8, cursor_1_9, error_1_5, cursor_1_10;
160                BitBlock cursor_1_11, error_1_6;
161
162
163        error_1_0 = simd_const_1(0);
164        cursor_1_0 = simd_andc(lex.s38, BitBlock_advance_ci_co(lex.s38, carryQ, 0));
165        error_1_1 = simd_andc(cursor_1_0, lex.s38);
166        cursor_1_1 = simd_andc(cursor_1_0, error_1_1);
167        cursor_1_2 = BitBlock_advance_ci_co(cursor_1_1, carryQ, 1);
168        error_1_2 = simd_andc(cursor_1_2, lex.s35);
169        cursor_1_3 = simd_andc(cursor_1_2, error_1_2);
170        cursor_1_4 = BitBlock_advance_ci_co(cursor_1_3, carryQ, 2);
171        error_1_3 = simd_andc(cursor_1_4, lex.s120);
172        cursor_1_5 = simd_andc(cursor_1_4, error_1_3);
173        cursor_1_6 = BitBlock_advance_ci_co(cursor_1_5, carryQ, 3);
174        error_1_4 = simd_andc(cursor_1_6, lex.s48__57);
175        cursor_1_7 = simd_andc(cursor_1_6, error_1_4);
176        cursor_1_8 = BitBlock_advance_ci_co(cursor_1_7, carryQ, 4);
177        cursor_1_9 = BitBlock_scanthru_ci_co(cursor_1_8, lex.s48__57, carryQ, 5);
178        error_1_5 = simd_andc(cursor_1_9, lex.s59);
179        cursor_1_10 = simd_andc(cursor_1_9, error_1_5);
180        cursor_1_11 = BitBlock_advance_ci_co(cursor_1_10, carryQ, 6);
181        error_1_6 = error_1_0;
182        error_1_6 = simd_or(error_1_6, error_1_1);
183        error_1_6 = simd_or(error_1_6, error_1_2);
184        error_1_6 = simd_or(error_1_6, error_1_3);
185        error_1_6 = simd_or(error_1_6, error_1_4);
186        error_1_6 = simd_or(error_1_6, error_1_5);
187        return;
188        CarryQ_Adjust(carryQ, 7);
189  }
190  void do_final_block(U8data & u8data, Lex & lex, BitBlock EOF_mask) {
191                BitBlock error_1_0, cursor_1_0, error_1_1, cursor_1_1, cursor_1_2, error_1_2;
192                BitBlock cursor_1_3, cursor_1_4, error_1_3, cursor_1_5, cursor_1_6, error_1_4;
193                BitBlock cursor_1_7, cursor_1_8, cursor_1_9, error_1_5, cursor_1_10;
194                BitBlock cursor_1_11, error_1_6;
195
196
197        error_1_0 = simd_const_1(0);
198        cursor_1_0 = simd_andc(lex.s38, BitBlock_advance_ci(lex.s38, carryQ, 0));
199        error_1_1 = simd_andc(cursor_1_0, lex.s38);
200        cursor_1_1 = simd_andc(cursor_1_0, error_1_1);
201        cursor_1_2 = BitBlock_advance_ci(cursor_1_1, carryQ, 1);
202        error_1_2 = simd_andc(cursor_1_2, lex.s35);
203        cursor_1_3 = simd_andc(cursor_1_2, error_1_2);
204        cursor_1_4 = BitBlock_advance_ci(cursor_1_3, carryQ, 2);
205        error_1_3 = simd_andc(cursor_1_4, lex.s120);
206        cursor_1_5 = simd_andc(cursor_1_4, error_1_3);
207        cursor_1_6 = BitBlock_advance_ci(cursor_1_5, carryQ, 3);
208        error_1_4 = simd_andc(cursor_1_6, lex.s48__57);
209        cursor_1_7 = simd_andc(cursor_1_6, error_1_4);
210        cursor_1_8 = BitBlock_advance_ci(cursor_1_7, carryQ, 4);
211        cursor_1_9 = BitBlock_scanthru_ci(cursor_1_8, lex.s48__57, carryQ, 5);
212        error_1_5 = simd_andc(cursor_1_9, lex.s59);
213        cursor_1_10 = simd_andc(cursor_1_9, error_1_5);
214        cursor_1_11 = BitBlock_advance_ci(cursor_1_10, carryQ, 6);
215        error_1_6 = error_1_0;
216        error_1_6 = simd_or(error_1_6, error_1_1);
217        error_1_6 = simd_or(error_1_6, error_1_2);
218        error_1_6 = simd_or(error_1_6, error_1_3);
219        error_1_6 = simd_or(error_1_6, error_1_4);
220        error_1_6 = simd_or(error_1_6, error_1_5);
221        return;
222  }
223  void do_segment(U8data u8data[], Lex lex[]) {
224  for (int i = 0; i < SEGMENT_BLOCKS; i++)
225    do_block(u8data[i], lex[i]);
226  }
227  CarryDeclare(carryQ, 7);
228  };
229
230
231
232static inline void s2p_do_block(BytePack U8[], Basis_bits & basis_bits) {
233  s2p(U8[0], U8[1], U8[2], U8[3], U8[4], U8[5], U8[6], U8[7],
234        basis_bits.bit_0, basis_bits.bit_1, basis_bits.bit_2, basis_bits.bit_3, basis_bits.bit_4, basis_bits.bit_5, basis_bits.bit_6, basis_bits.bit_7);
235}
236
237static inline void s2p_do_final_block(BytePack U8[], Basis_bits & basis_bits, BitBlock EOF_mask) {
238  s2p_do_block(U8, basis_bits);
239  basis_bits.bit_0 = simd_and(basis_bits.bit_0, EOF_mask);
240  basis_bits.bit_1 = simd_and(basis_bits.bit_1, EOF_mask);
241  basis_bits.bit_2 = simd_and(basis_bits.bit_2, EOF_mask);
242  basis_bits.bit_3 = simd_and(basis_bits.bit_3, EOF_mask);
243  basis_bits.bit_4 = simd_and(basis_bits.bit_4, EOF_mask);
244  basis_bits.bit_5 = simd_and(basis_bits.bit_5, EOF_mask);
245  basis_bits.bit_6 = simd_and(basis_bits.bit_6, EOF_mask);
246  basis_bits.bit_7 = simd_and(basis_bits.bit_7, EOF_mask);
247}
248
249void do_process(FILE *infile, FILE *outfile) {
250
251  struct Basis_bits basis_bits;
252
253  struct Lex lex;
254
255
256
257  int buf_pos = 0;
258  int block_pos = 0;
259  int errpos = 0;
260  int chars_avail = 0;
261  int check_pos = 0;
262  int chars_read = 0;
263  BytePack buf[(BUFFER_SIZE+BLOCK_SIZE+OVERLAP_BUFSIZE*2)/sizeof(SIMD_type)];
264
265  char * srcbuf = ((char *) buf) + OVERLAP_BUFSIZE;
266  buffer_base = buf_pos;
267  source = srcbuf;
268
269  chars_read = fread((void *)srcbuf, 1, BUFFER_SIZE + OVERLAP_BUFSIZE, infile);
270  chars_avail = chars_read;
271  if (chars_avail > BUFFER_SIZE) chars_avail = BUFFER_SIZE;
272
273  Classify_bytes classify_bytes;
274  Demo demo;
275
276
277/* Full Buffers */
278
279    while (chars_avail == BUFFER_SIZE) {
280      PERF_SEC_START(parser_timer);
281      for (int blk = 0; blk < SEGMENT_BLOCKS; blk++) {
282          block_base = blk*BLOCK_SIZE;
283          s2p_do_block((BytePack *) &srcbuf[block_base], basis_bits);
284         
285  classify_bytes.do_block(basis_bits, lex);
286  demo.do_block(lex, scope1);
287          //postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, chars_avail);
288      }
289      tracker.Advance_buffer();
290      PERF_SEC_END(parser_timer, chars_avail);
291           
292      int bytes_left = chars_read - chars_avail;
293      memmove(srcbuf, &srcbuf[BUFFER_SIZE], bytes_left);
294      chars_read = fread(&srcbuf[bytes_left],1, BUFFER_SIZE + OVERLAP_BUFSIZE - bytes_left, infile) + bytes_left;
295      chars_avail = chars_read;
296      if (chars_avail > BUFFER_SIZE) chars_avail = BUFFER_SIZE;
297      buf_pos += chars_avail;
298      buffer_base = buf_pos;
299    }
300/* Final Partial Buffer */
301    PERF_SEC_START(parser_timer);
302
303    block_pos = 0;
304    int remaining = chars_avail;
305/* Full Blocks */
306    while (remaining >= BLOCK_SIZE) {
307          block_base = block_pos;
308          s2p_do_block((BytePack *) &srcbuf[block_pos], basis_bits);
309         
310  classify_bytes.do_block(basis_bits, lex);
311  demo.do_block(lex, scope1);
312          postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, chars_avail);
313          block_pos += BLOCK_SIZE;
314          remaining -= BLOCK_SIZE;
315    }
316    block_base = block_pos;
317    if (remaining > 0 || CarryTest(demo.carryQ, 0, 7)) {
318          EOF_mask = sisd_srl(simd_const_1(1),sisd_from_int(BLOCK_SIZE-remaining));
319          s2p_do_final_block((BytePack *) &srcbuf[block_pos], basis_bits, EOF_mask);
320         
321  classify_bytes.do_final_block(basis_bits, lex, EOF_mask);
322  demo.do_final_block(lex, scope1, EOF_mask);
323          //postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, chars_avail);
324    }
325    buf_pos += chars_avail;
326    buffer_base = buf_pos;
327    tracker.Advance_buffer();
328
329    PERF_SEC_END(parser_timer, chars_avail);
330}
331
332int
333main(int argc, char * argv[]) {
334        char * infilename, * outfilename;
335        FILE *infile, *outfile;
336        struct stat fileinfo;
337
338        if (argc < 2) {
339                printf("Usage: %s <filename> [<outputfile>]\n", argv[0]);
340                exit(-1);
341        }
342
343        infilename = argv[1];
344        stat(infilename, &fileinfo);
345        infile = fopen(infilename, "rb");
346        if (!infile) {
347                fprintf(stderr, "Error: cannot open %s for input.\n", infilename);
348                exit(-1);
349        }
350
351        if (argc < 3) outfile = stdout;
352        else {
353                outfilename = argv[2];
354                outfile = fopen(outfilename, "wb");
355                if (!outfile) {
356                        fprintf(stderr, "Error: cannot open %s for writing.\n", outfilename);
357                        exit(-1);
358                }
359        }
360
361//      PERF_SEC_BIND(1);
362
363        PERF_SEC_INIT(parser_timer);
364
365        do_process(infile, outfile);
366
367        PERF_SEC_DUMP(parser_timer);
368
369        PERF_SEC_DESTROY(parser_timer);
370
371        fclose(infile);
372        fclose(outfile);
373        return(0);
374}
Note: See TracBrowser for help on using the repository browser.