source: proto/matchparens/pdfparentemplate.cpp @ 3834

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

PDF-style parenthesis matching prototypes including Pablo compilable.

File size: 5.9 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 <iostream>
7using namespace std;
8
9#define LocalCarryDeclare(name, count)\
10CarryArray<count, 0> name;\
11
12#include <bitblock.hpp>
13#include <carryQ.hpp>
14#include <pabloSupport.hpp>
15#include <bitblock_iterator.hpp>
16#include <s2p.hpp>
17#include <buffer.hpp>
18#include <perflib/perfsec.h>
19
20// Define the mappings for pablo.assert_0(strm, errkind) statements which
21// compile to the the form assert_0_error(errkind, strm)
22#define assert_0_error(errkind, errstrm) error_tracker.NoteError(errkind, errstrm);
23
24#ifdef BUFFER_PROFILING
25    BOM_Table * parser_timer;
26#elif PAPI
27                #define PAPI_EVENTS_COUNT 2
28                int PAPI_EVENTS[PAPI_EVENTS_COUNT] = {PAPI_TOT_CYC, PAPI_BR_MSP};       
29    CC * parser_timer;
30#else
31    void * parser_timer;
32#endif
33
34BitBlock EOF_mask = simd<1>::constant<1>();
35
36//////////////////////////////////////////////////////////////////////////////////////////
37// Buffer Management
38//////////////////////////////////////////////////////////////////////////////////////////
39#define PADDING_BLOCKS 1
40#define PADDING_SIZE (BLOCK_SIZE * PADDING_BLOCKS)
41#define COPYBACK_BLOCKS 1
42#define COPYBACK_SIZE (BLOCK_SIZE * COPYBACK_BLOCKS)
43#define LOOKAHEAD_BLOCKS 0
44#define LOOKAHEAD_SIZE (BLOCK_SIZE * LOOKAHEAD_BLOCKS)
45#define SEGMENT_BLOCKS  16
46#define SEGMENT_SIZE (BLOCK_SIZE * SEGMENT_BLOCKS)
47#define BUFFER_SIZE (COPYBACK_SIZE + SEGMENT_SIZE + LOOKAHEAD_SIZE + PADDING_SIZE)
48
49//////////////////////////////////////////////////////////////////////////////////////////
50// @ global depends on 'error_tracker' and 'EOF_mask' definitions.
51//////////////////////////////////////////////////////////////////////////////////////////
52@global
53
54//////////////////////////////////////////////////////////////////////////////////////////
55// Headers that depend @ global stream struct types.
56//////////////////////////////////////////////////////////////////////////////////////////
57#include <transpose.hpp>
58
59void do_process(FILE *infile, FILE *outfile) {
60        @decl
61
62
63        int block_base = 0;
64        int block_pos = 0;
65        int chars_avail = 0;
66        int chars_read = 0;
67        int padding_read = 0;
68        int remaining = 0;
69        //////////////////////////////////////////////////////////////////////////////////////////
70        // Buffer Management
71        //////////////////////////////////////////////////////////////////////////////////////////
72        uint8_t * src_buffer;
73        ALLOC_STATIC_ALIGNED_BYTE_BUFFER(src_buffer, BUFFER_SIZE);
74   
75        //////////////////////////////////////////////////////////////////////////////////////////
76        // Initial file read
77        //////////////////////////////////////////////////////////////////////////////////////////
78        chars_read = fread((void *)&src_buffer[COPYBACK_SIZE], 1, SEGMENT_SIZE + LOOKAHEAD_SIZE, infile);
79        remaining = chars_read;
80        chars_avail = chars_read;       
81        padding_read = chars_read - SEGMENT_SIZE;
82int position = 0;
83        if (chars_avail >= SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
84
85        @stream_stmts
86
87        //////////////////////////////////////////////////////////////////////////////////////////
88        // Processs Full Segments
89        //////////////////////////////////////////////////////////////////////////////////////////
90        while (chars_avail >= SEGMENT_SIZE) {
91          PERF_SEC_START(parser_timer);
92          for (int blk = 0; blk < SEGMENT_BLOCKS; blk++) {
93                  block_base = blk*BLOCK_SIZE+COPYBACK_SIZE;
94                  s2p_do_block((BytePack *) &src_buffer[block_base], basis_bits);
95
96                        #ifdef PDF_DEBUG
97                        for (int i = 0; i < BLOCK_SIZE; i++) {
98                                cout << src_buffer[block_base + i];
99                        }
100                        #endif
101
102                  @block_stmts
103
104          }
105
106
107
108          PERF_SEC_END(parser_timer, chars_avail);
109
110                remaining -= SEGMENT_SIZE;
111          memmove(src_buffer, &src_buffer[SEGMENT_SIZE-COPYBACK_SIZE], padding_read+COPYBACK_SIZE); 
112          chars_read = fread(&src_buffer[padding_read+COPYBACK_SIZE], 1, (SEGMENT_SIZE + LOOKAHEAD_SIZE - padding_read), infile);
113                padding_read = chars_read-(SEGMENT_SIZE + LOOKAHEAD_SIZE - padding_read) ;//chars_read;
114
115                remaining += chars_read;
116                chars_avail = remaining;
117
118                if (chars_avail >= SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
119
120
121        }
122
123        //////////////////////////////////////////////////////////////////////////////////////////
124        // Final Partial Segment
125        //////////////////////////////////////////////////////////////////////////////////////////
126        PERF_SEC_START(parser_timer);
127
128        block_base = COPYBACK_SIZE;
129
130        /* Full Blocks */
131        uint32_t blk = 0;
132        while (remaining >= BLOCK_SIZE) {
133       
134
135                  s2p_do_block((BytePack *) &src_buffer[block_base], basis_bits);
136                  @block_stmts
137
138                  print_register<BitBlock>("matches.instring", matches.instring);
139                  print_register<BitBlock>("matches.error", matches.error);
140                  block_base += BLOCK_SIZE;
141                  remaining -= BLOCK_SIZE;
142                  blk++;
143        }
144
145        /* Partial Block or Any Carry */
146
147                  EOF_mask = bitblock::srl(simd<1>::constant<1>(), convert(BLOCK_SIZE-remaining));
148                  s2p_do_final_block((BytePack *) &src_buffer[block_base], basis_bits, EOF_mask);
149                  @final_block_stmts
150                  print_register<BitBlock>("matches.instring", matches.instring);
151                  print_register<BitBlock>("matches.error", matches.error);
152                  blk++;
153        PERF_SEC_END(parser_timer, chars_avail);
154}
155
156
157
158
159int main(int argc, char * argv[]) {
160
161        char * infilename, * outfilename;
162        FILE *infile, *outfile;
163        struct stat fileinfo;
164
165        if (argc < 2) {
166                printf("Usage: %s <filename> [<outputfile>]\n", argv[0]);
167                exit(-1);
168        }
169
170        infilename = argv[1];
171        stat(infilename, &fileinfo);
172        infile = fopen(infilename, "rb");
173        if (!infile) {
174                fprintf(stderr, "Error: cannot open %s for input.\n", infilename);
175                exit(-1);
176        }
177
178        if (argc < 3) outfile = stdout;
179        else {
180                outfilename = argv[2];
181                outfile = fopen(outfilename, "wb");
182                if (!outfile) {
183                        fprintf(stderr, "Error: cannot open %s for writing.\n", outfilename);
184                        exit(-1);
185                }
186        }
187
188        //PERF_SEC_BIND(1);
189
190        PERF_SEC_INIT(parser_timer);
191
192        do_process(infile, outfile);
193
194        PERF_SEC_DUMP(parser_timer);
195
196        PERF_SEC_DESTROY(parser_timer);
197
198        fclose(infile);
199        fclose(outfile);
200
201        return(0);
202}
203
Note: See TracBrowser for help on using the repository browser.