Changeset 719 for proto


Ignore:
Timestamp:
Nov 24, 2010, 8:07:31 PM (9 years ago)
Author:
ksherdy
Message:

Refactor template.c

File:
1 edited

Legend:

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

    r645 r719  
    55#include <sys/types.h>
    66#include <sys/stat.h>
     7
    78#include "../lib/lib_simd.h"
    89#include "../lib/block_carry.h"
    9 
    10 #define min(x,y) ((x) <(y) ?(x) :(y) )
    11 
    12 #define BLOCK_SIZE 128
    13 #define BUFFER_SIZE (BLOCK_SIZE * 26)
    14 #define OVERLAP_BUFSIZE 16
     10#include "../lib/perflib/perfsec.h"
     11#include "../lib/s2p.h"
    1512
    1613typedef SIMD_type BytePack;
    1714typedef SIMD_type BitBlock;
    1815
    19 #include "../lib/perflib/perfsec.h"
    20 #include "../lib/s2p.h"
     16#define BLOCK_SIZE (sizeof(SIMD_type) * 8)      /* BLOCK_SIZE           - SIMD register in bits */     
     17#define BUFFER_SIZE (BLOCK_SIZE * 26)           /* BUFFER_SIZE          - multiple of BLOCK_SIZE */
     18#define OVERLAP_BUFSIZE sizeof(SIMD_type)       /* OVERLAP_BUFSIZE      - SIMD register width */
    2119
    2220#ifdef BUFFER_PROFILING
     
    3432
    3533void do_process(FILE *infile, FILE *outfile) {
    36 
    37         @decl
    38 
    39         /* Expected compiler generated stream variables */
    40         /*
    41         BitBlock EOF_mask;
     34 
     35        /* Compiler generated stream variable declarations. */
     36//      @decl
    4237        BitBlock array_bit__0_;
    43   BitBlock array_bit__1_;
     38        BitBlock array_bit__1_;
    4439        BitBlock array_bit__2_;
    4540        BitBlock array_bit__3_;
     
    4944        BitBlock array_bit__7_;
    5045        BitBlock error_mask;
    51         */
     46        BitBlock EOF_mask = simd_const_1(1);
     47       
     48        /* 8 * sizeof(SIMD_type) bytes. */
     49        BytePack U8[8];
     50       
     51        /* Source file data is broken into buffers, buffers are broken into blocks, blocks are SIMD register width. */
     52        int buf_pos = 0;
     53        int block_pos = 0;
     54        int err_pos = 0;
     55       
     56        BytePack buf[(OVERLAP_BUFSIZE+BUFFER_SIZE+OVERLAP_BUFSIZE)/sizeof(SIMD_type)];
     57        char * srcbuf = ((char *) buf) + OVERLAP_BUFSIZE;
     58        memset((unsigned char *)srcbuf,0,16);
     59        memset(((unsigned char *)srcbuf)+BUFFER_SIZE,0,16); /* zero out first and last sizeof(SIMD_type) bytes */
     60       
     61        /* File IO */
     62        int chars_avail = 0;
     63        int chars_read = 0;
    5264
    53   BytePack U8[8];
    54   int buf_pos = 0;
    55   int block_pos = 0;
    56   int errpos = 0;
    57   int chars_avail = 0;
    58   int check_pos = 0;
    59   int chars_read = 0;
    60   BytePack buf[(BUFFER_SIZE+BLOCK_SIZE+OVERLAP_BUFSIZE*2)/sizeof(SIMD_type)];
    61  
    62   char * srcbuf = ((char *) buf) + OVERLAP_BUFSIZE;
    63  
    64   EOF_mask = simd_const_1(1);
    65   chars_read = fread((void *)srcbuf, 1, BUFFER_SIZE + OVERLAP_BUFSIZE, infile);
    66   chars_avail = min(chars_read,BUFFER_SIZE);
    67  
    68   @stream_stmts
     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; }
    6969
    70   while(1){
     70        EOF_mask = simd_const_1(1);
     71        @stream_stmts
     72       
     73        while(1) {
    7174
    72     PERF_SEC_START(perf_timer);
     75                PERF_SEC_START(perf_timer);
     76               
     77                while (chars_avail >= BLOCK_SIZE) {
    7378
    74     block_pos = 0;
     79                        BytePack * U8 = (BytePack *) &srcbuf[block_pos];
    7580
    76     if(chars_avail < BUFFER_SIZE){
    77      
    78       while (block_pos <= chars_avail){
     81                        s2p(U8[0], U8[1], U8[2], U8[3], U8[4], U8[5], U8[6], U8[7],
     82                        array_bit__0_,array_bit__1_,array_bit__2_,array_bit__3_,array_bit__4_,array_bit__5_,array_bit__6_,array_bit__7_);
    7983
    80                                 int bytes = chars_avail - block_pos;   
    81          
    82                                 if(bytes < BLOCK_SIZE){
    83                                 EOF_mask = sisd_srl(simd_const_1(1),sisd_from_int(BLOCK_SIZE-bytes));
    84                                 }
    85                                
    86                                 BytePack * U8 = (BytePack *) &srcbuf[block_pos];
    87        
    88                                 s2p(U8[0], U8[1], U8[2], U8[3], U8[4], U8[5], U8[6], U8[7],
    89                                 array_bit__0_,array_bit__1_,array_bit__2_,array_bit__3_,array_bit__4_,array_bit__5_,array_bit__6_,array_bit__7_);
     84                        @block_stmts
    9085
    91                                 array_bit__0_ = simd_and(array_bit__0_, EOF_mask);
    92                                 array_bit__1_ = simd_and(array_bit__1_, EOF_mask);
    93                                 array_bit__2_ = simd_and(array_bit__2_, EOF_mask);
    94                                 array_bit__3_ = simd_and(array_bit__3_, EOF_mask);
    95                                 array_bit__4_ = simd_and(array_bit__4_, EOF_mask);
    96                                 array_bit__5_ = simd_and(array_bit__5_, EOF_mask);
    97                                 array_bit__6_ = simd_and(array_bit__6_, EOF_mask);
    98                                 array_bit__7_ = simd_and(array_bit__7_, EOF_mask);
     86                        if (bitblock_has_bit(error_mask)){
     87                                err_pos = buf_pos + (chars_read - chars_avail) + count_forward_zeroes(error_mask);
     88                                fprintf(stderr, "Error at position %i\n.", err_pos);
     89                                exit(-1);
     90                        }
    9991
    100                                 @block_stmts
     92                        chars_avail -= BLOCK_SIZE;
     93                }               
     94               
     95                if(chars_avail > 0 /* || any_carry */) {
     96                 
     97                        EOF_mask = sisd_srl(simd_const_1(1),sisd_from_int(BLOCK_SIZE-chars_avail));
     98                       
     99                        BytePack * U8 = (BytePack *) &srcbuf[block_pos];
     100                       
     101                        s2p(U8[0], U8[1], U8[2], U8[3], U8[4], U8[5], U8[6], U8[7],
     102                        array_bit__0_,array_bit__1_,array_bit__2_,array_bit__3_,array_bit__4_,array_bit__5_,array_bit__6_,array_bit__7_);
    101103
    102                                 if(bitblock_has_bit(error_mask)) {
    103                                 errpos = block_pos + buf_pos + count_forward_zeroes(error_mask);
    104                                 fprintf(stderr, "error found at position %i\n",errpos);
    105           exit(-1);
    106                                 }
    107        
    108                                 block_pos += BLOCK_SIZE;
    109       }
    110     } else {
     104                        array_bit__0_ = simd_and(array_bit__0_, EOF_mask);
     105                        array_bit__1_ = simd_and(array_bit__1_, EOF_mask);
     106                        array_bit__2_ = simd_and(array_bit__2_, EOF_mask);
     107                        array_bit__3_ = simd_and(array_bit__3_, EOF_mask);
     108                        array_bit__4_ = simd_and(array_bit__4_, EOF_mask);
     109                        array_bit__5_ = simd_and(array_bit__5_, EOF_mask);
     110                        array_bit__6_ = simd_and(array_bit__6_, EOF_mask);
     111                        array_bit__7_ = simd_and(array_bit__7_, EOF_mask);
     112                       
     113                        @block_stmts
     114                       
     115                        if(bitblock_has_bit(error_mask)) {
     116                                err_pos = err_pos = buf_pos + (chars_read - chars_avail) + count_forward_zeroes(error_mask);
     117                                fprintf(stderr, "Error at position %i\n.", err_pos);
     118                                exit(-1);
     119                        }
     120                }
     121               
     122                PERF_SEC_END(perf_timer, chars_avail);
    111123
    112       while (block_pos < chars_avail){
    113        
    114                                 BytePack * U8 = (BytePack *) &srcbuf[block_pos];
    115        
    116                                 s2p(U8[0], U8[1], U8[2], U8[3], U8[4], U8[5], U8[6], U8[7],
    117                                 array_bit__0_,array_bit__1_,array_bit__2_,array_bit__3_,array_bit__4_,array_bit__5_,array_bit__6_,array_bit__7_);
     124                buf_pos += chars_read;
    118125
    119                                 @block_stmts
    120 
    121                                 if (bitblock_has_bit(error_mask)){
    122                                         errpos = block_pos + buf_pos + count_forward_zeroes(error_mask);
    123                                         fprintf(stderr, "error found at position %i\n",errpos);
    124                                                     exit(-1);
    125                                 }
    126        
    127                                 block_pos += BLOCK_SIZE;
    128       }
    129     }
    130 
    131     PERF_SEC_END(perf_timer, chars_avail);
    132 
    133     buf_pos += chars_avail;
    134 
    135     if (chars_avail!=chars_read){
    136       int bytes_left = chars_read-chars_avail;
    137       memmove(srcbuf, &srcbuf[BUFFER_SIZE], bytes_left);
    138       chars_read = fread(&srcbuf[bytes_left], 1, BUFFER_SIZE , infile) + bytes_left;
    139       chars_avail = min(chars_read,BUFFER_SIZE);
    140     } else {
    141       break;   
    142                 }
    143   }
     126                chars_read = fread(&srcbuf[buf_pos], 1, BUFFER_SIZE, infile);
     127                chars_avail = chars_read;
     128                if(ferror(infile)) { fprintf(stderr, "Failed to read input file.\n"); return; }
     129                if(chars_avail==0 && feof(infile)) { return; }
     130        }
    144131}
    145132
     
    158145        infile = fopen(infilename, "rb");
    159146        if (!infile) {
    160                 fprintf(stderr, "Error: cannot open %s for input.\n", infilename);
     147                fprintf(stderr, "Error: Cannot open %s for reading.\n", infilename);
    161148                exit(-1);
    162149        }
     
    168155                outfile = fopen(outfilename, "wb");
    169156                if (!outfile) {
    170                         fprintf(stderr, "Error: cannot open %s for writing.\n", outfilename);
     157                        fprintf(stderr, "Error: Cannot open %s for writing.\n", outfilename);
    171158                        exit(-1);
    172159                }
     
    183170        PERF_SEC_DESTROY(perf_timer);
    184171
    185   fclose(infile);
    186   fclose(outfile);
     172        fclose(infile);
     173        fclose(outfile);
    187174       
    188175        return(0);
Note: See TracChangeset for help on using the changeset viewer.