source: proto/JSON/template.c @ 767

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

Initial working JSON compilable and executable.

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