source: proto/PDF/pablo_template_pdf.cpp @ 2570

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

Updated Makefile, compilable, template.

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