source: proto/PDF/pablo_template_pdf.cpp @ 2639

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

Support for longer input

File size: 15.5 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
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>
[2566]16#include <simd-lib/buffer.hpp>
[2560]17#include <perflib/perfsec.h>
18
[2570]19static unsigned int depth = 0;
[2639]20static string outstring="";
21static int startpos=0;
22static int val=0;
23static int cur_state;
[2570]24
25static inline void inc() {
26        depth++;
27}
28
29static inline void dec() {
30        depth--;
31}
[2639]32#define scan_to_next_and_test(scanner, state) \
33        scanner.scan_to_next();\
34        if (scanner.is_done()) {\
35                cur_state=state;\
36                return;\
37                }\
38               
39       
40        //if (scanner.is_done())
[2570]41
42static BitBlock lt_zero() {
43        if (depth < 0) {
[2629]44                return simd<1>::constant<1>();
45        } else {
[2570]46                return simd<1>::constant<0>();
47        }
48}
49
[2629]50static BitBlock gt_zero() {
[2570]51        if (depth > 0) {
[2629]52                return simd<1>::constant<1>();
53        } else {
[2570]54                return simd<1>::constant<0>();
55        }
56}
57
58static BitBlock is_zero() {
59        if (0 == depth) {
[2629]60                return simd<1>::constant<1>();
61        } else {
[2570]62                return simd<1>::constant<0>();
63        }
64}
65
[2560]66// Define the mappings for pablo.assert_0(strm, errkind) statements which
67// compile to the the form assert_0_error(errkind, strm)
68#define assert_0_error(errkind, errstrm) error_tracker.NoteError(errkind, errstrm);
69
70#ifdef BUFFER_PROFILING
71    BOM_Table * parser_timer;
72#elif PAPI
73                #define PAPI_EVENTS_COUNT 2
74                int PAPI_EVENTS[PAPI_EVENTS_COUNT] = {PAPI_TOT_CYC, PAPI_BR_MSP};       
75    CC * parser_timer;
76#else
77    void * parser_timer;
78#endif
79
80BitBlock EOF_mask = simd<1>::constant<1>();
81
82//////////////////////////////////////////////////////////////////////////////////////////
83// Buffer Management
84//////////////////////////////////////////////////////////////////////////////////////////
[2569]85#define PADDING_BLOCKS 1
[2560]86#define PADDING_SIZE (BLOCK_SIZE * PADDING_BLOCKS)
87#define COPYBACK_BLOCKS 0
88#define COPYBACK_SIZE (BLOCK_SIZE * COPYBACK_BLOCKS)
89#define LOOKAHEAD_BLOCKS 1
90#define LOOKAHEAD_SIZE (BLOCK_SIZE * LOOKAHEAD_BLOCKS)
[2569]91#define SEGMENT_BLOCKS  4
[2560]92#define SEGMENT_SIZE (BLOCK_SIZE * SEGMENT_BLOCKS)
93#define BUFFER_SIZE (COPYBACK_SIZE + SEGMENT_SIZE + LOOKAHEAD_SIZE + PADDING_SIZE)
94
95//////////////////////////////////////////////////////////////////////////////////////////
96// @ global depends on 'error_tracker' and 'EOF_mask' definitions.
97//////////////////////////////////////////////////////////////////////////////////////////
98@global
99
100//////////////////////////////////////////////////////////////////////////////////////////
101// Headers that depend @ global stream struct types.
102//////////////////////////////////////////////////////////////////////////////////////////
103#include <transpose.hpp>
104//#include <post_process.hpp>
105
106static void do_process(FILE *infile, FILE *outfile);
107
108int main(int argc, char * argv[]) {
109
110        char * infilename, * outfilename;
111        FILE *infile, *outfile;
112        struct stat fileinfo;
113
114        if (argc < 2) {
115                printf("Usage: %s <filename> [<outputfile>]\n", argv[0]);
116                exit(-1);
117        }
118
119        infilename = argv[1];
120        stat(infilename, &fileinfo);
121        infile = fopen(infilename, "rb");
122        if (!infile) {
123                fprintf(stderr, "Error: cannot open %s for input.\n", infilename);
124                exit(-1);
125        }
126
127        if (argc < 3) outfile = stdout;
128        else {
129                outfilename = argv[2];
130                outfile = fopen(outfilename, "wb");
131                if (!outfile) {
132                        fprintf(stderr, "Error: cannot open %s for writing.\n", outfilename);
133                        exit(-1);
134                }
135        }
136
137        PERF_SEC_BIND(1);
138
139        PERF_SEC_INIT(parser_timer);
140
141        do_process(infile, outfile);
142
143        PERF_SEC_DUMP(parser_timer);
144
145        PERF_SEC_DESTROY(parser_timer);
146
147        fclose(infile);
148        fclose(outfile);
149
150        return(0);
151}
[2629]152/*void print_register2(const char * var_name, BitBlock v, int length) {
153        unsigned char c;
154        printf("%10s = ", var_name);
155        for(int i=(length+7)/8; i>=0; i--) {
156                c = *(((unsigned char *)&v)+i);
157                int div = 128;
158                while (div > 0) {
159                        if (c>=div) {
160                                cout<<"1";
161                                c-=div;
162                        }
163                        else {
164                                cout<<"0";
165                        }
166                        div = div / 2;
167                }
168        }
169        printf("\n");
170}*/
171void print_register2(const char * var_name, BitBlock v, int length) {
172        unsigned char c;
173        printf("%10s = ", var_name);
174        for(int i=0;i<=(length+7)/8; i++) {
175                c = *(((unsigned char *)&v)+i);
176                int count = 0;
177                while (count < 8) {
178                        if ((c % 2)==1)
179                        {
180                                cout<<"1";
181                        }
182                        else {
183                                cout<<"0";
184                        }
185                        c = c / 2;
186                        count+=1;
187                }
188        }
189        printf("\n");
190}
191string get_substring(uint8_t * src_buffer, int start, int end) {
192        string out = "";
193        for (int i =start;i<end;i++) 
194        {
195                out+=src_buffer[i];
196        }
197        return out;
198}       
[2560]199
[2639]200void postprocess_do_block(Marker & marker, uint8_t * src_buffer,  int block_base) {
201               
202                int ch;
203                ForwardScanner<BitBlock, ScanWord> scanner;
204                ForwardScanner<BitBlock, ScanWord> starts_scanner(&(marker.starts));
205                ForwardScanner<BitBlock, ScanWord> others_scanner(&(marker.others));
206                scanner = starts_scanner;
207                switch(cur_state){
208                        case 0:
209                                scanner = starts_scanner;
210                                goto pos0;
211                        case 1:
212                                scanner = others_scanner;
213                                goto pos1;
214                        case 2:
215                                scanner = others_scanner;
216                                goto pos2;
217                        case 3:
218                                scanner = others_scanner;
219                                goto pos3;
220                        case 4:
221                                scanner = others_scanner;
222                                goto pos4;
223                        case 5:
224                                scanner = others_scanner;
225                                goto pos5;
226                        case 6:
227                                scanner = others_scanner;
228                                goto pos6;
229                        case 7:
230                                scanner = others_scanner;
231                                goto pos7;
232                        case 8:
233                                scanner = others_scanner;
234                                goto pos8;
235                        case 9:
236                                scanner = others_scanner;
237                                goto pos9;
238                        case 10:
239                                scanner = starts_scanner;
240                                goto pos10;
241                }
[2560]242
[2639]243               
244                pos0: scan_to_next_and_test(scanner, 0);
[2629]245                while(!scanner.is_done()) {
[2639]246                        switch (src_buffer[block_base+scanner.get_pos()])
[2629]247                        {
248                                case '/':
249                                        cout<<"LexName:";
250                                        outstring = "";
[2639]251                                        startpos = block_base+scanner.get_pos();
[2629]252                                        scanner.set_strm(&(marker.others));
253                                        scanner.move_to(scanner.get_pos());
[2639]254                                        pos1: scan_to_next_and_test(scanner, 1);
[2629]255                                       
256                                       
[2639]257                                        ch = src_buffer[block_base+scanner.get_pos()];
[2629]258                                        while (('0'<=ch && ch<='9') || ('A'<=ch && ch<='F') ||('a'<=ch && ch<='f')) {
259                                                outstring+=get_substring(src_buffer,startpos+1, scanner.get_pos()-2);
[2639]260                                                startpos = block_base+scanner.get_pos();
[2629]261                                                if (ch<='9')            val =  ch - '0';
262                                                else if (ch<='F')       val = 10 + ch - 'A';
263                                                else val = 10 + ch - 'a';
[2639]264                                                ch = src_buffer[block_base+scanner.get_pos()-1];
[2629]265                                               
266                                                if (ch<='9')            val = val + 16*(ch - '0');
267                                                else if (ch<='F')       val = val+16*(10 + ch - 'A');
268                                                else val = val+ 16*(10 + ch - 'a');
269                                                outstring+=val;
270                                                scanner.scan_to_next();
[2639]271                                                ch = src_buffer[block_base+scanner.get_pos()];
[2629]272                                        }
[2639]273                                        outstring+=get_substring(src_buffer,startpos+1,block_base+scanner.get_pos());
[2629]274                                        scanner.set_strm(&(marker.starts));
275                                        scanner.move_to(scanner.get_pos()-1);
276                                        cout<<outstring<<endl;
277                       
278                                       
279                                        break;
280                                case '(':
281                                        cout<<"LexLiteralString:";
282                                        outstring="";
[2639]283                                        startpos = block_base+scanner.get_pos();
[2629]284                                        scanner.set_strm(&(marker.others));
285                                        scanner.move_to(scanner.get_pos());
[2639]286                                        pos2: scan_to_next_and_test(scanner, 2);
[2629]287                                        while (!scanner.is_done()) {
[2639]288                                                outstring+=get_substring(src_buffer, startpos+1,block_base+scanner.get_pos());
289                                                if (src_buffer[block_base+scanner.get_pos()]==')') {
[2629]290                                                        cout<<outstring<<endl;
291                                                        break;
292                                                }
[2639]293                                                startpos=block_base+scanner.get_pos();
294                                                if (src_buffer[block_base+scanner.get_pos()]=='\\') {
295                                                        ch = src_buffer[block_base+scanner.get_pos()+1];
[2629]296                                                        switch (ch) {
297                                                                case 'n':
298                                                                        outstring+=0x0A;
299                                                                        break;
300                                                                case 'r':
301                                                                        outstring+=0x0D;
302                                                                        break;
303                                                                case 't':
304                                                                        outstring+=0x09;
305                                                                        break;
306                                                                case 'b':
307                                                                        outstring+=0x08;
308                                                                        break;
309                                                                case 'f':
310                                                                        outstring+=0x0C;
311                                                                        break;
312                                                                case 0: case 1:
313                                                                case 2: case 3:
314                                                                case 4: case 5:
315                                                                case 6: case 7:
316                                                                        val = ch - '0';
[2639]317                                                                        if ((src_buffer[block_base+scanner.get_pos()+2]) >= '0' && (src_buffer[block_base+scanner.get_pos()+2]<='8')) {
318                                                                                val = val*8 + src_buffer[block_base+scanner.get_pos()+2]-'0';
[2629]319                                                                                startpos+=1;
[2639]320                                                                                if ((src_buffer[block_base+scanner.get_pos()+3]) >= '0' && (src_buffer[block_base+scanner.get_pos()+3]<='8')) {
321                                                                                        val = val*8 + src_buffer[block_base+scanner.get_pos()+3]-'0';
[2629]322                                                                                        startpos+=1;
323                                                                                }
324                                                                        }
325                                                                        val = val & 0xFF;
326                                                                        outstring+=val;
327                                                                        break;
328                                                                case 13:
[2639]329                                                                        if (src_buffer[block_base+scanner.get_pos()+2]==10) {
[2629]330                                                                                startpos+=1;
331                                                                        }
332                                                                        break;
333                                                                case 10:
334                                                                        break;
335                                                                default:
336                                                                        outstring+=ch;
337                                                        }
338                                                        startpos+=1;
339                                       
340                                       
341                                                }
342                                                else {
343                                                        outstring+=0x0A;
[2639]344                                                        if (src_buffer[block_base+scanner.get_pos()+1]==0x0a) {
[2629]345                                                                startpos+=1;
346                                                        }
347                                                }
[2639]348                                                //CHANGE FOR FINAL BLOCK
349                                                pos3: scan_to_next_and_test(scanner, 3);
[2629]350                                        }
351                                       
352                                        if (scanner.is_done()) {
353                                                cout << "Corrupt string"<<endl;
354                                        }
355                                        scanner.set_strm(&(marker.starts));
356                                        scanner.move_to(scanner.get_pos()-1);
357                                        break;
358                                case '0': case '1':
359                                case '2': case '3':
360                                case '4': case '5':
361                                case '6': case '7':
362                                case '8': case '9':
363                                case '.': case '+':
364                                case '-':
365                                        cout << "LexNumber:";
366                                               
[2639]367                                        startpos = block_base+scanner.get_pos();
[2629]368                                        scanner.set_strm(&(marker.others));
369                                        scanner.move_to(scanner.get_pos());
[2639]370                                        pos4: scan_to_next_and_test(scanner, 4);
[2629]371                                       
[2639]372                                        outstring=get_substring(src_buffer,startpos,block_base+scanner.get_pos());
[2629]373                                        scanner.set_strm(&(marker.starts));
374                                        scanner.move_to(scanner.get_pos()-1);
375                                        cout<<outstring<<endl;
376                                        break;
377                                case '<':
378                                        cout << "LexHexString:";
379                                        outstring="";
380                                        scanner.set_strm(&(marker.others));
381                                        scanner.move_to(scanner.get_pos());
[2639]382                                        pos5: scan_to_next_and_test(scanner, 5);
383                                        ch = src_buffer[block_base+scanner.get_pos()];
[2629]384                                        while (('0'<=ch && ch<='9') || ('A'<=ch && ch<='F') ||('a'<=ch && ch<='f')) {
385                                                if (ch<='9')            val =  16*(ch - '0');
386                                                else if (ch<='F')       val = 16*(10 + ch - 'A');
387                                                else val = 16*(10 + ch - 'a');
[2639]388                                                pos6: scan_to_next_and_test(scanner, 6);
389                                                ch = src_buffer[block_base+scanner.get_pos()];
[2629]390                                                if (('0'<=ch && ch<='9') || ('A'<=ch && ch<='F') ||('a'<=ch && ch<='f')) {
391                                                        if (ch<='9')            val +=  (ch - '0');
392                                                        else if (ch<='F')       val += (10 + ch - 'A');
393                                                        else val += 10 + ch - 'a';
[2639]394                                                       
395                                                        //CHANGE FOR FINAL BLOCK (If scanner.is_done(), BASE_ASSERT)
396                                                        pos7: scan_to_next_and_test(scanner, 7);
397                                                       
398                                                       
399                                                        ch = src_buffer[block_base+scanner.get_pos()];
[2629]400                                                }
401                                                outstring+=val;
402                                        }
403                                        if (ch !='>') {
404                                                cout<<"BASE_ASSERT(false, \"Bad String\");"<<endl;
405                                        }
406                                        else
407                                        {
408                                                cout<<outstring<<endl;
409                                        }
410                                        scanner.set_strm(&(marker.starts));
411                                        scanner.move_to(scanner.get_pos()-1);                                   
412                                        break;
413                                case ')':
414                                        cout << "BASE_ASSERT(false, \"')' is not matched\");"<<endl;//"BASE_ASSERT(false, "\')\' is not matched");"
415                                        break;
416                                case '[':
417                                        cout<<"Array Start"<<endl;
418                                        scanner.set_strm(&(marker.others));
419                                        scanner.move_to(scanner.get_pos());
[2639]420                                        pos8: scan_to_next_and_test(scanner, 8);
[2629]421                                        scanner.set_strm(&(marker.starts));
422                                       
423                                        scanner.move_to(scanner.get_pos()-1);
424                                        break;
425                                default:
426                                        cout<<"LexDefault:";
[2639]427                                        startpos = block_base+scanner.get_pos();
[2629]428                                        scanner.set_strm(&(marker.others));
429                                        scanner.move_to(scanner.get_pos());
[2639]430                                        pos9: scan_to_next_and_test(scanner, 9);
431                                        outstring = get_substring(src_buffer,startpos,block_base+scanner.get_pos());
[2629]432                                        if (outstring=="null") {
433                                                cout << "NULL OBJECT"<<endl;
434                                        } else if (outstring=="true") {
435                                                cout << "TRUE OBJECT"<<endl;
436                                        } else if (outstring =="false") {
437                                                cout << "FALSE OBJECT"<<endl;
438                                        } else {
439                                                cout << "RETURN FALSE:"<<outstring<<endl;
440                                        }
441                                        scanner.set_strm(&(marker.starts));
442                                        scanner.move_to(scanner.get_pos()-1);
443                                       
444                                }
445                               
[2560]446
[2629]447                        if(!scanner.is_done()) {
[2639]448                                pos10: scan_to_next_and_test(scanner, 10);
[2629]449                        }
450                }
451                 
452                 
453                 
454                 
455                 
456                 
457                 
458                 
459                 
460                 
461                 
[2639]462
463
464
465
466
467}
468
469void do_process(FILE *infile, FILE *outfile) {
470        @decl
471
472        /* Extras */
473        parity.odd = simd<2>::constant<1>();
474        parity.even = simd<2>::constant<2>();
475
476        int block_base = 0;
477        int block_pos = 0;
478        int chars_avail = 0;
479        int chars_read = 0;
480        int padding_read = 0;
481        int remaining = 0;
482
483  /* Tracked for post processing */
484        //int buffer_base=0;
485        //int buffer_pos = 0;
486
487        //////////////////////////////////////////////////////////////////////////////////////////
488        // Buffer Management
489        //////////////////////////////////////////////////////////////////////////////////////////
490        uint8_t * src_buffer;
491        ALLOC_STATIC_ALIGNED_BYTE_BUFFER(src_buffer, BUFFER_SIZE);
492   
493        //////////////////////////////////////////////////////////////////////////////////////////
494        // Initial file read
495        //////////////////////////////////////////////////////////////////////////////////////////
496        chars_read = fread((void *)src_buffer, 1, SEGMENT_SIZE + LOOKAHEAD_SIZE, infile);
497        remaining = chars_read;
498        chars_avail = chars_read;       
499        padding_read = chars_read - SEGMENT_SIZE;
500
501        if (chars_avail >= SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
502
503        @stream_stmts
504
505        //////////////////////////////////////////////////////////////////////////////////////////
506        // Processs Full Segments
507        //////////////////////////////////////////////////////////////////////////////////////////
508        while (chars_avail >= SEGMENT_SIZE) {
509          PERF_SEC_START(parser_timer);
510          for (int blk = 0; blk < SEGMENT_BLOCKS; blk++) {
511                  block_base = blk*BLOCK_SIZE;
512                  s2p_do_block((BytePack *) &src_buffer[block_base], basis_bits);
513
514                        #ifdef PDF_DEBUG
515                        for (int i = 0; i < BLOCK_SIZE; i++) {
516                                cout << src_buffer[block_base + i];
517                        }
518                        #endif
519
520                  @block_stmts
521
522                  //postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, (char *)src_buffer, buffer_base, block_base,chars_avail, tracker);
523
524          }
525          PERF_SEC_END(parser_timer, chars_avail);
526
527                remaining -= SEGMENT_SIZE;
528          memmove(src_buffer, &src_buffer[SEGMENT_SIZE], padding_read); 
529          chars_read = fread(&src_buffer[padding_read], 1, (SEGMENT_SIZE + LOOKAHEAD_SIZE - padding_read), infile);
530
531                padding_read = SEGMENT_SIZE + LOOKAHEAD_SIZE - padding_read ;//chars_read;
532
533                remaining += chars_read;
534                chars_avail = remaining;
535
536                if (chars_avail >= SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
537
538    /* Tracked for post processing */
539          // buffer_pos += chars_avail;
540          // buffer_base = buffer_pos;
541
542        }
543
544        //////////////////////////////////////////////////////////////////////////////////////////
545        // Final Partial Segment
546        //////////////////////////////////////////////////////////////////////////////////////////
547        PERF_SEC_START(parser_timer);
548
549        block_base = 0;
550
551        /* Full Blocks */
552        uint32_t blk = 0;
553        while (remaining >= BLOCK_SIZE) {
554       
555                        #ifdef PDF_DEBUG
556                        for(int i = 0; i < BLOCK_SIZE; i++) {
557                                cout << src_buffer[block_base + i];
558                        }
559                        #endif         
560
561                  s2p_do_block((BytePack *) &src_buffer[block_base], basis_bits);
562                  @block_stmts
563
564      postprocess_do_block(marker, src_buffer,  block_base);
565
566                  block_base += BLOCK_SIZE;
567                  remaining -= BLOCK_SIZE;
568                  blk++;
569        }
570
571        /* Partial Block or Any Carry */
572        if (remaining > 0 || @any_carry) {
573
574                        #ifdef PDF_DEBUG
575                        for(int i = 0; i < remaining; i++) 
576                        {                               
577                                std::cout << src_buffer[block_base+i];
578                        }
579                        #endif
580
581                  EOF_mask = bitblock::srl(simd<1>::constant<1>(), convert(BLOCK_SIZE-remaining));
582                  s2p_do_final_block((BytePack *) &src_buffer[block_base], basis_bits, EOF_mask);
583                  @final_block_stmts
584                  //print_register2("markstarts",marker.starts,remaining);
[2629]585                 
586                 
[2639]587                 
588                 
589       postprocess_do_block(marker, src_buffer,  block_base);
[2560]590                  blk++;
591        }
592
[2566]593        /* Tracked for post processing */
594        // buffer_pos += chars_avail;
595        // buffer_base = buffer_pos;
[2560]596
597        PERF_SEC_END(parser_timer, chars_avail);
598}
599
Note: See TracBrowser for help on using the repository browser.