source: proto/RE/output/grep_template.cpp @ 3410

Last change on this file since 3410 was 3410, checked in by cameron, 6 years ago

Maximize segment length hack for possible long lines; fix needed.

File size: 7.9 KB
Line 
1// Stream struct and function headers and definitions
2
3#include <simd-lib/bitblock.hpp>
4#include <simd-lib/carryQ.hpp>
5#include <simd-lib/pabloSupport.hpp>
6
7#define LocalCarryDeclare(name, count)\
8CarryArray<count, 0> name;\
9
10#define assert_0_error(errkind, errstrm)
11
12BitBlock EOF_mask = simd<1>::constant<1>();
13
14// XMLWF application headers and definitions
15#include <stdio.h>
16#include <stdlib.h>
17#include <unistd.h>
18#include <errno.h>
19#include <sys/types.h>
20#include <sys/stat.h>
21
22#include <simd-lib/s2p.hpp>
23#include <simd-lib/buffer.hpp>
24#include <simd-lib/bitblock_iterator.hpp>
25#include <simd-lib/perflib/perfsec.h>
26
27
28#ifdef BUFFER_PROFILING
29    BOM_Table * parser_timer;
30#elif PAPI
31                #define PAPI_EVENTS_COUNT 2
32                int PAPI_EVENTS[PAPI_EVENTS_COUNT] = {PAPI_TOT_CYC, PAPI_BR_MSP};       
33    CC * parser_timer;
34#else
35    void * parser_timer;
36#endif
37
38#define SEGMENT_BLOCKS 31
39#define SEGMENT_SIZE (BLOCK_SIZE * SEGMENT_BLOCKS)
40
41@global
42
43#include <simd-lib/transpose.hpp>
44
45static void do_process(FILE *infile, FILE *outfile, int count_only_option);
46
47int main(int argc, char * argv[]) {
48
49        char * infilename, * outfilename;
50        FILE *infile, *outfile;
51
52        int opt_code;
53        int count_only_option = 0;
54        int print_version_option = 0;
55        while ( (opt_code = getopt(argc, argv, "cv")) != -1) {
56                switch (opt_code) {
57                case 'c':
58                    count_only_option = 1;
59                    break;
60                case 'v':
61                    print_version_option = 1;
62                    break;
63                case '?':
64                    break;
65                default:
66                    printf ("Invalid option: %c\n", opt_code);
67                    printf("Usage: %s [-c] [-v] <filename> [<outputfile>]\n", argv[0]);
68                    exit(-1);
69                }
70        }
71       
72       
73        if (optind >= argc) {
74                printf ("Too few arguments\n", opt_code);
75                printf("Usage: %s [-c] [-v] <filename> [<outputfile>]\n", argv[0]);
76                exit(-1);
77        }
78
79        infilename = argv[optind++];
80        infile = fopen(infilename, "rb");
81        if (!infile) {
82                fprintf(stderr, "Error: cannot open %s for input.\n", infilename);
83                exit(-1);
84        }
85
86        if (optind >= argc) outfile = stdout;
87        else {
88                outfilename = argv[optind++];
89                if (optind != argc) {
90                        printf ("Too many arguments\n", opt_code);
91                        printf("Usage: %s [-c] [-v] <filename> [<outputfile>]\n", argv[0]);
92                        exit(-1);
93                }
94
95
96                outfile = fopen(outfilename, "wb");
97                if (!outfile) {
98                        fprintf(stderr, "Error: cannot open %s for writing.\n", outfilename);
99                        exit(-1);
100                }
101        }
102
103
104        if (print_version_option) {
105                fprintf(outfile, "Parabix grep implementation: July 2013\n");
106        }
107
108        PERF_SEC_BIND(1);
109
110        PERF_SEC_INIT(parser_timer);
111
112        do_process(infile, outfile, count_only_option);
113
114        PERF_SEC_DUMP(parser_timer);
115
116        PERF_SEC_DESTROY(parser_timer);
117
118        fclose(infile);
119        fclose(outfile);
120
121        return(0);
122}
123
124void do_process(FILE *infile, FILE *outfile, int count_only_option) {
125
126        @decl
127
128        bool line_match_found=false;
129
130        BitBlock match_vector = simd<1>::constant<0>();
131        int match_count=0;
132        int blk = 0;
133        int block_base  = 0;
134        int block_pos   = 0;
135        int buffer_base = 0;
136        int buffer_pos  = 0;
137        int chars_avail = 0;
138        int chars_read  = 0;
139
140        int line_start, line_end, match_pos, line_no;
141        line_no = 0;
142
143        BitStreamScanner<BitBlock, uint64_t, uint64_t, SEGMENT_BLOCKS> LF_scanner;
144        BitStreamScanner<BitBlock, uint64_t, uint64_t, SEGMENT_BLOCKS> match_scanner;
145        ATTRIBUTE_SIMD_ALIGN char src_buffer[SEGMENT_SIZE];     
146       
147        chars_read = fread((void *)&src_buffer[0], 1, SEGMENT_SIZE, infile);
148        chars_avail = chars_read;
149        if (chars_avail >= SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
150
151
152        @stream_stmts
153
154//////////////////////////////////////////////////////////////////////////////////////////
155// Full Segments
156//////////////////////////////////////////////////////////////////////////////////////////
157       
158        while (chars_avail >= SEGMENT_SIZE) {
159                        LF_scanner.init();
160                        match_scanner.init();
161
162                PERF_SEC_START(parser_timer);
163                for (blk = 0; blk < SEGMENT_BLOCKS; blk++) {
164                        block_base = blk*BLOCK_SIZE;
165                        s2p_do_block((BytePack *) &src_buffer[block_base], basis_bits);
166
167                        @block_stmts
168
169                        LF_scanner.load_block(lex.LF, blk);
170                        match_scanner.load_block(output.matches, blk);
171                        if (count_only_option) {
172                          if (bitblock::any(output.matches)) {
173                            if (bitblock::any(simd_and(match_vector, output.matches))) {
174                              match_count += bitblock::popcount(match_vector);
175                              match_vector = output.matches;
176                            }
177                            else {
178                              match_vector = simd_or(match_vector, output.matches);
179                            }
180                          }
181                        }
182
183                }
184
185 
186        demo.clear();
187
188     
189        int copy_back_pos = LF_scanner.get_final_pos() + 1;
190        int copy_back_size = SEGMENT_SIZE - copy_back_pos;
191
192        match_scanner.clear_from(copy_back_pos);
193
194
195            if (!count_only_option) {
196                line_start = 0;
197
198                while (match_scanner.has_next()) {
199                        match_pos = match_scanner.scan_to_next();       
200                        line_end = LF_scanner.scan_to_next();
201                        while (line_end < match_pos) { 
202                                line_start = line_end+1;
203                                line_no++; 
204                                line_end = LF_scanner.scan_to_next();
205                        }
206                        fwrite(&src_buffer[line_start], 1, line_end - line_start + 1, outfile);
207                        line_start = line_end+1;
208                        line_no++; 
209                }
210                while (LF_scanner.has_next()) {
211                        line_end = LF_scanner.scan_to_next();
212                        line_no++;     
213                }       
214            }
215
216
217          memmove(&src_buffer[0], &src_buffer[copy_back_pos], copy_back_size);
218
219          PERF_SEC_END(parser_timer, chars_avail);
220
221          chars_read = fread(&src_buffer[copy_back_size], 1, copy_back_pos, infile);
222          chars_avail = chars_read + copy_back_size;
223          if (chars_avail >= SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
224          buffer_pos += chars_avail;
225          buffer_base = buffer_pos;
226        }
227
228
229//////////////////////////////////////////////////////////////////////////////////////////
230// Final Partial Segment
231//////////////////////////////////////////////////////////////////////////////////////////
232        PERF_SEC_START(parser_timer);
233
234        block_pos = 0;
235        int remaining = chars_avail;
236
237
238        LF_scanner.init();
239        match_scanner.init();
240
241        /* Full Blocks */
242        blk = 0;
243        while (remaining >= BLOCK_SIZE) {
244                block_base = block_pos;
245                s2p_do_block((BytePack *) &src_buffer[block_pos], basis_bits);
246                @block_stmts
247                LF_scanner.load_block(lex.LF, blk);
248                match_scanner.load_block(output.matches, blk);
249                        if (count_only_option) {
250                          if (bitblock::any(output.matches)) {
251                            if (bitblock::any(simd_and(match_vector, output.matches))) {
252                              match_count += bitblock::popcount(match_vector);
253                              match_vector = output.matches;
254                            }
255                            else {
256                              match_vector = simd_or(match_vector, output.matches);
257                            }
258                          }
259                        }
260                block_pos += BLOCK_SIZE;
261                remaining -= BLOCK_SIZE;
262                blk++;
263        }
264        block_base = block_pos;
265
266//    Partial Block or Any Carry
267//
268        EOF_mask = bitblock::srl(simd<1>::constant<1>(), convert(BLOCK_SIZE-remaining));
269                                s2p_do_final_block((BytePack *) &src_buffer[block_pos], basis_bits, EOF_mask);
270        @final_block_stmts
271
272        if (count_only_option) {
273                match_count += bitblock::popcount(match_vector);
274                if (bitblock::any(output.matches)) {
275                        match_count += bitblock::popcount(output.matches);
276                }
277                fprintf(outfile, "Matching Lines:%d\n",match_count);
278        }
279        else {
280                LF_scanner.load_block(lex.LF, blk);
281                match_scanner.load_block(output.matches, blk);
282                blk++;
283
284                for (int i = blk; i < SEGMENT_BLOCKS; i++){
285                    LF_scanner.load_block(simd<1>::constant<0>(), i);
286                    match_scanner.load_block(simd<1>::constant<0>(), i);
287                }
288                line_start = 0;
289
290                while (match_scanner.has_next()) {
291                        match_pos = match_scanner.scan_to_next();       
292                        line_end = LF_scanner.scan_to_next();
293                        while (line_end < match_pos) { 
294                                line_start = line_end+1;
295                                line_no++; 
296                                line_end = LF_scanner.scan_to_next();
297                        }
298                        fwrite(&src_buffer[line_start], 1, line_end - line_start + 1, outfile);
299                        line_start = line_end+1;
300                        line_no++; 
301                }
302                while (LF_scanner.has_next()) {
303                        line_end = LF_scanner.scan_to_next();
304                        line_no++;     
305                }       
306        }
307
308        buffer_pos += chars_avail;
309        buffer_base = buffer_pos;
310
311        PERF_SEC_END(parser_timer, chars_avail);
312}
313
Note: See TracBrowser for help on using the repository browser.