fixeria
/
srsRAN
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

renamed interfaces

This commit is contained in:
Francisco Paisana 2020-07-09 00:13:55 +01:00
parent 1a9c04bf2f
commit 039977aeb5
13 changed files with 65 additions and 85 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
lib/include/srslte/common/interfaces_common.h
View File

@ -91,13 +91,12 @@ public:
class task_handler_interface
{
public:
virtual srslte::timer_handler::unique_timer get_unique_timer() = 0;
virtual srslte::task_multiqueue::queue_handler make_task_queue() = 0;
virtual srslte::task_multiqueue::queue_handler make_task_queue(uint32_t queue_size) = 0;
virtual void defer_callback(uint32_t duration_ms, std::function<void()> func) = 0;
virtual void defer_task(srslte::move_task_t func) = 0;
virtual void enqueue_background_task(std::function<void(uint32_t)> task) = 0;
virtual void notify_background_task_result(srslte::move_task_t task) = 0;
virtual srslte::timer_handler::unique_timer get_unique_timer() = 0;
virtual srslte::task_multiqueue::queue_handle make_task_queue() = 0;
virtual void defer_callback(uint32_t duration_ms, std::function<void()> func) = 0;
virtual void defer_task(srslte::move_task_t func) = 0;
virtual void enqueue_background_task(std::function<void(uint32_t)> task) = 0;
virtual void notify_background_task_result(srslte::move_task_t task) = 0;
};
class stack_interface_phy_nr

13
lib/include/srslte/common/multiqueue.h
View File

@ -90,11 +90,11 @@ class multiqueue_handler
};
public:
class queue_handler
class queue_handle
{
public:
queue_handler() = default;
queue_handler(multiqueue_handler<myobj>* parent_, int id) : parent(parent_), queue_id(id) {}
queue_handle() = default;
queue_handle(multiqueue_handler<myobj>* parent_, int id) : parent(parent_), queue_id(id) {}
template <typename FwdRef>
void push(FwdRef&& value)
{
@ -293,8 +293,8 @@ public:
return is_queue_active_(qidx);
}
queue_handler get_queue_handler() { return {this, add_queue()}; }
queue_handler get_queue_handler(uint32_t size) { return {this, add_queue(size)}; }
queue_handle get_queue_handler() { return {this, add_queue()}; }
queue_handle get_queue_handler(uint32_t size) { return {this, add_queue(size)}; }
private:
bool is_queue_active_(int qidx) const { return running and queues[qidx].active; }
@ -325,7 +325,8 @@ private:
};
//! Specialization for tasks
using task_multiqueue = multiqueue_handler<move_task_t>;
using task_multiqueue = multiqueue_handler<move_task_t>;
using task_queue_handle = task_multiqueue::queue_handle;
} // namespace srslte

13
lib/include/srslte/common/task_scheduler.h
View File

@ -52,14 +52,11 @@ public:
external_tasks.reset();
}
srslte::timer_handler::unique_timer get_unique_timer() final { return timers.get_unique_timer(); }
srslte::unique_timer get_unique_timer() final { return timers.get_unique_timer(); }
//! Creates new queue for tasks coming from external thread
srslte::task_multiqueue::queue_handler make_task_queue() final { return external_tasks.get_queue_handler(); }
srslte::task_multiqueue::queue_handler make_task_queue(uint32_t size) final
{
return external_tasks.get_queue_handler(size);
}
srslte::task_queue_handle make_task_queue() final { return external_tasks.get_queue_handler(); }
srslte::task_queue_handle make_task_queue(uint32_t qsize) { return external_tasks.get_queue_handler(qsize); }
//! Delays a task processing by duration_ms
void defer_callback(uint32_t duration_ms, std::function<void()> func) final
@ -140,13 +137,13 @@ private:
std::vector<srslte::move_task_t> internal_tasks; ///< enqueues stack tasks from within main thread. Avoids locking
};
//! Handle to provide to classes/functions running within main thread
//! Task scheduler handle given to classes/functions running within the main control thread
class task_sched_handle
{
public:
task_sched_handle(task_scheduler* sched_) : sched(sched_) {}
srslte::timer_handler::unique_timer get_unique_timer() { return sched->get_unique_timer(); }
srslte::unique_timer get_unique_timer() { return sched->get_unique_timer(); }
void enqueue_background_task(std::function<void(uint32_t)> f) { sched->enqueue_background_task(std::move(f)); }
void notify_background_task_result(srslte::move_task_t task)
{

2
lib/include/srslte/common/timers.h
View File

@ -330,6 +330,8 @@ private:
std::mutex mutex; // Protect priority queue
};
using unique_timer = timer_handler::unique_timer;
} // namespace srslte
#endif // SRSLTE_TIMERS_H

