source: proto/parabix2/compiled/template.c @ 442

Last change on this file since 442 was 442, checked in by cameron, 9 years ago

Immediate error termination with first error.

File size: 8.8 KB
Line 
1#include <stdio.h>
2#include <stdlib.h>
3#include <errno.h>
4#include <sys/types.h>
5#include <sys/stat.h>
6#include "sse_simd.h"
7
8typedef SIMD_type BytePack;
9typedef SIMD_type BitBlock;
10
11#include "xmldecl.h"
12#include "xml_error.c"
13#include "xmldecl.c"
14
15#define BUFFER_PROFILING
16#include "perfsec.h"
17
18#ifdef BUFFER_PROFILING
19BOM_Table * parser_timer;
20#endif
21
22
23#define s2p_step(s0,s1,hi_mask,shift,p0,p1)  \
24{ \
25BitBlock t0,t1; \
26t0= simd_pack_16_hh(s0,s1) ; \
27t1= simd_pack_16_ll(s0,s1) ; \
28p0= simd_if(hi_mask,t0,simd_srli_16(t1,shift) ) ; \
29p1= simd_if(hi_mask,simd_slli_16(t0,shift) ,t1) ; \
30} \
31
32#define s2p_bytepack(s0,s1,s2,s3,s4,s5,s6,s7,p0,p1,p2,p3,p4,p5,p6,p7)  \
33{BitBlock bit00224466_0,bit00224466_1,bit00224466_2,bit00224466_3; \
34BitBlock bit11335577_0,bit11335577_1,bit11335577_2,bit11335577_3; \
35BitBlock bit00004444_0,bit22226666_0,bit00004444_1,bit22226666_1; \
36BitBlock bit11115555_0,bit33337777_0,bit11115555_1,bit33337777_1; \
37s2p_step(s0,s1,simd_himask_2,1,bit00224466_0,bit11335577_0)  \
38s2p_step(s2,s3,simd_himask_2,1,bit00224466_1,bit11335577_1)  \
39s2p_step(s4,s5,simd_himask_2,1,bit00224466_2,bit11335577_2)  \
40s2p_step(s6,s7,simd_himask_2,1,bit00224466_3,bit11335577_3)  \
41s2p_step(bit00224466_0,bit00224466_1,simd_himask_4,2,bit00004444_0,bit22226666_0)  \
42s2p_step(bit00224466_2,bit00224466_3,simd_himask_4,2,bit00004444_1,bit22226666_1)  \
43s2p_step(bit11335577_0,bit11335577_1,simd_himask_4,2,bit11115555_0,bit33337777_0)  \
44s2p_step(bit11335577_2,bit11335577_3,simd_himask_4,2,bit11115555_1,bit33337777_1)  \
45s2p_step(bit00004444_0,bit00004444_1,simd_himask_8,4,p0,p4)  \
46s2p_step(bit11115555_0,bit11115555_1,simd_himask_8,4,p1,p5)  \
47s2p_step(bit22226666_0,bit22226666_1,simd_himask_8,4,p2,p6)  \
48s2p_step(bit33337777_0,bit33337777_1,simd_himask_8,4,p3,p7)  \
49} \
50
51#define p2s_step(p0,p1,hi_mask,shift,s0,s1)  \
52{ \
53BitBlock t0,t1; \
54t0= simd_if(hi_mask,p0,simd_srli_16(p1,shift) ) ; \
55t1= simd_if(hi_mask,simd_slli_16(p0,shift) ,p1) ; \
56s0= simd_mergeh_8(t0,t1) ; \
57s1= simd_mergel_8(t0,t1) ; \
58} \
59
60#define p2s_bytemerge(p0,p1,p2,p3,p4,p5,p6,p7,s0,s1,s2,s3,s4,s5,s6,s7)  \
61{ \
62BitBlock bit00004444_0,bit22226666_0,bit00004444_1,bit22226666_1; \
63BitBlock bit11115555_0,bit33337777_0,bit11115555_1,bit33337777_1; \
64BitBlock bit00224466_0,bit00224466_1,bit00224466_2,bit00224466_3; \
65BitBlock bit11335577_0,bit11335577_1,bit11335577_2,bit11335577_3; \
66p2s_step(p0,p4,simd_himask_8,4,bit00004444_0,bit00004444_1)  \
67p2s_step(p1,p5,simd_himask_8,4,bit11115555_0,bit11115555_1)  \
68p2s_step(p2,p6,simd_himask_8,4,bit22226666_0,bit22226666_1)  \
69p2s_step(p3,p7,simd_himask_8,4,bit33337777_0,bit33337777_1)  \
70p2s_step(bit00004444_0,bit22226666_0,simd_himask_4,2,bit00224466_0,bit00224466_1)  \
71p2s_step(bit11115555_0,bit33337777_0,simd_himask_4,2,bit11335577_0,bit11335577_1)  \
72p2s_step(bit00004444_1,bit22226666_1,simd_himask_4,2,bit00224466_2,bit00224466_3)  \
73p2s_step(bit11115555_1,bit33337777_1,simd_himask_4,2,bit11335577_2,bit11335577_3)  \
74p2s_step(bit00224466_0,bit11335577_0,simd_himask_2,1,s0,s1)  \
75p2s_step(bit00224466_1,bit11335577_1,simd_himask_2,1,s2,s3)  \
76p2s_step(bit00224466_2,bit11335577_2,simd_himask_2,1,s4,s5)  \
77p2s_step(bit00224466_3,bit11335577_3,simd_himask_2,1,s6,s7)  \
78} \
79
80#define double_int64_adc(x1, x2, y1, y2, rslt1, rslt2, carry) \
81  __asm__  ("sahf\n\t" \
82        "adc %[e1], %[z1]\n\t" \
83        "adc %[e2], %[z2]\n\t" \
84        "lahf\n\t" \
85     : [z1] "=r" (rslt1), [z2] "=r" (rslt2), [carryflag] "=a" (carry) \
86         : "[z1]" (x1), "[z2]" (x2), \
87           [e1] "r" (y1), [e2] "r" (y2), \
88           "[carryflag]" (carry) \
89         : "cc")
90
91#define adc128(first, second, carry, sum) \
92do\
93{\
94  union {__m128i bitblock;\
95         uint64_t int64[2];} rslt;\
96\
97  union {__m128i bitblock;\
98         uint64_t int64[2];} x;\
99\
100  union {__m128i bitblock;\
101         uint64_t int64[2];} y;\
102\
103  x.bitblock = first;\
104  y.bitblock = second;\
105\
106  double_int64_adc(x.int64[0], x.int64[1], y.int64[0], y.int64[1], rslt.int64[0], rslt.int64[1], carry);\
107  sum = rslt.bitblock;\
108}while(0)
109
110
111
112#define double_int64_sbb(x1, x2, y1, y2, rslt1, rslt2, carry) \
113  __asm__  ("sahf\n\t" \
114        "sbb %[e1], %[z1]\n\t" \
115        "sbb %[e2], %[z2]\n\t" \
116        "lahf\n\t" \
117     : [z1] "=r" (rslt1), [z2] "=r" (rslt2), [carryflag] "=a" (carry) \
118         : "[z1]" (x1), "[z2]" (x2), \
119           [e1] "r" (y1), [e2] "r" (y2), \
120           "[carryflag]" (carry) \
121         : "cc")
122
123#define sbb128(first, second, carry, sum) \
124do\
125{ union {__m128i bitblock;\
126         uint64_t int64[2];} rslt;\
127\
128  union {__m128i bitblock;\
129         uint64_t int64[2];} x;\
130\
131  union {__m128i bitblock;\
132         uint64_t int64[2];} y;\
133\
134  x.bitblock = first;\
135  y.bitblock = second;\
136\
137  double_int64_sbb(x.int64[0], x.int64[1], y.int64[0], y.int64[1], \
138                   rslt.int64[0], rslt.int64[1], carry);\
139  sum = rslt.bitblock;\
140}while(0)
141
142       
143#define BUFFER_SIZE 12800   
144#define BLOCK_SIZE 128
145
146void do_process(FILE *infile, FILE *outfile) {
147
148  @decl
149
150  BytePack U8[8];
151  int buf_pos = 0;
152  int block_pos = 0;
153  int errpos = 0;
154  int chars_read = 0;
155  char * srcbuf;
156
157 
158  srcbuf = (char *) malloc(BUFFER_SIZE+BLOCK_SIZE);
159  if(!srcbuf){
160    printf("Can't allocate srcbuf!\n");
161    exit(-1);
162  }
163 
164  EOF_mask = simd_const_1(1);
165  chars_read = fread((void *)srcbuf, 1, BUFFER_SIZE, infile);
166
167  Entity_Info * e = new Entity_Info;
168  e->AnalyzeSignature((unsigned char *)srcbuf);
169  XML_Decl_Parser<ASCII> decl_parser((unsigned char *)srcbuf);
170
171  decl_parser.ReadXMLInfo(*e);
172
173  if (e->content_start != 0) {
174        memmove(&srcbuf[0], &srcbuf[e->content_start], chars_read - e->content_start);
175        if (chars_read == BUFFER_SIZE) {
176                chars_read = BUFFER_SIZE - e->content_start + 
177                             fread(&srcbuf[BUFFER_SIZE-e->content_start], 1, e->content_start, infile);
178        }
179  }
180 
181  @stream_stmts
182
183  while(chars_read>0){
184
185    PERF_SEC_START(parser_timer);
186
187    if(chars_read < BUFFER_SIZE){
188   
189      while (block_pos < chars_read){
190
191        int bytes = chars_read - block_pos;
192        if(bytes < BLOCK_SIZE){
193          EOF_mask = sisd_srl(simd_const_1(1),sisd_from_int(BLOCK_SIZE-bytes));
194        }
195        BytePack * U8pack = (BytePack *) &srcbuf[block_pos];
196        U8[0] = sisd_load_unaligned(&U8pack[0]);
197        U8[1] = sisd_load_unaligned(&U8pack[1]);
198        U8[2] = sisd_load_unaligned(&U8pack[2]);
199        U8[3] = sisd_load_unaligned(&U8pack[3]);
200        U8[4] = sisd_load_unaligned(&U8pack[4]);
201        U8[5] = sisd_load_unaligned(&U8pack[5]);
202        U8[6] = sisd_load_unaligned(&U8pack[6]);
203        U8[7] = sisd_load_unaligned(&U8pack[7]); 
204       
205        s2p_bytepack(U8[7], U8[6], U8[5], U8[4], U8[3], U8[2], U8[1], U8[0],
206        array_bit__0_,array_bit__1_,array_bit__2_,array_bit__3_,array_bit__4_,array_bit__5_,array_bit__6_,array_bit__7_);
207
208        array_bit__0_ &= EOF_mask;
209        array_bit__1_ &= EOF_mask;
210        array_bit__2_ &= EOF_mask;
211        array_bit__3_ &= EOF_mask;
212        array_bit__4_ &= EOF_mask;
213        array_bit__5_ &= EOF_mask;
214        array_bit__6_ &= EOF_mask;
215        array_bit__7_ &= EOF_mask;
216
217        @block_stmts
218
219        if (bitblock_has_bit(error_mask)) {
220          errpos = block_pos + buf_pos + count_forward_zeroes(error_mask);
221          fprintf(stderr, "error found at position %i\n",errpos);
222          exit(-1);
223        }
224       
225        block_pos += BLOCK_SIZE;
226      }
227    }
228    else{
229      while (block_pos < chars_read){
230
231        BytePack * U8pack = (BytePack *) &srcbuf[block_pos];
232        U8[0] = sisd_load_unaligned(&U8pack[0]);
233        U8[1] = sisd_load_unaligned(&U8pack[1]);
234        U8[2] = sisd_load_unaligned(&U8pack[2]);
235        U8[3] = sisd_load_unaligned(&U8pack[3]);
236        U8[4] = sisd_load_unaligned(&U8pack[4]);
237        U8[5] = sisd_load_unaligned(&U8pack[5]);
238        U8[6] = sisd_load_unaligned(&U8pack[6]);
239        U8[7] = sisd_load_unaligned(&U8pack[7]); 
240       
241        s2p_bytepack(U8[7], U8[6], U8[5], U8[4], U8[3], U8[2], U8[1], U8[0],
242        array_bit__0_,array_bit__1_,array_bit__2_,array_bit__3_,array_bit__4_,array_bit__5_,array_bit__6_,array_bit__7_);
243
244        @block_stmts
245       
246        if (bitblock_has_bit(error_mask)) {
247          errpos = block_pos + buf_pos + count_forward_zeroes(error_mask);
248          fprintf(stderr, "error found at position %i\n",errpos);
249          exit(-1);
250        }
251       
252        block_pos += BLOCK_SIZE;
253      }
254    }
255
256    PERF_SEC_END(parser_timer, chars_read);
257
258    buf_pos += chars_read;
259    chars_read = fread((void *)srcbuf, 1, BUFFER_SIZE, infile);
260    block_pos = 0;
261  }
262  free((void*)srcbuf);
263}
264
265
266
267int
268main(int argc, char * argv[]) {
269        char * infilename, * outfilename;       
270        FILE *infile, *outfile;
271        struct stat fileinfo;
272
273        if (argc < 2) {
274                printf("Usage: %s <filename> [<outputfile>]\n", argv[0]);
275                exit(-1);
276        }
277
278        infilename = argv[1];
279        stat(infilename, &fileinfo);
280        infile = fopen(infilename, "rb");
281        if (!infile) {
282                fprintf(stderr, "Error: cannot open %s for input.\n", infilename);
283                exit(-1);
284        }
285       
286        if (argc < 3) outfile = stdout;
287        else {
288                outfilename = argv[2];
289                outfile = fopen(outfilename, "wb");
290                if (!outfile) {
291                        fprintf(stderr, "Error: cannot open %s for writing.\n", outfilename);
292                        exit(-1);
293                }
294        }
295
296
297        PERF_SEC_INIT(parser_timer);
298
299        do_process(infile, outfile);
300       
301        PERF_SEC_DUMP(parser_timer);
302
303        fclose(infile);
304        fclose(outfile);
305        return(0);
306}
Note: See TracBrowser for help on using the repository browser.