Ignore:
Timestamp:
Mar 23, 2014, 11:53:07 PM (5 years ago)
Author:
ksherdy
Message:

Added support for segment-at-a-time processing. Match strings at follows position.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • proto/RE/demo/grep_template_segment.cpp

    r3738 r3739  
    106106@stream_stmts
    107107
    108 // Segment-at-a-time bufferd processing parameters.
     108// Segment-at-a-time parameters.
    109109int bytes_read              = 0;
    110110int bytes_avail             = 0;
     
    114114int copy_back_offset        = 0;
    115115
    116 int block_index             = 0; // block index wrt current segment
    117 int block_base              = 0; // byte offset wrt current segment
     116int block_index             = 0; // wrt current segment
     117int block_base              = 0; // ?
    118118
    119119//int segment_index           = 0; // segment index wrt current buffer  // unused
     
    123123
    124124int match_offset            = 0;
    125 int line_start_offset            = 0; 
    126 int line_end_offset              = -1;
     125int line_start_offset       = 0;  // ?
     126int line_end_offset         = -1; // ?
    127127
    128128int line_starts_final_offset     = 0;
     
    216216    bytes_remaining = bytes_avail;
    217217   
     218    block_base      = 0;   
     219   
    218220    //if(feof(infile)) { KH: No! OPC /*bytes_remaining--;*/ }
    219221    if(ferror(infile)) { perror( "io error" ); exit(1); }
    220222
    221223    // Process full segment.
    222    
    223     block_base      = 0;
     224    
     225    //assert(("fread exceeded segment size.", bytes_avail <= SEGMENT_SIZE));
    224226   
    225227    if (bytes_avail == SEGMENT_SIZE) { // (bytes_remaining >= SEGMENT_SIZE)
    226        
     228     
    227229      if(only_matching) { 
    228230        match_scanner.init();
    229231      }
    230              
    231       line_starts_scanner.init();
    232       line_ends_scanner.init();
     232     
     233      if(!only_matching) {
     234        line_starts_scanner.init();
     235        line_ends_scanner.init();
     236      }
    233237
    234238      for(block_index = 0;
     
    237241
    238242        byte_data = &buffer[block_base];
    239         //Replaced with C++ stream function 'do_block()' calls.
     243       
     244        //Compiled to 'do_block()' calls.
    240245        @block_stmts
    241246
     
    252257      if(only_matching) {
    253258        while(match_scanner.has_next()) {
    254           match_offset = match_scanner.scan_to_next() - pattern_size + 1;
     259          match_offset = match_scanner.scan_to_next() - pattern_size;
    255260          if(byte_offset) {
    256261              int match_stream_offset = stream_base + match_offset;
     
    267272        copy_back_size      = pattern_size;           
    268273        copy_back_offset    = bytes_avail - copy_back_size;           
    269        
    270274      }
    271275 
    272276      if(!only_matching) {
    273          
    274           print_register<BitBlock>("starts", output.line_starts);
    275           print_register<BitBlock>("starts", output.line_ends);
     277
     278        assert(("Line length exceeds segment size.", line_ends_scanner.has_next() && line_starts_scanner.has_next())); 
     279         
     280        //if(has_line_start) {
     281            line_starts_final_offset = line_starts_scanner.get_final_pos();
     282        //}
     283        //if(has_line_end) {
     284            line_ends_final_offset = line_ends_scanner.get_final_pos();
     285        //}
     286           
     287        // if(!has_line_start && !has_line_end) {/* Set flag to buffer entire segment. */;}
     288         
     289        while(line_starts_scanner.has_next() && line_ends_scanner.has_next()) {
     290             
     291          line_start_offset  = line_starts_scanner.scan_to_next();
     292          line_end_offset    = line_ends_scanner.scan_to_next();
     293             
     294          if(byte_offset) {
     295            fprintf(outfile, "%d:", stream_base + line_start_offset);
     296          }
     297             
     298          fwrite(&buffer[line_start_offset], 1, line_end_offset - line_start_offset + 1, outfile);
     299        }
     300       
     301        copy_back_offset   = (line_starts_final_offset > line_ends_final_offset) ? line_starts_final_offset : (line_ends_final_offset + 1) ;
     302        copy_back_size     = bytes_avail - copy_back_offset;   
     303
     304      }
    276305     
    277           // both, either, or none (in the general case)     
    278           bool has_line_start   = line_starts_scanner.has_next();
    279           bool has_line_end     = line_ends_scanner.has_next();
    280          
    281           //if(has_line_start) {
    282               line_starts_final_offset = line_starts_scanner.get_final_pos();
    283           //}
    284           //if(has_line_end) {
    285               line_ends_final_offset = line_ends_scanner.get_final_pos();
    286           //}
    287           assert(("Line length exceeds segment size.", has_line_end));
    288           // if(!has_line_start && !has_line_end) {/* Set flag to buffer entire segment. */;}
    289          
    290           while(line_starts_scanner.has_next() && line_ends_scanner.has_next()) {
    291              
    292               line_start_offset  = line_starts_scanner.scan_to_next();
    293               line_end_offset    = line_ends_scanner.scan_to_next();
    294              
    295               if(byte_offset) {
    296                   fprintf(outfile, "%d:", stream_base + line_start_offset);
    297               }
    298              
    299               fwrite(&buffer[line_start_offset], 1, line_end_offset - line_start_offset, outfile);
    300               fprintf(outfile, "\n");
    301           }
    302          
    303           copy_back_offset   = (line_starts_final_offset > line_ends_final_offset) ? line_starts_final_offset : (line_ends_final_offset + 1);
    304           copy_back_size  = bytes_avail - copy_back_offset;   
    305          
    306           bytes_remaining -= SEGMENT_SIZE;
    307       }   
    308      
     306      bytes_remaining -= SEGMENT_SIZE;
    309307    }
    310308   
    311     // Process partial segment
     309    // Process a partial segment.
    312310    if(bytes_remaining > 0) {
    313        
     311
    314312        block_index = 0;   
    315313       
     
    318316        }
    319317       
    320         line_starts_scanner.init();
    321         line_ends_scanner.init();
    322 
     318        if(!only_matching) {
     319          line_starts_scanner.init();
     320          line_ends_scanner.init();
     321        }
     322       
    323323        // Process full blocks.
    324324        while (bytes_remaining >= BLOCK_SIZE) {
    325325          byte_data = &buffer[block_base];
    326           //Replaced with C++ stream function 'do_block()' calls.
     326         
     327          // Compiler 'do_block()' calls.
    327328          @block_stmts
    328329   
     
    331332          }       
    332333         
    333           line_starts_scanner.load_block(output.line_starts, block_index);
    334           line_ends_scanner.load_block(output.line_ends, block_index);
     334          if(!only_matching) {
     335            line_starts_scanner.load_block(output.line_starts, block_index);
     336            line_ends_scanner.load_block(output.line_ends, block_index);
     337          }
    335338   
    336339          block_base += BLOCK_SIZE;
    337340          bytes_remaining -= BLOCK_SIZE;
    338341          block_index++;
    339         }
    340 
    341         // Process the final partial block. // KH: Not required, remove.
    342         if(bytes_remaining > 0) {           
    343           BitBlock EOF_mask = bitblock::srl(simd<1>::constant<1>(), convert(BLOCK_SIZE-bytes_remaining));
    344          
    345           byte_data = &buffer[block_base];
    346           //Replaced with C++ stream function 'do_final_block()' calls.
    347           @final_block_stmts
    348    
    349           if(only_matching) {
    350             match_scanner.load_block(output.matches & EOF_mask, block_index);
    351           }
    352          
    353           line_starts_scanner.load_block(output.line_starts & EOF_mask, block_index);
    354           line_ends_scanner.load_block(output.line_ends & EOF_mask, block_index);         
    355          
    356           if(0) {
    357               print_register<BitBlock>("starts", output.line_starts);
    358               print_register<BitBlock>("ends", output.line_ends);
    359               print_register<BitBlock>("lex.LF", lex.LF);
    360               print_register<BitBlock>("mask", EOF_mask);
    361           }
    362         }
    363 
    364         if(only_matching) {
     342       }
     343
     344       // Process a partial final block. // KH: Not required.     
     345       BitBlock EOF_mask = bitblock::srl(simd<1>::constant<1>(), convert(BLOCK_SIZE - bytes_remaining));   
     346       byte_data = &buffer[block_base];
     347         
     348       // Compiler 'do_final_block()' calls.
     349       @final_block_stmts
     350   
     351       if(only_matching) {
     352          match_scanner.load_block(output.matches & EOF_mask, block_index);
     353       }
     354         
     355       if(!only_matching) {   
     356         line_starts_scanner.load_block(output.line_starts & EOF_mask, block_index);
     357         line_ends_scanner.load_block(output.line_ends & EOF_mask, block_index);           
     358       }
     359
     360       if(only_matching) {
    365361          while(match_scanner.has_next()) {
    366             match_offset = match_scanner.scan_to_next() - pattern_size + 1;
     362            match_offset = match_scanner.scan_to_next() - pattern_size;
    367363            if(byte_offset) {
    368364                int match_stream_offset = stream_base + match_offset;
    369365                fprintf(outfile, "%d:", match_stream_offset);
    370             } 
     366            }
    371367           
    372368            // KH: Lookahead.
     
    377373         
    378374          copy_back_size      = pattern_size;           
    379           copy_back_offset    = bytes_avail - copy_back_size;           
    380          
     375          copy_back_offset    = bytes_avail - copy_back_size;             
    381376        }
    382377     
    383378        if(!only_matching) {
    384        
    385             // both, either, or none (in the general case)     
    386             bool has_line_start   = line_starts_scanner.has_next();
    387             bool has_line_end     = line_ends_scanner.has_next();
    388379           
     380            assert(("Line length exceeds segment size.", line_ends_scanner.has_next() && line_starts_scanner.has_next())); 
     381                       
    389382            //if(has_line_start) {
    390383                line_starts_final_offset = line_starts_scanner.get_final_pos();
     
    393386                line_ends_final_offset = line_ends_scanner.get_final_pos();
    394387            //}
    395             //assert(("Line length exceeds segment size.", has_line_end));
     388               
    396389            // if(!has_line_start && !has_line_end) {/* Set flag to buffer entire segment. */;}
    397            
     390   
    398391            while(line_starts_scanner.has_next() && line_ends_scanner.has_next()) {
    399392               
     
    405398                }
    406399               
    407                 fwrite(&buffer[line_start_offset], 1, line_end_offset - line_start_offset, outfile);
    408                 fprintf(outfile, "\n");
     400                fwrite(&buffer[line_start_offset], 1, line_end_offset - line_start_offset + 1, outfile);
    409401            }
    410402
    411             copy_back_offset    = (line_starts_final_offset > line_ends_final_offset) ? line_starts_final_offset : (line_ends_final_offset + 1);
    412             copy_back_size      = bytes_avail - copy_back_offset;           
    413            
    414         }
    415 
     403            copy_back_offset   = (line_starts_final_offset > line_ends_final_offset) ? line_starts_final_offset : (line_ends_final_offset + 1) ;
     404            copy_back_size     = bytes_avail - copy_back_offset;
     405        }       
    416406    }
    417      
     407   
     408    if(0) {
     409        cout << "bytes_avail: " << bytes_avail << endl;
     410        cout << "line_starts_final_offset: " << line_starts_final_offset << endl;
     411        cout << "line_ends_final_offset: " << line_ends_final_offset << endl;
     412        cout << "offset: " << copy_back_offset << ", " << "size: " << copy_back_size << endl;
     413    }
     414   
    418415    memmove(&buffer[0], &buffer[copy_back_offset], copy_back_size);
     416   
     417    // pablo.ScanToFirst() must clear carry-in at the start of each segment.
     418    classifyBytes.clear();
     419    match.clear();
     420    matchLines.clear();
    419421   
    420422    stream_base += bytes_avail;
     
    422424  }
    423425
    424   if(infile) {  fclose(infile); }
     426  if(infile) { fclose(infile); }
    425427  if(outfile) { fclose(outfile); }
     428 
    426429  return 0;
    427430}
Note: See TracChangeset for help on using the changeset viewer.