source: proto/PDF/cb_template.cpp @ 2948

Last change on this file since 2948 was 2934, checked in by lindanl, 7 years ago

Calculate token lenght

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