source: proto/s2k/trunk/demo/transpose/transpose.cpp @ 4092

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

Updated s2k demo.

File size: 11.3 KB
Line 
1/**
2 * Transpose C++ demo.
3 *
4 * Author:   Ken Herdy
5 *
6 * Usage:    transpose <infilename> [outfilename]
7 *
8 * Description:   
9 *
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.
22 *
23 **/
24
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
38#include <simd-lib/bitblock.hpp>
39#include <simd-lib/carryQ.hpp>
40#include <simd-lib/pabloSupport.hpp>
41#include <simd-lib/s2p.hpp>
42#include <simd-lib/buffer.hpp>
43#include <simd-lib/bitblock_iterator.hpp>
44
45// mmap system
46#include <sys/mman.h>
47#include <fcntl.h>
48
49#include <simd-lib/transpose.hpp>
50using namespace std;
51
52#define LE
53#define BE
54#define LE_S2K
55
56#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) \
57  do {\
58        BitBlock r_7654_3,r_7654_2,r_7654_1,r_7654_0;\
59  BitBlock r_3210_3,r_3210_2,r_3210_1,r_3210_0;\
60  BitBlock r_76_1,r_76_0,r_54_1,r_54_0;\
61        BitBlock r_32_1,r_32_0,r_10_1,r_10_0;\
62  r_7654_3 = hsimd<8>::packh(s_7, s_6);\
63        r_7654_2 = hsimd<8>::packh(s_5, s_4);\
64        r_7654_1 = hsimd<8>::packh(s_3, s_2);\
65        r_7654_0 = hsimd<8>::packh(s_1, s_0);\
66        r_3210_3 = hsimd<8>::packl(s_7, s_6);\
67        r_3210_2 = hsimd<8>::packl(s_5, s_4);\
68        r_3210_1 = hsimd<8>::packl(s_3, s_2);\
69        r_3210_0 = hsimd<8>::packl(s_1, s_0);\
70  r_76_1 = hsimd<4>::packh(r_7654_3, r_7654_2);\
71  r_76_0 = hsimd<4>::packh(r_7654_1, r_7654_0);\
72        r_54_1 = hsimd<4>::packl(r_7654_3, r_7654_2);\
73        r_54_0 = hsimd<4>::packl(r_7654_1, r_7654_0);\
74        r_32_1 = hsimd<4>::packh(r_3210_3, r_3210_2);\
75        r_32_0 = hsimd<4>::packh(r_3210_1, r_3210_0);\
76        r_10_1 = hsimd<4>::packl(r_3210_3, r_3210_2);\
77        r_10_0 = hsimd<4>::packl(r_3210_1, r_3210_0);\
78        r_7 = hsimd<2>::packh(r_76_1, r_76_0);\
79        r_6 = hsimd<2>::packl(r_76_1, r_76_0);\
80        r_5 = hsimd<2>::packh(r_54_1, r_54_0);\
81        r_4 = hsimd<2>::packl(r_54_1, r_54_0);\
82        r_3 = hsimd<2>::packh(r_32_1, r_32_0);\
83        r_2 = hsimd<2>::packl(r_32_1, r_32_0);\
84        r_1 = hsimd<2>::packh(r_10_1, r_10_0);\
85        r_0 = hsimd<2>::packl(r_10_1, r_10_0);\
86  } while(0)
87
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
127static void s2p_be(BytePack b76543210_7, BytePack b76543210_6, BytePack b76543210_5, BytePack b76543210_4, 
128                      BytePack b76543210_3, BytePack b76543210_2, BytePack b76543210_1, BytePack b76543210_0, 
129                      BitBlock & b0, BitBlock & b1, BitBlock & b2, BitBlock & b3, 
130                      BitBlock & b4, BitBlock & b5, BitBlock & b6, BitBlock & b7) 
131{
132        BitBlock b7654_0, b7654_1, b7654_2, b7654_3;
133        BitBlock b3210_0, b3210_1, b3210_2, b3210_3;
134        BitBlock b76_0, b76_1, b54_0, b54_1;
135        BitBlock b32_0, b32_1, b10_0, b10_1;
136
137        b7654_3 = hsimd<8>::packh(b76543210_7, b76543210_6);
138        b7654_2 = hsimd<8>::packh(b76543210_5, b76543210_4);
139        b7654_1 = hsimd<8>::packh(b76543210_3, b76543210_2);
140        b7654_0 = hsimd<8>::packh(b76543210_1, b76543210_0);
141        b3210_3 = hsimd<8>::packl(b76543210_7, b76543210_6);
142        b3210_2 = hsimd<8>::packl(b76543210_5, b76543210_4);
143        b3210_1 = hsimd<8>::packl(b76543210_3, b76543210_2);
144        b3210_0 = hsimd<8>::packl(b76543210_1, b76543210_0);
145
146        b76_1 = hsimd<4>::packh(b7654_3, b7654_2);
147        b76_0 = hsimd<4>::packh(b7654_1, b7654_0);
148        b54_1 = hsimd<4>::packl(b7654_3, b7654_2);
149        b54_0 = hsimd<4>::packl(b7654_1, b7654_0);
150        b32_1 = hsimd<4>::packh(b3210_3, b3210_2);
151        b32_0 = hsimd<4>::packh(b3210_1, b3210_0);
152        b10_1 = hsimd<4>::packl(b3210_3, b3210_2);
153        b10_0 = hsimd<4>::packl(b3210_1, b3210_0);
154
155        b0 = hsimd<2>::packh(b76_1, b76_0);
156        b1 = hsimd<2>::packl(b76_1, b76_0);
157        b2 = hsimd<2>::packh(b54_1, b54_0);
158        b3 = hsimd<2>::packl(b54_1, b54_0);
159        b4 = hsimd<2>::packh(b32_1, b32_0);
160        b5 = hsimd<2>::packl(b32_1, b32_0);
161        b6 = hsimd<2>::packh(b10_1, b10_0);
162        b7 = hsimd<2>::packl(b10_1, b10_0);
163}
164
165BitBlock eof_mask(int size);
166void do_process(char *, size_t, FILE *);
167
168int main(int argc, char *argv[])
169{
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
253    int k = 0;
254    int bytes_avail = infile_size;
255
256//////////////////////////////////////////////////////////////////////////////////////////
257// Full Blocks.
258//////////////////////////////////////////////////////////////////////////////////////////
259
260    while (bytes_avail >= BLOCK_SIZE) 
261    {
262      Byte = (BytePack *) &infile_buffer[k];
263
264      #ifdef BE         
265      s2p_be(Byte[7], Byte[6], Byte[5], Byte[4], 
266             Byte[3], Byte[2], Byte[1], Byte[0],
267             b7, b6, b5, b4, 
268             b3, b2, b1, b0);
269
270      printf("\n");
271      print_register<BitBlock>("b7", b7);
272      print_register<BitBlock>("b6", b6);
273      print_register<BitBlock>("b5", b5);
274      print_register<BitBlock>("b4", b4);
275      print_register<BitBlock>("b3", b3);
276      print_register<BitBlock>("b2", b2);
277      print_register<BitBlock>("b1", b1);
278      print_register<BitBlock>("b0", b0);
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");
287      print_register<BitBlock>("b7", b7);
288      print_register<BitBlock>("b6", b6);
289      print_register<BitBlock>("b5", b5);
290      print_register<BitBlock>("b4", b4);
291      print_register<BitBlock>("b3", b3);
292      print_register<BitBlock>("b2", b2);
293      print_register<BitBlock>("b1", b1);
294      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    {
306     
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");
328      print_register<BitBlock>("b7", b7);
329      print_register<BitBlock>("b6", b6);
330      print_register<BitBlock>("b5", b5);
331      print_register<BitBlock>("b4", b4);
332      print_register<BitBlock>("b3", b3);
333      print_register<BitBlock>("b2", b2);
334      print_register<BitBlock>("b1", b1);
335      print_register<BitBlock>("b0", b0);
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 TracBrowser for help on using the repository browser.