9
lib/include/srslte/test/ue_test_interfaces.h
View File

@ -39,11 +39,10 @@ public:
{
return srslte::tti_point{task_sched.get_timer_handler()->get_cur_time() % 10240};
}
srslte::task_multiqueue::queue_handler make_task_queue() final { return task_sched.make_task_queue(); }
srslte::task_multiqueue::queue_handler make_task_queue(uint32_t len) final { return task_sched.make_task_queue(len); }
void enqueue_background_task(std::function<void(uint32_t)> f) override { f(0); }
void notify_background_task_result(srslte::move_task_t task) override { task(); }
void defer_callback(uint32_t duration_ms, std::function<void()> func) final
srslte::task_multiqueue::queue_handle make_task_queue() final { return task_sched.make_task_queue(); }
void enqueue_background_task(std::function<void(uint32_t)> f) override { f(0); }
void notify_background_task_result(srslte::move_task_t task) override { task(); }
void defer_callback(uint32_t duration_ms, std::function<void()> func) final
{
task_sched.defer_callback(duration_ms, std::move(func));
}

17
srsenb/hdr/stack/enb_stack_lte.h
View File

@ -110,13 +110,12 @@ public:
void add_gtpu_m1u_socket_handler(int fd) override;
/* Stack-MAC interface */
srslte::timer_handler::unique_timer get_unique_timer() final;
srslte::task_multiqueue::queue_handler make_task_queue() final;
srslte::task_multiqueue::queue_handler make_task_queue(uint32_t qsize) final;
void defer_callback(uint32_t duration_ms, std::function<void()> func) final;
void enqueue_background_task(std::function<void(uint32_t)> task) final;
void notify_background_task_result(srslte::move_task_t task) final;
void defer_task(srslte::move_task_t task) final;
srslte::unique_timer get_unique_timer() final;
srslte::task_queue_handle make_task_queue() final;
void defer_callback(uint32_t duration_ms, std::function<void()> func) final;
void enqueue_background_task(std::function<void(uint32_t)> task) final;
void notify_background_task_result(srslte::move_task_t task) final;
void defer_task(srslte::move_task_t task) final;
private:
static const int STACK_MAIN_THREAD_PRIO = 4;
@ -134,8 +133,8 @@ private:
rrc_cfg_t rrc_cfg = {};
// task handling
srslte::task_scheduler task_sched;
srslte::task_multiqueue::queue_handler enb_task_queue, gtpu_task_queue, mme_task_queue, sync_task_queue;
srslte::task_scheduler task_sched;
srslte::task_queue_handle enb_task_queue, gtpu_task_queue, mme_task_queue, sync_task_queue;
// components that layers depend on (need to be destroyed after layers)
std::unique_ptr<srslte::rx_multisocket_handler> rx_sockets;

22
srsenb/hdr/stack/gnb_stack_nr.h
View File

