source: proto/PDF/pablo_template_pdf.cpp @ 2567

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

Updated template buffering.

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