Ignore:
Timestamp:
Mar 27, 2010, 2:14:44 PM (10 years ago)
Author:
lindanl
Message:

Direct bit stream generation; Parallel prefix quote mask.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • proto/CSV/postgres/copy_simd.c

    r383 r384  
    167167}while(0)
    168168
    169 void bitstream_gen2(CopyState cstate) {
    170 
    171 
    172         int carry1=0;
    173         int carry0=0;
    174         int carry3=0;
    175         int carry2=0;
    176         int carry5=0;
    177         int carry4=0;
    178         int carry7=0;
    179         int carry6=0;
    180         int carry5_i=0;
    181         int CarryTemp36=0;
    182         int carry4_i=0;
    183         int carry6_i=0;
    184         int carry3_i=0;
    185         int carry_brw0=0;
    186         BitBlock array_bit__6_;
    187         BitBlock _strct_csvclass__classify_bytes__strct_lex__CR_;
    188         BitBlock quote_end;
    189         BitBlock _strct_csvclass__classify_bytes__strct_lex__Comma_;
    190         BitBlock start;
    191         BitBlock _strct_csvclass__classify_bytes__temp16;
    192         BitBlock _strct_csvclass__classify_bytes__temp17;
    193         BitBlock _strct_csvclass__classify_bytes__temp10;
    194         BitBlock array_bit__2_;
    195         BitBlock _strct_csvclass__classify_bytes__temp12;
    196         BitBlock _strct_csvclass__classify_bytes__temp18;
    197         BitBlock _strct_csvclass__classify_bytes__temp19;
    198         BitBlock _strct_csvclass__classify_bytes__temp11;
    199         BitBlock array_bit__7_;
    200         BitBlock even_start;
    201         BitBlock _strct_csvclass__classify_bytes__temp9;
    202         BitBlock odd_final;
    203         BitBlock quote_mask;
    204         BitBlock escape_0;
    205         BitBlock _strct_csvclass__classify_bytes__temp21;
    206         BitBlock _strct_csvclass__classify_bytes__temp20;
    207         BitBlock array_bit__3_;
    208         BitBlock _strct_csvclass__classify_bytes__strct_lex__BackSlash_;
    209         BitBlock quote_start;
    210         BitBlock _strct_csvclass__classify_bytes__temp6;
    211         BitBlock _strct_csvclass__classify_bytes__temp7;
    212         BitBlock _strct_csvclass__classify_bytes__temp4;
    213         BitBlock _strct_csvclass__classify_bytes__temp5;
    214         BitBlock _strct_csvclass__classify_bytes__temp2;
    215         BitBlock _strct_csvclass__classify_bytes__temp3;
    216         BitBlock _strct_csvclass__classify_bytes__temp1;
    217         BitBlock delim;
    218         BitBlock _strct_csvclass__classify_bytes__temp8;
    219         BitBlock CSV_cursor;
    220         BitBlock Temp17;
    221         BitBlock Temp16;
    222         BitBlock escape;
    223         BitBlock eol;
    224         BitBlock odd;
    225         BitBlock even;
    226         BitBlock array_bit__4_;
    227         BitBlock array_bit__0_;
    228         BitBlock quote;
    229         BitBlock odd_start;
    230         BitBlock array_bit__5_;
    231         BitBlock _strct_csvclass__classify_bytes__strct_lex__DQuote_;
    232         BitBlock AllOne = simd_const_1(1);
    233         BitBlock AllZero = simd_const_1(0);
    234         BitBlock even_final;
    235         BitBlock Temp23;
    236         BitBlock _strct_csvclass__classify_bytes__strct_lex__LF_;
    237         BitBlock Temp24;
    238         BitBlock Temp25;
    239         BitBlock Temp3;
    240         BitBlock Temp2;
    241         BitBlock Temp1;
    242         BitBlock Temp7;
    243         BitBlock Temp4;
    244         BitBlock array_bit__1_;
    245         BitBlock Temp8;
    246 
    247 
    248 
    249         BytePack * U8;
    250 
    251         int block_pos = 0;
    252         int i=0;
    253         int chars_read = 0;
    254        
    255 
    256         U8 = simd_new(8);
    257        
    258         do{
    259                 U8 = (BytePack *)(&(cstate->raw_buf[block_pos]));       
    260                 chars_read = min(cstate->raw_buf_len-block_pos,BLOCK_SIZE_BITS);
    261                 if(chars_read==0)break;
    262                 for (i = chars_read;i < BLOCK_SIZE_BITS; i++) {
    263                         ((char *) U8)[i] = 0;
    264                 }
    265 
    266                 s2p_bytepack(U8[7], U8[6], U8[5], U8[4], U8[3], U8[2], U8[1], U8[0],
    267                 array_bit__0_,array_bit__1_,array_bit__2_,array_bit__3_,array_bit__4_,array_bit__5_,array_bit__6_,array_bit__7_);
    268                
    269                 odd = simd_const_2(1);
    270                 even = simd_const_2(2);
    271        
    272                 _strct_csvclass__classify_bytes__temp1 = simd_andc(array_bit__1_,array_bit__0_);
    273                 _strct_csvclass__classify_bytes__temp2 = simd_andc(array_bit__3_,array_bit__2_);
    274                 _strct_csvclass__classify_bytes__temp3 = simd_and(_strct_csvclass__classify_bytes__temp1,_strct_csvclass__classify_bytes__temp2);
    275                 _strct_csvclass__classify_bytes__temp4 = simd_and(array_bit__4_,array_bit__5_);
    276                 _strct_csvclass__classify_bytes__temp5 = simd_or(array_bit__6_,array_bit__7_);
    277                 _strct_csvclass__classify_bytes__temp6 = simd_andc(_strct_csvclass__classify_bytes__temp4,_strct_csvclass__classify_bytes__temp5);
    278                 _strct_csvclass__classify_bytes__strct_lex__BackSlash_ = simd_and(_strct_csvclass__classify_bytes__temp3,_strct_csvclass__classify_bytes__temp6);
    279                 _strct_csvclass__classify_bytes__temp7 = simd_or(array_bit__0_,array_bit__1_);
    280                 _strct_csvclass__classify_bytes__temp8 = simd_andc(array_bit__2_,array_bit__3_);
    281                 _strct_csvclass__classify_bytes__temp9 = simd_andc(_strct_csvclass__classify_bytes__temp8,_strct_csvclass__classify_bytes__temp7);
    282                 _strct_csvclass__classify_bytes__temp10 = simd_or(array_bit__4_,array_bit__5_);
    283                 _strct_csvclass__classify_bytes__temp11 = simd_andc(array_bit__6_,array_bit__7_);
    284                 _strct_csvclass__classify_bytes__temp12 = simd_andc(_strct_csvclass__classify_bytes__temp11,_strct_csvclass__classify_bytes__temp10);
    285                 _strct_csvclass__classify_bytes__strct_lex__DQuote_ = simd_and(_strct_csvclass__classify_bytes__temp9,_strct_csvclass__classify_bytes__temp12);
    286                 _strct_csvclass__classify_bytes__temp16 = simd_or(array_bit__2_,array_bit__3_);
    287                 _strct_csvclass__classify_bytes__temp17 = simd_or(_strct_csvclass__classify_bytes__temp7,_strct_csvclass__classify_bytes__temp16);
    288                 _strct_csvclass__classify_bytes__temp18 = simd_andc(array_bit__7_,array_bit__6_);
    289                 _strct_csvclass__classify_bytes__temp19 = simd_and(_strct_csvclass__classify_bytes__temp4,_strct_csvclass__classify_bytes__temp18);
    290                 _strct_csvclass__classify_bytes__strct_lex__CR_ = simd_andc(_strct_csvclass__classify_bytes__temp19,_strct_csvclass__classify_bytes__temp17);
    291                 _strct_csvclass__classify_bytes__temp20 = simd_andc(array_bit__4_,array_bit__5_);
    292                 _strct_csvclass__classify_bytes__temp21 = simd_and(_strct_csvclass__classify_bytes__temp20,_strct_csvclass__classify_bytes__temp11);
    293                 _strct_csvclass__classify_bytes__strct_lex__LF_ = simd_andc(_strct_csvclass__classify_bytes__temp21,_strct_csvclass__classify_bytes__temp17);
    294                 _strct_csvclass__classify_bytes__strct_lex__Comma_ = simd_and(_strct_csvclass__classify_bytes__temp9,_strct_csvclass__classify_bytes__temp6);
    295                 adc128(_strct_csvclass__classify_bytes__strct_lex__BackSlash_, _strct_csvclass__classify_bytes__strct_lex__BackSlash_, carry0, Temp1);
    296                 start = simd_andc(_strct_csvclass__classify_bytes__strct_lex__BackSlash_,Temp1);
    297                 even_start = simd_and(start,even);
    298                 adc128(even_start, _strct_csvclass__classify_bytes__strct_lex__BackSlash_, carry1, Temp2);
    299                 even_final = simd_andc(Temp2,_strct_csvclass__classify_bytes__strct_lex__BackSlash_);
    300                 escape_0 = simd_and(even_final,odd);
    301                 odd_start = simd_and(start,odd);
    302                 adc128(odd_start, _strct_csvclass__classify_bytes__strct_lex__BackSlash_, carry2, Temp3);
    303                 odd_final = simd_andc(Temp3,_strct_csvclass__classify_bytes__strct_lex__BackSlash_);
    304                 Temp4 = simd_and(odd_final,even);
    305                 escape = simd_or(escape_0,Temp4);
    306                 quote = simd_andc(_strct_csvclass__classify_bytes__strct_lex__DQuote_,escape);
    307                 CSV_cursor = sisd_from_int(1);
    308                
    309                 while (bitblock_has_bit(CSV_cursor)|CarryTemp36>0) {
    310                 CarryTemp36 = 0;
    311                 Temp7 = simd_andc(AllOne,quote);
    312                 adc128(CSV_cursor, Temp7, carry3, Temp8);
    313                 CSV_cursor = simd_and(Temp8,quote);
    314                 quote_start = simd_or(quote_start,CSV_cursor);
    315                 adc128(CSV_cursor, CSV_cursor, carry4, CSV_cursor);
    316                 Temp16 = simd_andc(AllOne,quote);
    317                 adc128(CSV_cursor, Temp16, carry5, Temp17);
    318                 CSV_cursor = simd_and(Temp17,quote);
    319                 quote_end = simd_or(quote_end,CSV_cursor);
    320                 adc128(CSV_cursor, CSV_cursor, carry6, CSV_cursor);
    321                 carry3_i = carry3_i|carry3;
    322                 carry4_i = carry4_i|carry4;
    323                 carry5_i = carry5_i|carry5;
    324                 carry6_i = carry6_i|carry6;
    325                 carry3 = 0;
    326                 carry4 = 0;
    327                 carry5 = 0;
    328                 carry6 = 0;
    329                 }
    330                 carry6 = carry6_i;
    331                 carry5 = carry5_i;
    332                 carry4 = carry4_i;
    333                 carry3 = carry3_i;
    334                 carry6_i = 0;
    335                 carry5_i = 0;
    336                 carry4_i = 0;
    337                 carry3_i = 0;
    338                 CarryTemp36 = carry3|carry4;
    339                 CarryTemp36 = CarryTemp36|carry6;
    340                 CarryTemp36 = CarryTemp36|carry5;
    341                 sbb128(quote_end, quote_start, carry_brw0, quote_mask);
    342                 Temp23 = simd_andc(_strct_csvclass__classify_bytes__strct_lex__CR_,quote_mask);
    343                 adc128(Temp23, Temp23, carry7, Temp24);
    344                 Temp25 = simd_andc(_strct_csvclass__classify_bytes__strct_lex__LF_,quote_mask);
    345                 eol = simd_or(Temp24,Temp25);
    346                 delim = simd_andc(_strct_csvclass__classify_bytes__strct_lex__Comma_,quote_mask);
    347 
    348                                
    349                 cstate->EOL_stream[block_pos/BLOCK_SIZE_BITS]=eol;
    350                 cstate->delim_stream[block_pos/BLOCK_SIZE_BITS]=delim;
    351 
    352                 block_pos += chars_read;
    353         }while (chars_read == BLOCK_SIZE_BITS);
    354 }
    355 
     169/*
    356170void bitstream_gen(CopyState cstate) {
    357171
     
    506320                block_pos += chars_read;
    507321        }while (chars_read == BLOCK_SIZE_BITS);
     322}*/
     323/*quote as '\'',escape as '\\'*/
     324void bitstream_gen3(CopyState cstate) {
     325
     326
     327        BitBlock temp1;
     328        BitBlock temp2;
     329        BitBlock temp3;
     330        BitBlock temp4;
     331        BitBlock temp5;
     332        BitBlock temp6;
     333        BitBlock temp7;
     334        BitBlock temp8;
     335        BitBlock temp9;
     336        BitBlock temp10;
     337        BitBlock temp11;
     338        BitBlock temp12;
     339        BitBlock temp13;
     340        BitBlock temp14;
     341        BitBlock temp15;
     342        BitBlock temp16;
     343        BitBlock temp17;
     344        BitBlock temp18;
     345        BitBlock temp19;
     346        BitBlock temp20;
     347        BitBlock temp21;
     348        BitBlock temp22;
     349        BitBlock temp23;
     350        BitBlock temp24;
     351        BitBlock temp25;
     352       
     353        BitBlock CR;
     354        BitBlock LF;
     355        BitBlock Comma;
     356        BitBlock DQuote;
     357        BitBlock SQuote;
     358        BitBlock HT;
     359        BitBlock EOL;
     360        BitBlock Delim;
     361       
     362        BitBlock p2;
     363        BitBlock p4;   
     364        BitBlock p8;
     365        BitBlock p16;
     366        BitBlock p32;
     367        BitBlock p64;
     368        BitBlock quote_mask;
     369        BitBlock BackSlash;
     370        BitBlock quote_base;
     371
     372        BytePack * U8;
     373        BitBlock * bit;
     374
     375        int block_pos = 0;
     376        int i=0;
     377        int chars_read = 0;
     378       
     379
     380        quote_base = simd_const_8(0);
     381
     382        U8 = simd_new(8);
     383        bit = simd_new(8);
     384        do{
     385                U8 = (BytePack *)(&(cstate->raw_buf[block_pos]));       
     386                chars_read = min(cstate->raw_buf_len-block_pos,BLOCK_SIZE_BITS);
     387                if(chars_read==0)break;
     388                for (i = chars_read;i < BLOCK_SIZE_BITS; i++) {
     389                        ((char *) U8)[i] = 0;
     390                }
     391
     392                s2p_bytepack(U8[7], U8[6], U8[5], U8[4], U8[3], U8[2], U8[1], U8[0],
     393                bit[0],bit[1],bit[2],bit[3],bit[4],bit[5],bit[6],bit[7]);
     394               
     395
     396                temp1 = simd_andc(bit[1], bit[0]);
     397                temp2 = simd_andc(bit[3], bit[2]);
     398                temp3 = simd_and(temp1, temp2);
     399                temp4 = simd_and(bit[4], bit[5]);
     400                temp5 = simd_or(bit[6], bit[7]);
     401                temp6 = simd_andc(temp4, temp5);
     402                BackSlash = simd_and(temp3, temp6);
     403                temp7 = simd_or(bit[0], bit[1]);
     404                temp8 = simd_andc(bit[2], bit[3]);
     405                temp9 = simd_andc(temp8, temp7);
     406                temp10 = simd_or(bit[4], bit[5]);
     407                temp11 = simd_andc(bit[6], bit[7]);
     408                temp12 = simd_andc(temp11, temp10);
     409                DQuote = simd_and(temp9, temp12);
     410                temp13 = simd_andc(bit[5], bit[4]);
     411                temp14 = simd_and(bit[6], bit[7]);
     412                temp15 = simd_and(temp13, temp14);
     413                SQuote = simd_and(temp9, temp15);
     414                temp16 = simd_or(bit[2], bit[3]);
     415                temp17 = simd_or(temp7, temp16);
     416                temp18 = simd_andc(bit[7], bit[6]);
     417                temp19 = simd_and(temp4, temp18);
     418                CR = simd_andc(temp19, temp17);
     419                temp20 = simd_andc(bit[4], bit[5]);
     420                temp21 = simd_and(temp20, temp11);
     421                LF = simd_andc(temp21, temp17);
     422                Comma = simd_and(temp9, temp6);
     423                temp22 = simd_and(temp20, temp18);
     424                HT = simd_andc(temp22, temp17);
     425               
     426                int carry0=0;
     427                int carry1=0;
     428                int carry2=0;
     429                BitBlock even;
     430                BitBlock odd;
     431                BitBlock start;
     432                BitBlock even_start;
     433                BitBlock even_final;
     434                BitBlock odd_start;
     435                BitBlock odd_final;
     436                BitBlock escape;
     437
     438                odd = simd_const_2(1);
     439                even = simd_const_2(2);
     440
     441                adc128(BackSlash,BackSlash,carry0,temp23);
     442                start = simd_andc(BackSlash,temp23);
     443                even_start = simd_and(start,even);
     444                adc128(even_start, BackSlash, carry1, temp24);
     445                even_final = simd_andc(temp24,BackSlash);
     446                escape = simd_and(even_final,odd);
     447               
     448                odd_start = simd_and(start,odd);
     449                adc128(odd_start, BackSlash, carry2, temp25);
     450                odd_final = simd_andc(temp25,BackSlash);
     451                escape = simd_or(escape, simd_and(odd_final,even));
     452       
     453                SQuote = simd_andc(SQuote,escape);
     454
     455                p2 = simd_xor(SQuote,simd_slli_128(SQuote,1));
     456                p4 = simd_xor(p2,simd_slli_128(p2,2));
     457                p8 = simd_xor(p4,simd_slli_128(p4,4));
     458                p16 = simd_xor(p8,simd_slli_128(p8,8));
     459                p32 = simd_xor(p16,simd_slli_128(p16,16));
     460                p64 = simd_xor(p32,simd_slli_128(p32,32));
     461                quote_mask = simd_xor(p64,simd_slli_128(p64,64));
     462                quote_mask = simd_xor(quote_base,quote_mask);
     463                quote_base = simd_shufflei_32(simd_srai_32(quote_mask,31),0xFF);
     464
     465
     466                Delim = simd_andc(Comma,quote_mask);
     467                EOL =  simd_andc(simd_or(simd_slli_128(CR,1),LF),quote_mask);
     468
     469                cstate->EOL_stream[block_pos/BLOCK_SIZE_BITS]=EOL;
     470                cstate->delim_stream[block_pos/BLOCK_SIZE_BITS]=Delim;
     471
     472                block_pos += chars_read;
     473        }while (chars_read == BLOCK_SIZE_BITS);
    508474}
     475/*quote and escape as '\"'*/
     476void bitstream_gen(CopyState cstate) {
     477
     478
     479        BitBlock temp1;
     480        BitBlock temp2;
     481        BitBlock temp3;
     482        BitBlock temp4;
     483        BitBlock temp5;
     484        BitBlock temp6;
     485        BitBlock temp7;
     486        BitBlock temp8;
     487        BitBlock temp9;
     488        BitBlock temp10;
     489        BitBlock temp11;
     490        BitBlock temp12;
     491        BitBlock temp13;
     492        BitBlock temp14;
     493        BitBlock temp15;
     494        BitBlock temp16;
     495        BitBlock temp17;
     496        BitBlock temp18;
     497        BitBlock temp19;
     498        BitBlock temp20;
     499        BitBlock temp21;
     500        BitBlock temp22;
     501       
     502        BitBlock CR;
     503        BitBlock LF;
     504        BitBlock Comma;
     505        BitBlock DQuote;
     506        BitBlock SQuote;
     507        BitBlock HT;
     508        BitBlock EOL;
     509        BitBlock Delim;
     510       
     511        BitBlock p2;
     512        BitBlock p4;   
     513        BitBlock p8;
     514        BitBlock p16;
     515        BitBlock p32;
     516        BitBlock p64;
     517        BitBlock quote_mask;
     518        BitBlock BackSlash;
     519        BitBlock quote_base;
     520
     521        BytePack * U8;
     522        BitBlock * bit;
     523
     524        int block_pos = 0;
     525        int i=0;
     526        int chars_read = 0;
     527       
     528
     529        quote_base = simd_const_8(0);
     530
     531        U8 = simd_new(8);
     532        bit = simd_new(8);
     533        do{
     534                U8 = (BytePack *)(&(cstate->raw_buf[block_pos]));       
     535                chars_read = min(cstate->raw_buf_len-block_pos,BLOCK_SIZE_BITS);
     536                if(chars_read==0)break;
     537                for (i = chars_read;i < BLOCK_SIZE_BITS; i++) {
     538                        ((char *) U8)[i] = 0;
     539                }
     540
     541                s2p_bytepack(U8[7], U8[6], U8[5], U8[4], U8[3], U8[2], U8[1], U8[0],
     542                bit[0],bit[1],bit[2],bit[3],bit[4],bit[5],bit[6],bit[7]);
     543               
     544
     545                temp1 = simd_andc(bit[1], bit[0]);
     546                temp2 = simd_andc(bit[3], bit[2]);
     547                temp3 = simd_and(temp1, temp2);
     548                temp4 = simd_and(bit[4], bit[5]);
     549                temp5 = simd_or(bit[6], bit[7]);
     550                temp6 = simd_andc(temp4, temp5);
     551                BackSlash = simd_and(temp3, temp6);
     552                temp7 = simd_or(bit[0], bit[1]);
     553                temp8 = simd_andc(bit[2], bit[3]);
     554                temp9 = simd_andc(temp8, temp7);
     555                temp10 = simd_or(bit[4], bit[5]);
     556                temp11 = simd_andc(bit[6], bit[7]);
     557                temp12 = simd_andc(temp11, temp10);
     558                DQuote = simd_and(temp9, temp12);
     559                temp13 = simd_andc(bit[5], bit[4]);
     560                temp14 = simd_and(bit[6], bit[7]);
     561                temp15 = simd_and(temp13, temp14);
     562                SQuote = simd_and(temp9, temp15);
     563                temp16 = simd_or(bit[2], bit[3]);
     564                temp17 = simd_or(temp7, temp16);
     565                temp18 = simd_andc(bit[7], bit[6]);
     566                temp19 = simd_and(temp4, temp18);
     567                CR = simd_andc(temp19, temp17);
     568                temp20 = simd_andc(bit[4], bit[5]);
     569                temp21 = simd_and(temp20, temp11);
     570                LF = simd_andc(temp21, temp17);
     571                Comma = simd_and(temp9, temp6);
     572                temp22 = simd_and(temp20, temp18);
     573                HT = simd_andc(temp22, temp17);
     574
     575                p2 = simd_xor(DQuote,simd_slli_128(DQuote,1));
     576                p4 = simd_xor(p2,simd_slli_128(p2,2));
     577                p8 = simd_xor(p4,simd_slli_128(p4,4));
     578                p16 = simd_xor(p8,simd_slli_128(p8,8));
     579                p32 = simd_xor(p16,simd_slli_128(p16,16));
     580                p64 = simd_xor(p32,simd_slli_128(p32,32));
     581                quote_mask = simd_xor(p64,simd_slli_128(p64,64));
     582                quote_mask = simd_xor(quote_base,quote_mask);
     583                quote_base = simd_shufflei_32(simd_srai_32(quote_mask,31),0xFF);
     584
     585
     586                Delim = simd_andc(Comma,quote_mask);
     587                EOL =  simd_andc(simd_or(simd_slli_128(CR,1),LF),quote_mask);
     588
     589                cstate->EOL_stream[block_pos/BLOCK_SIZE_BITS]=EOL;
     590                cstate->delim_stream[block_pos/BLOCK_SIZE_BITS]=Delim;
     591
     592                block_pos += chars_read;
     593        }while (chars_read == BLOCK_SIZE_BITS);
     594}
     595
     596void direct_bitstream_gen(CopyState cstate) {
     597
     598
     599        BitBlock Quote;
     600        BitBlock EOL;
     601        BitBlock CR;
     602        BitBlock LF;
     603       
     604        BitBlock p2;
     605        BitBlock p4;   
     606        BitBlock p8;
     607        BitBlock p16;
     608        BitBlock p32;
     609        BitBlock p64;
     610        BitBlock quote_mask;
     611        BitBlock quote_base;
     612        BitBlock quote_splat;
     613        BitBlock CR_splat;
     614        BitBlock LF_splat;
     615        BytePack * bytepack;
     616       
     617       
     618        int block_pos = 0;
     619        int i=0;
     620        int chars_read = 0;
     621       
     622
     623        quote_base = simd_const_8(0);
     624
     625        quote_splat = simd_const_8(cstate->quote[0]);
     626        CR_splat = simd_const_8('\r');
     627        LF_splat = simd_const_8('\n');
     628
     629        bytepack = simd_new(8);
     630       
     631        do{
     632                bytepack = (BytePack *)(&(cstate->raw_buf[block_pos]));
     633               
     634                chars_read = min(cstate->raw_buf_len-block_pos,BLOCK_SIZE_BITS);
     635                if(chars_read==0)break;
     636                for (i = chars_read;i < BLOCK_SIZE_BITS; i++) {
     637                        ((char *) bytepack)[i] = 0;
     638                }
     639
     640                for(i=0;i<8;i++){
     641                        ((short*)&Quote)[i] = (short)_mm_movemask_epi8(simd_eq_8(bytepack[i], quote_splat));
     642                        ((short*)&CR)[i] = (short)_mm_movemask_epi8(simd_eq_8(bytepack[i], CR_splat));
     643                        ((short*)&LF)[i] = (short)_mm_movemask_epi8(simd_eq_8(bytepack[i], LF_splat));
     644                }
     645
     646                p2 = simd_xor(Quote,simd_slli_128(Quote,1));
     647                p4 = simd_xor(p2,simd_slli_128(p2,2));
     648                p8 = simd_xor(p4,simd_slli_128(p4,4));
     649                p16 = simd_xor(p8,simd_slli_128(p8,8));
     650                p32 = simd_xor(p16,simd_slli_128(p16,16));
     651                p64 = simd_xor(p32,simd_slli_128(p32,32));
     652                quote_mask = simd_xor(p64,simd_slli_128(p64,64));
     653                quote_mask = simd_xor(quote_base,quote_mask);
     654                quote_base = simd_shufflei_32(simd_srai_32(quote_mask,31),0xFF);
     655
     656                EOL =  simd_andc(simd_or(simd_slli_128(CR,1),LF),quote_mask);
     657
     658                cstate->EOL_stream[block_pos/BLOCK_SIZE_BITS]=EOL;
     659
     660
     661                block_pos += chars_read;
     662        }while (chars_read == BLOCK_SIZE_BITS);
     663}
     664
     665void direct_bitstream_gen_with_escape(CopyState cstate) {
     666
     667
     668        BitBlock Quote;
     669        BitBlock EOL;
     670        BitBlock CR;
     671        BitBlock LF;
     672        BitBlock Escape;
     673       
     674        BitBlock p2;
     675        BitBlock p4;   
     676        BitBlock p8;
     677        BitBlock p16;
     678        BitBlock p32;
     679        BitBlock p64;
     680        BitBlock quote_mask;
     681        BitBlock quote_base;
     682        BitBlock quote_splat;
     683        BitBlock escape_splat;
     684        BitBlock CR_splat;
     685        BitBlock LF_splat;
     686        BytePack * bytepack;
     687       
     688        int carry0=0;
     689        int carry1=0;
     690        int carry2=0;
     691        BitBlock even;
     692        BitBlock odd;
     693        BitBlock start;
     694        BitBlock even_start;
     695        BitBlock even_final;
     696        BitBlock odd_start;
     697        BitBlock odd_final;
     698        BitBlock escape;
     699        BitBlock temp0;
     700        BitBlock temp1;
     701        BitBlock temp2;
     702        BitBlock escape_outof_quote;
     703        BitBlock cursor;
     704        BitBlock temp_Quote;
     705       
     706        int block_pos = 0;
     707        int i=0;
     708        int chars_read = 0;
     709       
     710        quote_base = simd_const_8(0);
     711
     712        quote_splat = simd_const_8(cstate->quote[0]);
     713        escape_splat = simd_const_8(cstate->escape[0]);
     714        CR_splat = simd_const_8('\r');
     715        LF_splat = simd_const_8('\n');
     716
     717        bytepack = simd_new(8);
     718       
     719        do{
     720                bytepack = (BytePack *)(&(cstate->raw_buf[block_pos]));
     721               
     722                chars_read = min(cstate->raw_buf_len-block_pos,BLOCK_SIZE_BITS);
     723                if(chars_read==0)break;
     724                for (i = chars_read;i < BLOCK_SIZE_BITS; i++) {
     725                        ((char *) bytepack)[i] = 0;
     726                }
     727
     728                for(i=0;i<8;i++){
     729                        ((short*)&Quote)[i] = (short)_mm_movemask_epi8(simd_eq_8(bytepack[i], quote_splat));
     730                        ((short*)&CR)[i] = (short)_mm_movemask_epi8(simd_eq_8(bytepack[i], CR_splat));
     731                        ((short*)&LF)[i] = (short)_mm_movemask_epi8(simd_eq_8(bytepack[i], LF_splat)); 
     732                        ((short*)&Escape)[i] = (short)_mm_movemask_epi8(simd_eq_8(bytepack[i], escape_splat));
     733                }
     734               
     735                if(bitblock_has_bit(Escape)){
     736                        odd = simd_const_2(1);
     737                        even = simd_const_2(2);
     738       
     739                        adc128(Escape,Escape,carry0,temp0);
     740                        start = simd_andc(Escape,temp0);
     741                        even_start = simd_and(start,even);
     742                        adc128(even_start, Escape, carry1, temp1);
     743                        even_final = simd_andc(temp1,Escape);
     744                        escape = simd_and(even_final,odd);
     745                       
     746                        odd_start = simd_and(start,odd);
     747                        adc128(odd_start, Escape, carry2, temp2);
     748                        odd_final = simd_andc(temp2,Escape);
     749                        escape = simd_or(escape, simd_and(odd_final,even));
     750               
     751                        temp_Quote = simd_andc(Quote,escape);                                           
     752                        p2 = simd_xor(temp_Quote,simd_slli_128(temp_Quote,1));
     753                        p4 = simd_xor(p2,simd_slli_128(p2,2));
     754                        p8 = simd_xor(p4,simd_slli_128(p4,4));
     755                        p16 = simd_xor(p8,simd_slli_128(p8,8));
     756                        p32 = simd_xor(p16,simd_slli_128(p16,16));
     757                        p64 = simd_xor(p32,simd_slli_128(p32,32));
     758                        quote_mask = simd_xor(p64,simd_slli_128(p64,64));
     759                        quote_mask = simd_xor(quote_base,quote_mask);
     760
     761                        escape_outof_quote = simd_andc(escape,quote_mask);
     762                        while (bitblock_has_bit(escape_outof_quote)){
     763                                cursor = sisd_from_int(1);
     764                                cursor = simd_and(simd_add_64(cursor, simd_not(escape_outof_quote)),escape_outof_quote);
     765                                escape = simd_andc(escape, cursor);
     766                                temp_Quote = simd_andc(Quote,escape);
     767                                p2 = simd_xor(temp_Quote,simd_slli_128(temp_Quote,1));
     768                                p4 = simd_xor(p2,simd_slli_128(p2,2));
     769                                p8 = simd_xor(p4,simd_slli_128(p4,4));
     770                                p16 = simd_xor(p8,simd_slli_128(p8,8));
     771                                p32 = simd_xor(p16,simd_slli_128(p16,16));
     772                                p64 = simd_xor(p32,simd_slli_128(p32,32));
     773                                quote_mask = simd_xor(p64,simd_slli_128(p64,64));
     774                                quote_mask = simd_xor(quote_base,quote_mask);
     775                                escape_outof_quote = simd_andc(escape,quote_mask);
     776                                break;
     777                        }
     778                       
     779                        quote_base = simd_shufflei_32(simd_srai_32(quote_mask,31),0xFF);
     780                        Quote = temp_Quote;
     781                }
     782                else{
     783                        p2 = simd_xor(Quote,simd_slli_128(Quote,1));
     784                        p4 = simd_xor(p2,simd_slli_128(p2,2));
     785                        p8 = simd_xor(p4,simd_slli_128(p4,4));
     786                        p16 = simd_xor(p8,simd_slli_128(p8,8));
     787                        p32 = simd_xor(p16,simd_slli_128(p16,16));
     788                        p64 = simd_xor(p32,simd_slli_128(p32,32));
     789                        quote_mask = simd_xor(p64,simd_slli_128(p64,64));
     790                        quote_mask = simd_xor(quote_base,quote_mask);
     791                        quote_base = simd_shufflei_32(simd_srai_32(quote_mask,31),0xFF);
     792                }
     793
     794                EOL =  simd_andc(simd_or(simd_slli_128(CR,1),LF),quote_mask);
     795                cstate->EOL_stream[block_pos/BLOCK_SIZE_BITS]=EOL;
     796
     797
     798                block_pos += chars_read;
     799        }while (chars_read == BLOCK_SIZE_BITS);
     800}
Note: See TracChangeset for help on using the changeset viewer.