@ -80,16 +80,12 @@ public:
void process_pdus() final;
// Task Handling interface
srslte::timer_handler::unique_timer get_unique_timer() final { return task_sched.get_unique_timer(); }
srslte::task_multiqueue::queue_handler make_task_queue() final { return task_sched.make_task_queue(); }
srslte::task_multiqueue::queue_handler make_task_queue(uint32_t qsize) final
{
return task_sched.make_task_queue(qsize);
}
void enqueue_background_task(std::function<void(uint32_t)> f) final;
void notify_background_task_result(srslte::move_task_t task) final;
void defer_callback(uint32_t duration_ms, std::function<void()> func) final;
void defer_task(srslte::move_task_t task) final;
srslte::timer_handler::unique_timer get_unique_timer() final { return task_sched.get_unique_timer(); }
srslte::task_multiqueue::queue_handle make_task_queue() final { return task_sched.make_task_queue(); }
void enqueue_background_task(std::function<void(uint32_t)> f) final;
void notify_background_task_result(srslte::move_task_t task) final;
void defer_callback(uint32_t duration_ms, std::function<void()> func) final;
void defer_task(srslte::move_task_t task) final;
private:
void run_thread() final;
@ -101,9 +97,9 @@ private:
phy_interface_stack_nr* phy = nullptr;
// task scheduling
static const int STACK_MAIN_THREAD_PRIO = 4;
srslte::task_scheduler task_sched;
srslte::task_multiqueue::queue_handler sync_task_queue, ue_task_queue, gw_task_queue, mac_task_queue;
static const int STACK_MAIN_THREAD_PRIO = 4;
srslte::task_scheduler task_sched;
srslte::task_multiqueue::queue_handle sync_task_queue, ue_task_queue, gw_task_queue, mac_task_queue;
// derived
std::unique_ptr<mac_nr> m_mac;

2
srsenb/hdr/stack/mac/mac.h
View File

@ -124,7 +124,7 @@ private:
mac_args_t args = {};
// derived from args
srslte::task_multiqueue::queue_handler stack_task_queue;
srslte::task_multiqueue::queue_handle stack_task_queue;
bool started = false;

9
srsenb/src/stack/enb_stack_lte.cc
View File

@ -248,21 +248,16 @@ void enb_stack_lte::add_gtpu_m1u_socket_handler(int fd)
rx_sockets->add_socket_pdu_handler(fd, gtpu_m1u_handler);
}
srslte::timer_handler::unique_timer enb_stack_lte::get_unique_timer()
srslte::unique_timer enb_stack_lte::get_unique_timer()
{
return task_sched.get_unique_timer();
}
srslte::task_multiqueue::queue_handler enb_stack_lte::make_task_queue()
srslte::task_queue_handle enb_stack_lte::make_task_queue()
{
return task_sched.make_task_queue();
}
srslte::task_multiqueue::queue_handler enb_stack_lte::make_task_queue(uint32_t qsize)
{
return task_sched.make_task_queue(qsize);
}
void enb_stack_lte::defer_callback(uint32_t duration_ms, std::function<void()> func)
{
task_sched.defer_callback(duration_ms, std::move(func));

4
srsue/hdr/stack/mac/mac.h
View File

@ -163,8 +163,8 @@ private:
void timer_alignment_expire();
/* Queue to dispatch stack tasks */
srslte::task_multiqueue::queue_handler stack_task_dispatch_queue;
srslte::byte_buffer_pool* pool = nullptr;
srslte::task_multiqueue::queue_handle stack_task_dispatch_queue;
srslte::byte_buffer_pool* pool = nullptr;
// pointer to MAC PCAP object
srslte::mac_pcap* pcap = nullptr;

2
srsue/hdr/stack/mac/mac_nr.h
View File

@ -111,7 +111,7 @@ private:
srslte::unique_byte_buffer_t tx_buffer = nullptr;
srslte::unique_byte_buffer_t rlc_buffer = nullptr;
srslte::task_multiqueue::queue_handler stack_task_dispatch_queue;
srslte::task_multiqueue::queue_handle stack_task_dispatch_queue;
};
} // namespace srsue

