Changeset 3793


Ignore:
Timestamp:
Apr 5, 2014, 4:03:18 AM (4 years ago)
Author:
ksherdy
Message:

Cleaned up templates.

Location:
proto/s2k/trunk/demo/grep/src
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • proto/s2k/trunk/demo/grep/src/grep_example_segment_at_a_time.cpp

    r3781 r3793  
    1212#define DEBUG 0
    1313
    14 #include "/home/ken/workspace/s2k/output/cpplang/grep/grep_definitions.hpp"
     14#include "/home/ken/workspace/s2k/output/cpplang/grep/grep.hpp"
    1515
    1616// Run-time support.
  • proto/s2k/trunk/demo/grep/src/grep_segment_at_a_time.cpp

    r3781 r3793  
    1010 * Implements a line-at-a-time copyback or fixed length match copyback.
    1111 *
     12 * Does not propagate information across segment of EOF boundary. A general solution
     13 * must address this using any_carry() or correct scanner line length in this template.
     14 *
    1215 **/
    1316
    1417#define DEBUG 0
    1518
    16 #include "/home/ken/workspace/s2k/output/cpplang/grep/grep_definitions.hpp"
     19#include "/home/ken/workspace/s2k/output/cpplang/grep/grep.hpp"
    1720
    1821// Run-time support.
     
    112115  }
    113116
    114   // preheader
     117  // loop_preheader()
    115118  // {
    116119
     
    151154  // Segment-at-a-time offset
    152155  // int block_base_offset    = 0;
     156  int block_index             = 0;
    153157  int segment_base            = 0; 
    154158 
     
    160164  int line_final_start_offset = 0;
    161165  int line_final_end_offset   = 0; 
    162   // }
     166 
     167  // } // end loop_preheader()
    163168 
    164169  // Segment-at-a-time processing.
    165170  while(!feof(infile)) {
    166 
    167     // loop_header()
    168     block_index = 0;   
    169    
    170     // scanners
    171     matches_scanner.init();
    172     line_starts_scanner.init();
    173     line_ends_scanner.init();
     171   
     172        // loop_header()
     173        // {
    174174     
    175     // ReadStream(), BufferSource(), BufferSink(). Read input stream segment-at-a-time.
    176     bytes_read      = fread(buffer + copy_back_size, 1, SEGMENT_SIZE - copy_back_size, infile);
    177     bytes_avail     = bytes_read + copy_back_size;
    178     bytes_remaining = bytes_avail;
    179        
    180     if(ferror(infile)) { perror( "io error" ); exit(1); }
    181     assert(("fread exceeded segment size.", bytes_avail <= SEGMENT_SIZE));
    182 
    183     // Process full segment.
    184     if (bytes_remaining == SEGMENT_SIZE) { // (bytes_remaining >= SEGMENT_SIZE)
    185    
    186       for(block_index = 0;
    187           block_index < SEGMENT_BLOCKS;
    188           block_index++) {
    189 
    190         byte_data = &buffer[block_index * BLOCK_SIZE];
    191        
    192         //Compiled to 'do_block()' calls.
    193        
    194           transpose.do_block(byte_data, basis_bits);
    195           classifyBytes.do_block(basis_bits, lex);
    196           match.do_block(lex, output);
    197           matchLines.do_block(lex, output);
    198        
    199           if(only_matching) { 
    200             matches_scanner.load_block(output.match_follows, block_index);
     175        block_index = 0;   
     176       
     177        // scanners
     178        matches_scanner.init();
     179        line_starts_scanner.init();
     180        line_ends_scanner.init();
     181         
     182        // ReadStream(), BufferSource(), BufferSink(). Read input stream segment-at-a-time.
     183        bytes_read      = fread(buffer + copy_back_size, 1, SEGMENT_SIZE - copy_back_size, infile);
     184        bytes_avail     = bytes_read + copy_back_size;
     185        bytes_remaining = bytes_avail;
     186       
     187         
     188       
     189        if(ferror(infile)) { perror( "io error" ); exit(1); }
     190        assert(("fread exceeded segment size.", bytes_avail <= SEGMENT_SIZE));
     191   
     192        // } // end loop_header()
     193       
     194        // loop_body()
     195       
     196        // Process full segment.
     197        if (bytes_remaining == SEGMENT_SIZE) { // (bytes_remaining >= SEGMENT_SIZE)
     198       
     199          for(block_index = 0;
     200              block_index < SEGMENT_BLOCKS;
     201              block_index++) {
     202   
     203            byte_data = &buffer[block_index * BLOCK_SIZE];
     204           
     205            //Compiled to 'do_block()' calls.
     206           
     207              transpose.do_block(byte_data, basis_bits);
     208              classifyBytes.do_block(basis_bits, lex);
     209              match.do_block(lex, output);
     210              matchLines.do_block(lex, output);
     211           
     212              if(only_matching) { 
     213                matches_scanner.load_block(output.match_follows, block_index);
     214              }
     215           
     216              if(!only_matching) {
     217                  line_starts_scanner.load_block(output.line_starts, block_index);
     218                  line_ends_scanner.load_block(output.line_ends, block_index);
     219              }         
    201220          }
    202        
     221         
     222          if(only_matching) {
     223            while(matches_scanner.has_next()) {
     224              match_offset = matches_scanner.scan_to_next() - pattern_size;
     225              if(byte_offset) {
     226                  int match_stream_offset = segment_base + match_offset;
     227                  fprintf(outfile, "%d:", match_stream_offset);
     228              }
     229             
     230              // KH: Lookahead.
     231              fwrite(&buffer[match_offset], 1, pattern_size, outfile);         
     232              //fprintf(outfile, "%s\n", fixed_pattern);
     233              fprintf(outfile, "\n");
     234            }
     235           
     236            copy_back_size      = pattern_size + 1;           
     237            copy_back_offset    = bytes_avail - copy_back_size;           
     238          }
     239     
    203240          if(!only_matching) {
    204               line_starts_scanner.load_block(output.line_starts, block_index);
    205               line_ends_scanner.load_block(output.line_ends, block_index);
    206           }         
    207       }
    208      
    209       if(only_matching) {
    210         while(matches_scanner.has_next()) {
    211           match_offset = matches_scanner.scan_to_next() - pattern_size;
    212           if(byte_offset) {
    213               int match_stream_offset = segment_base + match_offset;
    214               fprintf(outfile, "%d:", match_stream_offset);
     241   
     242            assert(("Line length exceeds segment size.", line_ends_scanner.has_next() && line_starts_scanner.has_next())); 
     243            line_final_start_offset = line_starts_scanner.get_final_pos();
     244            line_final_end_offset = line_ends_scanner.get_final_pos();
     245            // if(!has_line_start && !has_line_end) {/* Set flag to buffer entire segment. */;}
     246             
     247            while(line_starts_scanner.has_next() && line_ends_scanner.has_next()) {
     248                 
     249              line_start_offset  = line_starts_scanner.scan_to_next();
     250              line_end_offset    = line_ends_scanner.scan_to_next();
     251                 
     252              if(byte_offset) {
     253                fprintf(outfile, "%d:", segment_base + line_start_offset);
     254              }
     255                 
     256              fwrite(&buffer[line_start_offset], 1, line_end_offset - line_start_offset + 1, outfile);
     257            }
     258           
     259            copy_back_offset   = (line_final_start_offset > line_final_end_offset) ? line_final_start_offset : (line_final_end_offset + 1) ;
     260            copy_back_size     = bytes_avail - copy_back_offset;   
     261   
     262            assert(("copy_back_offset", (copy_back_offset >= 0)));
     263            assert(("copy_back_offset", (copy_back_offset <= bytes_avail)));           
     264            assert(("copy_back_size", (copy_back_size >= 0)));
     265            assert(("copy_back_size", (copy_back_size < SEGMENT_SIZE)));
     266           
    215267          }
    216268         
    217           // KH: Lookahead.
    218           fwrite(&buffer[match_offset], 1, pattern_size, outfile);         
    219           //fprintf(outfile, "%s\n", fixed_pattern);
    220           fprintf(outfile, "\n");
     269          bytes_remaining -= SEGMENT_SIZE;
    221270        }
    222        
    223         copy_back_size      = pattern_size + 1;           
    224         copy_back_offset    = bytes_avail - copy_back_size;           
    225       }
    226  
    227       if(!only_matching) {
    228 
    229         assert(("Line length exceeds segment size.", line_ends_scanner.has_next() && line_starts_scanner.has_next())); 
    230         line_final_start_offset = line_starts_scanner.get_final_pos();
    231         line_final_end_offset = line_ends_scanner.get_final_pos();
    232         // if(!has_line_start && !has_line_end) {/* Set flag to buffer entire segment. */;}
    233          
    234         while(line_starts_scanner.has_next() && line_ends_scanner.has_next()) {
     271   
     272        // if(bytes_remaining > 0) { // KH: @ any_carry
     273       
     274            // Process a partial segment.   
     275            while (bytes_remaining >= BLOCK_SIZE) {
     276                  byte_data = &buffer[block_index * BLOCK_SIZE];
     277                 
     278                  // Compiler 'do_block()' calls.     
     279                  transpose.do_block(byte_data, basis_bits);
     280                  classifyBytes.do_block(basis_bits, lex);
     281                  match.do_block(lex, output);
     282                  matchLines.do_block(lex, output);
     283           
     284                  if(only_matching) {
     285                    matches_scanner.load_block(output.match_follows, block_index);
     286                  }       
     287                 
     288                  if(!only_matching) {
     289                    line_starts_scanner.load_block(output.line_starts, block_index);
     290                    line_ends_scanner.load_block(output.line_ends, block_index);
     291                  }
     292           
     293                  bytes_remaining -= BLOCK_SIZE;
     294                  block_index++;
     295            }
     296           
     297       
     298        if(bytes_remaining > 0) { // KH: any_carry   
     299
     300            BitBlock EOF_mask = bitblock::srl(simd<1>::constant<1>(), convert(BLOCK_SIZE - bytes_remaining));   
     301            byte_data = &buffer[block_index * BLOCK_SIZE];
     302           
     303            // Compiler 'do_final_block()' calls.
     304           
     305            transpose.do_final_block(byte_data, basis_bits, EOF_mask);
     306            classifyBytes.do_final_block(basis_bits, lex, EOF_mask);
     307            match.do_final_block(lex, output, EOF_mask);
     308            matchLines.do_final_block(lex, output, EOF_mask);
     309               
     310            if(only_matching) {
     311              matches_scanner.load_block(output.match_follows & EOF_mask, block_index);
     312            }
    235313             
    236           line_start_offset  = line_starts_scanner.scan_to_next();
    237           line_end_offset    = line_ends_scanner.scan_to_next();
     314            if(!only_matching) {   
     315              line_starts_scanner.load_block(output.line_starts & EOF_mask, block_index);
     316              line_ends_scanner.load_block(output.line_ends & EOF_mask, block_index);           
     317            }
     318           
     319            if(only_matching) {
     320              while(matches_scanner.has_next()) {
     321                match_offset = matches_scanner.scan_to_next() - pattern_size;
     322                if(byte_offset) {
     323                    int match_stream_offset = segment_base + match_offset;
     324                    fprintf(outfile, "%d:", match_stream_offset);
     325                }
     326               
     327                // KH: Lookahead.
     328                fwrite(&buffer[match_offset], 1, pattern_size, outfile);
     329                fprintf(outfile, "\n");
     330              }
    238331             
    239           if(byte_offset) {
    240             fprintf(outfile, "%d:", segment_base + line_start_offset);
    241           }
    242              
    243           fwrite(&buffer[line_start_offset], 1, line_end_offset - line_start_offset + 1, outfile);
     332              copy_back_size      = pattern_size + 1;           
     333              copy_back_offset    = bytes_avail - copy_back_size;             
     334            }
     335             
     336            if(!only_matching) {
     337               
     338                //assert(("Line length exceeds segment size.", line_ends_scanner.has_next() && line_starts_scanner.has_next())); 
     339                           
     340                line_final_start_offset = line_starts_scanner.get_final_pos();
     341                line_final_end_offset = line_ends_scanner.get_final_pos();                 
     342                // if(!has_line_start && !has_line_end) {/* Set flag to buffer entire segment. */;}
     343           
     344                while(line_starts_scanner.has_next() && line_ends_scanner.has_next()) {
     345                   
     346                    line_start_offset  = line_starts_scanner.scan_to_next();
     347                    line_end_offset    = line_ends_scanner.scan_to_next();
     348                   
     349                    if(byte_offset) {
     350                        fprintf(outfile, "%d:", segment_base + line_start_offset);
     351                    }
     352                   
     353                    fwrite(&buffer[line_start_offset], 1, line_end_offset - line_start_offset + 1, outfile);
     354                }
     355           
     356                copy_back_offset   = (line_final_start_offset > line_final_end_offset) ? line_final_start_offset : (line_final_end_offset + 1) ;
     357                copy_back_size     = bytes_avail - copy_back_offset;
     358               
     359                assert(("copy_back_offset", (copy_back_offset >= 0)));
     360                assert(("copy_back_offset", (copy_back_offset <= bytes_avail)));           
     361                assert(("copy_back_size", (copy_back_size >= 0)));
     362                assert(("copy_back_size", (copy_back_size < SEGMENT_SIZE)));
     363               
     364              }       
     365        } // remaining > 0
     366       
     367       
     368       
     369        if(DEBUG) {
     370            printf("bytes_avail: %d\n", bytes_avail);
     371            printf("bytes_remaining: %d\n", bytes_remaining);
     372            printf("copy_back_offset: %d\n", copy_back_offset);
     373            printf("copy_back_size: %d\n", copy_back_size);       
     374            printf("final_line_starts_offset: %d\n", line_final_start_offset);
     375            printf("final_line_ends_offset: %d\n", line_final_end_offset);
    244376        }
    245377       
    246         copy_back_offset   = (line_final_start_offset > line_final_end_offset) ? line_final_start_offset : (line_final_end_offset + 1) ;
    247         copy_back_size     = bytes_avail - copy_back_offset;   
    248 
    249         assert(("copy_back_offset", (copy_back_offset >= 0)));
    250         assert(("copy_back_offset", (copy_back_offset <= bytes_avail)));           
    251         assert(("copy_back_size", (copy_back_size >= 0)));
    252         assert(("copy_back_size", (copy_back_size < SEGMENT_SIZE)));
    253        
    254       }
    255      
    256       bytes_remaining -= SEGMENT_SIZE;
    257     }
    258    
    259     // if(bytes_remaining > 0) {
    260        
    261     // Process a partial segment.   
    262     while (bytes_remaining >= BLOCK_SIZE) {
    263           byte_data = &buffer[block_index * BLOCK_SIZE];
    264          
    265           // Compiler 'do_block()' calls.     
    266           transpose.do_block(byte_data, basis_bits);
    267           classifyBytes.do_block(basis_bits, lex);
    268           match.do_block(lex, output);
    269           matchLines.do_block(lex, output);
    270    
    271           if(only_matching) {
    272             matches_scanner.load_block(output.match_follows, block_index);
    273           }       
    274          
    275           if(!only_matching) {
    276             line_starts_scanner.load_block(output.line_starts, block_index);
    277             line_ends_scanner.load_block(output.line_ends, block_index);
    278           }
    279    
    280           bytes_remaining -= BLOCK_SIZE;
    281           block_index++;
    282     }
    283 
    284     BitBlock EOF_mask = bitblock::srl(simd<1>::constant<1>(), convert(BLOCK_SIZE - bytes_remaining));   
    285        
    286     byte_data = &buffer[block_index * BLOCK_SIZE];
    287          
    288     // Compiler 'do_final_block()' calls.
    289        
    290     transpose.do_final_block(byte_data, basis_bits, EOF_mask);
    291     classifyBytes.do_final_block(basis_bits, lex, EOF_mask);
    292     match.do_final_block(lex, output, EOF_mask);
    293     matchLines.do_final_block(lex, output, EOF_mask);
    294        
    295     if(only_matching) {
    296       matches_scanner.load_block(output.match_follows & EOF_mask, block_index);
    297     }
    298      
    299     if(!only_matching) {   
    300       line_starts_scanner.load_block(output.line_starts & EOF_mask, block_index);
    301       line_ends_scanner.load_block(output.line_ends & EOF_mask, block_index);           
    302     }
    303    
    304     if(only_matching) {
    305       while(matches_scanner.has_next()) {
    306         match_offset = matches_scanner.scan_to_next() - pattern_size;
    307         if(byte_offset) {
    308             int match_stream_offset = segment_base + match_offset;
    309             fprintf(outfile, "%d:", match_stream_offset);
    310         }
    311        
    312         // KH: Lookahead.
    313         fwrite(&buffer[match_offset], 1, pattern_size, outfile);
    314         fprintf(outfile, "\n");
    315       }
    316      
    317       copy_back_size      = pattern_size + 1;           
    318       copy_back_offset    = bytes_avail - copy_back_size;             
    319     }
    320      
    321     if(!only_matching) {
    322        
    323         assert(("Line length exceeds segment size.", line_ends_scanner.has_next() && line_starts_scanner.has_next())); 
    324                    
    325         line_final_start_offset = line_starts_scanner.get_final_pos();
    326         line_final_end_offset = line_ends_scanner.get_final_pos();                 
    327         // if(!has_line_start && !has_line_end) {/* Set flag to buffer entire segment. */;}
    328    
    329         while(line_starts_scanner.has_next() && line_ends_scanner.has_next()) {
    330            
    331             line_start_offset  = line_starts_scanner.scan_to_next();
    332             line_end_offset    = line_ends_scanner.scan_to_next();
    333            
    334             if(byte_offset) {
    335                 fprintf(outfile, "%d:", segment_base + line_start_offset);
    336             }
    337            
    338             fwrite(&buffer[line_start_offset], 1, line_end_offset - line_start_offset + 1, outfile);
    339         }
    340    
    341         copy_back_offset   = (line_final_start_offset > line_final_end_offset) ? line_final_start_offset : (line_final_end_offset + 1) ;
    342         copy_back_size     = bytes_avail - copy_back_offset;
    343        
    344         assert(("copy_back_offset", (copy_back_offset >= 0)));
    345         assert(("copy_back_offset", (copy_back_offset <= bytes_avail)));           
    346         assert(("copy_back_size", (copy_back_size >= 0)));
    347         assert(("copy_back_size", (copy_back_size < SEGMENT_SIZE)));
    348        
    349     }       
    350   //} remaining > 0
    351    
    352     if(DEBUG) {
    353         printf("bytes_avail: %d\n", bytes_avail);
    354         printf("bytes_remaining: %d\n", bytes_remaining);
    355         printf("copy_back_offset: %d\n", copy_back_offset);
    356         printf("copy_back_size: %d\n", copy_back_size);       
    357         printf("final_line_starts_offset: %d\n", line_final_start_offset);
    358         printf("final_line_ends_offset: %d\n", line_final_end_offset);
    359     }
    360    
    361     // loop_tail()
    362    
    363     // Compiler 'clear()' calls.
    364     classifyBytes.clear();
    365     match.clear();
    366     matchLines.clear();
    367    
    368     // copy_back
    369     // copy_back_offset = max ?
    370     // copy_back_size   = max ?
    371    
    372     memmove(&buffer[0], &buffer[copy_back_offset], copy_back_size);   
    373    
    374     // segment_base()
    375     segment_base += bytes_avail;
    376     segment_base -= copy_back_size;
     378        // end loop_body()
     379       
     380        // loop_tail()
     381       
     382        // Compiler 'clear()' calls.
     383        classifyBytes.clear();
     384        match.clear();
     385        matchLines.clear();
     386       
     387        // copy_back
     388        // copy_back_offset = max ?
     389        // copy_back_size   = max ?
     390       
     391        memmove(&buffer[0], &buffer[copy_back_offset], copy_back_size);   
     392       
     393        // segment_base()
     394        segment_base += bytes_avail;
     395        segment_base -= copy_back_size;
     396       
     397        // end loop_tail()
    377398
    378399  }
    379400
    380401  // loop_exit()
     402  // {
    381403  if(infile) { fclose(infile); infile=NULL;}
    382404  if(outfile) { fclose(outfile); outfile=NULL;}
    383405 
     406  // end loop_exit()
     407 
    384408  return 0;
    385409}
Note: See TracChangeset for help on using the changeset viewer.