source: proto/Compiler/workspace/pybit_template.c @ 2049

Last change on this file since 2049 was 1464, checked in by ksherdy, 8 years ago

Centralized typedefs.

File size: 4.6 KB
Line 
1#include <string.h>
2#include <stdio.h>
3#include <stdlib.h>
4#include <errno.h>
5#include <sys/types.h>
6#include <sys/stat.h>
7
8#include "../lib/lib_simd.h"
9#include "../lib/block_carry.h"
10#include "../lib/perflib/perfsec.h"
11#include "../lib/s2p.h"
12
13#define BLOCK_SIZE (sizeof(SIMD_type) * 8)      /* BLOCK_SIZE           - SIMD register in bits */
14#define BUFFER_SIZE (BLOCK_SIZE * 16)           /* BUFFER_SIZE          - multiple of BLOCK_SIZE */
15#define OVERLAP_BUFSIZE BLOCK_SIZE              /* OVERLAP_BUFSIZE      - SIMD register width in bytes overlap */
16
17#ifdef BUFFER_PROFILING
18        BOM_Table * perf_timer;
19#elif CODE_CLOCKER
20        #define NUM_EVENTS 1
21        int Events[NUM_EVENTS] = {PAPI_TOT_CYC};
22        //int Events[NUM_EVENTS] = {PAPI_L2_DCM};
23        //int Events[NUM_EVENTS] = {PAPI_TOT_CYC, PAPI_BR_MSP};
24        int cal_size = 20;
25        CC * perf_timer = new CC(Events,NUM_EVENTS,cal_size);
26#else
27        void * perf_timer;
28#endif
29
30void do_process(FILE *infile, FILE *outfile) {
31
32        /* Compiler generated stream variable declarations. */
33        @decl
34
35        BitBlock error_mask;
36        BitBlock EOF_mask = simd_const_1(1);
37
38        /* 8 * sizeof(SIMD_type) bytes. */
39        BytePack U8[8];
40
41        /* Source file data is broken into buffers, buffers are broken into blocks, blocks are SIMD register width. */
42        int buf_pos = 0;
43        int block_pos = 0;
44        int err_pos = 0;
45
46        BytePack buf[(OVERLAP_BUFSIZE+BUFFER_SIZE+OVERLAP_BUFSIZE)/sizeof(SIMD_type)];
47        char * srcbuf = ((char *) buf) + OVERLAP_BUFSIZE;
48        memset((unsigned char *)srcbuf,0,16);
49        memset(((unsigned char *)srcbuf)+BUFFER_SIZE,0,16); /* Zero out first and last sizeof(SIMD_type) bytes. */
50
51        /* File IO */
52        int chars_avail = 0;
53        int chars_read = 0;
54
55        chars_read = fread((void *)srcbuf, 1, BUFFER_SIZE, infile);
56        chars_avail = chars_read;
57        if(ferror(infile)) { fprintf(stderr, "Error: Failed to read input file.\n"); return; }
58        if(chars_avail==0 && feof(infile)) { return; }
59
60        @stream_stmts
61
62        while(1) {
63
64                PERF_SEC_START(perf_timer);
65
66                while (chars_avail >= BLOCK_SIZE) { /* process full blocks */
67
68                        BytePack * U8 = (BytePack *) &srcbuf[block_pos];
69
70                        s2p(U8[0], U8[1], U8[2], U8[3], U8[4], U8[5], U8[6], U8[7],
71                        array_bit__0_,array_bit__1_,array_bit__2_,array_bit__3_,array_bit__4_,array_bit__5_,array_bit__6_,array_bit__7_);
72
73                        @block_stmts
74
75                        if (bitblock_has_bit(error_mask)){
76                                pos = buf_pos + block_pos + count_forward_zeroes(error_mask);
77                                fprintf(stderr, "Error at position %i.\n", pos);
78                                exit(-1);
79                        }
80
81                        chars_avail -= BLOCK_SIZE;
82                        block_pos += BLOCK_SIZE;
83                }
84
85                if(chars_avail > 0 /* || any_carry */) { /* process final partial block */
86                        /* extra */
87                        EOF_mask = sisd_srl(simd_const_1(1),sisd_from_int(BLOCK_SIZE-chars_avail));
88                        BitBlock high_bit_mask = sisd_srl(sisd_high_bit_mask, sisd_from_int(BLOCK_SIZE-chars_avail));
89
90                        BytePack * U8 = (BytePack *) &srcbuf[block_pos];
91
92                        s2p(U8[0], U8[1], U8[2], U8[3], U8[4], U8[5], U8[6], U8[7],
93                        array_bit__0_,array_bit__1_,array_bit__2_,array_bit__3_,array_bit__4_,array_bit__5_,array_bit__6_,array_bit__7_);
94
95                        array_bit__0_ = simd_and(array_bit__0_, EOF_mask);
96                        array_bit__1_ = simd_and(array_bit__1_, EOF_mask);
97                        array_bit__2_ = simd_and(array_bit__2_, EOF_mask);
98                        array_bit__3_ = simd_and(array_bit__3_, EOF_mask);
99                        array_bit__4_ = simd_and(array_bit__4_, EOF_mask);
100                        array_bit__5_ = simd_and(array_bit__5_, EOF_mask);
101                        array_bit__6_ = simd_and(array_bit__6_, EOF_mask);
102                        array_bit__7_ = simd_and(array_bit__7_, EOF_mask);
103
104                        @block_stmts
105
106                        if(bitblock_has_bit(error_mask)) {
107                                err_pos = buf_pos + block_pos + count_forward_zeroes(error_mask) + 1;
108                                fprintf(stderr, "Initial error at position %i.\n", err_pos);
109                                exit(-1);
110                        }
111                }
112
113                PERF_SEC_END(perf_timer, chars_avail);
114
115                buf_pos += chars_read;
116                block_pos = 0;
117
118                chars_read = fread((void *)srcbuf, 1, BUFFER_SIZE, infile);
119                chars_avail = chars_read;
120                if(ferror(infile)) { fprintf(stderr, "Failed to read input file.\n"); return; }
121                if(chars_avail==0 && feof(infile)) { return; }
122        }
123}
124
125int main(int argc, char * argv[]) {
126        char * infilename, * outfilename;
127        FILE *infile, *outfile;
128        struct stat fileinfo;
129
130        if (argc < 2) {
131                printf("Usage: %s <filename> [<outputfile>]\n", argv[0]);
132                exit(-1);
133        }
134
135        infilename = argv[1];
136        stat(infilename, &fileinfo);
137        infile = fopen(infilename, "rb");
138        if (!infile) {
139                fprintf(stderr, "Error: Cannot open %s for reading.\n", infilename);
140                exit(-1);
141        }
142
143        if (argc < 3) {
144                outfile = stdout;
145        }       else {
146                outfilename = argv[2];
147                outfile = fopen(outfilename, "wb");
148                if (!outfile) {
149                        fprintf(stderr, "Error: Cannot open %s for writing.\n", outfilename);
150                        exit(-1);
151                }
152        }
153
154        // PERF_SEC_BIND(1);
155
156        PERF_SEC_INIT(perf_timer);
157
158        do_process(infile, outfile);
159
160        PERF_SEC_DUMP(perf_timer);
161
162        PERF_SEC_DESTROY(perf_timer);
163
164        fclose(infile);
165        fclose(outfile);
166
167        return(0);
168}
Note: See TracBrowser for help on using the repository browser.