Changeset 4016 for proto


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

Updated parallel IDISA/C++ strtoll.

Location:
proto/s2k/trunk/demo/strtoll/src
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • proto/s2k/trunk/demo/strtoll/src/Makefile

    r3611 r4016  
    44STRTOLL_SRCFILE=strtoll.cpp
    55POUTFILE=pstrtoll
    6 PSTRTOLL_SRCFILE=pstrtoll.cpp
    7 #TESTFILE0=../test/strtoll0.dat
    8 #TESTFILE1=../test/strtoll1.dat
    9 TESTFILE2=../test/strtoll2.dat
    10 #TESTFILE3=../test/strtoll3.dat
    11 #TESTFILE4=../test/strtoll4.dat
     6TESTFILE=../test/strtoll2.dat
    127
    138CC= g++ $(CFLAGS)
     
    3025        $(CC) -o $(PARALLEL_STRTOLL_OUTFILE) $(PARALLEL_STRTOLL_SRCFILE) $(INCLUDES) $(AFLAGS) -DBASIS_BITS
    3126
    32 parallel_strtoll_test: $(PARALLEL_STRTOLL_OUTFILE)     
    33         ./$(PARALLEL_STRTOLL_OUTFILE) $(TESTFILE2)
     27parallel_strtoll_demo: $(PARALLEL_STRTOLL_OUTFILE)     
     28        ./$(PARALLEL_STRTOLL_OUTFILE) $(TESTFILE)
    3429
    3530#strtoll:       $(STRTOLL_SRCFILE)
     
    4035
    4136clean:
    42         rm -Rf $(IDISA_OUTFILE) $(STRTOLL_OUTFILE) $(PSTRTOLL_OUTFILE)
     37        rm -Rf  $(STRTOLL_OUTFILE) $(PARALLEL_STRTOLL_OUTFILE)
    4338
    4439
  • proto/s2k/trunk/demo/strtoll/src/parallel_strtoll.cpp

    r3884 r4016  
    11/**
    2  * Transpose C++ demo.
     2 * Demo.
    33 *
    44 * Author:   Ken Herdy
     
    88 * Description:   
    99 *
    10  * Demonstrates parallel ascii to integer conversion (strtoll-like).
     10 * Parallel ASCII to binary integer conversion demo, strtoll-like.
     11 * Assumes LSD ASCII digit aligns to "high-end" of a 32-bit field.
     12 *
     13 * Given a 128 bit register this method
     14 * converts 4 (32-bits) ASCII integers to 16-bit values.
    1115 *
    1216 **/
     
    4448
    4549BitBlock file_extent_mask(int size);
    46 
    4750struct Basis_bits basis;
    4851
     
    5861int final_segment_size      = 0;
    5962int stream_pos              = 0;
    60 int match_index             = 0;
    6163
    6264int main(int argc, char * argv[])
     
    9597      for(block=0; block<SEGMENT_BLOCKS; block++, block_base+=BLOCK_SIZE)
    9698      {
    97         //transpose.do_block(&buffer[block_base], basis);
     99        std::cerr << "Demo. Full blocks not implemented." << std::endl;
     100                exit(1);
    98101      }
    99102
     
    114117    {
    115118      //transpose.do_block(&buffer[block_base], basis);
    116      
     119      std::cerr << "Demo. Full blocks not implemented." << std::endl;
     120      exit(1);     
     121         
    117122      block_base += BLOCK_SIZE;
    118123      bytes_avail -= BLOCK_SIZE;
     
    125130    if(bytes_avail > 0)
    126131    {
    127       BitBlock FEM_mask = file_extent_mask(bytes_avail);
    128       //transpose.do_final_block(&buffer[block_base], basis, FEM_mask);
    129 
    130                                 BytePack * bytepacks = (BytePack *) buffer;
    131 
    132                                 BitBlock source_lo_128 = bytepacks[0];
    133                                 BitBlock source_hi_128 = bytepacks[1];
    134 
    135                                 //! parallel extract (parallel gather)
    136 
    137                                 BitBlock ascii_lo_4                             = hsimd<8>::packl(source_lo_128, source_hi_128);
    138 
    139                                 // Reverse nybbles using inductive doubling and rotation,
    140                                 // i.e. rotate least significant nybble (memory) to most significant nybble (register)
    141                                 BitBlock digits_rot_4                           = simd_or(simd<8>::slli<4>(ascii_lo_4), simd<8>::srli<4>(ascii_lo_4));
    142                                 BitBlock digits_rot_8                           = simd_or(simd<16>::slli<8>(digits_rot_4), simd<16>::srli<8>(digits_rot_4));
    143                                 BitBlock digits_rot_16                          = simd_or(simd<32>::slli<16>(digits_rot_8), simd<32>::srli<16>(digits_rot_8));
    144 //                              BitBlock digits_rot_32                          = simd_or(simd<64>::slli<32>(digits_rot_16), simd<64>::srli<32>(digits_rot_16)); 
    145 
    146                                 // Parallel ASCII to integer conversion (aligned 16 byte ASCII values to 32 bit integer values)
    147                                 // Step 1 - Convert nybble pairs
    148                                 BitBlock digits_hi_4                            = simd<8>::srli<4>(digits_rot_16);
    149                                 BitBlock lomask_8                                       = simd<8>::lomask();
    150                                 BitBlock digits_lo_4                            = simd_and(digits_rot_16, lomask_8);
    151 //                              BitBlock constant_10                            = mvmd<8>::fill(10);
    152                                 BitBlock constant_10                            = simd<8>::constant<10>();
    153                                 BitBlock temp_10s                                       = simd<8>::mult(digits_hi_4, constant_10);
    154                                 BitBlock result_10s                                     = simd<8>::add(temp_10s, digits_lo_4);
    155 
    156                                 // Step 2 - Convert byte pairs
    157                                 BitBlock digits_hi_8                            = simd<16>::srli<8>(result_10s);
    158                                 BitBlock lomask_16                                      = simd<16>::lomask();
    159                                 BitBlock digits_lo_8                            = simd_and(result_10s, lomask_16);
    160 //                              BitBlock constant_100                           = mvmd<16>::fill(100);
    161                                 BitBlock constant_100                           = simd<16>::constant<100>();
    162                                 BitBlock temp_100s                                      = simd<16>::mult(digits_hi_8, constant_100);
    163                                 BitBlock result_100s                            = simd<16>::add(temp_100s, digits_lo_8);
    164 
    165                                 // Step 3 - Convert double-byte pairs
    166                                 BitBlock digits_hi_16                           = simd<32>::srli<16>(result_100s);
    167                                 BitBlock lomask_32                                      = simd<32>::lomask();
    168                                 BitBlock digits_lo_16                           = simd_and(result_100s, lomask_32);
    169 //                              BitBlock constant_10000                         = mvmd<32>::fill(10000);
    170                                 BitBlock constant_10000                         = simd<32>::constant<10000>();
    171                                 BitBlock temp_10000s                            = simd<32>::mult(digits_hi_16, constant_10000);
    172                                 BitBlock result_10000s                          = simd<32>::add(temp_10000s, digits_lo_16);
    173 
    174                                 BitBlock packed_result_10000s           = hsimd<32>::packl(result_10000s, result_10000s);
    175 
    176                                 // Step 4 - Convert quad-byte pairs // 32 bit integers
     132                BitBlock FEM_mask = file_extent_mask(bytes_avail);
     133                //transpose.do_final_block(&buffer[block_base], basis, FEM_mask);
     134
     135                // least significant digit '7' is 32-bit aligned.
     136                BytePack * bytepacks = (BytePack *) "00031987000000000000000000000000000"; // (BytePack *) buffer;
     137                BitBlock source_lo_128 = bytepacks[0];
     138                BitBlock source_hi_128 = bytepacks[1];
     139
     140                // ! parallel extract (parallel gather)
     141               
     142                BitBlock r_3210         = hsimd<8>::packl(source_hi_128, source_lo_128);
     143
     144                // Reverse nybbles using inductive doubling and rotation,
     145                // i.e. rotate least significant nybble (memory) to most significant nybble (register)
     146                BitBlock rot_4          = simd_or(simd<8>::slli<4>(r_3210), simd<8>::srli<4>(r_3210));
     147                BitBlock rot_8          = simd_or(simd<16>::slli<8>(rot_4), simd<16>::srli<8>(rot_4));
     148                BitBlock rot_16         = simd_or(simd<32>::slli<16>(rot_8), simd<32>::srli<16>(rot_8));
     149//              BitBlock rot_32         = simd_or(simd<64>::slli<32>(rot_16), simd<64>::srli<32>(rot_16)); 
     150
     151                // Parallel ASCII to binary integer conversion.
     152                // Step 1 - Convert nybble pairs
     153                BitBlock d_hi_4         = simd<8>::srli<4>(rot_16);
     154                BitBlock lomask_8       = simd<8>::lomask();
     155                BitBlock d_lo_4         = simd_and(rot_16, lomask_8);
     156                BitBlock c_10           = simd<8>::constant<10>();
     157                BitBlock t1_10          = simd<8>::mult(d_hi_4, c_10);
     158                BitBlock t2_10          = simd<8>::add(t1_10, d_lo_4);
     159
     160                // Step 2 - Convert byte pairs
     161                BitBlock d_hi_8         = simd<16>::srli<8>(t2_10);
     162                BitBlock lomask_16      = simd<16>::lomask();
     163                BitBlock d_lo_8         = simd_and(t2_10, lomask_16);
     164                BitBlock c_100          = simd<16>::constant<100>();
     165                BitBlock t1_100         = simd<16>::mult(d_hi_8, c_100);
     166                BitBlock t2_100         = simd<16>::add(t1_100, d_lo_8);
     167
     168                // Step 3 - Convert double-byte pairs
     169                BitBlock d_hi_16        = simd<32>::srli<16>(t2_100);
     170                BitBlock lomask_32      = simd<32>::lomask();
     171                BitBlock d_lo_16        = simd_and(t2_100, lomask_32);
     172                BitBlock c_10000        = simd<32>::constant<10000>();
     173                BitBlock t1_10000       = simd<32>::mult(d_hi_16, c_10000);
     174                BitBlock t2_10000       = simd<32>::add(t1_10000, d_lo_16);
     175
     176                // BitBlock rslt        = hsimd<32>::packl(t2_10000, t2_10000);
     177
     178                // Step 4 - Convert quad-byte pairs // 32 bit integers
    177179/*
    178                                 BitBlock digits_hi_32                                   = simd<64>::srli<32>(result_10000s);
    179                                 BitBlock lomask_64                                              = simd<64>::lomask();
    180                                 BitBlock digits_lo_32                                   = simd_and(result_10000s, lomask_64);
    181 //                              BitBlock constant_100000000             = mvmd<64>::fill(100000000);
    182                                 BitBlock constant_100000000             = simd<64>::constant<100000000>();
    183                                 BitBlock temp_100000000s                        = simd<64>::mult(digits_hi_32, constant_100000000);
    184                                 BitBlock result_100000000s              = simd<64>::add(temp_100000000s, digits_lo_32);
     180                BitBlock d_hi_32                        = simd<64>::srli<32>(t2_10000);
     181                BitBlock lomask_64                      = simd<64>::lomask();
     182                BitBlock d_lo_32                        = simd_and(t2_10000, lomask_64);
     183                BitBlock c_100000000            = simd<64>::constant<100000000>();
     184                BitBlock t1_100000000s          = simd<64>::mult(d_hi_32, c_100000000);
     185                BitBlock t2_100000000s          = simd<64>::add(t1_100000000s, d_lo_32);
    185186*/
    186        
    187                                 // Step 5 - 64 integers ...
    188 
    189                                 // Source
    190                                 print_register<BytePack>("source_lo_128", source_lo_128);
    191                                 print_register<BytePack>("source_hi_128", source_hi_128);
    192 
    193                                 // Packl<8>
    194                                 print_register<BytePack>("ascii_lo_4", ascii_lo_4);
    195 
    196                                 // Rotate least significant nybble (memory) to most significant nybble (register)
    197                                 print_register<BitBlock>("digits_rot_4", digits_rot_4);
    198                                 print_register<BitBlock>("digits_rot_8", digits_rot_8);
    199                                 print_register<BitBlock>("digits_rot_16", digits_rot_16);
    200 //                              print_register<BitBlock>("digits_rot_32", digits_rot_32);
    201 
    202                                 // Parallel ASCII to integer conversion (two 16 bytes values to two 32 bit values)
    203 
    204 //! Write to memory buffer, append to stream? fw, length values
    205 
    206                                 print_register<BytePack>("digits_hi_4", digits_hi_4);
    207                                 print_register<BytePack>("digits_lo_4", digits_lo_4);
    208                                 print_register<BytePack>("result_10s", result_10s);
    209                                 print_register<BytePack>("result_100s", result_100s);
    210                                 print_register<BytePack>("result_10000s", result_10000s);
    211 //                      print_register<BytePack>("result_100000000s", result_100000000s);
    212 
    213                                 print_register<BytePack>("packed_result_10000s", packed_result_10000s);
     187                // Step 5 - 64 integers ...
     188
     189                // Source
     190                print_register<BytePack>("source_lo_128", source_lo_128);
     191                print_register<BytePack>("source_hi_128", source_hi_128);
     192
     193                // Packl<8>
     194                print_register<BytePack>("r_3210", r_3210);
     195
     196                // Rotate least significant nybble (memory) to most significant nybble (register)
     197                print_register<BitBlock>("rot_4", rot_4);
     198                print_register<BitBlock>("rot_8", rot_8);
     199                print_register<BitBlock>("rot_16", rot_16);
     200//              print_register<BitBlock>("rot_32", rot_32);
     201
     202                //! Write out to memory, results reside in the low 16 bits of each 32-bit field.
     203
     204                print_register<BytePack>("d_hi_4", d_hi_4);
     205                print_register<BytePack>("d_lo_4", d_lo_4);
     206                print_register<BytePack>("t2_10", t2_10);
     207                print_register<BytePack>("t2_100", t2_100);
     208                print_register<BytePack>("t2_10000", t2_10000);
     209//              print_register<BytePack>("t2_100000000s", t2_100000000s);
    214210
    215211    }
Note: See TracChangeset for help on using the changeset viewer.