source: proto/FIX/fix_template.cpp @ 1318

Last change on this file since 1318 was 1318, checked in by cameron, 8 years ago

Add error report postprocessing

File size: 5.7 KB
Line 
1#include <stdio.h>
2#include <string.h>
3#include <stdlib.h>
4#include <errno.h>
5#include <sys/types.h>
6#include <sys/stat.h>
7#include "../lib/lib_simd.h"
8
9#define BLOCK_SIZE (sizeof(SIMD_type) * 8)
10#define SEGMENT_BLOCKS 12
11#define BUFFER_SIZE (BLOCK_SIZE * SEGMENT_BLOCKS)
12#define OVERLAP_BUFSIZE (sizeof(SIMD_type))
13
14typedef long ScanBlock;
15typedef SIMD_type BytePack;
16typedef SIMD_type BitBlock;
17
18#include "../lib/carryQ.h"
19
20#include "../lib/perflib/perfsec.h"
21#include "../lib/s2p.h"
22
23#ifdef BUFFER_PROFILING
24        BOM_Table * parser_timer;
25
26#elif CODE_CLOCKER
27        #define NUM_EVENTS 1
28        int Events[NUM_EVENTS] = {PAPI_TOT_CYC};
29        //int Events[NUM_EVENTS] = {PAPI_L2_DCM};
30        //int Events[NUM_EVENTS] = {PAPI_TOT_CYC, PAPI_BR_MSP};
31        int cal_size = 20;
32        CC * parser_timer = new CC(Events,NUM_EVENTS,cal_size);
33#else
34        void * parser_timer;
35#endif
36
37int block_base=0;
38int buffer_base=0;
39int buffer_last;
40char * source;
41
42
43static inline void ReportError(const char * error_msg, int error_pos_in_block) {
44  fprintf(stderr, "%s at position %i\n", error_msg, block_base + error_pos_in_block);
45}
46
47class ErrorTracker {
48public:
49        ErrorTracker() { noted_pos_in_block = -1;}
50
51        inline void NoteError(const char * error_msg, BitBlock err_strm) {
52          int pos_in_block = count_forward_zeroes(err_strm);
53          if ((noted_pos_in_block == -1) || (noted_pos_in_block > pos_in_block)) {
54            noted_pos_in_block = pos_in_block;
55            noted_error = error_msg;
56          }
57        }
58
59        inline void If_Error_Report_First() {
60          if (noted_pos_in_block > -1) {
61                  int error_line, error_column;
62                  ReportError(noted_error, noted_pos_in_block);
63                  exit(-1);
64          }
65        }
66 
67private:
68  const char * noted_error;
69  int noted_pos_in_block;       
70};
71
72
73BitBlock EOF_mask = simd_const_1(1);
74
75ErrorTracker error_tracker;
76
77
78
79@global
80
81static inline void s2p_do_block(BytePack U8[], Basis_bits & basis_bits) {
82  s2p(U8[0], U8[1], U8[2], U8[3], U8[4], U8[5], U8[6], U8[7],
83        basis_bits.bit_0, basis_bits.bit_1, basis_bits.bit_2, basis_bits.bit_3, basis_bits.bit_4, basis_bits.bit_5, basis_bits.bit_6, basis_bits.bit_7);
84}
85
86static inline void s2p_do_final_block(BytePack U8[], Basis_bits & basis_bits, BitBlock EOF_mask) {
87  s2p_do_block(U8, basis_bits);
88  basis_bits.bit_0 = simd_and(basis_bits.bit_0, EOF_mask);
89  basis_bits.bit_1 = simd_and(basis_bits.bit_1, EOF_mask);
90  basis_bits.bit_2 = simd_and(basis_bits.bit_2, EOF_mask);
91  basis_bits.bit_3 = simd_and(basis_bits.bit_3, EOF_mask);
92  basis_bits.bit_4 = simd_and(basis_bits.bit_4, EOF_mask);
93  basis_bits.bit_5 = simd_and(basis_bits.bit_5, EOF_mask);
94  basis_bits.bit_6 = simd_and(basis_bits.bit_6, EOF_mask);
95  basis_bits.bit_7 = simd_and(basis_bits.bit_7, EOF_mask);
96}
97
98static inline void postprocess_do_block(Fix_lex & fix_lex, Fix_callout & Fix_callout, int chars_avail){
99                error_tracker.If_Error_Report_First();
100}
101
102void do_process(FILE *infile, FILE *outfile) {
103
104@decl
105
106  int buf_pos = 0;
107  int block_pos = 0;
108  int errpos = 0;
109  int chars_avail = 0;
110  int check_pos = 0;
111  int chars_read = 0;
112  BytePack buf[(BUFFER_SIZE+BLOCK_SIZE+OVERLAP_BUFSIZE*2)/sizeof(SIMD_type)];
113
114  char * srcbuf = ((char *) buf) + OVERLAP_BUFSIZE;
115  buffer_base = buf_pos;
116  source = srcbuf;
117
118  chars_read = fread((void *)srcbuf, 1, BUFFER_SIZE + OVERLAP_BUFSIZE, infile);
119  chars_avail = chars_read;
120  if (chars_avail > BUFFER_SIZE) chars_avail = BUFFER_SIZE;
121
122
123@stream_stmts
124
125/* Full Buffers */
126
127    while (chars_avail == BUFFER_SIZE) {
128      PERF_SEC_START(parser_timer);
129      for (int blk = 0; blk < SEGMENT_BLOCKS; blk++) {
130          block_base = blk*BLOCK_SIZE;
131          s2p_do_block((BytePack *) &srcbuf[block_base], basis_bits);
132          @block_stmts
133          postprocess_do_block(fix_lex, fix_callout, chars_avail);
134      }
135      PERF_SEC_END(parser_timer, chars_avail);
136           
137      int bytes_left = chars_read - chars_avail;
138      memmove(srcbuf, &srcbuf[BUFFER_SIZE], bytes_left);
139      chars_read = fread(&srcbuf[bytes_left],1, BUFFER_SIZE + OVERLAP_BUFSIZE - bytes_left, infile) + bytes_left;
140      chars_avail = chars_read;
141      if (chars_avail > BUFFER_SIZE) chars_avail = BUFFER_SIZE;
142      buf_pos += chars_avail;
143      buffer_base = buf_pos;
144    }
145/* Final Partial Buffer */
146    PERF_SEC_START(parser_timer);
147
148    block_pos = 0;
149    int remaining = chars_avail;
150/* Full Blocks */
151    while (remaining >= BLOCK_SIZE) {
152          block_base = block_pos;
153          s2p_do_block((BytePack *) &srcbuf[block_pos], basis_bits);
154          @block_stmts
155          postprocess_do_block(fix_lex, fix_callout, chars_avail);
156          block_pos += BLOCK_SIZE;
157          remaining -= BLOCK_SIZE;
158    }
159    block_base = block_pos;
160    if (remaining > 0 || @any_carry) {
161          EOF_mask = sisd_srl(simd_const_1(1),sisd_from_int(BLOCK_SIZE-remaining));
162          s2p_do_final_block((BytePack *) &srcbuf[block_pos], basis_bits, EOF_mask);
163          @final_block_stmts
164          postprocess_do_block(fix_lex, fix_callout, chars_avail);
165    }
166    buf_pos += chars_avail;
167    buffer_base = buf_pos;
168
169
170    PERF_SEC_END(parser_timer, chars_avail);
171}
172
173
174
175int
176main(int argc, char * argv[]) {
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//      PERF_SEC_BIND(1);
205
206        PERF_SEC_INIT(parser_timer);
207
208        do_process(infile, outfile);
209
210        PERF_SEC_DUMP(parser_timer);
211
212        PERF_SEC_DESTROY(parser_timer);
213
214        fclose(infile);
215        fclose(outfile);
216        return(0);
217}
Note: See TracBrowser for help on using the repository browser.