Changeset 2031 for trunk


Ignore:
Timestamp:
Apr 15, 2012, 3:03:16 AM (7 years ago)
Author:
ksherdy
Message:

Simplified/refactored block boundary case.

Location:
trunk/symbol_table/src
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • trunk/symbol_table/src/buffer.hpp

    r2010 r2031  
    99#define LOOKBACK_BLOCKS 1
    1010#define LOOKBACK_SIZE BLOCK_SIZE * LOOKBACK_BLOCKS
    11 #define SEGMENT_BLOCKS 1000                                                     // No COPY BACK for test, starts within segment
     11#define SEGMENT_BLOCKS 10000                                                    // No COPY BACK for test, starts within segment
    1212#define SEGMENT_SIZE BLOCK_SIZE * (SEGMENT_BLOCKS)      // (bytes) a multiple of BLOCK_SIZE
    1313#define SEGMENT_ALLOC_SIZE (LOOKBACK_SIZE + SEGMENT_SIZE + PADDING_SIZE) / sizeof(BitBlock) // (bytes)
  • trunk/symbol_table/src/hash_table.hpp

    r2028 r2031  
    6666
    6767    IDISA_ALWAYS_INLINE uint64_t get_bucket(const uint8_t * h0, const uint8_t * h1, const uint32_t idx, const uint32_t slice_bits) {
    68         #ifdef HASH_TABLE_HPP_DEBUG
    69             lookups++;
    70         #endif
    71         return hash_strategy.hash(h0,h1,idx,slice_bits,hash_size);
     68                        #ifdef HASH_TABLE_HPP_DEBUG
     69                                        lookups++;
     70                        #endif
     71                        return hash_strategy.hash(h0,h1,idx,slice_bits,hash_size);
    7272    }
    7373
     
    103103        while(NULL != crt) {
    104104            if(compare_strategy.compare(&raw_bytes[idx], crt->raw_bytes, raw_byte_lgth)) {
    105                 return crt->gid;
     105                                return crt->gid;
    106106            }
    107107            prev = crt;
    108108            crt = crt->next;
    109109            #ifdef HASH_TABLE_HPP_DEBUG
    110                 collisions++;
     110                                collisions++;
    111111            #endif
    112112        }
  • trunk/symbol_table/src/id_symbol_table.hpp

    r2030 r2031  
    277277              SYMBOL & symbols, GIDFactory & gid_factory, GIDData & gid_data) {
    278278
    279     gid_type gid;
    280     int32_t spos;
    281     int32_t epos;
    282     ForwardScanner<BitBlock, scanword_t> fscanner(&ends);
    283 
    284     fscanner.scan_to_next();
    285     epos = fscanner.get_pos();
    286     spos = (epos - lgth);
    287 
    288         if(!fscanner.is_done() && (spos < 0) ) { // block boundary case
    289 
    290         ////////////////////////////////////////////////////////////////////
    291         // Start - Review boundary logic
    292         ////////////////////////////////////////////////////////////////////
    293         uint8_t * lb_buffer = buffer - ((lgth / BLOCK_SIZE) + 1)*BLOCK_SIZE;
    294         int32_t lb_spos = (BLOCK_SIZE - (-1*spos)) & (BLOCK_SIZE-1);
    295 
    296         uint8_t * lb_h0 = h0 - ((lgth / BLOCK_SIZE) + 1)*h_block_size;
    297         uint8_t * lb_h1 = h1 - ((lgth / BLOCK_SIZE) + 1)*h_block_size;
    298 
    299         gid = h_table.lookup_or_insert(lb_buffer, lb_spos, lgth, lb_h0, lb_h1, h_lgth, gid_factory, gid_data);
    300 
    301         symbols.gids[blk_offset + spos] = gid;
    302         ////////////////////////////////////////////////////////////////////
    303         // End
    304         ////////////////////////////////////////////////////////////////////
    305 
    306         #ifdef ID_SYMBOL_TABLE_TEMPLATE_HPP_DEBUG
    307                         print_symbol_debug(gid, lb_buffer, lb_spos, epos, lgth);
    308         #endif
    309 
    310         fscanner.scan_to_next();
    311         epos = fscanner.get_pos();
    312         spos = (epos - lgth);
    313 
    314     }
    315 
    316         while(!fscanner.is_done()) {
    317 
    318                 gid = h_table.lookup_or_insert(buffer, spos, lgth, h0, h1, h_lgth, gid_factory, gid_data);
    319                 symbols.gids[blk_offset + spos] = gid;
    320 
    321         #ifdef ID_SYMBOL_TABLE_TEMPLATE_HPP_DEBUG
    322                 print_symbol_debug(gid, buffer, spos, epos, lgth);
    323         #endif
    324 
    325                 fscanner.scan_to_next();
    326                 epos = fscanner.get_pos();
    327                 spos = (epos - lgth);
    328     }
    329 
    330 }
     279                uint8_t * buffer_base = buffer;
     280                uint8_t * h0_base = h0;
     281                uint8_t * h1_base = h1;
     282
     283                gid_type gid;
     284                int32_t epos;
     285                int32_t spos;
     286                uint32_t blk_count;
     287
     288    ReverseScanner<BitBlock, scanword_t> rscanner(&ends);
     289
     290    rscanner.scan_to_next();
     291    epos = rscanner.get_pos();
     292
     293                while(!rscanner.is_done()) {
     294
     295        spos = epos - lgth;
     296
     297                        if(spos < 0) { // boundary case
     298                                        spos = (BLOCK_SIZE - (-1 * spos)) & (BLOCK_SIZE - 1);
     299                                        blk_count = (lgth/BLOCK_SIZE)+1;               
     300                                        buffer_base -= (BLOCK_SIZE * blk_count);       
     301                                        h0_base -= (h_block_size * blk_count);
     302                                        h1_base -= (h_block_size * blk_count);
     303                        }
     304
     305                        gid = h_table.lookup_or_insert(buffer_base, spos, lgth, h0_base, h1_base, h_lgth, gid_factory, gid_data); // WARNING: spos must be >= 0
     306                        symbols.gids[blk_offset + epos - lgth] = gid;
     307
     308                        #ifdef ID_SYMBOL_TABLE_TEMPLATE_HPP_DEBUG
     309                                print_symbol_debug(gid, buffer_base, spos, epos, lgth);
     310                        #endif
     311
     312                        rscanner.scan_to_next();
     313                epos = rscanner.get_pos();
     314                }
     315        }
     316
    331317
    332318// Variable Lengths, reverse scanner logic
     
    340326                          SYMBOL & symbols, GIDFactory & gid_factory, GIDData & gid_data) {
    341327
     328
     329
    342330        BitBlock * starts_base = starts;
     331//      uint8_t * buffer_base = buffer;
    343332        uint8_t * h0_base = h0;
    344333        uint8_t * h1_base = h1;
     
    364353
    365354                while(starts_rscanner.is_done()) { // boundary case
    366                     starts_base--;
    367                     h0_base--;
    368                     h1_base--;
     355                          starts_base--;
     356
    369357
    370358                    starts_rscanner.init(starts_base);
     
    372360
    373361                    if(!starts_rscanner.is_done()) { // found start
    374 
    375                         lgth = epos + (BLOCK_SIZE - starts_rscanner.get_pos()) + (BLOCK_SIZE * blk_count);
    376                         spos = epos - lgth;
    377                         h0_base -= (h_block_size * blk_count);
    378                         h1_base -= (h_block_size * blk_count);
    379                         break;
     362                                        lgth = epos + (BLOCK_SIZE - starts_rscanner.get_pos()) + (BLOCK_SIZE * blk_count);
     363                                //      spos = (BLOCK_SIZE - (-1 * spos)) & (BLOCK_SIZE - 1);
     364                                                       
     365                                        //                                      buffer_base -= (BLOCK_SIZE * blk_count);       
     366                                        spos = epos - lgth;
     367                                       
     368                                        blk_count = (lgth/BLOCK_SIZE)+1;
     369                                        h0_base -= (h_block_size * blk_count);
     370                                        h1_base -= (h_block_size * blk_count);
     371                                        break;
    380372                    }
    381373                    blk_count++;
     374
     375       
     376
    382377
    383378                }
     
    397392#endif // ID_SYMBOL_TABLE_TEMPLATE_HPP
    398393
    399 
     394//
     395/*
     396void do_block(uint32_t blk_offset,
     397              HASH_TABLE & h_table,
     398              BitBlock ends,
     399              uint8_t buffer [], const uint32_t lgth,
     400              uint8_t h0 [], uint8_t h1 [], const uint32_t h_lgth, const uint32_t h_block_size,
     401              SYMBOL & symbols, GIDFactory & gid_factory, GIDData & gid_data) {
     402
     403    gid_type gid;
     404    int32_t spos;
     405    int32_t epos;
     406    ForwardScanner<BitBlock, scanword_t> fscanner(&ends);
     407
     408    fscanner.scan_to_next();
     409    epos = fscanner.get_pos();
     410    spos = (epos - lgth);
     411
     412        if(!fscanner.is_done() && (spos < 0) ) { // block boundary case
     413
     414        ////////////////////////////////////////////////////////////////////
     415        // Start - Review boundary logic
     416        ////////////////////////////////////////////////////////////////////
     417        uint8_t * lb_buffer = buffer - ((lgth / BLOCK_SIZE) + 1)*BLOCK_SIZE;
     418        int32_t lb_spos = (BLOCK_SIZE - (-1*spos)) & (BLOCK_SIZE-1);
     419
     420        uint8_t * lb_h0 = h0 - ((lgth / BLOCK_SIZE) + 1)*h_block_size;
     421        uint8_t * lb_h1 = h1 - ((lgth / BLOCK_SIZE) + 1)*h_block_size;
     422
     423        gid = h_table.lookup_or_insert(lb_buffer, lb_spos, lgth, lb_h0, lb_h1, h_lgth, gid_factory, gid_data);
     424
     425        symbols.gids[blk_offset + spos] = gid;
     426        ////////////////////////////////////////////////////////////////////
     427        // End
     428        ////////////////////////////////////////////////////////////////////
     429
     430        #ifdef ID_SYMBOL_TABLE_TEMPLATE_HPP_DEBUG
     431                        print_symbol_debug(gid, lb_buffer, lb_spos, epos, lgth);
     432        #endif
     433
     434        fscanner.scan_to_next();
     435        epos = fscanner.get_pos();
     436        spos = (epos - lgth);
     437
     438    }
     439
     440        while(!fscanner.is_done()) {
     441
     442                gid = h_table.lookup_or_insert(buffer, spos, lgth, h0, h1, h_lgth, gid_factory, gid_data);
     443                symbols.gids[blk_offset + spos] = gid;
     444
     445        #ifdef ID_SYMBOL_TABLE_TEMPLATE_HPP_DEBUG
     446                print_symbol_debug(gid, buffer, spos, epos, lgth);
     447        #endif
     448
     449                fscanner.scan_to_next();
     450                epos = fscanner.get_pos();
     451                spos = (epos - lgth);
     452    }
     453
     454}
     455*/
     456
Note: See TracChangeset for help on using the changeset viewer.