Changeset 179 for trunk/src/byteplex.c


Ignore:
Timestamp:
Jul 9, 2008, 12:17:19 PM (11 years ago)
Author:
lindanl
Message:

Templated SIMD Library - initial version

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/byteplex.c

    r178 r179  
    119119
    120120
    121 inline void DoDuplex(BytePack * src_data, int packs_in_buffer,
     121void DoDuplex(BytePack * src_data, int packs_in_buffer,
    122122                                         BytePack * p0, BytePack * p1) {
    123123
     
    126126                BytePack s1 = src_data[2*pk+1];
    127127#if (BYTE_ORDER == LITTLE_ENDIAN)
     128#ifdef TEMPLATED_SIMD_LIB
     129                p0[pk] = simd_pack<16,l,l>(s1, s0);
     130                p1[pk] = simd_pack<16,h,h>(s1, s0);
     131#endif
     132#ifndef TEMPLATED_SIMD_LIB
    128133                p0[pk] = simd_pack_16_ll(s1, s0);
    129134                p1[pk] = simd_pack_16_hh(s1, s0);
    130135#endif
     136#endif
    131137#if (BYTE_ORDER == BIG_ENDIAN)
    132                 p0[pk] = simd_pack_16_hh(s0, s1);
    133                 p1[pk] = simd_pack_16_ll(s0, s1);
    134 #endif
    135         }
    136 }
    137 
     138#ifdef TEMPLATED_SIMD_LIB
     139                p0[pk] = simd_pack<16,l,l>(s0, s1);
     140                p1[pk] = simd_pack<16,h,h>(s0, s1);
     141#endif
     142#ifndef TEMPLATED_SIMD_LIB
     143                p0[pk] = simd_pack_16_ll(s0, s1);
     144                p1[pk] = simd_pack_16_hh(s0, s1);
     145#endif
     146#endif
     147        }
     148}
     149                                         
    138150void U16LE_Buffer::DoByteplex() {
    139151        DoDuplex(src_buffer, packs_in_buffer, x16lo, x16hi);
     
    153165                BytePack s3 = src_data[4*pk+3];
    154166#if (BYTE_ORDER == LITTLE_ENDIAN)
     167#ifdef TEMPLATED_SIMD_LIB
     168                BytePack p02_0 = simd_pack<16,l,l>(s1, s0);
     169                BytePack p13_0 = simd_pack<16,h,h>(s1, s0);
     170                BytePack p02_1 = simd_pack<16,l,l>(s3, s2);
     171                BytePack p13_1 = simd_pack<16,h,h>(s3, s2);
     172                p0[pk] = simd_pack<16,l,l>(p02_1, p02_0);
     173                p1[pk] = simd_pack<16,l,l>(p13_1, p13_0);
     174                p2[pk] = simd_pack<16,h,h>(p02_1, p02_0);
     175                p3[pk] = simd_pack<16,h,h>(p13_1, p13_0);
     176#endif
     177#ifndef TEMPLATED_SIMD_LIB
    155178                BytePack p02_0 = simd_pack_16_ll(s1, s0);
    156179                BytePack p13_0 = simd_pack_16_hh(s1, s0);
     
    162185                p3[pk] = simd_pack_16_hh(p13_1, p13_0);
    163186#endif
     187#endif
    164188#if (BYTE_ORDER == BIG_ENDIAN)
     189#ifdef TEMPLATED_SIMD_LIB
     190                BytePack p02_0 = simd_pack<16,h,h>(s0, s1);
     191                BytePack p13_0 = simd_pack<16,l,l>(s0, s1);
     192                BytePack p02_1 = simd_pack<16,h,h>(s2, s3);
     193                BytePack p13_1 = simd_pack<16,l,l>(s2, s3);
     194                p0[pk] = simd_pack<16,h,h>(p02_0, p02_1);
     195                p1[pk] = simd_pack<16,h,h>(p13_0, p13_1);
     196                p2[pk] = simd_pack<16,l,l>(p02_0, p02_1);
     197                p3[pk] = simd_pack<16,l,l>(p13_0, p13_1);
     198#endif
     199#ifndef TEMPLATED_SIMD_LIB
    165200                BytePack p02_0 = simd_pack_16_hh(s0, s1);
    166201                BytePack p13_0 = simd_pack_16_ll(s0, s1);
     
    172207                p3[pk] = simd_pack_16_ll(p13_0, p13_1);
    173208#endif
     209#endif
    174210        }
    175211}
     
    201237void U16_Buffer::PreparePseudoASCII_Stream() {
    202238        for (int pk = 0; pk < packs_in_buffer; pk++) {
    203                 x8data[pk] = simd_or(x16lo[pk],
    204                                      simd_andc(simd_const_8(0x80),
     239#ifdef TEMPLATED_SIMD_LIB
     240                x8data[pk] = simd_or(x16lo[pk], simd_andc(simd_const<8>(0x80),
     241                                               simd_eq<8>(x16hi[pk], simd_const<8>(0))));
     242#endif
     243#ifndef TEMPLATED_SIMD_LIB
     244                x8data[pk] = simd_or(x16lo[pk], simd_andc(simd_const_8(0x80),
    205245                                               simd_eq_8(x16hi[pk], simd_const_8(0))));
     246#endif
    206247        }
    207248}
     
    210251        for (int pk = 0; pk < packs_in_buffer; pk++) {
    211252                BytePack hi = simd_or(simd_or(x32hh[pk], x32hl[pk]), x32lh[pk]);
    212                 x8data[pk] = simd_or(x32ll[pk],
    213                                      simd_andc(simd_const_8(0x80),
     253#ifdef TEMPLATED_SIMD_LIB
     254                x8data[pk] = simd_or(x32ll[pk], simd_andc(simd_const<8>(0x80),
     255                                               simd_eq<8>(hi, simd_const<8>(0))));
     256#endif
     257#ifndef TEMPLATED_SIMD_LIB
     258                x8data[pk] = simd_or(x32ll[pk], simd_andc(simd_const_8(0x80),
    214259                                               simd_eq_8(hi, simd_const_8(0))));
     260#endif
    215261        }
    216262}
     
    238284
    239285template <CodeUnit_Base C>
    240 void X8_Buffer<C>::InitializeBuffer(unsigned char * src, int lgth){
    241         int byte_advance = BYTEPLEX_SIZE - lgth;
     286void X8_Buffer<C>::InitializeBuffer(unsigned char * src, int lgth){     
     287        int byte_advance = BYTEPLEX_SIZE - lgth;       
    242288        int bytes_read = CopyAndFill(src, lgth, byte_advance);
    243289        Set_limits(bytes_read + lgth);
    244290}
    245291
    246 void U16_Buffer::InitializeBuffer(unsigned char * src, int lgth){
    247         int byte_advance = BYTEPLEX_SIZE * 2 - lgth;
     292void U16_Buffer::InitializeBuffer(unsigned char * src, int lgth){       
     293        int byte_advance = BYTEPLEX_SIZE * 2 - lgth;   
    248294        int bytes_read = CopyAndFill(src, lgth, byte_advance);
    249295        if (bytes_read % 2 != 0) {
     
    253299}
    254300
    255 void U32_Buffer::InitializeBuffer(unsigned char * src, int lgth){
    256         int byte_advance = BYTEPLEX_SIZE * 4 - lgth;
     301void U32_Buffer::InitializeBuffer(unsigned char * src, int lgth){       
     302        int byte_advance = BYTEPLEX_SIZE * 4 - lgth;   
    257303        int bytes_read = CopyAndFill(src, lgth, byte_advance);
    258304        if (bytes_read % 4 != 0) {
     
    265311
    266312template <CodeUnit_Base C>
    267 void X8_Buffer<C>::AdvanceInputBuffer(int advance_amt){
    268         int bytes_to_keep = units_in_buffer - advance_amt;
     313void X8_Buffer<C>::AdvanceInputBuffer(int advance_amt){ 
     314        int bytes_to_keep = units_in_buffer - advance_amt;     
    269315        int bytes_read = CopyAndFill(&((unsigned char *)src_buffer)[advance_amt],
    270316                                        bytes_to_keep, advance_amt);
     
    272318}
    273319
    274 void U16_Buffer::AdvanceInputBuffer(int advance_amt){
    275         int bytes_to_keep = (units_in_buffer - advance_amt)*2;
     320void U16_Buffer::AdvanceInputBuffer(int advance_amt){   
     321        int bytes_to_keep = (units_in_buffer - advance_amt)*2; 
    276322        int bytes_read = CopyAndFill(&((unsigned char *)src_buffer)[advance_amt*2],
    277323                                        bytes_to_keep, advance_amt*2);
     
    282328}
    283329
    284 void U32_Buffer::AdvanceInputBuffer(int advance_amt){
    285         int bytes_to_keep = (units_in_buffer - advance_amt)*4;
     330void U32_Buffer::AdvanceInputBuffer(int advance_amt){   
     331        int bytes_to_keep = (units_in_buffer - advance_amt)*4; 
    286332        int bytes_read = CopyAndFill(&((unsigned char *)src_buffer)[advance_amt*4],
    287333                                        bytes_to_keep, advance_amt*4);
     
    296342        BytePack hi_surrogate;
    297343        BytePack lo_surrogate;
     344#ifdef TEMPLATED_SIMD_LIB
     345        BytePack hi_surrogate_pending = simd_const<8>(0);
     346#endif
     347#ifndef TEMPLATED_SIMD_LIB
    298348        BytePack hi_surrogate_pending = simd_const_8(0);
     349#endif
    299350        BytePack surrogate_scope;
    300351        BytePack u16_surrogate_error;
    301 //      BytePack u16_surrogate_accum = simd_const_8(0);
    302 //      BytePack u16_FFFE_FFFF_accum = simd_const_8(0);
     352//      BytePack u16_surrogate_accum = simd_const<8>(0);
     353//      BytePack u16_FFFE_FFFF_accum = simd_const<8>(0);
    303354        BytePack u16_FFFE_FFFF;
    304355        for (int pk = 0; pk < packs_in_buffer; pk++) {
     
    307358                   of surrogate pairs.  Validation requires that these values
    308359                   only occur in well-formed pairs. */
     360#ifdef TEMPLATED_SIMD_LIB
     361                surrogate_select = simd_and(x16hi[pk], simd_const<8>(0xDC));
     362                hi_surrogate = simd_eq<8>(surrogate_select, simd_const<8>(0xD8));
     363                lo_surrogate = simd_eq<8>(surrogate_select, simd_const<8>(0xDC));
     364                surrogate_scope = simd_or(hi_surrogate_pending,
     365                                          sisd_sfli(hi_surrogate, 8));
     366                                         
     367                u16_surrogate_error = simd_xor(surrogate_scope, lo_surrogate);
     368                hi_surrogate_pending = sisd_sbli(hi_surrogate, 8 * (PACKSIZE-1));
     369                /* The values FFFE and FFFF are excluded. */
     370                u16_FFFE_FFFF = simd_eq<8>(simd_and(x16hi[pk],
     371                                                   simd_or(x16lo[pk], simd_const<8>(1))),
     372                                          simd_const<8>(0xFF));
     373#endif
     374#ifndef TEMPLATED_SIMD_LIB
    309375                surrogate_select = simd_and(x16hi[pk], simd_const_8(0xDC));
    310376                hi_surrogate = simd_eq_8(surrogate_select, simd_const_8(0xD8));
     
    312378                surrogate_scope = simd_or(hi_surrogate_pending,
    313379                                          sisd_sfli(hi_surrogate, 8));
    314 
     380                                         
    315381                u16_surrogate_error = simd_xor(surrogate_scope, lo_surrogate);
    316382                hi_surrogate_pending = sisd_sbli(hi_surrogate, 8 * (PACKSIZE-1));
     
    319385                                                   simd_or(x16lo[pk], simd_const_8(1))),
    320386                                          simd_const_8(0xFF));
     387#endif
    321388//              u16_FFFE_FFFF_accum = simd_or(u16_FFFE_FFFF_accum, u16_FFFE_FFFF);
    322389                u16_surrogate_error = simd_or(u16_surrogate_error, u16_FFFE_FFFF);
    323 
     390       
    324391                if (bitblock_has_bit(u16_surrogate_error)) {
    325392                        CharSetValidationError("UTF-16 (relative position reported)",
     
    333400#ifdef X16HILO_ACCESS
    334401        int packs = (buffer_units - 1)/PACKSIZE + 1;
     402#ifdef TEMPLATED_SIMD_LIB
     403        BytePack u16_surrogate_accum = simd_const<8>(0);
     404        BytePack u16_FFFE_FFFF_accum = simd_const<8>(0);
     405#endif
     406#ifndef TEMPLATED_SIMD_LIB
    335407        BytePack u16_surrogate_accum = simd_const_8(0);
    336408        BytePack u16_FFFE_FFFF_accum = simd_const_8(0);
     409#endif
    337410        BytePack u16_FFFE_FFFF;
    338411        for (int pk = 0; pk < packs; pk++) {
    339412                /* The high byte of UCS-2 code units cannot be in the range D8-DF.
    340413                   This corresponds to the D800-DFFF range of illegal codepoints
    341                    reserved for UTF-16 surrogate pairs. Accumulate the results.
     414                   reserved for UTF-16 surrogate pairs. Accumulate the results. 
    342415                   To check, 0x20 is added to each such octet, mapping the D8-DF
    343416                   range to F8-FF and wrapping E0-FF values around.  The max value
    344                    is then accumulated.  */
     417                   is then accumulated.  */ 
     418#ifdef TEMPLATED_SIMD_LIB
    345419                u16_surrogate_accum =
    346                         simd_max_8(u16_surrogate_accum,
    347                                    simd_add_8(x16hi[pk], simd_const_8(0x20)));
     420                        simd_max_8(u16_surrogate_accum, simd_add<8>(x16hi[pk], simd_const<8>(0x20)));
     421                /* The values FFFE and FFFF are excluded. */
     422                u16_FFFE_FFFF = simd_eq<8>(simd_and(x16hi[pk],
     423                                                   simd_or(x16lo[pk], simd_const<8>(1))), simd_const<8>(0xFF));
     424                u16_FFFE_FFFF_accum = simd_or(u16_FFFE_FFFF_accum, u16_FFFE_FFFF);
     425#endif
     426#ifndef TEMPLATED_SIMD_LIB
     427                u16_surrogate_accum =
     428                        simd_max_8(u16_surrogate_accum, simd_add_8(x16hi[pk], simd_const_8(0x20)));
    348429                /* The values FFFE and FFFF are excluded. */
    349430                u16_FFFE_FFFF = simd_eq_8(simd_and(x16hi[pk],
    350                                                    simd_or(x16lo[pk], simd_const_8(1))),
    351                                           simd_const_8(0xFF));
     431                                                   simd_or(x16lo[pk], simd_const_8(1))), simd_const_8(0xFF));
    352432                u16_FFFE_FFFF_accum = simd_or(u16_FFFE_FFFF_accum, u16_FFFE_FFFF);
    353         }
     433#endif
     434        }
     435#ifdef TEMPLATED_SIMD_LIB
     436        u16_surrogate_accum = simd_eq<8>(simd_or(u16_surrogate_accum, simd_const<8>(0x07)),
     437                                        simd_const<8>(0xFF));
     438#endif
     439#ifndef TEMPLATED_SIMD_LIB
    354440        u16_surrogate_accum = simd_eq_8(simd_or(u16_surrogate_accum, simd_const_8(0x07)),
    355441                                        simd_const_8(0xFF));
     442#endif
     443
    356444        if (bitblock_has_bit(simd_or(u16_surrogate_accum, u16_FFFE_FFFF_accum)))
    357445                CharSetValidationError("UCS-2");
     
    367455#ifdef X32BYTEPLEX_ACCESS
    368456        int packs = (buffer_units - 1)/PACKSIZE + 1;
     457#ifdef TEMPLATED_SIMD_LIB
     458        BytePack u32hh_accum = simd_const<8>(0);
     459        BytePack u32hl_accum = simd_const<8>(0);
     460        BytePack u32_surrogate_accum = simd_const<8>(0);
     461        BytePack u32_FFFE_FFFF_accum = simd_const<8>(0);
     462#endif
     463#ifndef TEMPLATED_SIMD_LIB
    369464        BytePack u32hh_accum = simd_const_8(0);
    370465        BytePack u32hl_accum = simd_const_8(0);
    371466        BytePack u32_surrogate_accum = simd_const_8(0);
    372467        BytePack u32_FFFE_FFFF_accum = simd_const_8(0);
     468#endif
    373469        BytePack u32_BMP_select;
    374470        BytePack u32l_FFFE_FFFF;
     
    379475                /* The second octet has a max value of 0x10, corresponding to the
    380476                   maximum Unicode code point value of 0x10FFFF.  Accumulate the
    381                    maximum of all u32hl values observed. */
     477                   maximum of all u32hl values observed. */ 
    382478                u32hl_accum = simd_max_8(u32hl_accum, x32hl[pk]);
    383479                /* The third octet cannot be in the range D8-DF if the second octet
    384480                   is 0.  This corresponds to the D800-DFFF range of illegal codepoints
    385                    reserved for UTF-16 surrogate pairs. Accumulate the results.
     481                   reserved for UTF-16 surrogate pairs. Accumulate the results. 
    386482                   To check, 0x20 is added to each such octet, mapping the D8-DF
    387483                   range to F8-FF and wrapping E0-FF values around.  The max value
    388484                   is then accumulated.  */
     485#ifdef TEMPLATED_SIMD_LIB
     486                u32_BMP_select = simd_eq<8>(x32hl[pk], simd_const<8>(0));
     487                u32_surrogate_accum = simd_max_8(u32_surrogate_accum,
     488                                                                 simd_and(u32_BMP_select, simd_add<8>(x32lh[pk], simd_const<8>(0x20))));
     489                /* The low two octets cannot have the value FFFE or FFFF if
     490                   we're in the BMP (second octet is 0). */
     491                u32l_FFFE_FFFF = simd_eq<8>(simd_and(x32lh[pk],
     492                                                    simd_or(x32ll[pk], simd_const<8>(1))),simd_const<8>(0xFF));
     493                u32_FFFE_FFFF_accum = simd_or(u32_FFFE_FFFF_accum,
     494                                              simd_and(u32_BMP_select, u32l_FFFE_FFFF));
     495#endif
     496#ifndef TEMPLATED_SIMD_LIB
    389497                u32_BMP_select = simd_eq_8(x32hl[pk], simd_const_8(0));
    390                 u32_surrogate_accum =
    391                         simd_max_8(u32_surrogate_accum,
    392                                    simd_and(u32_BMP_select,
    393                                             simd_add_8(x32lh[pk], simd_const_8(0x20))));
     498                u32_surrogate_accum = simd_max_8(u32_surrogate_accum,
     499                                                                 simd_and(u32_BMP_select, simd_add<8>(x32lh[pk], simd_const_8(0x20))));
    394500                /* The low two octets cannot have the value FFFE or FFFF if
    395501                   we're in the BMP (second octet is 0). */
    396502                u32l_FFFE_FFFF = simd_eq_8(simd_and(x32lh[pk],
    397                                                     simd_or(x32ll[pk], simd_const_8(1))),
    398                                            simd_const_8(0xFF));
     503                                                    simd_or(x32ll[pk], simd_const_8(1))),simd_const_8(0xFF));
    399504                u32_FFFE_FFFF_accum = simd_or(u32_FFFE_FFFF_accum,
    400505                                              simd_and(u32_BMP_select, u32l_FFFE_FFFF));
    401         }
     506#endif
     507        }
     508#ifdef TEMPLATED_SIMD_LIB
     509        u32hl_accum = simd_gt_8(u32hl_accum, simd_const<8>(0x10));
     510        u32_surrogate_accum = simd_eq<8>(simd_or(u32_surrogate_accum, simd_const<8>(0x07)),
     511                                        simd_const<8>(0xFF));
     512#endif
     513#ifndef TEMPLATED_SIMD_LIB
    402514        u32hl_accum = simd_gt_8(u32hl_accum, simd_const_8(0x10));
    403515        u32_surrogate_accum = simd_eq_8(simd_or(u32_surrogate_accum, simd_const_8(0x07)),
    404516                                        simd_const_8(0xFF));
     517#endif
    405518        if (bitblock_has_bit(simd_or(simd_or(u32hh_accum, u32hl_accum),
    406519                                         simd_or(u32_surrogate_accum, u32_FFFE_FFFF_accum)))) {
     
    416529        Byteplex * b;
    417530        if (likely(e->code_unit_size == SingleByte)) {
    418                 if (likely(e->code_unit_base == ASCII))
     531                if (likely(e->code_unit_base == ASCII)) 
    419532                        b = new X8_Buffer<ASCII>();
    420533                else b = new X8_Buffer<EBCDIC>();
     
    430543                case Unusual_2143: b = new U32_2143_Buffer(); break;
    431544                case Unusual_3412: b = new U32_3412_Buffer(); break;
    432         }
     545        }       
    433546        return b;
    434547}
     
    439552        return b;
    440553}
    441 
     554       
    442555Byteplex * Byteplex::ByteplexFactory(Entity_Info * e, unsigned char * buffer_bytes, int buffer_size) {
    443556        Byteplex * b = ByteplexFactory(e);
     
    511624template <>
    512625void X8_Buffer<EBCDIC>::to_UTF8(int name_pos, int lgth, char * u8_ptr){
    513 
     626       
    514627}
    515628void U16_Buffer::to_UTF8(int name_pos, int lgth, char * u8_ptr){
     
    562675                        u8_ptr[u8_lgth+1] = 0x80 + ((u32hl[i] & 0x03) << 4) + (u32lh[i] >> 4);
    563676                        u8_ptr[u8_lgth+2] = 0x80 + ((u32lh[i] & 0x0F) << 2) + (u32ll[i] >> 6);
    564                         u8_ptr[u8_lgth+3] = 0x80 + (u32ll[i] & 0x3F);
     677                        u8_ptr[u8_lgth+3] = 0x80 + (u32ll[i] & 0x3F);           
    565678                        u8_lgth += 4;
    566679                }
Note: See TracChangeset for help on using the changeset viewer.