Changeset 4092


Ignore:
Timestamp:
Aug 28, 2014, 7:25:22 PM (4 years ago)
Author:
ksherdy
Message:

Updated s2k demo.

Location:
proto/s2k/trunk/demo/transpose
Files:
3 added
1 edited

Legend:

Unmodified
Added
Removed
  • proto/s2k/trunk/demo/transpose/transpose.cpp

    r3747 r4092  
    44 * Author:   Ken Herdy
    55 *
    6  * Usage:    transpose <filename>
     6 * Usage:    transpose <infilename> [outfilename]
    77 *
    88 * Description:   
    99 *
    10  * Demonstrates both little endian bit order and big endian bit order s2p.
     10 * Demonstrates little endian and big endian bit order transposition.
     11 *
     12 * A test bed for s2k block-by-block compilation strategies.
     13 *
     14 * 8 * 128 = 1024 bits => 8 parallel 128 bit registers
     15 * 8 consecutive registers of 128 bits s2p_les to 8 parallel registers of 128 bits.
     16 *
     17 * 8 * 16  = 128 bytes => 8 parallel 16 byte registers
     18 * 8 consecutive registers of 16 bytes s2p_les to 8 parallel registers of 16 bytes.
     19 *
     20 * A segment-at-a-time processing strategy is not
     21 * required for the transposition.
    1122 *
    1223 **/
    1324
    14 /**
    15  * Platform independent runtime support libraries and C++ libraries.
    16  **/
     25#include <fstream>
     26#include <sstream>
     27#include <iostream>
     28#include <string>
     29#include <stdint.h>
     30
     31#include <stdio.h>
     32#include <stdlib.h>
     33#include <unistd.h>
     34#include <errno.h>
     35#include <sys/types.h>
     36#include <sys/stat.h>
     37
    1738#include <simd-lib/bitblock.hpp>
    1839#include <simd-lib/carryQ.hpp>
    1940#include <simd-lib/pabloSupport.hpp>
     41#include <simd-lib/s2p.hpp>
     42#include <simd-lib/buffer.hpp>
    2043#include <simd-lib/bitblock_iterator.hpp>
     44
     45// mmap system
     46#include <sys/mman.h>
     47#include <fcntl.h>
     48
    2149#include <simd-lib/transpose.hpp>
    22 #include <stdio.h>
    23 #include <stdlib.h>
    24 /*
    25 
    26 A quick demo to demonstrate s2p_le.
    27 
    28 8 * 128 = 1024 bits => 8 parallel 128 bit registers
    29 8 consecutive registers of 128 bits s2p_les to 8 parallel registers of 128 bits.
    30 
    31 8 * 16  = 128 bytes => 8 parallel 16 byte registers
    32 8 consecutive registers of 16 bytes s2p_les to 8 parallel registers of 16 bytes.
    33 
    34 BLOCK_SIZE
    35 
    36 The size of a register (block) expressed
    37 in terms of bits used in the s2k compiler
    38 register-at-a-time processing model.
    39 
    40 A segment-at-a-time processing model is not
    41 required for the transposition example and intentionally
    42 is not shown for clarity.
    43 
    44 */
    45 
    46 typedef __m128i BitBlock;
    47 typedef BitBlock BytePack;
    48 
    49 BitBlock file_extent_mask(int size) {
    50   return bitblock::srl(simd<1>::constant<1>(), convert(BLOCK_SIZE-size));
    51 }
    52 
    53 /*
    54 
    55 Describe hsimd<8>::packh(a,b), draw a picture.
    56 
    57 Using IDISA, it is possible to design a transposition
    58 algorithm in terms of IDISA horizontal binary operations.
    59 
    60 IDISA horizontal binary operations are of the form
    61 t = hsimd<fw>::op$_fw$(a, b), where fw is
    62 the field width, a and b are input registers,
    63 and t is the result register.
    64 
    65 */
    66 
    67 static void s2p_le(BytePack b76543210_7, BytePack b76543210_6, BytePack b76543210_5, BytePack b76543210_4,
    68                       BytePack b76543210_3, BytePack b76543210_2, BytePack b76543210_1, BytePack b76543210_0,
    69                       BitBlock & b0, BitBlock & b1, BitBlock & b2, BitBlock & b3,
    70                       BitBlock & b4, BitBlock & b5, BitBlock & b6, BitBlock & b7)
    71 {
    72         BitBlock b7654_0, b7654_1, b7654_2, b7654_3;
    73         BitBlock b3210_0, b3210_1, b3210_2, b3210_3;
    74         BitBlock b76_0, b76_1, b54_0, b54_1;
    75         BitBlock b32_0, b32_1, b10_0, b10_1;
    76 
    77         b7654_3 = hsimd<8>::packh(b76543210_7, b76543210_6);
    78         b7654_2 = hsimd<8>::packh(b76543210_5, b76543210_4);
    79         b7654_1 = hsimd<8>::packh(b76543210_3, b76543210_2);
    80         b7654_0 = hsimd<8>::packh(b76543210_1, b76543210_0);
    81         b3210_3 = hsimd<8>::packl(b76543210_7, b76543210_6);
    82         b3210_2 = hsimd<8>::packl(b76543210_5, b76543210_4);
    83         b3210_1 = hsimd<8>::packl(b76543210_3, b76543210_2);
    84         b3210_0 = hsimd<8>::packl(b76543210_1, b76543210_0);
    85 
    86         b76_1 = hsimd<4>::packh(b7654_3, b7654_2);
    87         b76_0 = hsimd<4>::packh(b7654_1, b7654_0);
    88         b54_1 = hsimd<4>::packl(b7654_3, b7654_2);
    89         b54_0 = hsimd<4>::packl(b7654_1, b7654_0);
    90         b32_1 = hsimd<4>::packh(b3210_3, b3210_2);
    91         b32_0 = hsimd<4>::packh(b3210_1, b3210_0);
    92         b10_1 = hsimd<4>::packl(b3210_3, b3210_2);
    93         b10_0 = hsimd<4>::packl(b3210_1, b3210_0);
    94 
    95         b7 = hsimd<2>::packh(b76_1, b76_0);
    96         b6 = hsimd<2>::packl(b76_1, b76_0);
    97         b5 = hsimd<2>::packh(b54_1, b54_0);
    98         b4 = hsimd<2>::packl(b54_1, b54_0);
    99         b3 = hsimd<2>::packh(b32_1, b32_0);
    100         b2 = hsimd<2>::packl(b32_1, b32_0);
    101         b1 = hsimd<2>::packh(b10_1, b10_0);
    102         b0 = hsimd<2>::packl(b10_1, b10_0);
    103 }
     50using namespace std;
     51
     52#define LE
     53#define BE
     54#define LE_S2K
    10455
    10556#define s2p_ideal_le(s_7, s_6, s_5, s_4, s_3, s_2, s_1, s_0, r_0, r_1, r_2, r_3, r_4, r_5, r_6, r_7) \
     
    13586  } while(0)
    13687
     88static void s2p_le(BytePack b76543210_7, BytePack b76543210_6, BytePack b76543210_5, BytePack b76543210_4,
     89                      BytePack b76543210_3, BytePack b76543210_2, BytePack b76543210_1, BytePack b76543210_0,
     90                      BitBlock & b0, BitBlock & b1, BitBlock & b2, BitBlock & b3,
     91                      BitBlock & b4, BitBlock & b5, BitBlock & b6, BitBlock & b7)
     92{
     93        BitBlock b7654_0, b7654_1, b7654_2, b7654_3;
     94        BitBlock b3210_0, b3210_1, b3210_2, b3210_3;
     95        BitBlock b76_0, b76_1, b54_0, b54_1;
     96        BitBlock b32_0, b32_1, b10_0, b10_1;
     97
     98        b7654_3 = hsimd<8>::packh(b76543210_7, b76543210_6);
     99        b7654_2 = hsimd<8>::packh(b76543210_5, b76543210_4);
     100        b7654_1 = hsimd<8>::packh(b76543210_3, b76543210_2);
     101        b7654_0 = hsimd<8>::packh(b76543210_1, b76543210_0);
     102        b3210_3 = hsimd<8>::packl(b76543210_7, b76543210_6);
     103        b3210_2 = hsimd<8>::packl(b76543210_5, b76543210_4);
     104        b3210_1 = hsimd<8>::packl(b76543210_3, b76543210_2);
     105        b3210_0 = hsimd<8>::packl(b76543210_1, b76543210_0);
     106
     107        b76_1 = hsimd<4>::packh(b7654_3, b7654_2);
     108        b76_0 = hsimd<4>::packh(b7654_1, b7654_0);
     109        b54_1 = hsimd<4>::packl(b7654_3, b7654_2);
     110        b54_0 = hsimd<4>::packl(b7654_1, b7654_0);
     111        b32_1 = hsimd<4>::packh(b3210_3, b3210_2);
     112        b32_0 = hsimd<4>::packh(b3210_1, b3210_0);
     113        b10_1 = hsimd<4>::packl(b3210_3, b3210_2);
     114        b10_0 = hsimd<4>::packl(b3210_1, b3210_0);
     115
     116        b7 = hsimd<2>::packh(b76_1, b76_0);
     117        b6 = hsimd<2>::packl(b76_1, b76_0);
     118        b5 = hsimd<2>::packh(b54_1, b54_0);
     119        b4 = hsimd<2>::packl(b54_1, b54_0);
     120        b3 = hsimd<2>::packh(b32_1, b32_0);
     121        b2 = hsimd<2>::packl(b32_1, b32_0);
     122        b1 = hsimd<2>::packh(b10_1, b10_0);
     123        b0 = hsimd<2>::packl(b10_1, b10_0);
     124}
     125
     126
    137127static void s2p_be(BytePack b76543210_7, BytePack b76543210_6, BytePack b76543210_5, BytePack b76543210_4,
    138128                      BytePack b76543210_3, BytePack b76543210_2, BytePack b76543210_1, BytePack b76543210_0,
     
    173163}
    174164
    175 #define BLOCK_SIZE           128
    176 #define BUFFER_BLOCKS        10
    177 #define BUFFER_SIZE          (BLOCK_SIZE * BUFFER_BLOCKS)
    178 
    179 int main( void )
     165BitBlock eof_mask(int size);
     166void do_process(char *, size_t, FILE *);
     167
     168int main(int argc, char *argv[])
    180169{
    181 
    182   BytePack * Byte;
    183   BitBlock b7, b6, b5, b4;
    184   BitBlock b3, b2, b1, b0;
    185 
    186   BitBlock aligned_buffer[BUFFER_SIZE/sizeof(BitBlock)];
    187   char * buffer = (char *) aligned_buffer;
    188 
    189   FILE * istream;
    190   if((istream = fopen( "test/transpose.dat", "r" )) == NULL ) { exit( 1 ); }
    191 
    192   while(!feof(istream))
    193   {
    194     int bytes_ead = fread(buffer, 1, BUFFER_SIZE, istream );
    195     int bytes_avail = bytes_ead;
     170    char * infilename, * outfilename;
     171    FILE *infile, *outfile;
     172
     173    int fdSrc;
     174    struct stat infile_sb;
     175    char * infile_buffer;
     176   
     177    int opt_code;
     178    while ((opt_code = getopt(argc, argv, "h")) != -1)
     179    {
     180        switch (opt_code)
     181        {
     182        case 'h': /* help */
     183        default:
     184            printf ("Invalid option: %c\n", opt_code);
     185            printf("Usage: %s [-?] <inputfile> [<outputfile>]\n", argv[0]);
     186            exit(-1);
     187        }
     188    }
     189
     190    if (optind >= argc)
     191    {
     192        printf ("Too few arguments\n");
     193        printf("Usage: %s [-?] <inputfile> [<outputfile>]\n", argv[0]);
     194        exit(-1);
     195    }
     196
     197    infilename = argv[optind++];
     198    fdSrc = open(infilename, O_RDONLY);
     199    if (fdSrc == -1) {
     200        fprintf(stderr, "Error: cannot open %s for processing.\n", infilename);
     201        exit(-1);
     202    }
     203    if (fstat(fdSrc, &infile_sb) == -1) {
     204        fprintf(stderr, "Error: cannot stat %s for processing.\n", infilename);
     205        exit(-1);
     206    }
     207    if (infile_sb.st_size == 0) {
     208        exit(0);
     209    }
     210    infile_buffer = (char *) mmap(NULL, infile_sb.st_size, PROT_READ, MAP_PRIVATE, fdSrc, 0);
     211    if (infile_buffer == MAP_FAILED) {
     212        fprintf(stderr, "Error: mmap of %s failure.\n", infilename);
     213        exit(-1);
     214    }
     215
     216    if (optind >= argc) outfile = stdout;
     217    else
     218    {
     219        outfilename = argv[optind++];
     220        if (optind != argc)
     221        {
     222                printf ("Too few arguments\n");
     223                printf("Usage: %s [-?] <inputfile> [<outputfile>]\n", argv[0]);
     224                exit(-1);
     225        }
     226        outfile = fopen(outfilename, "wb");
     227        if (!outfile)
     228        {
     229            fprintf(stderr, "Error: cannot open %s for writing.\n", outfilename);
     230            exit(-1);
     231        }
     232    }
     233
     234    do_process(infile_buffer, infile_sb.st_size, outfile);
     235
     236    close(fdSrc);
     237    fclose(outfile);
     238
     239    return 0;
     240}
     241
     242BitBlock eof_mask(int size) {
     243  return bitblock::srl(simd<1>::constant<1>(), convert(BLOCK_SIZE-size));
     244}
     245
     246void do_process(char * infile_buffer, size_t infile_size, FILE *outfile) {
     247
     248    BytePack * Byte;
     249    BitBlock b7, b6, b5, b4;
     250    BitBlock b3, b2, b1, b0;
     251
     252
    196253    int k = 0;
    197 
    198     if (feof(istream)) { bytes_avail--; }
    199 
    200     /* Process full registers */
     254    int bytes_avail = infile_size;
     255
     256//////////////////////////////////////////////////////////////////////////////////////////
     257// Full Blocks.
     258//////////////////////////////////////////////////////////////////////////////////////////
     259
    201260    while (bytes_avail >= BLOCK_SIZE)
    202261    {
    203       Byte = (BytePack *) &buffer[k];
    204 
     262      Byte = (BytePack *) &infile_buffer[k];
     263
     264      #ifdef BE         
    205265      s2p_be(Byte[7], Byte[6], Byte[5], Byte[4],
    206266             Byte[3], Byte[2], Byte[1], Byte[0],
     
    208268             b3, b2, b1, b0);
    209269
     270      printf("\n");
    210271      print_register<BitBlock>("b7", b7);
    211272      print_register<BitBlock>("b6", b6);
     
    216277      print_register<BitBlock>("b1", b1);
    217278      print_register<BitBlock>("b0", b0);
    218 
    219       k += BLOCK_SIZE;
    220       bytes_avail -= BLOCK_SIZE;
    221     }
    222 
    223     /* Process final block */
    224     if(bytes_avail > 0)
    225     {
    226      
    227       Byte = (BytePack *) &buffer[k];
    228 
    229       s2p_be(Byte[7], Byte[6], Byte[5], Byte[4],
    230              Byte[3], Byte[2], Byte[1], Byte[0],
    231              b7, b6, b5, b4,
    232              b3, b2, b1, b0);
    233 
    234       BitBlock FE_mask = file_extent_mask(bytes_avail);
    235 
    236       b7 = simd_and(b7, FE_mask);
    237       b6 = simd_and(b6, FE_mask);
    238       b5 = simd_and(b5, FE_mask);
    239       b4 = simd_and(b4, FE_mask);
    240       b3 = simd_and(b3, FE_mask);
    241       b2 = simd_and(b2, FE_mask);
    242       b1 = simd_and(b1, FE_mask);
    243       b0 = simd_and(b0, FE_mask);
    244 
     279      #endif
     280
     281      #ifdef LE
     282      s2p(Byte[0], Byte[1], Byte[2], Byte[3],
     283          Byte[4], Byte[5], Byte[6], Byte[7],
     284                  b0, b1, b2, b3, b4, b5, b6, b7);
     285
     286      printf("\n");
    245287      print_register<BitBlock>("b7", b7);
    246288      print_register<BitBlock>("b6", b6);
     
    251293      print_register<BitBlock>("b1", b1);
    252294      print_register<BitBlock>("b0", b0);
     295      #endif
     296
     297      k += BLOCK_SIZE;
     298      bytes_avail -= BLOCK_SIZE;
     299    }
     300
     301//////////////////////////////////////////////////////////////////////////////////////////
     302// Final Partial Block.
     303//////////////////////////////////////////////////////////////////////////////////////////
     304    if(bytes_avail > 0)
     305    {
    253306     
    254                 s2p(Byte[0], Byte[1], Byte[2], Byte[3], Byte[4], Byte[5], Byte[6], Byte[7],
    255                   b0, b1, b2, b3, b4, b5, b6, b7);
    256 
    257       b7 = simd_and(b7, FE_mask);
    258       b6 = simd_and(b6, FE_mask);
    259       b5 = simd_and(b5, FE_mask);
    260       b4 = simd_and(b4, FE_mask);
    261       b3 = simd_and(b3, FE_mask);
    262       b2 = simd_and(b2, FE_mask);
    263       b1 = simd_and(b1, FE_mask);
    264       b0 = simd_and(b0, FE_mask);
    265 
    266                         printf("\n");
     307      Byte = (BytePack *) &infile_buffer[k];
     308      BitBlock EOF_mask = eof_mask(bytes_avail);
     309
     310      #ifdef BE       
     311      s2p_be(Byte[7], Byte[6], Byte[5], Byte[4],
     312             Byte[3], Byte[2], Byte[1], Byte[0],
     313             b7, b6, b5, b4,
     314             b3, b2, b1, b0);
     315
     316
     317
     318      b7 = simd_and(b7, EOF_mask);
     319      b6 = simd_and(b6, EOF_mask);
     320      b5 = simd_and(b5, EOF_mask);
     321      b4 = simd_and(b4, EOF_mask);
     322      b3 = simd_and(b3, EOF_mask);
     323      b2 = simd_and(b2, EOF_mask);
     324      b1 = simd_and(b1, EOF_mask);
     325      b0 = simd_and(b0, EOF_mask);
     326
     327      printf("\n");
    267328      print_register<BitBlock>("b7", b7);
    268329      print_register<BitBlock>("b6", b6);
     
    273334      print_register<BitBlock>("b1", b1);
    274335      print_register<BitBlock>("b0", b0);
    275 
    276     }
    277   }
    278 
    279   fclose(istream);
    280 
    281         printf("afa");
    282 
    283   return 0;
    284 }
     336      #endif
     337
     338      #ifdef LE
     339          s2p(Byte[0], Byte[1], Byte[2], Byte[3],
     340          Byte[4], Byte[5], Byte[6], Byte[7],
     341                  b0, b1, b2, b3,
     342          b4, b5, b6, b7);
     343
     344      b7 = simd_and(b7, EOF_mask);
     345      b6 = simd_and(b6, EOF_mask);
     346      b5 = simd_and(b5, EOF_mask);
     347      b4 = simd_and(b4, EOF_mask);
     348      b3 = simd_and(b3, EOF_mask);
     349      b2 = simd_and(b2, EOF_mask);
     350      b1 = simd_and(b1, EOF_mask);
     351      b0 = simd_and(b0, EOF_mask);
     352
     353      printf("\n");
     354      print_register<BitBlock>("b7", b7);
     355      print_register<BitBlock>("b6", b6);
     356      print_register<BitBlock>("b5", b5);
     357      print_register<BitBlock>("b4", b4);
     358      print_register<BitBlock>("b3", b3);
     359      print_register<BitBlock>("b2", b2);
     360      print_register<BitBlock>("b1", b1);
     361      print_register<BitBlock>("b0", b0);
     362      #endif
     363
     364    }
     365
     366}
     367
     368
     369
Note: See TracChangeset for help on using the changeset viewer.