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

Last change on this file since 1207 was 1207, checked in by ksherdy, 8 years ago

Added demo C file.

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