source: proto/parabix2/template.c @ 557

Last change on this file since 557 was 557, checked in by ksherdy, 9 years ago

Added functionality to programmatically bind a process to a core.

File size: 11.7 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 "../lib/lib_simd.h"
7#include "../lib/block_carry.h"
8
9typedef SIMD_type BytePack;
10typedef SIMD_type BitBlock;
11
12#include "xmldecl.h"
13#include "xml_error.c"
14#include "xmldecl.c"
15#include "namechars.h"
16
17#include "../lib/perflib/perfsec.h"
18
19#ifdef BUFFER_PROFILING
20        BOM_Table * parser_timer;
21
22#elif CODE_CLOCKER
23        #define NUM_EVENTS 1
24        int Events[NUM_EVENTS] = {PAPI_TOT_CYC};
25        //int Events[NUM_EVENTS] = {PAPI_L2_DCM};
26        //int Events[NUM_EVENTS] = {PAPI_TOT_CYC, PAPI_BR_MSP};
27        int cal_size = 20;
28        CC * parser_timer = new CC(Events,NUM_EVENTS,cal_size);
29#else
30        void * parser_timer;
31#endif
32
33inline bool bit_test(unsigned char * bit_Map, int codepoint) {
34        return (bit_Map[codepoint/8] >> (7 - codepoint % 8)) & 1;
35}
36
37bool is_XML10_NameStrt_codepoint(int codepoint) {
38        switch (codepoint >> 12) {
39                case 0: return bit_test(NameStrt_XML10_0000_11FF, codepoint);
40                case 1: if (codepoint <= 0x11FF)
41                                return bit_test(NameStrt_XML10_0000_11FF, codepoint);
42                        else if (codepoint < 0x1E00) return false;
43                        else return bit_test(NameStrt_XML10_1E00_1FFF, codepoint & 0x1FF);
44                case 2: if (codepoint > 0x2182) return false;
45                        else return bit_test(NameStrt_XML10_2000_21FF, codepoint & 0x1FF);
46                case 3: if (codepoint > 0x312C) return false;
47                        else return bit_test(NameStrt_XML10_3000_31FF, codepoint & 0x1FF);
48                case 4: return codepoint >= 0x4E00;
49                case 5: case 6: case 7: case 8: return true;
50                case 9: return codepoint <= 0x9FA5;
51                case 0xA: return codepoint >= 0xAC00;
52                case 0xB: case 0xC: return true;
53                case 0xD: return codepoint <= 0xD7A3;
54                default: return false;
55        }
56}
57
58bool is_XML10_NameChar_codepoint(int codepoint) {
59        switch (codepoint >> 12) {
60                case 0: return bit_test(NameChar_XML10_0000_11FF, codepoint);
61                case 1: if (codepoint <= 0x11FF)
62                                return bit_test(NameChar_XML10_0000_11FF, codepoint);
63                        else if (codepoint < 0x1E00) return false;
64                        else return bit_test(NameStrt_XML10_1E00_1FFF, codepoint & 0x1FF);
65                case 2: if (codepoint > 0x2182) return false;
66                        else return bit_test(NameChar_XML10_2000_21FF, codepoint & 0x1FF);
67                case 3: if (codepoint > 0x312C) return false;
68                        else return bit_test(NameChar_XML10_3000_31FF, codepoint & 0x1FF);
69                case 4: return codepoint >= 0x4E00;
70                case 5: case 6: case 7: case 8: return true;
71                case 9: return codepoint <= 0x9FA5;
72                case 0xA:       return codepoint >= 0xAC00;
73                case 0xB: case 0xC: return true;
74                case 0xD: return codepoint <= 0xD7A3;
75                default: return false;
76        }
77}
78
79inline int XML_10_UTF8_NameStrt_bytes (unsigned char bytes[]) {
80        if (bytes[0] <= 0x7F) {
81                if (bit_test(NameStrt_XML10_0000_11FF, (int) bytes[0])) return 1;
82                else return 0;
83        }
84        else if (bytes[0] <= 0xDF) {
85                int codepoint = ((bytes[0] & 0x3F) << 6) | (bytes[1] & 0x3F);
86                if (bit_test(NameStrt_XML10_0000_11FF, codepoint)) return 2;
87                else return 0;
88        }
89        else if (bytes[0] <= 0xEF) {
90                int codepoint = ((bytes[0] & 0x0F) << 12)| ((bytes[1] & 0x3F) << 6) | (bytes[2] & 0x3F);
91                return is_XML10_NameStrt_codepoint(codepoint) ? 3 : 0;
92        }
93        else return 0;
94}
95
96inline int XML_10_UTF8_NameChar_bytes (unsigned char bytes[]) {
97        if (bytes[0] <= 0x7F) {
98                if (bit_test(NameChar_XML10_0000_11FF, (int) bytes[0])) return 1;
99                else return 0;
100        }
101        else if (bytes[0] <= 0xDF) {
102                int codepoint = ((bytes[0] & 0x3F) << 6) | (bytes[1] & 0x3F);
103                if (bit_test(NameChar_XML10_0000_11FF, codepoint)) return 2;
104                else return 0;
105        }
106        else if (bytes[0] <= 0xEF) {
107                int codepoint = ((bytes[0] & 0x0F) << 12)| ((bytes[1] & 0x3F) << 6) | (bytes[2] & 0x3F);
108                return is_XML10_NameChar_codepoint(codepoint) ? 3 : 0;
109        }
110        else return 0;
111}
112
113#define s2p_step(s0,s1,hi_mask,shift,p0,p1)  \
114{ \
115BitBlock t0,t1; \
116t0= simd_pack_16_hh(s0,s1) ; \
117t1= simd_pack_16_ll(s0,s1) ; \
118p0= simd_if(hi_mask,t0,simd_srli_16(t1,shift) ) ; \
119p1= simd_if(hi_mask,simd_slli_16(t0,shift) ,t1) ; \
120} \
121
122#define s2p_bytepack(s0,s1,s2,s3,s4,s5,s6,s7,p0,p1,p2,p3,p4,p5,p6,p7)  \
123{BitBlock bit00224466_0,bit00224466_1,bit00224466_2,bit00224466_3; \
124BitBlock bit11335577_0,bit11335577_1,bit11335577_2,bit11335577_3; \
125BitBlock bit00004444_0,bit22226666_0,bit00004444_1,bit22226666_1; \
126BitBlock bit11115555_0,bit33337777_0,bit11115555_1,bit33337777_1; \
127s2p_step(s0,s1,simd_himask_2,1,bit00224466_0,bit11335577_0)  \
128s2p_step(s2,s3,simd_himask_2,1,bit00224466_1,bit11335577_1)  \
129s2p_step(s4,s5,simd_himask_2,1,bit00224466_2,bit11335577_2)  \
130s2p_step(s6,s7,simd_himask_2,1,bit00224466_3,bit11335577_3)  \
131s2p_step(bit00224466_0,bit00224466_1,simd_himask_4,2,bit00004444_0,bit22226666_0)  \
132s2p_step(bit00224466_2,bit00224466_3,simd_himask_4,2,bit00004444_1,bit22226666_1)  \
133s2p_step(bit11335577_0,bit11335577_1,simd_himask_4,2,bit11115555_0,bit33337777_0)  \
134s2p_step(bit11335577_2,bit11335577_3,simd_himask_4,2,bit11115555_1,bit33337777_1)  \
135s2p_step(bit00004444_0,bit00004444_1,simd_himask_8,4,p0,p4)  \
136s2p_step(bit11115555_0,bit11115555_1,simd_himask_8,4,p1,p5)  \
137s2p_step(bit22226666_0,bit22226666_1,simd_himask_8,4,p2,p6)  \
138s2p_step(bit33337777_0,bit33337777_1,simd_himask_8,4,p3,p7)  \
139} \
140
141#define p2s_step(p0,p1,hi_mask,shift,s0,s1)  \
142{ \
143BitBlock t0,t1; \
144t0= simd_if(hi_mask,p0,simd_srli_16(p1,shift) ) ; \
145t1= simd_if(hi_mask,simd_slli_16(p0,shift) ,p1) ; \
146s0= simd_mergeh_8(t0,t1) ; \
147s1= simd_mergel_8(t0,t1) ; \
148} \
149
150#define p2s_bytemerge(p0,p1,p2,p3,p4,p5,p6,p7,s0,s1,s2,s3,s4,s5,s6,s7)  \
151{ \
152BitBlock bit00004444_0,bit22226666_0,bit00004444_1,bit22226666_1; \
153BitBlock bit11115555_0,bit33337777_0,bit11115555_1,bit33337777_1; \
154BitBlock bit00224466_0,bit00224466_1,bit00224466_2,bit00224466_3; \
155BitBlock bit11335577_0,bit11335577_1,bit11335577_2,bit11335577_3; \
156p2s_step(p0,p4,simd_himask_8,4,bit00004444_0,bit00004444_1)  \
157p2s_step(p1,p5,simd_himask_8,4,bit11115555_0,bit11115555_1)  \
158p2s_step(p2,p6,simd_himask_8,4,bit22226666_0,bit22226666_1)  \
159p2s_step(p3,p7,simd_himask_8,4,bit33337777_0,bit33337777_1)  \
160p2s_step(bit00004444_0,bit22226666_0,simd_himask_4,2,bit00224466_0,bit00224466_1)  \
161p2s_step(bit11115555_0,bit33337777_0,simd_himask_4,2,bit11335577_0,bit11335577_1)  \
162p2s_step(bit00004444_1,bit22226666_1,simd_himask_4,2,bit00224466_2,bit00224466_3)  \
163p2s_step(bit11115555_1,bit33337777_1,simd_himask_4,2,bit11335577_2,bit11335577_3)  \
164p2s_step(bit00224466_0,bit11335577_0,simd_himask_2,1,s0,s1)  \
165p2s_step(bit00224466_1,bit11335577_1,simd_himask_2,1,s2,s3)  \
166p2s_step(bit00224466_2,bit11335577_2,simd_himask_2,1,s4,s5)  \
167p2s_step(bit00224466_3,bit11335577_3,simd_himask_2,1,s6,s7)  \
168} \
169
170       
171#define BUFFER_SIZE 12800   
172#define BLOCK_SIZE 128
173
174void do_process(FILE *infile, FILE *outfile) {
175
176  @decl
177
178  BytePack U8[8];
179  int buf_pos = 0;
180  int block_pos = 0;
181  int errpos = 0;
182  int chars_read = 0;
183  int check_pos = 0;
184  char srcbuf[BUFFER_SIZE+BLOCK_SIZE];
185 
186  EOF_mask = simd_const_1(1);
187  chars_read = fread((void *)srcbuf, 1, BUFFER_SIZE, infile);
188
189  Entity_Info * e = new Entity_Info;
190  e->AnalyzeSignature((unsigned char *)srcbuf);
191  XML_Decl_Parser<ASCII> decl_parser((unsigned char *)srcbuf);
192
193  decl_parser.ReadXMLInfo(*e);
194
195  if (e->content_start != 0) {
196        memmove(&srcbuf[0], &srcbuf[e->content_start], chars_read - e->content_start);
197        if (chars_read == BUFFER_SIZE) {
198                chars_read = BUFFER_SIZE - e->content_start + 
199                             fread(&srcbuf[BUFFER_SIZE-e->content_start], 1, e->content_start, infile);
200        }
201  }
202 
203  @stream_stmts
204
205  while(chars_read>0){
206
207    PERF_SEC_START(parser_timer);
208
209    if(chars_read < BUFFER_SIZE){
210   
211      while (block_pos < chars_read){
212
213        int bytes = chars_read - block_pos;
214        if(bytes < BLOCK_SIZE){
215          EOF_mask = sisd_srl(simd_const_1(1),sisd_from_int(BLOCK_SIZE-bytes));
216        }
217        BytePack * U8pack = (BytePack *) &srcbuf[block_pos];
218        U8[0] = sisd_load_unaligned(&U8pack[0]);
219        U8[1] = sisd_load_unaligned(&U8pack[1]);
220        U8[2] = sisd_load_unaligned(&U8pack[2]);
221        U8[3] = sisd_load_unaligned(&U8pack[3]);
222        U8[4] = sisd_load_unaligned(&U8pack[4]);
223        U8[5] = sisd_load_unaligned(&U8pack[5]);
224        U8[6] = sisd_load_unaligned(&U8pack[6]);
225        U8[7] = sisd_load_unaligned(&U8pack[7]); 
226       
227        s2p_bytepack(U8[7], U8[6], U8[5], U8[4], U8[3], U8[2], U8[1], U8[0],
228        array_bit__0_,array_bit__1_,array_bit__2_,array_bit__3_,array_bit__4_,array_bit__5_,array_bit__6_,array_bit__7_);
229
230        array_bit__0_ = simd_and(array_bit__0_, EOF_mask);
231        array_bit__1_ = simd_and(array_bit__1_, EOF_mask);
232        array_bit__2_ = simd_and(array_bit__2_, EOF_mask);
233        array_bit__3_ = simd_and(array_bit__3_, EOF_mask);
234        array_bit__4_ = simd_and(array_bit__4_, EOF_mask);
235        array_bit__5_ = simd_and(array_bit__5_, EOF_mask);
236        array_bit__6_ = simd_and(array_bit__6_, EOF_mask);
237        array_bit__7_ = simd_and(array_bit__7_, EOF_mask);
238
239        @block_stmts
240
241        if (bitblock_has_bit(error_mask)) {
242          errpos = block_pos + buf_pos + count_forward_zeroes(error_mask);
243          fprintf(stderr, "error found at position %i\n",errpos);
244          exit(-1);
245        }
246       
247        if (bitblock_has_bit(simd_or(name_check,name_start_check))) {
248          if(bitblock_has_bit(name_start_check)){
249            check_pos = block_pos + count_forward_zeroes(name_start_check);
250            if(XML_10_UTF8_NameStrt_bytes((unsigned char*)&srcbuf[check_pos]) == 0)
251              fprintf(stderr, "name start error found at position %i\n",check_pos+buf_pos);
252          }
253          if(bitblock_has_bit(name_check)){
254            check_pos = block_pos + count_forward_zeroes(name_start_check);
255            if(XML_10_UTF8_NameStrt_bytes((unsigned char*)&srcbuf[check_pos]) == 0)
256              fprintf(stderr, "name error found at position %i\n",check_pos+buf_pos);
257          }
258        }
259       
260        block_pos += BLOCK_SIZE;
261      }
262    }
263    else{
264      while (block_pos < chars_read){
265
266        BytePack * U8pack = (BytePack *) &srcbuf[block_pos];
267        U8[0] = sisd_load_unaligned(&U8pack[0]);
268        U8[1] = sisd_load_unaligned(&U8pack[1]);
269        U8[2] = sisd_load_unaligned(&U8pack[2]);
270        U8[3] = sisd_load_unaligned(&U8pack[3]);
271        U8[4] = sisd_load_unaligned(&U8pack[4]);
272        U8[5] = sisd_load_unaligned(&U8pack[5]);
273        U8[6] = sisd_load_unaligned(&U8pack[6]);
274        U8[7] = sisd_load_unaligned(&U8pack[7]); 
275       
276        s2p_bytepack(U8[7], U8[6], U8[5], U8[4], U8[3], U8[2], U8[1], U8[0],
277        array_bit__0_,array_bit__1_,array_bit__2_,array_bit__3_,array_bit__4_,array_bit__5_,array_bit__6_,array_bit__7_);
278
279        @block_stmts
280       
281        if (bitblock_has_bit(error_mask)) {
282          errpos = block_pos + buf_pos + count_forward_zeroes(error_mask);
283          fprintf(stderr, "error found at position %i\n",errpos);
284          exit(-1);
285        }
286       
287        if (bitblock_has_bit(simd_or(name_check,name_start_check))) {
288          if(bitblock_has_bit(name_start_check)){
289            check_pos = block_pos + count_forward_zeroes(name_start_check);
290            if(XML_10_UTF8_NameStrt_bytes((unsigned char*)&srcbuf[check_pos]) == 0)
291              fprintf(stderr, "name start error found at position %i\n",check_pos+buf_pos);
292          }
293          if(bitblock_has_bit(name_check)){
294            check_pos = block_pos + count_forward_zeroes(name_start_check);
295            if(XML_10_UTF8_NameStrt_bytes((unsigned char*)&srcbuf[check_pos]) == 0)
296              fprintf(stderr, "name error found at position %i\n",check_pos+buf_pos);
297          }
298        }
299       
300        block_pos += BLOCK_SIZE;
301      }
302    }
303
304    PERF_SEC_END(parser_timer, chars_read);
305
306    buf_pos += chars_read;
307    chars_read = fread((void *)srcbuf, 1, BUFFER_SIZE, infile);
308    block_pos = 0;
309  }
310}
311
312
313
314int
315main(int argc, char * argv[]) {
316        char * infilename, * outfilename;       
317        FILE *infile, *outfile;
318        struct stat fileinfo;
319
320        if (argc < 2) {
321                printf("Usage: %s <filename> [<outputfile>]\n", argv[0]);
322                exit(-1);
323        }
324
325        infilename = argv[1];
326        stat(infilename, &fileinfo);
327        infile = fopen(infilename, "rb");
328        if (!infile) {
329                fprintf(stderr, "Error: cannot open %s for input.\n", infilename);
330                exit(-1);
331        }
332       
333        if (argc < 3) outfile = stdout;
334        else {
335                outfilename = argv[2];
336                outfile = fopen(outfilename, "wb");
337                if (!outfile) {
338                        fprintf(stderr, "Error: cannot open %s for writing.\n", outfilename);
339                        exit(-1);
340                }
341        }
342
343        PERF_SEC_BIND(1);
344
345        PERF_SEC_INIT(parser_timer);
346
347        do_process(infile, outfile);
348       
349        PERF_SEC_DUMP(parser_timer);
350       
351        PERF_SEC_DESTROY(parser_timer);
352
353        fclose(infile);
354        fclose(outfile);
355        return(0);
356}
Note: See TracBrowser for help on using the repository browser.