Changeset 4015


Ignore:
Timestamp:
Aug 16, 2014, 6:16:53 PM (5 years ago)
Author:
ksherdy
Message:

Updated strtoll demos.

Location:
proto/s2k/trunk/demo/strtoll
Files:
1 added
1 edited

Legend:

Unmodified
Added
Removed
  • proto/s2k/trunk/demo/strtoll/strtoll_demo.py

    r3884 r4015  
    11#
    22# Ken Herdy
    3 # Dec 22, 2013
     3# Dec  22, 2013  - Original
     4# June 21, 2014  - Removed inductive rotation.
     5# July 11, 2014  - Added option to rotate first.
    46#
    57# Program Flow
     
    1921# Character Class Definitions
    2022#
    21 # lex.ws                = [\x0D\x0A\x09 ]
     23# lex.ws        = [\x0D\x0A\x09 ]
    2224# lex.neg   = [-]
    2325# lex.pos   = [+]
     
    3234#
    3335# ws*(sign)?digit+(ws*(sign)?digit+)*
     36#
     37# Delimeter is ~(lex.ws|lex.sign|lex.digit).
    3438
    3539import sys
     
    4044from lib import estreams
    4145from lib import mstreams
     46from lib import cast
    4247import optparse
    4348import strtoll_demo_config
     49import binascii
    4450
    4551class Basis_bits():     
     
    5460
    5561class Lex():
    56         ws              = 0
     62        ws        = 0
    5763        neg   = 0
    5864        pos   = 0       
    59         sign    = 0
     65        sign  = 0
    6066        digit = 0
    6167
     
    113119        digits.follows                          = pablo.ScanThru(digits.starts, lex.digit)
    114120        digits.expect_ws_sign           = pablo.inFile(digits.follows) &~ (lex.ws | lex.sign)
    115 
    116 basis_bits                                              = Basis_bits()
    117 lex                                             = Lex()
    118 digits                                                  = Digits()
     121       
     122def Convert(s_3210):   
     123        # Step 1 - Convert nybble pairs
     124        # s<8> s8_3210 = bitcast<4>(s4_3210,8)
     125        d_lo_4                                  = hstreams.packh(8, s_3210, lgth_nybbles);
     126        d_lo_4_8                                = cast.zext(4, d_lo_4, 8, lgth_nybbles/2);
     127        d_hi_4                                  = hstreams.packl(8, s_3210, lgth_nybbles);
     128        d_hi_4_8                                = cast.zext(4, d_hi_4, 8, lgth_nybbles/2);
     129        c_10                                    = vstreams.constant(8, 10, lgth_nybbles);
     130        t_10                                    = vstreams.mul(8, d_hi_4_8, c_10, lgth_nybbles);
     131        result_10                               = vstreams.add(8, t_10, d_lo_4_8, lgth_nybbles);
     132       
     133        print ""       
     134        print "s<4> d_lo_4          = packh<8>(bitcast<4>(s_3210,8));     //" + bitutil.format_fields(bitutil.strm_to_bstr(d_lo_4, 4), 4)
     135        print "s<8> zext_d_lo_4     = zext<4>(d_lo_4,8);                  //" + bitutil.format_fields(bitutil.strm_to_bstr(d_lo_4_8, 8), 8)
     136        print "s<4> d_hi_4          = packl<8>(bitcast<4>(s_3210,8));     //" + bitutil.format_fields(bitutil.strm_to_bstr(d_hi_4, 4), 4)
     137        print "s<8> zext_d_hi_4     = zext<4>(d_hi_4,8);                  //" + bitutil.format_fields(bitutil.strm_to_bstr(d_hi_4_8, 8), 8)
     138        print "s<8> c_10            = constant<8>(10);                    //" + bitutil.format_fields(bitutil.strm_to_bstr(c_10, 8), 8)
     139        print "s<8> t1_10           = mul<8>(zext_d_hi_4, c_10);          //" + bitutil.format_fields(bitutil.strm_to_bstr(t_10, 8), 8)
     140        print "s<8> t2_10           = add<8>(t1_10,zext_d_lo_4);          //" + bitutil.format_fields(bitutil.strm_to_bstr(result_10, 8), 8)
     141
     142        # Step 2 - Convert byte pairs
     143        d_lo_8                  = hstreams.packh(16, result_10, lgth_nybbles);
     144        d_lo_8_16               = cast.zext(8, d_lo_8, 16, lgth_nybbles/2);
     145        d_hi_8                  = hstreams.packl(16, result_10, lgth_nybbles);
     146        d_hi_8_16               = cast.zext(8, d_hi_8, 16, lgth_nybbles/2);
     147        c_100                   = vstreams.constant(16, 100, lgth_nybbles);
     148        t_100                   = vstreams.mul(16, d_hi_8_16, c_100, lgth_nybbles);
     149        result_100              = vstreams.add(16, t_100, d_lo_8_16, lgth_nybbles);
     150
     151        print ""       
     152        print "s<8>  d_lo_8         = packh<16>(bitcast<8>(t2_10),16);    //" + bitutil.format_fields(bitutil.strm_to_bstr(d_lo_8, 8), 8)       
     153        print "s<16> zext_d_lo_8    = zext<8>(d_lo_8,16);                 //" + bitutil.format_fields(bitutil.strm_to_bstr(d_lo_8_16, 16), 16)
     154        print "s<8>  d_hi_8         = packl<16>(bitcast<8>(t2_10),16);    //" + bitutil.format_fields(bitutil.strm_to_bstr(d_hi_8, 8), 8)       
     155        print "s<16> zext_d_hi_8    = zext<8>(d_hi_8,16);                 //" + bitutil.format_fields(bitutil.strm_to_bstr(d_hi_8_16, 16), 16)
     156        print "s<16> c_100          = constant<16>(100);                  //" + bitutil.format_fields(bitutil.strm_to_bstr(c_100, 16), 16)
     157        print "s<16> t1_100         = mul<16>zext_di_hi_8,c_100);         //" + bitutil.format_fields(bitutil.strm_to_bstr(t_100, 16), 16)
     158        print "s<16> t2_100         = add<16>(t1_100,zext_do_lo_8);       //" + bitutil.format_fields(bitutil.strm_to_bstr(result_100, 16), 16)
     159
     160        # Step 3 - Convert double-byte pairs
     161        d_lo_16                 = hstreams.packh(32, result_100, lgth_nybbles/2);
     162        d_lo_16_32              = cast.zext(16, d_lo_16, 32, lgth_nybbles/2);
     163        d_hi_16                 = hstreams.packl(32, result_100, lgth_nybbles/2);       
     164        d_hi_16_32              = cast.zext(16, d_hi_16, 32, lgth_nybbles/2);
     165        c_10000                 = vstreams.constant(32, 10000, lgth_nybbles/2);
     166        t_10000                 = vstreams.mul(32, d_hi_16, c_10000, lgth_nybbles);
     167        t2_10000                = vstreams.add(32, t_10000, d_lo_16, lgth_nybbles);
     168
     169        print ""       
     170        print "s<16> d_lo_16        = packh<32>(bitcast<16>(t2_100),32);  //" + bitutil.format_fields(bitutil.strm_to_bstr(d_lo_16, 16), 16)   
     171        print "s<32> zext_d_lo_16   = zext<16>(d_lo_16,32);               //" + bitutil.format_fields(bitutil.strm_to_bstr(d_lo_16_32, 32), 32)
     172        print "s<16> d_hi_16        = packl<32>(bitcast<16>(t2_100),32);  //" + bitutil.format_fields(bitutil.strm_to_bstr(d_hi_16, 16), 16)   
     173        print "s<32> zext_d_hi_16   = zext<16>(d_hi_16,32);               //" + bitutil.format_fields(bitutil.strm_to_bstr(d_hi_16_32, 32), 32)
     174        print "s<32> c_10000        = constant<32>(10000);                //" + bitutil.format_fields(bitutil.strm_to_bstr(c_10000, 32), 32)
     175        print "s<32> t1_10000       = mul<32>(zext_d_hi_16,c_10000);      //" + bitutil.format_fields(bitutil.strm_to_bstr(t_10000, 32), 32)
     176        print "s<32> t2_10000       = add<32>(t1_10000,zext_d_lo_16);     //" + bitutil.format_fields(bitutil.strm_to_bstr(t2_10000, 32), 32)
     177               
     178        rslt                    = hstreams.packl(32, t2_10000, lgth_nybbles);
     179        print ""
     180        print "s<16> rslt           = packl<32>(t2_10000)               "       + bitutil.format_fields(bitutil.strm_to_bstr(rslt, 16), 16)
     181       
     182def Rotate(s_3210):     
     183    # Stage 1: Rotate 4-bit fields.
     184        # BitBlock rot_4                                = simd_or(simd<8>::slli<4>(s_3210), simd<8>::srli<4>(s_3210));
     185        # bitcast<16>(rot_16,32);
     186        rot_4 = mstreams.slli(8,4,s_3210, lgth_nybbles) | mstreams.srli(8,4,s_3210, lgth_nybbles)
     187        print "rot_4                                " + bitutil.format_fields(bitutil.strm_to_bstr(rot_4, lgth_nybbles), 8)
     188
     189        # Stage 2: Rotate 8-bit fields.
     190        #       BitBlock rot_8                          = simd_or(simd<16>::slli<8>(rot_4), simd<16>::srli<8>(rot_4));
     191        # bitcast<16>(rot_16,32);
     192        rot_8 = mstreams.slli(16,8,rot_4, lgth_nybbles) | mstreams.srli(16,8,rot_4, lgth_nybbles)
     193        print "rot_8                                " + bitutil.format_fields(bitutil.strm_to_bstr(rot_8, lgth_nybbles), 16)
     194
     195        # Stage 3: Rotate 16-bit fields.       
     196        #       BitBlock rot_16                         = simd_or(simd<32>::slli<16>(rot_8), simd<32>::srli<16>(rot_8));
     197        # bitcast<16>(rot_16,32);
     198        rot_16 = mstreams.slli(32,16,rot_8, lgth_nybbles) | mstreams.srli(32,16,rot_8, lgth_nybbles)
     199        print "rot_16                               " + bitutil.format_fields(bitutil.strm_to_bstr(rot_16, lgth_nybbles), 32)
     200       
     201        # bitcast<32>(rot_16,4);
     202        return rot_16
     203
     204def RConvert(rot_16):
     205        pass
     206        ### Parallel ASCII to binary integer conversion, low-aligned (32-bit) least significant digit
     207       
     208       
     209        # Stage 1: Convert 4-bit pairs.
     210        # TODO bitcast rot_16 to 8
     211       
     212        d_hi_4                  = mstreams.srli(8, 4, rot_16, lgth_nybbles) 
     213        lomask_8                = vstreams.lomask(8, lgth_nybbles);
     214        d_lo_4                  = rot_16 & lomask_8
     215        c_10                    = vstreams.constant(8, 10, lgth_nybbles);
     216        t1_10                   = vstreams.mul(8, d_hi_4, c_10, lgth_nybbles);
     217        t2_10                   = vstreams.add(8, t1_10, d_lo_4, lgth_nybbles);
     218               
     219        print "s<8> d_hi_4     = srli<8>(4,bitcast<32>(rot_16,8))   // " + bitutil.format_fields(bitutil.strm_to_bstr(d_hi_4, lgth_nybbles), 8)
     220        print "s<8> lomask_8   = lomask<8>()                        // " + bitutil.format_fields(bitutil.strm_to_bstr(lomask_8, lgth_nybbles), 8)
     221        print "s<8> d_lo_4     = and<8>(rot_16, lomask8)            // " + bitutil.format_fields(bitutil.strm_to_bstr(d_lo_4, lgth_nybbles), 8)
     222        print "s<8> c_10       = constant<8>(10)                    // " + bitutil.format_fields(bitutil.strm_to_bstr(c_10, lgth_nybbles), 8)
     223        print "s<8> t1_10      = mul<8>(d_hi_4, c_10)               // " + bitutil.format_fields(bitutil.strm_to_bstr(t1_10, lgth_nybbles), 8)
     224        print "s<8> t2_10      = add<8>(t1_10, d_lo_4)              // " + bitutil.format_fields(bitutil.strm_to_bstr(t2_10, lgth_nybbles), 8)
     225
     226        # Stage 2: Convert 8-bit pairs.
     227        # TODO bitcast t2_10 to 16
     228        d_hi_8                  = mstreams.srli(16, 8, t2_10, lgth_nybbles)
     229        lomask_16               = vstreams.lomask(16, lgth_nybbles);
     230        d_lo_8                  = t2_10 & lomask_16
     231        c_100                   = vstreams.constant(16, 100, lgth_nybbles);
     232        t1_100                  = vstreams.mul(16, d_hi_8, c_100, lgth_nybbles);
     233        t2_100                  = vstreams.add(16, t1_100, d_lo_8, lgth_nybbles);
     234
     235        print "s<16> d_hi_8    = srli<16>(8,bitcast<8>(t2_10,16))   // " + bitutil.format_fields(bitutil.strm_to_bstr(d_hi_8, lgth_nybbles), 16)
     236        print "s<16> lomask_16 = lomask<16>()                       // " + bitutil.format_fields(bitutil.strm_to_bstr(lomask_16, lgth_nybbles), 16)
     237        print "s<16> d_lo_8    = and<16>(d_hi_8, lomask16)          // " + bitutil.format_fields(bitutil.strm_to_bstr(d_lo_8, lgth_nybbles), 16)
     238        print "s<16> c_100     = constant<16>(100)                  // " + bitutil.format_fields(bitutil.strm_to_bstr(c_100, lgth_nybbles), 16)
     239        print "s<16> t1_100    = mul<16>(d_hi_8, c_100)             // " + bitutil.format_fields(bitutil.strm_to_bstr(t1_100, lgth_nybbles), 16)
     240        print "s<16> t2_100    = add<16>(t1_100, d_lo_8)            // " + bitutil.format_fields(bitutil.strm_to_bstr(t2_100, lgth_nybbles), 16)
     241
     242        # Stage 3: Convert 16-bit pairs.
     243        # TODO bitcast t2_100 to 32
     244        d_hi_16         = mstreams.srli(32, 16, t2_100, lgth_nybbles)
     245        lomask_32       = vstreams.lomask(32, lgth_nybbles);
     246        d_lo_16         = t2_100 & lomask_32
     247        c_10000         = vstreams.constant(32, 10000, lgth_nybbles);
     248        t1_10000        = vstreams.mul(32, d_hi_16, c_10000, lgth_nybbles);
     249        t2_10000        = vstreams.add(32, t1_10000, d_lo_16, lgth_nybbles);
     250
     251        print "s<32> d_hi_16   = srli<32>(16,bitcast<8>(t2_100,32)) // " + bitutil.format_fields(bitutil.strm_to_bstr(d_hi_16, lgth_nybbles), 32)
     252        print "s<32> lomask_32 = lomask<32>()                       // " + bitutil.format_fields(bitutil.strm_to_bstr(lomask_32, lgth_nybbles), 32)
     253        print "s<32> d_lo_16   = and<32>(d_hi_16, lomask32)         // " + bitutil.format_fields(bitutil.strm_to_bstr(d_lo_16, lgth_nybbles), 32)
     254        print "s<32> c_10000   = constant<32>(10000)                // " + bitutil.format_fields(bitutil.strm_to_bstr(c_10000, lgth_nybbles), 32)
     255        print "s<32> t1_10000  = mul<32>(d_hi_16, c_10000)          // " + bitutil.format_fields(bitutil.strm_to_bstr(t1_10000, lgth_nybbles), 32)
     256        print "s<32> t2_10000  = add<32>(t1_10000, d_lo_16)         // " + bitutil.format_fields(bitutil.strm_to_bstr(t2_10000, lgth_nybbles), 32)
     257
     258        rslt            = hstreams.packl(32,t2_10000,lgth_nybbles)
     259        print "s<16> rslt      = packl<32>(t2_10000)                // " + bitutil.format_fields(bitutil.strm_to_bstr(rslt, lgth_nybbles/2), 16)
     260       
     261basis   = Basis_bits()
     262lex     = Lex()
     263digits  = Digits()
    119264
    120265if __name__ == "__main__":
     
    129274                input_file = args[0]
    130275
    131   # ReadStreamInput(data)
    132276        global data
    133277        global lgth
    134278
    135279        data = bitutil.readfile(input_file)
    136         data = data[:-2] # -1 strip EOF
     280        data = data[:-1] # -1 strip EOF
    137281
    138282        data_le                         = data[::-1] # reverse
     
    143287        lgth_bits                       = lgth/8
    144288
    145         pablo.EOF_mask = pablo.transpose_streams(data, basis_bits)
    146 
    147         ClassifyBytes(basis_bits, lex)
     289        pablo.EOF_mask = pablo.transpose_streams(data, basis)
     290
     291        ClassifyBytes(basis, lex)
    148292        MarkDigits(lex, digits)
    149293
     
    151295        ### Demo
    152296        #       
    153         print "Source Data                                 " + bitutil.format_fields(data_le,1)
    154 #       print "s_76543210                                  " + bitutil.format_fields(s_76543210)
    155         print "pablo.EOF_mask                              " + bitutil.format_fields(bin(pablo.EOF_mask)[2:],1)
    156         print "basis_bits_le.bit_7                         " + bitutil.format_fields(bitutil.strm_to_bstr(basis_bits.bit_0,lgth_bits),1)
    157         print "basis_bits_le.bit_6                         " + bitutil.format_fields(bitutil.strm_to_bstr(basis_bits.bit_1,lgth_bits),1)
    158         print "basis_bits_le.bit_5                         " + bitutil.format_fields(bitutil.strm_to_bstr(basis_bits.bit_2,lgth_bits),1)
    159         print "basis_bits_le.bit_4                         " + bitutil.format_fields(bitutil.strm_to_bstr(basis_bits.bit_3,lgth_bits),1)
    160         print "basis_bits_le.bit_3                         " + bitutil.format_fields(bitutil.strm_to_bstr(basis_bits.bit_4,lgth_bits),1)
    161         print "basis_bits_le.bit_2                         " + bitutil.format_fields(bitutil.strm_to_bstr(basis_bits.bit_5,lgth_bits),1)
    162         print "basis_bits_le.bit_1                         " + bitutil.format_fields(bitutil.strm_to_bstr(basis_bits.bit_6,lgth_bits),1)
    163         print "basis_bits_le.bit_0                         " + bitutil.format_fields(bitutil.strm_to_bstr(basis_bits.bit_7,lgth_bits),1)
    164         print "lex.neg                                     " + bitutil.format_fields(bitutil.strm_to_bstr(lex.neg,lgth_bits),1)
    165         print "lex.pos                                     " + bitutil.format_fields(bitutil.strm_to_bstr(lex.pos,lgth_bits),1)
    166         print "lex.digit                                   " + bitutil.format_fields(bitutil.strm_to_bstr(lex.digit,lgth_bits),1)
    167 
    168         # BitBlock ascii_lo_4                                                   = hsimd<8>::packl(source_lo_128, source_hi_128);
    169         ascii_lo_4 = hstreams.packl(8, bitutil.bstr_to_strm(s_76543210), lgth)
    170         print "stream<4> ascii_lo_4 = packl(4, s_76543210) " + bitutil.format_fields(bitutil.strm_to_bstr(ascii_lo_4, lgth_nybbles), 4)
    171 
    172         ###     Reverse nybbles using inductive doubling and rotation 
    173  
    174         #       BitBlock digits_rot_4                           = simd_or(simd<8>::slli<4>(ascii_lo_4), simd<8>::srli<4>(ascii_lo_4));
    175         digits_rot_4 = mstreams.slli(8,4,ascii_lo_4, lgth_nybbles) | mstreams.srli(8,4,ascii_lo_4, lgth_nybbles)
    176         print "digits_rot_4                                " + bitutil.format_fields(bitutil.strm_to_bstr(digits_rot_4, lgth_nybbles), 4)
    177 
    178         #       BitBlock digits_rot_8                           = simd_or(simd<16>::slli<8>(digits_rot_4), simd<16>::srli<8>(digits_rot_4));
    179         digits_rot_8 = mstreams.slli(16,8,digits_rot_4, lgth_nybbles) | mstreams.srli(16,8,digits_rot_4, lgth_nybbles)
    180         print "digits_rot_8                                " + bitutil.format_fields(bitutil.strm_to_bstr(digits_rot_8, lgth_nybbles), 4)
    181 
    182         #       BitBlock digits_rot_16                          = simd_or(simd<32>::slli<16>(digits_rot_8), simd<32>::srli<16>(digits_rot_8));
    183         digits_rot_16 = mstreams.slli(32,16,digits_rot_8, lgth_nybbles) | mstreams.srli(32,16,digits_rot_8, lgth_nybbles)
    184         print "digits_rot_16                               " + bitutil.format_fields(bitutil.strm_to_bstr(digits_rot_16, lgth_nybbles), 4)
    185 
    186 
     297        print "Input Data                                               " + bitutil.format_fields(data_le,1)
     298        #print "s_76543210                                              " + bitutil.format_fields(s_76543210)
     299        #print "pablo.EOF_mask                                          " + bitutil.format_fields(bin(pablo.EOF_mask)[2:],1)
     300        print "basis.s_7                                                " + bitutil.format_fields(bitutil.strm_to_bstr(basis.bit_0,lgth_bits),1)
     301        print "basis.s_6                                                " + bitutil.format_fields(bitutil.strm_to_bstr(basis.bit_1,lgth_bits),1)
     302        print "basis.s_5                                                " + bitutil.format_fields(bitutil.strm_to_bstr(basis.bit_2,lgth_bits),1)
     303        print "basis.s_4                                                " + bitutil.format_fields(bitutil.strm_to_bstr(basis.bit_3,lgth_bits),1)
     304        print "basis.s_3                                                " + bitutil.format_fields(bitutil.strm_to_bstr(basis.bit_4,lgth_bits),1)
     305        print "basis.s_2                                                " + bitutil.format_fields(bitutil.strm_to_bstr(basis.bit_5,lgth_bits),1)
     306        print "basis.s_1                                                " + bitutil.format_fields(bitutil.strm_to_bstr(basis.bit_6,lgth_bits),1)
     307        print "basis.s_0                                                " + bitutil.format_fields(bitutil.strm_to_bstr(basis.bit_7,lgth_bits),1)
     308        print "lex.neg                                                  " + bitutil.format_fields(bitutil.strm_to_bstr(lex.neg,lgth_bits),1)
     309        print "lex.pos                                                  " + bitutil.format_fields(bitutil.strm_to_bstr(lex.pos,lgth_bits),1)
     310        print "lex.digit                                                " + bitutil.format_fields(bitutil.strm_to_bstr(lex.digit,lgth_bits),1)
     311
     312        print ""
     313
     314        # ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- -----   
     315    # Parallel ASCII to integer conversion (aligned 8 byte ASCII values to 16 bit integer values)
     316    # using a shift approach.
     317        #
     318    # BitBlock s_3210                                                   = hsimd<8>::packl(source_lo_128, source_hi_128);
     319        #
     320        # pgatherh<4>(lex.digit,s_3210,32)
     321        #
     322        s_3210 = hstreams.packl(8, bitutil.bstr_to_strm(s_76543210), lgth)
     323        print ""
     324        print "s<8> s_76543210      = read();                            " + bitutil.format_fields(s_76543210, 8)
     325        print "s<4> s_3210          = packl<4>(s_76543210);              " + bitutil.format_fields(bitutil.strm_to_bstr(s_3210, lgth_nybbles), 4)
    187326        ### Parallel ASCII to integer conversion (aligned 8 byte ASCII values to 16 bit integer values)
    188327
     328#       Convert(s_3210)
     329        RConvert(Rotate(s_3210))
     330
     331        # WriteStreamOutput(Output)
     332
     333        #
     334    # ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- -----       
     335    # Parallel ASCII to integer conversion (aligned 8 byte ASCII values to 16 bit integer values)
     336    # using a shift approach.
     337    #
     338        # BitBlock s_3210                                               = hsimd<8>::packl(source_lo_128, source_hi_128);
     339        #s_3210 = hstreams.packl(8, bitutil.bstr_to_strm(s_76543210), lgth)
     340        #print "s<4> s_3210  = packl(4, s_76543210)         " + bitutil.format_fields(bitutil.strm_to_bstr(s_3210, lgth_nybbles), 4)
     341
    189342        # Step 1 - Convert nybble pairs
    190         digits_hi_4                                     = mstreams.srli(8,4,digits_rot_16, lgth_nybbles)
    191         lomask_8                                        = vstreams.lomask(8, lgth_nybbles);
    192         digits_lo_4                                     = digits_rot_16 & lomask_8
    193         constant_10                                     = vstreams.constant(8,10, lgth_nybbles);
    194         temp_10s                                        = vstreams.mul(8,digits_hi_4, constant_10, lgth_nybbles);       # TODO bitcast to 8
    195         result_10s                                      = vstreams.add(8,temp_10s, digits_lo_4, lgth_nybbles);
    196 
    197         print "digits_hi_4                                 " + bitutil.format_fields(bitutil.strm_to_bstr(digits_hi_4, lgth_nybbles), 4)       
    198         print "lomask_8                                    " + bitutil.format_fields(bitutil.strm_to_bstr(lomask_8, lgth_nybbles), 4)
    199         print "digits_lo_4                                 " + bitutil.format_fields(bitutil.strm_to_bstr(digits_lo_4, lgth_nybbles), 4)
    200         print "constant_10                                 " + bitutil.format_fields(bitutil.strm_to_bstr(constant_10, lgth_nybbles), 4)
    201         print "temp_10s                                    " + bitutil.format_fields(bitutil.strm_to_bstr(temp_10s, lgth_nybbles), 8)
    202         print "result_10s                                  " + bitutil.format_fields(bitutil.strm_to_bstr(result_10s, lgth_nybbles), 8)
     343        # s<8> s8_3210 = bitcast<4>(s4_3210,8)
     344        #s_76543210             = cast.bitcast(4, s_3210, 8);
     345        #d_lo_4                 = mstreams.srli(8, 4, s_76543210, lgth_nybbles);
     346        #lomask_8               = vstreams.lomask(8, lgth_nybbles);
     347        #d_hi_4                 = s_76543210 & lomask_8;
     348        #c_10                   = vstreams.constant(8, 10, lgth_nybbles);
     349        #t1_10                  = vstreams.mul(8, d_hi_4, c_10, lgth_nybbles);
     350        #result1_10             = vstreams.add(8, t1_10, d_lo_4, lgth_nybbles);
     351
     352        # s<8> s8_3210 = bitcast<4>(s4_3210,8)
     353        #print "s_76543210                           " + bitutil.format_fields(bitutil.strm_to_bstr(s_76543210, lgth_nybbles), 8)
     354        #print "d_lo_4                               " + bitutil.format_fields(bitutil.strm_to_bstr(d_lo_4, lgth_nybbles), 8)
     355        #print "lomask_8                             " + bitutil.format_fields(bitutil.strm_to_bstr(lomask_8, lgth_nybbles), 8)
     356        #print "d_hi_4                               " + bitutil.format_fields(bitutil.strm_to_bstr(d_hi_4, lgth_nybbles), 8)   
     357        #print "c_10                                 " + bitutil.format_fields(bitutil.strm_to_bstr(c_10, lgth_nybbles), 8)
     358        #print "t1_10                                 " + bitutil.format_fields(bitutil.strm_to_bstr(t1_10, lgth_nybbles), 8)
     359        #print "result1_10                            " + bitutil.format_fields(bitutil.strm_to_bstr(result1_10, lgth_nybbles), 8)
    203360
    204361        # Step 2 - Convert byte pairs
    205 
    206         digits_hi_8                                     = mstreams.srli(8*2,4*2, result_10s, lgth_nybbles)
    207         lomask_16                                       = vstreams.lomask(8*2, lgth_nybbles);
    208         digits_lo_8                                     = result_10s & lomask_16
    209         constant_100                            = vstreams.constant(8*2,10*10, lgth_nybbles);
    210         temp_100s                                       = vstreams.mul(8*2,digits_hi_8, constant_100, lgth_nybbles);    # TODO bitcast to 8
    211         result_100s                                     = vstreams.add(8*2,temp_100s, digits_lo_8, lgth_nybbles);
    212 
    213         print "digits_hi_8                                 " + bitutil.format_fields(bitutil.strm_to_bstr(digits_hi_8, lgth_nybbles), 8)       
    214         print "lomask_16                                   " + bitutil.format_fields(bitutil.strm_to_bstr(lomask_16, lgth_nybbles), 8)
    215         print "digits_lo_8                                 " + bitutil.format_fields(bitutil.strm_to_bstr(digits_lo_8, lgth_nybbles), 8)
    216         print "constant_100                                " + bitutil.format_fields(bitutil.strm_to_bstr(constant_100, lgth_nybbles), 8)
    217         print "temp_100s                                   " + bitutil.format_fields(bitutil.strm_to_bstr(temp_100s, lgth_nybbles), 16)
    218         print "result_100s                                 " + bitutil.format_fields(bitutil.strm_to_bstr(result_100s, lgth_nybbles), 16)
     362        #d_lo_8                 = mstreams.srli(8*2,4*2, cast.bitcast(8, result1_10, 16), lgth_nybbles)
     363        #lomask_16              = vstreams.lomask(8*2, lgth_nybbles);
     364        #d_hi_8                 = cast.bitcast(8, result1_10, 16) & lomask_16
     365        #c_100                  = vstreams.constant(8*2, 10*10, lgth_nybbles);
     366        #t1_100                 = vstreams.mul(8*2, d_hi_8, c_100, lgth_nybbles);       # TODO bitcast to 8
     367        #result1_100            = vstreams.add(8*2, t1_100, d_lo_8, lgth_nybbles);
     368
     369        #print "d_hi_8                               " + bitutil.format_fields(bitutil.strm_to_bstr(d_hi_8, lgth_nybbles), 16) 
     370        #print "lomask_16                            " + bitutil.format_fields(bitutil.strm_to_bstr(lomask_16, lgth_nybbles), 16)
     371        #print "d_lo_8                               " + bitutil.format_fields(bitutil.strm_to_bstr(d_lo_8, lgth_nybbles), 16)
     372        #print "c_100                                " + bitutil.format_fields(bitutil.strm_to_bstr(c_100, lgth_nybbles), 16)
     373        #print "t1_100                                " + bitutil.format_fields(bitutil.strm_to_bstr(t1_100, lgth_nybbles), 16)
     374        #print "result1_100                           " + bitutil.format_fields(bitutil.strm_to_bstr(result1_100, lgth_nybbles), 16)
    219375
    220376        # Step 3 - Convert double-byte pairs
    221 
    222         digits_hi_16                            = mstreams.srli(8*2*2,4*2*2, result_100s, lgth_nybbles)
    223         lomask_32                                       = vstreams.lomask(8*2*2, lgth_nybbles);
    224         digits_lo_16                            = result_100s & lomask_32
    225         constant_10000                      = vstreams.constant(8*2*2,10*10*10*10, lgth_nybbles);
    226         temp_10000s                                     = vstreams.mul(8*2*2,digits_hi_16, constant_10000, lgth_nybbles);       # TODO bitcast to 8
    227         result_10000s                           = vstreams.add(8*2*2,temp_10000s, digits_lo_16, lgth_nybbles);
    228 
    229         print "digits_hi_16                                " + bitutil.format_fields(bitutil.strm_to_bstr(digits_hi_16, lgth_nybbles), 8)       
    230         print "lomask_32                                   " + bitutil.format_fields(bitutil.strm_to_bstr(lomask_32, lgth_nybbles), 8)
    231         print "digits_lo_16                                " + bitutil.format_fields(bitutil.strm_to_bstr(digits_lo_16, lgth_nybbles), 8)
    232         print "constant_1000                               " + bitutil.format_fields(bitutil.strm_to_bstr(constant_10000, lgth_nybbles), 8)
    233         print "temp_10000s                                 " + bitutil.format_fields(bitutil.strm_to_bstr(temp_10000s, lgth_nybbles), 16)
    234         print "result_10000s                               " + bitutil.format_fields(bitutil.strm_to_bstr(result_10000s, lgth_nybbles), 16)
    235 
    236         pack_result_10000s      = hstreams.packl(32,result_10000s,lgth_nybbles)
    237         print "pack_result_10000s                          " + bitutil.format_fields(bitutil.strm_to_bstr(pack_result_10000s, lgth_nybbles/2), 16)
    238 
    239   # WriteStreamOutput(Output)
    240 
    241 #
    242 ### Some Samples
    243 #
    244 
    245 #       t                                       = vstreams.add_hl(8,s_76543210)
    246 #       t                                       = vstreams.add_hl(4,s_7654)
    247 #   t                                   = vstreams.add_hl(2,s_10)
    248 #       t                                       = vstreams.lomask(2,s_10)
    249 #       t                                       = vstreams.himask(4,s_3210)
    250 #       t                                       = vstreams.himask(8,s_76543210)
    251 #       t                                       = vstreams.constant(4,10,s_3210)
    252 #       t                                       = vstreams.constant(8,100,s_76543210)
    253 
    254 #       m                                       = vstreams.AndC(cast.bitcast(1,s_76543210), cast.bitcast(1,flow.Advance(s_76543210)))
    255 #       s                                       = cast.bitcast(24,s_76543210)
    256 #       r                                       = flow.ScanThru(m,s)
    257 
    258 #       t                                       = cast.bitcast(8, r)
    259 #       m                                       = cast.bitcast(8,m)
    260 #       s                                       = cast.bitcast(8,s)
    261 #       t                                       = cast.bitcast(8,t)
    262 
    263 #       t                                       = estreams.paligned_extract(8, 8, m, s_76543210)
    264 
    265 # if a strm had a length we would know how to pad out the zeroes before the chop
    266 
     377        #d_lo_16                = mstreams.srli(8*2*2, 4*2*2, cast.bitcast(16,result1_100,32), lgth_nybbles)
     378        #lomask_32              = vstreams.lomask(8*2*2, lgth_nybbles);
     379        #d_hi_16                = cast.bitcast(16,result1_100,32) & lomask_32
     380        #c_10000                = vstreams.constant(8*2*2, 10*10*10*10, lgth_nybbles);
     381        #t1_10000               = vstreams.mul(8*2*2, d_hi_16, c_10000, lgth_nybbles);  # TODO bitcast to 8
     382        #t2_10000       = vstreams.add(8*2*2, t1_10000, d_lo_16, lgth_nybbles);
     383
     384        #print "d_hi_16                              " + bitutil.format_fields(bitutil.strm_to_bstr(d_hi_16, lgth_nybbles), 32)
     385        #print "lomask_32                            " + bitutil.format_fields(bitutil.strm_to_bstr(lomask_32, lgth_nybbles), 32)
     386        #print "d_lo_16                              " + bitutil.format_fields(bitutil.strm_to_bstr(d_lo_16, lgth_nybbles), 32)
     387        #print "c_1000                               " + bitutil.format_fields(bitutil.strm_to_bstr(c_10000, lgth_nybbles), 32)
     388        #print "t1_10000                              " + bitutil.format_fields(bitutil.strm_to_bstr(t1_10000, lgth_nybbles), 32)
     389        #print "t2_10000                         " + bitutil.format_fields(bitutil.strm_to_bstr(t2_10000, lgth_nybbles), 32)
     390
     391        #pack_t2_10000  = hstreams.packl(32,t2_10000,lgth_nybbles)
     392        #print "pack_t2_10000                    " + bitutil.format_fields(bitutil.strm_to_bstr(pack_t2_10000, lgth_nybbles/2), 16)
     393
     394        # BitBlock s_3210   = hsimd<8>::packl(source_lo_128, source_hi_128);
     395        #s_3210 = hstreams.packl(8, bitutil.bstr_to_strm(s_76543210), lgth)
     396        #print "s<4> s_3210 = packl(4, s_76543210)   " + bitutil.format_fields(bitutil.strm_to_bstr(s_3210, lgth_nybbles), 4)
     397
     398        #--- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
     399
     400        ### Parallel ASCII to integer conversion (aligned 8 byte ASCII values to 16 bit integer values)
     401
     402        # Step 1 - Convert nybble pairs
     403        #d_hi_4                         = mstreams.srli(8, 4, rot_16, lgth_nybbles)
     404        #lomask_8                       = vstreams.lomask(8, lgth_nybbles);
     405        #d_lo_4                         = rot_16 & lomask_8
     406        #c_10                           = vstreams.constant(8, 10, lgth_nybbles);
     407        #t1_10                          = vstreams.mul(8, d_hi_4, c_10, lgth_nybbles);  # TODO bitcast to 8
     408        #result_10                      = vstreams.add(8, t_10, d_lo_4, lgth_nybbles);
     409
     410        #print "d_hi_4                               " + bitutil.format_fields(bitutil.strm_to_bstr(d_hi_4, lgth_nybbles), 4)   
     411        #print "lomask_8                             " + bitutil.format_fields(bitutil.strm_to_bstr(lomask_8, lgth_nybbles), 4)
     412        #print "d_lo_4                               " + bitutil.format_fields(bitutil.strm_to_bstr(d_lo_4, lgth_nybbles), 4)
     413        #print "c_10                                 " + bitutil.format_fields(bitutil.strm_to_bstr(c_10, lgth_nybbles), 4)
     414        #print "t_10                                 " + bitutil.format_fields(bitutil.strm_to_bstr(t_10, lgth_nybbles), 8)
     415        #print "result_10                            " + bitutil.format_fields(bitutil.strm_to_bstr(result_10, lgth_nybbles), 8)
     416
     417        # Step 2 - Convert byte pairs
     418        #d_hi_8                 = mstreams.srli(8*2,4*2, result_10, lgth_nybbles)
     419        #lomask_16              = vstreams.lomask(8*2, lgth_nybbles);
     420        #d_lo_8                 = result_10 & lomask_16
     421        #c_100                  = vstreams.constant(8*2,10*10, lgth_nybbles);
     422        #t_100                  = vstreams.mul(8*2,d_hi_8, c_100, lgth_nybbles);        # TODO bitcast to 8
     423        #result_100             = vstreams.add(8*2,t_100, d_lo_8, lgth_nybbles);
     424
     425        #print "d_hi_8                               " + bitutil.format_fields(bitutil.strm_to_bstr(d_hi_8, lgth_nybbles), 8)   
     426        #print "lomask_16                            " + bitutil.format_fields(bitutil.strm_to_bstr(lomask_16, lgth_nybbles), 8)
     427        #print "d_lo_8                               " + bitutil.format_fields(bitutil.strm_to_bstr(d_lo_8, lgth_nybbles), 8)
     428        #print "c_100                                " + bitutil.format_fields(bitutil.strm_to_bstr(c_100, lgth_nybbles), 8)
     429        #print "t_100                                " + bitutil.format_fields(bitutil.strm_to_bstr(t_100, lgth_nybbles), 16)
     430        #print "result_100                           " + bitutil.format_fields(bitutil.strm_to_bstr(result_100, lgth_nybbles), 16)
     431
     432        # Step 3 - Convert double-byte pairs
     433
     434        #d_hi_16                = mstreams.srli(8*2*2,4*2*2, result_100, lgth_nybbles)
     435        #lomask_32              = vstreams.lomask(8*2*2, lgth_nybbles);
     436        #d_lo_16                = result_100 & lomask_32
     437        #c_10000                = vstreams.constant(8*2*2,10*10*10*10, lgth_nybbles);
     438        #t_10000                = vstreams.mul(8*2*2,d_hi_16, c_10000, lgth_nybbles);   # TODO bitcast to 8
     439        #t2_10000       = vstreams.add(8*2*2,t_10000, d_lo_16, lgth_nybbles);
     440
     441        #print "d_hi_16                              " + bitutil.format_fields(bitutil.strm_to_bstr(d_hi_16, lgth_nybbles), 8) 
     442        #print "lomask_32                            " + bitutil.format_fields(bitutil.strm_to_bstr(lomask_32, lgth_nybbles), 8)
     443        #print "d_lo_16                              " + bitutil.format_fields(bitutil.strm_to_bstr(d_lo_16, lgth_nybbles), 8)
     444        #print "c_1000                               " + bitutil.format_fields(bitutil.strm_to_bstr(c_10000, lgth_nybbles), 8)
     445        #print "t_10000                              " + bitutil.format_fields(bitutil.strm_to_bstr(t_10000, lgth_nybbles), 16)
     446        #print "t2_10000                         " + bitutil.format_fields(bitutil.strm_to_bstr(t2_10000, lgth_nybbles), 16)
     447
     448        #pack_t2_10000  = hstreams.packl(32,t2_10000,lgth_nybbles)
     449        #print "pack_t2_10000                          " + bitutil.format_fields(bitutil.strm_to_bstr(pack_t2_10000, lgth_nybbles/2), 16)
     450       
Note: See TracChangeset for help on using the changeset viewer.