24
srsue/hdr/stack/ue_stack_lte.h
View File

@ -126,16 +126,12 @@ public:
tti_point get_current_tti() final { return current_tti; }
// Task Handling interface
srslte::timer_handler::unique_timer get_unique_timer() final { return task_sched.get_unique_timer(); }
srslte::task_multiqueue::queue_handler make_task_queue() final { return task_sched.make_task_queue(); }
srslte::task_multiqueue::queue_handler make_task_queue(uint32_t queue_size) final
{
return task_sched.make_task_queue(queue_size);
}
void enqueue_background_task(std::function<void(uint32_t)> f) final;
void notify_background_task_result(srslte::move_task_t task) final;
void defer_callback(uint32_t duration_ms, std::function<void()> func) final;
void defer_task(srslte::move_task_t task) final;
srslte::unique_timer get_unique_timer() final { return task_sched.get_unique_timer(); }
srslte::task_multiqueue::queue_handle make_task_queue() final { return task_sched.make_task_queue(); }
void enqueue_background_task(std::function<void(uint32_t)> f) final;
void notify_background_task_result(srslte::move_task_t task) final;
void defer_callback(uint32_t duration_ms, std::function<void()> func) final;
void defer_task(srslte::move_task_t task) final;
private:
void run_thread() final;
@ -167,10 +163,10 @@ private:
gw_interface_stack* gw = nullptr;
// Thread
static const int STACK_MAIN_THREAD_PRIO = 4; // Next lower priority after PHY workers
srslte::block_queue<stack_metrics_t> pending_stack_metrics;
task_scheduler task_sched;
srslte::task_multiqueue::queue_handler sync_task_queue, ue_task_queue, gw_queue_id;
static const int STACK_MAIN_THREAD_PRIO = 4; // Next lower priority after PHY workers
srslte::block_queue<stack_metrics_t> pending_stack_metrics;
task_scheduler task_sched;
srslte::task_multiqueue::queue_handle sync_task_queue, ue_task_queue, gw_queue_id;
// TTI stats
srslte::tprof<srslte::sliding_window_stats_ms> tti_tprof;

20
srsue/hdr/stack/ue_stack_nr.h
View File

@ -97,16 +97,12 @@ public:
srslte::tti_point get_current_tti() { return srslte::tti_point{0}; };
// Task Handling interface
srslte::timer_handler::unique_timer get_unique_timer() final { return task_sched.get_unique_timer(); }
srslte::task_multiqueue::queue_handler make_task_queue() final { return task_sched.make_task_queue(); }
srslte::task_multiqueue::queue_handler make_task_queue(uint32_t qsize) final
{
return task_sched.make_task_queue(qsize);
}
void enqueue_background_task(std::function<void(uint32_t)> f) final;
void notify_background_task_result(srslte::move_task_t task) final;
void defer_callback(uint32_t duration_ms, std::function<void()> func) final;
void defer_task(srslte::move_task_t task) final;
srslte::timer_handler::unique_timer get_unique_timer() final { return task_sched.get_unique_timer(); }
srslte::task_multiqueue::queue_handle make_task_queue() final { return task_sched.make_task_queue(); }
void enqueue_background_task(std::function<void(uint32_t)> f) final;
void notify_background_task_result(srslte::move_task_t task) final;
void defer_callback(uint32_t duration_ms, std::function<void()> func) final;
void defer_task(srslte::move_task_t task) final;
private:
void run_thread() final;
@ -117,8 +113,8 @@ private:
srsue::stack_args_t args = {};
// task scheduler
srslte::task_scheduler task_sched;
srslte::task_multiqueue::queue_handler sync_task_queue, ue_task_queue, gw_task_queue;
srslte::task_scheduler task_sched;
srslte::task_multiqueue::queue_handle sync_task_queue, ue_task_queue, gw_task_queue;
// UE stack logging
srslte::logger* logger = nullptr;