source: proto/JSON/json_pablo_template.c @ 800

Last change on this file since 800 was 800, checked in by ksherdy, 9 years ago

Update template error message.

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