source: proto/JSON/json_pablo_template.c @ 4177

Last change on this file since 4177 was 2548, checked in by ksherdy, 7 years ago

Updated JSON project. Migration to IDISA library needed.

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