source: proto/PDF/cb_template.cpp @ 2911

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

Add token generation

File size: 14.0 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#include <vector>
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
41static inline int Digit_postprocessing(char * source, int pos);
42
43@global
44
45static inline void s2p_do_block(BytePack U8[], Basis_bits & basis_bits);
46static inline void s2p_do_final_block(BytePack U8[], Basis_bits & basis_bits, BitBlock EOF_mask);
47
48void do_process(FILE *infile, FILE *outfile, int filesize);
49
50enum PDFTokenType {
51  str_token,
52  hex_token,
53  name_token,
54  int_token,
55  flt_token,
56  kw_token
57};
58
59union PDFToken { char * char_ptr; int idx;};
60
61typedef struct tokenStruct{
62  union PDFToken token;
63  int len;
64  enum PDFTokenType type;
65} TokenStruct;
66
67TokenStruct tokenArray[1000000];
68int token_idx=0;
69
70#define MAX_NUM 1000000
71int numbers[MAX_NUM];
72int dec_pl[MAX_NUM];
73int num_idx=0;
74
75static inline int Digit_postprocessing(char * source, int pos) {
76    bool negative= false;
77    int num = 0;
78    int start_pos = -1;
79    if (source[pos] == '-')     {
80      pos++;
81      negative = true;
82    }
83    else if (source[pos] == '+')
84      pos++;
85
86    while ('0' <= source[pos] && source[pos] <= '9' || source[pos]=='.'){
87      if(source[pos]=='.'){
88        pos++;
89        start_pos = pos;
90        continue;
91      }
92      num = num * 10 + source[pos] - '0';
93      pos++;
94    }
95    if (negative) (num) = -(num);
96    numbers[num_idx] = num;
97    if(start_pos!=-1){
98      dec_pl[num_idx] = pow_ten[pos - start_pos];
99      tokenArray[token_idx].type = flt_token;
100      tokenArray[token_idx].token.idx = num_idx;
101    }
102    else{
103      dec_pl[num_idx] = 1;
104      tokenArray[token_idx].type = int_token;
105      tokenArray[token_idx].token.idx = num_idx;
106    }
107    num_idx++;
108}
109
110int main(int argc, char * argv[]) {
111
112        char * infilename, * outfilename;
113        FILE *infile, *outfile;
114        struct stat fileinfo;
115
116        if (argc < 2) {
117                printf("Usage: %s <filename> [<outputfile>]\n", argv[0]);
118                exit(-1);
119        }
120
121        infilename = argv[1];
122        stat(infilename, &fileinfo);
123        infile = fopen(infilename, "rb");
124        if (!infile) {
125                fprintf(stderr, "Error: cannot open %s for input.\n", infilename);
126                exit(-1);
127        }
128
129        if (argc < 3) outfile = stdout;
130        else {
131                outfilename = argv[2];
132                outfile = fopen(outfilename, "wb");
133                if (!outfile) {
134                        fprintf(stderr, "Error: cannot open %s for writing.\n", outfilename);
135                        exit(-1);
136                }
137        }
138
139//      PERF_SEC_BIND(1);
140
141        PERF_SEC_INIT(parser_timer);
142
143        do_process(infile, outfile, fileinfo.st_size+1);
144
145        PERF_SEC_DUMP(parser_timer);
146
147        PERF_SEC_DESTROY(parser_timer);
148
149        fclose(infile);
150        fclose(outfile);
151
152        return(0);
153}
154
155/* s2p Definitions */
156static inline void s2p_do_block(BytePack U8[], Basis_bits & basis_bits) {
157  s2p(U8[0], U8[1], U8[2], U8[3], U8[4], U8[5], U8[6], U8[7],
158        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);
159}
160
161static inline void s2p_do_final_block(BytePack U8[], Basis_bits & basis_bits, BitBlock EOF_mask) {
162  s2p_do_block(U8, basis_bits);
163  basis_bits.bit_0 = simd_and(basis_bits.bit_0, EOF_mask);
164  basis_bits.bit_1 = simd_and(basis_bits.bit_1, EOF_mask);
165  basis_bits.bit_2 = simd_and(basis_bits.bit_2, EOF_mask);
166  basis_bits.bit_3 = simd_and(basis_bits.bit_3, EOF_mask);
167  basis_bits.bit_4 = simd_and(basis_bits.bit_4, EOF_mask);
168  basis_bits.bit_5 = simd_and(basis_bits.bit_5, EOF_mask);
169  basis_bits.bit_6 = simd_and(basis_bits.bit_6, EOF_mask);
170  basis_bits.bit_7 = simd_and(basis_bits.bit_7, EOF_mask);
171}
172
173#define do_right16_shifts(vec,rshift1,rshift2,rshift4,rshift8)  \
174{BitBlock s2; \
175vec= simd<16>::sub(vec,simd<16>::srli<1>(simd_and(rshift1,vec)) ) ; \
176s2= simd_and(rshift2,vec) ; \
177vec= simd_or(simd<16>::srli<2>(s2) ,simd_xor(vec,s2) ) ; \
178s2= simd_and(rshift4,vec) ; \
179vec= simd_or(simd<16>::srli<4>(s2) ,simd_xor(vec,s2) ) ; \
180s2= simd_and(rshift8,vec) ; \
181vec= simd_or(simd<16>::srli<8>(s2) ,simd_xor(vec,s2) ) ; \
182}
183
184static inline void delinfo_16(BitBlock & del16_rshift1, BitBlock & del16_rshift2, BitBlock & del16_rshift4,
185                              BitBlock & del16_rshift8, BitBlock delmask){
186       
187        BitBlock del16_trans2;
188        BitBlock del16_trans4;
189        BitBlock del16_trans8;
190        BitBlock shift_bits;
191       
192        del16_rshift1= simd_xor(simd<16>::slli<1>(delmask),simd<16>::slli<2>(delmask));
193        del16_rshift1= simd_xor(del16_rshift1,simd<16>::slli<2>(del16_rshift1));
194        del16_rshift1= simd_xor(del16_rshift1,simd<16>::slli<4>(del16_rshift1));
195        del16_rshift1= simd_xor(del16_rshift1,simd<16>::slli<8>(del16_rshift1));
196       
197        del16_trans2= simd_and(del16_rshift1,delmask);
198        del16_rshift2= simd_xor(simd<16>::slli<1>(del16_trans2),simd<16>::slli<2>(del16_trans2));
199        del16_rshift2= simd_xor(del16_rshift2,simd<16>::slli<2>(del16_rshift2));
200        del16_rshift2= simd_xor(del16_rshift2,simd<16>::slli<4>(del16_rshift2));
201        del16_rshift2= simd_xor(del16_rshift2,simd<16>::slli<8>(del16_rshift2));
202       
203        del16_trans4= simd_and(del16_rshift2,del16_trans2);
204        del16_rshift4= simd_xor(simd<16>::slli<1>(del16_trans4),simd<16>::slli<2>(del16_trans4));
205        del16_rshift4= simd_xor(del16_rshift4,simd<16>::slli<2>(del16_rshift4));
206        del16_rshift4= simd_xor(del16_rshift4,simd<16>::slli<4>(del16_rshift4));
207        del16_rshift4= simd_xor(del16_rshift4,simd<16>::slli<8>(del16_rshift4));
208       
209        del16_trans8= simd_and(del16_rshift4,del16_trans4);
210        del16_rshift8= simd_xor(simd<16>::slli<1>(del16_trans8),simd<16>::slli<2>(del16_trans8));
211        del16_rshift8= simd_xor(del16_rshift8,simd<16>::slli<2>(del16_rshift8));
212        del16_rshift8= simd_xor(del16_rshift8,simd<16>::slli<4>(del16_rshift8));
213        del16_rshift8= simd_xor(del16_rshift8,simd<16>::slli<8>(del16_rshift8));
214       
215        del16_rshift1= simd_andc(del16_rshift1,delmask);
216        del16_rshift2= simd_andc(del16_rshift2,delmask);
217        del16_rshift4= simd_andc(del16_rshift4,delmask);
218        del16_rshift8= simd_andc(del16_rshift8,delmask);
219       
220        del16_rshift2= simd<16>::sub(del16_rshift2,simd<16>::srli<1>(simd_and(del16_rshift1,del16_rshift2)));
221       
222        del16_rshift4= simd<16>::sub(del16_rshift4,simd<16>::srli<1>(simd_and(del16_rshift1,del16_rshift4)));
223        shift_bits= simd_and(del16_rshift2,del16_rshift4);
224        del16_rshift4= simd_or(simd<16>::srli<2>(shift_bits),simd_xor(del16_rshift4,shift_bits));
225       
226        del16_rshift8= simd<16>::sub(del16_rshift8,simd<16>::srli<1>(simd_and(del16_rshift1,del16_rshift8)));
227        shift_bits= simd_and(del16_rshift2,del16_rshift8);
228        del16_rshift8= simd_or(simd<16>::srli<2>(shift_bits),simd_xor(del16_rshift8,shift_bits));       
229        shift_bits= simd_and(del16_rshift4,del16_rshift8);
230        del16_rshift8= simd_or(simd<16>::srli<4>(shift_bits),simd_xor(del16_rshift8,shift_bits));
231}
232
233static inline void del_count(BitBlock delmask, BitBlock & u8_bytes_per_reg){
234
235        BitBlock delcounts_16 = simd<16>::popcount(delmask);
236        u8_bytes_per_reg = simd<16>::sub(simd<16>::constant<16>(), delcounts_16);
237}
238
239static inline void Build_ContentBuffer(Out_Callouts out_Callouts, Marker & marker, char * content_buf, char ** content_buf_ptr, int * del_sum, int blk){
240   
241    BytePack S[8];
242
243    if (bitblock::any(out_Callouts.delmask)) {
244            BitBlock shift1, shift2, shift4, shift8;
245            delinfo_16(shift1, shift2, shift4, shift8, out_Callouts.delmask);
246            do_right16_shifts(out_Callouts.bit_0, shift1, shift2, shift4, shift8);
247            do_right16_shifts(out_Callouts.bit_1, shift1, shift2, shift4, shift8);
248            do_right16_shifts(out_Callouts.bit_2, shift1, shift2, shift4, shift8);
249            do_right16_shifts(out_Callouts.bit_3, shift1, shift2, shift4, shift8);
250            do_right16_shifts(out_Callouts.bit_4, shift1, shift2, shift4, shift8);
251            do_right16_shifts(out_Callouts.bit_5, shift1, shift2, shift4, shift8);
252            do_right16_shifts(out_Callouts.bit_6, shift1, shift2, shift4, shift8);
253            do_right16_shifts(out_Callouts.bit_7, shift1, shift2, shift4, shift8);
254            do_right16_shifts(marker.starts, shift1, shift2, shift4, shift8);
255            do_right16_shifts(marker.ends, shift1, shift2, shift4, shift8);
256        }
257
258        union {BitBlock i128; uint16_t i8[8];} units_per_reg;
259       
260        p2s(out_Callouts.bit_0,out_Callouts.bit_1,out_Callouts.bit_2,out_Callouts.bit_3,
261            out_Callouts.bit_4,out_Callouts.bit_5,out_Callouts.bit_6,out_Callouts.bit_7,
262                          S[0], S[1],S[2] ,S[3] ,S[4] ,S[5] ,S[6] ,S[7]);
263         
264        for(int k=0; k<8; k++) units_per_reg.i8[k] = 0;
265        del_count(out_Callouts.delmask,units_per_reg.i128);
266        for(int k=0; k<8; k++) {
267            del_sum[blk*8+k+1] = del_sum[blk*8+k] + (16-units_per_reg.i8[k]);
268        }
269
270        for(int j=0; j<8; j++){
271          bitblock::store_unaligned(S[j], (BytePack *) *content_buf_ptr);
272          *content_buf_ptr += units_per_reg.i8[j];
273        }
274}
275
276static inline void Postprocessing(char* cb, int cb_blocks, Marker * marker, int * del_sum){   
277     
278  for(int i=0; i<cb_blocks; i++){ 
279    if(bitblock::any(marker[i].starts)){
280      BitBlockForwardIterator iter;
281      iter.init(&(marker[i].starts));
282      BitBlockForwardIterator iter_end;
283      while(iter != iter_end) {
284        int pos = i*BLOCK_SIZE + (*iter);
285        pos = pos - del_sum[pos/16];
286        if (cb[pos]== 0x2f){
287          tokenArray[token_idx].type = name_token;
288          tokenArray[token_idx].token.char_ptr = &cb[pos];
289        }
290        else if(pos>0 && cb[pos-1]== 0x28){
291          tokenArray[token_idx].type = str_token;
292          tokenArray[token_idx].token.char_ptr = &cb[pos];
293        }
294        else if (cb[pos]== 0x0c){
295          tokenArray[token_idx].type = hex_token;
296          tokenArray[token_idx].token.char_ptr = &cb[pos];
297        }
298        else if (cb[pos]== '-' || cb[pos]== '+' || (cb[pos]>='0'&&cb[pos]<='9')){
299          Digit_postprocessing(cb, pos);
300        }
301        iter++;
302        token_idx++;
303      }
304    } 
305  }
306}
307
308void do_process(FILE *infile, FILE *outfile, int filesize) {
309 
310  int BLOCKS = filesize/BLOCK_SIZE+1;
311
312  struct Basis_bits * basis_bits = (struct Basis_bits *)malloc(sizeof(struct Basis_bits)*BLOCKS);
313
314  struct Lex * lex = (struct Lex *)malloc(sizeof(struct Lex)*BLOCKS);
315 
316  struct Parity parity;
317
318  struct Escape_Callouts escape_Callouts;
319
320  struct Out_Callouts out_Callouts;
321
322  struct Marker * marker = (struct Marker *)malloc(sizeof(struct Marker)*BLOCKS);
323
324  int block_base = 0;
325  int chars_read = 0;
326  int chars_avail = 0;
327  char * srcbuf = (char*)malloc(filesize);
328  char * content_buf = (char*)malloc(filesize);
329  char * content_buf_ptr =  content_buf;
330  int del_sum[BLOCKS*8];
331  del_sum[0] = 0;
332
333  parity.odd = simd<2>::constant<1>();
334  parity.even = simd<2>::constant<2>();
335 
336
337  chars_read = fread((void *)srcbuf, 1, filesize, infile);
338  chars_avail = chars_read;
339
340@stream_stmts
341
342
343    PERF_SEC_START(parser_timer);
344   
345    for (int i = 0; i < BLOCKS; i++){
346      s2p_do_block((BytePack *) &srcbuf[i*BLOCK_SIZE], basis_bits[i]);
347      classify_bytes.do_block(basis_bits[i], lex[i]);
348    }
349   
350    for (int i = 0; i < BLOCKS-1; i++){
351      parse_Escaped.do_block(lex[i], parity, escape_Callouts, out_Callouts, lex[i+1]);
352      parse_Comment.do_block(lex[i], escape_Callouts, marker[i], out_Callouts);
353      parse_String.do_block(escape_Callouts, marker[i], out_Callouts);
354      parse_HexStrings.do_block(lex[i], marker[i], out_Callouts);
355      parse_Names.do_block(lex[i], marker[i], out_Callouts, lex[i+1]);
356      parse_Numeric.do_block(lex[i], marker[i], out_Callouts);
357      prepare_content_buffer.do_block(basis_bits[i], lex[i], marker[i], parity, escape_Callouts, out_Callouts, lex[i+1]);
358      Build_ContentBuffer(out_Callouts, marker[i], content_buf, &content_buf_ptr, del_sum, i);
359    }
360   
361    /*final block*/
362    EOF_mask = bitblock::srl(simd<1>::constant<1>(), convert(BLOCK_SIZE-chars_avail));
363    parse_Escaped.do_final_block(lex[BLOCKS-1], parity, escape_Callouts, out_Callouts, EOF_mask);
364    parse_Comment.do_final_block(lex[BLOCKS-1], escape_Callouts, marker[BLOCKS-1], out_Callouts, EOF_mask);
365    parse_String.do_final_block(escape_Callouts, marker[BLOCKS-1], out_Callouts, EOF_mask);
366    parse_HexStrings.do_final_block(lex[BLOCKS-1], marker[BLOCKS-1], out_Callouts, EOF_mask);
367    parse_Names.do_final_block(lex[BLOCKS-1], marker[BLOCKS-1], out_Callouts, EOF_mask);
368    parse_Numeric.do_final_block(lex[BLOCKS-1], marker[BLOCKS-1], out_Callouts, EOF_mask);
369    prepare_content_buffer.do_final_block(basis_bits[BLOCKS-1], lex[BLOCKS-1], marker[BLOCKS-1], parity, escape_Callouts, out_Callouts, EOF_mask);
370    out_Callouts.delmask |= ~EOF_mask;         
371    Build_ContentBuffer(out_Callouts, marker[BLOCKS-1], content_buf, &content_buf_ptr, del_sum, BLOCKS-1);
372   
373
374    Postprocessing(content_buf, (content_buf_ptr-content_buf)/BLOCK_SIZE+1, marker, del_sum);
375
376
377//      print_register("marker.error",marker.error);
378//   
379//     for(int i=0;i<num_idx;i++)
380//       printf("%i,%i\n",numbers[i],dec_pl[i]);
381   
382//     for(int i=0; i<10;i++){
383//       if(tokenArray[i].type==str_token)
384//      printf("String: %s\n",tokenArray[i].token.char_ptr);
385//   
386//       if(tokenArray[i].type==hex_token)
387//      printf("Hex: %s\n",tokenArray[i].token.char_ptr);
388//       
389//       if(tokenArray[i].type==name_token)
390//      printf("Name: %s\n",tokenArray[i].token.char_ptr);
391//       
392//       if(tokenArray[i].type==int_token)
393//      printf("Number: %i\n",numbers[tokenArray[i].token.idx]);
394//       
395//       if(tokenArray[i].type==flt_token)
396//      printf("Number: %i\n",numbers[tokenArray[i].token.idx]);
397//
398//     }
399     
400 
401    PERF_SEC_END(parser_timer, chars_read);
402   
403    fwrite(content_buf, 1, content_buf_ptr-content_buf, outfile);
404
405}
406
Note: See TracBrowser for help on using the repository browser.