0934902bba
* Add base PROXY support implementation * Remove some dynamic memory allocations * Rewrite configuration reading module * Make everything in core connector memory resource aware * Add logs to check is proxy is used * Add a proxy fallback, and read proxy from env * Add config entry to check application * Cleanup includes * Ddd configuration dump to check application * Update rhel8 packages * Fix http headers bug when using proxy server * Fix formatting * Fix bad optional access * Fix configuration check regresion * Fix memory management issue, remove strict allocators and make connector more polite to memory overflow errors * Fix initialization of core handler
81 lines
2.6 KiB
C++
81 lines
2.6 KiB
C++
#pragma once
|
|
|
|
#include <memory_resource>
|
|
#include <rublon/stdlib.hpp>
|
|
|
|
namespace rublon {
|
|
namespace memory {
|
|
namespace literals {
|
|
constexpr std::uint64_t operator"" _kB(unsigned long long kilobytes) {
|
|
return kilobytes * 1024ULL;
|
|
}
|
|
} // namespace literals
|
|
|
|
struct default_memory_resource {
|
|
static inline std::pmr::memory_resource * _mr = std::pmr::get_default_resource();
|
|
};
|
|
|
|
inline void set_default_resource(std::pmr::memory_resource * memory_resource) {
|
|
default_memory_resource{}._mr = memory_resource;
|
|
}
|
|
|
|
inline std::pmr::memory_resource * default_resource() {
|
|
return default_memory_resource{}._mr;
|
|
}
|
|
|
|
class MonotonicResourceBase {
|
|
public:
|
|
std::pmr::memory_resource * _upstream{};
|
|
std::size_t _size{};
|
|
void * _buffer{nullptr};
|
|
|
|
MonotonicResourceBase(std::size_t size) : _upstream{default_resource()}, _size{size}, _buffer{_upstream->allocate(size)} {}
|
|
|
|
~MonotonicResourceBase() {
|
|
if(_buffer)
|
|
_upstream->deallocate(_buffer, _size);
|
|
}
|
|
};
|
|
|
|
template < std::size_t N >
|
|
class MonotonicResource : MonotonicResourceBase, public std::pmr::monotonic_buffer_resource {
|
|
public:
|
|
MonotonicResource(std::pmr::memory_resource * mr = default_resource())
|
|
: MonotonicResourceBase{N}, std::pmr::monotonic_buffer_resource{this->_buffer, this->_size, mr} {}
|
|
};
|
|
|
|
template < std::size_t N >
|
|
class MonotonicStackResourceBase {
|
|
public:
|
|
char _buffer[N];
|
|
};
|
|
|
|
template < std::size_t N >
|
|
class MonotonicStackResource : MonotonicStackResourceBase< N >, public std::pmr::monotonic_buffer_resource {
|
|
public:
|
|
MonotonicStackResource()
|
|
: MonotonicStackResourceBase< N >{}, std::pmr::monotonic_buffer_resource{this->_buffer, N, default_resource()} {}
|
|
};
|
|
|
|
using MonotonicStack_1k_Resource = MonotonicStackResource< 1 * 1024 >;
|
|
using MonotonicStack_2k_Resource = MonotonicStackResource< 2 * 1024 >;
|
|
|
|
|
|
using Monotonic_1k_Resource = MonotonicResource< 1 * 1024 >;
|
|
using Monotonic_2k_Resource = MonotonicResource< 2 * 1024 >;
|
|
using Monotonic_4k_Resource = MonotonicResource< 4 * 1024 >;
|
|
using Monotonic_8k_Resource = MonotonicResource< 8 * 1024 >;
|
|
} // namespace memory
|
|
|
|
// class RublonMemory {
|
|
// public:
|
|
// std::byte sharedMemory[32 * 1024] = {};
|
|
// std::pmr::monotonic_buffer_resource mr{sharedMemory, std::size(sharedMemory)};
|
|
// std::pmr::unsynchronized_pool_resource rublonPoolResource{&mr};
|
|
|
|
// RublonMemory() {
|
|
// std::pmr::set_default_resource(&rublonPoolResource);
|
|
// }
|
|
// };
|
|
} // namespace rublon
|