Changeset 3145 for proto/PDF


Ignore:
Timestamp:
May 15, 2013, 4:45:00 PM (6 years ago)
Author:
lindanl
Message:

Use scanner instead of iterator.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • proto/PDF/cb_template.cpp

    r3136 r3145  
    1010#include "../../simd-lib/bitblock.hpp"
    1111#include "../../simd-lib/carryQ.hpp"
    12 #include "../../simd-lib/bitblock_iterator.hpp"
     12#include "bitblock_iterator.hpp"
    1313#include "../../simd-lib/pabloSupport.hpp"
    1414#include "../../simd-lib/s2p.hpp"
     
    239239        del_count(out_Callouts.delmask,units_per_reg._128);
    240240       
    241         unitsums_per_reg[blk]._128 = PartialSum16(units_per_reg._128);
     241        unitsums_per_reg[blk+1]._128 = simd<16>::add(mvmd<16>::splat<7>(unitsums_per_reg[blk]._128), PartialSum16(units_per_reg._128));
    242242       
    243243        for(int j=0; j<8; j++){
     
    246246        }
    247247}
    248 
     248/*
    249249static inline void Postprocessing(char* cb, int cb_size, char* cb_new, BitBlock * marker_starts, BitBlock * marker_ends, ubitblock * unitsums_per_reg, int & at_start, int & at_optr, int & base_pos){   
    250250     
     
    269269  for(int i=0; i<BLOCKS; i++){
    270270    if(bitblock::any(simd_or(marker_starts[i],marker_ends[i]))){
    271       BitBlockForwardIteratorWithBaseCounts16 iter_start;
    272       BitBlockForwardIteratorWithBaseCounts16 iter_end;
    273       iter_start.init(&(marker_starts[i]), unitsums_per_reg[i]._128);
    274       iter_end.init(&(marker_ends[i]), unitsums_per_reg[i]._128);
    275       BitBlockForwardIteratorWithBaseCounts16 end;
    276       while(*iter_start != -1 || *iter_end != -1) {
     271      ForwardScannerWithBaseCounts16<BitBlock, ScanWord> iter_start(&(marker_starts[i]), unitsums_per_reg[i]._128);
     272      ForwardScannerWithBaseCounts16<BitBlock, ScanWord> iter_end(&(marker_ends[i]), unitsums_per_reg[i]._128);
     273      iter_start.scan_to_next();
     274      iter_end.scan_to_next();
     275      while(!iter_start.is_done() || !iter_end.is_done()) {
    277276        if(at_start){
    278           pos = block_pos + (*iter_start);
     277          pos = block_pos + (iter_start.get_pos());
    279278          if (cb[pos]== 0x2f){ 
    280279            tokenArray[token_idx].type = name_token;
     
    305304            at_optr = 1;
    306305          }
    307           iter_start++;
     306          iter_start.scan_to_next();
    308307          at_start = 0;
    309308        }
    310309        else{
    311           int len = block_pos + (*iter_end) - pos;     
     310          int len = block_pos + (iter_end.get_pos()) - pos;     
    312311          if(at_optr){
    313312            optrArray[optr_idx].len = len;
     
    319318            token_idx++;
    320319          }
    321           iter_end++;
     320          iter_end.scan_to_next();
    322321          at_start = 1;
    323322        }
     
    332331//       cout << "in markup " << cb_size << "," << pos << "," << base_pos << endl;
    333332//     }
     333    memcpy(cb_new, &cb[pos], base_pos);
     334  }
     335  else
     336    base_pos = 0;
     337}
     338*/
     339static inline void Postprocessing(char* cb, int cb_size, char* cb_new, BitBlock * marker_starts, BitBlock * marker_ends, ubitblock * unitsums_per_reg, int & at_start, int & at_optr, int & base_pos){   
     340     
     341  int pos = 0;
     342  int len = 0;
     343 
     344  if(!at_start){
     345    if(at_optr){
     346      optrArray[optr_idx].char_ptr = cb;
     347    }
     348    else{
     349      if (tokenArray[token_idx].type == flt_token || tokenArray[token_idx].type == int_token){
     350        num_idx--;
     351        Digit_postprocessing(cb, 0);
     352      }
     353      else{
     354        tokenArray[token_idx].token.char_ptr = cb;
     355      }
     356    }
     357  }
     358   
     359  int block_pos = base_pos;
     360  uint16_t * unit_sums = &(((uint16_t *) unitsums_per_reg)[7]);
     361
     362  ForwardScannerWithBaseCounts16<BitBlock, ScanWord> iter_start(marker_starts, unit_sums, BLOCKS);
     363  ForwardScannerWithBaseCounts16<BitBlock, ScanWord> iter_end(marker_ends, unit_sums, BLOCKS);
     364  iter_start.scan_to_next();
     365  iter_end.scan_to_next();
     366  while(!iter_start.is_done()) {
     367    pos = block_pos + (iter_start.get_pos());
     368    if (cb[pos]== 0x2f){       
     369      tokenArray[token_idx].type = name_token;
     370      tokenArray[token_idx].token.char_ptr = &cb[pos];
     371    }
     372    else if(cb[pos]== 0x28){   
     373      tokenArray[token_idx].type = str_token;
     374      tokenArray[token_idx].token.char_ptr = &cb[pos];
     375    }
     376    else if (cb[pos]== 0x0c){   
     377      tokenArray[token_idx].type = hex_token;
     378      tokenArray[token_idx].token.char_ptr = &cb[pos];
     379    }
     380    else if (cb[pos]== '-' || cb[pos]== '+' || (cb[pos]>='0'&&cb[pos]<='9')){
     381      Digit_postprocessing(cb, pos);
     382    }
     383    else if ( (cb[pos]== 'n' && cb[pos+1]== 'u' && cb[pos+2]== 'l'  && cb[pos+3]== 'l')
     384      || (cb[pos]== 't' && cb[pos+1]== 'r' && cb[pos+2]== 'u'  && cb[pos+3]== 'e')
     385      || (cb[pos]== 'f' && cb[pos+1]== 'a' && cb[pos+2]== 'l'  && cb[pos+3]== 's' && cb[pos+3]== 'e')){
     386     
     387      tokenArray[token_idx].type = kw_token;
     388      tokenArray[token_idx].token.char_ptr = &cb[pos]; 
     389    }
     390    else{
     391      //operator
     392      optrArray[optr_idx].char_ptr = &cb[pos];
     393      optrArray[optr_idx].token_pos = token_idx-1;
     394      at_optr = 1;
     395    }
     396    iter_start.scan_to_next();
     397    if(iter_end.is_done()){
     398      at_start = 0;
     399      break;
     400    }
     401    len = block_pos + (iter_end.get_pos()) - pos;       
     402    if(at_optr){
     403      optrArray[optr_idx].len = len;
     404      optr_idx++;
     405      at_optr = 0;
     406    }
     407    else{
     408      tokenArray[token_idx].len = len;
     409      token_idx++;
     410    }
     411    iter_end.scan_to_next();
     412    at_start = 1;
     413  }
     414 
     415  if(!at_start){
     416    base_pos = cb_size - pos;
    334417    memcpy(cb_new, &cb[pos], base_pos);
    335418  }
     
    366449  char * content_buf_ptr =  content_buf[0];
    367450  int cb_idx = 0; 
    368   ubitblock unitsums_per_reg[BLOCKS];
     451  ubitblock unitsums_per_reg[BLOCKS+1];
    369452  int at_start = 1;
    370453  int at_optr = 0;
    371454  int base_pos = 0;
    372455
     456  unitsums_per_reg[0]._128 = simd<16>::constant<0>();
    373457  parity.odd = simd<2>::constant<1>();
    374458  parity.even = simd<2>::constant<2>();
     
    472556    break;
    473557  }
     558 
     559  ints_x_floats(numbers, dec_pl, num_rslt, num_idx);
    474560}
    475561/*
     
    478564    for(int i=0;i<num_idx;i++)
    479565      printf("%i,%i\n",numbers[i],dec_pl[i]);*/
    480    
     566/*   
    481567    for(int i=0; i<100;i++){
    482568      if(tokenArray[i].type==str_token){
     
    511597    }
    512598   
    513 /*
     599
    514600    for(int i=0;i<100;i++)  {
    515601        printf("len at %i is %i\n",i, optrArray[i].len);
     
    517603          printf("%c",optrArray[i].char_ptr[j]);
    518604        printf("\n");
    519     }*/
    520 
     605    }
     606*/
    521607}
    522608
Note: See TracChangeset for help on using the changeset viewer.