Changeset 2062 for trunk/symbol_table


Ignore:
Timestamp:
Apr 28, 2012, 3:50:02 PM (7 years ago)
Author:
ksherdy
Message:

Renamed class Symbol as class gid . Templated class gid on SEGMENT_SIZE.

Location:
trunk/symbol_table
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • trunk/symbol_table/main_template.cpp

    r2058 r2062  
    124124
    125125    // Symbol Table
    126     const uint32_t SYMBOL_COUNT = SEGMENT_SIZE;
    127 
    128     Symbol symbols(SYMBOL_COUNT);
    129     symbol_table<Symbol, fast_pool_allocator<1024> > st;
     126    gid<SEGMENT_SIZE> gids;
     127    symbol_table<gid<SEGMENT_SIZE>, fast_pool_allocator<1024> > st;
    130128
    131129    is.read ((char *)raw_buffer, SEGMENT_SIZE);
     
    152150
    153151      PERF_SEC_START(parser_timer);
    154       st.resolve(raw_buffer, groups, starts, ends_gte_17, h0, h1, SEGMENT_BLOCKS, symbols /*, SYMBOL_COUNT*/);
     152      st.resolve(raw_buffer, groups, starts, ends_gte_17, h0, h1, SEGMENT_BLOCKS, gids);
    155153      PERF_SEC_END(parser_timer, SEGMENT_SIZE);
    156154
     
    178176                                fscanner.scan_to_next();
    179177                                while(!fscanner.is_done()) {
    180                                         gid = symbols.gids[fscanner.get_pos() + blk_offset];
     178                                        gid = gids.at[fscanner.get_pos() + blk_offset];
    181179                                        cout << string((char *)st.get_raw_data(gid), st.get_lgth(gid)) << ",";
    182180                                        fscanner.scan_to_next();
     
    212210    }
    213211
    214     uint32_t segment_size = blk;
    215     for(int blk=0;blk<segment_size;blk++) { // write contiguous hash bit streams
     212    uint32_t segment_blocks = blk;
     213    for(int blk=0;blk<segment_blocks;blk++) { // write contiguous hash bit streams
    216214                        h0[blk] = hash[blk].h0;
    217215                        h1[blk] = hash[blk].h1;
     
    221219
    222220    //PERF_SEC_START(parser_timer);
    223     st.resolve(raw_buffer, groups, starts, ends_gte_17, h0, h1, segment_size, symbols/*, SYMBOL_COUNT*/);
     221    st.resolve(raw_buffer, groups, starts, ends_gte_17, h0, h1, segment_blocks, gids);
    224222    //PERF_SEC_END(parser_timer, chars_avail+1);
    225223
    226224    uint32_t blk_offset;
    227     for(int blk=0;blk<segment_size;blk++) {
     225    for(int blk=0;blk<segment_blocks;blk++) {
    228226                        blk_offset = blk * BLOCKSIZE;
    229227                        gid_type gid;
     
    232230                        fscanner.scan_to_next();
    233231                        while(!fscanner.is_done()) {
    234                                 gid = symbols.gids[fscanner.get_pos() + blk_offset];
     232                                gid = gids.at[fscanner.get_pos() + blk_offset];
    235233                                cout << string((char *)st.get_raw_data(gid), st.get_lgth(gid)) << ",";
    236234                                fscanner.scan_to_next();
  • trunk/symbol_table/src/buffer.hpp

    r2040 r2062  
    99#define LOOKBACK_BLOCKS 1
    1010#define LOOKBACK_SIZE BLOCK_SIZE * LOOKBACK_BLOCKS
    11 #define SEGMENT_BLOCKS 10000                                            // No COPY BACK for test, starts within segment
     11#define SEGMENT_BLOCKS 1000                                             // 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

    r2059 r2062  
    411411            // Odd
    412412            ///////////////////////////////////////////////////////////////////////////
    413 
    414413            if(this->hash_table_odd.lookup(bucket, raw_bytes, idx, lgth-1, h0, h1, gid)) {
    415414                return gid;
  • trunk/symbol_table/src/symbol_table.hpp

    r2059 r2062  
    4545              uint8_t buffer [], const uint32_t lgth,
    4646              uint8_t h0 [], uint8_t h1 [], const uint32_t h_block_size,
    47               SYMBOL & symbols, GIDFactory & gid_factory, GIDData & gid_data);
     47              SYMBOL & gids, GIDFactory & gid_factory, GIDData & gid_data);
    4848
    4949template<class SYMBOL, class HASH_TABLE>
     
    5353              uint8_t buffer [],
    5454              uint8_t h0 [], uint8_t h1 [], const uint32_t h_block_size,
    55               SYMBOL & symbols, GIDFactory & gid_factory, GIDData & gid_data);
     55              SYMBOL & gids, GIDFactory & gid_factory, GIDData & gid_data);
    5656
    5757///////////////////////////////////////////////////////////////////////////
     
    5959///////////////////////////////////////////////////////////////////////////
    6060
    61 class Symbol {
     61template<uint32_t SIZE>
     62class gid {
    6263public:
    63     Symbol (uint32_t n) {
    64                         init(n);
    65     }
    66 
    67     void init(uint32_t n) {
    68                         gids.reserve(n);
    69                         //gids_idx.reserve((n/BLOCK_SIZE) + 1);
    70     }
    71 
    72     vector<gid_type> gids;
     64    gid_type at[SIZE];
    7365    //vector<BitBlock> gids_idx;   // gids index
    7466};
    7567
    76 
    7768// TODO - Refactor as a single mixed symbol table class composed of Id, Div2, Log2 hash tables.
    78 template<class SYMBOL, class ALLOCATOR>
     69template<class GIDS, class ALLOCATOR>
    7970class symbol_table {
    8071public:
     
    121112        // Groups & groups
    122113        void resolve(uint8_t buffer [], Groups groups [],  BitBlock starts [], BitBlock ends_gte_17 [],
    123                                  BitBlock h0 [], BitBlock h1 [], uint32_t blocks, SYMBOL & symbols) {
    124 
    125                         for(uint32_t blk = 0; blk < blocks; blk++) {
     114                                 BitBlock h0 [], BitBlock h1 [], uint32_t segment_blocks, GIDS & gids) {
     115
     116                        for(uint32_t blk = 0; blk < segment_blocks; blk++) {
    126117                                const uint32_t blk_offset = blk * BLOCKSIZE;
    127                                 resolve(blk_offset, &buffer[blk_offset], groups[blk], &starts[blk], &h0[blk], &h1[blk], symbols);
     118                                resolve(blk_offset, &buffer[blk_offset], groups[blk], &starts[blk], &h0[blk], &h1[blk], gids);
    128119                        }
    129120        }
     
    132123        IDISA_ALWAYS_INLINE
    133124        void resolve(uint32_t blk_offset, uint8_t buffer [], Groups & groups,  BitBlock starts[],
    134                                  BitBlock * h0, BitBlock * h1, SYMBOL & symbols) {
     125                                 BitBlock * h0, BitBlock * h1, GIDS & gids) {
    135126
    136127                        ///////////////////////////////////////////////////////////////////////////////
     
    139130                        #define BYTE_HASH(GROUP, LGTH) \
    140131                                if(bitblock::any(groups.ends_##LGTH)) { \
    141                                         do_block<SYMBOL, GROUP##_hash_table <LGTH, ALLOCATOR> > \
     132                                        do_block<GIDS, GROUP##_hash_table <LGTH, ALLOCATOR> > \
    142133                                                (blk_offset, \
    143134                                                 hash_table_##LGTH, \
     
    145136                                                 buffer, LGTH, /* buffer, symbol length */ \
    146137                                                 buffer, buffer, BLOCK_SIZE, /* h0, h1, hash block size (bits) */ \
    147                                                  symbols, this->gid_factory, this->gid_data); \
     138                                                 gids, this->gid_factory, this->gid_data); \
    148139                                }
    149140
     
    163154                        #define BIT_HASH(GROUP, LGTH) \
    164155                                if(bitblock::any(groups.ends_##LGTH)) { \
    165                                         do_block<SYMBOL, GROUP##_hash_table <LGTH, ALLOCATOR> > \
     156                                        do_block<GIDS, GROUP##_hash_table <LGTH, ALLOCATOR> > \
    166157                                                (blk_offset, \
    167158                                                 hash_table_##LGTH, \
     
    169160                                                 buffer, LGTH, \
    170161                                                 (uint8_t *)h0, (uint8_t *)h1, (BLOCK_SIZE / 8), \
    171                                                  symbols, this->gid_factory, this->gid_data); \
     162                                                 gids, this->gid_factory, this->gid_data); \
    172163                                }
    173164
     
    188179                                //print_register("17", groups.ends_gte_17);
    189180
    190                                 do_block<SYMBOL, id_hash_table<0, ALLOCATOR> >
     181                                do_block<GIDS, id_hash_table<0, ALLOCATOR> >
    191182                                                (blk_offset,
    192183                                                 hash_table_gte_17,
     
    194185                                                 buffer,
    195186                                                 (uint8_t *)h0, (uint8_t *)h1, BLOCK_SIZE/8,
    196                                                  symbols, this->gid_factory, this->gid_data);
     187                                                 gids, this->gid_factory, this->gid_data);
    197188                        }
    198189        }
     
    252243
    253244// Fixed Lengths - REVERSE SCAN LOGIC - Scan each BLOCK MSB to LSB
    254 template<class SYMBOL, class HASH_TABLE>
     245template<class GIDS, class HASH_TABLE>
    255246void do_block(uint32_t blk_offset,
    256247                  HASH_TABLE & h_table,
     
    258249                  uint8_t buffer [], const uint32_t lgth,
    259250                  uint8_t h0 [], uint8_t h1 [], const uint32_t h_block_size,
    260                   SYMBOL & symbols, GIDFactory & gid_factory, GIDData & gid_data) {
     251                  GIDS & gids, GIDFactory & gid_factory, GIDData & gid_data) {
    261252
    262253                uint8_t * buffer_base = buffer;
     
    291282
    292283                        #ifdef ID_SYMBOL_STORE_SYMBOL_GIDS_AT_END_POSITION
    293                         symbols.gids[blk_offset + epos] = gid;
     284                        gids.at[blk_offset + epos] = gid;
    294285                        #else
    295                         symbols.gids[blk_offset + epos - lgth] = gid;
     286                        gids.at[blk_offset + epos - lgth] = gid;
    296287                        #endif
    297288
     
    314305                          uint8_t buffer [],
    315306                          uint8_t h0 [], uint8_t h1 [], const uint32_t h_block_size,
    316                           SYMBOL & symbols, GIDFactory & gid_factory, GIDData & gid_data) {
     307                          SYMBOL & gids, GIDFactory & gid_factory, GIDData & gid_data) {
    317308
    318309        BitBlock * starts_base = starts;
     
    362353
    363354                #ifdef ID_SYMBOL_STORE_SYMBOL_GIDS_AT_END_POSITION
    364                 symbols.gids[blk_offset + epos] = gid;
     355                gids.at[blk_offset + epos] = gid;
    365356                #else
    366                 symbols.gids[blk_offset + epos - lgth] = gid;
     357                gids.at[blk_offset + epos - lgth] = gid;
    367358                #endif
    368359
Note: See TracChangeset for help on using the changeset viewer.