source: proto/s2k/trunk/demo/strtoll/strtoll_demo.py @ 4015

Last change on this file since 4015 was 4015, checked in by ksherdy, 5 years ago

Updated strtoll demos.

File size: 24.0 KB
Line 
1#
2# Ken Herdy
3# Dec  22, 2013  - Original
4# June 21, 2014  - Removed inductive rotation.
5# July 11, 2014  - Added option to rotate first.
6#
7# Program Flow
8#
9# StreamInput` -> Transpose` -> Classify -> MarkDigits -> StringToInteger -> StreamOutput`
10#                                       
11# Back ticks ` denote functionality provided by a hand-coded C++ template.
12#
13# A very simple example to demonstrate ASCII to integer conversion
14# in a manner similar to the BSD strtoll utility. This demo converts to 16 bit integers.
15#
16# See,
17#
18# - http://linux.die.net/man/3/strtoll,
19# - http://www.opensource.apple.com/source/lukemftp/lukemftp-12/tnftp/libnetbsd/strtoll.c
20#
21# Character Class Definitions
22#
23# lex.ws        = [\x0D\x0A\x09 ]
24# lex.neg   = [-]
25# lex.pos   = [+]
26# lex.sign  = [-+]
27# lex.digit = [0-9]
28#
29# ASCII Base 10 Integer Lexical Grammar.
30#
31# ws*(sign)?digit+
32#
33# Whitespace or Sign Delimited ASCII Base 10 Integers.
34#
35# ws*(sign)?digit+(ws*(sign)?digit+)*
36#
37# Delimeter is ~(lex.ws|lex.sign|lex.digit).
38
39import sys
40from lib import pablo
41from lib import bitutil
42from lib import vstreams
43from lib import hstreams
44from lib import estreams
45from lib import mstreams
46from lib import cast
47import optparse
48import strtoll_demo_config
49import binascii
50
51class Basis_bits():     
52        bit_7 = 0
53        bit_6 = 0
54        bit_5 = 0
55        bit_4 = 0
56        bit_3 = 0
57        bit_2 = 0
58        bit_1 = 0
59        bit_0 = 0
60
61class Lex():
62        ws        = 0
63        neg   = 0
64        pos   = 0       
65        sign  = 0
66        digit = 0
67
68class Digits():
69        starts                                  = 0
70        pos_starts                              = 0
71        neg_starts                              = 0
72        follows                                 = 0
73        expect_ws_sign_digit    = 0
74        expect_digit                    = 0
75        expect_ws_sign                  = 0
76
77def ClassifyBytes(basis_bits, lex):
78        temp1 = (basis_bits.bit_0 | basis_bits.bit_1)
79        temp2 = (basis_bits.bit_2 | basis_bits.bit_3)
80        temp3 = (temp1 | temp2)
81        temp4 = (basis_bits.bit_4 & basis_bits.bit_5)
82        temp5 = (basis_bits.bit_7 &~ basis_bits.bit_6)
83        temp6 = (temp4 & temp5)
84        temp7 = (basis_bits.bit_4 &~ basis_bits.bit_5)
85        temp8 = (basis_bits.bit_6 &~ basis_bits.bit_7)
86        temp9 = (temp7 & temp8)
87        temp10 = (temp6 | temp9)
88        temp11 = (temp7 & temp5)
89        temp12 = (temp10 | temp11)
90        temp13 = (temp12 &~ temp3)
91        temp14 = (basis_bits.bit_2 &~ basis_bits.bit_3)
92        temp15 = (temp14 &~ temp1)
93        temp16 = (basis_bits.bit_4 | basis_bits.bit_5)
94        temp17 = (basis_bits.bit_6 | basis_bits.bit_7)
95        temp18 = (temp16 | temp17)
96        temp19 = (temp15 &~ temp18)
97        lex.ws = (temp13 | temp19)
98        lex.neg = (temp15 & temp6)
99        temp20 = (basis_bits.bit_6 & basis_bits.bit_7)
100        temp21 = (temp7 & temp20)
101        lex.pos = (temp15 & temp21)
102        temp22 = (temp6 | temp21)
103        lex.sign = (temp15 & temp22)
104        temp23 = (basis_bits.bit_2 & basis_bits.bit_3)
105        temp24 = (temp23 &~ temp1)
106        temp25 = (basis_bits.bit_5 | basis_bits.bit_6)
107        temp26 = (basis_bits.bit_4 & temp25)
108        lex.digit = (temp24 &~ temp26)
109
110def MarkDigits(lex, digits):
111        ws_scope1                                       = ~pablo.Advance(~lex.ws)
112        pos_scope1                                      = pablo.Advance(lex.pos)
113        neg_scope1                                      = pablo.Advance(lex.neg)
114        digits.expect_ws_sign_digit     = pablo.inFile(ws_scope1) &~ (lex.ws | lex.sign | lex.digit)
115        digits.expect_digit                     = pablo.inFile(pos_scope1|neg_scope1) &~ lex.digit
116        digits.pos_starts                       = (ws_scope1 | pos_scope1) & lex.digit
117        digits.neg_starts                       = neg_scope1 & lex.digit
118        digits.starts                           = digits.pos_starts | digits.neg_starts                                         
119        digits.follows                          = pablo.ScanThru(digits.starts, lex.digit)
120        digits.expect_ws_sign           = pablo.inFile(digits.follows) &~ (lex.ws | lex.sign)
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()
264
265if __name__ == "__main__":
266
267        option_parser = strtoll_demo_config.get_option_parser() 
268        options, args = option_parser.parse_args(sys.argv[1:])
269
270        if len(args) != 1:
271                option_parser.print_usage()
272                sys.exit()
273        else:
274                input_file = args[0]
275
276        global data
277        global lgth
278
279        data = bitutil.readfile(input_file)
280        data = data[:-1] # -1 strip EOF
281
282        data_le                         = data[::-1] # reverse
283        s_76543210                      = bitutil.bytes_to_bstr(data_le)
284        lgth                            = len(s_76543210)
285        lgth_nybbles            = lgth/2
286        lgth_pairs                      = lgth/4
287        lgth_bits                       = lgth/8
288
289        pablo.EOF_mask = pablo.transpose_streams(data, basis) 
290
291        ClassifyBytes(basis, lex)
292        MarkDigits(lex, digits)
293
294    #
295        ### Demo
296        #       
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)
326        ### Parallel ASCII to integer conversion (aligned 8 byte ASCII values to 16 bit integer values)
327
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
342        # Step 1 - Convert nybble pairs
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)
360
361        # Step 2 - Convert byte pairs
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)
375
376        # Step 3 - Convert double-byte pairs
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 TracBrowser for help on using the repository browser.