source: proto/PDF/pablo_template_pdf.cpp @ 2569

Last change on this file since 2569 was 2569, checked in by ksherdy, 7 years ago

Updated compilable.

File size: 6.8 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 1
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  4
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        padding_read = chars_read - SEGMENT_SIZE;
156
157        if (chars_avail >= SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
158
159        @stream_stmts
160
161        //////////////////////////////////////////////////////////////////////////////////////////
162        // Processs Full Segments
163        //////////////////////////////////////////////////////////////////////////////////////////
164        while (chars_avail >= SEGMENT_SIZE) {
165          PERF_SEC_START(parser_timer);
166          for (int blk = 0; blk < SEGMENT_BLOCKS; blk++) {
167                  block_base = blk*BLOCK_SIZE;
168                  s2p_do_block((BytePack *) &src_buffer[block_base], basis_bits);
169
170                        #ifdef PDF_DEBUG
171                        for (int i = 0; i < BLOCK_SIZE; i++) {
172                                cout << src_buffer[block_base + i];
173                        }
174                        #endif
175
176                  @block_stmts
177
178                  //postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, (char *)src_buffer, buffer_base, block_base,chars_avail, tracker);
179
180          }
181          PERF_SEC_END(parser_timer, chars_avail);
182
183                remaining -= SEGMENT_SIZE;
184          memmove(src_buffer, &src_buffer[SEGMENT_SIZE], padding_read); 
185          chars_read = fread(&src_buffer[padding_read], 1, (SEGMENT_SIZE + LOOKAHEAD_SIZE - padding_read), infile);
186
187                padding_read = SEGMENT_SIZE + LOOKAHEAD_SIZE - padding_read ;//chars_read;
188
189                remaining += chars_read;
190                chars_avail = remaining;
191
192                if (chars_avail >= SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
193
194    /* Tracked for post processing */
195          // buffer_pos += chars_avail;
196          // buffer_base = buffer_pos;
197
198        }
199
200        //////////////////////////////////////////////////////////////////////////////////////////
201        // Final Partial Segment
202        //////////////////////////////////////////////////////////////////////////////////////////
203        PERF_SEC_START(parser_timer);
204
205        block_base = 0;
206
207        /* Full Blocks */
208        uint32_t blk = 0;
209        while (remaining >= BLOCK_SIZE) {
210       
211                        #ifdef PDF_DEBUG
212                        for(int i = 0; i < BLOCK_SIZE; i++) {
213                                cout << src_buffer[block_base + i];
214                        }
215                        #endif         
216
217                  s2p_do_block((BytePack *) &src_buffer[block_base], basis_bits);
218                  @block_stmts
219
220      // postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, (char *)src_buffer, buffer_base, block_base, chars_avail, tracker);
221
222                  block_base += BLOCK_SIZE;
223                  remaining -= BLOCK_SIZE;
224                  blk++;
225        }
226
227        /* Partial Block or Any Carry */
228        if (remaining > 0 || @any_carry) {
229
230                        #ifdef PDF_DEBUG
231                        for(int i = 0; i < remaining; i++) 
232                        {                               
233                                std::cout << src_buffer[block_base+i];
234                        }
235                        #endif
236
237                  EOF_mask = bitblock::srl(simd<1>::constant<1>(), convert(BLOCK_SIZE-remaining));
238                  s2p_do_final_block((BytePack *) &src_buffer[block_base], basis_bits, EOF_mask);
239                  @final_block_stmts
240
241      // postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, (char *)src_buffer, buffer_base, block_base, chars_avail, tracker);
242                  blk++;
243        }
244
245        /* Tracked for post processing */
246        // buffer_pos += chars_avail;
247        // buffer_base = buffer_pos;
248
249        PERF_SEC_END(parser_timer, chars_avail);
250}
251
Note: See TracBrowser for help on using the repository browser.