source: proto/CSV/postgres/copy_simd.c @ 4735

Last change on this file since 4735 was 1465, checked in by ksherdy, 8 years ago

Centralized typedefs.

File size: 23.9 KB
Line 
1
2#include "lib_simd.h "
3
4#define min(x,y) ((x) <(y) ?(x) :(y) )
5#define LAHF_CARRY 0x100
6
7#define s2p_step(s0,s1,hi_mask,shift,p0,p1)  \
8{ \
9BitBlock t0,t1; \
10t0= simd_pack_16_hh(s0,s1) ; \
11t1= simd_pack_16_ll(s0,s1) ; \
12p0= simd_if(hi_mask,t0,simd_srli_16(t1,shift) ) ; \
13p1= simd_if(hi_mask,simd_slli_16(t0,shift) ,t1) ; \
14} \
15
16#define s2p_bytepack(s0,s1,s2,s3,s4,s5,s6,s7,p0,p1,p2,p3,p4,p5,p6,p7)  \
17{BitBlock bit00224466_0,bit00224466_1,bit00224466_2,bit00224466_3; \
18BitBlock bit11335577_0,bit11335577_1,bit11335577_2,bit11335577_3; \
19BitBlock bit00004444_0,bit22226666_0,bit00004444_1,bit22226666_1; \
20BitBlock bit11115555_0,bit33337777_0,bit11115555_1,bit33337777_1; \
21s2p_step(s0,s1,simd_himask_2,1,bit00224466_0,bit11335577_0)  \
22s2p_step(s2,s3,simd_himask_2,1,bit00224466_1,bit11335577_1)  \
23s2p_step(s4,s5,simd_himask_2,1,bit00224466_2,bit11335577_2)  \
24s2p_step(s6,s7,simd_himask_2,1,bit00224466_3,bit11335577_3)  \
25s2p_step(bit00224466_0,bit00224466_1,simd_himask_4,2,bit00004444_0,bit22226666_0)  \
26s2p_step(bit00224466_2,bit00224466_3,simd_himask_4,2,bit00004444_1,bit22226666_1)  \
27s2p_step(bit11335577_0,bit11335577_1,simd_himask_4,2,bit11115555_0,bit33337777_0)  \
28s2p_step(bit11335577_2,bit11335577_3,simd_himask_4,2,bit11115555_1,bit33337777_1)  \
29s2p_step(bit00004444_0,bit00004444_1,simd_himask_8,4,p0,p4)  \
30s2p_step(bit11115555_0,bit11115555_1,simd_himask_8,4,p1,p5)  \
31s2p_step(bit22226666_0,bit22226666_1,simd_himask_8,4,p2,p6)  \
32s2p_step(bit33337777_0,bit33337777_1,simd_himask_8,4,p3,p7)  \
33} \
34
35#define p2s_step(p0,p1,hi_mask,shift,s0,s1)  \
36{ \
37BitBlock t0,t1; \
38t0= simd_if(hi_mask,p0,simd_srli_16(p1,shift) ) ; \
39t1= simd_if(hi_mask,simd_slli_16(p0,shift) ,p1) ; \
40s0= simd_mergeh_8(t0,t1) ; \
41s1= simd_mergel_8(t0,t1) ; \
42} \
43
44#define p2s_bytemerge(p0,p1,p2,p3,p4,p5,p6,p7,s0,s1,s2,s3,s4,s5,s6,s7)  \
45{ \
46BitBlock bit00004444_0,bit22226666_0,bit00004444_1,bit22226666_1; \
47BitBlock bit11115555_0,bit33337777_0,bit11115555_1,bit33337777_1; \
48BitBlock bit00224466_0,bit00224466_1,bit00224466_2,bit00224466_3; \
49BitBlock bit11335577_0,bit11335577_1,bit11335577_2,bit11335577_3; \
50p2s_step(p0,p4,simd_himask_8,4,bit00004444_0,bit00004444_1)  \
51p2s_step(p1,p5,simd_himask_8,4,bit11115555_0,bit11115555_1)  \
52p2s_step(p2,p6,simd_himask_8,4,bit22226666_0,bit22226666_1)  \
53p2s_step(p3,p7,simd_himask_8,4,bit33337777_0,bit33337777_1)  \
54p2s_step(bit00004444_0,bit22226666_0,simd_himask_4,2,bit00224466_0,bit00224466_1)  \
55p2s_step(bit11115555_0,bit33337777_0,simd_himask_4,2,bit11335577_0,bit11335577_1)  \
56p2s_step(bit00004444_1,bit22226666_1,simd_himask_4,2,bit00224466_2,bit00224466_3)  \
57p2s_step(bit11115555_1,bit33337777_1,simd_himask_4,2,bit11335577_2,bit11335577_3)  \
58p2s_step(bit00224466_0,bit11335577_0,simd_himask_2,1,s0,s1)  \
59p2s_step(bit00224466_1,bit11335577_1,simd_himask_2,1,s2,s3)  \
60p2s_step(bit00224466_2,bit11335577_2,simd_himask_2,1,s4,s5)  \
61p2s_step(bit00224466_3,bit11335577_3,simd_himask_2,1,s6,s7)  \
62} \
63
64
65
66
67#define double_int64_adc(x1, x2, y1, y2, rslt1, rslt2, carry) \
68  __asm__  ("sahf\n\t" \
69            "adc %[e1], %[z1]\n\t" \
70            "adc %[e2], %[z2]\n\t" \
71            "lahf\n\t" \
72         : [z1] "=r" (rslt1), [z2] "=r" (rslt2), [carryflag] "=a" (carry) \
73         : "[z1]" (x1), "[z2]" (x2), \
74           [e1] "r" (y1), [e2] "r" (y2), \
75           "[carryflag]" (carry) \
76         : "cc")
77
78#define adc128(first, second, carry, sum) \
79do\
80{\
81  union {__m128i bitblock;\
82         uint64_t int64[2];} rslt;\
83\
84  union {__m128i bitblock;\
85         uint64_t int64[2];} x;\
86\
87  union {__m128i bitblock;\
88         uint64_t int64[2];} y;\
89\
90  x.bitblock = first;\
91  y.bitblock = second;\
92\
93  double_int64_adc(x.int64[0], x.int64[1], y.int64[0], y.int64[1], rslt.int64[0], rslt.int64[1], carry);\
94  sum = rslt.bitblock;\
95}while(0)
96
97
98/*static inline BitBlock adc128(BitBlock first, BitBlock second, int &carry)
99{
100  union {__m128i bitblock;
101         uint64_t int64[2];} rslt;
102
103  union {__m128i bitblock;
104         uint64_t int64[2];} x;
105
106  union {__m128i bitblock;
107         uint64_t int64[2];} y;
108
109  x.bitblock = first;
110  y.bitblock = second;
111
112  double_int64_adc(x.int64[0], x.int64[1], y.int64[0], y.int64[1],
113                   rslt.int64[0], rslt.int64[1], carry);
114
115  return rslt.bitblock;
116}*/
117                     
118#define double_int64_sbb(x1, x2, y1, y2, rslt1, rslt2, carry) \
119  __asm__  ("sahf\n\t" \
120            "sbb %[e1], %[z1]\n\t" \
121            "sbb %[e2], %[z2]\n\t" \
122            "lahf\n\t" \
123         : [z1] "=r" (rslt1), [z2] "=r" (rslt2), [carryflag] "=a" (carry) \
124         : "[z1]" (x1), "[z2]" (x2), \
125           [e1] "r" (y1), [e2] "r" (y2), \
126           "[carryflag]" (carry) \
127         : "cc")
128
129/*static inline BitBlock sbb128(BitBlock first, BitBlock second, int &carry)
130{
131  union {__m128i bitblock;
132         uint64_t int64[2];} rslt;
133
134  union {__m128i bitblock;
135         uint64_t int64[2];} x;
136
137  union {__m128i bitblock;
138         uint64_t int64[2];} y;
139
140  x.bitblock = first;
141  y.bitblock = second;
142
143  double_int64_sbb(x.int64[0], x.int64[1], y.int64[0], y.int64[1],
144                   rslt.int64[0], rslt.int64[1], carry);
145
146  return rslt.bitblock;
147}*/
148
149#define sbb128(first, second, carry, sum) \
150do\
151{ union {__m128i bitblock;\
152         uint64_t int64[2];} rslt;\
153\
154  union {__m128i bitblock;\
155         uint64_t int64[2];} x;\
156\
157  union {__m128i bitblock;\
158         uint64_t int64[2];} y;\
159\
160  x.bitblock = first;\
161  y.bitblock = second;\
162\
163  double_int64_sbb(x.int64[0], x.int64[1], y.int64[0], y.int64[1], \
164                   rslt.int64[0], rslt.int64[1], carry);\
165  sum = rslt.bitblock;\
166}while(0)
167
168/*
169void bitstream_gen(CopyState cstate) {
170
171
172        int carry1=0;
173        int carry0=0;
174        int CarryTemp20=0;
175        int carry2=0;
176        int carry4=0;
177        int carry1_i=0;
178        int carry3=0;
179        int carry2_i=0;
180        int carry_brw0=0;
181        int carry3_i=0;
182        int carry0_i=0;
183        BitBlock _strct_csvclass__classify_bytes__temp6;
184        BitBlock _strct_csvclass__classify_bytes__temp7;
185        BitBlock _strct_csvclass__classify_bytes__temp4;
186        BitBlock _strct_csvclass__classify_bytes__temp5;
187        BitBlock array_bit__6_;
188        BitBlock _strct_csvclass__classify_bytes__strct_lex__CR_;
189        BitBlock delim;
190        BitBlock _strct_csvclass__classify_bytes__temp8;
191        BitBlock _strct_csvclass__classify_bytes__temp9;
192        BitBlock Temp13;
193        BitBlock Temp12;
194        BitBlock Temp19;
195        BitBlock quote_end;
196        BitBlock _strct_csvclass__classify_bytes__strct_lex__Comma_;
197        BitBlock Temp3;
198        BitBlock Temp13_temp;
199        BitBlock Temp4_temp;
200        BitBlock _strct_csvclass__classify_bytes__temp16;
201        BitBlock array_bit__4_;
202        BitBlock _strct_csvclass__classify_bytes__temp10;
203        BitBlock _strct_csvclass__classify_bytes__temp11;
204        BitBlock _strct_csvclass__classify_bytes__temp12;
205        BitBlock _strct_csvclass__classify_bytes__temp18;
206        BitBlock _strct_csvclass__classify_bytes__temp19;
207        BitBlock array_bit__2_;
208        BitBlock array_bit__7_;
209        BitBlock array_bit__5_;
210        BitBlock _strct_csvclass__classify_bytes__temp17;
211        BitBlock _strct_csvclass__classify_bytes__strct_lex__DQuote_;
212        BitBlock CSV_cursor;
213        BitBlock AllOne = simd_const_1(1);
214        BitBlock AllZero = simd_const_1(0);
215        BitBlock quote_mask;
216        BitBlock Temp20;
217        BitBlock Temp21;
218        BitBlock _strct_csvclass__classify_bytes__strct_lex__LF_;
219        BitBlock eol;
220        BitBlock _strct_csvclass__classify_bytes__temp21;
221        BitBlock _strct_csvclass__classify_bytes__temp20;
222        BitBlock array_bit__3_;
223        BitBlock Temp4;
224        BitBlock array_bit__1_;
225        BitBlock quote_start;
226        BitBlock array_bit__0_;
227
228        BytePack * U8;
229
230        int block_pos = 0;
231        int i=0;
232        int chars_read = 0;
233       
234
235        CSV_cursor = sisd_from_int(1);
236
237        U8 = simd_new(8);
238       
239        do{
240                U8 = (BytePack *)(&(cstate->raw_buf[block_pos]));       
241                chars_read = min(cstate->raw_buf_len-block_pos,BLOCK_SIZE_BITS);
242                if(chars_read==0)break;
243                for (i = chars_read;i < BLOCK_SIZE_BITS; i++) {
244                        ((char *) U8)[i] = 0;
245                }
246
247                s2p_bytepack(U8[7], U8[6], U8[5], U8[4], U8[3], U8[2], U8[1], U8[0],
248                array_bit__0_,array_bit__1_,array_bit__2_,array_bit__3_,array_bit__4_,array_bit__5_,array_bit__6_,array_bit__7_);
249               
250
251                _strct_csvclass__classify_bytes__temp4 = simd_and(array_bit__4_,array_bit__5_);
252                _strct_csvclass__classify_bytes__temp5 = simd_or(array_bit__6_,array_bit__7_);
253                _strct_csvclass__classify_bytes__temp6 = simd_andc(_strct_csvclass__classify_bytes__temp4,_strct_csvclass__classify_bytes__temp5);
254                _strct_csvclass__classify_bytes__temp7 = simd_or(array_bit__0_,array_bit__1_);
255                _strct_csvclass__classify_bytes__temp8 = simd_andc(array_bit__2_,array_bit__3_);
256                _strct_csvclass__classify_bytes__temp9 = simd_andc(_strct_csvclass__classify_bytes__temp8,_strct_csvclass__classify_bytes__temp7);
257                _strct_csvclass__classify_bytes__temp10 = simd_or(array_bit__4_,array_bit__5_);
258                _strct_csvclass__classify_bytes__temp11 = simd_andc(array_bit__6_,array_bit__7_);
259                _strct_csvclass__classify_bytes__temp12 = simd_andc(_strct_csvclass__classify_bytes__temp11,_strct_csvclass__classify_bytes__temp10);
260                _strct_csvclass__classify_bytes__strct_lex__DQuote_ = simd_and(_strct_csvclass__classify_bytes__temp9,_strct_csvclass__classify_bytes__temp12);
261                _strct_csvclass__classify_bytes__temp16 = simd_or(array_bit__2_,array_bit__3_);
262                _strct_csvclass__classify_bytes__temp17 = simd_or(_strct_csvclass__classify_bytes__temp7,_strct_csvclass__classify_bytes__temp16);
263                _strct_csvclass__classify_bytes__temp18 = simd_andc(array_bit__7_,array_bit__6_);
264                _strct_csvclass__classify_bytes__temp19 = simd_and(_strct_csvclass__classify_bytes__temp4,_strct_csvclass__classify_bytes__temp18);
265                _strct_csvclass__classify_bytes__strct_lex__CR_ = simd_andc(_strct_csvclass__classify_bytes__temp19,_strct_csvclass__classify_bytes__temp17);
266                _strct_csvclass__classify_bytes__temp20 = simd_andc(array_bit__4_,array_bit__5_);
267                _strct_csvclass__classify_bytes__temp21 = simd_and(_strct_csvclass__classify_bytes__temp20,_strct_csvclass__classify_bytes__temp11);
268                _strct_csvclass__classify_bytes__strct_lex__LF_ = simd_andc(_strct_csvclass__classify_bytes__temp21,_strct_csvclass__classify_bytes__temp17);
269                _strct_csvclass__classify_bytes__strct_lex__Comma_ = simd_and(_strct_csvclass__classify_bytes__temp9,_strct_csvclass__classify_bytes__temp6);
270
271                quote_start = AllZero;
272                quote_end = AllZero;
273
274                while (bitblock_has_bit(CSV_cursor)||((CarryTemp20&LAHF_CARRY)>0)) {
275               
276                CarryTemp20 = 0;
277                Temp3 = simd_andc(AllOne,_strct_csvclass__classify_bytes__strct_lex__DQuote_);
278                adc128(CSV_cursor, Temp3, carry0, Temp4_temp);
279                Temp4 = simd_andc(Temp4_temp, Temp3);           
280                CSV_cursor = simd_and(Temp4,_strct_csvclass__classify_bytes__strct_lex__DQuote_);
281                quote_start = simd_or(quote_start,CSV_cursor);
282                adc128(CSV_cursor, CSV_cursor, carry1, CSV_cursor);
283                Temp12 = simd_andc(AllOne,_strct_csvclass__classify_bytes__strct_lex__DQuote_);
284                adc128(CSV_cursor, Temp12, carry2, Temp13_temp);
285                Temp13 = simd_andc(Temp13_temp, Temp12);
286                CSV_cursor = simd_and(Temp13,_strct_csvclass__classify_bytes__strct_lex__DQuote_);
287                quote_end = simd_or(quote_end,CSV_cursor);
288                adc128(CSV_cursor, CSV_cursor, carry3, CSV_cursor);
289                carry0_i = carry0_i|carry0;
290                carry1_i = carry1_i|carry1;
291                carry2_i = carry2_i|carry2;
292                carry3_i = carry3_i|carry3;
293                carry0 = 0;
294                carry1 = 0;
295                carry2 = 0;
296                carry3 = 0;
297                }
298                carry3 = carry3_i;
299                carry2 = carry2_i;
300                carry1 = carry1_i;
301                carry0 = carry0_i;
302                carry3_i = 0;
303                carry2_i = 0;
304                carry1_i = 0;
305                carry0_i = 0;
306                CarryTemp20 = carry0|carry1;
307                CarryTemp20 = CarryTemp20|carry3;
308                CarryTemp20 = CarryTemp20|carry2;
309                sbb128(quote_end, quote_start, carry_brw0, quote_mask);
310                Temp19 = simd_andc(_strct_csvclass__classify_bytes__strct_lex__CR_,quote_mask);
311                adc128(Temp19, Temp19, carry4, Temp20);
312                Temp21 = simd_andc(_strct_csvclass__classify_bytes__strct_lex__LF_,quote_mask);
313                eol = simd_or(Temp20,Temp21);
314                delim = simd_andc(_strct_csvclass__classify_bytes__strct_lex__Comma_,quote_mask);
315
316                cstate->EOL_stream[block_pos/BLOCK_SIZE_BITS]=eol;
317                cstate->delim_stream[block_pos/BLOCK_SIZE_BITS]=delim;
318
319                block_pos += chars_read;
320        }while (chars_read == BLOCK_SIZE_BITS);
321}*/
322/*quote as '\'',escape as '\\'*/
323void bitstream_gen3(CopyState cstate) {
324
325
326        BitBlock temp1;
327        BitBlock temp2;
328        BitBlock temp3;
329        BitBlock temp4;
330        BitBlock temp5;
331        BitBlock temp6;
332        BitBlock temp7;
333        BitBlock temp8;
334        BitBlock temp9;
335        BitBlock temp10;
336        BitBlock temp11;
337        BitBlock temp12;
338        BitBlock temp13;
339        BitBlock temp14;
340        BitBlock temp15;
341        BitBlock temp16;
342        BitBlock temp17;
343        BitBlock temp18;
344        BitBlock temp19;
345        BitBlock temp20;
346        BitBlock temp21;
347        BitBlock temp22;
348        BitBlock temp23;
349        BitBlock temp24;
350        BitBlock temp25;
351       
352        BitBlock CR;
353        BitBlock LF;
354        BitBlock Comma;
355        BitBlock DQuote;
356        BitBlock SQuote;
357        BitBlock HT;
358        BitBlock EOL;
359        BitBlock Delim;
360       
361        BitBlock p2;
362        BitBlock p4;   
363        BitBlock p8;
364        BitBlock p16;
365        BitBlock p32;
366        BitBlock p64;
367        BitBlock quote_mask;
368        BitBlock BackSlash;
369        BitBlock quote_base;
370
371        BytePack * U8;
372        BitBlock * bit;
373
374        int block_pos = 0;
375        int i=0;
376        int chars_read = 0;
377       
378
379        quote_base = simd_const_8(0);
380
381        U8 = simd_new(8);
382        bit = simd_new(8);
383        do{
384                U8 = (BytePack *)(&(cstate->raw_buf[block_pos]));       
385                chars_read = min(cstate->raw_buf_len-block_pos,BLOCK_SIZE_BITS);
386                if(chars_read==0)break;
387                for (i = chars_read;i < BLOCK_SIZE_BITS; i++) {
388                        ((char *) U8)[i] = 0;
389                }
390
391                s2p_bytepack(U8[7], U8[6], U8[5], U8[4], U8[3], U8[2], U8[1], U8[0],
392                bit[0],bit[1],bit[2],bit[3],bit[4],bit[5],bit[6],bit[7]);
393               
394
395                temp1 = simd_andc(bit[1], bit[0]);
396                temp2 = simd_andc(bit[3], bit[2]);
397                temp3 = simd_and(temp1, temp2);
398                temp4 = simd_and(bit[4], bit[5]);
399                temp5 = simd_or(bit[6], bit[7]);
400                temp6 = simd_andc(temp4, temp5);
401                BackSlash = simd_and(temp3, temp6);
402                temp7 = simd_or(bit[0], bit[1]);
403                temp8 = simd_andc(bit[2], bit[3]);
404                temp9 = simd_andc(temp8, temp7);
405                temp10 = simd_or(bit[4], bit[5]);
406                temp11 = simd_andc(bit[6], bit[7]);
407                temp12 = simd_andc(temp11, temp10);
408                DQuote = simd_and(temp9, temp12);
409                temp13 = simd_andc(bit[5], bit[4]);
410                temp14 = simd_and(bit[6], bit[7]);
411                temp15 = simd_and(temp13, temp14);
412                SQuote = simd_and(temp9, temp15);
413                temp16 = simd_or(bit[2], bit[3]);
414                temp17 = simd_or(temp7, temp16);
415                temp18 = simd_andc(bit[7], bit[6]);
416                temp19 = simd_and(temp4, temp18);
417                CR = simd_andc(temp19, temp17);
418                temp20 = simd_andc(bit[4], bit[5]);
419                temp21 = simd_and(temp20, temp11);
420                LF = simd_andc(temp21, temp17);
421                Comma = simd_and(temp9, temp6);
422                temp22 = simd_and(temp20, temp18);
423                HT = simd_andc(temp22, temp17);
424               
425                int carry0=0;
426                int carry1=0;
427                int carry2=0;
428                BitBlock even;
429                BitBlock odd;
430                BitBlock start;
431                BitBlock even_start;
432                BitBlock even_final;
433                BitBlock odd_start;
434                BitBlock odd_final;
435                BitBlock escape;
436
437                odd = simd_const_2(1);
438                even = simd_const_2(2);
439
440                adc128(BackSlash,BackSlash,carry0,temp23);
441                start = simd_andc(BackSlash,temp23);
442                even_start = simd_and(start,even);
443                adc128(even_start, BackSlash, carry1, temp24);
444                even_final = simd_andc(temp24,BackSlash);
445                escape = simd_and(even_final,odd);
446               
447                odd_start = simd_and(start,odd);
448                adc128(odd_start, BackSlash, carry2, temp25);
449                odd_final = simd_andc(temp25,BackSlash);
450                escape = simd_or(escape, simd_and(odd_final,even));
451       
452                SQuote = simd_andc(SQuote,escape);
453
454                p2 = simd_xor(SQuote,simd_slli_128(SQuote,1));
455                p4 = simd_xor(p2,simd_slli_128(p2,2));
456                p8 = simd_xor(p4,simd_slli_128(p4,4));
457                p16 = simd_xor(p8,simd_slli_128(p8,8));
458                p32 = simd_xor(p16,simd_slli_128(p16,16));
459                p64 = simd_xor(p32,simd_slli_128(p32,32));
460                quote_mask = simd_xor(p64,simd_slli_128(p64,64));
461                quote_mask = simd_xor(quote_base,quote_mask);
462                quote_base = simd_shufflei_32(simd_srai_32(quote_mask,31),0xFF);
463
464
465                Delim = simd_andc(Comma,quote_mask);
466                EOL =  simd_andc(simd_or(simd_slli_128(CR,1),LF),quote_mask);
467
468                cstate->EOL_stream[block_pos/BLOCK_SIZE_BITS]=EOL;
469                cstate->delim_stream[block_pos/BLOCK_SIZE_BITS]=Delim;
470
471                block_pos += chars_read;
472        }while (chars_read == BLOCK_SIZE_BITS);
473}
474/*quote and escape as '\"'*/
475void bitstream_gen(CopyState cstate) {
476
477
478        BitBlock temp1;
479        BitBlock temp2;
480        BitBlock temp3;
481        BitBlock temp4;
482        BitBlock temp5;
483        BitBlock temp6;
484        BitBlock temp7;
485        BitBlock temp8;
486        BitBlock temp9;
487        BitBlock temp10;
488        BitBlock temp11;
489        BitBlock temp12;
490        BitBlock temp13;
491        BitBlock temp14;
492        BitBlock temp15;
493        BitBlock temp16;
494        BitBlock temp17;
495        BitBlock temp18;
496        BitBlock temp19;
497        BitBlock temp20;
498        BitBlock temp21;
499        BitBlock temp22;
500       
501        BitBlock CR;
502        BitBlock LF;
503        BitBlock Comma;
504        BitBlock DQuote;
505        BitBlock SQuote;
506        BitBlock HT;
507        BitBlock EOL;
508        BitBlock Delim;
509       
510        BitBlock p2;
511        BitBlock p4;   
512        BitBlock p8;
513        BitBlock p16;
514        BitBlock p32;
515        BitBlock p64;
516        BitBlock quote_mask;
517        BitBlock BackSlash;
518        BitBlock quote_base;
519
520        BytePack * U8;
521        BitBlock * bit;
522
523        int block_pos = 0;
524        int i=0;
525        int chars_read = 0;
526       
527
528        quote_base = simd_const_8(0);
529
530        U8 = simd_new(8);
531        bit = simd_new(8);
532        do{
533                U8 = (BytePack *)(&(cstate->raw_buf[block_pos]));       
534                chars_read = min(cstate->raw_buf_len-block_pos,BLOCK_SIZE_BITS);
535                if(chars_read==0)break;
536                for (i = chars_read;i < BLOCK_SIZE_BITS; i++) {
537                        ((char *) U8)[i] = 0;
538                }
539
540                s2p_bytepack(U8[7], U8[6], U8[5], U8[4], U8[3], U8[2], U8[1], U8[0],
541                bit[0],bit[1],bit[2],bit[3],bit[4],bit[5],bit[6],bit[7]);
542               
543
544                temp1 = simd_andc(bit[1], bit[0]);
545                temp2 = simd_andc(bit[3], bit[2]);
546                temp3 = simd_and(temp1, temp2);
547                temp4 = simd_and(bit[4], bit[5]);
548                temp5 = simd_or(bit[6], bit[7]);
549                temp6 = simd_andc(temp4, temp5);
550                BackSlash = simd_and(temp3, temp6);
551                temp7 = simd_or(bit[0], bit[1]);
552                temp8 = simd_andc(bit[2], bit[3]);
553                temp9 = simd_andc(temp8, temp7);
554                temp10 = simd_or(bit[4], bit[5]);
555                temp11 = simd_andc(bit[6], bit[7]);
556                temp12 = simd_andc(temp11, temp10);
557                DQuote = simd_and(temp9, temp12);
558                temp13 = simd_andc(bit[5], bit[4]);
559                temp14 = simd_and(bit[6], bit[7]);
560                temp15 = simd_and(temp13, temp14);
561                SQuote = simd_and(temp9, temp15);
562                temp16 = simd_or(bit[2], bit[3]);
563                temp17 = simd_or(temp7, temp16);
564                temp18 = simd_andc(bit[7], bit[6]);
565                temp19 = simd_and(temp4, temp18);
566                CR = simd_andc(temp19, temp17);
567                temp20 = simd_andc(bit[4], bit[5]);
568                temp21 = simd_and(temp20, temp11);
569                LF = simd_andc(temp21, temp17);
570                Comma = simd_and(temp9, temp6);
571                temp22 = simd_and(temp20, temp18);
572                HT = simd_andc(temp22, temp17);
573
574                p2 = simd_xor(DQuote,simd_slli_128(DQuote,1));
575                p4 = simd_xor(p2,simd_slli_128(p2,2));
576                p8 = simd_xor(p4,simd_slli_128(p4,4));
577                p16 = simd_xor(p8,simd_slli_128(p8,8));
578                p32 = simd_xor(p16,simd_slli_128(p16,16));
579                p64 = simd_xor(p32,simd_slli_128(p32,32));
580                quote_mask = simd_xor(p64,simd_slli_128(p64,64));
581                quote_mask = simd_xor(quote_base,quote_mask);
582                quote_base = simd_shufflei_32(simd_srai_32(quote_mask,31),0xFF);
583
584
585                Delim = simd_andc(Comma,quote_mask);
586                EOL =  simd_andc(simd_or(simd_slli_128(CR,1),LF),quote_mask);
587
588                cstate->EOL_stream[block_pos/BLOCK_SIZE_BITS]=EOL;
589                cstate->delim_stream[block_pos/BLOCK_SIZE_BITS]=Delim;
590
591                block_pos += chars_read;
592        }while (chars_read == BLOCK_SIZE_BITS);
593}
594
595void direct_bitstream_gen(CopyState cstate) {
596
597
598        BitBlock Quote;
599        BitBlock EOL;
600        BitBlock CR;
601        BitBlock LF;
602       
603        BitBlock p2;
604        BitBlock p4;   
605        BitBlock p8;
606        BitBlock p16;
607        BitBlock p32;
608        BitBlock p64;
609        BitBlock quote_mask;
610        BitBlock quote_base;
611        BitBlock quote_splat;
612        BitBlock CR_splat;
613        BitBlock LF_splat;
614        BytePack * bytepack;
615       
616       
617        int block_pos = 0;
618        int i=0;
619        int chars_read = 0;
620       
621
622        quote_base = simd_const_8(0);
623
624        quote_splat = simd_const_8(cstate->quote[0]);
625        CR_splat = simd_const_8('\r');
626        LF_splat = simd_const_8('\n');
627
628        bytepack = simd_new(8);
629       
630        do{
631                bytepack = (BytePack *)(&(cstate->raw_buf[block_pos]));
632               
633                chars_read = min(cstate->raw_buf_len-block_pos,BLOCK_SIZE_BITS);
634                if(chars_read==0)break;
635                for (i = chars_read;i < BLOCK_SIZE_BITS; i++) {
636                        ((char *) bytepack)[i] = 0;
637                }
638
639                for(i=0;i<8;i++){
640                        ((short*)&Quote)[i] = (short)_mm_movemask_epi8(simd_eq_8(bytepack[i], quote_splat));
641                        ((short*)&CR)[i] = (short)_mm_movemask_epi8(simd_eq_8(bytepack[i], CR_splat));
642                        ((short*)&LF)[i] = (short)_mm_movemask_epi8(simd_eq_8(bytepack[i], LF_splat));
643                }
644
645                p2 = simd_xor(Quote,simd_slli_128(Quote,1));
646                p4 = simd_xor(p2,simd_slli_128(p2,2));
647                p8 = simd_xor(p4,simd_slli_128(p4,4));
648                p16 = simd_xor(p8,simd_slli_128(p8,8));
649                p32 = simd_xor(p16,simd_slli_128(p16,16));
650                p64 = simd_xor(p32,simd_slli_128(p32,32));
651                quote_mask = simd_xor(p64,simd_slli_128(p64,64));
652                quote_mask = simd_xor(quote_base,quote_mask);
653                quote_base = simd_shufflei_32(simd_srai_32(quote_mask,31),0xFF);
654
655                EOL =  simd_andc(simd_or(simd_slli_128(CR,1),LF),quote_mask);
656
657                cstate->EOL_stream[block_pos/BLOCK_SIZE_BITS]=EOL;
658
659
660                block_pos += chars_read;
661        }while (chars_read == BLOCK_SIZE_BITS);
662}
663
664void direct_bitstream_gen_with_escape(CopyState cstate) {
665
666
667        BitBlock Quote;
668        BitBlock EOL;
669        BitBlock CR;
670        BitBlock LF;
671        BitBlock Escape;
672       
673        BitBlock p2;
674        BitBlock p4;   
675        BitBlock p8;
676        BitBlock p16;
677        BitBlock p32;
678        BitBlock p64;
679        BitBlock quote_mask;
680        BitBlock quote_base;
681        BitBlock quote_splat;
682        BitBlock escape_splat;
683        BitBlock CR_splat;
684        BitBlock LF_splat;
685        BytePack * bytepack;
686       
687        int carry0=0;
688        int carry1=0;
689        int carry2=0;
690        BitBlock even;
691        BitBlock odd;
692        BitBlock start;
693        BitBlock even_start;
694        BitBlock even_final;
695        BitBlock odd_start;
696        BitBlock odd_final;
697        BitBlock escape;
698        BitBlock temp0;
699        BitBlock temp1;
700        BitBlock temp2;
701        BitBlock escape_outof_quote;
702        BitBlock cursor;
703        BitBlock temp_Quote;
704       
705        int block_pos = 0;
706        int i=0;
707        int chars_read = 0;
708       
709        quote_base = simd_const_8(0);
710
711        quote_splat = simd_const_8(cstate->quote[0]);
712        escape_splat = simd_const_8(cstate->escape[0]);
713        CR_splat = simd_const_8('\r');
714        LF_splat = simd_const_8('\n');
715
716        bytepack = simd_new(8);
717       
718        do{
719                bytepack = (BytePack *)(&(cstate->raw_buf[block_pos]));
720               
721                chars_read = min(cstate->raw_buf_len-block_pos,BLOCK_SIZE_BITS);
722                if(chars_read==0)break;
723                for (i = chars_read;i < BLOCK_SIZE_BITS; i++) {
724                        ((char *) bytepack)[i] = 0;
725                }
726
727                for(i=0;i<8;i++){
728                        ((short*)&Quote)[i] = (short)_mm_movemask_epi8(simd_eq_8(bytepack[i], quote_splat));
729                        ((short*)&CR)[i] = (short)_mm_movemask_epi8(simd_eq_8(bytepack[i], CR_splat));
730                        ((short*)&LF)[i] = (short)_mm_movemask_epi8(simd_eq_8(bytepack[i], LF_splat)); 
731                        ((short*)&Escape)[i] = (short)_mm_movemask_epi8(simd_eq_8(bytepack[i], escape_splat));
732                }
733               
734                if(bitblock_has_bit(Escape)){
735                        odd = simd_const_2(1);
736                        even = simd_const_2(2);
737       
738                        adc128(Escape,Escape,carry0,temp0);
739                        start = simd_andc(Escape,temp0);
740                        even_start = simd_and(start,even);
741                        adc128(even_start, Escape, carry1, temp1);
742                        even_final = simd_andc(temp1,Escape);
743                        escape = simd_and(even_final,odd);
744                       
745                        odd_start = simd_and(start,odd);
746                        adc128(odd_start, Escape, carry2, temp2);
747                        odd_final = simd_andc(temp2,Escape);
748                        escape = simd_or(escape, simd_and(odd_final,even));
749               
750                        temp_Quote = simd_andc(Quote,escape);                                           
751                        p2 = simd_xor(temp_Quote,simd_slli_128(temp_Quote,1));
752                        p4 = simd_xor(p2,simd_slli_128(p2,2));
753                        p8 = simd_xor(p4,simd_slli_128(p4,4));
754                        p16 = simd_xor(p8,simd_slli_128(p8,8));
755                        p32 = simd_xor(p16,simd_slli_128(p16,16));
756                        p64 = simd_xor(p32,simd_slli_128(p32,32));
757                        quote_mask = simd_xor(p64,simd_slli_128(p64,64));
758                        quote_mask = simd_xor(quote_base,quote_mask);
759
760                        escape_outof_quote = simd_andc(escape,quote_mask);
761                        while (bitblock_has_bit(escape_outof_quote)){
762                                cursor = sisd_from_int(1);
763                                cursor = simd_and(simd_add_64(cursor, simd_not(escape_outof_quote)),escape_outof_quote);
764                                escape = simd_andc(escape, cursor);
765                                temp_Quote = simd_andc(Quote,escape);
766                                p2 = simd_xor(temp_Quote,simd_slli_128(temp_Quote,1));
767                                p4 = simd_xor(p2,simd_slli_128(p2,2));
768                                p8 = simd_xor(p4,simd_slli_128(p4,4));
769                                p16 = simd_xor(p8,simd_slli_128(p8,8));
770                                p32 = simd_xor(p16,simd_slli_128(p16,16));
771                                p64 = simd_xor(p32,simd_slli_128(p32,32));
772                                quote_mask = simd_xor(p64,simd_slli_128(p64,64));
773                                quote_mask = simd_xor(quote_base,quote_mask);
774                                escape_outof_quote = simd_andc(escape,quote_mask);
775                                break;
776                        }
777                       
778                        quote_base = simd_shufflei_32(simd_srai_32(quote_mask,31),0xFF);
779                        Quote = temp_Quote;
780                }
781                else{
782                        p2 = simd_xor(Quote,simd_slli_128(Quote,1));
783                        p4 = simd_xor(p2,simd_slli_128(p2,2));
784                        p8 = simd_xor(p4,simd_slli_128(p4,4));
785                        p16 = simd_xor(p8,simd_slli_128(p8,8));
786                        p32 = simd_xor(p16,simd_slli_128(p16,16));
787                        p64 = simd_xor(p32,simd_slli_128(p32,32));
788                        quote_mask = simd_xor(p64,simd_slli_128(p64,64));
789                        quote_mask = simd_xor(quote_base,quote_mask);
790                        quote_base = simd_shufflei_32(simd_srai_32(quote_mask,31),0xFF);
791                }
792
793                EOL =  simd_andc(simd_or(simd_slli_128(CR,1),LF),quote_mask);
794                cstate->EOL_stream[block_pos/BLOCK_SIZE_BITS]=EOL;
795
796
797                block_pos += chars_read;
798        }while (chars_read == BLOCK_SIZE_BITS);
799}
Note: See TracBrowser for help on using the repository browser.