source: proto/RE/output/pablo_template.cpp @ 3788

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

Simplify template to count matches without scanning

File size: 8.0 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 <errno.h>
18#include <sys/types.h>
19#include <sys/stat.h>
20
21#include <simd-lib/s2p.hpp>
22#include <simd-lib/buffer.hpp>
23#include <simd-lib/bitblock_iterator.hpp>
24#include <simd-lib/perflib/perfsec.h>
25
26
27#ifdef BUFFER_PROFILING
28    BOM_Table * parser_timer;
29#elif PAPI
30                #define PAPI_EVENTS_COUNT 2
31                int PAPI_EVENTS[PAPI_EVENTS_COUNT] = {PAPI_TOT_CYC, PAPI_BR_MSP};       
32    CC * parser_timer;
33#else
34    void * parser_timer;
35#endif
36
37//////////////////////////////////////////////////////////////////////////////////////////
38// Buffer Management // WARNING: Do Not update #defines. Results in TagMatcher errors.
39//////////////////////////////////////////////////////////////////////////////////////////
40#define PADDING_BLOCKS 0
41#define PADDING_SIZE (BLOCK_SIZE * PADDING_BLOCKS)
42#define COPYBACK_BLOCKS 2
43#define COPYBACK_SIZE (BLOCK_SIZE * COPYBACK_BLOCKS)
44#define LOOKAHEAD_BLOCKS 1
45#define LOOKAHEAD_SIZE (BLOCK_SIZE * LOOKAHEAD_BLOCKS)
46#define SEGMENT_BLOCKS  12 // WARNING: TagMatcher.hpp causes xmlconf test suite failures for SEGMENT_BLOCKS < 3.
47#define SEGMENT_SIZE (BLOCK_SIZE * SEGMENT_BLOCKS)
48#define BUFFER_SIZE (COPYBACK_SIZE + SEGMENT_SIZE + LOOKAHEAD_SIZE + PADDING_SIZE)
49
50//////////////////////////////////////////////////////////////////////////////////////////
51// @ global depends on 'error_tracker' and 'EOF_mask' definitions.
52//////////////////////////////////////////////////////////////////////////////////////////
53@global
54
55//////////////////////////////////////////////////////////////////////////////////////////
56// Headers that depend @ global stream struct types.
57//////////////////////////////////////////////////////////////////////////////////////////
58#include <simd-lib/transpose.hpp>
59
60
61
62
63void print_register2(const char * var_name, BitBlock v, int length) {
64        unsigned char c;
65        printf("%10s = ", var_name);
66        for(int i=0;i<=(length+7)/8; i++) {
67                c = *(((unsigned char *)&v)+i);
68                int count = 0;
69                while (count < 8) {
70                        if ((c % 2)==1)
71                        {
72                                printf("1");
73                        }
74                        else {
75                                printf("0");
76                        }
77                        c = c / 2;
78                        count+=1;
79                }
80        }
81        printf("\n");
82}
83
84
85
86static void do_process(FILE *infile, FILE *outfile);
87
88int main(int argc, char * argv[]) {
89
90        char * infilename, * outfilename;
91        FILE *infile, *outfile;
92        struct stat fileinfo;
93
94        if (argc < 2) {
95                printf("Usage: %s <filename> [<outputfile>]\n", argv[0]);
96                exit(-1);
97        }
98
99        infilename = argv[1];
100        stat(infilename, &fileinfo);
101        infile = fopen(infilename, "rb");
102        if (!infile) {
103                fprintf(stderr, "Error: cannot open %s for input.\n", infilename);
104                exit(-1);
105        }
106
107        if (argc < 3) outfile = stdout;
108        else {
109                outfilename = argv[2];
110                outfile = fopen(outfilename, "wb");
111                if (!outfile) {
112                        fprintf(stderr, "Error: cannot open %s for writing.\n", outfilename);
113                        exit(-1);
114                }
115        }
116
117        PERF_SEC_BIND(1);
118
119        PERF_SEC_INIT(parser_timer);
120
121        do_process(infile, outfile);
122
123        PERF_SEC_DUMP(parser_timer);
124
125        PERF_SEC_DESTROY(parser_timer);
126
127        fclose(infile);
128        fclose(outfile);
129
130        return(0);
131}
132
133void do_process(FILE *infile, FILE *outfile) {
134
135    @decl
136bool line_match_found=false;
137
138BitBlock match_vector = simd<1>::constant<0>();
139        int match_count=0;
140    int block_base  = 0;
141                int block_pos   = 0;
142    int buffer_base = 0;
143    int buffer_pos  = 0;
144    int chars_avail = 0;
145                int chars_read  = 0;
146
147    //////////////////////////////////////////////////////////////////////////////////////////
148    // Buffer Management
149    //////////////////////////////////////////////////////////////////////////////////////////
150                //      BitBlock buf[(BUFFER_SIZE)/sizeof(BitBlock)];
151                //      uint8_t * src_buffer = (uint8_t *)buf + COPYBACK_SIZE;
152
153                #ifdef STL_ALIGNED_VECTOR
154                        std::vector<uint8_t, AAllocator<uint8_t> > src_buffer;
155                        src_buffer.reserve(BUFFER_SIZE);
156                #else
157                        uint8_t * COPYBACK;
158                        uint8_t * src_buffer;
159                        ALLOC_STATIC_ALIGNED_BYTE_BUFFER_WITH_COPYBACK(COPYBACK, src_buffer);
160                #endif
161       
162                chars_read = fread((void *)&src_buffer[0], 1, SEGMENT_SIZE, infile);
163                chars_avail = chars_read;
164                if (chars_avail >= SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
165
166
167        //////////////////////////////////////////////////////////////////////////////////////////
168        // Read OVERLAP bytes to support post processing validation lookahead.
169        //////////////////////////////////////////////////////////////////////////////////////////
170        chars_read = chars_avail + fread(&src_buffer[chars_avail], 1, LOOKAHEAD_SIZE, infile);
171        chars_avail = chars_read;
172        if (chars_avail >= SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
173
174    @stream_stmts
175
176    //////////////////////////////////////////////////////////////////////////////////////////
177    // Full Segments
178    //////////////////////////////////////////////////////////////////////////////////////////
179       
180        while (chars_avail >= SEGMENT_SIZE) {
181      PERF_SEC_START(parser_timer);
182      for (int blk = 0; blk < SEGMENT_BLOCKS; blk++) {
183          block_base = blk*BLOCK_SIZE;
184                  s2p_do_block((BytePack *) &src_buffer[block_base], basis_bits);
185
186          @block_stmts
187//print_register2("Matches",output.matches,128);
188
189          if (bitblock::any(output.matches)) {
190            if (bitblock::any(simd_and(match_vector, output.matches))) {
191              match_count += bitblock::popcount(match_vector);
192              match_vector = output.matches;
193            }
194            else {
195              match_vector = simd_or(match_vector, output.matches);
196            }
197          }
198
199
200
201
202//print_register2("Matches",output.matches, 128);
203      }
204      PERF_SEC_END(parser_timer, chars_avail);
205
206          memmove(&src_buffer[0], &src_buffer[SEGMENT_SIZE], LOOKAHEAD_SIZE); // CopyBack Trailing Padding
207
208          chars_read = fread(&src_buffer[LOOKAHEAD_SIZE], 1, SEGMENT_SIZE, infile) + LOOKAHEAD_SIZE;
209          chars_avail = chars_read;
210          if (chars_avail >= SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
211          buffer_pos += chars_avail;
212          buffer_base = buffer_pos;
213    }
214
215    //////////////////////////////////////////////////////////////////////////////////////////
216    // Final Partial Segment
217    //////////////////////////////////////////////////////////////////////////////////////////
218    PERF_SEC_START(parser_timer);
219
220    block_pos = 0;
221    int remaining = chars_avail;
222
223    /* Full Blocks */
224    while (remaining >= BLOCK_SIZE) {
225          block_base = block_pos;
226                                s2p_do_block((BytePack *) &src_buffer[block_pos], basis_bits);
227                                @block_stmts
228//print_register2("Matches",output.matches,128);
229          if (bitblock::any(output.matches)) {
230            if (bitblock::any(simd_and(match_vector, output.matches))) {
231              match_count += bitblock::popcount(match_vector);
232              match_vector = output.matches;
233            }
234            else {
235              match_vector = simd_or(match_vector, output.matches);
236            }
237          }
238
239
240
241                                //print_register2("Matches",output.matches,128);
242       block_pos += BLOCK_SIZE;
243          remaining -= BLOCK_SIZE;
244    }
245    block_base = block_pos;
246
247//    Partial Block or Any Carry
248//
249          EOF_mask = bitblock::srl(simd<1>::constant<1>(), convert(BLOCK_SIZE-remaining));
250                                s2p_do_final_block((BytePack *) &src_buffer[block_pos], basis_bits, EOF_mask);
251          @final_block_stmts
252//print_register2("Matches",output.matches,128);
253          match_count += bitblock::popcount(match_vector);
254          if (bitblock::any(output.matches)) {
255            match_count += bitblock::popcount(output.matches);
256          }
257
258//print_register2("Matches",output.matches,128);
259
260    buffer_pos += chars_avail;
261    buffer_base = buffer_pos;
262
263                PERF_SEC_END(parser_timer, chars_avail);
264printf("Matching Lines:%d\n",match_count);
265}
266
Note: See TracBrowser for help on using the repository browser.