Skip to content

Refactor node set unify rebuild #1

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
luomojim wants to merge 1 commit into
base: main
Choose a base branch
from
Open

Refactor node set unify rebuild #1

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
166 changes: 90 additions & 76 deletions node_path_share.h
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,7 +1,8 @@
#pragma once
#include <vector>
#include <algorithm>
#include <unordered_map>
#pragma once
#include <vector>
#include <algorithm>
#include <cstdint>
#include <unordered_map>

namespace node_path
{
Expand Down Expand Up @@ -776,78 +777,91 @@ namespace node_path
return true;
}
//整合路径节点，最大化共享
bool unify_node_set()
{
std::vector<path> path_all;
if (get_path_all(path_all) == false)//先获取全部路径的全部节点
return false;

//清除原来的数据
this->node_set.clear();
this->node_set_free.clear();

std::unordered_map<path_unify_construct, std::vector<std::pair<path_index, size_t>>, path_unify_hash> floor_statistic;//按照层级，统计所有相同的信息
size_t floor_current = 0;//当前层级

while (path_all.empty() == false)
{
floor_statistic.clear();

size_t pos_path_each = 0;

//遍历每个层级中的所有节点
while (pos_path_each < path_all.size())
{
std::vector<path>::iterator path_each = path_all.begin() + pos_path_each;

if (floor_current < path_each->nodes.size())
{
path_unify_construct temp;

//构建统计信息
if (floor_current == 0) temp = path_unify_construct(NODE_ROOT_POS, path_each->nodes.front());//如果当前层级是根节点
else temp = path_unify_construct(static_cast<node_pos>(path_each->nodes[floor_current - 1]), path_each->nodes[floor_current]);

floor_statistic[temp].emplace_back(std::make_pair(path_each->index, pos_path_each));//统计
pos_path_each++;
}
else
{
path_all.erase(path_all.begin() + pos_path_each);//当前层级超出了路径长度范围，表明当前路径已经处理完毕，去除当前路径，直到所有路径处理完毕
}
}

std::unordered_map<path_unify_construct, std::vector<std::pair<path_index, size_t>>, path_unify_hash>::iterator statistic_each = floor_statistic.begin();

//遍历上边的所有统计
while (statistic_each != floor_statistic.end())
{
node_pos pos_new = create_ahead(ahead(statistic_each->first.last, statistic_each->first.current, statistic_each->second.size()));

std::vector<std::pair<path_index, size_t>>::iterator path_ref = statistic_each->second.begin();

//为每个路径构建
while (path_ref != statistic_each->second.end())
{
path_info* path_ref_single = get_path_info_by_path_pos_ptr(get_path_pos(path_ref->first));

path_ref_single->info.last_pos = pos_new;

if (floor_current == static_cast<size_t>((path_ref_single->info.len - 1) / 2))
path_ref_single->info.mid_pos = pos_new;//更新中点位置

path_all[path_ref->second].nodes[floor_current] = static_cast<node_index>(pos_new);//重复利用空间，保存当前前驱的储存位置
path_ref++;
}

statistic_each++;
}

floor_current++;
}

return true;
}
bool unify_node_set()
{
std::vector<path> path_all;
if (get_path_all(path_all) == false)//先获取全部路径的全部节点
return false;

std::vector<ahead> node_set_new;
size_t node_ref_total = 0;
for (std::vector<path>::const_iterator path_each = path_all.begin(); path_each != path_all.end(); path_each++)
node_ref_total += path_each->nodes.size();
node_set_new.reserve(node_ref_total);

std::unordered_map<path_unify_construct, node_pos, path_unify_hash> node_unify_pos;
node_unify_pos.reserve(node_ref_total);

std::vector<std::pair<path_index, path_info_base>> path_info_new;
path_info_new.reserve(path_all.size());

for (std::vector<path>::const_iterator path_each = path_all.begin(); path_each != path_all.end(); path_each++)
{
if (path_each->nodes.empty() == true)
return false;

node_pos pos_last = NODE_ROOT_POS;
node_pos pos_mid = NODE_INVALID_POS;
const size_t pos_mid_target = (path_each->nodes.size() - 1) / 2;

for (size_t pos_current = 0; pos_current < path_each->nodes.size(); pos_current++)
{
path_unify_construct node_key(pos_last, path_each->nodes[pos_current]);
std::unordered_map<path_unify_construct, node_pos, path_unify_hash>::iterator node_find = node_unify_pos.find(node_key);
node_pos pos_new = NODE_INVALID_POS;

if (node_find == node_unify_pos.end())
{
pos_new = static_cast<node_pos>(node_set_new.size());
node_set_new.emplace_back(pos_last, path_each->nodes[pos_current], 0);
node_unify_pos.emplace(node_key, pos_new);
}
else
{
pos_new = node_find->second;
}

node_set_new[pos_new].ref++;

if (pos_current == pos_mid_target)
pos_mid = pos_new;

pos_last = pos_new;
}

if (pos_mid == NODE_INVALID_POS || pos_last == NODE_INVALID_POS)
return false;

path_info_new.emplace_back(path_each->index, path_info_base(pos_last, pos_mid, static_cast<path_len>(path_each->nodes.size())));
}

for (std::vector<ahead>::const_iterator node_each = node_set_new.begin(); node_each != node_set_new.end(); node_each++)
{
if (node_each->test_validity_index() == false || node_each->test_validity_ref() == false)
return false;
if (node_each->last != NODE_ROOT_POS && node_each->last >= node_set_new.size())
return false;
}

for (std::vector<std::pair<path_index, path_info_base>>::const_iterator path_each = path_info_new.begin(); path_each != path_info_new.end(); path_each++)
{
if (test_validity_path_pos(get_path_pos(path_each->first)) == false)
return false;
}

this->node_set = std::move(node_set_new);
this->node_set_free.clear();

for (std::vector<std::pair<path_index, path_info_base>>::const_iterator path_each = path_info_new.begin(); path_each != path_info_new.end(); path_each++)
{
path_info* path_info_target = get_path_info_by_path_pos_ptr(get_path_pos(path_each->first));
path_info_target->info.last_pos = path_each->second.last_pos;
path_info_target->info.mid_pos = path_each->second.mid_pos;
path_info_target->info.len = path_each->second.len;
}

return true;
}
//获取系统状态
path_state_statistic get_state() const noexcept
{
Expand Down
70 changes: 70 additions & 0 deletions tests/smoke_unify.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,70 @@
#include "../node_path_share.h"

#include <cassert>
#include <vector>

using namespace node_path;

static std::vector<node_index> read_path(path_share& paths, path_index index)
{
path result;
assert(paths.get_path(index, result));
return result.nodes;
}

int main()
{
path_share paths;

path_index main_path = paths.create_path(1);
assert(main_path != PATH_INVALID_INDEX);
assert(paths.add_path_node(main_path, std::vector<node_index>({ 2, 3, 4, 5 })));

path_index branch_one = paths.create_branch(main_path, 2, 6);
assert(branch_one != PATH_INVALID_INDEX);
path_index branch_two = paths.create_branch(main_path, 3, 7);
assert(branch_two != PATH_INVALID_INDEX);

path_index same_one = paths.create_path(10);
assert(same_one != PATH_INVALID_INDEX);
assert(paths.add_path_node(same_one, std::vector<node_index>({ 11, 12 })));

path_index same_two = paths.create_path(10);
assert(same_two != PATH_INVALID_INDEX);
assert(paths.add_path_node(same_two, std::vector<node_index>({ 11, 12 })));

path_index sparse_path = paths.create_path(20);
assert(sparse_path != PATH_INVALID_INDEX);
assert(paths.add_path_node(sparse_path, std::vector<node_index>({ 21, 22 })));
assert(paths.del_path_node_single(sparse_path, 1));

const std::vector<node_index> main_before = read_path(paths, main_path);
const std::vector<node_index> branch_one_before = read_path(paths, branch_one);
const std::vector<node_index> branch_two_before = read_path(paths, branch_two);
const std::vector<node_index> same_one_before = read_path(paths, same_one);
const std::vector<node_index> same_two_before = read_path(paths, same_two);
const std::vector<node_index> sparse_before = read_path(paths, sparse_path);

const path_state_statistic before = paths.get_stastic();
assert(before.quantity_bytes_memory_alloc > before.quantity_bytes_memory_used);

assert(paths.unify());

const path_state_statistic after = paths.get_stastic();
assert(after.quantity_bytes_memory_alloc == after.quantity_bytes_memory_used);
assert(after.quantity_bytes_memory_alloc < before.quantity_bytes_memory_alloc);

assert(read_path(paths, main_path) == main_before);
assert(read_path(paths, branch_one) == branch_one_before);
assert(read_path(paths, branch_two) == branch_two_before);
assert(read_path(paths, same_one) == same_one_before);
assert(read_path(paths, same_two) == same_two_before);
assert(read_path(paths, sparse_path) == sparse_before);

assert(paths.get_path_node_index(main_path, 2) == main_before[2]);
assert(paths.get_path_node_index(branch_one, 1) == branch_one_before[1]);
assert(paths.get_path_node_index(branch_two, 3) == branch_two_before[3]);
assert(paths.get_path_node_index(sparse_path, 1) == sparse_before[1]);

return 0;
}