source: proto/JSON/template.c @ 741

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

Add template.c, json.c, json.c Makefile.

File size: 6.1 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 sizeof(SIMD_type)       /* OVERLAP_BUFSIZE      - SIMD register width */
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        /*extra*/
42        BitBlock high_bit_mask = sisd_high_bit_mask;   
43        BitBlock high_bit_is_set;
44        BitBlock parity_mask = simd_const_1(0);
45        BitBlock bitblock_parity_mask; 
46       
47        /* 8 * sizeof(SIMD_type) bytes. */
48        BytePack U8[8];
49       
50        /* Source file data is broken into buffers, buffers are broken into blocks, blocks are SIMD register width. */
51        int src_pos = 0;
52        int buf_pos = 0;
53        int err_pos = 0;
54       
55        BytePack buf[(OVERLAP_BUFSIZE+BUFFER_SIZE+OVERLAP_BUFSIZE)/sizeof(SIMD_type)]; 
56        char * srcbuf = ((char *) buf) + OVERLAP_BUFSIZE;
57        memset((unsigned char *)srcbuf,0,16);
58        memset(((unsigned char *)srcbuf)+BUFFER_SIZE,0,16); /* Zero out first and last sizeof(SIMD_type) bytes. */
59       
60        /* File IO */
61        int chars_avail = 0;
62        int chars_read = 0;
63
64        chars_read = fread((void *)srcbuf, 1, BUFFER_SIZE, infile);
65        chars_avail = chars_read;
66        if(ferror(infile)) { fprintf(stderr, "Error: Failed to read input file.\n"); return; }
67        if(chars_avail==0 && feof(infile)) { return; }
68
69        @stream_stmts
70       
71        while(1) {
72
73                PERF_SEC_START(perf_timer);
74               
75                while (chars_avail >= BLOCK_SIZE) { /* process full blocks */
76
77                        BytePack * U8 = (BytePack *) &srcbuf[buf_pos];
78
79                        s2p(U8[0], U8[1], U8[2], U8[3], U8[4], U8[5], U8[6], U8[7],
80                        array_bit__0_,array_bit__1_,array_bit__2_,array_bit__3_,array_bit__4_,array_bit__5_,array_bit__6_,array_bit__7_);
81
82                        @block_stmts
83
84                        /* strct_Lex__Null_ = simd_or(temp89,strct_Lex__l_); */
85                        high_bit_mask = sisd_high_bit_mask;
86                        high_bit_is_set = simd_and(high_bit_mask, bitblock_parity_mask);                       
87                        parity_mask = sisd_add( simd_not(sisd_srl(high_bit_is_set, sisd_from_int(BLOCK_SIZE-1))) , sisd_low_bit_mask);                                         
88                        bitblock_parity_mask = bitblock_parallel_prefix_parity(strct_Lex__DQuote_, parity_mask);
89                       
90                        print_simd_register("strct_Lex__DQuote_",strct_Lex__DQuote_);
91                        print_simd_register("high_bit_is_set", high_bit_is_set);
92                        print_simd_register("high_bit_mask", high_bit_mask);
93                        print_simd_register("bitblock_parity_mask", bitblock_parity_mask);
94
95                        if (bitblock_has_bit(error_mask)){
96                                err_pos = src_pos + buf_pos + count_forward_zeroes(error_mask);
97                                fprintf(stderr, "Error at position %i\n.", err_pos);
98                                exit(-1);
99                        }
100
101                        chars_avail -= BLOCK_SIZE;
102                        buf_pos += BLOCK_SIZE;
103                }               
104               
105                if(chars_avail > 0 /* || any_carry */) { /* process final partial block */
106                        /* extra */
107                        EOF_mask = sisd_srl(simd_const_1(1),sisd_from_int(BLOCK_SIZE-chars_avail));
108                       
109                        BytePack * U8 = (BytePack *) &srcbuf[buf_pos];
110                       
111                        s2p(U8[0], U8[1], U8[2], U8[3], U8[4], U8[5], U8[6], U8[7],
112                        array_bit__0_,array_bit__1_,array_bit__2_,array_bit__3_,array_bit__4_,array_bit__5_,array_bit__6_,array_bit__7_);
113
114                        array_bit__0_ = simd_and(array_bit__0_, EOF_mask);
115                        array_bit__1_ = simd_and(array_bit__1_, EOF_mask);
116                        array_bit__2_ = simd_and(array_bit__2_, EOF_mask);
117                        array_bit__3_ = simd_and(array_bit__3_, EOF_mask);
118                        array_bit__4_ = simd_and(array_bit__4_, EOF_mask);
119                        array_bit__5_ = simd_and(array_bit__5_, EOF_mask);
120                        array_bit__6_ = simd_and(array_bit__6_, EOF_mask);
121                        array_bit__7_ = simd_and(array_bit__7_, EOF_mask);
122                       
123                        @block_stmts
124
125                        /* strct_Lex__Null_ = simd_or(temp89,strct_Lex__l_); */
126                        /* extra */
127                        high_bit_mask = sisd_srl(sisd_high_bit_mask, sisd_from_int(BLOCK_SIZE-chars_avail));
128                        high_bit_is_set = simd_and(high_bit_mask, bitblock_parity_mask);
129                        parity_mask = sisd_add(simd_not(sisd_srl(high_bit_is_set, sisd_from_int(chars_avail-1))) , sisd_low_bit_mask);                 
130                        bitblock_parity_mask = bitblock_parallel_prefix_parity(strct_Lex__DQuote_, parity_mask);
131                        bitblock_parity_mask = simd_and(bitblock_parity_mask, EOF_mask);
132                       
133                        print_simd_register("strct_Lex__DQuote_",strct_Lex__DQuote_);
134                        print_simd_register("high_bit_is_set", high_bit_is_set);
135                        print_simd_register("high_bit_mask", high_bit_mask);
136                        print_simd_register("bitblock_parity_mask", bitblock_parity_mask);
137                       
138                        if(bitblock_has_bit(error_mask)) {
139                                err_pos = src_pos + buf_pos + count_forward_zeroes(error_mask);
140                                fprintf(stderr, "Error at position %i\n.", err_pos);
141                                exit(-1);
142                        }
143                }
144               
145                PERF_SEC_END(perf_timer, chars_avail);
146
147                src_pos += chars_read;
148                buf_pos = 0;
149
150                chars_read = fread((void *)srcbuf, 1, BUFFER_SIZE, infile);
151                chars_avail = chars_read;
152                if(ferror(infile)) { fprintf(stderr, "Failed to read input file.\n"); return; }
153                if(chars_avail==0 && feof(infile)) { return; } 
154        }
155}
156
157int main(int argc, char * argv[]) {
158        char * infilename, * outfilename;       
159        FILE *infile, *outfile;
160        struct stat fileinfo;
161
162        if (argc < 2) {
163                printf("Usage: %s <filename> [<outputfile>]\n", argv[0]);
164                exit(-1);
165        }
166
167        infilename = argv[1];
168        stat(infilename, &fileinfo);
169        infile = fopen(infilename, "rb");
170        if (!infile) {
171                fprintf(stderr, "Error: Cannot open %s for reading.\n", infilename);
172                exit(-1);
173        }
174       
175        if (argc < 3) {
176                outfile = stdout;
177        }       else {
178                outfilename = argv[2];
179                outfile = fopen(outfilename, "wb");
180                if (!outfile) {
181                        fprintf(stderr, "Error: Cannot open %s for writing.\n", outfilename);
182                        exit(-1);
183                }
184        }
185
186        // PERF_SEC_BIND(1);
187
188        PERF_SEC_INIT(perf_timer);
189
190        do_process(infile, outfile);
191       
192        PERF_SEC_DUMP(perf_timer);
193       
194        PERF_SEC_DESTROY(perf_timer);
195
196        fclose(infile);
197        fclose(outfile);
198       
199        return(0);
200}
Note: See TracBrowser for help on using the repository browser.