mirror of https://github.com/pvnis/srsRAN_4G.git
Merge branch 'next' into agpl_next
# Conflicts: # srsue/test/mac_nr/mac_nr_test.ccmaster
Codebot
4 years ago
committed by
Your Name
commit
c0282856d0
@ -0,0 +1,184 @@
|
||||
/**
|
||||
*
|
||||
* \section COPYRIGHT
|
||||
*
|
||||
* Copyright 2013-2021 Software Radio Systems Limited
|
||||
*
|
||||
* By using this file, you agree to the terms and conditions set
|
||||
* forth in the LICENSE file which can be found at the top level of
|
||||
* the distribution.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef SRSRAN_BATCH_MEM_POOL_H
|
||||
#define SRSRAN_BATCH_MEM_POOL_H
|
||||
|
||||
#include "memblock_cache.h"
|
||||
#include "pool_utils.h"
|
||||
#include "srsran/common/srsran_assert.h"
|
||||
#include "srsran/common/thread_pool.h"
|
||||
#include <memory>
|
||||
#include <mutex>
|
||||
|
||||
namespace srsran {
|
||||
|
||||
/**
|
||||
* Non-thread-safe, node-based memory pool that allocates nodes in batches of "objs_per_batch" > 1, and caches
|
||||
* allocated blocks on deallocation
|
||||
*/
|
||||
class growing_batch_mem_pool
|
||||
{
|
||||
public:
|
||||
explicit growing_batch_mem_pool(size_t objs_per_batch_,
|
||||
size_t node_size_,
|
||||
size_t node_alignment_,
|
||||
int init_size = -1) :
|
||||
objs_per_batch(objs_per_batch_),
|
||||
memblock_size(std::max(node_size_, free_memblock_list::min_memblock_size())),
|
||||
allocated(objs_per_batch * memblock_size, std::max(node_alignment_, free_memblock_list::min_memblock_align()))
|
||||
{
|
||||
size_t N = init_size < 0 ? objs_per_batch_ : init_size;
|
||||
while (N > cache_size()) {
|
||||
allocate_batch();
|
||||
}
|
||||
}
|
||||
~growing_batch_mem_pool()
|
||||
{
|
||||
srsran_assert(cache_size() == size(), "Not all nodes have been deallocated yet (%zd < %zd)", cache_size(), size());
|
||||
}
|
||||
|
||||
size_t get_node_max_size() const { return memblock_size; }
|
||||
|
||||
void clear()
|
||||
{
|
||||
free_list.clear();
|
||||
allocated.clear();
|
||||
}
|
||||
|
||||
size_t cache_size() const { return free_list.size(); }
|
||||
size_t size() const { return allocated.size() * objs_per_batch; }
|
||||
|
||||
void allocate_batch()
|
||||
{
|
||||
uint8_t* batch_payload = static_cast<uint8_t*>(allocated.allocate_block());
|
||||
for (size_t i = 0; i < objs_per_batch; ++i) {
|
||||
void* cache_node = batch_payload + i * memblock_size;
|
||||
free_list.push(cache_node);
|
||||
}
|
||||
}
|
||||
|
||||
void* allocate_node()
|
||||
{
|
||||
if (free_list.empty()) {
|
||||
allocate_batch();
|
||||
}
|
||||
return free_list.pop();
|
||||
}
|
||||
|
||||
void deallocate_node(void* ptr) { free_list.push(ptr); }
|
||||
|
||||
private:
|
||||
const size_t objs_per_batch;
|
||||
const size_t memblock_size;
|
||||
|
||||
memblock_stack allocated;
|
||||
free_memblock_list free_list;
|
||||
};
|
||||
|
||||
/**
|
||||
* Thread-safe object pool specialized in allocating batches of objects in a preemptive way in a background thread
|
||||
* to minimize latency.
|
||||
* Note: The dispatched allocation jobs may outlive the pool. To handle this, the pool state is passed to jobs via a
|
||||
* shared ptr.
|
||||
*/
|
||||
class background_mem_pool
|
||||
{
|
||||
public:
|
||||
const size_t batch_threshold;
|
||||
|
||||
explicit background_mem_pool(size_t nodes_per_batch_, size_t node_size_, size_t thres_, int initial_size = -1) :
|
||||
batch_threshold(thres_),
|
||||
state(std::make_shared<detached_pool_state>(this)),
|
||||
grow_pool(nodes_per_batch_, node_size_, detail::max_alignment, initial_size)
|
||||
{
|
||||
srsran_assert(batch_threshold > 1, "Invalid arguments for background memory pool");
|
||||
}
|
||||
~background_mem_pool()
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(state->mutex);
|
||||
state->pool = nullptr;
|
||||
grow_pool.clear();
|
||||
}
|
||||
|
||||
/// alloc new object space. If no memory is pre-reserved in the pool, malloc is called to allocate new batch.
|
||||
void* allocate_node(size_t sz)
|
||||
{
|
||||
srsran_assert(sz <= grow_pool.get_node_max_size(),
|
||||
"Mismatch of allocated node size=%zd and object size=%zd",
|
||||
sz,
|
||||
grow_pool.get_node_max_size());
|
||||
std::lock_guard<std::mutex> lock(state->mutex);
|
||||
void* node = grow_pool.allocate_node();
|
||||
|
||||
if (grow_pool.size() < batch_threshold) {
|
||||
allocate_batch_in_background_unlocked();
|
||||
}
|
||||
return node;
|
||||
}
|
||||
|
||||
void deallocate_node(void* p)
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(state->mutex);
|
||||
grow_pool.deallocate_node(p);
|
||||
}
|
||||
|
||||
void allocate_batch()
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(state->mutex);
|
||||
grow_pool.allocate_batch();
|
||||
}
|
||||
|
||||
size_t get_node_max_size() const { return grow_pool.get_node_max_size(); }
|
||||
size_t cache_size() const
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(state->mutex);
|
||||
return grow_pool.cache_size();
|
||||
}
|
||||
|
||||
private:
|
||||
void allocate_batch_in_background_unlocked()
|
||||
{
|
||||
if (state->dispatched) {
|
||||
// new batch allocation already ongoing
|
||||
return;
|
||||
}
|
||||
state->dispatched = true;
|
||||
std::shared_ptr<detached_pool_state> state_sptr = state;
|
||||
get_background_workers().push_task([state_sptr]() {
|
||||
std::lock_guard<std::mutex> lock(state_sptr->mutex);
|
||||
// check if pool has not been destroyed
|
||||
if (state_sptr->pool != nullptr) {
|
||||
auto* pool = state_sptr->pool;
|
||||
do {
|
||||
pool->grow_pool.allocate_batch();
|
||||
} while (pool->grow_pool.cache_size() < pool->batch_threshold);
|
||||
}
|
||||
state_sptr->dispatched = false;
|
||||
});
|
||||
}
|
||||
|
||||
// State is stored in a shared_ptr that may outlive the pool.
|
||||
struct detached_pool_state {
|
||||
std::mutex mutex;
|
||||
background_mem_pool* pool;
|
||||
bool dispatched = false;
|
||||
explicit detached_pool_state(background_mem_pool* pool_) : pool(pool_) {}
|
||||
};
|
||||
std::shared_ptr<detached_pool_state> state;
|
||||
|
||||
growing_batch_mem_pool grow_pool;
|
||||
};
|
||||
|
||||
} // namespace srsran
|
||||
|
||||
#endif // SRSRAN_BATCH_MEM_POOL_H
|
||||
@ -0,0 +1,112 @@
|
||||
/**
|
||||
*
|
||||
* \section COPYRIGHT
|
||||
*
|
||||
* Copyright 2013-2021 Software Radio Systems Limited
|
||||
*
|
||||
* By using this file, you agree to the terms and conditions set
|
||||
* forth in the LICENSE file which can be found at the top level of
|
||||
* the distribution.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef SRSRAN_CIRCULAR_MAP_STACK_POOL_H
|
||||
#define SRSRAN_CIRCULAR_MAP_STACK_POOL_H
|
||||
|
||||
#include "batch_mem_pool.h"
|
||||
#include "linear_allocator.h"
|
||||
#include "srsran/adt/circular_array.h"
|
||||
#include <mutex>
|
||||
|
||||
namespace srsran {
|
||||
|
||||
template <size_t NofStacks>
|
||||
class circular_stack_pool
|
||||
{
|
||||
struct mem_block_elem_t {
|
||||
std::mutex mutex;
|
||||
size_t key = std::numeric_limits<size_t>::max();
|
||||
size_t count = 0;
|
||||
linear_allocator alloc;
|
||||
|
||||
void clear()
|
||||
{
|
||||
key = std::numeric_limits<size_t>::max();
|
||||
count = 0;
|
||||
alloc.clear();
|
||||
}
|
||||
};
|
||||
|
||||
public:
|
||||
circular_stack_pool(size_t nof_objs_per_batch, size_t stack_size, size_t batch_thres, int initial_size = -1) :
|
||||
central_cache(std::min(NofStacks, nof_objs_per_batch), stack_size, batch_thres, initial_size),
|
||||
logger(srslog::fetch_basic_logger("POOL"))
|
||||
{}
|
||||
circular_stack_pool(circular_stack_pool&&) = delete;
|
||||
circular_stack_pool(const circular_stack_pool&) = delete;
|
||||
circular_stack_pool& operator=(circular_stack_pool&&) = delete;
|
||||
circular_stack_pool& operator=(const circular_stack_pool&) = delete;
|
||||
~circular_stack_pool()
|
||||
{
|
||||
for (mem_block_elem_t& elem : pools) {
|
||||
std::unique_lock<std::mutex> lock(elem.mutex);
|
||||
srsran_assert(elem.count == 0, "There are missing deallocations for stack id=%zd", elem.key);
|
||||
if (elem.alloc.is_init()) {
|
||||
void* ptr = elem.alloc.memblock_ptr();
|
||||
elem.alloc.clear();
|
||||
central_cache.deallocate_node(ptr);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void* allocate(size_t key, size_t size, size_t alignment) noexcept
|
||||
{
|
||||
size_t idx = key % NofStacks;
|
||||
mem_block_elem_t& elem = pools[idx];
|
||||
std::unique_lock<std::mutex> lock(elem.mutex);
|
||||
if (not elem.alloc.is_init()) {
|
||||
void* block = central_cache.allocate_node(central_cache.get_node_max_size());
|
||||
if (block == nullptr) {
|
||||
logger.warning("Failed to allocate memory block from central cache");
|
||||
return nullptr;
|
||||
}
|
||||
elem.key = key;
|
||||
elem.alloc = linear_allocator(block, central_cache.get_node_max_size());
|
||||
}
|
||||
void* ptr = elem.alloc.allocate(size, alignment);
|
||||
if (ptr == nullptr) {
|
||||
logger.warning("No space left in memory block with key=%zd of circular stack pool", key);
|
||||
} else {
|
||||
elem.count++;
|
||||
}
|
||||
return ptr;
|
||||
}
|
||||
|
||||
void deallocate(size_t key, void* p)
|
||||
{
|
||||
size_t idx = key % NofStacks;
|
||||
mem_block_elem_t& elem = pools[idx];
|
||||
std::lock_guard<std::mutex> lock(elem.mutex);
|
||||
elem.alloc.deallocate(p);
|
||||
elem.count--;
|
||||
if (elem.count == 0) {
|
||||
// return back to central cache
|
||||
void* ptr = elem.alloc.memblock_ptr();
|
||||
elem.clear();
|
||||
central_cache.deallocate_node(ptr);
|
||||
}
|
||||
}
|
||||
|
||||
void allocate_batch() { central_cache.allocate_batch(); }
|
||||
|
||||
size_t cache_size() const { return central_cache.cache_size(); }
|
||||
|
||||
private:
|
||||
srsran::circular_array<mem_block_elem_t, NofStacks> pools;
|
||||
srsran::background_mem_pool central_cache;
|
||||
srslog::basic_logger& logger;
|
||||
};
|
||||
|
||||
} // namespace srsran
|
||||
|
||||
#endif // SRSRAN_CIRCULAR_MAP_STACK_POOL_H
|
||||
@ -0,0 +1,79 @@
|
||||
/**
|
||||
*
|
||||
* \section COPYRIGHT
|
||||
*
|
||||
* Copyright 2013-2021 Software Radio Systems Limited
|
||||
*
|
||||
* By using this file, you agree to the terms and conditions set
|
||||
* forth in the LICENSE file which can be found at the top level of
|
||||
* the distribution.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef SRSRAN_LINEAR_ALLOCATOR_H
|
||||
#define SRSRAN_LINEAR_ALLOCATOR_H
|
||||
|
||||
#include "pool_utils.h"
|
||||
#include "srsran/common/srsran_assert.h"
|
||||
|
||||
namespace srsran {
|
||||
|
||||
class linear_allocator
|
||||
{
|
||||
public:
|
||||
linear_allocator() = default;
|
||||
linear_allocator(void* start_, void* end_) :
|
||||
start(static_cast<uint8_t*>(start_)), end(static_cast<uint8_t*>(end_)), cur(start)
|
||||
{}
|
||||
linear_allocator(void* start_, size_t sz) : start(static_cast<uint8_t*>(start_)), end(start + sz), cur(start) {}
|
||||
linear_allocator(const linear_allocator& other) = delete;
|
||||
linear_allocator(linear_allocator&& other) noexcept : start(other.start), end(other.end), cur(other.cur)
|
||||
{
|
||||
other.clear();
|
||||
}
|
||||
linear_allocator& operator=(const linear_allocator& other) = delete;
|
||||
linear_allocator& operator =(linear_allocator&& other) noexcept
|
||||
{
|
||||
start = other.start;
|
||||
end = other.end;
|
||||
cur = other.cur;
|
||||
other.clear();
|
||||
return *this;
|
||||
}
|
||||
|
||||
void* allocate(size_t sz, size_t alignment)
|
||||
{
|
||||
void* alloc_start = align_to(cur, alignment);
|
||||
uint8_t* new_cur = static_cast<uint8_t*>(alloc_start) + sz;
|
||||
if (new_cur > end) {
|
||||
// Cannot fit allocation in memory block
|
||||
return nullptr;
|
||||
}
|
||||
cur = new_cur;
|
||||
return alloc_start;
|
||||
}
|
||||
|
||||
void deallocate(void* p) { srsran_assert(p >= start and p < end, "pointer does not belong to pool"); }
|
||||
|
||||
size_t nof_bytes_allocated() const { return cur - start; }
|
||||
size_t nof_bytes_left() const { return end - cur; }
|
||||
size_t size() const { return end - start; }
|
||||
bool is_init() const { return start != end; }
|
||||
void* memblock_ptr() { return static_cast<void*>(start); }
|
||||
|
||||
void clear()
|
||||
{
|
||||
start = nullptr;
|
||||
cur = nullptr;
|
||||
end = nullptr;
|
||||
}
|
||||
|
||||
protected:
|
||||
uint8_t* start = nullptr;
|
||||
uint8_t* end = nullptr;
|
||||
uint8_t* cur = nullptr;
|
||||
};
|
||||
|
||||
} // namespace srsran
|
||||
|
||||
#endif // SRSRAN_LINEAR_ALLOCATOR_H
|
||||
@ -0,0 +1,219 @@
|
||||
/**
|
||||
*
|
||||
* \section COPYRIGHT
|
||||
*
|
||||
* Copyright 2013-2021 Software Radio Systems Limited
|
||||
*
|
||||
* By using this file, you agree to the terms and conditions set
|
||||
* forth in the LICENSE file which can be found at the top level of
|
||||
* the distribution.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef SRSRAN_OBJ_POOL_H
|
||||
#define SRSRAN_OBJ_POOL_H
|
||||
|
||||
#include "batch_mem_pool.h"
|
||||
#include "memblock_cache.h"
|
||||
#include "pool_interface.h"
|
||||
|
||||
namespace srsran {
|
||||
|
||||
template <typename T>
|
||||
class background_obj_pool;
|
||||
|
||||
template <typename T>
|
||||
class growing_batch_obj_pool final : public obj_pool_itf<T>
|
||||
{
|
||||
static size_t memblock_size()
|
||||
{
|
||||
/// Node Structure [ node header | (pad to node alignment) | node size | (pad to node header alignment) ]
|
||||
return align_next(align_next(free_memblock_list::min_memblock_size(), alignof(T)) + sizeof(T),
|
||||
free_memblock_list::min_memblock_align());
|
||||
}
|
||||
static size_t batch_size(size_t nof_objs_per_batch)
|
||||
{
|
||||
/// Batch Structure: [allocated stack header | (pad max alignment) | [memblock] x objs_per_batch ]
|
||||
return align_next(detail::max_alignment + (memblock_size() * nof_objs_per_batch), detail::max_alignment);
|
||||
}
|
||||
|
||||
public:
|
||||
using init_mem_oper_t = srsran::move_callback<void(void*)>;
|
||||
using recycle_oper_t = srsran::move_callback<void(T&)>;
|
||||
|
||||
explicit growing_batch_obj_pool(size_t objs_per_batch_,
|
||||
int init_size = -1,
|
||||
init_mem_oper_t init_oper_ = detail::inplace_default_ctor_operator<T>{},
|
||||
recycle_oper_t recycle_oper_ = detail::noop_operator{}) :
|
||||
objs_per_batch(objs_per_batch_),
|
||||
init_oper(std::move(init_oper_)),
|
||||
recycle_oper(std::move(recycle_oper_)),
|
||||
allocated(batch_size(objs_per_batch_), detail::max_alignment),
|
||||
cache(sizeof(T), alignof(T))
|
||||
{
|
||||
size_t N = init_size < 0 ? objs_per_batch_ : init_size;
|
||||
while (N > cache.size()) {
|
||||
allocate_batch();
|
||||
}
|
||||
}
|
||||
~growing_batch_obj_pool() { clear(); }
|
||||
|
||||
void clear()
|
||||
{
|
||||
if (not allocated.empty()) {
|
||||
srsran_assert(allocated.size() * objs_per_batch == cache_size(),
|
||||
"Not all objects have been deallocated (%zd < %zd)",
|
||||
cache_size(),
|
||||
allocated.size() * objs_per_batch);
|
||||
while (not cache.empty()) {
|
||||
void* node_payload = cache.top();
|
||||
static_cast<T*>(node_payload)->~T();
|
||||
cache.pop();
|
||||
}
|
||||
allocated.clear();
|
||||
}
|
||||
}
|
||||
|
||||
unique_pool_ptr<T> make() final
|
||||
{
|
||||
return unique_pool_ptr<T>(do_allocate(), [this](T* ptr) {
|
||||
// dtor is not called, as object is going to be recycled
|
||||
do_deallocate(ptr);
|
||||
});
|
||||
}
|
||||
|
||||
void allocate_batch()
|
||||
{
|
||||
uint8_t* batch_payload = static_cast<uint8_t*>(allocated.allocate_block());
|
||||
for (size_t i = 0; i < objs_per_batch; ++i) {
|
||||
void* cache_node = batch_payload + (i * cache.memblock_size);
|
||||
cache.push(cache_node);
|
||||
init_oper(cache.top());
|
||||
}
|
||||
}
|
||||
|
||||
size_t cache_size() const { return cache.size(); }
|
||||
|
||||
private:
|
||||
friend class background_obj_pool<T>;
|
||||
|
||||
T* do_allocate()
|
||||
{
|
||||
if (cache.empty()) {
|
||||
allocate_batch();
|
||||
}
|
||||
void* top = cache.top();
|
||||
cache.pop();
|
||||
return static_cast<T*>(top);
|
||||
}
|
||||
|
||||
void do_deallocate(T* payload_ptr)
|
||||
{
|
||||
recycle_oper(*payload_ptr);
|
||||
void* header_ptr = cache.get_node_header(static_cast<void*>(payload_ptr));
|
||||
cache.push(header_ptr);
|
||||
}
|
||||
|
||||
// args
|
||||
const size_t objs_per_batch;
|
||||
init_mem_oper_t init_oper;
|
||||
recycle_oper_t recycle_oper;
|
||||
|
||||
memblock_stack allocated;
|
||||
memblock_node_list cache;
|
||||
};
|
||||
|
||||
/**
|
||||
* Thread-safe object pool specialized in allocating batches of objects in a preemptive way in a background thread
|
||||
* to minimize latency.
|
||||
* Note: The dispatched allocation jobs may outlive the pool. To handle this, the pool state is passed to jobs via a
|
||||
* shared ptr.
|
||||
*/
|
||||
template <typename T>
|
||||
class background_obj_pool final : public obj_pool_itf<T>
|
||||
{
|
||||
public:
|
||||
using init_mem_oper_t = typename growing_batch_obj_pool<T>::init_mem_oper_t;
|
||||
using recycle_oper_t = typename growing_batch_obj_pool<T>::recycle_oper_t;
|
||||
|
||||
explicit background_obj_pool(size_t nof_objs_per_batch,
|
||||
size_t thres_,
|
||||
int init_size = -1,
|
||||
init_mem_oper_t init_oper_ = detail::inplace_default_ctor_operator<T>{},
|
||||
recycle_oper_t recycle_oper_ = detail::noop_operator{}) :
|
||||
thres(thres_),
|
||||
state(std::make_shared<detached_pool_state>(this)),
|
||||
grow_pool(nof_objs_per_batch, init_size, std::move(init_oper_), std::move(recycle_oper_))
|
||||
{
|
||||
srsran_assert(thres_ > 1, "The provided threshold=%zd is not valid", thres_);
|
||||
}
|
||||
~background_obj_pool()
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(state->mutex);
|
||||
state->pool = nullptr;
|
||||
grow_pool.clear();
|
||||
}
|
||||
|
||||
unique_pool_ptr<T> make() final
|
||||
{
|
||||
return unique_pool_ptr<T>(do_allocate(), [this](T* ptr) {
|
||||
// dtor is not called, as object is going to be recycled
|
||||
do_deallocate(ptr);
|
||||
});
|
||||
}
|
||||
|
||||
size_t cache_size() const { return grow_pool.cache_size(); }
|
||||
|
||||
private:
|
||||
T* do_allocate()
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(state->mutex);
|
||||
T* obj = grow_pool.do_allocate();
|
||||
if (grow_pool.cache_size() < thres) {
|
||||
allocate_batch_in_background_();
|
||||
}
|
||||
return obj;
|
||||
}
|
||||
void do_deallocate(T* ptr)
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(state->mutex);
|
||||
return grow_pool.do_deallocate(ptr);
|
||||
}
|
||||
|
||||
void allocate_batch_in_background_()
|
||||
{
|
||||
if (state->dispatched) {
|
||||
// new batch allocation already ongoing
|
||||
return;
|
||||
}
|
||||
state->dispatched = true;
|
||||
std::shared_ptr<detached_pool_state> state_sptr = state;
|
||||
get_background_workers().push_task([state_sptr]() {
|
||||
std::lock_guard<std::mutex> lock(state_sptr->mutex);
|
||||
if (state_sptr->pool != nullptr) {
|
||||
auto* pool = state_sptr->pool;
|
||||
do {
|
||||
pool->grow_pool.allocate_batch();
|
||||
} while (pool->grow_pool.cache_size() < pool->thres);
|
||||
}
|
||||
state_sptr->dispatched = false;
|
||||
});
|
||||
}
|
||||
|
||||
size_t thres;
|
||||
|
||||
// state of pool is detached because pool may be destroyed while batches are being allocated in the background
|
||||
struct detached_pool_state {
|
||||
std::mutex mutex;
|
||||
background_obj_pool<T>* pool;
|
||||
bool dispatched = false;
|
||||
explicit detached_pool_state(background_obj_pool<T>* pool_) : pool(pool_) {}
|
||||
};
|
||||
std::shared_ptr<detached_pool_state> state;
|
||||
|
||||
growing_batch_obj_pool<T> grow_pool;
|
||||
};
|
||||
|
||||
} // namespace srsran
|
||||
|
||||
#endif // SRSRAN_OBJ_POOL_H
|
||||
@ -0,0 +1,62 @@
|
||||
/**
|
||||
*
|
||||
* \section COPYRIGHT
|
||||
*
|
||||
* Copyright 2013-2021 Software Radio Systems Limited
|
||||
*
|
||||
* By using this file, you agree to the terms and conditions set
|
||||
* forth in the LICENSE file which can be found at the top level of
|
||||
* the distribution.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef SRSRAN_POOL_INTERFACE_H
|
||||
#define SRSRAN_POOL_INTERFACE_H
|
||||
|
||||
#include "srsran/adt/move_callback.h"
|
||||
|
||||
namespace srsran {
|
||||
|
||||
/// unique ptr with type-erased dtor, so that it can be used by any object or memory pool
|
||||
constexpr size_t unique_pool_deleter_small_buffer = sizeof(void*) * 2u;
|
||||
template <typename T>
|
||||
using unique_pool_ptr = std::unique_ptr<T, srsran::move_callback<void(T*), unique_pool_deleter_small_buffer> >;
|
||||
|
||||
/// Common object pool interface
|
||||
template <typename T>
|
||||
class obj_pool_itf
|
||||
{
|
||||
public:
|
||||
using object_type = T;
|
||||
|
||||
obj_pool_itf() = default;
|
||||
// Object pool address should not change
|
||||
obj_pool_itf(const obj_pool_itf&) = delete;
|
||||
obj_pool_itf(obj_pool_itf&&) = delete;
|
||||
obj_pool_itf& operator=(const obj_pool_itf&) = delete;
|
||||
obj_pool_itf& operator=(obj_pool_itf&&) = delete;
|
||||
|
||||
virtual ~obj_pool_itf() = default;
|
||||
virtual unique_pool_ptr<T> make() = 0;
|
||||
};
|
||||
|
||||
/// Allocate object in memory pool
|
||||
template <typename T, typename MemPool, typename... Args>
|
||||
unique_pool_ptr<T> make_pool_obj_with_heap_fallback(MemPool& mempool, Args&&... args)
|
||||
{
|
||||
void* block = mempool.allocate(sizeof(T), alignof(T));
|
||||
if (block == nullptr) {
|
||||
return unique_pool_ptr<T>(new T(std::forward<Args>(args)...), std::default_delete<T>());
|
||||
}
|
||||
new (block) T(std::forward<Args>(args)...);
|
||||
return unique_pool_ptr<T>(block, [&mempool](T* ptr) {
|
||||
if (ptr != nullptr) {
|
||||
ptr->~T();
|
||||
mempool.deallocate(ptr);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
} // namespace srsran
|
||||
|
||||
#endif // SRSRAN_POOL_INTERFACE_H
|
||||
@ -0,0 +1,64 @@
|
||||
/**
|
||||
*
|
||||
* \section COPYRIGHT
|
||||
*
|
||||
* Copyright 2013-2021 Software Radio Systems Limited
|
||||
*
|
||||
* By using this file, you agree to the terms and conditions set
|
||||
* forth in the LICENSE file which can be found at the top level of
|
||||
* the distribution.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef SRSRAN_POOL_UTILS_H
|
||||
#define SRSRAN_POOL_UTILS_H
|
||||
|
||||
#include "../move_callback.h"
|
||||
#include <memory>
|
||||
|
||||
namespace srsran {
|
||||
|
||||
namespace detail {
|
||||
|
||||
template <typename T>
|
||||
struct inplace_default_ctor_operator {
|
||||
void operator()(void* ptr) { new (ptr) T(); }
|
||||
};
|
||||
|
||||
struct noop_operator {
|
||||
template <typename T>
|
||||
void operator()(T&& t) const
|
||||
{
|
||||
// do nothing
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
|
||||
/// check if alignment is power of 2
|
||||
constexpr bool is_valid_alignment(std::size_t alignment)
|
||||
{
|
||||
return alignment && (alignment & (alignment - 1)) == 0u;
|
||||
}
|
||||
|
||||
inline bool is_aligned(void* ptr, std::size_t alignment)
|
||||
{
|
||||
return (reinterpret_cast<std::uintptr_t>(ptr) & (alignment - 1)) == 0;
|
||||
}
|
||||
|
||||
constexpr std::uintptr_t align_next(std::uintptr_t pos, size_t alignment)
|
||||
{
|
||||
return (pos + (alignment - 1)) & ~(alignment - 1);
|
||||
}
|
||||
inline void* align_to(void* pos, size_t alignment)
|
||||
{
|
||||
return reinterpret_cast<void*>(align_next(reinterpret_cast<std::uintptr_t>(pos), alignment));
|
||||
}
|
||||
inline void* offset_byte_ptr(void* pos, size_t offset)
|
||||
{
|
||||
return static_cast<void*>(static_cast<uint8_t*>(pos) + offset);
|
||||
}
|
||||
|
||||
} // namespace srsran
|
||||
|
||||
#endif // SRSRAN_POOL_UTILS_H
|
||||
@ -0,0 +1,44 @@
|
||||
/**
|
||||
*
|
||||
* \section COPYRIGHT
|
||||
*
|
||||
* Copyright 2013-2021 Software Radio Systems Limited
|
||||
*
|
||||
* By using this file, you agree to the terms and conditions set
|
||||
* forth in the LICENSE file which can be found at the top level of
|
||||
* the distribution.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef SRSRAN_PDCCH_CFG_NR_H
|
||||
#define SRSRAN_PDCCH_CFG_NR_H
|
||||
|
||||
#include "dci_nr.h"
|
||||
|
||||
/**
|
||||
* Maximum number of CORESET
|
||||
* @remark Defined in TS 38.331 by maxNrofControlResourceSets-1
|
||||
*/
|
||||
#define SRSRAN_UE_DL_NR_MAX_NOF_CORESET 12
|
||||
|
||||
/**
|
||||
* Maximum number of Search spaces
|
||||
* @remark Defined in TS 38.331 by maxNrofSearchSpaces-1
|
||||
*/
|
||||
#define SRSRAN_UE_DL_NR_MAX_NOF_SEARCH_SPACE 40
|
||||
|
||||
/**
|
||||
* @brief PDCCH configuration provided by upper layers
|
||||
*/
|
||||
typedef struct SRSRAN_API {
|
||||
srsran_coreset_t coreset[SRSRAN_UE_DL_NR_MAX_NOF_CORESET]; ///< PDCCH Control resource sets (CORESET) collection
|
||||
bool coreset_present[SRSRAN_UE_DL_NR_MAX_NOF_CORESET]; ///< CORESET present flags
|
||||
|
||||
srsran_search_space_t search_space[SRSRAN_UE_DL_NR_MAX_NOF_SEARCH_SPACE];
|
||||
bool search_space_present[SRSRAN_UE_DL_NR_MAX_NOF_SEARCH_SPACE];
|
||||
|
||||
srsran_search_space_t ra_search_space;
|
||||
bool ra_search_space_present;
|
||||
} srsran_pdcch_cfg_nr_t;
|
||||
|
||||
#endif // SRSRAN_PDCCH_CFG_NR_H
|
||||
@ -0,0 +1,27 @@
|
||||
/**
|
||||
*
|
||||
* \section COPYRIGHT
|
||||
*
|
||||
* Copyright 2013-2021 Software Radio Systems Limited
|
||||
*
|
||||
* By using this file, you agree to the terms and conditions set
|
||||
* forth in the LICENSE file which can be found at the top level of
|
||||
* the distribution.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef SRSRAN_BEARER_MEM_POOL_H
|
||||
#define SRSRAN_BEARER_MEM_POOL_H
|
||||
|
||||
#include <cstddef>
|
||||
|
||||
namespace srsran {
|
||||
|
||||
// Allocation of objects in rnti-dedicated memory pool
|
||||
void reserve_rlc_memblocks(size_t nof_blocks);
|
||||
void* allocate_rlc_bearer(std::size_t size);
|
||||
void deallocate_rlc_bearer(void* p);
|
||||
|
||||
} // namespace srsran
|
||||
|
||||
#endif // SRSRAN_BEARER_MEM_POOL_H
|
||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,53 @@
|
||||
/**
|
||||
*
|
||||
* \section COPYRIGHT
|
||||
*
|
||||
* Copyright 2013-2021 Software Radio Systems Limited
|
||||
*
|
||||
* By using this file, you agree to the terms and conditions set
|
||||
* forth in the LICENSE file which can be found at the top level of
|
||||
* the distribution.
|
||||
*
|
||||
*/
|
||||
|
||||
#include "srsran/common/test_common.h"
|
||||
#include "srsran/phy/phch/dci_nr.h"
|
||||
|
||||
static int test_52prb()
|
||||
{
|
||||
// Default configuration with all options disabled
|
||||
srsran_dci_cfg_nr_t cfg = {};
|
||||
|
||||
// Set bandwidths
|
||||
cfg.coreset0_bw = 0;
|
||||
cfg.bwp_dl_initial_bw = 52;
|
||||
cfg.bwp_dl_active_bw = 52;
|
||||
cfg.bwp_ul_initial_bw = 52;
|
||||
cfg.bwp_ul_active_bw = 52;
|
||||
|
||||
// Enable all monitoring
|
||||
cfg.monitor_common_0_0 = true;
|
||||
cfg.monitor_0_0_and_1_0 = true;
|
||||
cfg.monitor_0_1_and_1_1 = true;
|
||||
|
||||
// Configure DCI
|
||||
srsran_dci_nr_t dci = {};
|
||||
TESTASSERT(srsran_dci_nr_set_cfg(&dci, &cfg) == SRSRAN_SUCCESS);
|
||||
|
||||
// Check DCI sizes
|
||||
TESTASSERT(srsran_dci_nr_size(&dci, srsran_search_space_type_common_3, srsran_dci_format_nr_0_0) == 39);
|
||||
TESTASSERT(srsran_dci_nr_size(&dci, srsran_search_space_type_common_3, srsran_dci_format_nr_1_0) == 39);
|
||||
TESTASSERT(srsran_dci_nr_size(&dci, srsran_search_space_type_ue, srsran_dci_format_nr_0_0) == 39);
|
||||
TESTASSERT(srsran_dci_nr_size(&dci, srsran_search_space_type_ue, srsran_dci_format_nr_1_0) == 39);
|
||||
TESTASSERT(srsran_dci_nr_size(&dci, srsran_search_space_type_ue, srsran_dci_format_nr_0_1) == 28);
|
||||
TESTASSERT(srsran_dci_nr_size(&dci, srsran_search_space_type_ue, srsran_dci_format_nr_1_1) == 26);
|
||||
|
||||
return SRSRAN_SUCCESS;
|
||||
}
|
||||
|
||||
int main(int argc, char** argv)
|
||||
{
|
||||
TESTASSERT(test_52prb() == SRSRAN_SUCCESS);
|
||||
|
||||
return SRSRAN_SUCCESS;
|
||||
}
|
||||
@ -0,0 +1,150 @@
|
||||
/**
|
||||
*
|
||||
* \section COPYRIGHT
|
||||
*
|
||||
* Copyright 2013-2021 Software Radio Systems Limited
|
||||
*
|
||||
* By using this file, you agree to the terms and conditions set
|
||||
* forth in the LICENSE file which can be found at the top level of
|
||||
* the distribution.
|
||||
*
|
||||
*/
|
||||
|
||||
#include "srsran/common/test_common.h"
|
||||
#include "srsran/phy/ue/ue_dl_nr.h"
|
||||
#include <getopt.h>
|
||||
|
||||
static int test_case_1()
|
||||
{
|
||||
// Set configuration
|
||||
srsran_ue_dl_nr_harq_ack_cfg_t cfg = {};
|
||||
cfg.harq_ack_codebook = srsran_pdsch_harq_ack_codebook_dynamic;
|
||||
|
||||
// Generate ACK information
|
||||
srsran_pdsch_ack_nr_t ack_info = {};
|
||||
ack_info.nof_cc = 1;
|
||||
ack_info.use_pusch = true;
|
||||
|
||||
srsran_pdsch_ack_m_nr_t m = {};
|
||||
m.value[0] = 1;
|
||||
m.present = true;
|
||||
|
||||
m.resource.k1 = 8;
|
||||
m.resource.v_dai_dl = 0;
|
||||
m.value[0] = 1;
|
||||
m.present = true;
|
||||
TESTASSERT(srsran_ue_dl_nr_ack_insert_m(&ack_info, &m) == SRSRAN_SUCCESS);
|
||||
|
||||
m.resource.k1 = 5;
|
||||
m.resource.v_dai_dl = 2;
|
||||
TESTASSERT(srsran_ue_dl_nr_ack_insert_m(&ack_info, &m) == SRSRAN_SUCCESS);
|
||||
|
||||
m.resource.k1 = 6;
|
||||
m.resource.v_dai_dl = 1;
|
||||
TESTASSERT(srsran_ue_dl_nr_ack_insert_m(&ack_info, &m) == SRSRAN_SUCCESS);
|
||||
|
||||
m.resource.k1 = 4;
|
||||
m.resource.v_dai_dl = 3;
|
||||
TESTASSERT(srsran_ue_dl_nr_ack_insert_m(&ack_info, &m) == SRSRAN_SUCCESS);
|
||||
|
||||
m.resource.k1 = 3;
|
||||
m.resource.v_dai_dl = 0;
|
||||
TESTASSERT(srsran_ue_dl_nr_ack_insert_m(&ack_info, &m) == SRSRAN_SUCCESS);
|
||||
|
||||
// Print trace
|
||||
char str[512] = {};
|
||||
TESTASSERT(srsran_ue_dl_nr_ack_info(&ack_info, str, (uint32_t)sizeof(str)) > SRSRAN_SUCCESS);
|
||||
INFO("%s", str);
|
||||
|
||||
// Generate UCI data
|
||||
srsran_uci_data_nr_t uci_data = {};
|
||||
TESTASSERT(srsran_ue_dl_nr_gen_ack(&cfg, &ack_info, &uci_data) == SRSRAN_SUCCESS);
|
||||
|
||||
// Assert UCI data
|
||||
TESTASSERT(uci_data.cfg.o_ack == 5);
|
||||
|
||||
return SRSRAN_SUCCESS;
|
||||
}
|
||||
|
||||
static int test_case_2()
|
||||
{
|
||||
// Set configuration
|
||||
srsran_ue_dl_nr_harq_ack_cfg_t cfg = {};
|
||||
cfg.harq_ack_codebook = srsran_pdsch_harq_ack_codebook_dynamic;
|
||||
|
||||
// Generate ACK information
|
||||
srsran_pdsch_ack_nr_t ack_info = {};
|
||||
ack_info.nof_cc = 1;
|
||||
ack_info.use_pusch = true;
|
||||
|
||||
srsran_pdsch_ack_m_nr_t m = {};
|
||||
m.value[0] = 1;
|
||||
m.present = true;
|
||||
|
||||
m.resource.k1 = 7;
|
||||
m.resource.v_dai_dl = 1;
|
||||
TESTASSERT(srsran_ue_dl_nr_ack_insert_m(&ack_info, &m) == SRSRAN_SUCCESS);
|
||||
|
||||
m.resource.k1 = 6;
|
||||
m.resource.v_dai_dl = 2;
|
||||
TESTASSERT(srsran_ue_dl_nr_ack_insert_m(&ack_info, &m) == SRSRAN_SUCCESS);
|
||||
|
||||
m.resource.k1 = 8;
|
||||
m.resource.v_dai_dl = 0;
|
||||
TESTASSERT(srsran_ue_dl_nr_ack_insert_m(&ack_info, &m) == SRSRAN_SUCCESS);
|
||||
|
||||
m.resource.k1 = 5;
|
||||
m.resource.v_dai_dl = 3;
|
||||
TESTASSERT(srsran_ue_dl_nr_ack_insert_m(&ack_info, &m) == SRSRAN_SUCCESS);
|
||||
|
||||
m.resource.k1 = 4;
|
||||
m.resource.v_dai_dl = 0;
|
||||
TESTASSERT(srsran_ue_dl_nr_ack_insert_m(&ack_info, &m) == SRSRAN_SUCCESS);
|
||||
|
||||
// Print trace
|
||||
char str[512] = {};
|
||||
TESTASSERT(srsran_ue_dl_nr_ack_info(&ack_info, str, (uint32_t)sizeof(str)) > SRSRAN_SUCCESS);
|
||||
INFO("%s", str);
|
||||
|
||||
// Generate UCI data
|
||||
srsran_uci_data_nr_t uci_data = {};
|
||||
TESTASSERT(srsran_ue_dl_nr_gen_ack(&cfg, &ack_info, &uci_data) == SRSRAN_SUCCESS);
|
||||
|
||||
// Assert UCI data
|
||||
TESTASSERT(uci_data.cfg.o_ack == 5);
|
||||
|
||||
return SRSRAN_SUCCESS;
|
||||
}
|
||||
|
||||
static void usage(char* prog)
|
||||
{
|
||||
printf("Usage: %s [v]\n", prog);
|
||||
printf("\t-v Increase srsran_verbose\n");
|
||||
}
|
||||
|
||||
static void parse_args(int argc, char** argv)
|
||||
{
|
||||
int opt;
|
||||
while ((opt = getopt(argc, argv, "v")) != -1) {
|
||||
switch (opt) {
|
||||
case 'v':
|
||||
srsran_verbose++;
|
||||
break;
|
||||
default:
|
||||
usage(argv[0]);
|
||||
exit(-1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
int main(int argc, char** argv)
|
||||
{
|
||||
parse_args(argc, argv);
|
||||
|
||||
// Test only until Format1B - CS
|
||||
TESTASSERT(test_case_1() == SRSRAN_SUCCESS);
|
||||
TESTASSERT(test_case_2() == SRSRAN_SUCCESS);
|
||||
|
||||
printf("Ok\n");
|
||||
return SRSRAN_SUCCESS;
|
||||
}
|
||||
@ -0,0 +1,44 @@
|
||||
/**
|
||||
*
|
||||
* \section COPYRIGHT
|
||||
*
|
||||
* Copyright 2013-2021 Software Radio Systems Limited
|
||||
*
|
||||
* By using this file, you agree to the terms and conditions set
|
||||
* forth in the LICENSE file which can be found at the top level of
|
||||
* the distribution.
|
||||
*
|
||||
*/
|
||||
|
||||
#include "srsran/upper/bearer_mem_pool.h"
|
||||
#include "srsran/adt/pool/batch_mem_pool.h"
|
||||
#include "srsran/upper/rlc_am_lte.h"
|
||||
#include "srsran/upper/rlc_um_lte.h"
|
||||
#include "srsran/upper/rlc_um_nr.h"
|
||||
|
||||
namespace srsran {
|
||||
|
||||
srsran::background_mem_pool* get_bearer_pool()
|
||||
{
|
||||
static background_mem_pool pool(
|
||||
4, std::max(std::max(sizeof(rlc_am_lte), sizeof(rlc_um_lte)), sizeof(rlc_um_nr)), 8, 8);
|
||||
return &pool;
|
||||
}
|
||||
|
||||
void reserve_rlc_memblocks(size_t nof_blocks)
|
||||
{
|
||||
srsran::background_mem_pool* pool = get_bearer_pool();
|
||||
while (pool->cache_size() < nof_blocks) {
|
||||
pool->allocate_batch();
|
||||
}
|
||||
}
|
||||
void* allocate_rlc_bearer(std::size_t sz)
|
||||
{
|
||||
return get_bearer_pool()->allocate_node(sz);
|
||||
}
|
||||
void deallocate_rlc_bearer(void* p)
|
||||
{
|
||||
get_bearer_pool()->deallocate_node(p);
|
||||
}
|
||||
|
||||
} // namespace srsran
|
||||
@ -0,0 +1,48 @@
|
||||
/**
|
||||
*
|
||||
* \section COPYRIGHT
|
||||
*
|
||||
* Copyright 2013-2021 Software Radio Systems Limited
|
||||
*
|
||||
* By using this file, you agree to the terms and conditions set
|
||||
* forth in the LICENSE file which can be found at the top level of
|
||||
* the distribution.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef SRSRAN_RNTI_POOL_H
|
||||
#define SRSRAN_RNTI_POOL_H
|
||||
|
||||
#include "srsran/adt/pool/pool_interface.h"
|
||||
#include "srsran/phy/common/phy_common.h"
|
||||
#include <memory>
|
||||
|
||||
namespace srsenb {
|
||||
|
||||
// Allocation of objects in rnti-dedicated memory pool
|
||||
void reserve_rnti_memblocks(size_t nof_blocks);
|
||||
void* allocate_rnti_dedicated_mem(uint16_t rnti, std::size_t size, std::size_t align);
|
||||
void deallocate_rnti_dedicated_mem(uint16_t rnti, void* p);
|
||||
|
||||
template <typename T>
|
||||
using unique_rnti_ptr = srsran::unique_pool_ptr<T>;
|
||||
|
||||
template <typename T, typename... Args>
|
||||
unique_rnti_ptr<T> make_rnti_obj(uint16_t rnti, Args&&... args)
|
||||
{
|
||||
void* block = allocate_rnti_dedicated_mem(rnti, sizeof(T), alignof(T));
|
||||
if (block == nullptr) {
|
||||
// allocated with "new" as a fallback
|
||||
return unique_rnti_ptr<T>(new T(std::forward<Args>(args)...), std::default_delete<T>());
|
||||
}
|
||||
// allocation using rnti-dedicated memory pool was successful
|
||||
new (block) T(std::forward<Args>(args)...);
|
||||
return unique_rnti_ptr<T>(static_cast<T*>(block), [rnti](T* ptr) {
|
||||
ptr->~T();
|
||||
deallocate_rnti_dedicated_mem(rnti, ptr);
|
||||
});
|
||||
}
|
||||
|
||||
} // namespace srsenb
|
||||
|
||||
#endif // SRSRAN_RNTI_POOL_H
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue