source: proto/PDF/cb_template.cpp @ 2905

Last change on this file since 2905 was 2905, checked in by lindanl, 6 years ago

Add Comment Parsing. Compiler for nested while loop needs to be fixed.

File size: 11.7 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
7#define LocalCarryDeclare(name, count)\
8CarryArray<count, 0> name;\
9
10#include "../../simd-lib/bitblock.hpp"
11#include "../../simd-lib/carryQ.hpp"
12#include "../../simd-lib/bitblock_iterator.hpp"
13#include "../../simd-lib/pabloSupport.hpp"
14#include "../../simd-lib/s2p.hpp"
15#include "../../simd-lib/p2s.hpp"
16#include <math.h>
17
18#include "../../simd-lib/perflib/perfsec.h"
19using namespace std;
20#include <iostream>
21
22
23#ifdef BUFFER_PROFILING
24        BOM_Table * parser_timer;
25
26#elif CODE_CLOCKER
27        #define NUM_EVENTS 1
28        int Events[NUM_EVENTS] = {PAPI_TOT_CYC};
29        //int Events[NUM_EVENTS] = {PAPI_L2_DCM};
30        //int Events[NUM_EVENTS] = {PAPI_TOT_CYC, PAPI_BR_MSP};
31        int cal_size = 20;
32        CC * parser_timer = new CC(Events,NUM_EVENTS,cal_size);
33#else
34        void * parser_timer;
35#endif
36
37BitBlock EOF_mask = simd<1>::constant<1>();
38
39int pow_ten[8] = {1,10,100,1000,10000,100000,1000000,10000000};
40
41
42static inline int Digit_postprocessing(char * source, int pos);
43
44@global
45
46static inline void s2p_do_block(BytePack U8[], Basis_bits & basis_bits);
47static inline void s2p_do_final_block(BytePack U8[], Basis_bits & basis_bits, BitBlock EOF_mask);
48
49void do_process(FILE *infile, FILE *outfile, int filesize);
50
51#define MAX_NUM 1000000
52int numbers[MAX_NUM];
53int dec_pl[MAX_NUM];
54int num_idx=0;
55
56
57static inline int Digit_postprocessing(char * source, int pos) {
58    bool negative= false;
59    int num = 0;
60    int start_pos = -1;
61    if (source[pos] == '-')     {
62      pos++;
63      negative = true;
64    }
65    else if (source[pos] == '+')
66      pos++;
67
68    while ('0' <= source[pos] && source[pos] <= '9' || source[pos]=='.'){
69      if(source[pos]=='.'){
70        pos++;
71        start_pos = pos;
72        continue;
73      }
74      num = num * 10 + source[pos] - '0';
75      pos++;
76    }
77    if (negative) (num) = -(num);
78    numbers[num_idx] = num;
79    if(start_pos!=-1)
80      dec_pl[num_idx] = pow_ten[pos - start_pos];
81    else
82      dec_pl[num_idx] = 1;
83    num_idx++;
84}
85
86int main(int argc, char * argv[]) {
87
88        char * infilename, * outfilename;
89        FILE *infile, *outfile;
90        struct stat fileinfo;
91
92        if (argc < 2) {
93                printf("Usage: %s <filename> [<outputfile>]\n", argv[0]);
94                exit(-1);
95        }
96
97        infilename = argv[1];
98        stat(infilename, &fileinfo);
99        infile = fopen(infilename, "rb");
100        if (!infile) {
101                fprintf(stderr, "Error: cannot open %s for input.\n", infilename);
102                exit(-1);
103        }
104
105        if (argc < 3) outfile = stdout;
106        else {
107                outfilename = argv[2];
108                outfile = fopen(outfilename, "wb");
109                if (!outfile) {
110                        fprintf(stderr, "Error: cannot open %s for writing.\n", outfilename);
111                        exit(-1);
112                }
113        }
114
115//      PERF_SEC_BIND(1);
116
117        PERF_SEC_INIT(parser_timer);
118
119        do_process(infile, outfile, fileinfo.st_size+1);
120
121        PERF_SEC_DUMP(parser_timer);
122
123        PERF_SEC_DESTROY(parser_timer);
124
125        fclose(infile);
126        fclose(outfile);
127
128        return(0);
129}
130
131/* s2p Definitions */
132static inline void s2p_do_block(BytePack U8[], Basis_bits & basis_bits) {
133  s2p(U8[0], U8[1], U8[2], U8[3], U8[4], U8[5], U8[6], U8[7],
134        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);
135}
136
137static inline void s2p_do_final_block(BytePack U8[], Basis_bits & basis_bits, BitBlock EOF_mask) {
138  s2p_do_block(U8, basis_bits);
139  basis_bits.bit_0 = simd_and(basis_bits.bit_0, EOF_mask);
140  basis_bits.bit_1 = simd_and(basis_bits.bit_1, EOF_mask);
141  basis_bits.bit_2 = simd_and(basis_bits.bit_2, EOF_mask);
142  basis_bits.bit_3 = simd_and(basis_bits.bit_3, EOF_mask);
143  basis_bits.bit_4 = simd_and(basis_bits.bit_4, EOF_mask);
144  basis_bits.bit_5 = simd_and(basis_bits.bit_5, EOF_mask);
145  basis_bits.bit_6 = simd_and(basis_bits.bit_6, EOF_mask);
146  basis_bits.bit_7 = simd_and(basis_bits.bit_7, EOF_mask);
147}
148
149#define do_right16_shifts(vec,rshift1,rshift2,rshift4,rshift8)  \
150{BitBlock s2; \
151vec= simd<16>::sub(vec,simd<16>::srli<1>(simd_and(rshift1,vec)) ) ; \
152s2= simd_and(rshift2,vec) ; \
153vec= simd_or(simd<16>::srli<2>(s2) ,simd_xor(vec,s2) ) ; \
154s2= simd_and(rshift4,vec) ; \
155vec= simd_or(simd<16>::srli<4>(s2) ,simd_xor(vec,s2) ) ; \
156s2= simd_and(rshift8,vec) ; \
157vec= simd_or(simd<16>::srli<8>(s2) ,simd_xor(vec,s2) ) ; \
158}
159
160static inline void delinfo_16(BitBlock & del16_rshift1, BitBlock & del16_rshift2, BitBlock & del16_rshift4,
161                              BitBlock & del16_rshift8, BitBlock delmask){
162       
163        BitBlock del16_trans2;
164        BitBlock del16_trans4;
165        BitBlock del16_trans8;
166        BitBlock shift_bits;
167       
168        del16_rshift1= simd_xor(simd<16>::slli<1>(delmask),simd<16>::slli<2>(delmask));
169        del16_rshift1= simd_xor(del16_rshift1,simd<16>::slli<2>(del16_rshift1));
170        del16_rshift1= simd_xor(del16_rshift1,simd<16>::slli<4>(del16_rshift1));
171        del16_rshift1= simd_xor(del16_rshift1,simd<16>::slli<8>(del16_rshift1));
172       
173        del16_trans2= simd_and(del16_rshift1,delmask);
174        del16_rshift2= simd_xor(simd<16>::slli<1>(del16_trans2),simd<16>::slli<2>(del16_trans2));
175        del16_rshift2= simd_xor(del16_rshift2,simd<16>::slli<2>(del16_rshift2));
176        del16_rshift2= simd_xor(del16_rshift2,simd<16>::slli<4>(del16_rshift2));
177        del16_rshift2= simd_xor(del16_rshift2,simd<16>::slli<8>(del16_rshift2));
178       
179        del16_trans4= simd_and(del16_rshift2,del16_trans2);
180        del16_rshift4= simd_xor(simd<16>::slli<1>(del16_trans4),simd<16>::slli<2>(del16_trans4));
181        del16_rshift4= simd_xor(del16_rshift4,simd<16>::slli<2>(del16_rshift4));
182        del16_rshift4= simd_xor(del16_rshift4,simd<16>::slli<4>(del16_rshift4));
183        del16_rshift4= simd_xor(del16_rshift4,simd<16>::slli<8>(del16_rshift4));
184       
185        del16_trans8= simd_and(del16_rshift4,del16_trans4);
186        del16_rshift8= simd_xor(simd<16>::slli<1>(del16_trans8),simd<16>::slli<2>(del16_trans8));
187        del16_rshift8= simd_xor(del16_rshift8,simd<16>::slli<2>(del16_rshift8));
188        del16_rshift8= simd_xor(del16_rshift8,simd<16>::slli<4>(del16_rshift8));
189        del16_rshift8= simd_xor(del16_rshift8,simd<16>::slli<8>(del16_rshift8));
190       
191        del16_rshift1= simd_andc(del16_rshift1,delmask);
192        del16_rshift2= simd_andc(del16_rshift2,delmask);
193        del16_rshift4= simd_andc(del16_rshift4,delmask);
194        del16_rshift8= simd_andc(del16_rshift8,delmask);
195       
196        del16_rshift2= simd<16>::sub(del16_rshift2,simd<16>::srli<1>(simd_and(del16_rshift1,del16_rshift2)));
197       
198        del16_rshift4= simd<16>::sub(del16_rshift4,simd<16>::srli<1>(simd_and(del16_rshift1,del16_rshift4)));
199        shift_bits= simd_and(del16_rshift2,del16_rshift4);
200        del16_rshift4= simd_or(simd<16>::srli<2>(shift_bits),simd_xor(del16_rshift4,shift_bits));
201       
202        del16_rshift8= simd<16>::sub(del16_rshift8,simd<16>::srli<1>(simd_and(del16_rshift1,del16_rshift8)));
203        shift_bits= simd_and(del16_rshift2,del16_rshift8);
204        del16_rshift8= simd_or(simd<16>::srli<2>(shift_bits),simd_xor(del16_rshift8,shift_bits));       
205        shift_bits= simd_and(del16_rshift4,del16_rshift8);
206        del16_rshift8= simd_or(simd<16>::srli<4>(shift_bits),simd_xor(del16_rshift8,shift_bits));
207}
208
209static inline void del_count(BitBlock delmask, BitBlock & u8_bytes_per_reg){
210
211        BitBlock delcounts_16 = simd<16>::popcount(delmask);
212        u8_bytes_per_reg = simd<16>::sub(simd<16>::constant<16>(), delcounts_16);
213}
214
215static inline void Build_ContentBuffer(Out_Callouts out_Callouts, char * content_buf, char ** content_buf_ptr){
216   
217    BytePack S[8];
218   
219    if (bitblock::any(out_Callouts.delmask)) {
220            BitBlock shift1, shift2, shift4, shift8;
221            delinfo_16(shift1, shift2, shift4, shift8, out_Callouts.delmask);
222            do_right16_shifts(out_Callouts.bit_0, shift1, shift2, shift4, shift8);
223            do_right16_shifts(out_Callouts.bit_1, shift1, shift2, shift4, shift8);
224            do_right16_shifts(out_Callouts.bit_2, shift1, shift2, shift4, shift8);
225            do_right16_shifts(out_Callouts.bit_3, shift1, shift2, shift4, shift8);
226            do_right16_shifts(out_Callouts.bit_4, shift1, shift2, shift4, shift8);
227            do_right16_shifts(out_Callouts.bit_5, shift1, shift2, shift4, shift8);
228            do_right16_shifts(out_Callouts.bit_6, shift1, shift2, shift4, shift8);
229            do_right16_shifts(out_Callouts.bit_7, shift1, shift2, shift4, shift8);
230        }
231
232        union {BitBlock i128; uint16_t i8[8];} units_per_reg;
233       
234        p2s(out_Callouts.bit_0,out_Callouts.bit_1,out_Callouts.bit_2,out_Callouts.bit_3,
235            out_Callouts.bit_4,out_Callouts.bit_5,out_Callouts.bit_6,out_Callouts.bit_7,
236                          S[0], S[1],S[2] ,S[3] ,S[4] ,S[5] ,S[6] ,S[7]);
237         
238        for(int k=0; k<8; k++) units_per_reg.i8[k] = 0;
239        del_count(out_Callouts.delmask,units_per_reg.i128);
240//      for(int k=0; k<8; k++)
241//        printf("delcount=%i\n",units_per_reg.i8[k]);
242
243        for(int j=0; j<8; j++){
244          bitblock::store_unaligned(S[j], (BytePack *) *content_buf_ptr);
245          *content_buf_ptr += units_per_reg.i8[j];
246        }
247}
248
249static inline void Postprocessing(char* src, Marker marker){   
250 
251    if(bitblock::any(marker.numeric_starts)){
252      BitBlockForwardIterator iter;
253      iter.init(&(marker.numeric_starts));
254      BitBlockForwardIterator iter_end;
255      while(iter != iter_end) {
256          Digit_postprocessing(src, *iter);
257          iter++;
258      }
259    }
260}
261
262void do_process(FILE *infile, FILE *outfile, int filesize) {
263 
264  int BLOCKS = filesize/BLOCK_SIZE+1;
265
266  struct Basis_bits * basis_bits = (struct Basis_bits *)malloc(sizeof(struct Basis_bits)*BLOCKS);
267
268  struct Lex * lex = (struct Lex *)malloc(sizeof(struct Lex)*BLOCKS);
269 
270  struct Parity parity;
271
272  struct Escape_Callouts escape_Callouts;
273
274  struct Out_Callouts out_Callouts;
275
276  struct Marker marker;
277
278  int block_base = 0;
279  int chars_read = 0;
280  int chars_avail = 0;
281  char * srcbuf = (char*)malloc(filesize);
282  char * content_buf = (char*)malloc(filesize);
283  char * content_buf_ptr =  content_buf;
284
285  parity.odd = simd<2>::constant<1>();
286  parity.even = simd<2>::constant<2>();
287 
288
289  chars_read = fread((void *)srcbuf, 1, filesize, infile);
290  chars_avail = chars_read;
291
292@stream_stmts
293
294
295    PERF_SEC_START(parser_timer);
296   
297    for (int i = 0; i < BLOCKS; i++){
298      s2p_do_block((BytePack *) &srcbuf[i*BLOCK_SIZE], basis_bits[i]);
299      classify_bytes.do_block(basis_bits[i], lex[i]);
300    }
301   
302    for (int i = 0; i < BLOCKS-1; i++){
303      parse_Escaped.do_block(lex[i], parity, escape_Callouts, out_Callouts, lex[i+1]);
304      parse_Comment.do_block(lex[i], escape_Callouts, marker, out_Callouts);
305      parse_HexStrings.do_block(lex[i], marker, out_Callouts);
306      parse_Names.do_block(lex[i], marker, out_Callouts, lex[i+1]);
307      parse_Numeric.do_block(lex[i], marker, out_Callouts);
308      prepare_content_buffer.do_block(basis_bits[i], lex[i], marker, parity, escape_Callouts, out_Callouts, lex[i+1]);
309      Build_ContentBuffer(out_Callouts, content_buf, &content_buf_ptr);
310      Postprocessing(&srcbuf[i*BLOCK_SIZE], marker);
311    }
312   
313    /*final block*/
314    EOF_mask = bitblock::srl(simd<1>::constant<1>(), convert(BLOCK_SIZE-chars_avail));
315    parse_Escaped.do_final_block(lex[BLOCKS-1], parity, escape_Callouts, out_Callouts, EOF_mask);
316    parse_Comment.do_final_block(lex[BLOCKS-1], escape_Callouts, marker, out_Callouts, EOF_mask);
317    parse_HexStrings.do_final_block(lex[BLOCKS-1], marker, out_Callouts, EOF_mask);
318    parse_Names.do_final_block(lex[BLOCKS-1], marker, out_Callouts, EOF_mask);
319    parse_Numeric.do_block(lex[BLOCKS-1], marker, out_Callouts);
320    prepare_content_buffer.do_final_block(basis_bits[BLOCKS-1], lex[BLOCKS-1], marker, parity, escape_Callouts, out_Callouts, EOF_mask);
321    out_Callouts.delmask |= ~EOF_mask;         
322    Build_ContentBuffer(out_Callouts, content_buf, &content_buf_ptr);
323    Postprocessing(&srcbuf[(BLOCKS-1)*BLOCK_SIZE], marker);
324
325//     print_register("out_Callouts.comment",out_Callouts.comment);
326   
327//     for(int i=0;i<num_idx;i++)
328//       printf("%i,%i\n",numbers[i],dec_pl[i]);
329 
330    PERF_SEC_END(parser_timer, chars_read);
331   
332    fwrite(content_buf, 1, content_buf_ptr-content_buf, outfile);
333
334}
335
Note: See TracBrowser for help on using the repository browser.