Changeset 2028 for trunk


Ignore:
Timestamp:
Apr 14, 2012, 10:43:12 PM (7 years ago)
Author:
ksherdy
Message:

Added GIDData as a member of class Symbol Table.

Location:
trunk/symbol_table/src
Files:
1 deleted
3 edited

Legend:

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

    r2027 r2028  
    2828#include "../lib/byte_pool.hpp"
    2929#include "../lib/hash.hpp"
    30 #include "gid_factory.hpp"
     30#include "gid.hpp"
    3131#include <cmath>
    3232#include <stdint.h>
     
    3434#include <sstream>
    3535#include <iostream>
    36 #include <vector>
    3736using namespace std;
    3837
     
    4746} node;
    4847
    49 class gid_data {
    50 public:
    51 
    52     static void add_data(uint8_t * raw_bytes, uint32_t raw_bytes_lgth) {
    53         data next;
    54         next.raw_bytes = raw_bytes;
    55         next.raw_bytes_lgth = raw_bytes_lgth;
    56         values.push_back(next);
    57     }
    58 
    59     static size_t max() { return values.size(); }
    60 
    61     static uint8_t * get_raw_bytes(size_t idx) {
    62         return values.at(idx).raw_bytes;
    63     }
    64 
    65     static uint32_t get_bytes_lgth(size_t idx) {
    66         return values.at(idx).raw_bytes_lgth;
    67     }
    68 
    69 private:
    70     typedef struct data {
    71         uint8_t * raw_bytes;
    72         uint32_t raw_bytes_lgth;
    73     } data;
    74 
    75     static vector<data> values;
    76 };
    77 
    78 /* Global GID data for all hash tables. */
    79 vector<gid_data::data> gid_data::values;
    80 
    8148template<class COMPARE_STRATEGY, class HASH_STRATEGY, class ALLOCATOR>
    8249class hash_table {
     
    12592
    12693    IDISA_ALWAYS_INLINE gid_type lookup_or_insert(uint8_t * raw_bytes, const uint32_t idx, const uint32_t raw_byte_lgth,
    127                                                   uint8_t * h0, uint8_t * h1, const uint32_t hash_bit_lgth, GIDFactory & gid_factory) {
     94                                                  uint8_t * h0, uint8_t * h1, const uint32_t hash_bit_lgth,
     95                                                        GIDFactory & gid_factory, GIDData & gid_data) {
    12896
    12997        uint64_t bucket = get_bucket(h0,h1,idx,hash_bit_lgth);
     
    173141        #endif
    174142
    175         gid_data::add_data(data_pool_raw_bytes,raw_byte_lgth);
     143        gid_data.add_data(data_pool_raw_bytes,raw_byte_lgth);
    176144
    177145        return gid;
  • trunk/symbol_table/src/id_symbol_table.hpp

    r2027 r2028  
    1414#define ID_SYMBOL_TABLE_TEMPLATE_HPP
    1515
    16 //#define ID_SYMBOL_TABLE_TEMPLATE_HPP_DEBUG
    17 #ifdef ID_SYMBOL_TABLE_TEMPLATE_HPP_DEBUG
    18 static void print_symbol_debug(const uint8_t buffer [], const int32_t spos, const uint32_t epos, const uint32_t lgth) {
    19     cout << "Symbol(";
    20     cout << "Lgth:" << lgth;
    21     cout << ",Value:'" << string((char *)&(buffer[spos]), lgth) << "'";
    22     cout << ",Start:" << spos;
    23     cout << ",End:" << epos;
    24     cout << ")" << endl;
    25 }
    26 #endif
    27 
    2816#include "symbol_table.hpp"
    2917#include "buffer.hpp"
     
    3220#include "../lib/bitblock_scan.hpp"
    3321#include <cstdlib>
     22
     23#ifdef ID_SYMBOL_TABLE_TEMPLATE_HPP_DEBUG
     24static void print_symbol_debug(gid_type gid, const uint8_t buffer [], const int32_t spos, const uint32_t epos, const uint32_t lgth) {
     25    cout << "{Symbol:{";
     26    cout << "GID:" << gid;
     27    cout << ",Length:" << lgth;
     28    cout << ",Value:'" << string((char *)&(buffer[spos]), lgth) << "'";
     29    cout << ",Start:" << spos;
     30    cout << ",End:" << epos;
     31    cout << "}}" << endl;
     32}
     33#endif
    3434
    3535template<class SYMBOL, class ALLOCATOR>
     
    9696                                 &buffer[blk_offset], 1,                                                  /* buffer, symbol length */
    9797                                 &buffer[blk_offset], &buffer[blk_offset], bytes2bits(1), BLOCK_SIZE, /* h0, h1, hash lgth (bits), hash block size (bits) */
    98                                  symbols, this->gid_factory);
     98                                 symbols, this->gid_factory, this->gid_data);
    9999            }
    100100
     
    106106                                 &buffer[blk_offset], 2,
    107107                                 &buffer[blk_offset], &buffer[blk_offset], bytes2bits(2), BLOCK_SIZE,
    108                                  symbols, this->gid_factory);
     108                                 symbols, this->gid_factory, this->gid_data);
    109109        }
    110110
     
    116116                                 &buffer[blk_offset], 3,
    117117                                 &buffer[blk_offset], &buffer[blk_offset], bytes2bits(3), BLOCK_SIZE,
    118                                  symbols, this->gid_factory);
     118                                 symbols, this->gid_factory, this->gid_data);
    119119        }
    120120        if(bitblock::any(groups[blk].ends_4)) {
     
    125125                                 &buffer[blk_offset], 4,
    126126                                 &buffer[blk_offset], &buffer[blk_offset], bytes2bits(4), BLOCK_SIZE,
    127                                  symbols, this->gid_factory);
     127                                 symbols, this->gid_factory, this->gid_data);
    128128        }
    129129
     
    135135                                 &buffer[blk_offset], 5,
    136136                                 &buffer[blk_offset], &buffer[blk_offset], bytes2bits(5), BLOCK_SIZE,
    137                                  symbols, this->gid_factory);
     137                                 symbols, this->gid_factory, this->gid_data);
    138138        }
    139139        if(bitblock::any(groups[blk].ends_6)) {
     
    144144                                 &buffer[blk_offset], 6,
    145145                                 &buffer[blk_offset], &buffer[blk_offset], bytes2bits(6), BLOCK_SIZE,
    146                                  symbols, this->gid_factory);
     146                                 symbols, this->gid_factory, this->gid_data);
    147147        }
    148148        if(bitblock::any(groups[blk].ends_7)) {
     
    153153                                 &buffer[blk_offset], 7,
    154154                                 &buffer[blk_offset], &buffer[blk_offset], bytes2bits(7), BLOCK_SIZE,
    155                                  symbols, this->gid_factory);
     155                                 symbols, this->gid_factory, this->gid_data);
    156156        }
    157157
     
    165165                                 groups[blk].ends_8, &buffer[blk_offset], 8,
    166166                                 (uint8_t *)&h0[blk], (uint8_t *)&h1[blk], 8, BLOCK_SIZE/8,
    167                                  symbols, this->gid_factory);
     167                                 symbols, this->gid_factory, this->gid_data);
    168168        }
    169169                if(bitblock::any(groups[blk].ends_9)) {
     
    173173                                groups[blk].ends_9, &buffer[blk_offset], 9,
    174174                                (uint8_t *)&h0[blk], (uint8_t *)&h1[blk], 9, BLOCK_SIZE/8,
    175                                 symbols, this->gid_factory);
     175                                symbols, this->gid_factory, this->gid_data);
    176176                }
    177177
     
    182182                                groups[blk].ends_10, &buffer[blk_offset], 10,
    183183                                (uint8_t *)&h0[blk], (uint8_t *)&h1[blk], 10, BLOCK_SIZE/8,
    184                                 symbols, this->gid_factory);
     184                                symbols, this->gid_factory, this->gid_data);
    185185                }
    186186                if(bitblock::any(groups[blk].ends_11)) {
     
    190190                                        groups[blk].ends_11, &buffer[blk_offset], 11,
    191191                                        (uint8_t *)&h0[blk], (uint8_t *)&h1[blk], 11, BLOCK_SIZE/8,
    192                                         symbols, this->gid_factory);
     192                                        symbols, this->gid_factory, this->gid_data);
    193193                }
    194194                if(bitblock::any(groups[blk].ends_12)) {
     
    198198                                        groups[blk].ends_12, &buffer[blk_offset], 12,
    199199                                        (uint8_t *)&h0[blk], (uint8_t *)&h1[blk], 12, BLOCK_SIZE/8,
    200                                         symbols, this->gid_factory);
     200                                        symbols, this->gid_factory, this->gid_data);
    201201                }
    202202                if(bitblock::any(groups[blk].ends_13)) {
     
    206206                                        groups[blk].ends_13, &buffer[blk_offset], 13,
    207207                                        (uint8_t *)&h0[blk], (uint8_t *)&h1[blk], 13, BLOCK_SIZE/8,
    208                                         symbols, this->gid_factory);
     208                                        symbols, this->gid_factory, this->gid_data);
    209209                }
    210210                if(bitblock::any(groups[blk].ends_14)) {
     
    214214                                        groups[blk].ends_14, &buffer[blk_offset], 14,
    215215                                        (uint8_t *)&h0[blk], (uint8_t *)&h1[blk], 14, BLOCK_SIZE/8,
    216                                         symbols, this->gid_factory);
     216                                        symbols, this->gid_factory, this->gid_data);
    217217                }
    218218                if(bitblock::any(groups[blk].ends_15)) {
     
    222222                                        groups[blk].ends_15, &buffer[blk_offset], 15,
    223223                                        (uint8_t *)&h0[blk], (uint8_t *)&h1[blk], 15, BLOCK_SIZE/8,
    224                                         symbols, this->gid_factory);
     224                                        symbols, this->gid_factory, this->gid_data);
    225225                }
    226226                if(bitblock::any(groups[blk].ends_16)) {
     
    230230                                        groups[blk].ends_16, &buffer[blk_offset], 16,
    231231                                        (uint8_t *)&h0[blk], (uint8_t *)&h1[blk], 16, BLOCK_SIZE/8,
    232                                         symbols, this->gid_factory);
     232                                        symbols, this->gid_factory, this->gid_data);
    233233                }
    234234
     
    240240                                         &buffer[blk_offset],
    241241                                         (uint8_t *)&h0[blk], (uint8_t *)&h1[blk], 17, BLOCK_SIZE/8,
    242                                          symbols, this->gid_factory);
     242                                         symbols, this->gid_factory, this->gid_data);
    243243                }
    244244
     
    281281              uint8_t buffer [], const uint32_t lgth,
    282282              uint8_t h0 [], uint8_t h1 [], const uint32_t h_lgth, const uint32_t h_block_size,
    283               SYMBOL & symbols, GIDFactory & gid_factory) {
     283              SYMBOL & symbols, GIDFactory & gid_factory, GIDData & gid_data) {
    284284
    285285    gid_type gid;
     
    303303        uint8_t * lb_h1 = h1 - ((lgth / BLOCK_SIZE) + 1)*h_block_size;
    304304
    305         gid = h_table.lookup_or_insert(lb_buffer, lb_spos, lgth, lb_h0, lb_h1, h_lgth, gid_factory);
     305        gid = h_table.lookup_or_insert(lb_buffer, lb_spos, lgth, lb_h0, lb_h1, h_lgth, gid_factory, gid_data);
    306306
    307307        symbols.gids[blk_offset + spos] = gid;
     
    311311
    312312        #ifdef ID_SYMBOL_TABLE_TEMPLATE_HPP_DEBUG
    313                         print_symbol_debug(lb_buffer, lb_spos, epos, lgth);
     313                        print_symbol_debug(gid, lb_buffer, lb_spos, epos, lgth);
    314314        #endif
    315315
     
    322322        while(!fscanner.is_done()) {
    323323
    324                 gid = h_table.lookup_or_insert(buffer, spos, lgth, h0, h1, h_lgth, gid_factory);
     324                gid = h_table.lookup_or_insert(buffer, spos, lgth, h0, h1, h_lgth, gid_factory, gid_data);
    325325                symbols.gids[blk_offset + spos] = gid;
    326326
    327327        #ifdef ID_SYMBOL_TABLE_TEMPLATE_HPP_DEBUG
    328                 print_symbol_debug(buffer, spos, epos, lgth);
     328                print_symbol_debug(gid, buffer, spos, epos, lgth);
    329329        #endif
    330330
     
    344344                          uint8_t buffer [],
    345345                          uint8_t h0 [], uint8_t h1 [], const uint32_t h_lgth, const uint32_t h_block_size,
    346                           SYMBOL & symbols, GIDFactory & gid_factory) {
     346                          SYMBOL & symbols, GIDFactory & gid_factory, GIDData & gid_data) {
    347347
    348348        BitBlock * starts_base = starts;
     
    389389                }
    390390
    391                 gid = h_table.lookup_or_insert(buffer, spos, lgth, h0_base, h1_base, h_lgth, gid_factory);
     391                gid = h_table.lookup_or_insert(buffer, spos, lgth, h0_base, h1_base, h_lgth, gid_factory, gid_data);
    392392                symbols.gids[blk_offset + spos] = gid;
    393393
    394394                #ifdef ID_SYMBOL_TABLE_TEMPLATE_HPP_DEBUG
    395                         print_symbol_debug(buffer, spos, epos, lgth);
     395                        print_symbol_debug(gid, buffer, spos, epos, lgth);
    396396                #endif
    397397
  • trunk/symbol_table/src/symbol_table.hpp

    r2027 r2028  
    1111#include "../lib/bitblock.hpp"
    1212#include "../lib/byte_pool.hpp"
    13 #include "gid_factory.hpp"
     13#include "gid.hpp"
    1414#include "hash_table.hpp"
    1515
     
    2525public:
    2626    Symbol (uint32_t n) {
    27         init(n);
     27                        init(n);
    2828    }
    2929
    3030    void init(uint32_t n) {
    31         gids.reserve(n);
    32         //gids_idx.reserve((n/BLOCK_SIZE) + 1);
     31                        gids.reserve(n);
     32                        //gids_idx.reserve((n/BLOCK_SIZE) + 1);
    3333    }
    3434
     
    3737};
    3838
    39 ///////////////////////////////////////////////////////////////////////////
    40 // GID indexed POD array
    41 ///////////////////////////////////////////////////////////////////////////
    42 
    4339template <class SYMBOL> class symbol_table{
    4440public:
     
    4642                 BitBlock h0 [], BitBlock h1 [], uint32_t blocks, SYMBOL & symbols /*, const uint32_t symbols*/);
    4743
    48     IDISA_ALWAYS_INLINE uint8_t * get_raw_data(uint32_t idx) const { return gid_data::get_raw_bytes(idx); }
    49     IDISA_ALWAYS_INLINE uint32_t get_lgth(uint32_t idx) const { return gid_data::get_bytes_lgth(idx); }
     44    IDISA_ALWAYS_INLINE uint8_t * get_raw_data(uint32_t idx) const { return gid_data.get_raw_bytes(idx); }
     45    IDISA_ALWAYS_INLINE uint32_t get_lgth(uint32_t idx) const { return gid_data.get_bytes_lgth(idx); }
    5046
    5147protected:
     
    5349    ~symbol_table() {}
    5450
    55     GIDFactory gid_factory;
     51    GIDFactory gid_factory;     
     52                GIDData gid_data;               
    5653};
    5754
     
    6259              uint8_t buffer [], const uint32_t lgth,
    6360              uint8_t h0 [], uint8_t h1 [], const uint32_t h_lgth, const uint32_t h_block_size,
    64               SYMBOL & symbols, GIDFactory & gid_factory);
     61              SYMBOL & symbols, GIDFactory & gid_factory, GIDData & gid_data);
    6562
    6663template<class SYMBOL, class HASH_TABLE>
     
    7067              uint8_t buffer [],
    7168              uint8_t h0 [], uint8_t h1 [], const uint32_t h_lgth, const uint32_t h_block_size,
    72               SYMBOL & symbols, GIDFactory & gid_factory);
     69              SYMBOL & symbols, GIDFactory & gid_factory, GIDData & gid_data);
    7370
    7471#endif // SYMBOL_TABLE_HPP
Note: See TracChangeset for help on using the changeset viewer.