Changeset 418


Ignore:
Timestamp:
Jun 28, 2010, 2:41:16 PM (9 years ago)
Author:
lindanl
Message:

Buffered process with profiling

File:
1 edited

Legend:

Unmodified
Added
Removed
  • proto/Compiler/template.c

    r410 r418  
    22#include <stdlib.h>
    33#include <errno.h>
     4#include <sys/types.h>
     5#include <sys/stat.h>
    46#include "sse_simd.h"
     7#define minimum(x,y) ((x) <(y) ?(x) :(y) )  \
    58
    69
     
    912
    1013
    11 // Profiling
     14#define BUFFER_PROFILING
    1215
    1316#ifdef BUFFER_PROFILING
    14 #include "../Profiling/BOM_Profiler.c"
    15 BOM_Table * transcode_timer;
     17#include "perfsec.h"
     18BOM_Table * parser_timer;
    1619#endif
    1720
     
    137140
    138141       
    139            
     142#define BUFFER_SIZE 12800   
    140143#define BLOCK_SIZE 128
    141144
     
    145148
    146149  BytePack U8[8];
    147 //  BitBlock u8bit[8];
    148 
     150  int buf_pos = 0;
    149151  int block_pos = 0;
    150 
    151   int chars_read = fread(&U8[0], 1, BLOCK_SIZE, infile);
    152   while (chars_read > 0) {
    153     sisd_srl(EOF_mask, sisd_from_int(128-chars_read));
    154 
    155     s2p_bytepack(U8[7], U8[6], U8[5], U8[4], U8[3], U8[2], U8[1], U8[0],
    156     array_bit__0_,array_bit__1_,array_bit__2_,array_bit__3_,array_bit__4_,array_bit__5_,array_bit__6_,array_bit__7_);
    157 
    158 array_bit__0_ &= EOF_mask;
    159 array_bit__1_ &= EOF_mask;
    160 array_bit__2_ &= EOF_mask;
    161 array_bit__3_ &= EOF_mask;
    162 array_bit__4_ &= EOF_mask;
    163 array_bit__5_ &= EOF_mask;
    164 array_bit__6_ &= EOF_mask;
    165 array_bit__7_ &= EOF_mask;
    166 
    167     @stmts
    168 
    169     if (bitblock_has_bit(error_mask)) {
    170       int errpos = count_forward_zeroes(error_mask);
    171       fprintf(stderr, "Error at byte #%i\n", block_pos + errpos);
     152  int errpos = 0;
     153  int chars_read = 0;
     154  int bytes = 0;
     155  char * srcbuf;
     156  char * srclimit;
     157
     158 
     159  srcbuf = (char *) malloc(BUFFER_SIZE+BLOCK_SIZE);
     160  if(!srcbuf){
     161    printf("Can't allocate srcbuf!\n");
     162    exit(-1);
     163  }
     164 
     165  EOF_mask = simd_const_1(1);
     166  chars_read = fread((void *)srcbuf, 1, BUFFER_SIZE, infile);
     167  srclimit = srcbuf + chars_read;
     168
     169  while(chars_read>0){
     170
     171    PERF_SEC_START(parser_timer);
     172       
     173    while (&srcbuf[block_pos] < srclimit){
     174     
     175      bytes = minimum(srclimit-&srcbuf[block_pos],BLOCK_SIZE);
     176      if(bytes < BLOCK_SIZE){
     177        EOF_mask = sisd_srl(simd_const_1(1),sisd_from_int(BLOCK_SIZE-bytes));
     178      }
     179      BytePack * U8pack = (BytePack *) &srcbuf[block_pos];
     180      U8[0] = sisd_load_unaligned(&U8pack[0]);
     181      U8[1] = sisd_load_unaligned(&U8pack[1]);
     182      U8[2] = sisd_load_unaligned(&U8pack[2]);
     183      U8[3] = sisd_load_unaligned(&U8pack[3]);
     184      U8[4] = sisd_load_unaligned(&U8pack[4]);
     185      U8[5] = sisd_load_unaligned(&U8pack[5]);
     186      U8[6] = sisd_load_unaligned(&U8pack[6]);
     187      U8[7] = sisd_load_unaligned(&U8pack[7]);
     188     
     189      s2p_bytepack(U8[7], U8[6], U8[5], U8[4], U8[3], U8[2], U8[1], U8[0],
     190      array_bit__0_,array_bit__1_,array_bit__2_,array_bit__3_,array_bit__4_,array_bit__5_,array_bit__6_,array_bit__7_);
     191
     192      array_bit__0_ &= EOF_mask;
     193      array_bit__1_ &= EOF_mask;
     194      array_bit__2_ &= EOF_mask;
     195      array_bit__3_ &= EOF_mask;
     196      array_bit__4_ &= EOF_mask;
     197      array_bit__5_ &= EOF_mask;
     198      array_bit__6_ &= EOF_mask;
     199      array_bit__7_ &= EOF_mask;
     200
     201      @stmts
     202
     203      if (bitblock_has_bit(error_mask)) {
     204        errpos = block_pos + buf_pos + count_forward_zeroes(error_mask);
     205        fprintf(stderr, "error found at position %i\n",errpos);
     206      }
     207     
     208      block_pos += BLOCK_SIZE;
     209      bytes = minimum(srclimit-&srcbuf[block_pos],BLOCK_SIZE);
    172210    }
    173     block_pos += BLOCK_SIZE;
    174     chars_read = fread(&U8[0], 1, BLOCK_SIZE, infile);
     211
     212    PERF_SEC_END(parser_timer, chars_read);
     213
     214    buf_pos += chars_read;
     215    chars_read = fread((void *)srcbuf, 1, BUFFER_SIZE, infile);
     216    block_pos = 0;
     217    srclimit = srcbuf + chars_read;
    175218  }
    176 
    177   fclose(infile);
    178   fclose(outfile);
     219  free((void*)srcbuf);
    179220}
    180 
    181221
    182222
     
    184224int
    185225main(int argc, char * argv[]) {
    186   if (argc < 2) {
    187     printf("Usage: %s <filename> [<outputfile>]\n", argv[0]);
    188           exit(-1);
    189   }
    190   char * filename = argv[1];
    191 #ifdef BUFFER_PROFILING
    192   transcode_timer = init_BOM_timer(BUFFER_SIZE);
    193 #endif
    194   FILE *infile, *outfile;
    195   infile = fopen(filename, "rb");
    196   if (!infile) {
    197       fprintf(stderr, "Error: cannot open %s for input.\n", filename);
    198       exit(-1);
    199   }
    200 
    201   if (argc < 3) outfile = stdout;
    202   else {
    203     outfile = fopen(argv[2], "wb");
    204     if (!outfile) {
    205       fprintf(stderr, "Error: cannot open %s for writing.\n", argv[2]);
    206       exit(-1);
    207     }
    208   }
    209 
    210   do_process(infile, outfile);
    211 
    212 #ifdef BUFFER_PROFILING
    213   printf("Buffer conversion timing.\n");
    214   dump_BOM_table(transcode_timer);
    215 #endif
    216   return(0);
     226        char * infilename, * outfilename;       
     227        FILE *infile, *outfile;
     228        struct stat fileinfo;
     229
     230        if (argc < 2) {
     231                printf("Usage: %s <filename> [<outputfile>]\n", argv[0]);
     232                exit(-1);
     233        }
     234
     235        infilename = argv[1];
     236        stat(infilename, &fileinfo);
     237        infile = fopen(infilename, "rb");
     238        if (!infile) {
     239                fprintf(stderr, "Error: cannot open %s for input.\n", infilename);
     240                exit(-1);
     241        }
     242       
     243        if (argc < 3) outfile = stdout;
     244        else {
     245                outfilename = argv[2];
     246                outfile = fopen(outfilename, "wb");
     247                if (!outfile) {
     248                        fprintf(stderr, "Error: cannot open %s for writing.\n", outfilename);
     249                        exit(-1);
     250                }
     251        }
     252
     253
     254        PERF_SEC_INIT(parser_timer);
     255
     256        do_process(infile, outfile);
     257       
     258        PERF_SEC_DUMP(parser_timer);
     259
     260        fclose(infile);
     261        fclose(outfile);
     262        return(0);
    217263}
Note: See TracChangeset for help on using the changeset viewer.