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

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

Steady-state s2k code generation for 8-4-2-1 reductions.

File size: 12.4 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 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_be(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
126static void s2p_le(BytePack b76543210_7, BytePack b76543210_6, BytePack b76543210_5, BytePack b76543210_4,
127                      BytePack b76543210_3, BytePack b76543210_2, BytePack b76543210_1, BytePack b76543210_0, 
128                      BitBlock & b7, BitBlock & b6, BitBlock & b5, BitBlock & b4,
129                      BitBlock & b3, BitBlock & b2, BitBlock & b1, BitBlock & b0)
130{
131        BitBlock b7654_0, b7654_1, b7654_2, b7654_3;
132        BitBlock b3210_0, b3210_1, b3210_2, b3210_3;
133        BitBlock b76_0, b76_1, b54_0, b54_1;
134        BitBlock b32_0, b32_1, b10_0, b10_1;
135
136        b7654_3 = hsimd<8>::packh(b76543210_7, b76543210_6);
137        b7654_2 = hsimd<8>::packh(b76543210_5, b76543210_4);
138        b7654_1 = hsimd<8>::packh(b76543210_3, b76543210_2);
139        b7654_0 = hsimd<8>::packh(b76543210_1, b76543210_0);
140        b3210_3 = hsimd<8>::packl(b76543210_7, b76543210_6);
141        b3210_2 = hsimd<8>::packl(b76543210_5, b76543210_4);
142        b3210_1 = hsimd<8>::packl(b76543210_3, b76543210_2);
143        b3210_0 = hsimd<8>::packl(b76543210_1, b76543210_0);
144
145        b76_1 = hsimd<4>::packh(b7654_3, b7654_2);
146        b76_0 = hsimd<4>::packh(b7654_1, b7654_0);
147        b54_1 = hsimd<4>::packl(b7654_3, b7654_2);
148        b54_0 = hsimd<4>::packl(b7654_1, b7654_0);
149        b32_1 = hsimd<4>::packh(b3210_3, b3210_2);
150        b32_0 = hsimd<4>::packh(b3210_1, b3210_0);
151        b10_1 = hsimd<4>::packl(b3210_3, b3210_2);
152        b10_0 = hsimd<4>::packl(b3210_1, b3210_0);
153
154    b7 = hsimd<2>::packh(b76_1, b76_0);
155    b6 = hsimd<2>::packl(b76_1, b76_0);
156    b5 = hsimd<2>::packh(b54_1, b54_0);
157    b4 = hsimd<2>::packl(b54_1, b54_0);
158    b3 = hsimd<2>::packh(b32_1, b32_0);
159    b2 = hsimd<2>::packl(b32_1, b32_0);
160    b1 = hsimd<2>::packh(b10_1, b10_0);
161    b0 = hsimd<2>::packl(b10_1, b10_0);
162}
163
164BitBlock eof_mask(int size);
165void do_process(char *, size_t, FILE *);
166
167int main(int argc, char *argv[])
168{
169    char * infilename, * outfilename;
170    FILE *infile, *outfile;
171
172    int fdSrc;
173    struct stat infile_sb;
174    char * infile_buffer;
175   
176    int opt_code;
177    while ((opt_code = getopt(argc, argv, "h")) != -1)
178    {
179        switch (opt_code)
180        {
181        case 'h': /* help */
182        default:
183            printf ("Invalid option: %c\n", opt_code);
184            printf("Usage: %s [-?] <inputfile> [<outputfile>]\n", argv[0]);
185            exit(-1);
186        }
187    }
188
189    if (optind >= argc)
190    {
191        printf ("Too few arguments\n");
192        printf("Usage: %s [-?] <inputfile> [<outputfile>]\n", argv[0]);
193        exit(-1);
194    }
195
196    infilename = argv[optind++];
197    fdSrc = open(infilename, O_RDONLY);
198    if (fdSrc == -1) {
199        fprintf(stderr, "Error: cannot open %s for processing.\n", infilename);
200        exit(-1);
201    }
202    if (fstat(fdSrc, &infile_sb) == -1) {
203        fprintf(stderr, "Error: cannot stat %s for processing.\n", infilename);
204        exit(-1);
205    }
206    if (infile_sb.st_size == 0) {
207        exit(0);
208    }
209    infile_buffer = (char *) mmap(NULL, infile_sb.st_size, PROT_READ, MAP_PRIVATE, fdSrc, 0);
210    if (infile_buffer == MAP_FAILED) {
211        fprintf(stderr, "Error: mmap of %s failure.\n", infilename);
212        exit(-1);
213    }
214
215    if (optind >= argc) outfile = stdout;
216    else
217    {
218        outfilename = argv[optind++];
219        if (optind != argc)
220        {
221                printf ("Too few arguments\n");
222                printf("Usage: %s [-?] <inputfile> [<outputfile>]\n", argv[0]);
223                exit(-1);
224        }
225        outfile = fopen(outfilename, "wb");
226        if (!outfile)
227        {
228            fprintf(stderr, "Error: cannot open %s for writing.\n", outfilename);
229            exit(-1);
230        }
231    }
232
233    do_process(infile_buffer, infile_sb.st_size, outfile);
234
235    close(fdSrc);
236    fclose(outfile);
237
238    return 0;
239}
240
241BitBlock eof_mask(int size) {
242  return bitblock::srl(simd<1>::constant<1>(), convert(BLOCK_SIZE-size));
243}
244
245void do_process(char * infile_buffer, size_t infile_size, FILE *outfile) {
246
247    BytePack * Byte;
248    BitBlock b7, b6, b5, b4;
249    BitBlock b3, b2, b1, b0;
250
251    int k = 0;
252    int bytes_avail = infile_size;
253
254
255//////////////////////////////////////////////////////////////////////////////////////////
256// Full Blocks.
257//////////////////////////////////////////////////////////////////////////////////////////
258
259
260    while (bytes_avail >= BLOCK_SIZE)
261    {
262{
263        BitBlock b76543210 [8];
264        memcpy(&b76543210, &infile_buffer[k], BLOCK_SIZE);
265
266        BitBlock b7654 [4];
267        BitBlock b3210 [4];
268        BitBlock b76 [2];
269        BitBlock b54 [2];
270        BitBlock b32 [2];
271        BitBlock b10 [2];
272
273        BitBlock b7[1];
274        BitBlock b6[1];
275        BitBlock b5[1];
276        BitBlock b4[1];
277        BitBlock b3[1];
278        BitBlock b2[1];
279        BitBlock b1[1];
280        BitBlock b0[1];
281
282        for(int i=0; i<8/2; i++) {
283            b7654[i] = hsimd<8>::packh(b76543210[i+i+1], b76543210[i+i]);
284        }
285
286        for(int i=0; i<8/2; i++) {
287            b3210[i] = hsimd<8>::packl(b76543210[i+i+1], b76543210[i+i]);
288        }
289
290        for(int i=0; i<4/2; i++) {
291            b76[i] = hsimd<4>::packh(b7654[i+i+1], b7654[i+i]);
292        }
293
294        for(int i=0; i<4/2; i++) {
295            b54[i] = hsimd<4>::packl(b7654[i+i+1], b7654[i+i]);
296        }
297
298        for(int i=0; i<4/2; i++) {
299            b32[i] = hsimd<4>::packh(b3210[i+i+1], b3210[i+i]);
300        }
301
302        for(int i=0; i<4/2; i++) {
303            b10[i] = hsimd<4>::packl(b3210[i+i+1], b3210[i+i]);
304        }
305
306        for(int i=0; i<2/2; i++) {
307            b7[0] = hsimd<2>::packh(b76[i+i+1], b76[i+i]);
308        }
309
310        for(int i=0; i<2/2; i++) {
311            b6[0] = hsimd<2>::packl(b76[i+i+1], b76[i+i]);
312        }
313
314        for(int i=0; i<2/2; i++) {
315            b5[0] = hsimd<2>::packh(b54[i+i+1], b54[i+i]);
316        }
317
318        for(int i=0; i<2/2; i++) {
319            b4[0] = hsimd<2>::packl(b54[i+i+1], b54[i+i]);
320        }
321
322        for(int i=0; i<2/2; i++) {
323            b3[0] = hsimd<2>::packh(b32[i+i+1], b32[i+i]);
324        }
325
326        for(int i=0; i<2/2; i++) {
327            b2[0] = hsimd<2>::packl(b32[i+i+1], b32[i+i]);
328        }
329
330        for(int i=0; i<2/2; i++) {
331            b1[0] = hsimd<2>::packh(b10[i+i+1], b10[i+i]);
332        }
333
334        for(int i=0; i<2/2; i++) {
335            b0[0] = hsimd<2>::packl(b10[i+i+1], b10[i+i]);
336        }
337
338        printf("\n");
339        print_register<BitBlock>("b7", b7[0]);
340        print_register<BitBlock>("b6", b6[0]);
341        print_register<BitBlock>("b5", b5[0]);
342        print_register<BitBlock>("b4", b4[0]);
343        print_register<BitBlock>("b3", b3[0]);
344        print_register<BitBlock>("b2", b2[0]);
345        print_register<BitBlock>("b1", b1[0]);
346        print_register<BitBlock>("b0", b0[0]);
347
348        printf("---");
349}
350      //////////////////////////////////////////////////////////////////////////////////////////
351{
352      Byte = (BytePack *) &infile_buffer[k];
353
354      #ifdef BE
355      s2p_le(Byte[7], Byte[6], Byte[5], Byte[4],
356             Byte[3], Byte[2], Byte[1], Byte[0],
357             b7, b6, b5, b4,
358             b3, b2, b1, b0);
359
360      printf("\n");
361      print_register<BitBlock>("b7", b7);
362      print_register<BitBlock>("b6", b6);
363      print_register<BitBlock>("b5", b5);
364      print_register<BitBlock>("b4", b4);
365      print_register<BitBlock>("b3", b3);
366      print_register<BitBlock>("b2", b2);
367      print_register<BitBlock>("b1", b1);
368      print_register<BitBlock>("b0", b0);
369      #endif
370
371      k += BLOCK_SIZE;
372      bytes_avail -= BLOCK_SIZE;
373    }
374}
375//////////////////////////////////////////////////////////////////////////////////////////
376// Final Partial Block.
377//////////////////////////////////////////////////////////////////////////////////////////
378    if(bytes_avail > 0) 
379    {
380
381      Byte = (BytePack *) &infile_buffer[k];
382      BitBlock EOF_mask = eof_mask(bytes_avail);
383
384      #ifdef BE
385      s2p_le(Byte[7], Byte[6], Byte[5], Byte[4],
386             Byte[3], Byte[2], Byte[1], Byte[0],
387             b7, b6, b5, b4,
388             b3, b2, b1, b0);
389
390
391
392      b7 = simd_and(b7, EOF_mask);
393      b6 = simd_and(b6, EOF_mask);
394      b5 = simd_and(b5, EOF_mask);
395      b4 = simd_and(b4, EOF_mask);
396      b3 = simd_and(b3, EOF_mask);
397      b2 = simd_and(b2, EOF_mask);
398      b1 = simd_and(b1, EOF_mask);
399      b0 = simd_and(b0, EOF_mask);
400
401      printf("\n");
402      print_register<BitBlock>("b7", b7);
403      print_register<BitBlock>("b6", b6);
404      print_register<BitBlock>("b5", b5);
405      print_register<BitBlock>("b4", b4);
406      print_register<BitBlock>("b3", b3);
407      print_register<BitBlock>("b2", b2);
408      print_register<BitBlock>("b1", b1);
409      print_register<BitBlock>("b0", b0);
410      #endif
411
412
413    }
414
415}
416
417
418
Note: See TracBrowser for help on using the repository browser.