Changeset 636 for proto/Compiler


Ignore:
Timestamp:
Oct 1, 2010, 12:28:01 PM (9 years ago)
Author:
ksherdy
Message:

Delete p-workspace directory. Performance timing code inclusion is macro controlled and located in a single central directory.

Location:
proto/Compiler
Files:
1 deleted
1 edited

Legend:

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

    r433 r636  
    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
     
    811typedef SIMD_type BitBlock;
    912
    10 
    11 
     13#if (defined(BUFFER_PROFILING) || defined(CODE_CLOCKER))
     14  #include "perfsec.h"
     15#endif
     16
     17#ifdef BUFFER_PROFILING
     18  BOM_Table * parser_timer;
     19#endif
     20
     21#ifdef CODE_CLOCKER
     22        #define NUM_EVENTS 1
     23        int Events[NUM_EVENTS] = {PAPI_TOT_CYC};
     24        //int Events[NUM_EVENTS] = {PAPI_L2_DCM};
     25        //int Events[NUM_EVENTS] = {PAPI_TOT_CYC, PAPI_BR_MSP};
     26        int cal_size = 20;
     27        CC * parser_timer = new CC(Events,NUM_EVENTS,cal_size);
     28#endif
    1229
    1330#define s2p_step(s0,s1,hi_mask,shift,p0,p1)  \
     
    6986
    7087     
     88
     89       
     90#define BUFFER_SIZE 12800   
    7191#define BLOCK_SIZE 128
    7292
     
    7696
    7797  BytePack U8[8];
    78 //  BitBlock u8bit[8];
    79 
     98  int buf_pos = 0;
    8099  int block_pos = 0;
    81 
    82   int chars_read = fread(&U8[0], 1, BLOCK_SIZE, infile);
     100  int errpos = 0;
     101  int chars_read = 0;
     102  int bytes = 0;
     103  char * srcbuf;
     104  char * srclimit;
     105
     106
     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;
    83116
    84117@stream_stmts
    85   while (chars_read > 0) {
    86     sisd_srl(EOF_mask, sisd_from_int(128-chars_read));
    87 
    88     s2p_bytepack(U8[7], U8[6], U8[5], U8[4], U8[3], U8[2], U8[1], U8[0],
    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_ &= EOF_mask;
    92 array_bit__1_ &= EOF_mask;
    93 array_bit__2_ &= EOF_mask;
    94 array_bit__3_ &= EOF_mask;
    95 array_bit__4_ &= EOF_mask;
    96 array_bit__5_ &= EOF_mask;
    97 array_bit__6_ &= EOF_mask;
    98 array_bit__7_ &= EOF_mask;
    99 
    100 @block_stmts
    101 
    102     if (bitblock_has_bit(error_mask)) {
    103       int errpos = count_forward_zeroes(error_mask);
    104       fprintf(stderr, "Error at byte #%i\n", block_pos + errpos);
     118
     119  while(chars_read>0){
     120
     121    PERF_SEC_START(parser_timer);
     122       
     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));
     128      }
     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_);
     141
     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;
     150
     151      @block_stmts
     152
     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);
     157      }
     158     
     159      block_pos += BLOCK_SIZE;
     160      bytes = minimum(srclimit-&srcbuf[block_pos],BLOCK_SIZE);
    105161    }
    106     block_pos += BLOCK_SIZE;
    107     chars_read = fread(&U8[0], 1, BLOCK_SIZE, infile);
     162
     163    PERF_SEC_END(parser_timer, chars_read);
     164
     165    buf_pos += chars_read;
     166    chars_read = fread((void *)srcbuf, 1, BUFFER_SIZE, infile);
     167    block_pos = 0;
     168    srclimit = srcbuf + chars_read;
    108169  }
    109 
    110   fclose(infile);
    111   fclose(outfile);
     170  free((void*)srcbuf);
    112171}
    113 
    114172
    115173
     
    117175int
    118176main(int argc, char * argv[]) {
    119   if (argc < 2) {
    120     printf("Usage: %s <filename> [<outputfile>]\n", argv[0]);
    121           exit(-1);
    122   }
    123   char * filename = argv[1];
    124 #ifdef BUFFER_PROFILING
    125   transcode_timer = init_BOM_timer(BUFFER_SIZE);
    126 #endif
    127   FILE *infile, *outfile;
    128   infile = fopen(filename, "rb");
    129   if (!infile) {
    130       fprintf(stderr, "Error: cannot open %s for input.\n", filename);
    131       exit(-1);
    132   }
    133 
    134   if (argc < 3) outfile = stdout;
    135   else {
    136     outfile = fopen(argv[2], "wb");
    137     if (!outfile) {
    138       fprintf(stderr, "Error: cannot open %s for writing.\n", argv[2]);
    139       exit(-1);
    140     }
    141   }
    142 
    143   do_process(infile, outfile);
    144 
    145 #ifdef BUFFER_PROFILING
    146   printf("Buffer conversion timing.\n");
    147   dump_BOM_table(transcode_timer);
    148 #endif
    149   return(0);
     177        char * infilename, * outfilename;       
     178        FILE *infile, *outfile;
     179        struct stat fileinfo;
     180
     181        if (argc < 2) {
     182                printf("Usage: %s <filename> [<outputfile>]\n", argv[0]);
     183                exit(-1);
     184        }
     185
     186        infilename = argv[1];
     187        stat(infilename, &fileinfo);
     188        infile = fopen(infilename, "rb");
     189        if (!infile) {
     190                fprintf(stderr, "Error: cannot open %s for input.\n", infilename);
     191                exit(-1);
     192        }
     193       
     194        if (argc < 3) outfile = stdout;
     195        else {
     196                outfilename = argv[2];
     197                outfile = fopen(outfilename, "wb");
     198                if (!outfile) {
     199                        fprintf(stderr, "Error: cannot open %s for writing.\n", outfilename);
     200                        exit(-1);
     201                }
     202        }
     203
     204
     205        PERF_SEC_INIT(parser_timer);
     206
     207        do_process(infile, outfile);
     208       
     209        PERF_SEC_DUMP(parser_timer);
     210
     211        PERF_SEC_DESTROY(parser_timer);
     212       
     213        fclose(infile);
     214        fclose(outfile);
     215        return(0);
    150216}
Note: See TracChangeset for help on using the changeset viewer.