Open-Harbor/osrm-backend
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 3 Wiki Activity

wip

Browse Source
This commit is contained in:
Siarhei Fedartsou 2024-07-12 20:13:40 +02:00
parent 81d128b100
commit fdd1ca05df
5 changed files with 92 additions and 63 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
include/customizer/cell_customizer.hpp
View File

@ -117,9 +117,7 @@ class CellCustomizer
CellMetric &metric) const
{
const auto number_of_nodes = graph.GetNumberOfNodes();
HeapPtr heaps([number_of_nodes]{
return Heap{number_of_nodes};
});
HeapPtr heaps([number_of_nodes] { return Heap{number_of_nodes}; });
for (std::size_t level = 1; level < partition.GetNumberOfLevels(); ++level)
{

83
include/util/pool_allocator.hpp
View File

@ -6,21 +6,31 @@
#include <boost/assert.hpp>
#include <cstddef>
#include <cstdlib>
#include <iostream>
#include <memory>
#include <mutex>
#include <new>
#include <vector>
#include <memory>
namespace osrm::util
{
inline size_t align_up(size_t n, size_t alignment)
{
return (n + alignment - 1) & ~(alignment - 1);
}
inline size_t get_next_power_of_two_exponent(size_t n)
{
BOOST_ASSERT(n > 0);
return (sizeof(size_t) * 8) - std::countl_zero(n - 1);
}
class MemoryPool
{
private:
private:
constexpr static size_t MIN_CHUNK_SIZE_BYTES = 4096;
public:
public:
static std::shared_ptr<MemoryPool> instance()
{
static thread_local std::shared_ptr<MemoryPool> instance;
@ -31,10 +41,10 @@ public:
return instance;
}
template <typename T>
T *allocate(std::size_t items_count)
template <typename T> T *allocate(std::size_t items_count)
{
static_assert(alignof(T) <= alignof(std::max_align_t), "Type is over-aligned for this allocator.");
static_assert(alignof(T) <= alignof(std::max_align_t),
"Type is over-aligned for this allocator.");
size_t free_list_index = get_next_power_of_two_exponent(items_count * sizeof(T));
auto &free_list = free_lists_[free_list_index];
@ -42,7 +52,7 @@ public:
{
size_t block_size_in_bytes = 1u << free_list_index;
block_size_in_bytes = align_up(block_size_in_bytes, alignof(std::max_align_t));
// Check if there is space in current memory chunk
// check if there is space in current memory chunk
if (current_chunk_left_bytes_ < block_size_in_bytes)
{
allocate_chunk(block_size_in_bytes);
@ -52,13 +62,12 @@ public:
current_chunk_left_bytes_ -= block_size_in_bytes;
current_chunk_ptr_ += block_size_in_bytes;
}
auto ptr = static_cast<T*>(free_list.back());
auto ptr = static_cast<T *>(free_list.back());
free_list.pop_back();
return ptr;
}
template <typename T>
void deallocate(T *p, std::size_t n) noexcept
template <typename T> void deallocate(T *p, std::size_t n) noexcept
{
size_t free_list_index = get_next_power_of_two_exponent(n * sizeof(T));
free_lists_[free_list_index].push_back(p);
@ -73,27 +82,11 @@ public:
}
}
private:
private:
MemoryPool() = default;
MemoryPool(const MemoryPool &) = delete;
MemoryPool &operator=(const MemoryPool &) = delete;
inline size_t get_next_power_of_two_exponent(size_t n) const
{
BOOST_ASSERT(n > 0);
return (sizeof(size_t) * 8) - std::countl_zero(n - 1);
}
inline size_t align_up(size_t n, size_t alignment)
{
return (n + alignment - 1) & ~(alignment - 1);
}
inline void* align_pointer(void* ptr, size_t alignment)
{
return reinterpret_cast<void*>(align_up(reinterpret_cast<uintptr_t>(ptr), alignment));
}
void allocate_chunk(size_t bytes)
{
auto chunk_size = std::max(bytes, MIN_CHUNK_SIZE_BYTES);
@ -104,49 +97,47 @@ private:
throw std::bad_alloc();
}
chunks_.push_back(chunk);
current_chunk_ptr_ = static_cast<uint8_t*>(chunk);
current_chunk_ptr_ = static_cast<uint8_t *>(chunk);
current_chunk_left_bytes_ = chunk_size;
}
std::array<std::vector<void *>, 32> free_lists_;
// we have 64 free lists, one for each possible power of two
std::array<std::vector<void *>, sizeof(std::size_t) * 8> free_lists_;
// list of allocated memory chunks, we don't free them until the pool is destroyed
std::vector<void *> chunks_;
uint8_t *current_chunk_ptr_ = nullptr;
size_t current_chunk_left_bytes_ = 0;
};
template <typename T>
class PoolAllocator
template <typename T> class PoolAllocator
{
public:
public:
using value_type = T;
PoolAllocator() noexcept : pool(MemoryPool::instance()) {};
PoolAllocator() noexcept : pool(MemoryPool::instance()){};
template <typename U>
PoolAllocator(const PoolAllocator<U> &) noexcept : pool(MemoryPool::instance()) {}
PoolAllocator(const PoolAllocator<U> &) noexcept : pool(MemoryPool::instance())
{
}
template <typename U>
struct rebind
template <typename U> struct rebind
{
using other = PoolAllocator<U>;
};
T *allocate(std::size_t n)
{
return pool->allocate<T>(n);
}
T *allocate(std::size_t n) { return pool->allocate<T>(n); }
void deallocate(T *p, std::size_t n) noexcept
{
pool->deallocate<T>(p, n);
}
void deallocate(T *p, std::size_t n) noexcept { pool->deallocate<T>(p, n); }
PoolAllocator(const PoolAllocator &) = default;
PoolAllocator &operator=(const PoolAllocator &) = default;
PoolAllocator(PoolAllocator &&) noexcept = default;
PoolAllocator &operator=(PoolAllocator &&) noexcept = default;
private:
private:
std::shared_ptr<MemoryPool> pool;
};
template <typename T, typename U>

6
include/util/query_heap.hpp
View File

@ -148,8 +148,6 @@ class QueryHeap
}
};
using HeapContainer = boost::heap::d_ary_heap<HeapData,
boost::heap::arity<4>,
boost::heap::mutable_<true>,
@ -169,8 +167,8 @@ class QueryHeap
Data data;
};
QueryHeap(const QueryHeap& other) = delete;
QueryHeap(QueryHeap&& other) = delete;
QueryHeap(const QueryHeap &other) = delete;
QueryHeap(QueryHeap &&other) = delete;
template <typename... StorageArgs> explicit QueryHeap(StorageArgs... args) : node_index(args...)
{

5
src/benchmarks/bench.cpp
View File

@ -12,9 +12,9 @@
#include "osrm/coordinate.hpp"
#include "osrm/engine_config.hpp"
#include "osrm/json_container.hpp"
#include "util/meminfo.hpp"
#include "osrm/osrm.hpp"
#include "osrm/status.hpp"
#include "util/meminfo.hpp"
#include <boost/assert.hpp>
@ -656,7 +656,8 @@ try
return EXIT_FAILURE;
}
std::cout << "Peak RAM: " << osrm::util::PeakRAMUsedInBytes() / (1024 * 1024) << "MB" << std::endl;
std::cout << "Peak RAM: " << osrm::util::PeakRAMUsedInBytes() / (1024 * 1024) << "MB"
<< std::endl;
return EXIT_SUCCESS;
}
catch (const std::exception &e)

