inv_table.h

Go to the documentation of this file.

#ifndef GPUGenie_inv_table_h
#define GPUGenie_inv_table_h

#include <vector>
#include <map>
#include <unordered_map>
#include "inv_list.h"

#include <boost/serialization/access.hpp>
#include <boost/serialization/split_member.hpp>

typedef unsigned long long u64;


namespace genie
{
namespace table
{

class inv_compr_table;

class inv_table
{
public:

    enum status
    {
        not_builded, builded
    };
    int *d_inv_p = NULL;

    static int max_inv_size;

    bool is_stored_in_gpu;

    int shift_bits_sequence;



private:

    int table_index;

    int total_num_of_table;



    status _build_status;

    int _shifter;

    int _size;

    int _dim_size;

    std::vector<inv_list> _inv_lists;

    //vector<vector<int> > distinct_value;
    std::vector<std::unordered_map<int, int> > _distinct_map;


    std::vector<int> inv_list_upperbound;

    std::vector<int> inv_list_lowerbound;

    std::vector<std::vector<int> > posting_list_size;



    std::vector<int> _ck;

    std::vector<int> _inv;

    std::unordered_map<size_t, int> _inv_index_map;

    std::vector<int> _inv_pos;

      unsigned int shift_bits_subsequence;

      int min_value_sequence;


      int max_value_sequence;

      int gram_length_sequence;


public:

    inv_table():is_stored_in_gpu(false),shift_bits_sequence(0),
                table_index(0),total_num_of_table(1),
                _build_status(not_builded), _shifter(16),_size(-1),_dim_size(0),
                shift_bits_subsequence(0),
                min_value_sequence(0), max_value_sequence(0), gram_length_sequence(1)
    {
    }

    virtual ~inv_table();


    std::unordered_map<int, int>* get_distinct_map(int dim);

    void append_sequence(inv_list& inv);

    void
    set_table_index(int attr_index);

    void
    set_total_num_of_table(int num);

    int
    get_table_index() const;

    int
    get_total_num_of_table() const;


    bool
    cpy_data_to_gpu();

    void
    clear_gpu_mem();

    void
    clear();

    bool
    empty();

    int
    m_size();

    int
    i_size();

    int
    shifter();

        unsigned int
        _shift_bits_subsequence();

    void
    append(inv_list& inv);

    void
    append(inv_list* inv);

    status
    build_status();

    std::vector<inv_list>*
    inv_lists();

    virtual std::vector<int>*
    ck();

    virtual std::vector<int>*
    inv();

    std::unordered_map<size_t, int>*
    inv_index_map();

    virtual std::vector<int>*
    inv_pos();


    int
    get_upperbound_of_list(int attr_index);

    int
    get_lowerbound_of_list(int attr_index);




    void
    virtual build(size_t max_length, bool use_load_balance);


    int
    get_posting_list_size(int attr_index, int value);

    bool
    list_contain(int attr_index, int value);

    void
    set_min_value_sequence(int min_value);

    int
    get_min_value_sequence();

    void
    set_max_value_sequence(int max_value);

    int
    get_max_value_sequence();

    void
    set_gram_length_sequence(int gram_length);

    int
    get_gram_length_sequence();


    template <class Archive>
    void load(Archive &ar, const unsigned int version);

    template <class Archive>
    void save(Archive &ar, const unsigned int version) const;

    BOOST_SERIALIZATION_SPLIT_MEMBER()

private:
    friend class boost::serialization::access;

};

} // namespace table
} // namespace genie

#endif