source: proto/PDF/cb_template.cpp @ 2900

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

hex processing without WS

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