351964199a
* Prevent printing in noninteractive mode * Allow PAM modules to be configurated directly in pam.d * Configuration should be redable by everybody * Add a way to read ip address in when no IP is awailable * Enable read ip from pam * Fix veritas BUG
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
|