source: proto/PDF/pablo_template_pdf.cpp @ 2568

Last change on this file since 2568 was 2568, checked in by bhull, 7 years ago

Changes to template

File size: 7.3 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 PDF_DEBUG
10
11#define depth 0
12
13#define inc()\
14        depth++;
15
16#define dec()\
17        depth--;
18
19#define lt_zero()\
20        (depth < 0)
21
22#define gt_zero()\
23        (depth > 0)
24
25#define is_zero()\
26        (0==depth)
27
28#define LocalCarryDeclare(name, count)\
29CarryArray<count, 0> name;\
30
31#include <simd-lib/bitblock.hpp>
32#include <simd-lib/carryQ.hpp>
33#include <simd-lib/bitblock_iterator.hpp>
34#include <simd-lib/s2p.hpp>
35#include <simd-lib/buffer.hpp>
36#include <perflib/perfsec.h>
37
38// Define the mappings for pablo.assert_0(strm, errkind) statements which
39// compile to the the form assert_0_error(errkind, strm)
40#define assert_0_error(errkind, errstrm) error_tracker.NoteError(errkind, errstrm);
41
42#ifdef BUFFER_PROFILING
43    BOM_Table * parser_timer;
44#elif PAPI
45                #define PAPI_EVENTS_COUNT 2
46                int PAPI_EVENTS[PAPI_EVENTS_COUNT] = {PAPI_TOT_CYC, PAPI_BR_MSP};       
47    CC * parser_timer;
48#else
49    void * parser_timer;
50#endif
51
52BitBlock EOF_mask = simd<1>::constant<1>();
53
54//////////////////////////////////////////////////////////////////////////////////////////
55// Buffer Management
56//////////////////////////////////////////////////////////////////////////////////////////
57#define PADDING_BLOCKS 0
58#define PADDING_SIZE (BLOCK_SIZE * PADDING_BLOCKS)
59#define COPYBACK_BLOCKS 0
60#define COPYBACK_SIZE (BLOCK_SIZE * COPYBACK_BLOCKS)
61#define LOOKAHEAD_BLOCKS 1
62#define LOOKAHEAD_SIZE (BLOCK_SIZE * LOOKAHEAD_BLOCKS)
63#define SEGMENT_BLOCKS  1
64#define SEGMENT_SIZE (BLOCK_SIZE * SEGMENT_BLOCKS)
65#define BUFFER_SIZE (COPYBACK_SIZE + SEGMENT_SIZE + LOOKAHEAD_SIZE + PADDING_SIZE)
66
67//////////////////////////////////////////////////////////////////////////////////////////
68// @ global depends on 'error_tracker' and 'EOF_mask' definitions.
69//////////////////////////////////////////////////////////////////////////////////////////
70@global
71
72//////////////////////////////////////////////////////////////////////////////////////////
73// Headers that depend @ global stream struct types.
74//////////////////////////////////////////////////////////////////////////////////////////
75#include <transpose.hpp>
76//#include <post_process.hpp>
77
78static void do_process(FILE *infile, FILE *outfile);
79
80int main(int argc, char * argv[]) {
81
82        char * infilename, * outfilename;
83        FILE *infile, *outfile;
84        struct stat fileinfo;
85
86        if (argc < 2) {
87                printf("Usage: %s <filename> [<outputfile>]\n", argv[0]);
88                exit(-1);
89        }
90
91        infilename = argv[1];
92        stat(infilename, &fileinfo);
93        infile = fopen(infilename, "rb");
94        if (!infile) {
95                fprintf(stderr, "Error: cannot open %s for input.\n", infilename);
96                exit(-1);
97        }
98
99        if (argc < 3) outfile = stdout;
100        else {
101                outfilename = argv[2];
102                outfile = fopen(outfilename, "wb");
103                if (!outfile) {
104                        fprintf(stderr, "Error: cannot open %s for writing.\n", outfilename);
105                        exit(-1);
106                }
107        }
108
109        PERF_SEC_BIND(1);
110
111        PERF_SEC_INIT(parser_timer);
112
113        do_process(infile, outfile);
114
115        PERF_SEC_DUMP(parser_timer);
116
117        PERF_SEC_DESTROY(parser_timer);
118
119        fclose(infile);
120        fclose(outfile);
121
122        return(0);
123}
124
125void do_process(FILE *infile, FILE *outfile) {
126        @decl
127
128        /* Extras */
129        parity.odd = simd<2>::constant<1>();
130        parity.even = simd<2>::constant<2>();
131
132        int block_base = 0;
133        int block_pos = 0;
134        int chars_avail = 0;
135        int chars_read = 0;
136        int padding_read = 0;
137        int remaining = 0;
138
139  /* Tracked for post processing */
140        //int buffer_base=0;
141        //int buffer_pos = 0;
142
143        //////////////////////////////////////////////////////////////////////////////////////////
144        // Buffer Management
145        //////////////////////////////////////////////////////////////////////////////////////////
146        uint8_t * src_buffer;
147        ALLOC_STATIC_ALIGNED_BYTE_BUFFER(src_buffer, BUFFER_SIZE);
148   
149        //////////////////////////////////////////////////////////////////////////////////////////
150        // Initial file read
151        //////////////////////////////////////////////////////////////////////////////////////////
152        chars_read = fread((void *)src_buffer, 1, SEGMENT_SIZE + LOOKAHEAD_SIZE, infile);
153        remaining = chars_read;
154        chars_avail = chars_read;
155
156        //////////////////////////////////////////////////////////////////////////////////////////
157        // Read OVERLAP bytes to support post processing validation lookahead.
158        //
159        // For example, true, false, null marked that overlap end of the segment.
160        //
161        //////////////////////////////////////////////////////////////////////////////////////////
162       
163        padding_read = chars_read - SEGMENT_SIZE;
164
165        cout << "padding_read: " << padding_read << endl;
166       
167
168//      remaining += padding_read;
169//      chars_avail += padding_read;
170
171        if (chars_avail >= SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
172
173        @stream_stmts
174
175        //////////////////////////////////////////////////////////////////////////////////////////
176        // Processs Full Segments
177        //////////////////////////////////////////////////////////////////////////////////////////
178        while (chars_avail >= SEGMENT_SIZE) {
179          PERF_SEC_START(parser_timer);
180          for (int blk = 0; blk < SEGMENT_BLOCKS; blk++) {
181                  block_base = blk*BLOCK_SIZE;
182                  s2p_do_block((BytePack *) &src_buffer[block_base], basis_bits);
183
184                        #ifdef PDF_DEBUG
185                        //cout << endl << "SEGMENTS" << endl;
186                        for (int i = 0; i < BLOCK_SIZE; i++) {
187                                cout << src_buffer[block_base + i];
188                        }
189                        #endif
190
191                  @block_stmts
192
193                  //postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, (char *)src_buffer, buffer_base, block_base,chars_avail, tracker);
194
195          }
196          PERF_SEC_END(parser_timer, chars_avail);
197
198                remaining -= SEGMENT_SIZE;
199          memmove(src_buffer, &src_buffer[SEGMENT_SIZE], padding_read); 
200          chars_read = fread(&src_buffer[padding_read], 1, (SEGMENT_SIZE + LOOKAHEAD_SIZE - padding_read), infile);
201
202                padding_read = SEGMENT_SIZE + LOOKAHEAD_SIZE - padding_read ;//chars_read;
203
204                remaining += chars_read;
205                chars_avail = remaining;
206
207                if (chars_avail >= SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
208
209    /* Tracked for post processing */
210          // buffer_pos += chars_avail;
211          // buffer_base = buffer_pos;
212
213        }
214
215        //////////////////////////////////////////////////////////////////////////////////////////
216        // Final Partial Segment
217        //////////////////////////////////////////////////////////////////////////////////////////
218        PERF_SEC_START(parser_timer);
219
220        block_base = 0;
221
222        /* Full Blocks */
223        uint32_t blk = 0;
224        while (remaining >= BLOCK_SIZE) {
225       
226                        #ifdef PDF_DEBUG
227                        //cout << endl << "FULL BLOCK" << endl;
228                        for(int i = 0; i < BLOCK_SIZE; i++) {
229                                cout << src_buffer[block_base + i];
230                        }
231                        #endif         
232
233                  s2p_do_block((BytePack *) &src_buffer[block_base], basis_bits);
234                  @block_stmts
235
236      // postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, (char *)src_buffer, buffer_base, block_base, chars_avail, tracker);
237
238                  block_base += BLOCK_SIZE;
239                  remaining -= BLOCK_SIZE;
240                  blk++;
241        }
242
243        /* Partial Block or Any Carry */
244        if (remaining > 0 || @any_carry) {
245
246                        #ifdef PDF_DEBUG
247                        for(int i = 0; i < remaining; i++) 
248                        {                               
249                                std::cout << src_buffer[block_base+i];
250                        }
251                        #endif
252
253                  EOF_mask = bitblock::srl(simd<1>::constant<1>(), convert(BLOCK_SIZE-remaining));
254                  s2p_do_final_block((BytePack *) &src_buffer[block_base], basis_bits, EOF_mask);
255                  @final_block_stmts
256
257      // postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, (char *)src_buffer, buffer_base, block_base, chars_avail, tracker);
258                  blk++;
259        }
260
261        /* Tracked for post processing */
262        // buffer_pos += chars_avail;
263        // buffer_base = buffer_pos;
264
265        PERF_SEC_END(parser_timer, chars_avail);
266}
267
Note: See TracBrowser for help on using the repository browser.