interface.h

Go to the documentation of this file.

#ifndef INTERFACE_H_
#define INTERFACE_H_

#include <vector>
#include <string>

#include <genie/compression/DeviceCodecFactory.h>
#include <genie/configure.h>
#include <genie/exception/exception.h>
#include <genie/query/query.h>
#include <genie/table/inv_table.h>
#include <genie/utility/FileReader.h>

#define GPUGENIE_DEFAULT_TOPK 10

#define GPUGENIE_DEFAULT_RADIUS 0

#define GPUGENIE_DEFAULT_THRESHOLD 0

#define GPUGENIE_DEFAULT_HASHTABLE_SIZE 1.0f

#define GPUGENIE_DEFAULT_WEIGHT 1

#define GPUGENIE_DEFAULT_DEVICE 0

#define GPUGENIE_DEFAULT_USE_ADAPTIVE_RANGE false

#define GPUGENIE_DEFAULT_SELECTIVITY -1.0f

#define GPUGENIE_DEFAULT_POSTING_LIST_LENGTH 100000

#define GPUGENIE_DEFAULT_LOAD_MULTIPLIER 3.0f

#define GPUGENIE_DEFAULT_USE_LOAD_BALANCE false

#define GPUGENIE_DEFAULT_USE_MULTIRANGE true

#define GPUGENIE_DEFAULT_NUM_OF_QUERIES 0


