source: proto/Compiler/workspace/template.c @ 743

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

Increase OVERLAP_BUFSIZE to 128 bytes.

File size: 4.7 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
13typedef SIMD_type BytePack;
14typedef SIMD_type BitBlock;
15
16#define BLOCK_SIZE (sizeof(SIMD_type) * 8)      /* BLOCK_SIZE           - SIMD register in bits */     
17#define BUFFER_SIZE (BLOCK_SIZE * 16)           /* BUFFER_SIZE          - multiple of BLOCK_SIZE */
18#define OVERLAP_BUFSIZE BLOCK_SIZE              /* OVERLAP_BUFSIZE      - SIMD register width in bytes overlap */
19
20#ifdef BUFFER_PROFILING
21        BOM_Table * perf_timer;
22#elif CODE_CLOCKER
23        #define NUM_EVENTS 1
24        int Events[NUM_EVENTS] = {PAPI_TOT_CYC};
25        //int Events[NUM_EVENTS] = {PAPI_L2_DCM};
26        //int Events[NUM_EVENTS] = {PAPI_TOT_CYC, PAPI_BR_MSP};
27        int cal_size = 20;
28        CC * perf_timer = new CC(Events,NUM_EVENTS,cal_size);
29#else
30        void * perf_timer;
31#endif
32
33void do_process(FILE *infile, FILE *outfile) {
34 
35        /* Compiler generated stream variable declarations. */
36        @decl
37       
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 src_pos = 0;
46        int buf_pos = 0;
47        int err_pos = 0;
48       
49        BytePack buf[(OVERLAP_BUFSIZE+BUFFER_SIZE+OVERLAP_BUFSIZE)/sizeof(SIMD_type)]; 
50        char * srcbuf = ((char *) buf) + OVERLAP_BUFSIZE;
51        memset((unsigned char *)srcbuf,0,16);
52        memset(((unsigned char *)srcbuf)+BUFFER_SIZE,0,16); /* 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[buf_pos];
72
73                        s2p(U8[0], U8[1], U8[2], U8[3], U8[4], U8[5], U8[6], U8[7],
74                        array_bit__0_,array_bit__1_,array_bit__2_,array_bit__3_,array_bit__4_,array_bit__5_,array_bit__6_,array_bit__7_);
75
76                        @block_stmts
77
78                        if (bitblock_has_bit(error_mask)){
79                                err_pos = src_pos + buf_pos + count_forward_zeroes(error_mask);
80                                fprintf(stderr, "Error at position %i\n.", err_pos);
81                                exit(-1);
82                        }
83
84                        chars_avail -= BLOCK_SIZE;
85                        buf_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[buf_pos];
94                       
95                        s2p(U8[0], U8[1], U8[2], U8[3], U8[4], U8[5], U8[6], U8[7],
96                        array_bit__0_,array_bit__1_,array_bit__2_,array_bit__3_,array_bit__4_,array_bit__5_,array_bit__6_,array_bit__7_);
97
98                        array_bit__0_ = simd_and(array_bit__0_, EOF_mask);
99                        array_bit__1_ = simd_and(array_bit__1_, EOF_mask);
100                        array_bit__2_ = simd_and(array_bit__2_, EOF_mask);
101                        array_bit__3_ = simd_and(array_bit__3_, EOF_mask);
102                        array_bit__4_ = simd_and(array_bit__4_, EOF_mask);
103                        array_bit__5_ = simd_and(array_bit__5_, EOF_mask);
104                        array_bit__6_ = simd_and(array_bit__6_, EOF_mask);
105                        array_bit__7_ = simd_and(array_bit__7_, EOF_mask);
106                       
107                        @block_stmts
108                       
109                        if(bitblock_has_bit(error_mask)) {
110                                err_pos = src_pos + buf_pos + count_forward_zeroes(error_mask);
111                                fprintf(stderr, "Error at position %i\n.", err_pos);
112                                exit(-1);
113                        }
114                }
115               
116                PERF_SEC_END(perf_timer, chars_avail);
117
118                src_pos += chars_read;
119                buf_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.