Changeset 823 for proto


Ignore:
Timestamp:
Dec 14, 2010, 3:03:26 PM (9 years ago)
Author:
ksherdy
Message:

Synchronize variable names with the parabix2 template.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • proto/Compiler/workspace/pablo_template.c

    r819 r823  
    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 */
     
    3232
    3333void do_process(FILE *infile, FILE *outfile) {
    34  
     34
    3535        /* Compiler generated stream variable declarations. */
    3636        @decl
    37        
     37
    3838        BitBlock bit[8];
    3939        BitBlock error_mask;
    4040        BitBlock EOF_mask = simd_const_1(1);
    41        
     41
    4242        /* 8 * sizeof(SIMD_type) bytes. */
    4343        BytePack U8[8];
    44        
     44
    4545        /* Source file data is broken into buffers, buffers are broken into blocks, blocks are SIMD register width. */
    46         int src_pos = 0;
    4746        int buf_pos = 0;
     47        int block_pos = 0;
    4848        int err_pos = 0;
    49        
    50         BytePack buf[(OVERLAP_BUFSIZE+BUFFER_SIZE+OVERLAP_BUFSIZE)]; 
     49
     50        BytePack buf[(OVERLAP_BUFSIZE+BUFFER_SIZE+OVERLAP_BUFSIZE)];
    5151        char * srcbuf = ((char *) buf) + OVERLAP_BUFSIZE;
    5252        memset((unsigned char *)srcbuf,0,OVERLAP_BUFSIZE);
    5353        memset(((unsigned char *)srcbuf)+OVERLAP_BUFSIZE+BUFFER_SIZE,0,OVERLAP_BUFSIZE); /* Zero out first and last sizeof(SIMD_type) bytes. */
    54        
     54
    5555        /* File IO */
    5656        int chars_avail = 0;
     
    6363
    6464        @stream_stmts
    65        
     65
    6666        while(1) {
    6767
    6868                PERF_SEC_START(perf_timer);
    69                
     69
    7070                while (chars_avail >= BLOCK_SIZE) { /* process full blocks */
    7171
    72                         BytePack * U8 = (BytePack *) &srcbuf[buf_pos];
     72                        BytePack * U8 = (BytePack *) &srcbuf[block_pos];
    7373
    7474                        s2p(U8[0], U8[1], U8[2], U8[3], U8[4], U8[5], U8[6], U8[7],
     
    7878
    7979                        if (bitblock_has_bit(error_mask)){
    80                                 pos = src_pos + buf_pos + count_forward_zeroes(error_mask);
     80                                pos = buf_pos + block_pos + count_forward_zeroes(error_mask);
    8181                                fprintf(stderr, "Error at position %i.\n", pos);
    8282                                exit(-1);
     
    8484
    8585                        chars_avail -= BLOCK_SIZE;
    86                         buf_pos += BLOCK_SIZE;
    87                 }               
    88                
     86                        block_pos += BLOCK_SIZE;
     87                }
     88
    8989                if(chars_avail > 0 || @any_carry ) { /* process final partial block */
    9090                        /* extra */
    9191                        EOF_mask = sisd_srl(simd_const_1(1),sisd_from_int(BLOCK_SIZE-chars_avail));
    9292                        BitBlock high_bit_mask = sisd_srl(sisd_high_bit_mask, sisd_from_int(BLOCK_SIZE-chars_avail));
    93                        
    94                         BytePack * U8 = (BytePack *) &srcbuf[buf_pos];
    95                        
     93
     94                        BytePack * U8 = (BytePack *) &srcbuf[block_pos];
     95
    9696                        s2p(U8[0], U8[1], U8[2], U8[3], U8[4], U8[5], U8[6], U8[7],
    9797                        bit[0], bit[1], bit[2], bit[3], bit[4], bit[5], bit[6], bit[7]);
     
    105105                        bit[6] = simd_and(bit[6], EOF_mask);
    106106                        bit[7] = simd_and(bit[7], EOF_mask);
    107                        
     107
    108108                        @block_stmts
    109                        
     109
    110110                        if(bitblock_has_bit(error_mask)) {
    111                                 err_pos = src_pos + buf_pos + count_forward_zeroes(error_mask);
     111                                err_pos = buf_pos + block_pos + count_forward_zeroes(error_mask);
    112112                                fprintf(stderr, "Initial error at position %i.\n", err_pos);
    113113                                exit(-1);
    114114                        }
    115115                }
    116                
     116
    117117                PERF_SEC_END(perf_timer, chars_avail);
    118118
    119                 src_pos += chars_read;
    120                 buf_pos = 0;
     119                buf_pos += chars_read;
     120                block_pos = 0;
    121121
    122122                chars_read = fread((void *)srcbuf, 1, BUFFER_SIZE, infile);
    123123                chars_avail = chars_read;
    124124                if(ferror(infile)) { fprintf(stderr, "Failed to read input file.\n"); return; }
    125                 if(chars_avail==0 && feof(infile)) { return; } 
     125                if(chars_avail==0 && feof(infile)) { return; }
    126126        }
    127127}
    128128
    129129int main(int argc, char * argv[]) {
    130         char * infilename, * outfilename;       
     130        char * infilename, * outfilename;
    131131        FILE *infile, *outfile;
    132132        struct stat fileinfo;
     
    144144                exit(-1);
    145145        }
    146        
     146
    147147        if (argc < 3) {
    148148                outfile = stdout;
     
    161161
    162162        do_process(infile, outfile);
    163        
     163
    164164        PERF_SEC_DUMP(perf_timer);
    165        
     165
    166166        PERF_SEC_DESTROY(perf_timer);
    167167
    168168        fclose(infile);
    169169        fclose(outfile);
    170        
     170
    171171        return(0);
    172172}
Note: See TracChangeset for help on using the changeset viewer.