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

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

Centralized typedefs.

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