Changeset 849


Ignore:
Timestamp:
Dec 22, 2010, 1:55:42 PM (8 years ago)
Author:
ksherdy
Message:

Update variable name.

Location:
proto/JSON
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • proto/JSON/json_pablo_template.c

    r821 r849  
    1414typedef SIMD_type BitBlock;
    1515
    16 #define BLOCK_SIZE (sizeof(SIMD_type) * 8)      /* BLOCK_SIZE           - SIMD register in bits */     
     16#define BLOCK_SIZE (sizeof(SIMD_type) * 8)      /* BLOCK_SIZE           - SIMD register in bits */
    1717#define BUFFER_SIZE (BLOCK_SIZE * 16)           /* BUFFER_SIZE          - multiple of BLOCK_SIZE */
    1818#define OVERLAP_BUFSIZE BLOCK_SIZE              /* OVERLAP_BUFSIZE      - SIMD register width in bytes overlap */
     
    3434
    3535void do_process(FILE *infile, FILE *outfile) {
    36  
     36
    3737        /* Compiler generated stream variable declarations. */
    3838        @decl
    39        
     39
    4040        // BitBlock error_mask;  // PyBit compiler auto declares this variable
    4141        BitBlock bit[8];
    4242        BitBlock EOF_mask = simd_const_1(1);
    43        
     43
    4444        /*extra*/
    4545        /* parse_escape, do not declare, since the PyBit compiler does so by default*/
    4646        Parity.Odd = simd_const_2(1);
    4747        Parity.Even = simd_const_2(2);
    48        
    49         BitBlock high_bit_mask = sisd_high_bit_mask;   
     48
     49        BitBlock high_bit_mask = sisd_high_bit_mask;
    5050        BitBlock high_bit_is_set;
    5151        // BitBlock ParityMask = simd_const_1(0); // PyBit compiler auto declares this variable
    52         BitBlock bitblock_parity_mask; 
    53        
     52        BitBlock bitblock_parity_mask;
     53
    5454        /* 8 * sizeof(SIMD_type) bytes. */
    5555        BytePack U8[8];
    56        
     56
    5757        /* Source file data is broken into buffers, buffers are broken into blocks, blocks are SIMD register width. */
    58         int src_pos = 0;
    5958        int buf_pos = 0;
     59        int block_pos = 0;
    6060        int err_col = 0;
    61        
    62         BytePack buf[(OVERLAP_BUFSIZE+BUFFER_SIZE+OVERLAP_BUFSIZE)]; 
     61
     62        BytePack buf[(OVERLAP_BUFSIZE+BUFFER_SIZE+OVERLAP_BUFSIZE)];
    6363        char * srcbuf = ((char *) buf) + OVERLAP_BUFSIZE;
    6464        memset((unsigned char *)srcbuf,0,OVERLAP_BUFSIZE);
    6565        memset(((unsigned char *)srcbuf)+OVERLAP_BUFSIZE+BUFFER_SIZE,0,OVERLAP_BUFSIZE); /* Zero out first and last sizeof(SIMD_type) bytes. */
    66        
     66
    6767        /* File IO */
    6868        int chars_avail = 0;
     
    7575
    7676        @stream_stmts
    77        
     77
    7878        while(1) {
    7979
    8080                PERF_SEC_START(perf_timer);
    81                
     81
    8282                while (chars_avail >= BLOCK_SIZE) { /* process full blocks */
    8383
    84                         BytePack * U8 = (BytePack *) &srcbuf[buf_pos];
     84                        BytePack * U8 = (BytePack *) &srcbuf[block_pos];
    8585
    8686                        s2p(U8[0], U8[1], U8[2], U8[3], U8[4], U8[5], U8[6], U8[7],
     
    9191                        /* Generate Parity Mask */
    9292                        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);                                         
     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);
    9595                        Parity.ParityMask = bitblock_parallel_prefix_parity(UnescapedDQuotes, bitblock_parity_mask);
    96                        
     96
    9797                        #ifdef DEBUG
    98                        
    99                         print_array_le("Data", &srcbuf[buf_pos],BLOCK_SIZE);
     98
     99                        print_array_le("Data", &srcbuf[block_pos],BLOCK_SIZE);
    100100                        print_simd_register("Escape", Escape);
    101101                        print_simd_register("Unescaped DQuote",UnescapedDQuotes);
     
    106106                        print_simd_register("Parity.ParityMask", Parity.ParityMask);
    107107                        print_simd_register("StringMask", StringMask);
    108                         print_simd_register("StringSpans", StringSpans);                                               
    109                
     108                        print_simd_register("StringSpans", StringSpans);
     109
    110110                        print_simd_register("AtomStarts", AtomStarts);
    111111                        print_simd_register("StringStarts", StringStarts);
     
    116116                        print_simd_register("AtomSpans", AtomSpans);
    117117                        print_simd_register("ErrorMask", error_mask);
    118                                                
     118
    119119                        #endif
    120                        
     120
    121121                        if (bitblock_has_bit(error_mask)){
    122                                 err_col = src_pos + buf_pos + count_forward_zeroes(error_mask) + 1;
     122                                err_col = buf_pos + block_pos + count_forward_zeroes(error_mask) + 1;
    123123                                fprintf(stderr, "Initial error at column %i.\n", err_col);
    124124                                exit(-1);
     
    126126
    127127                        chars_avail -= BLOCK_SIZE;
    128                         buf_pos += BLOCK_SIZE;
    129                 }               
    130                
     128                        block_pos += BLOCK_SIZE;
     129                }
     130
    131131                if(chars_avail > 0 || @any_carry ) { /* process final partial block */
    132132                        /* extra */
    133133                        EOF_mask = sisd_srl(simd_const_1(1),sisd_from_int(BLOCK_SIZE-chars_avail));
    134                                                
    135                         BytePack * U8 = (BytePack *) &srcbuf[buf_pos];
    136                        
     134
     135                        BytePack * U8 = (BytePack *) &srcbuf[block_pos];
     136
    137137                        s2p(U8[0], U8[1], U8[2], U8[3], U8[4], U8[5], U8[6], U8[7],
    138138                        bit[0], bit[1], bit[2], bit[3], bit[4], bit[5], bit[6], bit[7]);
     
    146146                        bit[6] = simd_and(bit[6], EOF_mask);
    147147                        bit[7] = simd_and(bit[7], EOF_mask);
    148                        
     148
    149149                        @block_stmts
    150                        
     150
    151151                        /* Generate Parity Mask */
    152152                        high_bit_mask = sisd_srl(sisd_high_bit_mask, sisd_from_int(BLOCK_SIZE-chars_avail));
    153153                        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);                 
     154                        bitblock_parity_mask = sisd_add(simd_not(sisd_srl(high_bit_is_set, sisd_from_int(chars_avail-1))) , sisd_low_bit_mask);
    155155                        Parity.ParityMask = bitblock_parallel_prefix_parity(UnescapedDQuotes, bitblock_parity_mask);
    156156                        Parity.ParityMask = simd_and(Parity.ParityMask, EOF_mask);
    157                        
     157
    158158                        #ifdef DEBUG
    159                        
    160                         print_array_le("Data", &srcbuf[buf_pos],BLOCK_SIZE);
     159
     160                        print_array_le("Data", &srcbuf[block_pos],BLOCK_SIZE);
    161161                        print_simd_register("Escape", Escape);
    162162                        print_simd_register("Unescaped DQuote",UnescapedDQuotes);
     
    167167                        print_simd_register("Parity.ParityMask", Parity.ParityMask);
    168168                        print_simd_register("StringMask", StringMask);
    169                         print_simd_register("StringSpans", StringSpans);                                               
    170                
     169                        print_simd_register("StringSpans", StringSpans);
     170
    171171                        print_simd_register("AtomStarts", AtomStarts);
    172172                        print_simd_register("StringStarts", StringStarts);
     
    176176                        print_simd_register("NullStarts", NullStarts);
    177177                        print_simd_register("AtomSpans", AtomSpans);
    178                         print_simd_register("ErrorMask", error_mask);                   
    179                        
     178                        print_simd_register("ErrorMask", error_mask);
     179
    180180                        #endif
    181                        
     181
    182182                        if(bitblock_has_bit(error_mask)) {
    183                                 err_col = src_pos + buf_pos + count_forward_zeroes(error_mask) + 1;
     183                                err_col = buf_pos + block_pos + count_forward_zeroes(error_mask) + 1;
    184184                                fprintf(stderr, "Initial error at position %i.\n", err_col);
    185185                                exit(-1);
    186186                        }
    187187                }
    188                
     188
    189189                PERF_SEC_END(perf_timer, chars_avail);
    190190
    191                 src_pos += chars_read;
    192                 buf_pos = 0;
     191                buf_pos += chars_read;
     192                block_pos = 0;
    193193
    194194                chars_read = fread((void *)srcbuf, 1, BUFFER_SIZE, infile);
    195195                chars_avail = chars_read;
    196196                if(ferror(infile)) { fprintf(stderr, "Failed to read input file.\n"); return; }
    197                 if(chars_avail==0 && feof(infile)) { return; } 
     197                if(chars_avail==0 && feof(infile)) { return; }
    198198        }
    199199}
    200200
    201201int main(int argc, char * argv[]) {
    202         char * infilename, * outfilename;       
     202        char * infilename, * outfilename;
    203203        FILE *infile, *outfile;
    204204        struct stat fileinfo;
     
    216216                exit(-1);
    217217        }
    218        
     218
    219219        if (argc < 3) {
    220220                outfile = stdout;
     
    233233
    234234        do_process(infile, outfile);
    235        
     235
    236236        PERF_SEC_DUMP(perf_timer);
    237        
     237
    238238        PERF_SEC_DESTROY(perf_timer);
    239239
    240240        fclose(infile);
    241241        fclose(outfile);
    242        
     242
    243243        return(0);
    244244}
  • proto/JSON/json_pybit_template.c

    r821 r849  
    1414typedef SIMD_type BitBlock;
    1515
    16 #define BLOCK_SIZE (sizeof(SIMD_type) * 8)      /* BLOCK_SIZE           - SIMD register in bits */     
     16#define BLOCK_SIZE (sizeof(SIMD_type) * 8)      /* BLOCK_SIZE           - SIMD register in bits */
    1717#define BUFFER_SIZE (BLOCK_SIZE * 16)           /* BUFFER_SIZE          - multiple of BLOCK_SIZE */
    1818#define OVERLAP_BUFSIZE BLOCK_SIZE              /* OVERLAP_BUFSIZE      - SIMD register width in bytes overlap */
     
    3434
    3535void do_process(FILE *infile, FILE *outfile) {
    36  
     36
    3737        /* Compiler generated stream variable declarations. */
    3838        @decl
    39        
     39
    4040        // BitBlock error_mask;  // PyBit compiler auto declares this variable
    4141        BitBlock EOF_mask = simd_const_1(1);
    42        
     42
    4343        /*extra*/
    4444        /* parse_escape, do not declare, since the PyBit compiler does so by default*/
    4545        Odd = simd_const_2(1);
    4646        Even = simd_const_2(2);
    47        
    48         BitBlock high_bit_mask = sisd_high_bit_mask;   
     47
     48        BitBlock high_bit_mask = sisd_high_bit_mask;
    4949        BitBlock high_bit_is_set;
    5050        // BitBlock ParityMask = simd_const_1(0); // PyBit compiler auto declares this variable
    51         BitBlock bitblock_parity_mask; 
    52        
     51        BitBlock bitblock_parity_mask;
     52
    5353        /* 8 * sizeof(SIMD_type) bytes. */
    5454        BytePack U8[8];
    55        
     55
    5656        /* Source file data is broken into buffers, buffers are broken into blocks, blocks are SIMD register width. */
    57         int src_pos = 0;
    5857        int buf_pos = 0;
     58        int block_pos = 0;
    5959        int err_col = 0;
    60        
    61         BytePack buf[(OVERLAP_BUFSIZE+BUFFER_SIZE+OVERLAP_BUFSIZE)/sizeof(SIMD_type)]; 
     60
     61        BytePack buf[(OVERLAP_BUFSIZE+BUFFER_SIZE+OVERLAP_BUFSIZE)/sizeof(SIMD_type)];
    6262        char * srcbuf = ((char *) buf) + OVERLAP_BUFSIZE;
    6363        memset((unsigned char *)srcbuf,0,16);
    6464        memset(((unsigned char *)srcbuf)+BUFFER_SIZE,0,16); /* Zero out first and last sizeof(SIMD_type) bytes. */
    65        
     65
    6666        /* File IO */
    6767        int chars_avail = 0;
     
    7474
    7575        @stream_stmts
    76        
     76
    7777        while(1) {
    7878
    7979                PERF_SEC_START(perf_timer);
    80                
     80
    8181                while (chars_avail >= BLOCK_SIZE) { /* process full blocks */
    8282
    83                         BytePack * U8 = (BytePack *) &srcbuf[buf_pos];
     83                        BytePack * U8 = (BytePack *) &srcbuf[block_pos];
    8484
    8585                        s2p(U8[0], U8[1], U8[2], U8[3], U8[4], U8[5], U8[6], U8[7],
     
    9090                        /* Generate Parity Mask */
    9191                        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);                                         
     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);
    9494                        ParityMask = bitblock_parallel_prefix_parity(UnescapedDQuotes, bitblock_parity_mask);
    95                        
     95
    9696                        #ifdef DEBUG
    97                        
    98                         print_array_le("Data", &srcbuf[buf_pos],BLOCK_SIZE);
     97
     98                        print_array_le("Data", &srcbuf[block_pos],BLOCK_SIZE);
    9999                        print_simd_register("Escape", Escape);
    100100                        print_simd_register("Unescaped DQuote",UnescapedDQuotes);
     
    105105                        print_simd_register("ParityMask", ParityMask);
    106106                        print_simd_register("StringMask", StringMask);
    107                         print_simd_register("StringSpans", StringSpans);                                               
    108                
     107                        print_simd_register("StringSpans", StringSpans);
     108
    109109                        print_simd_register("AtomStarts", AtomStarts);
    110110                        print_simd_register("StringStarts", StringStarts);
     
    115115                        print_simd_register("AtomSpans", AtomSpans);
    116116                        print_simd_register("ErrorMask", error_mask);
    117                                                
     117
    118118                        #endif
    119                        
     119
    120120                        if (bitblock_has_bit(error_mask)){
    121                                 err_col = src_pos + buf_pos + count_forward_zeroes(error_mask) + 1;
     121                                err_col = buf_pos + block_pos + count_forward_zeroes(error_mask) + 1;
    122122                                fprintf(stderr, "Initial error at column %i.\n", err_col);
    123123                                exit(-1);
     
    125125
    126126                        chars_avail -= BLOCK_SIZE;
    127                         buf_pos += BLOCK_SIZE;
    128                 }               
    129                
     127                        block_pos += BLOCK_SIZE;
     128                }
     129
    130130                if(chars_avail > 0 /* || any_carry */) { /* process final partial block */
    131131                        /* extra */
    132132                        EOF_mask = sisd_srl(simd_const_1(1),sisd_from_int(BLOCK_SIZE-chars_avail));
    133                                                
    134                         BytePack * U8 = (BytePack *) &srcbuf[buf_pos];
    135                        
     133
     134                        BytePack * U8 = (BytePack *) &srcbuf[block_pos];
     135
    136136                        s2p(U8[0], U8[1], U8[2], U8[3], U8[4], U8[5], U8[6], U8[7],
    137137                        array_bit__0_,array_bit__1_,array_bit__2_,array_bit__3_,array_bit__4_,array_bit__5_,array_bit__6_,array_bit__7_);
     
    145145                        array_bit__6_ = simd_and(array_bit__6_, EOF_mask);
    146146                        array_bit__7_ = simd_and(array_bit__7_, EOF_mask);
    147                        
     147
    148148                        @block_stmts
    149                        
     149
    150150                        /* Generate Parity Mask */
    151151                        high_bit_mask = sisd_srl(sisd_high_bit_mask, sisd_from_int(BLOCK_SIZE-chars_avail));
    152152                        high_bit_is_set = simd_and(high_bit_mask, bitblock_parity_mask);
    153                         bitblock_parity_mask = sisd_add(simd_not(sisd_srl(high_bit_is_set, sisd_from_int(chars_avail-1))) , sisd_low_bit_mask);                 
     153                        bitblock_parity_mask = sisd_add(simd_not(sisd_srl(high_bit_is_set, sisd_from_int(chars_avail-1))) , sisd_low_bit_mask);
    154154                        ParityMask = bitblock_parallel_prefix_parity(UnescapedDQuotes, bitblock_parity_mask);
    155155                        ParityMask = simd_and(ParityMask, EOF_mask);
    156                        
     156
    157157                        #ifdef DEBUG
    158                        
    159                         print_array_le("Data", &srcbuf[buf_pos],BLOCK_SIZE);
     158
     159                        print_array_le("Data", &srcbuf[block_pos],BLOCK_SIZE);
    160160                        print_simd_register("Escape", Escape);
    161161                        print_simd_register("Unescaped DQuote",UnescapedDQuotes);
     
    166166                        print_simd_register("ParityMask", ParityMask);
    167167                        print_simd_register("StringMask", StringMask);
    168                         print_simd_register("StringSpans", StringSpans);                                               
    169                
     168                        print_simd_register("StringSpans", StringSpans);
     169
    170170                        print_simd_register("AtomStarts", AtomStarts);
    171171                        print_simd_register("StringStarts", StringStarts);
     
    175175                        print_simd_register("NullStarts", NullStarts);
    176176                        print_simd_register("AtomSpans", AtomSpans);
    177                         print_simd_register("ErrorMask", error_mask);                   
    178                        
     177                        print_simd_register("ErrorMask", error_mask);
     178
    179179                        #endif
    180                        
     180
    181181                        if(bitblock_has_bit(error_mask)) {
    182                                 err_col = src_pos + buf_pos + count_forward_zeroes(error_mask) + 1;
     182                                err_col = buf_pos + block_pos + count_forward_zeroes(error_mask) + 1;
    183183                                fprintf(stderr, "Initial error at position %i.\n", err_col);
    184184                                exit(-1);
    185185                        }
    186186                }
    187                
     187
    188188                PERF_SEC_END(perf_timer, chars_avail);
    189189
    190                 src_pos += chars_read;
    191                 buf_pos = 0;
     190                buf_pos += chars_read;
     191                block_pos = 0;
    192192
    193193                chars_read = fread((void *)srcbuf, 1, BUFFER_SIZE, infile);
    194194                chars_avail = chars_read;
    195195                if(ferror(infile)) { fprintf(stderr, "Failed to read input file.\n"); return; }
    196                 if(chars_avail==0 && feof(infile)) { return; } 
     196                if(chars_avail==0 && feof(infile)) { return; }
    197197        }
    198198}
    199199
    200200int main(int argc, char * argv[]) {
    201         char * infilename, * outfilename;       
     201        char * infilename, * outfilename;
    202202        FILE *infile, *outfile;
    203203        struct stat fileinfo;
     
    215215                exit(-1);
    216216        }
    217        
     217
    218218        if (argc < 3) {
    219219                outfile = stdout;
     
    232232
    233233        do_process(infile, outfile);
    234        
     234
    235235        PERF_SEC_DUMP(perf_timer);
    236        
     236
    237237        PERF_SEC_DESTROY(perf_timer);
    238238
    239239        fclose(infile);
    240240        fclose(outfile);
    241        
     241
    242242        return(0);
    243243}
Note: See TracChangeset for help on using the changeset viewer.