Changeset 645


Ignore:
Timestamp:
Oct 2, 2010, 5:52:00 PM (9 years ago)
Author:
ksherdy
Message:

Boilerplate template.c file.

File:
1 edited

Legend:

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

    r636 r645  
     1#include <string.h>
    12#include <stdio.h>
    23#include <stdlib.h>
     
    45#include <sys/types.h>
    56#include <sys/stat.h>
    6 #include "sse_simd.h"
    7 #define minimum(x,y) ((x) <(y) ?(x) :(y) )  \
     7#include "../lib/lib_simd.h"
     8#include "../lib/block_carry.h"
    89
     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
    915
    1016typedef SIMD_type BytePack;
    1117typedef SIMD_type BitBlock;
    1218
    13 #if (defined(BUFFER_PROFILING) || defined(CODE_CLOCKER))
    14   #include "perfsec.h"
    15 #endif
     19#include "../lib/perflib/perfsec.h"
     20#include "../lib/s2p.h"
    1621
    1722#ifdef BUFFER_PROFILING
    18   BOM_Table * parser_timer;
    19 #endif
    20 
    21 #ifdef CODE_CLOCKER
     23        BOM_Table * perf_timer;
     24#elif CODE_CLOCKER
    2225        #define NUM_EVENTS 1
    2326        int Events[NUM_EVENTS] = {PAPI_TOT_CYC};
     
    2528        //int Events[NUM_EVENTS] = {PAPI_TOT_CYC, PAPI_BR_MSP};
    2629        int cal_size = 20;
    27         CC * parser_timer = new CC(Events,NUM_EVENTS,cal_size);
     30        CC * perf_timer = new CC(Events,NUM_EVENTS,cal_size);
     31#else
     32        void * perf_timer;
    2833#endif
    29 
    30 #define s2p_step(s0,s1,hi_mask,shift,p0,p1)  \
    31 { \
    32 BitBlock t0,t1; \
    33 t0= simd_pack_16_hh(s0,s1) ; \
    34 t1= simd_pack_16_ll(s0,s1) ; \
    35 p0= simd_if(hi_mask,t0,simd_srli_16(t1,shift) ) ; \
    36 p1= simd_if(hi_mask,simd_slli_16(t0,shift) ,t1) ; \
    37 } \
    38 
    39 #define s2p_bytepack(s0,s1,s2,s3,s4,s5,s6,s7,p0,p1,p2,p3,p4,p5,p6,p7)  \
    40 {BitBlock bit00224466_0,bit00224466_1,bit00224466_2,bit00224466_3; \
    41 BitBlock bit11335577_0,bit11335577_1,bit11335577_2,bit11335577_3; \
    42 BitBlock bit00004444_0,bit22226666_0,bit00004444_1,bit22226666_1; \
    43 BitBlock bit11115555_0,bit33337777_0,bit11115555_1,bit33337777_1; \
    44 s2p_step(s0,s1,simd_himask_2,1,bit00224466_0,bit11335577_0)  \
    45 s2p_step(s2,s3,simd_himask_2,1,bit00224466_1,bit11335577_1)  \
    46 s2p_step(s4,s5,simd_himask_2,1,bit00224466_2,bit11335577_2)  \
    47 s2p_step(s6,s7,simd_himask_2,1,bit00224466_3,bit11335577_3)  \
    48 s2p_step(bit00224466_0,bit00224466_1,simd_himask_4,2,bit00004444_0,bit22226666_0)  \
    49 s2p_step(bit00224466_2,bit00224466_3,simd_himask_4,2,bit00004444_1,bit22226666_1)  \
    50 s2p_step(bit11335577_0,bit11335577_1,simd_himask_4,2,bit11115555_0,bit33337777_0)  \
    51 s2p_step(bit11335577_2,bit11335577_3,simd_himask_4,2,bit11115555_1,bit33337777_1)  \
    52 s2p_step(bit00004444_0,bit00004444_1,simd_himask_8,4,p0,p4)  \
    53 s2p_step(bit11115555_0,bit11115555_1,simd_himask_8,4,p1,p5)  \
    54 s2p_step(bit22226666_0,bit22226666_1,simd_himask_8,4,p2,p6)  \
    55 s2p_step(bit33337777_0,bit33337777_1,simd_himask_8,4,p3,p7)  \
    56 } \
    57 
    58 #define p2s_step(p0,p1,hi_mask,shift,s0,s1)  \
    59 { \
    60 BitBlock t0,t1; \
    61 t0= simd_if(hi_mask,p0,simd_srli_16(p1,shift) ) ; \
    62 t1= simd_if(hi_mask,simd_slli_16(p0,shift) ,p1) ; \
    63 s0= simd_mergeh_8(t0,t1) ; \
    64 s1= simd_mergel_8(t0,t1) ; \
    65 } \
    66 
    67 #define p2s_bytemerge(p0,p1,p2,p3,p4,p5,p6,p7,s0,s1,s2,s3,s4,s5,s6,s7)  \
    68 { \
    69 BitBlock bit00004444_0,bit22226666_0,bit00004444_1,bit22226666_1; \
    70 BitBlock bit11115555_0,bit33337777_0,bit11115555_1,bit33337777_1; \
    71 BitBlock bit00224466_0,bit00224466_1,bit00224466_2,bit00224466_3; \
    72 BitBlock bit11335577_0,bit11335577_1,bit11335577_2,bit11335577_3; \
    73 p2s_step(p0,p4,simd_himask_8,4,bit00004444_0,bit00004444_1)  \
    74 p2s_step(p1,p5,simd_himask_8,4,bit11115555_0,bit11115555_1)  \
    75 p2s_step(p2,p6,simd_himask_8,4,bit22226666_0,bit22226666_1)  \
    76 p2s_step(p3,p7,simd_himask_8,4,bit33337777_0,bit33337777_1)  \
    77 p2s_step(bit00004444_0,bit22226666_0,simd_himask_4,2,bit00224466_0,bit00224466_1)  \
    78 p2s_step(bit11115555_0,bit33337777_0,simd_himask_4,2,bit11335577_0,bit11335577_1)  \
    79 p2s_step(bit00004444_1,bit22226666_1,simd_himask_4,2,bit00224466_2,bit00224466_3)  \
    80 p2s_step(bit11115555_1,bit33337777_1,simd_himask_4,2,bit11335577_2,bit11335577_3)  \
    81 p2s_step(bit00224466_0,bit11335577_0,simd_himask_2,1,s0,s1)  \
    82 p2s_step(bit00224466_1,bit11335577_1,simd_himask_2,1,s2,s3)  \
    83 p2s_step(bit00224466_2,bit11335577_2,simd_himask_2,1,s4,s5)  \
    84 p2s_step(bit00224466_3,bit11335577_3,simd_himask_2,1,s6,s7)  \
    85 } \
    86 
    87      
    88 
    89        
    90 #define BUFFER_SIZE 12800   
    91 #define BLOCK_SIZE 128
    9234
    9335void do_process(FILE *infile, FILE *outfile) {
    9436
    95 @decl
     37        @decl
     38
     39        /* Expected compiler generated stream variables */
     40        /*
     41        BitBlock EOF_mask;
     42        BitBlock array_bit__0_;
     43  BitBlock array_bit__1_;
     44        BitBlock array_bit__2_;
     45        BitBlock array_bit__3_;
     46        BitBlock array_bit__4_;
     47        BitBlock array_bit__5_;
     48        BitBlock array_bit__6_;
     49        BitBlock array_bit__7_;
     50        BitBlock error_mask;
     51        */
    9652
    9753  BytePack U8[8];
     
    9955  int block_pos = 0;
    10056  int errpos = 0;
     57  int chars_avail = 0;
     58  int check_pos = 0;
    10159  int chars_read = 0;
    102   int bytes = 0;
    103   char * srcbuf;
    104   char * srclimit;
     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
    10569
     70  while(1){
    10671
    107  
    108   srcbuf = (char *) malloc(BUFFER_SIZE+BLOCK_SIZE);
    109   if(!srcbuf){
    110     printf("Can't allocate srcbuf!\n");
    111     exit(-1);
    112   }
    113  
    114   chars_read = fread((void *)srcbuf, 1, BUFFER_SIZE, infile);
    115   srclimit = srcbuf + chars_read;
     72    PERF_SEC_START(perf_timer);
    11673
    117 @stream_stmts
     74    block_pos = 0;
    11875
    119   while(chars_read>0){
     76    if(chars_avail < BUFFER_SIZE){
     77     
     78      while (block_pos <= chars_avail){
    12079
    121     PERF_SEC_START(parser_timer);
     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];
    12287       
    123     while (&srcbuf[block_pos] < srclimit){
    124      
    125       bytes = minimum(srclimit-&srcbuf[block_pos],BLOCK_SIZE);
    126       if(bytes < BLOCK_SIZE){
    127         EOF_mask = sisd_srl(simd_const_1(1),sisd_from_int(BLOCK_SIZE-bytes));
     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_);
     90
     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);
     99
     100                                @block_stmts
     101
     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;
    128109      }
    129       BytePack * U8pack = (BytePack *) &srcbuf[block_pos];
    130       U8[0] = sisd_load_unaligned(&U8pack[0]);
    131       U8[1] = sisd_load_unaligned(&U8pack[1]);
    132       U8[2] = sisd_load_unaligned(&U8pack[2]);
    133       U8[3] = sisd_load_unaligned(&U8pack[3]);
    134       U8[4] = sisd_load_unaligned(&U8pack[4]);
    135       U8[5] = sisd_load_unaligned(&U8pack[5]);
    136       U8[6] = sisd_load_unaligned(&U8pack[6]);
    137       U8[7] = sisd_load_unaligned(&U8pack[7]);
    138      
    139       s2p_bytepack(U8[7], U8[6], U8[5], U8[4], U8[3], U8[2], U8[1], U8[0],
    140       array_bit__0_,array_bit__1_,array_bit__2_,array_bit__3_,array_bit__4_,array_bit__5_,array_bit__6_,array_bit__7_);
     110    } else {
    141111
    142       array_bit__0_ &= EOF_mask;
    143       array_bit__1_ &= EOF_mask;
    144       array_bit__2_ &= EOF_mask;
    145       array_bit__3_ &= EOF_mask;
    146       array_bit__4_ &= EOF_mask;
    147       array_bit__5_ &= EOF_mask;
    148       array_bit__6_ &= EOF_mask;
    149       array_bit__7_ &= EOF_mask;
     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_);
    150118
    151       @block_stmts
     119                                @block_stmts
    152120
    153      
    154       if (bitblock_has_bit(error_mask)) {
    155         errpos = block_pos + buf_pos + count_forward_zeroes(error_mask);
    156         fprintf(stderr, "error found at position %i\n",errpos);
     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;
    157128      }
    158      
    159       block_pos += BLOCK_SIZE;
    160       bytes = minimum(srclimit-&srcbuf[block_pos],BLOCK_SIZE);
    161129    }
    162130
    163     PERF_SEC_END(parser_timer, chars_read);
     131    PERF_SEC_END(perf_timer, chars_avail);
    164132
    165     buf_pos += chars_read;
    166     chars_read = fread((void *)srcbuf, 1, BUFFER_SIZE, infile);
    167     block_pos = 0;
    168     srclimit = srcbuf + chars_read;
     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                }
    169143  }
    170   free((void*)srcbuf);
    171144}
    172145
    173 
    174 
    175 int
    176 main(int argc, char * argv[]) {
     146int main(int argc, char * argv[]) {
    177147        char * infilename, * outfilename;       
    178148        FILE *infile, *outfile;
     
    192162        }
    193163       
    194         if (argc < 3) outfile = stdout;
    195         else {
     164        if (argc < 3) {
     165                outfile = stdout;
     166        }       else {
    196167                outfilename = argv[2];
    197168                outfile = fopen(outfilename, "wb");
     
    202173        }
    203174
     175        // PERF_SEC_BIND(1);
    204176
    205         PERF_SEC_INIT(parser_timer);
     177        PERF_SEC_INIT(perf_timer);
    206178
    207179        do_process(infile, outfile);
    208180       
    209         PERF_SEC_DUMP(parser_timer);
     181        PERF_SEC_DUMP(perf_timer);
     182       
     183        PERF_SEC_DESTROY(perf_timer);
    210184
    211         PERF_SEC_DESTROY(parser_timer);
     185  fclose(infile);
     186  fclose(outfile);
    212187       
    213         fclose(infile);
    214         fclose(outfile);
    215188        return(0);
    216189}
Note: See TracChangeset for help on using the changeset viewer.