source: proto/JSON/json_pablo_template.c @ 872

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

Add call to bitblock_prefix_parity to avoid manual insertion.

File size: 7.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/perflib/perfsec.h"
10#include "../lib/s2p.h"
11#include "../lib/carryQ.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#define DEBUG 1
21
22#ifdef BUFFER_PROFILING
23        BOM_Table * perf_timer;
24#elif CODE_CLOCKER
25        #define NUM_EVENTS 1
26        int Events[NUM_EVENTS] = {PAPI_TOT_CYC};
27        //int Events[NUM_EVENTS] = {PAPI_L2_DCM};
28        //int Events[NUM_EVENTS] = {PAPI_TOT_CYC, PAPI_BR_MSP};
29        int cal_size = 20;
30        CC * perf_timer = new CC(Events,NUM_EVENTS,cal_size);
31#else
32        void * perf_timer;
33#endif
34
35@global
36
37void do_process(FILE *infile, FILE *outfile) {
38
39        /* Compiler generated stream variable declarations. */
40        @decl
41
42        // BitBlock error_mask;  // PyBit compiler auto declares this variable
43        BitBlock bit[8];
44        BitBlock EOF_mask = simd_const_1(1);
45
46        /*extras*/
47        parity.Odd = simd_const_2(1);
48        parity.Even = simd_const_2(2);
49
50        BitBlock high_bit_mask = sisd_high_bit_mask;
51        BitBlock high_bit_is_set;
52        // BitBlock ParityMask = simd_const_1(0); // PyBit compiler auto declares this variable
53        BitBlock bitblock_parity_mask;
54
55        /* 8 * sizeof(SIMD_type) bytes. */
56        BytePack U8[8];
57
58        /* Source file data is broken into buffers, buffers are broken into blocks, blocks are SIMD register width. */
59        int buf_pos = 0;
60        int block_pos = 0;
61        int err_col = 0;
62
63        BytePack buf[(OVERLAP_BUFSIZE+BUFFER_SIZE+OVERLAP_BUFSIZE)];
64        char * srcbuf = ((char *) buf) + OVERLAP_BUFSIZE;
65        memset((unsigned char *)srcbuf,0,OVERLAP_BUFSIZE);
66        memset(((unsigned char *)srcbuf)+OVERLAP_BUFSIZE+BUFFER_SIZE,0,OVERLAP_BUFSIZE); /* Zero out first and last sizeof(SIMD_type) bytes. */
67
68        /* File IO */
69        int chars_avail = 0;
70        int chars_read = 0;
71
72        chars_read = fread((void *)srcbuf, 1, BUFFER_SIZE, infile);
73        chars_avail = chars_read;
74        if(ferror(infile)) { fprintf(stderr, "Error: Failed to read input file.\n"); return; }
75        if(chars_avail==0 && feof(infile)) { return; }
76
77        @stream_stmts
78
79        while(1) {
80
81                PERF_SEC_START(perf_timer);
82
83                while (chars_avail >= BLOCK_SIZE) { /* process full blocks */
84
85                        BytePack * U8 = (BytePack *) &srcbuf[block_pos];
86
87                        s2p(U8[0], U8[1], U8[2], U8[3], U8[4], U8[5], U8[6], U8[7],
88                        bit[0], bit[1], bit[2], bit[3], bit[4], bit[5], bit[6], bit[7]);
89
90                        /* generate bitblock_parity_mask */
91
92                        // TODO - Figure out this code - May replace
93                        high_bit_mask = sisd_high_bit_mask;
94                        high_bit_is_set = simd_and(high_bit_mask, bitblock_parity_mask);
95                        bitblock_parity_mask = sisd_add( simd_not(sisd_srl(high_bit_is_set, sisd_from_int(BLOCK_SIZE-1))), sisd_low_bit_mask);
96
97                        @block_stmts
98
99                        /* Generate Parity Mask */
100                        // TODO - Migrate to json_pablo_compilable.py
101                        //parity.ParityMask = bitblock_parallel_prefix_parity(UnescapedDQuotes, bitblock_parity_mask);
102
103                        #ifdef DEBUG
104
105                        print_array_le("Data", &srcbuf[block_pos],BLOCK_SIZE);
106                        print_simd_register("Escape", Escape);
107                        print_simd_register("Unescaped DQuote",UnescapedDQuotes);
108                        /*
109                        print_simd_register("high_bit_is_set", high_bit_is_set);
110                        print_simd_register("high_bit_mask", high_bit_mask);
111                        */
112                        print_simd_register("parity.ParityMask", parity.ParityMask);
113                        print_simd_register("StringMask", StringMask);
114                        print_simd_register("StringSpans", StringSpans);
115
116                        print_simd_register("AtomStarts", AtomStarts);
117                        print_simd_register("StringStarts", StringStarts);
118                        print_simd_register("NumberStarts", NumberStarts);
119                        print_simd_register("TrueStarts", TrueStarts);
120                        print_simd_register("FalseStarts", FalseStarts);
121                        print_simd_register("NullStarts", NullStarts);
122                        print_simd_register("AtomSpans", AtomSpans);
123                        print_simd_register("ErrorMask", error_mask);
124
125                        #endif
126
127                        if (bitblock_has_bit(error_mask)){
128                                err_col = buf_pos + block_pos + count_forward_zeroes(error_mask) + 1;
129                                fprintf(stderr, "Initial error at column %i.\n", err_col);
130                                exit(-1);
131                        }
132
133                        chars_avail -= BLOCK_SIZE;
134                        block_pos += BLOCK_SIZE;
135                }
136
137                if(chars_avail > 0 || @any_carry ) { /* process final partial block */
138                        /* extra */
139                        EOF_mask = sisd_srl(simd_const_1(1),sisd_from_int(BLOCK_SIZE-chars_avail));
140
141                        BytePack * U8 = (BytePack *) &srcbuf[block_pos];
142
143                        s2p(U8[0], U8[1], U8[2], U8[3], U8[4], U8[5], U8[6], U8[7],
144                        bit[0], bit[1], bit[2], bit[3], bit[4], bit[5], bit[6], bit[7]);
145
146                        bit[0] = simd_and(bit[0], EOF_mask);
147                        bit[1] = simd_and(bit[1], EOF_mask);
148                        bit[2] = simd_and(bit[2], EOF_mask);
149                        bit[3] = simd_and(bit[3], EOF_mask);
150                        bit[4] = simd_and(bit[4], EOF_mask);
151                        bit[5] = simd_and(bit[5], EOF_mask);
152                        bit[6] = simd_and(bit[6], EOF_mask);
153                        bit[7] = simd_and(bit[7], EOF_mask);
154
155                        /* generate bitblock_parity_mask */
156                        // TODO - Figure out this code - May replace
157                        high_bit_mask = sisd_srl(sisd_high_bit_mask, sisd_from_int(BLOCK_SIZE-chars_avail));
158                        high_bit_is_set = simd_and(high_bit_mask, bitblock_parity_mask);
159                        bitblock_parity_mask = sisd_add(simd_not(sisd_srl(high_bit_is_set, sisd_from_int(chars_avail-1))), sisd_low_bit_mask);
160
161                        @block_stmts
162
163                        // TODO - Migrate to json_pablo_compilable.py
164                        //parity.ParityMask = bitblock_parallel_prefix_parity(UnescapedDQuotes, bitblock_parity_mask);
165                        // TODO - Re-consider inclusion of 'EOF_mask' in the prototype
166                        //parity.ParityMask = simd_and(parity.ParityMask, EOF_mask);
167
168                        #ifdef DEBUG
169
170                        print_array_le("Data", &srcbuf[block_pos],BLOCK_SIZE);
171                        print_simd_register("Escape", Escape);
172                        print_simd_register("Unescaped DQuote",UnescapedDQuotes);
173                        /*
174                        print_simd_register("high_bit_is_set", high_bit_is_set);
175                        print_simd_register("high_bit_mask", high_bit_mask);
176                        */
177                        print_simd_register("parity.ParityMask", parity.ParityMask);
178                        print_simd_register("StringMask", StringMask);
179                        print_simd_register("StringSpans", StringSpans);
180
181                        print_simd_register("AtomStarts", AtomStarts);
182                        print_simd_register("StringStarts", StringStarts);
183                        print_simd_register("NumberStarts", NumberStarts);
184                        print_simd_register("TrueStarts", TrueStarts);
185                        print_simd_register("FalseStarts", FalseStarts);
186                        print_simd_register("NullStarts", NullStarts);
187                        print_simd_register("AtomSpans", AtomSpans);
188                        print_simd_register("ErrorMask", error_mask);
189
190                        #endif
191
192                        if(bitblock_has_bit(error_mask)) {
193                                err_col = buf_pos + block_pos + count_forward_zeroes(error_mask) + 1;
194                                fprintf(stderr, "Initial error at position %i.\n", err_col);
195                                exit(-1);
196                        }
197                }
198
199                PERF_SEC_END(perf_timer, chars_avail);
200
201                buf_pos += chars_read;
202                block_pos = 0;
203
204                chars_read = fread((void *)srcbuf, 1, BUFFER_SIZE, infile);
205                chars_avail = chars_read;
206                if(ferror(infile)) { fprintf(stderr, "Failed to read input file.\n"); return; }
207                if(chars_avail==0 && feof(infile)) { return; }
208        }
209}
210
211int main(int argc, char * argv[]) {
212        char * infilename, * outfilename;
213        FILE *infile, *outfile;
214        struct stat fileinfo;
215
216        if (argc < 2) {
217                printf("Usage: %s <filename> [<outputfile>]\n", argv[0]);
218                exit(-1);
219        }
220
221        infilename = argv[1];
222        stat(infilename, &fileinfo);
223        infile = fopen(infilename, "rb");
224        if (!infile) {
225                fprintf(stderr, "Error: Cannot open %s for reading.\n", infilename);
226                exit(-1);
227        }
228
229        if (argc < 3) {
230                outfile = stdout;
231        }       else {
232                outfilename = argv[2];
233                outfile = fopen(outfilename, "wb");
234                if (!outfile) {
235                        fprintf(stderr, "Error: Cannot open %s for writing.\n", outfilename);
236                        exit(-1);
237                }
238        }
239
240        // PERF_SEC_BIND(1);
241
242        PERF_SEC_INIT(perf_timer);
243
244        do_process(infile, outfile);
245
246        PERF_SEC_DUMP(perf_timer);
247
248        PERF_SEC_DESTROY(perf_timer);
249
250        fclose(infile);
251        fclose(outfile);
252
253        return(0);
254}
Note: See TracBrowser for help on using the repository browser.