namespace genie
{
namespace original
{

typedef struct _GPUGenie_Config
{
    int num_of_topk;
    int query_radius;
    int count_threshold;
    float hashtable_size;
    int use_device;
    int dim;
    bool use_adaptive_range;
    float selectivity;
    std::vector<std::vector<int> > * data_points;
    int *data; 
    unsigned int *index; 
    unsigned int item_num;
    unsigned int row_num;
    int search_type; 
    int data_type; 
    unsigned int max_data_size; 
    bool save_to_gpu; 
    std::vector<std::vector<int> > * query_points;
    std::vector<genie::utility::attr_t> * multirange_query_points;
    int posting_list_max_length;
    float multiplier;
    bool use_load_balance;
    bool use_multirange;
    int num_of_queries;
    bool use_subsequence_search;
    int data_gram_length;
    unsigned int num_of_iteration;
    genie::compression::COMPRESSION_TYPE compression;

    _GPUGenie_Config() :
        num_of_topk(GPUGENIE_DEFAULT_TOPK),
        query_radius(GPUGENIE_DEFAULT_RADIUS),
        count_threshold(GPUGENIE_DEFAULT_THRESHOLD),
        hashtable_size(GPUGENIE_DEFAULT_HASHTABLE_SIZE),
        use_device(GPUGENIE_DEFAULT_DEVICE),
        dim(0),
        use_adaptive_range(GPUGENIE_DEFAULT_USE_ADAPTIVE_RANGE),
        selectivity(GPUGENIE_DEFAULT_SELECTIVITY),
        data_points(NULL), data(NULL), index(NULL),
        item_num(0), row_num(0), search_type(0),
        data_type(0), max_data_size(0), save_to_gpu(false),
        query_points(NULL), multirange_query_points(NULL),
        posting_list_max_length(GPUGENIE_DEFAULT_POSTING_LIST_LENGTH),
        multiplier(GPUGENIE_DEFAULT_LOAD_MULTIPLIER),
        use_load_balance(GPUGENIE_DEFAULT_USE_LOAD_BALANCE),
        use_multirange(GPUGENIE_DEFAULT_USE_MULTIRANGE),
        num_of_queries(GPUGENIE_DEFAULT_NUM_OF_QUERIES),
        use_subsequence_search(false),
        data_gram_length(3), num_of_iteration(1),
        compression(genie::compression::DEFAULT_COMPRESSION_TYPE){}

    _GPUGenie_Config(const _GPUGenie_Config &config) :
        num_of_topk(config.num_of_topk),
        query_radius(config.query_radius),
        count_threshold(config.count_threshold),
        hashtable_size(config.hashtable_size),
        use_device(config.use_device),
        dim(config.dim), use_adaptive_range(config.use_adaptive_range),
        selectivity(config.selectivity),
        data_points(config.data_points),
        data(config.data), index(config.index),
        item_num(config.item_num), row_num(config.row_num),
        search_type(config.search_type),
        data_type(config.data_type),
        max_data_size(config.max_data_size),
        save_to_gpu(config.save_to_gpu),
        query_points(config.query_points),
        multirange_query_points(config.multirange_query_points),
        posting_list_max_length(config.posting_list_max_length),
        multiplier(config.multiplier),
        use_load_balance(config.use_load_balance),
        use_multirange(config.use_multirange),
        num_of_queries(config.num_of_queries),
        use_subsequence_search(config.use_subsequence_search),
        data_gram_length(config.data_gram_length),
        num_of_iteration(config.num_of_iteration),
        compression(config.compression){}

                    
} GPUGenie_Config;







bool preprocess_for_knn_csv(GPUGenie_Config& config, genie::table::inv_table * &_table);

void knn_search_after_preprocess(GPUGenie_Config& config, genie::table::inv_table * &_table, std::vector<int>& result, std::vector<int>& result_count);

void knn_search(std::vector<int>& result, std::vector<int>& result_count, GPUGenie_Config& config);

void knn_search(std::vector<int>& result, GPUGenie_Config& config);

void knn_search(genie::table::inv_table& table, std::vector<genie::query::Query>& queries,
        std::vector<int>& h_topk, std::vector<int>& h_topk_count, GPUGenie_Config& config);

/* Multi table search */
void knn_search_MT(std::vector<genie::table::inv_table*>& table,std::vector<std::vector<genie::query::Query>>& queries,
        std::vector<std::vector<int> >& h_topk, std::vector<std::vector<int> >& h_topk_count, std::vector<GPUGenie_Config>& config);

void knn_search_for_csv_data(std::vector<int>& result, std::vector<int>& result_count, GPUGenie_Config& config);


void load_table(genie::table::inv_table& table, std::vector<std::vector<int> >& data_points, GPUGenie_Config& config);

void load_query(genie::table::inv_table& table, std::vector<genie::query::Query>& queries, GPUGenie_Config& config);

void load_query_singlerange(genie::table::inv_table& table, std::vector<genie::query::Query>& queries, GPUGenie_Config& config);

void load_query_multirange(genie::table::inv_table& table, std::vector<genie::query::Query>& queries, GPUGenie_Config& config);

void load_table_bijectMap(genie::table::inv_table& table, std::vector<std::vector<int> >& data_points, GPUGenie_Config& config);

void load_table(genie::table::inv_table& table, int *data, unsigned int item_num,
        unsigned int *index, unsigned int row_num, GPUGenie_Config& config);

void load_table_bijectMap(genie::table::inv_table& table, int *data, unsigned int item_num,
        unsigned int *index, unsigned int row_num, GPUGenie_Config& config);



void load_table_sequence(genie::table::inv_table& table, std::vector<std::vector<int> >& data_points, GPUGenie_Config& config);


void load_query_sequence(genie::table::inv_table& table, std::vector<genie::query::Query>& queries, GPUGenie_Config& config);

void sequence_to_gram(std::vector<std::vector<int> >& sequences, std::vector<std::vector<int> >& gram_data, int max_value, int gram_length);

void sequence_reduce_to_ground(std::vector<std::vector<int> >& data, std::vector<std::vector<int> >& converted_data, int& min_value, int& max_value);


void reset_device();

void get_rowID_offset(std::vector<int> &result, std::vector<int> &resultID, std::vector<int> &resultOffset, unsigned int shift_bits);

void init_genie(GPUGenie_Config &config);

} // namespace orig
} // namespace genie

#endif /* INTERFACE_H_ */