inv_compr_table.h

Go to the documentation of this file.

#ifndef GPUGenie_inv_compr_table_h
#define GPUGenie_inv_compr_table_h

#include <assert.h>
#include <map>
#include <memory>
#include <string>

#include <boost/serialization/export.hpp>

#include <genie/compression/DeviceCodecFactory.h>

#include "inv_table.h"

namespace genie
{
namespace table
{

class inv_compr_table : public genie::table::inv_table
{
protected:

    bool m_isCompressed; // TODO unused -> remove (Caution: need to generate all the binary inverted tables again!)

    std::vector<uint32_t> m_comprInv;

    std::vector<int> m_comprInvPos;

    genie::compression::COMPRESSION_TYPE m_compression;

    uint32_t *m_d_compr_inv_p;

    size_t m_uncompressedInvListsMaxLength;

public:

    inv_compr_table(): inv_table(),
            m_isCompressed(false),
            m_compression(genie::compression::DEFAULT_COMPRESSION_TYPE),
            m_d_compr_inv_p(nullptr),
            m_uncompressedInvListsMaxLength(0)
    {
        assert(sizeof(int) == sizeof(uint32_t)); // this is to make sure that virtual function inv() is correct
    }

    virtual ~inv_compr_table();


    genie::compression::COMPRESSION_TYPE getCompression() const;

    void setCompression(genie::compression::COMPRESSION_TYPE compression);


    /*
     * Return the equivalent of GPUGenie_Config::posting_list_max_length, indicating what is the maximum length of
     * a single uncompressed posting lists.
     * TODO: make this actually return the maximum length of an existing uncompressed inverted list
     */
    size_t getUncompressedPostingListMaxLength() const;

        void setUncompressedPostingListMaxLength(size_t length);

    /* 
     * Returns compressed version of _inv (posting lists array)
     * Note that the compressed table, decompression and matching modules all treat the compressed data as uint32_t,
     * so to avoid casts, use inv_compr_table::compressedInv() convenience function.
     */
    virtual std::vector<int>* inv();
    /*
     * Returns compressed version of _inv (posting lists array)
     */
    std::vector<uint32_t>* compressedInv();
    /* 
     * Returns uncompressed version of _inv (posting lists array).
     * This is an alias for inv_table::inv()
     * Note that inv_compt_table keeps a copy of uncompressed posting lists array.
     */
    std::vector<int>* uncompressedInv();

    /*
     * Returns compressed version of _inv_pos (starting positions of inverted lists in posting lists array)
     */
    virtual std::vector<int>* inv_pos(); 
    /* 
     * Returns compressed version of _inv_pos (starting positions of inverted lists in posting lists array)
     * This is an alias for inv_compr_table::inv_pos()
     */
    std::vector<int>* compressedInvPos();

    /* 
     * Returns uncompressed version of _inv_pos (starting positions of inverted lists in posting lists array)
     * This is an alias for inv_table::inv_pos()
     */
    std::vector<int>* uncompressedInvPos();


    uint32_t* deviceCompressedInv() const;

    double getCompressionRatio();



    virtual void build(size_t max_length, bool use_load_balance);



    bool cpy_data_to_gpu();

    void clear_gpu_mem();


    void clear();

    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


BOOST_CLASS_EXPORT_KEY(genie::table::inv_compr_table)

#endif