498 lines
14 KiB
C++
498 lines
14 KiB
C++
#include <chrono>
|
|
#include <ctime>
|
|
#include <fstream>
|
|
#include <iostream>
|
|
#include <queue>
|
|
#include <regex>
|
|
#include <sstream>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
#include "data_structures/map/rh_hashmap.hpp"
|
|
#include "database/db.hpp"
|
|
#include "database/db_accessor.hpp"
|
|
#include "storage/edges.cpp"
|
|
#include "storage/edges.hpp"
|
|
#include "storage/indexes/impl/nonunique_unordered_index.cpp"
|
|
#include "storage/model/properties/properties.cpp"
|
|
#include "storage/record_accessor.cpp"
|
|
#include "storage/vertex_accessor.cpp"
|
|
#include "storage/vertex_accessor.hpp"
|
|
#include "storage/vertices.cpp"
|
|
#include "storage/vertices.hpp"
|
|
|
|
using namespace std;
|
|
typedef Vertex::Accessor VertexAccessor;
|
|
void load_graph_dummy(Db &db);
|
|
int load_csv(Db &db, char *file_path, char *edge_file_path);
|
|
|
|
class Node
|
|
{
|
|
public:
|
|
Node *parent = {nullptr};
|
|
type_key_t<Double> tkey;
|
|
double cost;
|
|
int depth = {0};
|
|
VertexAccessor vacc;
|
|
|
|
Node(VertexAccessor vacc, double cost, type_key_t<Double> tkey)
|
|
: cost(cost), vacc(vacc), tkey(tkey)
|
|
{
|
|
}
|
|
Node(VertexAccessor vacc, double cost, Node *parent,
|
|
type_key_t<Double> tkey)
|
|
: cost(cost), vacc(vacc), parent(parent), depth(parent->depth + 1),
|
|
tkey(tkey)
|
|
{
|
|
}
|
|
|
|
double sum_vertex_score()
|
|
{
|
|
auto now = this;
|
|
double sum = 0;
|
|
do {
|
|
sum += *(now->vacc.at(tkey).get());
|
|
now = now->parent;
|
|
} while (now != nullptr);
|
|
return sum;
|
|
}
|
|
};
|
|
|
|
class Score
|
|
{
|
|
public:
|
|
Score() : value(std::numeric_limits<double>::max()) {}
|
|
Score(double v) : value(v) {}
|
|
double value;
|
|
};
|
|
|
|
// class Iterator : public Crtp<Iterator>
|
|
// {
|
|
// public:
|
|
// Vertex *operator*()
|
|
// {
|
|
// assert(head != nullptr);
|
|
// return head->vertex;
|
|
// }
|
|
//
|
|
// Vertex *operator->()
|
|
// {
|
|
// assert(head != nullptr);
|
|
// return head->vertex;
|
|
// }
|
|
//
|
|
// Iterator &operator++()
|
|
// {
|
|
// assert(head != nullptr);
|
|
// head = head->parent;
|
|
// return this->derived();
|
|
// }
|
|
//
|
|
// Iterator &operator++(int) { return operator++(); }
|
|
//
|
|
// friend bool operator==(const Iterator &a, const Iterator &b)
|
|
// {
|
|
// return a.head == b.head;
|
|
// }
|
|
//
|
|
// friend bool operator!=(const Iterator &a, const Iterator &b)
|
|
// {
|
|
// return !(a == b);
|
|
// }
|
|
//
|
|
// Iterator end() { return Iterator(); }
|
|
//
|
|
// private:
|
|
// Node *head;
|
|
// };
|
|
|
|
void found_result(Node *res)
|
|
{
|
|
double sum = res->sum_vertex_score();
|
|
|
|
std::cout << "{score: " << sum << endl;
|
|
auto bef = res;
|
|
while (bef != nullptr) {
|
|
std::cout << " " << *(bef->vacc.operator->()) << endl;
|
|
bef = bef->parent;
|
|
}
|
|
}
|
|
|
|
double calc_heuristic_cost_dummy(type_key_t<Double> tkey, Edge::Accessor &edge,
|
|
Vertex::Accessor &vertex)
|
|
{
|
|
assert(!vertex.empty());
|
|
return 1 - *vertex.at(tkey).get();
|
|
}
|
|
|
|
typedef bool (*EdgeFilter)(DbAccessor &t, Edge::Accessor &, Node *before);
|
|
typedef bool (*VertexFilter)(DbAccessor &t, Vertex::Accessor &, Node *before);
|
|
|
|
bool edge_filter_dummy(DbAccessor &t, Edge::Accessor &e, Node *before)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
bool vertex_filter_dummy(DbAccessor &t, Vertex::Accessor &va, Node *before)
|
|
{
|
|
return va.fill();
|
|
}
|
|
|
|
bool vertex_filter_contained_dummy(DbAccessor &t, Vertex::Accessor &v,
|
|
Node *before)
|
|
{
|
|
if (v.fill()) {
|
|
bool found;
|
|
do {
|
|
found = false;
|
|
before = before->parent;
|
|
if (before == nullptr) {
|
|
return true;
|
|
}
|
|
auto it = before->vacc.out();
|
|
for (auto e = it.next(); e.is_present(); e = it.next()) {
|
|
VertexAccessor va = e.get().to();
|
|
if (va == v) {
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
} while (found);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool vertex_filter_contained(DbAccessor &t, Vertex::Accessor &v, Node *before)
|
|
{
|
|
if (v.fill()) {
|
|
bool found;
|
|
do {
|
|
found = false;
|
|
before = before->parent;
|
|
if (before == nullptr) {
|
|
return true;
|
|
}
|
|
} while (v.in_contains(before->vacc));
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Vertex filter ima max_depth funkcija te edge filter ima max_depth funkcija.
|
|
// Jedan za svaku dubinu.
|
|
// Filtri vracaju true ako element zadovoljava uvjete.
|
|
auto a_star(Db &db, int64_t sys_id_start, uint max_depth, EdgeFilter e_filter[],
|
|
VertexFilter v_filter[],
|
|
double (*calc_heuristic_cost)(type_key_t<Double> tkey,
|
|
Edge::Accessor &edge,
|
|
Vertex::Accessor &vertex),
|
|
int limit)
|
|
{
|
|
DbAccessor t(db);
|
|
type_key_t<Double> tkey = t.vertex_property_family_get("score")
|
|
.get(Flags::Double)
|
|
.type_key<Double>();
|
|
|
|
auto best_found = new std::map<Id, Score>[max_depth];
|
|
|
|
std::vector<Node *> best;
|
|
auto cmp = [](Node *left, Node *right) { return left->cost > right->cost; };
|
|
std::priority_queue<Node *, std::vector<Node *>, decltype(cmp)> queue(cmp);
|
|
|
|
auto start_vr = t.vertex_find(sys_id_start);
|
|
assert(start_vr);
|
|
start_vr.get().fill();
|
|
Node *start = new Node(start_vr.take(), 0, tkey);
|
|
queue.push(start);
|
|
int count = 0;
|
|
do {
|
|
auto now = queue.top();
|
|
queue.pop();
|
|
// if(!visited.insert(now)){
|
|
// continue;
|
|
// }
|
|
|
|
if (max_depth <= now->depth) {
|
|
best.push_back(now);
|
|
count++;
|
|
if (count >= limit) {
|
|
return best;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
// { // FOUND FILTER
|
|
// Score &bef = best_found[now->depth][now->vacc.id()];
|
|
// if (bef.value <= now->cost) {
|
|
// continue;
|
|
// }
|
|
// bef.value = now->cost;
|
|
// }
|
|
|
|
iter::for_all(now->vacc.out(), [&](auto edge) {
|
|
if (e_filter[now->depth](t, edge, now)) {
|
|
VertexAccessor va = edge.to();
|
|
if (v_filter[now->depth](t, va, now)) {
|
|
auto cost = calc_heuristic_cost(tkey, edge, va);
|
|
Node *n = new Node(va, now->cost + cost, now, tkey);
|
|
queue.push(n);
|
|
}
|
|
}
|
|
});
|
|
} while (!queue.empty());
|
|
// std::cout << "Found: " << count << " resoults\n";
|
|
// TODO: GUBI SE MEMORIJA JER SE NODOVI NEBRISU
|
|
|
|
t.commit();
|
|
return best;
|
|
}
|
|
|
|
// class Data
|
|
// {
|
|
//
|
|
// private:
|
|
// size_t data = 0;
|
|
// int key;
|
|
//
|
|
// public:
|
|
// Data(int key) : key(key) {}
|
|
//
|
|
// const int &get_key() { return key; }
|
|
// };
|
|
|
|
int main(int argc, char **argv)
|
|
{
|
|
if (argc < 3) {
|
|
std::cout << "Not enough input values\n";
|
|
return 0;
|
|
} else if (argc > 4) {
|
|
std::cout << "To much input values\n";
|
|
return 0;
|
|
}
|
|
|
|
Db db;
|
|
auto vertex_no = load_csv(db, argv[argc - 2], argv[argc - 1]);
|
|
|
|
EdgeFilter e_filters[] = {&edge_filter_dummy, &edge_filter_dummy,
|
|
&edge_filter_dummy, &edge_filter_dummy};
|
|
VertexFilter f_filters[] = {
|
|
&vertex_filter_contained, &vertex_filter_contained,
|
|
&vertex_filter_contained, &vertex_filter_contained};
|
|
|
|
// CONF
|
|
std::srand(time(0));
|
|
auto best_n = 10;
|
|
auto bench_n = 1000;
|
|
auto best_print_n = 10;
|
|
bool pick_best_found = argc > 3 ? true : false;
|
|
|
|
double sum = 0;
|
|
std::vector<Node *> best;
|
|
for (int i = 0; i < bench_n; i++) {
|
|
auto start_vertex_index = std::rand() % vertex_no;
|
|
|
|
auto begin = clock();
|
|
auto found = a_star(db, start_vertex_index, 3, e_filters, f_filters,
|
|
&calc_heuristic_cost_dummy, best_n);
|
|
clock_t end = clock();
|
|
|
|
double elapsed_ms = (double(end - begin) / CLOCKS_PER_SEC) * 1000;
|
|
sum += elapsed_ms;
|
|
|
|
if ((best.size() < best_print_n && found.size() > best.size()) ||
|
|
(pick_best_found && found.size() > 0 &&
|
|
found.front()->sum_vertex_score() >
|
|
best.front()->sum_vertex_score())) {
|
|
best = found;
|
|
}
|
|
|
|
// Just to be safe
|
|
if (i + 1 == bench_n && best.size() == 0) {
|
|
bench_n++;
|
|
}
|
|
}
|
|
|
|
std::cout << "\nSearch for best " << best_n
|
|
<< " results has runing time of:\n avg: " << sum / bench_n
|
|
<< " [ms]\n";
|
|
std::cout << "\nExample of best result:\n";
|
|
for (int i = 0; i < best_print_n && best.size() > 0; i++) {
|
|
found_result(best.front());
|
|
best.erase(best.begin());
|
|
}
|
|
|
|
// RhHashMultiMap benchmark
|
|
// const int n_pow2 = 20;
|
|
// int n = 1 << n_pow2;
|
|
// RhHashMultiMap<int, Data, n_pow2 + 1> map;
|
|
// std::srand(time(0));
|
|
// auto data = std::vector<Data *>();
|
|
// for (int i = 0; i < n; i++) {
|
|
// data.push_back(new Data(std::rand()));
|
|
// }
|
|
//
|
|
// begin = clock();
|
|
// for (auto e : data) {
|
|
// map.add(e);
|
|
// }
|
|
// end = clock();
|
|
// elapsed_ms = (double(end - begin) / CLOCKS_PER_SEC) * 1000;
|
|
// std::cout << "Map: " << elapsed_ms << " [ms]\n";
|
|
|
|
return 0;
|
|
}
|
|
|
|
void split(const string &s, char delim, vector<string> &elems)
|
|
{
|
|
stringstream ss(s);
|
|
string item;
|
|
while (getline(ss, item, delim)) {
|
|
elems.push_back(item);
|
|
}
|
|
}
|
|
|
|
vector<string> split(const string &s, char delim)
|
|
{
|
|
vector<string> elems;
|
|
split(s, delim, elems);
|
|
return elems;
|
|
}
|
|
|
|
int load_csv(Db &db, char *file_path, char *edge_file_path)
|
|
{
|
|
std::fstream file(file_path);
|
|
std::fstream e_file(edge_file_path);
|
|
|
|
std::string line;
|
|
|
|
DbAccessor t(db);
|
|
auto key_id =
|
|
t.vertex_property_family_get("id").get(Flags::Int32).family_key();
|
|
auto key_garment_id = t.vertex_property_family_get("garment_id")
|
|
.get(Flags::Int32)
|
|
.family_key();
|
|
auto key_garment_category_id =
|
|
t.vertex_property_family_get("garment_category_id")
|
|
.get(Flags::Int32)
|
|
.family_key();
|
|
auto key_score =
|
|
t.vertex_property_family_get("score").get(Flags::Double).family_key();
|
|
|
|
int max_score = 1000000;
|
|
|
|
// VERTEX import
|
|
int start_vertex_id = -1;
|
|
auto v = [&](auto id, auto labels, auto gar_id, auto cat_id) {
|
|
if (start_vertex_id < 0) {
|
|
start_vertex_id = id;
|
|
}
|
|
|
|
auto vertex_accessor = t.vertex_insert();
|
|
vertex_accessor.set(key_id, std::make_shared<Int32>(id));
|
|
vertex_accessor.set(key_garment_id, std::make_shared<Int32>(gar_id));
|
|
vertex_accessor.set(key_garment_category_id,
|
|
std::make_shared<Int32>(cat_id));
|
|
// from Kruno's head :) (could be ALMOST anything else)
|
|
std::srand(id ^ 0x7482616);
|
|
vertex_accessor.set(key_score,
|
|
std::make_shared<Double>((std::rand() % max_score) /
|
|
(max_score + 0.0)));
|
|
|
|
for (auto l_name : labels) {
|
|
auto &label = t.label_find_or_create(l_name);
|
|
vertex_accessor.add_label(label);
|
|
}
|
|
|
|
return vertex_accessor;
|
|
};
|
|
|
|
// Skip header
|
|
std::getline(file, line);
|
|
|
|
vector<Vertex::Accessor> va;
|
|
int v_count = 0;
|
|
while (std::getline(file, line)) {
|
|
v_count++;
|
|
line.erase(std::remove(line.begin(), line.end(), '['), line.end());
|
|
line.erase(std::remove(line.begin(), line.end(), ']'), line.end());
|
|
line.erase(std::remove(line.begin(), line.end(), '\"'), line.end());
|
|
line.erase(std::remove(line.begin(), line.end(), ' '), line.end());
|
|
auto splited = split(line, ',');
|
|
vector<string> labels(splited.begin() + 1,
|
|
splited.begin() + splited.size() - 2);
|
|
auto vacs =
|
|
v(stoi(splited[0]), labels, stoi(splited[splited.size() - 2]),
|
|
stoi(splited[splited.size() - 1]));
|
|
|
|
assert(va.size() == (uint64_t)vacs.id());
|
|
va.push_back(vacs);
|
|
}
|
|
|
|
// EDGE IMPORT
|
|
auto e = [&](auto from, auto type, auto to) {
|
|
auto v1 = va[from - start_vertex_id];
|
|
|
|
auto v2 = va[to - start_vertex_id];
|
|
|
|
auto edge_accessor = t.edge_insert(v1, v2);
|
|
|
|
auto &edge_type = t.type_find_or_create(type);
|
|
edge_accessor.edge_type(edge_type);
|
|
};
|
|
|
|
std::getline(e_file, line);
|
|
long count = 0;
|
|
while (std::getline(e_file, line)) {
|
|
auto splited = split(line, ',');
|
|
count++;
|
|
e(stoi(splited[2]), splited[1], stoi(splited[3]));
|
|
}
|
|
|
|
cout << "Loaded:\n Vertices: " << v_count << "\n Edges: " << count
|
|
<< endl;
|
|
|
|
t.commit();
|
|
return v_count;
|
|
}
|
|
|
|
void load_graph_dummy(Db &db)
|
|
{
|
|
DbAccessor t(db);
|
|
|
|
// TODO: update code
|
|
// auto v = [&](auto id, auto score) {
|
|
// auto vertex_accessor = t.vertex_insert();
|
|
// vertex_accessor.property("id", std::make_shared<Int32>(id));
|
|
// vertex_accessor.property("score", std::make_shared<Double>(score));
|
|
// return vertex_accessor.id();
|
|
// };
|
|
//
|
|
// Id va[] = {
|
|
// v(0, 0.5), v(1, 1), v(2, 0.3), v(3, 0.15), v(4, 0.8), v(5, 0.8),
|
|
// };
|
|
//
|
|
// auto e = [&](auto from, auto type, auto to) {
|
|
// auto v1 = t.vertex_find(va[from]);
|
|
//
|
|
// auto v2 = t.vertex_find(va[to]);
|
|
//
|
|
// auto edge_accessor = t.edge_insert(v1.get(), v2.get());
|
|
//
|
|
// auto &edge_type = t.type_find_or_create(type);
|
|
// edge_accessor.edge_type(edge_type);
|
|
// };
|
|
//
|
|
// e(0, "ok", 3);
|
|
// e(0, "ok", 2);
|
|
// e(0, "ok", 4);
|
|
// e(1, "ok", 3);
|
|
// e(2, "ok", 1);
|
|
// e(2, "ok", 4);
|
|
// e(3, "ok", 4);
|
|
// e(3, "ok", 5);
|
|
// e(4, "ok", 0);
|
|
// e(4, "ok", 1);
|
|
// e(5, "ok", 2);
|
|
|
|
t.commit();
|
|
}
|