57
unit_tests/util/pool_allocator.cpp
View File

@ -9,7 +9,44 @@ BOOST_AUTO_TEST_SUITE(pool_allocator)
using namespace osrm;
using namespace osrm::util;
// in many of these tests we hope on address sanitizer to alert in the case if we are doing something wrong
BOOST_AUTO_TEST_CASE(test_align_up)
{
BOOST_CHECK_EQUAL(align_up(5, 4), 8);
BOOST_CHECK_EQUAL(align_up(9, 8), 16);
BOOST_CHECK_EQUAL(align_up(17, 16), 32);
BOOST_CHECK_EQUAL(align_up(4, 4), 4);
BOOST_CHECK_EQUAL(align_up(8, 8), 8);
BOOST_CHECK_EQUAL(align_up(16, 16), 16);
BOOST_CHECK_EQUAL(align_up(32, 16), 32);
BOOST_CHECK_EQUAL(align_up(0, 4), 0);
BOOST_CHECK_EQUAL(align_up(0, 8), 0);
BOOST_CHECK_EQUAL(align_up(0, 16), 0);
BOOST_CHECK_EQUAL(align_up(1000000, 256), 1000192);
BOOST_CHECK_EQUAL(align_up(999999, 512), 1000448);
BOOST_CHECK_EQUAL(align_up(123456789, 1024), 123457536);
BOOST_CHECK_EQUAL(align_up(0, 1), 0);
BOOST_CHECK_EQUAL(align_up(5, 1), 5);
BOOST_CHECK_EQUAL(align_up(123456, 1), 123456);
}
BOOST_AUTO_TEST_CASE(test_get_next_power_of_two_exponent)
{
BOOST_CHECK_EQUAL(get_next_power_of_two_exponent(1), 0);
BOOST_CHECK_EQUAL(get_next_power_of_two_exponent(2), 1);
BOOST_CHECK_EQUAL(get_next_power_of_two_exponent(4), 2);
BOOST_CHECK_EQUAL(get_next_power_of_two_exponent(8), 3);
BOOST_CHECK_EQUAL(get_next_power_of_two_exponent(16), 4);
BOOST_CHECK_EQUAL(get_next_power_of_two_exponent(3), 2);
BOOST_CHECK_EQUAL(get_next_power_of_two_exponent(5), 3);
BOOST_CHECK_EQUAL(get_next_power_of_two_exponent(9), 4);
BOOST_CHECK_EQUAL(get_next_power_of_two_exponent(15), 4);
BOOST_CHECK_EQUAL(get_next_power_of_two_exponent(17), 5);
BOOST_CHECK_EQUAL(get_next_power_of_two_exponent(1), 0);
BOOST_CHECK_EQUAL(get_next_power_of_two_exponent(SIZE_MAX), sizeof(size_t) * 8);
}
// in many of these tests we hope on address sanitizer to alert in the case if we are doing
// something wrong
BOOST_AUTO_TEST_CASE(smoke)
{
PoolAllocator<int> pool;
@ -74,7 +111,12 @@ BOOST_AUTO_TEST_CASE(move)
BOOST_AUTO_TEST_CASE(unordered_map)
{
std::unordered_map<int, int, std::hash<int>, std::equal_to<int>, PoolAllocator<std::pair<const int, int>>> map;
std::unordered_map<int,
int,
std::hash<int>,
std::equal_to<int>,
PoolAllocator<std::pair<const int, int>>>
map;
map[1] = 42;
BOOST_CHECK_EQUAL(map[1], 42);
@ -87,9 +129,9 @@ BOOST_AUTO_TEST_CASE(unordered_map)
BOOST_AUTO_TEST_CASE(alignment)
{
PoolAllocator<char> pool_char;
PoolAllocator<double> pool_double;
PoolAllocator<char> pool_char;
PoolAllocator<double> pool_double;
auto ptr_char = pool_char.allocate(1);
auto ptr_double = pool_double.allocate(1);
@ -98,9 +140,8 @@ BOOST_AUTO_TEST_CASE(alignment)
BOOST_CHECK_NE(ptr_char, nullptr);
BOOST_CHECK_EQUAL(reinterpret_cast<uintptr_t>(ptr_char) % alignof(char), 0);
pool_char.deallocate(ptr_char, 1);
pool_double.deallocate(ptr_double, 1);
pool_char.deallocate(ptr_char, 1);
pool_double.deallocate(ptr_double, 1);
ptr_char = pool_char.allocate(2);
ptr_double = pool_double.allocate(1);