source: proto/parabix2/template.c @ 486

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

Update template.c to provide code clocker support.

File size: 7.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
16#if (defined(BUFFER_PROFILING) || defined(CODE_CLOCKER))
17  #include "../lib/perflib/perfsec.h"
18#endif
19
20#ifdef BUFFER_PROFILING
21  BOM_Table * parser_timer;
22#endif
23
24#ifdef CODE_CLOCKER
25        #define NUM_EVENTS 1
26        int Events[NUM_EVENTS] = {PAPI_TOT_CYC};
27        //int Events[NUM_EVENTS] = {PAPI_L2_DCM};
28        //int Events[NUM_EVENTS] = {PAPI_TOT_CYC, PAPI_BR_MSP};
29        int cal_size = 20;
30        CC * parser_timer = new CC(Events,NUM_EVENTS,cal_size);
31#endif
32
33#define s2p_step(s0,s1,hi_mask,shift,p0,p1)  \
34{ \
35BitBlock t0,t1; \
36t0= simd_pack_16_hh(s0,s1) ; \
37t1= simd_pack_16_ll(s0,s1) ; \
38p0= simd_if(hi_mask,t0,simd_srli_16(t1,shift) ) ; \
39p1= simd_if(hi_mask,simd_slli_16(t0,shift) ,t1) ; \
40} \
41
42#define s2p_bytepack(s0,s1,s2,s3,s4,s5,s6,s7,p0,p1,p2,p3,p4,p5,p6,p7)  \
43{BitBlock bit00224466_0,bit00224466_1,bit00224466_2,bit00224466_3; \
44BitBlock bit11335577_0,bit11335577_1,bit11335577_2,bit11335577_3; \
45BitBlock bit00004444_0,bit22226666_0,bit00004444_1,bit22226666_1; \
46BitBlock bit11115555_0,bit33337777_0,bit11115555_1,bit33337777_1; \
47s2p_step(s0,s1,simd_himask_2,1,bit00224466_0,bit11335577_0)  \
48s2p_step(s2,s3,simd_himask_2,1,bit00224466_1,bit11335577_1)  \
49s2p_step(s4,s5,simd_himask_2,1,bit00224466_2,bit11335577_2)  \
50s2p_step(s6,s7,simd_himask_2,1,bit00224466_3,bit11335577_3)  \
51s2p_step(bit00224466_0,bit00224466_1,simd_himask_4,2,bit00004444_0,bit22226666_0)  \
52s2p_step(bit00224466_2,bit00224466_3,simd_himask_4,2,bit00004444_1,bit22226666_1)  \
53s2p_step(bit11335577_0,bit11335577_1,simd_himask_4,2,bit11115555_0,bit33337777_0)  \
54s2p_step(bit11335577_2,bit11335577_3,simd_himask_4,2,bit11115555_1,bit33337777_1)  \
55s2p_step(bit00004444_0,bit00004444_1,simd_himask_8,4,p0,p4)  \
56s2p_step(bit11115555_0,bit11115555_1,simd_himask_8,4,p1,p5)  \
57s2p_step(bit22226666_0,bit22226666_1,simd_himask_8,4,p2,p6)  \
58s2p_step(bit33337777_0,bit33337777_1,simd_himask_8,4,p3,p7)  \
59} \
60
61#define p2s_step(p0,p1,hi_mask,shift,s0,s1)  \
62{ \
63BitBlock t0,t1; \
64t0= simd_if(hi_mask,p0,simd_srli_16(p1,shift) ) ; \
65t1= simd_if(hi_mask,simd_slli_16(p0,shift) ,p1) ; \
66s0= simd_mergeh_8(t0,t1) ; \
67s1= simd_mergel_8(t0,t1) ; \
68} \
69
70#define p2s_bytemerge(p0,p1,p2,p3,p4,p5,p6,p7,s0,s1,s2,s3,s4,s5,s6,s7)  \
71{ \
72BitBlock bit00004444_0,bit22226666_0,bit00004444_1,bit22226666_1; \
73BitBlock bit11115555_0,bit33337777_0,bit11115555_1,bit33337777_1; \
74BitBlock bit00224466_0,bit00224466_1,bit00224466_2,bit00224466_3; \
75BitBlock bit11335577_0,bit11335577_1,bit11335577_2,bit11335577_3; \
76p2s_step(p0,p4,simd_himask_8,4,bit00004444_0,bit00004444_1)  \
77p2s_step(p1,p5,simd_himask_8,4,bit11115555_0,bit11115555_1)  \
78p2s_step(p2,p6,simd_himask_8,4,bit22226666_0,bit22226666_1)  \
79p2s_step(p3,p7,simd_himask_8,4,bit33337777_0,bit33337777_1)  \
80p2s_step(bit00004444_0,bit22226666_0,simd_himask_4,2,bit00224466_0,bit00224466_1)  \
81p2s_step(bit11115555_0,bit33337777_0,simd_himask_4,2,bit11335577_0,bit11335577_1)  \
82p2s_step(bit00004444_1,bit22226666_1,simd_himask_4,2,bit00224466_2,bit00224466_3)  \
83p2s_step(bit11115555_1,bit33337777_1,simd_himask_4,2,bit11335577_2,bit11335577_3)  \
84p2s_step(bit00224466_0,bit11335577_0,simd_himask_2,1,s0,s1)  \
85p2s_step(bit00224466_1,bit11335577_1,simd_himask_2,1,s2,s3)  \
86p2s_step(bit00224466_2,bit11335577_2,simd_himask_2,1,s4,s5)  \
87p2s_step(bit00224466_3,bit11335577_3,simd_himask_2,1,s6,s7)  \
88} \
89
90       
91#define BUFFER_SIZE 12800   
92#define BLOCK_SIZE 128
93
94void do_process(FILE *infile, FILE *outfile) {
95
96  @decl
97
98  BytePack U8[8];
99  int buf_pos = 0;
100  int block_pos = 0;
101  int errpos = 0;
102  int chars_read = 0;
103  char * srcbuf;
104
105 
106  srcbuf = (char *) malloc(BUFFER_SIZE+BLOCK_SIZE);
107  if(!srcbuf){
108    printf("Can't allocate srcbuf!\n");
109    exit(-1);
110  }
111 
112  EOF_mask = simd_const_1(1);
113  chars_read = fread((void *)srcbuf, 1, BUFFER_SIZE, infile);
114
115  Entity_Info * e = new Entity_Info;
116  e->AnalyzeSignature((unsigned char *)srcbuf);
117  XML_Decl_Parser<ASCII> decl_parser((unsigned char *)srcbuf);
118
119  decl_parser.ReadXMLInfo(*e);
120
121  if (e->content_start != 0) {
122        memmove(&srcbuf[0], &srcbuf[e->content_start], chars_read - e->content_start);
123        if (chars_read == BUFFER_SIZE) {
124                chars_read = BUFFER_SIZE - e->content_start + 
125                             fread(&srcbuf[BUFFER_SIZE-e->content_start], 1, e->content_start, infile);
126        }
127  }
128 
129  @stream_stmts
130
131  while(chars_read>0){
132
133    PERF_SEC_START(parser_timer);
134
135    if(chars_read < BUFFER_SIZE){
136   
137      while (block_pos < chars_read){
138
139        int bytes = chars_read - block_pos;
140        if(bytes < BLOCK_SIZE){
141          EOF_mask = sisd_srl(simd_const_1(1),sisd_from_int(BLOCK_SIZE-bytes));
142        }
143        BytePack * U8pack = (BytePack *) &srcbuf[block_pos];
144        U8[0] = sisd_load_unaligned(&U8pack[0]);
145        U8[1] = sisd_load_unaligned(&U8pack[1]);
146        U8[2] = sisd_load_unaligned(&U8pack[2]);
147        U8[3] = sisd_load_unaligned(&U8pack[3]);
148        U8[4] = sisd_load_unaligned(&U8pack[4]);
149        U8[5] = sisd_load_unaligned(&U8pack[5]);
150        U8[6] = sisd_load_unaligned(&U8pack[6]);
151        U8[7] = sisd_load_unaligned(&U8pack[7]); 
152       
153        s2p_bytepack(U8[7], U8[6], U8[5], U8[4], U8[3], U8[2], U8[1], U8[0],
154        array_bit__0_,array_bit__1_,array_bit__2_,array_bit__3_,array_bit__4_,array_bit__5_,array_bit__6_,array_bit__7_);
155
156        array_bit__0_ = simd_and(array_bit__0_, EOF_mask);
157        array_bit__1_ = simd_and(array_bit__1_, EOF_mask);
158        array_bit__2_ = simd_and(array_bit__2_, EOF_mask);
159        array_bit__3_ = simd_and(array_bit__3_, EOF_mask);
160        array_bit__4_ = simd_and(array_bit__4_, EOF_mask);
161        array_bit__5_ = simd_and(array_bit__5_, EOF_mask);
162        array_bit__6_ = simd_and(array_bit__6_, EOF_mask);
163        array_bit__7_ = simd_and(array_bit__7_, EOF_mask);
164
165        @block_stmts
166
167        if (bitblock_has_bit(error_mask)) {
168          errpos = block_pos + buf_pos + count_forward_zeroes(error_mask);
169          fprintf(stderr, "error found at position %i\n",errpos);
170          exit(-1);
171        }
172       
173        block_pos += BLOCK_SIZE;
174      }
175    }
176    else{
177      while (block_pos < chars_read){
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        @block_stmts
193       
194        if (bitblock_has_bit(error_mask)) {
195          errpos = block_pos + buf_pos + count_forward_zeroes(error_mask);
196          fprintf(stderr, "error found at position %i\n",errpos);
197          exit(-1);
198        }
199       
200        block_pos += BLOCK_SIZE;
201      }
202    }
203
204    PERF_SEC_END(parser_timer, chars_read);
205
206    buf_pos += chars_read;
207    chars_read = fread((void *)srcbuf, 1, BUFFER_SIZE, infile);
208    block_pos = 0;
209  }
210  free((void*)srcbuf);
211}
212
213
214
215int
216main(int argc, char * argv[]) {
217        char * infilename, * outfilename;       
218        FILE *infile, *outfile;
219        struct stat fileinfo;
220
221        if (argc < 2) {
222                printf("Usage: %s <filename> [<outputfile>]\n", argv[0]);
223                exit(-1);
224        }
225
226        infilename = argv[1];
227        stat(infilename, &fileinfo);
228        infile = fopen(infilename, "rb");
229        if (!infile) {
230                fprintf(stderr, "Error: cannot open %s for input.\n", infilename);
231                exit(-1);
232        }
233       
234        if (argc < 3) outfile = stdout;
235        else {
236                outfilename = argv[2];
237                outfile = fopen(outfilename, "wb");
238                if (!outfile) {
239                        fprintf(stderr, "Error: cannot open %s for writing.\n", outfilename);
240                        exit(-1);
241                }
242        }
243
244
245        PERF_SEC_INIT(parser_timer);
246
247        do_process(infile, outfile);
248       
249        PERF_SEC_DUMP(parser_timer);
250       
251        PERF_SEC_DESTROY(parser_timer);
252
253        fclose(infile);
254        fclose(outfile);
255        return(0);
256}
Note: See TracBrowser for help on using the repository browser.