Changeset 393 for proto/u16u8


Ignore:
Timestamp:
May 5, 2010, 1:27:56 PM (9 years ago)
Author:
ksherdy
Message:

Commit a working u16u8 prototype.

Location:
proto/u16u8
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • proto/u16u8/template.c

    r366 r393  
    194194#define double_int64_adc(x1, x2, y1, y2, rslt1, rslt2, carry) \
    195195  __asm__  ("sahf\n\t" \
    196             "adc %[e1], %[z1]\n\t" \
    197             "adc %[e2], %[z2]\n\t" \
    198             "lahf\n\t" \
    199          : [z1] "=r" (rslt1), [z2] "=r" (rslt2), [carry] "=a" (carry) \
     196        "adc %[e1], %[z1]\n\t" \
     197        "adc %[e2], %[z2]\n\t" \
     198        "lahf\n\t" \
     199     : [z1] "=r" (rslt1), [z2] "=r" (rslt2), [carryflag] "=a" (carry) \
    200200         : "[z1]" (x1), "[z2]" (x2), \
    201201           [e1] "r" (y1), [e2] "r" (y2), \
    202            "[carry]" (carry) \
     202           "[carryflag]" (carry) \
    203203         : "cc")
    204204
    205 static inline BitBlock adc128(BitBlock first, BitBlock second, int &carry)
    206 {
    207   union {__m128i bitblock;
    208          uint64_t int64[2];} rslt;
    209 
    210   union {__m128i bitblock;
    211          uint64_t int64[2];} x;
    212 
    213   union {__m128i bitblock;
    214          uint64_t int64[2];} y;
    215 
    216   x.bitblock = first;
    217   y.bitblock = second;
    218 
    219   double_int64_adc(x.int64[0], x.int64[1], y.int64[0], y.int64[1],
    220                    rslt.int64[0], rslt.int64[1], carry);
    221 
    222   return rslt.bitblock;
    223 }
     205#define adc128(first, second, carry, sum) \
     206do\
     207{\
     208  union {__m128i bitblock;\
     209         uint64_t int64[2];} rslt;\
     210\
     211  union {__m128i bitblock;\
     212         uint64_t int64[2];} x;\
     213\
     214  union {__m128i bitblock;\
     215         uint64_t int64[2];} y;\
     216\
     217  x.bitblock = first;\
     218  y.bitblock = second;\
     219\
     220  double_int64_adc(x.int64[0], x.int64[1], y.int64[0], y.int64[1], rslt.int64[0], rslt.int64[1], carry);\
     221  sum = rslt.bitblock;\
     222}while(0)
     223
     224#define double_int64_sbb(x1, x2, y1, y2, rslt1, rslt2, carry) \
     225  __asm__  ("sahf\n\t" \
     226        "sbb %[e1], %[z1]\n\t" \
     227        "sbb %[e2], %[z2]\n\t" \
     228        "lahf\n\t" \
     229     : [z1] "=r" (rslt1), [z2] "=r" (rslt2), [carryflag] "=a" (carry) \
     230         : "[z1]" (x1), "[z2]" (x2), \
     231           [e1] "r" (y1), [e2] "r" (y2), \
     232           "[carryflag]" (carry) \
     233         : "cc")
     234
     235
     236#define sbb128(first, second, carry, sum) \
     237do\
     238{ union {__m128i bitblock;\
     239         uint64_t int64[2];} rslt;\
     240\
     241  union {__m128i bitblock;\
     242         uint64_t int64[2];} x;\
     243\
     244  union {__m128i bitblock;\
     245         uint64_t int64[2];} y;\
     246\
     247  x.bitblock = first;\
     248  y.bitblock = second;\
     249\
     250  double_int64_sbb(x.int64[0], x.int64[1], y.int64[0], y.int64[1], \
     251                   rslt.int64[0], rslt.int64[1], carry);\
     252  sum = rslt.bitblock;\
     253}while(0)
    224254
    225255
     
    229259
    230260  @decl
     261
     262SIMD_type u16l [8];
     263SIMD_type u16h [8];
     264
    231265
    232266  BytePack * U16;
     
    276310    u16l[0], u16l[1], u16l[2], u16l[3], u16l[4], u16l[5], u16l[6], u16l[7]);
    277311
     312array_u16l__0_ = u16l [0];
     313array_u16l__1_ = u16l [1];
     314array_u16l__2_ = u16l [2];
     315array_u16l__3_ = u16l [3];
     316array_u16l__4_ = u16l [4];
     317array_u16l__5_ = u16l [5];
     318array_u16l__6_ = u16l [6];
     319array_u16l__7_ = u16l [7];
     320
     321array_u16h__0_ = u16h [0];
     322array_u16h__1_ = u16h [1];
     323array_u16h__2_ = u16h [2];
     324array_u16h__3_ = u16h [3];
     325array_u16h__4_ = u16h [4];
     326array_u16h__5_ = u16h [5];
     327array_u16h__6_ = u16h [6];
     328array_u16h__7_ = u16h [7];
     329
    278330    @stmts
    279331
    280     if (bitblock_has_bit(u16.error)) {
     332/* Convert flattened array values to arrays */
     333SIMD_type u8_pre [8];
     334u8_pre[0] = array_u8_pre__0_;
     335u8_pre[1] = array_u8_pre__1_;
     336u8_pre[2] = array_u8_pre__2_;
     337u8_pre[3] = array_u8_pre__3_;
     338u8_pre[4] = array_u8_pre__4_;
     339u8_pre[5] = array_u8_pre__5_;
     340u8_pre[6] = array_u8_pre__6_;
     341u8_pre[7] = array_u8_pre__7_;
     342
     343SIMD_type u8_butlast [8];
     344u8_butlast[0] = array_u8_butlast__0_;
     345u8_butlast[1] = array_u8_butlast__1_;
     346u8_butlast[2] = array_u8_butlast__2_;
     347u8_butlast[3] = array_u8_butlast__3_;
     348u8_butlast[4] = array_u8_butlast__4_;
     349u8_butlast[5] = array_u8_butlast__5_;
     350u8_butlast[6] = array_u8_butlast__6_;
     351u8_butlast[7] = array_u8_butlast__7_;
     352
     353SIMD_type u8_last [8];
     354u8_last[0] = array_u8_last__0_;
     355u8_last[1] = array_u8_last__1_;
     356u8_last[2] = array_u8_last__2_;
     357u8_last[3] = array_u8_last__3_;
     358u8_last[4] = array_u8_last__4_;
     359u8_last[5] = array_u8_last__5_;
     360u8_last[6] = array_u8_last__6_;
     361u8_last[7] = array_u8_last__7_;
     362
     363
     364    if (bitblock_has_bit(strct_u16__error_)) {
    281365       
    282        err_pos = count_forward_zeroes(u16.error);
     366       err_pos = count_forward_zeroes(strct_u16__error_);
    283367       error_found = true;
    284368        if ((err_pos == units_read)) {
     
    286370                *err = U_TRUNCATED_CHAR_FOUND;
    287371                (*srcbuf) += err_pos;
     372                if(err_pos<0){
     373                        target_bckup_steps = 2;
     374                        (*targetbuf) -= target_bckup_steps;
     375                        return;
     376                }               
    288377        }
    289378        else {
     
    306395                                doublepair[i*4+2], doublepair[i*4+3]);
    307396    }
    308         interleave4(simd_const_1(1), simd_or(endmask, simd_not(u16.utf8_3)),
    309                                 simd_or(endmask, u16.ASCII), endmask,
     397
     398        interleave4(simd_const_1(1), simd_or(endmask, simd_not(strct_u16__utf8_3_)),
     399                                simd_or(endmask, strct_u16__ASCII_), endmask,
    310400                                delmask[0], delmask[1], delmask[2], delmask[3]);
    311401
     
    380470        srcbuf = (UChar *) malloc(fileinfo.st_size+1);
    381471        if (!srcbuf) {
    382               fprintf(stderr, "Error: buffer for %s of size %i cannot be created.\n", infilename, fileinfo.st_size+1);
     472              fprintf(stderr, "Error: buffer for %s of size %zu cannot be created.\n", infilename, fileinfo.st_size+1);
    383473              exit(-1);
    384474        }
     
    398488
    399489        if (status == U_ILLEGAL_CHAR_FOUND) {
    400                 fprintf(stderr, "Illegal UTF-16 sequence at position %i in source.\n", chars_read-(srclimit-srcbuf)*2);
     490                fprintf(stderr, "Illegal UTF-16 sequence at position %lu in source.\n", chars_read-(srclimit-srcbuf)*2);
    401491        }
    402492        else if (status == U_TRUNCATED_CHAR_FOUND) {
    403                 fprintf(stderr, "EOF with incomplete UTF-16 sequence at position %i in source.\n",chars_read-(srclimit-srcbuf)*2);
     493                fprintf(stderr, "EOF with incomplete UTF-16 sequence at position %lu in source.\n",chars_read-(srclimit-srcbuf)*2);
    404494        }
    405495
  • proto/u16u8/u16u8.c

    r385 r393  
    1313
    1414
    15 #define BUFFER_PROFILING
    16 #define BUFFER_SIZE 10000
     15// Profiling
     16
    1717#ifdef BUFFER_PROFILING
    18 #include "Profiling/BOM_Profiler.c"
     18#include "../Profiling/BOM_Profiler.c"
    1919BOM_Table * transcode_timer;
    2020#endif
     
    194194#define double_int64_adc(x1, x2, y1, y2, rslt1, rslt2, carry) \
    195195  __asm__  ("sahf\n\t" \
    196             "adc %[e1], %[z1]\n\t" \
    197             "adc %[e2], %[z2]\n\t" \
    198             "lahf\n\t" \
    199          : [z1] "=r" (rslt1), [z2] "=r" (rslt2), [carry] "=a" (carry) \
     196        "adc %[e1], %[z1]\n\t" \
     197        "adc %[e2], %[z2]\n\t" \
     198        "lahf\n\t" \
     199     : [z1] "=r" (rslt1), [z2] "=r" (rslt2), [carryflag] "=a" (carry) \
    200200         : "[z1]" (x1), "[z2]" (x2), \
    201201           [e1] "r" (y1), [e2] "r" (y2), \
    202            "[carry]" (carry) \
     202           "[carryflag]" (carry) \
    203203         : "cc")
    204204
    205 static inline BitBlock adc128(BitBlock first, BitBlock second, int &carry)
    206 {
    207   union {__m128i bitblock;
    208          uint64_t int64[2];} rslt;
    209 
    210   union {__m128i bitblock;
    211          uint64_t int64[2];} x;
    212 
    213   union {__m128i bitblock;
    214          uint64_t int64[2];} y;
    215 
    216   x.bitblock = first;
    217   y.bitblock = second;
    218 
    219   double_int64_adc(x.int64[0], x.int64[1], y.int64[0], y.int64[1],
    220                    rslt.int64[0], rslt.int64[1], carry);
    221 
    222   return rslt.bitblock;
    223 }
     205#define adc128(first, second, carry, sum) \
     206do\
     207{\
     208  union {__m128i bitblock;\
     209         uint64_t int64[2];} rslt;\
     210\
     211  union {__m128i bitblock;\
     212         uint64_t int64[2];} x;\
     213\
     214  union {__m128i bitblock;\
     215         uint64_t int64[2];} y;\
     216\
     217  x.bitblock = first;\
     218  y.bitblock = second;\
     219\
     220  double_int64_adc(x.int64[0], x.int64[1], y.int64[0], y.int64[1], rslt.int64[0], rslt.int64[1], carry);\
     221  sum = rslt.bitblock;\
     222}while(0)
     223
     224#define double_int64_sbb(x1, x2, y1, y2, rslt1, rslt2, carry) \
     225  __asm__  ("sahf\n\t" \
     226        "sbb %[e1], %[z1]\n\t" \
     227        "sbb %[e2], %[z2]\n\t" \
     228        "lahf\n\t" \
     229     : [z1] "=r" (rslt1), [z2] "=r" (rslt2), [carryflag] "=a" (carry) \
     230         : "[z1]" (x1), "[z2]" (x2), \
     231           [e1] "r" (y1), [e2] "r" (y2), \
     232           "[carryflag]" (carry) \
     233         : "cc")
     234
     235
     236#define sbb128(first, second, carry, sum) \
     237do\
     238{ union {__m128i bitblock;\
     239         uint64_t int64[2];} rslt;\
     240\
     241  union {__m128i bitblock;\
     242         uint64_t int64[2];} x;\
     243\
     244  union {__m128i bitblock;\
     245         uint64_t int64[2];} y;\
     246\
     247  x.bitblock = first;\
     248  y.bitblock = second;\
     249\
     250  double_int64_sbb(x.int64[0], x.int64[1], y.int64[0], y.int64[1], \
     251                   rslt.int64[0], rslt.int64[1], carry);\
     252  sum = rslt.bitblock;\
     253}while(0)
    224254
    225255
     
    228258void u16u8(char ** targetbuf, const char * targetlimit, const UChar ** srcbuf, const UChar * srclimit, UErrorCode * err){
    229259
    230         int carry1=0;
    231         int carry0=0;
    232         int carry2=0;
    233         BitBlock hcarry;
    234         BitBlock efghi_i;
    235         BitBlock u8_2or3;
    236         BitBlock Temp13;
    237         BitBlock Temp12;
    238         BitBlock Temp11;
    239         BitBlock Temp10;
    240         BitBlock Temp17;
    241         BitBlock Temp16;
    242         BitBlock Temp15;
    243         BitBlock Temp14;
    244         BitBlock Temp19;
    245         BitBlock Temp18;
    246         BitBlock Temp31;
    247         BitBlock Temp30;
    248         BitBlock Temp33;
    249         BitBlock Temp32;
    250         BitBlock Temp35;
    251         BitBlock Temp34;
    252         BitBlock Temp37;
    253         BitBlock Temp36;
    254         BitBlock above_0x7F;
    255         BitBlock above_0x7FF;
    256         BitBlock gcarry;
    257         BitBlock efghi_h;
    258         BitBlock efghi_g;
    259         BitBlock efghi_f;
    260         BitBlock efghi_e;
    261         BitBlock AllOne = simd_const_1(1);
    262         BitBlock AllZero = simd_const_1(0);
    263         BitBlock Temp28;
    264         BitBlock Temp29;
    265         BitBlock Temp22;
    266         BitBlock Temp23;
    267         BitBlock Temp20;
    268         BitBlock Temp21;
    269         BitBlock Temp26;
    270         BitBlock Temp27;
    271         BitBlock Temp24;
    272         BitBlock Temp25;
    273         BitBlock Temp3;
    274         BitBlock Temp2;
    275         BitBlock Temp1;
    276         BitBlock Temp7;
    277         BitBlock Temp6;
    278         BitBlock Temp5;
    279         BitBlock Temp4;
    280         BitBlock Temp9;
    281         BitBlock Temp8;
    282         BitBlock u16h[8];
    283         BitBlock u8_last[8];
    284         BitBlock u8_pre[8];
    285         BitBlock u16l[8];
    286         BitBlock u8_butlast[8];
    287         struct __u16__{
    288                 BitBlock lsurrogate;
    289                 BitBlock surrogate;
    290                 BitBlock ASCII;
    291                 BitBlock hsurrogate;
    292                 BitBlock error;
    293                 BitBlock utf8_2;
    294                 BitBlock utf8_3;
    295         };
    296         struct __u16__ u16;
    297        
    298        
    299         BytePack * U16;
    300         BytePack U16h[8];
    301         BytePack U16l[8];
    302        
    303         BitBlock doublepair[32];
    304        
    305         BitBlock endmask;
    306        
    307         BitBlock delmask[4];
    308        
    309         BitBlock U8[32];
    310        
    311         int target_bckup_steps = 0;
    312         int pos = 0;
    313        
    314         int  units_read  = 0;
    315        
    316         bool error_found = false;
    317         int err_pos;
    318 
    319 
    320 
    321         do {
    322 
    323                 U16 = (BytePack *)(*srcbuf);
    324                 units_read = min(srclimit-(*srcbuf),BLOCK_SIZE);
    325                 if(units_read < BLOCK_SIZE){
    326                         endmask = sisd_sll(simd_const_1(1),sisd_from_int(units_read));
    327                 //      ((uint16_t *) U16)[units_read/2] = 0;
     260  int carry1=0;
     261int carry0=0;
     262int carry2=0;
     263BitBlock hcarry;
     264BitBlock array_u16l__4_;
     265BitBlock array_u16h__4_;
     266BitBlock array_u8_butlast__5_;
     267BitBlock strct_u16__utf8_3_;
     268BitBlock array_u8_butlast__2_;
     269BitBlock array_u8_last__5_;
     270BitBlock Temp37;
     271BitBlock array_u16l__0_;
     272BitBlock efghi_e;
     273BitBlock strct_u16__ASCII_;
     274BitBlock array_u8_last__1_;
     275BitBlock array_u8_pre__3_;
     276BitBlock Temp31;
     277BitBlock Temp30;
     278BitBlock Temp33;
     279BitBlock Temp32;
     280BitBlock Temp35;
     281BitBlock Temp34;
     282BitBlock array_u8_butlast__6_;
     283BitBlock Temp36;
     284BitBlock array_u16h__0_;
     285BitBlock array_u16l__1_;
     286BitBlock strct_u16__surrogate_;
     287BitBlock array_u8_last__0_;
     288BitBlock array_u16l__7_;
     289BitBlock array_u8_last__4_;
     290BitBlock gcarry;
     291BitBlock array_u8_butlast__3_;
     292BitBlock strct_u16__error_;
     293BitBlock array_u8_pre__7_;
     294BitBlock strct_u16__lsurrogate_;
     295BitBlock array_u8_butlast__7_;
     296BitBlock array_u16h__7_;
     297BitBlock array_u8_pre__4_;
     298BitBlock Temp17;
     299BitBlock array_u16h__3_;
     300BitBlock array_u8_pre__0_;
     301BitBlock array_u16l__3_;
     302BitBlock array_u8_last__3_;
     303BitBlock array_u16l__6_;
     304BitBlock u8_2or3;
     305BitBlock array_u16h__6_;
     306BitBlock Temp13;
     307BitBlock Temp12;
     308BitBlock Temp11;
     309BitBlock Temp10;
     310BitBlock array_u8_butlast__4_;
     311BitBlock Temp16;
     312BitBlock Temp15;
     313BitBlock Temp14;
     314BitBlock array_u8_butlast__0_;
     315BitBlock array_u8_last__7_;
     316BitBlock Temp19;
     317BitBlock Temp18;
     318BitBlock array_u16l__2_;
     319BitBlock array_u8_pre__1_;
     320BitBlock array_u16l__5_;
     321BitBlock array_u8_pre__5_;
     322BitBlock array_u16h__2_;
     323BitBlock Temp5;
     324BitBlock array_u8_last__2_;
     325BitBlock array_u16h__5_;
     326BitBlock above_0x7F;
     327BitBlock above_0x7FF;
     328BitBlock strct_u16__hsurrogate_;
     329BitBlock efghi_i;
     330BitBlock efghi_h;
     331BitBlock efghi_g;
     332BitBlock efghi_f;
     333BitBlock array_u8_last__6_;
     334BitBlock array_u8_butlast__1_;
     335BitBlock AllOne = simd_const_1(1);
     336BitBlock AllZero = simd_const_1(0);
     337BitBlock Temp28;
     338BitBlock Temp29;
     339BitBlock array_u8_pre__2_;
     340BitBlock Temp22;
     341BitBlock Temp23;
     342BitBlock Temp20;
     343BitBlock Temp21;
     344BitBlock Temp26;
     345BitBlock strct_u16__utf8_2_;
     346BitBlock Temp24;
     347BitBlock Temp25;
     348BitBlock Temp3;
     349BitBlock Temp2;
     350BitBlock Temp1;
     351BitBlock Temp27;
     352BitBlock Temp7;
     353BitBlock Temp6;
     354BitBlock array_u16h__1_;
     355BitBlock Temp4;
     356BitBlock array_u8_pre__6_;
     357BitBlock Temp9;
     358BitBlock Temp8;
     359
     360
     361SIMD_type u16l [8];
     362SIMD_type u16h [8];
     363
     364
     365  BytePack * U16;
     366  BytePack U16h[8];
     367  BytePack U16l[8];
     368
     369  BitBlock doublepair[32];
     370
     371  BitBlock endmask;
     372
     373  BitBlock delmask[4];
     374
     375  BitBlock U8[32];
     376
     377  int target_bckup_steps = 0;
     378  int pos = 0;
     379
     380  int  units_read  = 0;
     381
     382  bool error_found = false;
     383  int err_pos;
     384
     385
     386
     387  do {
     388
     389    U16 = (BytePack *)(*srcbuf);
     390    units_read = min(srclimit-(*srcbuf),BLOCK_SIZE);
     391
     392    if(units_read < BLOCK_SIZE){
     393        endmask = sisd_sll(simd_const_1(1),sisd_from_int(units_read));
     394//      ((uint16_t *) U16)[units_read/2] = 0;
     395    }
     396    else endmask = simd_const_1(0);
     397
     398
     399    for (int i=0; i< 8; i++){
     400      U16h[i] = simd_pack_16_ll(sisd_load_unaligned(&U16[i*2+1]),sisd_load_unaligned(&U16[i*2]));
     401      U16l[i] = simd_pack_16_hh(sisd_load_unaligned(&U16[i*2+1]),sisd_load_unaligned(&U16[i*2]));
     402    }
     403
     404
     405    s2p_bytepack(U16h[7], U16h[6], U16h[5], U16h[4], U16h[3], U16h[2], U16h[1], U16h[0],
     406    u16h[0], u16h[1], u16h[2], u16h[3], u16h[4], u16h[5], u16h[6], u16h[7]);
     407
     408    s2p_bytepack(U16l[7], U16l[6], U16l[5], U16l[4], U16l[3], U16l[2], U16l[1], U16l[0],
     409    u16l[0], u16l[1], u16l[2], u16l[3], u16l[4], u16l[5], u16l[6], u16l[7]);
     410
     411array_u16l__0_ = u16l [0];
     412array_u16l__1_ = u16l [1];
     413array_u16l__2_ = u16l [2];
     414array_u16l__3_ = u16l [3];
     415array_u16l__4_ = u16l [4];
     416array_u16l__5_ = u16l [5];
     417array_u16l__6_ = u16l [6];
     418array_u16l__7_ = u16l [7];
     419
     420array_u16h__0_ = u16h [0];
     421array_u16h__1_ = u16h [1];
     422array_u16h__2_ = u16h [2];
     423array_u16h__3_ = u16h [3];
     424array_u16h__4_ = u16h [4];
     425array_u16h__5_ = u16h [5];
     426array_u16h__6_ = u16h [6];
     427array_u16h__7_ = u16h [7];
     428
     429    Temp1 = simd_or(array_u16h__0_,array_u16h__1_);
     430Temp2 = simd_or(array_u16h__2_,array_u16h__3_);
     431Temp3 = simd_or(Temp1,Temp2);
     432above_0x7FF = simd_or(Temp3,array_u16h__4_);
     433Temp4 = simd_or(above_0x7FF,array_u16h__5_);
     434Temp5 = simd_or(array_u16h__6_,array_u16h__7_);
     435Temp6 = simd_or(Temp4,Temp5);
     436above_0x7F = simd_or(Temp6,array_u16l__0_);
     437Temp7 = simd_and(array_u16h__0_,array_u16h__1_);
     438Temp8 = simd_andc(array_u16h__3_,array_u16h__2_);
     439Temp9 = simd_and(Temp7,Temp8);
     440strct_u16__surrogate_ = simd_and(Temp9,array_u16h__4_);
     441strct_u16__hsurrogate_ = simd_andc(strct_u16__surrogate_,array_u16h__5_);
     442strct_u16__lsurrogate_ = simd_and(strct_u16__surrogate_,array_u16h__5_);
     443strct_u16__utf8_3_ = simd_andc(above_0x7FF,strct_u16__surrogate_);
     444strct_u16__utf8_2_ = simd_andc(above_0x7F,above_0x7FF);
     445strct_u16__ASCII_ = simd_andc(AllOne,above_0x7F);
     446adc128(strct_u16__hsurrogate_, strct_u16__hsurrogate_, carry0, Temp10);
     447strct_u16__error_ = simd_xor(Temp10,strct_u16__lsurrogate_);
     448efghi_i = simd_andc(AllOne,array_u16l__1_);
     449efghi_h = simd_xor(array_u16l__0_,array_u16l__1_);
     450hcarry = simd_andc(array_u16l__0_,efghi_h);
     451efghi_g = simd_xor(array_u16h__7_,hcarry);
     452gcarry = simd_andc(array_u16h__7_,efghi_g);
     453efghi_f = simd_xor(array_u16h__6_,gcarry);
     454efghi_e = simd_andc(array_u16h__6_,efghi_f);
     455array_u8_last__0_ = simd_andc(AllOne,strct_u16__ASCII_);
     456array_u8_last__1_ = simd_and(strct_u16__ASCII_,array_u16l__1_);
     457Temp11 = simd_andc(array_u16l__2_,strct_u16__hsurrogate_);
     458Temp12 = simd_and(efghi_h,strct_u16__hsurrogate_);
     459array_u8_last__2_ = simd_or(Temp11,Temp12);
     460Temp13 = simd_andc(array_u16l__3_,strct_u16__hsurrogate_);
     461Temp14 = simd_and(efghi_i,strct_u16__hsurrogate_);
     462array_u8_last__3_ = simd_or(Temp13,Temp14);
     463Temp15 = simd_andc(array_u16l__4_,strct_u16__hsurrogate_);
     464Temp16 = simd_and(array_u16l__2_,strct_u16__hsurrogate_);
     465array_u8_last__4_ = simd_or(Temp15,Temp16);
     466Temp17 = simd_andc(array_u16l__5_,strct_u16__hsurrogate_);
     467Temp18 = simd_and(array_u16l__3_,strct_u16__hsurrogate_);
     468array_u8_last__5_ = simd_or(Temp17,Temp18);
     469Temp19 = simd_andc(array_u16l__6_,strct_u16__hsurrogate_);
     470Temp20 = simd_and(array_u16l__4_,strct_u16__hsurrogate_);
     471array_u8_last__6_ = simd_or(Temp19,Temp20);
     472Temp21 = simd_andc(array_u16l__7_,strct_u16__hsurrogate_);
     473Temp22 = simd_and(array_u16l__5_,strct_u16__hsurrogate_);
     474array_u8_last__7_ = simd_or(Temp21,Temp22);
     475u8_2or3 = simd_or(strct_u16__utf8_2_,strct_u16__utf8_3_);
     476array_u8_butlast__0_ = simd_andc(AllOne,strct_u16__ASCII_);
     477array_u8_butlast__1_ = simd_or(strct_u16__utf8_2_,strct_u16__hsurrogate_);
     478Temp23 = simd_and(strct_u16__utf8_3_,array_u16h__4_);
     479Temp24 = simd_or(strct_u16__hsurrogate_,Temp23);
     480adc128(array_u16l__6_, array_u16l__6_, carry1, Temp25);
     481Temp26 = simd_and(strct_u16__lsurrogate_,Temp25);
     482array_u8_butlast__2_ = simd_or(Temp24,Temp26);
     483Temp27 = simd_and(u8_2or3,array_u16h__5_);
     484Temp28 = simd_or(strct_u16__hsurrogate_,Temp27);
     485adc128(array_u16l__7_, array_u16l__7_, carry2, Temp29);
     486Temp30 = simd_and(strct_u16__lsurrogate_,Temp29);
     487array_u8_butlast__3_ = simd_or(Temp28,Temp30);
     488Temp31 = simd_or(strct_u16__hsurrogate_,strct_u16__ASCII_);
     489array_u8_butlast__4_ = simd_andc(array_u16h__6_,Temp31);
     490Temp32 = simd_andc(array_u16h__7_,Temp31);
     491Temp33 = simd_and(efghi_e,strct_u16__hsurrogate_);
     492array_u8_butlast__5_ = simd_or(Temp32,Temp33);
     493Temp34 = simd_andc(array_u16l__0_,Temp31);
     494Temp35 = simd_and(efghi_f,strct_u16__hsurrogate_);
     495array_u8_butlast__6_ = simd_or(Temp34,Temp35);
     496Temp36 = simd_andc(array_u16l__1_,Temp31);
     497Temp37 = simd_and(efghi_g,strct_u16__hsurrogate_);
     498array_u8_butlast__7_ = simd_or(Temp36,Temp37);
     499array_u8_pre__0_ = simd_andc(above_0x7FF,strct_u16__surrogate_);
     500array_u8_pre__1_ = simd_andc(above_0x7FF,strct_u16__surrogate_);
     501array_u8_pre__2_ = simd_andc(above_0x7FF,strct_u16__surrogate_);
     502array_u8_pre__3_ = AllZero;
     503array_u8_pre__4_ = simd_and(strct_u16__utf8_3_,array_u16h__0_);
     504array_u8_pre__5_ = simd_and(strct_u16__utf8_3_,array_u16h__1_);
     505array_u8_pre__6_ = simd_and(strct_u16__utf8_3_,array_u16h__2_);
     506array_u8_pre__7_ = simd_and(strct_u16__utf8_3_,array_u16h__3_);
     507
     508
     509/* Convert flattened array values to arrays */
     510SIMD_type u8_pre [8];
     511u8_pre[0] = array_u8_pre__0_;
     512u8_pre[1] = array_u8_pre__1_;
     513u8_pre[2] = array_u8_pre__2_;
     514u8_pre[3] = array_u8_pre__3_;
     515u8_pre[4] = array_u8_pre__4_;
     516u8_pre[5] = array_u8_pre__5_;
     517u8_pre[6] = array_u8_pre__6_;
     518u8_pre[7] = array_u8_pre__7_;
     519
     520SIMD_type u8_butlast [8];
     521u8_butlast[0] = array_u8_butlast__0_;
     522u8_butlast[1] = array_u8_butlast__1_;
     523u8_butlast[2] = array_u8_butlast__2_;
     524u8_butlast[3] = array_u8_butlast__3_;
     525u8_butlast[4] = array_u8_butlast__4_;
     526u8_butlast[5] = array_u8_butlast__5_;
     527u8_butlast[6] = array_u8_butlast__6_;
     528u8_butlast[7] = array_u8_butlast__7_;
     529
     530SIMD_type u8_last [8];
     531u8_last[0] = array_u8_last__0_;
     532u8_last[1] = array_u8_last__1_;
     533u8_last[2] = array_u8_last__2_;
     534u8_last[3] = array_u8_last__3_;
     535u8_last[4] = array_u8_last__4_;
     536u8_last[5] = array_u8_last__5_;
     537u8_last[6] = array_u8_last__6_;
     538u8_last[7] = array_u8_last__7_;
     539
     540
     541    if (bitblock_has_bit(strct_u16__error_)) {
     542       
     543       err_pos = count_forward_zeroes(strct_u16__error_);
     544       error_found = true;
     545        if ((err_pos == units_read)) {
     546                err_pos--;
     547                *err = U_TRUNCATED_CHAR_FOUND;
     548                (*srcbuf) += err_pos;
     549                if(err_pos<0){
     550                        target_bckup_steps = 2;
     551                        (*targetbuf) -= target_bckup_steps;
     552                        return;
     553                }               
     554        }
     555        else {
     556          if((((unsigned char *)U16h)[err_pos]< 0xDC) || (((unsigned char *)U16h)[err_pos] >= 0xE0))
     557                err_pos--;
     558                *err = U_ILLEGAL_CHAR_FOUND;
     559                (*srcbuf) += err_pos;
     560                if(err_pos<0){
     561                        target_bckup_steps = 2;
     562                        (*targetbuf) -= target_bckup_steps;
     563                        return;
    328564                }
    329                 else endmask = simd_const_1(0);
    330                 u16l[0] = simd_const_1(0);
    331                 for (int i=0; i< 8; i++){
    332                         U16h[i] = simd_pack_16_ll(sisd_load_unaligned(&U16[i*2+1]),sisd_load_unaligned(&U16[i*2]));
    333                         U16l[i] = simd_pack_16_hh(sisd_load_unaligned(&U16[i*2+1]),sisd_load_unaligned(&U16[i*2]));
    334                         u16l[0] = simd_or(u16l[0], simd_and(U16l[i], simd_const_8(0x80)));
    335                 }
    336                 above_0x7F = simd_or(simd_or(simd_or(simd_or(U16h[0], U16h[1]), simd_or(U16h[2], U16h[3])),
    337                                               simd_or(simd_or(U16h[4], U16h[5]), simd_or(U16h[6], U16h[7]))),u16l[0]);
    338                
    339                 if(!bitblock_has_bit(above_0x7F)){
    340                         for (int i=0; i< 8; i++){
    341                                 sisd_store_unaligned(U16l[i],(SIMD_type *) (*targetbuf));
    342                                 *targetbuf += 16;
    343                         }               
    344                         *targetbuf -= (BLOCK_SIZE-units_read);
    345                 }
    346 //              else if(!bit_block_hasbit(above_0x7FF)){
    347 //                     
    348 //
    349 //              }
    350                 else{
    351 
    352                         s2p_bytepack(U16l[7], U16l[6], U16l[5], U16l[4], U16l[3], U16l[2], U16l[1], U16l[0],
    353                         u16l[0], u16l[1], u16l[2], u16l[3], u16l[4], u16l[5], u16l[6], u16l[7]);
    354 
    355                         s2p_bytepack(U16h[7], U16h[6], U16h[5], U16h[4], U16h[3], U16h[2], U16h[1], U16h[0],
    356                         u16h[0], u16h[1], u16h[2], u16h[3], u16h[4], u16h[5], u16h[6], u16h[7]);
    357                        
    358                         Temp1 = simd_or(u16h[0],u16h[1]);
    359                         Temp2 = simd_or(u16h[2],u16h[3]);
    360                         Temp3 = simd_or(Temp1,Temp2);
    361                         above_0x7FF = simd_or(Temp3,u16h[4]);
    362                         Temp4 = simd_or(above_0x7FF,u16h[5]);
    363                         Temp5 = simd_or(u16h[6],u16h[7]);
    364                         Temp6 = simd_or(Temp4,Temp5);
    365                         above_0x7F = simd_or(Temp6,u16l[0]);
    366 
    367                         Temp7 = simd_and(u16h[0],u16h[1]);
    368                         Temp8 = simd_andc(u16h[3],u16h[2]);
    369                         Temp9 = simd_and(Temp7,Temp8);
    370                         u16.surrogate = simd_and(Temp9,u16h[4]);
    371                         u16.hsurrogate = simd_andc(u16.surrogate,u16h[5]);
    372                         u16.lsurrogate = simd_and(u16.surrogate,u16h[5]);
    373                         u16.utf8_3 = simd_andc(above_0x7FF,u16.surrogate);
    374                         u16.utf8_2 = simd_andc(above_0x7F,above_0x7FF);
    375                         u16.ASCII = simd_andc(AllOne,above_0x7F);
    376                         Temp10 = adc128(u16.hsurrogate,u16.hsurrogate,carry0);
    377                         u16.error = simd_xor(Temp10,u16.lsurrogate);
    378                         efghi_i = simd_andc(AllOne,u16l[1]);
    379                         efghi_h = simd_xor(u16l[0],u16l[1]);
    380                         hcarry = simd_andc(u16l[0],efghi_h);
    381                         efghi_g = simd_xor(u16h[7],hcarry);
    382                         gcarry = simd_andc(u16h[7],efghi_g);
    383                         efghi_f = simd_xor(u16h[6],gcarry);
    384                         efghi_e = simd_andc(u16h[6],efghi_f);
    385                         u8_last[0] = simd_andc(AllOne,u16.ASCII);
    386                         u8_last[1] = simd_and(u16.ASCII,u16l[1]);
    387                         Temp11 = simd_andc(u16l[2],u16.hsurrogate);
    388                         Temp12 = simd_and(efghi_h,u16.hsurrogate);
    389                         u8_last[2] = simd_or(Temp11,Temp12);
    390                         Temp13 = simd_andc(u16l[3],u16.hsurrogate);
    391                         Temp14 = simd_and(efghi_i,u16.hsurrogate);
    392                         u8_last[3] = simd_or(Temp13,Temp14);
    393                         Temp15 = simd_andc(u16l[4],u16.hsurrogate);
    394                         Temp16 = simd_and(u16l[2],u16.hsurrogate);
    395                         u8_last[4] = simd_or(Temp15,Temp16);
    396                         Temp17 = simd_andc(u16l[5],u16.hsurrogate);
    397                         Temp18 = simd_and(u16l[3],u16.hsurrogate);
    398                         u8_last[5] = simd_or(Temp17,Temp18);
    399                         Temp19 = simd_andc(u16l[6],u16.hsurrogate);
    400                         Temp20 = simd_and(u16l[4],u16.hsurrogate);
    401                         u8_last[6] = simd_or(Temp19,Temp20);
    402                         Temp21 = simd_andc(u16l[7],u16.hsurrogate);
    403                         Temp22 = simd_and(u16l[5],u16.hsurrogate);
    404                         u8_last[7] = simd_or(Temp21,Temp22);
    405                         u8_2or3 = simd_or(u16.utf8_2,u16.utf8_3);
    406                         u8_butlast[0] = simd_andc(AllOne,u16.ASCII);
    407                         u8_butlast[1] = simd_or(u16.utf8_2,u16.hsurrogate);
    408                         Temp23 = simd_and(u16.utf8_3,u16h[4]);
    409                         Temp24 = simd_or(u16.hsurrogate,Temp23);
    410                         Temp25 = adc128(u16l[6],u16l[6],carry1);
    411                         Temp26 = simd_and(u16.lsurrogate,Temp25);
    412                         u8_butlast[2] = simd_or(Temp24,Temp26);
    413                         Temp27 = simd_and(u8_2or3,u16h[5]);
    414                         Temp28 = simd_or(u16.hsurrogate,Temp27);
    415                         Temp29 = adc128(u16l[7],u16l[7],carry2);
    416                         Temp30 = simd_and(u16.lsurrogate,Temp29);
    417                         u8_butlast[3] = simd_or(Temp28,Temp30);
    418                         Temp31 = simd_or(u16.hsurrogate,u16.ASCII);
    419                         u8_butlast[4] = simd_andc(u16h[6],Temp31);
    420                         Temp32 = simd_andc(u16h[7],Temp31);
    421                         Temp33 = simd_and(efghi_e,u16.hsurrogate);
    422                         u8_butlast[5] = simd_or(Temp32,Temp33);
    423                         Temp34 = simd_andc(u16l[0],Temp31);
    424                         Temp35 = simd_and(efghi_f,u16.hsurrogate);
    425                         u8_butlast[6] = simd_or(Temp34,Temp35);
    426                         Temp36 = simd_andc(u16l[1],Temp31);
    427                         Temp37 = simd_and(efghi_g,u16.hsurrogate);
    428                         u8_butlast[7] = simd_or(Temp36,Temp37);
    429                         u8_pre[0] = simd_andc(above_0x7FF,u16.surrogate);
    430                         u8_pre[1] = simd_andc(above_0x7FF,u16.surrogate);
    431                         u8_pre[2] = simd_andc(above_0x7FF,u16.surrogate);
    432                         u8_pre[3] = AllZero;
    433                         u8_pre[4] = simd_and(u16.utf8_3,u16h[0]);
    434                         u8_pre[5] = simd_and(u16.utf8_3,u16h[1]);
    435                         u8_pre[6] = simd_and(u16.utf8_3,u16h[2]);
    436                         u8_pre[7] = simd_and(u16.utf8_3,u16h[3]);
    437                        
    438                        
    439 //                      u16.error = simd_andc(u16.error,endmask);
    440                         if (bitblock_has_bit(u16.error)) {
    441                        
    442                         err_pos = count_forward_zeroes(u16.error);
    443                         error_found = true;
    444                                 if ((err_pos == units_read)) {
    445                                         err_pos--;
    446                                         *err = U_TRUNCATED_CHAR_FOUND;
    447                                         (*srcbuf) += err_pos;
    448                                 }
    449                                 else {
    450                                         if((((unsigned char *)U16h)[err_pos]< 0xDC) || (((unsigned char *)U16h)[err_pos] >= 0xE0))
    451                                                 err_pos--;
    452                                         *err = U_ILLEGAL_CHAR_FOUND;
    453                                         (*srcbuf) += err_pos;
    454                                         if(err_pos<0){
    455                                                 target_bckup_steps = 2;
    456                                                 (*targetbuf) -= target_bckup_steps;
    457                                                 return;
    458                                         }
    459                                 }
    460                                 endmask = sisd_sll(simd_const_1(1),sisd_from_int(err_pos));
    461                         }
    462                        
    463                         for (int i=0; i< 8; i++){
    464                                 interleave4(simd_const_8(0), u8_pre[i], u8_butlast[i], u8_last[i],
    465                                                         doublepair[i*4], doublepair[i*4+1],
    466                                                         doublepair[i*4+2], doublepair[i*4+3]);
    467                         }
    468                                 interleave4(simd_const_1(1), simd_or(endmask, simd_not(u16.utf8_3)),
    469                                                         simd_or(endmask, u16.ASCII), endmask,
    470                                                         delmask[0], delmask[1], delmask[2], delmask[3]);
    471                        
    472                        
    473                         for (int i=0; i< 32; i=i+4){
    474                                 bit_del_16(doublepair[i],delmask[0]);
    475                                 bit_del_16(doublepair[i+1],delmask[1]);
    476                                 bit_del_16(doublepair[i+2],delmask[2]);
    477                                 bit_del_16(doublepair[i+3],delmask[3]);
    478                         }
    479 
    480                         short u8_bytes_per_reg[8];
    481                        
    482                         for (int i=0; i< 4; i++){
    483                                 p2s_bytemerge(doublepair[i],doublepair[4+i],doublepair[8+i],doublepair[12+i],doublepair[16+i],doublepair[20+i],doublepair[24+i],doublepair[28+i],
    484                                                         U8[i*8+7],U8[i*8+6],U8[i*8+5],U8[i*8+4],U8[i*8+3],U8[i*8+2],U8[i*8+1],U8[i*8]);
    485                                 for(int k=0; k<8; k++) u8_bytes_per_reg[k] = 0;
    486                                 del_count(delmask[i],u8_bytes_per_reg);
    487                                
    488                                 for(int j=0; j<8; j++){
    489                                         sisd_store_unaligned(U8[i*8+j],(SIMD_type *) (*targetbuf));
    490                                         *targetbuf += u8_bytes_per_reg[j];
    491                                         if(*targetbuf>targetlimit)
    492                                                 printf("target buffer out of boundry!\n");
    493                                 }
    494                         }
    495                 }
    496         if(!error_found) (*srcbuf) += units_read;
    497         } while ((units_read == BLOCK_SIZE) && !error_found);
     565        }
     566        endmask = sisd_sll(simd_const_1(1),sisd_from_int(err_pos));
     567    }
     568
     569    for (int i=0; i< 8; i++){
     570        interleave4(simd_const_8(0), u8_pre[i], u8_butlast[i], u8_last[i],
     571                                doublepair[i*4], doublepair[i*4+1],
     572                                doublepair[i*4+2], doublepair[i*4+3]);
     573    }
     574
     575        interleave4(simd_const_1(1), simd_or(endmask, simd_not(strct_u16__utf8_3_)),
     576                                simd_or(endmask, strct_u16__ASCII_), endmask,
     577                                delmask[0], delmask[1], delmask[2], delmask[3]);
     578
     579
     580     for (int i=0; i< 32; i=i+4){
     581        bit_del_16(doublepair[i],delmask[0]);
     582        bit_del_16(doublepair[i+1],delmask[1]);
     583        bit_del_16(doublepair[i+2],delmask[2]);
     584        bit_del_16(doublepair[i+3],delmask[3]);
     585     }
     586
     587    short u8_bytes_per_reg[8];
     588
     589    for (int i=0; i< 4; i++){
     590      p2s_bytemerge(doublepair[i],doublepair[4+i],doublepair[8+i],doublepair[12+i],doublepair[16+i],doublepair[20+i],doublepair[24+i],doublepair[28+i],
     591                        U8[i*8+7],U8[i*8+6],U8[i*8+5],U8[i*8+4],U8[i*8+3],U8[i*8+2],U8[i*8+1],U8[i*8]);
     592       for(int k=0; k<8; k++) u8_bytes_per_reg[k] = 0;
     593       del_count(delmask[i],u8_bytes_per_reg);
     594 
     595       for(int j=0; j<8; j++){
     596        sisd_store_unaligned(U8[i*8+j],(SIMD_type *) (*targetbuf));
     597        *targetbuf += u8_bytes_per_reg[j];
     598       }
     599    }
     600
     601    if(!error_found) (*srcbuf) += units_read;
     602
     603    } while ((units_read == BLOCK_SIZE) && !error_found);
     604
    498605}
    499606
     
    507614        struct stat fileinfo;
    508615        const UChar * srcbuf;
    509         const UChar * src_head;
    510616        const UChar * srclimit;
    511617        const char * targetlimit;
     
    514620        UErrorCode status;
    515621        int chars_read;
    516         int buf_pos = 0;
    517622
    518623        if (argc < 2) {
     
    540645
    541646
    542 //      srcbuf = (UChar *) malloc(fileinfo.st_size+1);
    543         srcbuf = (UChar *) malloc(BUFFER_SIZE+BLOCK_SIZE*2);
    544         src_head = srcbuf;
     647        srcbuf = (UChar *) malloc(fileinfo.st_size+1);
    545648        if (!srcbuf) {
    546               fprintf(stderr, "Error: buffer for %s of size %i cannot be created.\n", infilename, fileinfo.st_size+1);
     649              fprintf(stderr, "Error: buffer for %s of size %zu cannot be created.\n", infilename, fileinfo.st_size+1);
    547650              exit(-1);
    548651        }
    549652
    550         targetbuf = (char *) malloc(BUFFER_SIZE*2);
    551         targetlimit = targetbuf + BUFFER_SIZE*2;
     653        chars_read = fread((void *)srcbuf, 1, fileinfo.st_size, infile);
     654
     655        srclimit = srcbuf + chars_read/2;
     656//      (*srcbuf)[fileinfo.st_size] = '\0';
     657        fclose(infile);
     658
     659        targetbuf = (char *) malloc(chars_read*2);
     660        targetlimit = targetbuf + chars_read*2;
    552661        target_head = targetbuf;
    553662
    554 #ifdef BUFFER_PROFILING
    555   transcode_timer = init_BOM_timer(BUFFER_SIZE);
    556 #endif
    557 
    558         chars_read = fread((void *)srcbuf, 1, BUFFER_SIZE, infile);
    559         srclimit = srcbuf + chars_read/2;
    560 
    561         while(chars_read>0){
    562 //              printf("chars_read = %i\n",chars_read);
    563 #ifdef BUFFER_PROFILING
    564 start_BOM_interval(transcode_timer);
    565 #endif
    566                 u16u8(&targetbuf, targetlimit, &srcbuf, srclimit, &status);
    567 
    568 #ifdef BUFFER_PROFILING
    569 end_BOM_interval(transcode_timer);
    570 #endif
    571                 fwrite(target_head , 1 ,  targetbuf - target_head, outfile );
    572 
    573                 targetbuf = target_head;
    574 
    575                 if (status == U_ILLEGAL_CHAR_FOUND) {
    576                         fprintf(stderr, "Illegal UTF-16 sequence at position %x in source.\n", buf_pos+chars_read-(srclimit-srcbuf)*2);
    577                         printf("error at pos %i is %x%x\n",chars_read-(srclimit-srcbuf)*2,((char*)srcbuf)[chars_read-(srclimit-srcbuf)*2],((char*)srcbuf)[chars_read-(srclimit-srcbuf)*2]);
    578                         exit(-1);
    579                 }
    580                 else if (status == U_TRUNCATED_CHAR_FOUND) {
    581                         fprintf(stderr, "EOF with incomplete UTF-16 sequence at position %i in source.\n",buf_pos+chars_read-(srclimit-srcbuf)*2);
    582                         exit(-1);
    583                 }
    584                 srcbuf = src_head;
    585                 buf_pos += chars_read;
    586 
    587                 chars_read = fread((void *)srcbuf, 1, BUFFER_SIZE, infile);
    588                 srclimit = srcbuf + chars_read/2;
    589         }
    590 #ifdef BUFFER_PROFILING
    591   printf("transcode_timer!\n");
    592   dump_BOM_table(transcode_timer);
    593 #endif
    594         fclose(infile);
    595         fclose(outfile);
     663        u16u8(&targetbuf, targetlimit, &srcbuf, srclimit, &status);
     664        fwrite(target_head , 1 ,  targetbuf - target_head, outfile );
     665
     666        if (status == U_ILLEGAL_CHAR_FOUND) {
     667                fprintf(stderr, "Illegal UTF-16 sequence at position %lu in source.\n", chars_read-(srclimit-srcbuf)*2);
     668        }
     669        else if (status == U_TRUNCATED_CHAR_FOUND) {
     670                fprintf(stderr, "EOF with incomplete UTF-16 sequence at position %lu in source.\n",chars_read-(srclimit-srcbuf)*2);
     671        }
     672
     673//      fclose(infile);
     674//      fclose(outfile);
    596675
    597676
  • proto/u16u8/u16u8_compilable2.py

    r366 r393  
    9898        u8_pre[7] = u16.utf8_3 & u16h[3]
    9999       
    100 #___    return (u16, u8_pre, u8_butlast, u8_last)
     100        return (u16, u8_pre, u8_butlast, u8_last)
    101101
Note: See TracChangeset for help on using the changeset viewer.