source: proto/PDF/cb_template.cpp @ 2859

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

hex nyble precalculated.

File size: 9.2 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> 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#define BUFSIZE 1000000
20
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
49void do_process(FILE *infile, FILE *outfile);
50
51int main(int argc, char * argv[]) {
52
53        char * infilename, * outfilename;
54        FILE *infile, *outfile;
55        struct stat fileinfo;
56
57        if (argc < 2) {
58                printf("Usage: %s <filename> [<outputfile>]\n", argv[0]);
59                exit(-1);
60        }
61
62        infilename = argv[1];
63        stat(infilename, &fileinfo);
64        infile = fopen(infilename, "rb");
65        if (!infile) {
66                fprintf(stderr, "Error: cannot open %s for input.\n", infilename);
67                exit(-1);
68        }
69
70        if (argc < 3) outfile = stdout;
71        else {
72                outfilename = argv[2];
73                outfile = fopen(outfilename, "wb");
74                if (!outfile) {
75                        fprintf(stderr, "Error: cannot open %s for writing.\n", outfilename);
76                        exit(-1);
77                }
78        }
79
80//      PERF_SEC_BIND(1);
81
82        PERF_SEC_INIT(parser_timer);
83
84        do_process(infile, outfile);
85
86        PERF_SEC_DUMP(parser_timer);
87
88        PERF_SEC_DESTROY(parser_timer);
89
90        fclose(infile);
91        fclose(outfile);
92
93        return(0);
94}
95
96/* s2p Definitions */
97static inline void s2p_do_block(BytePack U8[], Basis_bits & basis_bits) {
98  s2p(U8[0], U8[1], U8[2], U8[3], U8[4], U8[5], U8[6], U8[7],
99        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);
100}
101
102static inline void s2p_do_final_block(BytePack U8[], Basis_bits & basis_bits, BitBlock EOF_mask) {
103  s2p_do_block(U8, basis_bits);
104  basis_bits.bit_0 = simd_and(basis_bits.bit_0, EOF_mask);
105  basis_bits.bit_1 = simd_and(basis_bits.bit_1, EOF_mask);
106  basis_bits.bit_2 = simd_and(basis_bits.bit_2, EOF_mask);
107  basis_bits.bit_3 = simd_and(basis_bits.bit_3, EOF_mask);
108  basis_bits.bit_4 = simd_and(basis_bits.bit_4, EOF_mask);
109  basis_bits.bit_5 = simd_and(basis_bits.bit_5, EOF_mask);
110  basis_bits.bit_6 = simd_and(basis_bits.bit_6, EOF_mask);
111  basis_bits.bit_7 = simd_and(basis_bits.bit_7, EOF_mask);
112}
113
114#define do_right16_shifts(vec,rshift1,rshift2,rshift4,rshift8)  \
115{BitBlock s2; \
116vec= simd<16>::sub(vec,simd<16>::srli<1>(simd_and(rshift1,vec)) ) ; \
117s2= simd_and(rshift2,vec) ; \
118vec= simd_or(simd<16>::srli<2>(s2) ,simd_xor(vec,s2) ) ; \
119s2= simd_and(rshift4,vec) ; \
120vec= simd_or(simd<16>::srli<4>(s2) ,simd_xor(vec,s2) ) ; \
121s2= simd_and(rshift8,vec) ; \
122vec= simd_or(simd<16>::srli<8>(s2) ,simd_xor(vec,s2) ) ; \
123}
124
125static inline void delinfo_16(BitBlock & del16_rshift1, BitBlock & del16_rshift2, BitBlock & del16_rshift4,
126                              BitBlock & del16_rshift8, BitBlock delmask){
127       
128        BitBlock del16_trans2;
129        BitBlock del16_trans4;
130        BitBlock del16_trans8;
131        BitBlock shift_bits;
132       
133        del16_rshift1= simd_xor(simd<16>::slli<1>(delmask),simd<16>::slli<2>(delmask));
134        del16_rshift1= simd_xor(del16_rshift1,simd<16>::slli<2>(del16_rshift1));
135        del16_rshift1= simd_xor(del16_rshift1,simd<16>::slli<4>(del16_rshift1));
136        del16_rshift1= simd_xor(del16_rshift1,simd<16>::slli<8>(del16_rshift1));
137       
138        del16_trans2= simd_and(del16_rshift1,delmask);
139        del16_rshift2= simd_xor(simd<16>::slli<1>(del16_trans2),simd<16>::slli<2>(del16_trans2));
140        del16_rshift2= simd_xor(del16_rshift2,simd<16>::slli<2>(del16_rshift2));
141        del16_rshift2= simd_xor(del16_rshift2,simd<16>::slli<4>(del16_rshift2));
142        del16_rshift2= simd_xor(del16_rshift2,simd<16>::slli<8>(del16_rshift2));
143       
144        del16_trans4= simd_and(del16_rshift2,del16_trans2);
145        del16_rshift4= simd_xor(simd<16>::slli<1>(del16_trans4),simd<16>::slli<2>(del16_trans4));
146        del16_rshift4= simd_xor(del16_rshift4,simd<16>::slli<2>(del16_rshift4));
147        del16_rshift4= simd_xor(del16_rshift4,simd<16>::slli<4>(del16_rshift4));
148        del16_rshift4= simd_xor(del16_rshift4,simd<16>::slli<8>(del16_rshift4));
149       
150        del16_trans8= simd_and(del16_rshift4,del16_trans4);
151        del16_rshift8= simd_xor(simd<16>::slli<1>(del16_trans8),simd<16>::slli<2>(del16_trans8));
152        del16_rshift8= simd_xor(del16_rshift8,simd<16>::slli<2>(del16_rshift8));
153        del16_rshift8= simd_xor(del16_rshift8,simd<16>::slli<4>(del16_rshift8));
154        del16_rshift8= simd_xor(del16_rshift8,simd<16>::slli<8>(del16_rshift8));
155       
156        del16_rshift1= simd_andc(del16_rshift1,delmask);
157        del16_rshift2= simd_andc(del16_rshift2,delmask);
158        del16_rshift4= simd_andc(del16_rshift4,delmask);
159        del16_rshift8= simd_andc(del16_rshift8,delmask);
160       
161        del16_rshift2= simd<16>::sub(del16_rshift2,simd<16>::srli<1>(simd_and(del16_rshift1,del16_rshift2)));
162       
163        del16_rshift4= simd<16>::sub(del16_rshift4,simd<16>::srli<1>(simd_and(del16_rshift1,del16_rshift4)));
164        shift_bits= simd_and(del16_rshift2,del16_rshift4);
165        del16_rshift4= simd_or(simd<16>::srli<2>(shift_bits),simd_xor(del16_rshift4,shift_bits));
166       
167        del16_rshift8= simd<16>::sub(del16_rshift8,simd<16>::srli<1>(simd_and(del16_rshift1,del16_rshift8)));
168        shift_bits= simd_and(del16_rshift2,del16_rshift8);
169        del16_rshift8= simd_or(simd<16>::srli<2>(shift_bits),simd_xor(del16_rshift8,shift_bits));       
170        shift_bits= simd_and(del16_rshift4,del16_rshift8);
171        del16_rshift8= simd_or(simd<16>::srli<4>(shift_bits),simd_xor(del16_rshift8,shift_bits));
172}
173
174static inline void del_count(BitBlock delmask, BitBlock & u8_bytes_per_reg){
175
176        BitBlock delcounts_16 = simd<16>::popcount(delmask);
177        u8_bytes_per_reg = simd<16>::sub(simd<16>::constant<16>(), delcounts_16);
178}
179
180static inline void Build_ContentBuffer(Out_Callouts out_Callouts, char * content_buf, char ** content_buf_ptr){
181   
182    BytePack S[8];
183   
184    if (bitblock::any(out_Callouts.delmask)) {
185            BitBlock shift1, shift2, shift4, shift8;
186            delinfo_16(shift1, shift2, shift4, shift8, out_Callouts.delmask);
187            do_right16_shifts(out_Callouts.bit_0, shift1, shift2, shift4, shift8);
188            do_right16_shifts(out_Callouts.bit_1, shift1, shift2, shift4, shift8);
189            do_right16_shifts(out_Callouts.bit_2, shift1, shift2, shift4, shift8);
190            do_right16_shifts(out_Callouts.bit_3, shift1, shift2, shift4, shift8);
191            do_right16_shifts(out_Callouts.bit_4, shift1, shift2, shift4, shift8);
192            do_right16_shifts(out_Callouts.bit_5, shift1, shift2, shift4, shift8);
193            do_right16_shifts(out_Callouts.bit_6, shift1, shift2, shift4, shift8);
194            do_right16_shifts(out_Callouts.bit_7, shift1, shift2, shift4, shift8);
195        }
196
197        union {BitBlock i128; uint16_t i8[8];} units_per_reg;
198       
199        p2s(out_Callouts.bit_0,out_Callouts.bit_1,out_Callouts.bit_2,out_Callouts.bit_3,
200            out_Callouts.bit_4,out_Callouts.bit_5,out_Callouts.bit_6,out_Callouts.bit_7,
201                          S[0], S[1],S[2] ,S[3] ,S[4] ,S[5] ,S[6] ,S[7]);
202         
203        for(int k=0; k<8; k++) units_per_reg.i8[k] = 0;
204        del_count(out_Callouts.delmask,units_per_reg.i128);
205        for(int k=0; k<8; k++)
206          printf("delcount=%i\n",units_per_reg.i8[k]);
207
208        for(int j=0; j<8; j++){
209          bitblock::store_unaligned(S[j], (BytePack *) *content_buf_ptr);
210          *content_buf_ptr += units_per_reg.i8[j];
211        }
212}
213
214void do_process(FILE *infile, FILE *outfile) {
215
216@decl
217
218  int block_base = 0;
219  int chars_read = 0;
220  int chars_avail = 0;
221  char srcbuf[BUFSIZE];
222  char content_buf[BUFSIZE];
223  char * content_buf_ptr =  content_buf;
224
225  parity.odd = simd<2>::constant<1>();
226  parity.even = simd<2>::constant<2>();
227 
228
229  chars_read = fread((void *)srcbuf, 1, BUFSIZE, infile);
230  chars_avail = chars_read;
231
232@stream_stmts
233
234
235    PERF_SEC_START(parser_timer);
236
237/* Full Blocks */
238    while (chars_avail >= BLOCK_SIZE) {
239          s2p_do_block((BytePack *) &srcbuf[block_base], basis_bits);
240          @block_stmts                   
241          Build_ContentBuffer(out_Callouts, content_buf, &content_buf_ptr);
242                  block_base += BLOCK_SIZE;
243          chars_avail -= BLOCK_SIZE;
244    }
245/*Partial Blocks*/
246    if (chars_avail > 0 || @any_carry) {
247          EOF_mask = bitblock::srl(simd<1>::constant<1>(), convert(BLOCK_SIZE-chars_avail));
248          s2p_do_final_block((BytePack *) &srcbuf[block_base], basis_bits, EOF_mask);
249          @final_block_stmts
250          out_Callouts.delmask |= ~EOF_mask;         
251          Build_ContentBuffer(out_Callouts, content_buf, &content_buf_ptr);
252    }
253   
254    PERF_SEC_END(parser_timer, chars_read);
255   
256    fwrite(content_buf, 2, content_buf_ptr-content_buf, outfile);
257
258}
259
Note: See TracBrowser for help on using the repository browser.