source: proto/PDF/cb_template.cpp @ 2914

Last change on this file since 2914 was 2914, checked in by cameron, 6 years ago

Lex 2-block mode

File size: 16.4 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  for(int i=0; i<cb_blocks; i++){ 
289    if(bitblock::any(marker[i].starts)){
290      BitBlockForwardIterator iter;
291      iter.init(&(marker[i].starts));
292      BitBlockForwardIterator iter_end;
293      while(iter != iter_end) {
294        int pos = i*BLOCK_SIZE + (*iter);
295        pos = pos - del_sum[pos/16];
296        if (cb[pos]== 0x2f){
297          tokenArray[token_idx].type = name_token;
298          tokenArray[token_idx].token.char_ptr = &cb[pos];
299        }
300        else if(pos>0 && cb[pos-1]== 0x28){
301          tokenArray[token_idx].type = str_token;
302          tokenArray[token_idx].token.char_ptr = &cb[pos];
303        }
304        else if (cb[pos]== 0x0c){
305          tokenArray[token_idx].type = hex_token;
306          tokenArray[token_idx].token.char_ptr = &cb[pos];
307        }
308        else if (cb[pos]== '-' || cb[pos]== '+' || (cb[pos]>='0'&&cb[pos]<='9')){
309          Digit_postprocessing(cb, pos);
310        }
311        iter++;
312        token_idx++;
313      }
314    } 
315  }
316}
317
318void do_process(FILE *infile, FILE *outfile, int filesize) {
319 
320  int BLOCKS = filesize/BLOCK_SIZE+1;
321
322  struct Basis_bits * basis_bits = (struct Basis_bits *)malloc(sizeof(struct Basis_bits)*BLOCKS);
323
324#ifndef TWOBLOCK_LEX
325  struct Lex * lex = (struct Lex *)malloc(sizeof(struct Lex)*BLOCKS);
326#endif
327#ifdef TWOBLOCK_LEX 
328  struct Lex lex0;
329  struct Lex lex1;
330#endif
331
332  struct Parity parity;
333
334  struct Escape_Callouts escape_Callouts;
335
336  struct Out_Callouts out_Callouts;
337
338  struct Marker * marker = (struct Marker *)malloc(sizeof(struct Marker)*BLOCKS);
339
340  int block_base = 0;
341  int chars_read = 0;
342  int chars_avail = 0;
343  char * srcbuf = (char*)malloc(filesize);
344  char * content_buf = (char*)malloc(filesize);
345  char * content_buf_ptr =  content_buf;
346  int del_sum[BLOCKS*8];
347  del_sum[0] = 0;
348
349  parity.odd = simd<2>::constant<1>();
350  parity.even = simd<2>::constant<2>();
351 
352
353  chars_read = fread((void *)srcbuf, 1, filesize, infile);
354  chars_avail = chars_read;
355
356@stream_stmts
357
358
359    PERF_SEC_START(s2p_lex_timer);
360   
361    for (int i = 0; i < BLOCKS; i++){
362      s2p_do_block((BytePack *) &srcbuf[i*BLOCK_SIZE], basis_bits[i]);
363    }
364#ifndef TWOBLOCK_LEX
365    for (int i = 0; i < BLOCKS; i++){
366      classify_bytes.do_block(basis_bits[i], lex[i]);
367    }
368#endif
369#ifdef TWOBLOCK_LEX 
370    classify_bytes.do_block(basis_bits[0], lex0);
371#endif
372   
373    PERF_SEC_END(s2p_lex_timer, chars_read);
374    PERF_SEC_START(parser_timer);
375
376
377    for (int i = 0; i < BLOCKS-1; i++){
378#ifdef TWOBLOCK_LEX 
379      classify_bytes.do_block(basis_bits[i+1], lex1);
380      parse_Escaped.do_block(lex0, parity, escape_Callouts, out_Callouts, lex1);
381      parse_Comment.do_block(lex0, escape_Callouts, marker[i], out_Callouts);
382      parse_String.do_block(escape_Callouts, marker[i], out_Callouts);
383      parse_HexStrings.do_block(lex0, marker[i], out_Callouts);
384      parse_Names.do_block(lex0, marker[i], out_Callouts, lex1);
385      parse_Numeric.do_block(lex0, marker[i], out_Callouts);
386      prepare_content_buffer.do_block(basis_bits[i], lex0, marker[i], parity, escape_Callouts, out_Callouts, lex1);
387      Build_ContentBuffer(out_Callouts, marker[i], content_buf, &content_buf_ptr, del_sum, i);
388      lex0 = lex1;
389#endif
390#ifndef TWOBLOCK_LEX
391      parse_Escaped.do_block(lex[i], parity, escape_Callouts, out_Callouts, lex[i+1]);
392      parse_Comment.do_block(lex[i], escape_Callouts, marker[i], out_Callouts);
393      parse_String.do_block(escape_Callouts, marker[i], out_Callouts);
394      parse_HexStrings.do_block(lex[i], marker[i], out_Callouts);
395      parse_Names.do_block(lex[i], marker[i], out_Callouts, lex[i+1]);
396      parse_Numeric.do_block(lex[i], marker[i], out_Callouts);
397      prepare_content_buffer.do_block(basis_bits[i], lex[i], marker[i], parity, escape_Callouts, out_Callouts, lex[i+1]);
398      Build_ContentBuffer(out_Callouts, marker[i], content_buf, &content_buf_ptr, del_sum, i);
399#endif
400    }
401   
402    /*final block*/
403    EOF_mask = bitblock::srl(simd<1>::constant<1>(), convert(BLOCK_SIZE-chars_avail));
404#ifdef TWOBLOCK_LEX
405    parse_Escaped.do_final_block(lex0, parity, escape_Callouts, out_Callouts, EOF_mask);
406    parse_Comment.do_final_block(lex0, escape_Callouts, marker[BLOCKS-1], out_Callouts, EOF_mask);
407    parse_String.do_final_block(escape_Callouts, marker[BLOCKS-1], out_Callouts, EOF_mask);
408    parse_HexStrings.do_final_block(lex0, marker[BLOCKS-1], out_Callouts, EOF_mask);
409    parse_Names.do_final_block(lex0, marker[BLOCKS-1], out_Callouts, EOF_mask);
410    parse_Numeric.do_final_block(lex0, marker[BLOCKS-1], out_Callouts, EOF_mask);
411    prepare_content_buffer.do_final_block(basis_bits[BLOCKS-1], lex0, marker[BLOCKS-1], parity, escape_Callouts, out_Callouts, EOF_mask);
412    out_Callouts.delmask |= ~EOF_mask;         
413    Build_ContentBuffer(out_Callouts, marker[BLOCKS-1], content_buf, &content_buf_ptr, del_sum, BLOCKS-1);
414#endif
415#ifndef TWOBLOCK_LEX
416    parse_Escaped.do_final_block(lex[BLOCKS-1], parity, escape_Callouts, out_Callouts, EOF_mask);
417    parse_Comment.do_final_block(lex[BLOCKS-1], escape_Callouts, marker[BLOCKS-1], out_Callouts, EOF_mask);
418    parse_String.do_final_block(escape_Callouts, marker[BLOCKS-1], out_Callouts, EOF_mask);
419    parse_HexStrings.do_final_block(lex[BLOCKS-1], marker[BLOCKS-1], out_Callouts, EOF_mask);
420    parse_Names.do_final_block(lex[BLOCKS-1], marker[BLOCKS-1], out_Callouts, EOF_mask);
421    parse_Numeric.do_final_block(lex[BLOCKS-1], marker[BLOCKS-1], out_Callouts, EOF_mask);
422    prepare_content_buffer.do_final_block(basis_bits[BLOCKS-1], lex[BLOCKS-1], marker[BLOCKS-1], parity, escape_Callouts, out_Callouts, EOF_mask);
423    out_Callouts.delmask |= ~EOF_mask;         
424    Build_ContentBuffer(out_Callouts, marker[BLOCKS-1], content_buf, &content_buf_ptr, del_sum, BLOCKS-1);
425#endif
426   
427    PERF_SEC_END(parser_timer, chars_read);
428    PERF_SEC_START(postprocess_timer);
429
430    Postprocessing(content_buf, (content_buf_ptr-content_buf)/BLOCK_SIZE+1, marker, del_sum);
431
432
433//      print_register("marker.error",marker.error);
434//   
435//     for(int i=0;i<num_idx;i++)
436//       printf("%i,%i\n",numbers[i],dec_pl[i]);
437   
438//     for(int i=0; i<10;i++){
439//       if(tokenArray[i].type==str_token)
440//      printf("String: %s\n",tokenArray[i].token.char_ptr);
441//   
442//       if(tokenArray[i].type==hex_token)
443//      printf("Hex: %s\n",tokenArray[i].token.char_ptr);
444//       
445//       if(tokenArray[i].type==name_token)
446//      printf("Name: %s\n",tokenArray[i].token.char_ptr);
447//       
448//       if(tokenArray[i].type==int_token)
449//      printf("Number: %i\n",numbers[tokenArray[i].token.idx]);
450//       
451//       if(tokenArray[i].type==flt_token)
452//      printf("Number: %i\n",numbers[tokenArray[i].token.idx]);
453//
454//     }
455     
456 
457    PERF_SEC_END(postprocess_timer, chars_read);
458   
459    fwrite(content_buf, 1, content_buf_ptr-content_buf, outfile);
460
461}
462
Note: See TracBrowser for help on using the repository browser.