5g-team
/
srsRAN_4G
mirror of https://github.com/pvnis/srsRAN_4G.git
2
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

remove byte buffer pool cached member variables as they are unnecessary now.

Browse Source
master
Francisco 4 years ago committed by Francisco Paisana
parent 04ab4eefcd
commit 3265d940ec
74 changed files with 179 additions and 332 deletions
Show Stats Download Patch File Download Diff File

1
lib/include/srslte/common/basic_pnf.h
Unescape Escape View File

@ -510,7 +510,6 @@ private:
std::unique_ptr<std::thread> tx_thread, rx_thread; std::unique_ptr<std::thread> tx_thread, rx_thread;
std::string tx_thread_name = "TX_PNF", rx_thread_name = "RX_PNF"; std::string tx_thread_name = "TX_PNF", rx_thread_name = "RX_PNF";
bool running = false; bool running = false;
srslte::byte_buffer_pool* pool = srslte::byte_buffer_pool::get_instance();
srslog::basic_logger& logger = srslog::fetch_basic_logger("PNF", false); srslog::basic_logger& logger = srslog::fetch_basic_logger("PNF", false);
std::mutex mutex; std::mutex mutex;

1
lib/include/srslte/common/basic_vnf.h
Unescape Escape View File

@ -63,7 +63,6 @@ private:
srslog::basic_logger& logger = srslog::fetch_basic_logger("VNF", false); srslog::basic_logger& logger = srslog::fetch_basic_logger("VNF", false);
srsenb::stack_interface_phy_nr* m_gnb_stack = nullptr; srsenb::stack_interface_phy_nr* m_gnb_stack = nullptr;
srsue::stack_interface_phy_nr* m_ue_stack = nullptr; srsue::stack_interface_phy_nr* m_ue_stack = nullptr;
srslte::byte_buffer_pool* m_pool = nullptr;
std::unique_ptr<basic_vnf_api::tx_request_msg_t> m_tx_req_msg; std::unique_ptr<basic_vnf_api::tx_request_msg_t> m_tx_req_msg;

47
lib/include/srslte/common/mac_pcap.h
Unescape Escape View File

@ -61,30 +61,29 @@ public:
void write_dl_si_rnti_nr(uint8_t* pdu, uint32_t pdu_len_bytes, uint16_t rnti, uint8_t harqid, uint32_t tti); void write_dl_si_rnti_nr(uint8_t* pdu, uint32_t pdu_len_bytes, uint16_t rnti, uint8_t harqid, uint32_t tti);
private: private:
srslte::byte_buffer_pool* pool = nullptr; srslog::basic_logger& logger;
srslog::basic_logger& logger; bool running = false;
bool running = false; srslte_rat_t rat = srslte_rat_t::nulltype;
srslte_rat_t rat = srslte_rat_t::nulltype; uint32_t dlt = 0; // The DLT used for the PCAP file
uint32_t dlt = 0; // The DLT used for the PCAP file std::string filename;
std::string filename; FILE* pcap_file = nullptr;
FILE* pcap_file = nullptr; uint32_t ue_id = 0;
uint32_t ue_id = 0; void pack_and_queue(uint8_t* payload,
void pack_and_queue(uint8_t* payload, uint32_t payload_len,
uint32_t payload_len, uint32_t reTX,
uint32_t reTX, bool crc_ok,
bool crc_ok, uint8_t cc_idx,
uint8_t cc_idx, uint32_t tti,
uint32_t tti, uint16_t crnti_,
uint16_t crnti_, uint8_t direction,
uint8_t direction, uint8_t rnti_type);
uint8_t rnti_type); void pack_and_queue_nr(uint8_t* payload,
void pack_and_queue_nr(uint8_t* payload, uint32_t payload_len,
uint32_t payload_len, uint32_t tti,
uint32_t tti, uint16_t crnti,
uint16_t crnti, uint8_t harqid,
uint8_t harqid, uint8_t direction,
uint8_t direction, uint8_t rnti_type);
uint8_t rnti_type);
typedef struct { typedef struct {
// Different PCAP context for both RATs // Different PCAP context for both RATs

5
lib/include/srslte/common/network_utils.h
Unescape Escape View File

@ -150,9 +150,8 @@ private:
bool remove_socket_unprotected(int fd, fd_set* total_fd_set, int* max_fd); bool remove_socket_unprotected(int fd, fd_set* total_fd_set, int* max_fd);
// args // args
std::string name; std::string name;
srslog::basic_logger& logger; srslog::basic_logger& logger;
srslte::byte_buffer_pool* pool = nullptr;
// state // state
std::mutex socket_mutex; std::mutex socket_mutex;

5
lib/src/common/basic_vnf.cc
Unescape Escape View File

@ -29,10 +29,7 @@ struct srslte_pnf_info_t {
struct srslte_vnf_info_t {}; struct srslte_vnf_info_t {};
srslte_basic_vnf::srslte_basic_vnf(const vnf_args_t& args_, stack_interface_phy_nr* stack_) : srslte_basic_vnf::srslte_basic_vnf(const vnf_args_t& args_, stack_interface_phy_nr* stack_) :
m_args(args_), m_args(args_), thread("BASIC_VNF_P7"), m_tx_req_msg(new basic_vnf_api::tx_request_msg_t)
thread("BASIC_VNF_P7"),
m_tx_req_msg(new basic_vnf_api::tx_request_msg_t),
m_pool(srslte::byte_buffer_pool::get_instance())
{ {
logger.set_level(srslog::str_to_basic_level(m_args.log_level)); logger.set_level(srslog::str_to_basic_level(m_args.log_level));
logger.set_hex_dump_max_size(m_args.log_hex_limit); logger.set_hex_dump_max_size(m_args.log_hex_limit);

5
lib/src/common/mac_pcap.cc
Unescape Escape View File

@ -18,10 +18,7 @@
namespace srslte { namespace srslte {
mac_pcap::mac_pcap(srslte_rat_t rat_) : mac_pcap::mac_pcap(srslte_rat_t rat_) :
pool(srslte::byte_buffer_pool::get_instance()), logger(srslog::fetch_basic_logger("MAC")), thread("PCAP_WRITER_" + to_string(rat_)), rat(rat_)
logger(srslog::fetch_basic_logger("MAC")),
thread("PCAP_WRITER_" + to_string(rat_)),
rat(rat_)
{} {}
mac_pcap::~mac_pcap() mac_pcap::~mac_pcap()

12
lib/src/common/network_utils.cc
Unescape Escape View File

@ -442,8 +442,8 @@ class sctp_recvmsg_pdu_task final : public rx_multisocket_handler::recv_task
public: public:
using callback_t = std::function< using callback_t = std::function<
void(srslte::unique_byte_buffer_t pdu, const sockaddr_in& from, const sctp_sndrcvinfo& sri, int flags)>; void(srslte::unique_byte_buffer_t pdu, const sockaddr_in& from, const sctp_sndrcvinfo& sri, int flags)>;
explicit sctp_recvmsg_pdu_task(srslte::byte_buffer_pool* pool_, srslog::basic_logger& logger, callback_t func_) : explicit sctp_recvmsg_pdu_task(srslog::basic_logger& logger, callback_t func_) :
pool(pool_), logger(logger), func(std::move(func_)) logger(logger), func(std::move(func_))
{} {}
bool operator()(int fd) override bool operator()(int fd) override
@ -479,9 +479,8 @@ public:
} }
private: private:
srslte::byte_buffer_pool* pool = nullptr; srslog::basic_logger& logger;
srslog::basic_logger& logger; callback_t func;
callback_t func;
}; };
/*************************************************************** /***************************************************************
@ -491,7 +490,6 @@ private:
rx_multisocket_handler::rx_multisocket_handler(std::string name_, srslog::basic_logger& logger, int thread_prio) : rx_multisocket_handler::rx_multisocket_handler(std::string name_, srslog::basic_logger& logger, int thread_prio) :
thread(name_), name(std::move(name_)), logger(logger) thread(name_), name(std::move(name_)), logger(logger)
{ {
pool = srslte::byte_buffer_pool::get_instance();
// register control pipe fd // register control pipe fd
if (pipe(pipefd) == -1) { if (pipe(pipefd) == -1) {
rxSockInfo("Failed to open control pipe"); rxSockInfo("Failed to open control pipe");
@ -546,7 +544,7 @@ bool rx_multisocket_handler::add_socket_pdu_handler(int fd, recvfrom_callback_t
bool rx_multisocket_handler::add_socket_sctp_pdu_handler(int fd, sctp_recv_callback_t pdu_task) bool rx_multisocket_handler::add_socket_sctp_pdu_handler(int fd, sctp_recv_callback_t pdu_task)
{ {
srslte::rx_multisocket_handler::task_callback_t task; srslte::rx_multisocket_handler::task_callback_t task;
task.reset(new srslte::sctp_recvmsg_pdu_task(pool, logger, std::move(pdu_task))); task.reset(new srslte::sctp_recvmsg_pdu_task(logger, std::move(pdu_task)));
return add_socket_handler(fd, std::move(task)); return add_socket_handler(fd, std::move(task));
} }

1
lib/test/asn1/srslte_asn1_nas_test.cc
Unescape Escape View File

@ -33,7 +33,6 @@ int nas_dedicated_eps_bearer_context_setup_request_test()
nas_logger.set_level(srslog::basic_levels::debug); nas_logger.set_level(srslog::basic_levels::debug);
nas_logger.set_hex_dump_max_size(128); nas_logger.set_hex_dump_max_size(128);
srslte::byte_buffer_pool* pool = srslte::byte_buffer_pool::get_instance();
srslte::unique_byte_buffer_t tst_msg, out_msg; srslte::unique_byte_buffer_t tst_msg, out_msg;
tst_msg = srslte::make_byte_buffer(); tst_msg = srslte::make_byte_buffer();
out_msg = srslte::make_byte_buffer(); out_msg = srslte::make_byte_buffer();

4
lib/test/upper/pdcp_lte_test.h
Unescape Escape View File

@ -82,7 +82,6 @@ srslte::unique_byte_buffer_t gen_expected_pdu(const srslte::unique_byte_buffer_t
uint8_t pdcp_sn_len, uint8_t pdcp_sn_len,
srslte::pdcp_rb_type_t rb_type, srslte::pdcp_rb_type_t rb_type,
srslte::as_security_config_t sec_cfg, srslte::as_security_config_t sec_cfg,
srslte::byte_buffer_pool* pool,
srslte::log_ref log) srslte::log_ref log)
{ {
srslte::pdcp_config_t cfg = {1, srslte::pdcp_config_t cfg = {1,
@ -117,13 +116,12 @@ std::vector<pdcp_test_event_t> gen_expected_pdus_vector(const srslte::unique_byt
uint8_t pdcp_sn_len, uint8_t pdcp_sn_len,
srslte::pdcp_rb_type_t rb_type, srslte::pdcp_rb_type_t rb_type,
srslte::as_security_config_t sec_cfg_, srslte::as_security_config_t sec_cfg_,
srslte::byte_buffer_pool* pool,
srslte::log_ref log) srslte::log_ref log)
{ {
std::vector<pdcp_test_event_t> pdu_vec; std::vector<pdcp_test_event_t> pdu_vec;
for (uint32_t tx_next : tx_nexts) { for (uint32_t tx_next : tx_nexts) {
pdcp_test_event_t event; pdcp_test_event_t event;
event.pkt = gen_expected_pdu(in_sdu, tx_next, pdcp_sn_len, rb_type, sec_cfg_, pool, log); event.pkt = gen_expected_pdu(in_sdu, tx_next, pdcp_sn_len, rb_type, sec_cfg_, log);
event.ticks = 0; event.ticks = 0;
pdu_vec.push_back(std::move(event)); pdu_vec.push_back(std::move(event));
} }

61
lib/test/upper/pdcp_lte_test_rx.cc
Unescape Escape View File

@ -21,7 +21,6 @@ int test_rx(std::vector<pdcp_test_event_t> events,
srslte::pdcp_rb_type_t rb_type, srslte::pdcp_rb_type_t rb_type,
uint32_t n_sdus_exp, uint32_t n_sdus_exp,
const srslte::unique_byte_buffer_t& sdu_exp, const srslte::unique_byte_buffer_t& sdu_exp,
srslte::byte_buffer_pool* pool,
srslte::log_ref log) srslte::log_ref log)
{ {
@ -73,7 +72,7 @@ int test_rx(std::vector<pdcp_test_event_t> events,
* RX Test: PDCP Entity with SN LEN = 5 and 12. * RX Test: PDCP Entity with SN LEN = 5 and 12.
* PDCP entity configured with EIA2 and EEA2 * PDCP entity configured with EIA2 and EEA2
*/ */
int test_rx_all(srslte::byte_buffer_pool* pool, srslte::log_ref log) int test_rx_all(srslte::log_ref log)
{ {
// Test SDUs // Test SDUs
srslte::unique_byte_buffer_t tst_sdu1 = srslte::make_byte_buffer(); // SDU 1 srslte::unique_byte_buffer_t tst_sdu1 = srslte::make_byte_buffer(); // SDU 1
@ -89,18 +88,14 @@ int test_rx_all(srslte::byte_buffer_pool* pool, srslte::log_ref log)
{ {
std::vector<uint32_t> test1_counts(2); // Test two packets std::vector<uint32_t> test1_counts(2); // Test two packets
std::iota(test1_counts.begin(), test1_counts.end(), 31); // Starting at COUNT 31 std::iota(test1_counts.begin(), test1_counts.end(), 31); // Starting at COUNT 31
std::vector<pdcp_test_event_t> test1_pdus = gen_expected_pdus_vector( std::vector<pdcp_test_event_t> test1_pdus =
tst_sdu1, test1_counts, srslte::PDCP_SN_LEN_5, srslte::PDCP_RB_IS_SRB, sec_cfg, pool, log); gen_expected_pdus_vector(tst_sdu1, test1_counts, srslte::PDCP_SN_LEN_5, srslte::PDCP_RB_IS_SRB, sec_cfg, log);
srslte::pdcp_lte_state_t test1_init_state = { srslte::pdcp_lte_state_t test1_init_state = {
.next_pdcp_tx_sn = 0, .tx_hfn = 0, .rx_hfn = 0, .next_pdcp_rx_sn = 31, .last_submitted_pdcp_rx_sn = 30}; .next_pdcp_tx_sn = 0, .tx_hfn = 0, .rx_hfn = 0, .next_pdcp_rx_sn = 31, .last_submitted_pdcp_rx_sn = 30};
TESTASSERT(test_rx(std::move(test1_pdus), TESTASSERT(
test1_init_state, test_rx(
srslte::PDCP_SN_LEN_5, std::move(test1_pdus), test1_init_state, srslte::PDCP_SN_LEN_5, srslte::PDCP_RB_IS_SRB, 2, tst_sdu1, log) ==
srslte::PDCP_RB_IS_SRB, 0);
2,
tst_sdu1,
pool,
log) == 0);
} }
/* /*
@ -111,18 +106,14 @@ int test_rx_all(srslte::byte_buffer_pool* pool, srslte::log_ref log)
{ {
std::vector<uint32_t> test_counts(2); // Test two packets std::vector<uint32_t> test_counts(2); // Test two packets
std::iota(test_counts.begin(), test_counts.end(), 4095); // Starting at COUNT 4095 std::iota(test_counts.begin(), test_counts.end(), 4095); // Starting at COUNT 4095
std::vector<pdcp_test_event_t> test_pdus = gen_expected_pdus_vector( std::vector<pdcp_test_event_t> test_pdus =
tst_sdu1, test_counts, srslte::PDCP_SN_LEN_12, srslte::PDCP_RB_IS_DRB, sec_cfg, pool, log); gen_expected_pdus_vector(tst_sdu1, test_counts, srslte::PDCP_SN_LEN_12, srslte::PDCP_RB_IS_DRB, sec_cfg, log);
srslte::pdcp_lte_state_t test_init_state = { srslte::pdcp_lte_state_t test_init_state = {
.next_pdcp_tx_sn = 0, .tx_hfn = 0, .rx_hfn = 0, .next_pdcp_rx_sn = 4095, .last_submitted_pdcp_rx_sn = 4094}; .next_pdcp_tx_sn = 0, .tx_hfn = 0, .rx_hfn = 0, .next_pdcp_rx_sn = 4095, .last_submitted_pdcp_rx_sn = 4094};
TESTASSERT(test_rx(std::move(test_pdus), TESTASSERT(
test_init_state, test_rx(
srslte::PDCP_SN_LEN_12, std::move(test_pdus), test_init_state, srslte::PDCP_SN_LEN_12, srslte::PDCP_RB_IS_DRB, 2, tst_sdu1, log) ==
srslte::PDCP_RB_IS_DRB, 0);
2,
tst_sdu1,
pool,
log) == 0);
} }
/* /*
@ -132,8 +123,8 @@ int test_rx_all(srslte::byte_buffer_pool* pool, srslte::log_ref log)
{ {
std::vector<uint32_t> test_counts(2); // Test two packets std::vector<uint32_t> test_counts(2); // Test two packets
std::iota(test_counts.begin(), test_counts.end(), 31); // Starting at COUNT 31 std::iota(test_counts.begin(), test_counts.end(), 31); // Starting at COUNT 31
std::vector<pdcp_test_event_t> test_pdus = gen_expected_pdus_vector( std::vector<pdcp_test_event_t> test_pdus =
tst_sdu1, test_counts, srslte::PDCP_SN_LEN_12, srslte::PDCP_RB_IS_DRB, sec_cfg, pool, log); gen_expected_pdus_vector(tst_sdu1, test_counts, srslte::PDCP_SN_LEN_12, srslte::PDCP_RB_IS_DRB, sec_cfg, log);
srslte::pdcp_lte_state_t test_init_state = { srslte::pdcp_lte_state_t test_init_state = {
.next_pdcp_tx_sn = 0, .tx_hfn = 0, .rx_hfn = 0, .next_pdcp_rx_sn = 32, .last_submitted_pdcp_rx_sn = 31}; .next_pdcp_tx_sn = 0, .tx_hfn = 0, .rx_hfn = 0, .next_pdcp_rx_sn = 32, .last_submitted_pdcp_rx_sn = 31};
TESTASSERT(test_rx(std::move(test_pdus), TESTASSERT(test_rx(std::move(test_pdus),
@ -142,7 +133,6 @@ int test_rx_all(srslte::byte_buffer_pool* pool, srslte::log_ref log)
srslte::PDCP_RB_IS_DRB, srslte::PDCP_RB_IS_DRB,
test_counts.size() - 1, test_counts.size() - 1,
tst_sdu1, tst_sdu1,
pool,
log) == 0); log) == 0);
} }
@ -151,7 +141,7 @@ int test_rx_all(srslte::byte_buffer_pool* pool, srslte::log_ref log)
// Basic test to verify the correct handling of PDCP status PDUs on DRBs // Basic test to verify the correct handling of PDCP status PDUs on DRBs
// As long as we don't implement status reporting, the PDU shall be dropped // As long as we don't implement status reporting, the PDU shall be dropped
int test_rx_control_pdu(srslte::byte_buffer_pool* pool, srslte::log_ref log) int test_rx_control_pdu(srslte::log_ref log)
{ {
const uint8_t pdcp_status_report_long[] = {0x0a, 0xc9, 0x3c}; const uint8_t pdcp_status_report_long[] = {0x0a, 0xc9, 0x3c};
@ -167,35 +157,30 @@ int test_rx_control_pdu(srslte::byte_buffer_pool* pool, srslte::log_ref log)
srslte::pdcp_lte_state_t test_init_state = { srslte::pdcp_lte_state_t test_init_state = {
.next_pdcp_tx_sn = 0, .tx_hfn = 0, .rx_hfn = 0, .next_pdcp_rx_sn = 32, .last_submitted_pdcp_rx_sn = 31}; .next_pdcp_tx_sn = 0, .tx_hfn = 0, .rx_hfn = 0, .next_pdcp_rx_sn = 32, .last_submitted_pdcp_rx_sn = 31};
TESTASSERT(test_rx(std::move(pdu_vec), TESTASSERT(
test_init_state, test_rx(std::move(pdu_vec), test_init_state, srslte::PDCP_SN_LEN_12, srslte::PDCP_RB_IS_DRB, 0, tst_sdu1, log) ==
srslte::PDCP_SN_LEN_12, 0);
srslte::PDCP_RB_IS_DRB,
0,
tst_sdu1,
pool,
log) == 0);
return SRSLTE_SUCCESS; return SRSLTE_SUCCESS;
} }
// Setup all tests // Setup all tests
int run_all_tests(srslte::byte_buffer_pool* pool) int run_all_tests()
{ {
// Setup log // Setup log
srslte::log_ref log("PDCP LTE Test RX"); srslte::log_ref log("PDCP LTE Test RX");
log->set_level(srslte::LOG_LEVEL_DEBUG); log->set_level(srslte::LOG_LEVEL_DEBUG);
log->set_hex_limit(128); log->set_hex_limit(128);
TESTASSERT(test_rx_all(pool, log) == 0); TESTASSERT(test_rx_all(log) == 0);
TESTASSERT(test_rx_control_pdu(pool, log) == 0); TESTASSERT(test_rx_control_pdu(log) == 0);
return 0; return 0;
} }
int main() int main()
{ {
if (run_all_tests(srslte::byte_buffer_pool::get_instance()) != SRSLTE_SUCCESS) { if (run_all_tests() != SRSLTE_SUCCESS) {
fprintf(stderr, "pdcp_nr_tests_rx() failed\n"); fprintf(stderr, "pdcp_nr_tests_rx() failed\n");
return SRSLTE_ERROR; return SRSLTE_ERROR;
} }

4
lib/test/upper/pdcp_nr_test.h
Unescape Escape View File

@ -115,7 +115,6 @@ srslte::unique_byte_buffer_t gen_expected_pdu(const srslte::unique_byte_buffer_t
uint32_t count, uint32_t count,
uint8_t pdcp_sn_len, uint8_t pdcp_sn_len,
srslte::as_security_config_t sec_cfg, srslte::as_security_config_t sec_cfg,
srslte::byte_buffer_pool* pool,
srslte::log_ref log) srslte::log_ref log)
{ {
srslte::pdcp_config_t cfg = {1, srslte::pdcp_config_t cfg = {1,
@ -148,13 +147,12 @@ std::vector<pdcp_test_event_t> gen_expected_pdus_vector(const srslte::unique_byt
const std::vector<uint32_t>& tx_nexts, const std::vector<uint32_t>& tx_nexts,
uint8_t pdcp_sn_len, uint8_t pdcp_sn_len,
srslte::as_security_config_t sec_cfg_, srslte::as_security_config_t sec_cfg_,
srslte::byte_buffer_pool* pool,
srslte::log_ref log) srslte::log_ref log)
{ {
std::vector<pdcp_test_event_t> pdu_vec; std::vector<pdcp_test_event_t> pdu_vec;
for (uint32_t tx_next : tx_nexts) { for (uint32_t tx_next : tx_nexts) {
pdcp_test_event_t event; pdcp_test_event_t event;
event.pkt = gen_expected_pdu(in_sdu, tx_next, pdcp_sn_len, sec_cfg_, pool, log); event.pkt = gen_expected_pdu(in_sdu, tx_next, pdcp_sn_len, sec_cfg_, log);
event.ticks = 0; event.ticks = 0;
pdu_vec.push_back(std::move(event)); pdu_vec.push_back(std::move(event));
} }

13
lib/test/upper/pdcp_nr_test_discard_sdu.cc
Unescape Escape View File

@ -18,7 +18,6 @@
int test_tx_sdu_discard(const pdcp_initial_state& init_state, int test_tx_sdu_discard(const pdcp_initial_state& init_state,
srslte::pdcp_discard_timer_t discard_timeout, srslte::pdcp_discard_timer_t discard_timeout,
bool imediate_notify, bool imediate_notify,
srslte::byte_buffer_pool* pool,
srslte::log_ref log) srslte::log_ref log)
{ {
srslte::pdcp_config_t cfg = {1, srslte::pdcp_config_t cfg = {1,
@ -73,37 +72,37 @@ int test_tx_sdu_discard(const pdcp_initial_state& init_state,
* TX Test: PDCP Entity with SN LEN = 12 and 18. * TX Test: PDCP Entity with SN LEN = 12 and 18.
* PDCP entity configured with EIA2 and EEA2 * PDCP entity configured with EIA2 and EEA2
*/ */
int test_tx_discard_all(srslte::byte_buffer_pool* pool, srslte::log_ref log) int test_tx_discard_all(srslte::log_ref log)
{ {
/* /*
* TX Test 1: PDCP Entity with SN LEN = 12 * TX Test 1: PDCP Entity with SN LEN = 12
* Test TX PDU discard. * Test TX PDU discard.
*/ */
TESTASSERT(test_tx_sdu_discard(normal_init_state, srslte::pdcp_discard_timer_t::ms50, false, pool, log) == 0); TESTASSERT(test_tx_sdu_discard(normal_init_state, srslte::pdcp_discard_timer_t::ms50, false, log) == 0);
/* /*
* TX Test 2: PDCP Entity with SN LEN = 12 * TX Test 2: PDCP Entity with SN LEN = 12
* Test TX PDU discard. * Test TX PDU discard.
*/ */
// TESTASSERT(test_tx_sdu_discard(normal_init_state, srslte::pdcp_discard_timer_t::ms50, true, pool, log) == 0); // TESTASSERT(test_tx_sdu_discard(normal_init_state, srslte::pdcp_discard_timer_t::ms50, true, log) == 0);
return 0; return 0;
} }
// Setup all tests // Setup all tests
int run_all_tests(srslte::byte_buffer_pool* pool) int run_all_tests()
{ {
// Setup log // Setup log
srslte::log_ref log("PDCP NR Test"); srslte::log_ref log("PDCP NR Test");
log->set_level(srslte::LOG_LEVEL_DEBUG); log->set_level(srslte::LOG_LEVEL_DEBUG);
log->set_hex_limit(128); log->set_hex_limit(128);
TESTASSERT(test_tx_discard_all(pool, log) == 0); TESTASSERT(test_tx_discard_all(log) == 0);
return 0; return 0;
} }
int main() int main()
{ {
if (run_all_tests(srslte::byte_buffer_pool::get_instance()) != SRSLTE_SUCCESS) { if (run_all_tests() != SRSLTE_SUCCESS) {
fprintf(stderr, "pdcp_nr_tests() failed\n"); fprintf(stderr, "pdcp_nr_tests() failed\n");
return SRSLTE_ERROR; return SRSLTE_ERROR;
} }

33
lib/test/upper/pdcp_nr_test_rx.cc
Unescape Escape View File

@ -20,7 +20,6 @@ int test_rx(std::vector<pdcp_test_event_t> events,
uint8_t pdcp_sn_len, uint8_t pdcp_sn_len,
uint32_t n_sdus_exp, uint32_t n_sdus_exp,
const srslte::unique_byte_buffer_t& sdu_exp, const srslte::unique_byte_buffer_t& sdu_exp,
srslte::byte_buffer_pool* pool,
srslte::log_ref log) srslte::log_ref log)
{ {
@ -59,7 +58,7 @@ int test_rx(std::vector<pdcp_test_event_t> events,
* RX Test: PDCP Entity with SN LEN = 12 and 18. * RX Test: PDCP Entity with SN LEN = 12 and 18.
* PDCP entity configured with EIA2 and EEA2 * PDCP entity configured with EIA2 and EEA2
*/ */
int test_rx_all(srslte::byte_buffer_pool* pool, srslte::log_ref log) int test_rx_all(srslte::log_ref log)
{ {
// Test SDUs // Test SDUs
srslte::unique_byte_buffer_t tst_sdu1 = srslte::make_byte_buffer(); // SDU 1 srslte::unique_byte_buffer_t tst_sdu1 = srslte::make_byte_buffer(); // SDU 1
@ -76,9 +75,9 @@ int test_rx_all(srslte::byte_buffer_pool* pool, srslte::log_ref log)
std::vector<uint32_t> test1_counts(2); // Test two packets std::vector<uint32_t> test1_counts(2); // Test two packets
std::iota(test1_counts.begin(), test1_counts.end(), 4095); // Starting at COUNT 4095 std::iota(test1_counts.begin(), test1_counts.end(), 4095); // Starting at COUNT 4095
std::vector<pdcp_test_event_t> test1_pdus = std::vector<pdcp_test_event_t> test1_pdus =
gen_expected_pdus_vector(tst_sdu1, test1_counts, srslte::PDCP_SN_LEN_12, sec_cfg, pool, log); gen_expected_pdus_vector(tst_sdu1, test1_counts, srslte::PDCP_SN_LEN_12, sec_cfg, log);
pdcp_initial_state test1_init_state = {.tx_next = 4095, .rx_next = 4095, .rx_deliv = 4095, .rx_reord = 0}; pdcp_initial_state test1_init_state = {.tx_next = 4095, .rx_next = 4095, .rx_deliv = 4095, .rx_reord = 0};
TESTASSERT(test_rx(std::move(test1_pdus), test1_init_state, srslte::PDCP_SN_LEN_12, 2, tst_sdu1, pool, log) == 0); TESTASSERT(test_rx(std::move(test1_pdus), test1_init_state, srslte::PDCP_SN_LEN_12, 2, tst_sdu1, log) == 0);
} }
/* /*
* RX Test 2: PDCP Entity with SN LEN = 12 * RX Test 2: PDCP Entity with SN LEN = 12
@ -90,10 +89,10 @@ int test_rx_all(srslte::byte_buffer_pool* pool, srslte::log_ref log)
std::vector<uint32_t> test2_counts(2); // Test two packets std::vector<uint32_t> test2_counts(2); // Test two packets
std::iota(test2_counts.begin(), test2_counts.end(), 4294967295); // Starting at COUNT 4294967295 std::iota(test2_counts.begin(), test2_counts.end(), 4294967295); // Starting at COUNT 4294967295
std::vector<pdcp_test_event_t> test2_pdus = std::vector<pdcp_test_event_t> test2_pdus =
gen_expected_pdus_vector(tst_sdu1, test2_counts, srslte::PDCP_SN_LEN_12, sec_cfg, pool, log); gen_expected_pdus_vector(tst_sdu1, test2_counts, srslte::PDCP_SN_LEN_12, sec_cfg, log);
pdcp_initial_state test2_init_state = { pdcp_initial_state test2_init_state = {
.tx_next = 4294967295, .rx_next = 4294967295, .rx_deliv = 4294967295, .rx_reord = 0}; .tx_next = 4294967295, .rx_next = 4294967295, .rx_deliv = 4294967295, .rx_reord = 0};
TESTASSERT(test_rx(std::move(test2_pdus), test2_init_state, srslte::PDCP_SN_LEN_12, 1, tst_sdu1, pool, log) == 0); TESTASSERT(test_rx(std::move(test2_pdus), test2_init_state, srslte::PDCP_SN_LEN_12, 1, tst_sdu1, log) == 0);
} }
/* /*
* RX Test 3: PDCP Entity with SN LEN = 18 * RX Test 3: PDCP Entity with SN LEN = 18
@ -104,9 +103,9 @@ int test_rx_all(srslte::byte_buffer_pool* pool, srslte::log_ref log)
std::vector<uint32_t> test3_counts(2); // Test two packets std::vector<uint32_t> test3_counts(2); // Test two packets
std::iota(test3_counts.begin(), test3_counts.end(), 262144); // Starting at COUNT 262144 std::iota(test3_counts.begin(), test3_counts.end(), 262144); // Starting at COUNT 262144
std::vector<pdcp_test_event_t> test3_pdus = std::vector<pdcp_test_event_t> test3_pdus =
gen_expected_pdus_vector(tst_sdu1, test3_counts, srslte::PDCP_SN_LEN_18, sec_cfg, pool, log); gen_expected_pdus_vector(tst_sdu1, test3_counts, srslte::PDCP_SN_LEN_18, sec_cfg, log);
pdcp_initial_state test3_init_state = {.tx_next = 262144, .rx_next = 262144, .rx_deliv = 262144, .rx_reord = 0}; pdcp_initial_state test3_init_state = {.tx_next = 262144, .rx_next = 262144, .rx_deliv = 262144, .rx_reord = 0};
TESTASSERT(test_rx(std::move(test3_pdus), test3_init_state, srslte::PDCP_SN_LEN_18, 2, tst_sdu1, pool, log) == 0); TESTASSERT(test_rx(std::move(test3_pdus), test3_init_state, srslte::PDCP_SN_LEN_18, 2, tst_sdu1, log) == 0);
} }
/* /*
@ -118,10 +117,10 @@ int test_rx_all(srslte::byte_buffer_pool* pool, srslte::log_ref log)
std::vector<uint32_t> test4_counts(2); // Test two packets std::vector<uint32_t> test4_counts(2); // Test two packets
std::iota(test4_counts.begin(), test4_counts.end(), 4294967295); // Starting at COUNT 4294967295 std::iota(test4_counts.begin(), test4_counts.end(), 4294967295); // Starting at COUNT 4294967295
std::vector<pdcp_test_event_t> test4_pdus = std::vector<pdcp_test_event_t> test4_pdus =
gen_expected_pdus_vector(tst_sdu1, test4_counts, srslte::PDCP_SN_LEN_18, sec_cfg, pool, log); gen_expected_pdus_vector(tst_sdu1, test4_counts, srslte::PDCP_SN_LEN_18, sec_cfg, log);
pdcp_initial_state test4_init_state = { pdcp_initial_state test4_init_state = {
.tx_next = 4294967295, .rx_next = 4294967295, .rx_deliv = 4294967295, .rx_reord = 0}; .tx_next = 4294967295, .rx_next = 4294967295, .rx_deliv = 4294967295, .rx_reord = 0};
TESTASSERT(test_rx(std::move(test4_pdus), test4_init_state, srslte::PDCP_SN_LEN_18, 1, tst_sdu1, pool, log) == 0); TESTASSERT(test_rx(std::move(test4_pdus), test4_init_state, srslte::PDCP_SN_LEN_18, 1, tst_sdu1, log) == 0);
} }
/* /*
@ -145,7 +144,7 @@ int test_rx_all(srslte::byte_buffer_pool* pool, srslte::log_ref log)
// Write PDUs out of order (first the pdu with COUNT 1 and COUNT 0 after) // Write PDUs out of order (first the pdu with COUNT 1 and COUNT 0 after)
test5_pdus.push_back(std::move(event_pdu2)); test5_pdus.push_back(std::move(event_pdu2));
test5_pdus.push_back(std::move(event_pdu1)); test5_pdus.push_back(std::move(event_pdu1));
TESTASSERT(test_rx(std::move(test5_pdus), test5_init_state, srslte::PDCP_SN_LEN_12, 2, tst_sdu2, pool, log) == 0); TESTASSERT(test_rx(std::move(test5_pdus), test5_init_state, srslte::PDCP_SN_LEN_12, 2, tst_sdu2, log) == 0);
} }
/* /*
@ -169,7 +168,7 @@ int test_rx_all(srslte::byte_buffer_pool* pool, srslte::log_ref log)
// Write PDUs out of order (first the pdu with COUNT 1 and COUNT 0 after) // Write PDUs out of order (first the pdu with COUNT 1 and COUNT 0 after)
test6_pdus.push_back(std::move(event_pdu2)); test6_pdus.push_back(std::move(event_pdu2));
test6_pdus.push_back(std::move(event_pdu1)); test6_pdus.push_back(std::move(event_pdu1));
TESTASSERT(test_rx(std::move(test6_pdus), test6_init_state, srslte::PDCP_SN_LEN_18, 2, tst_sdu2, pool, log) == 0); TESTASSERT(test_rx(std::move(test6_pdus), test6_init_state, srslte::PDCP_SN_LEN_18, 2, tst_sdu2, log) == 0);
} }
/* /*
@ -188,7 +187,7 @@ int test_rx_all(srslte::byte_buffer_pool* pool, srslte::log_ref log)
// Write PDUs out of order (first the pdu with COUNT 1 and COUNT 0 after) // Write PDUs out of order (first the pdu with COUNT 1 and COUNT 0 after)
test7_pdus.push_back(std::move(event_pdu1)); test7_pdus.push_back(std::move(event_pdu1));
TESTASSERT(test_rx(std::move(test7_pdus), test7_init_state, srslte::PDCP_SN_LEN_12, 1, tst_sdu2, pool, log) == 0); TESTASSERT(test_rx(std::move(test7_pdus), test7_init_state, srslte::PDCP_SN_LEN_12, 1, tst_sdu2, log) == 0);
} }
/* /*
@ -212,26 +211,26 @@ int test_rx_all(srslte::byte_buffer_pool* pool, srslte::log_ref log)
// Write PDUs out of order (first the pdu with COUNT 1 and COUNT 0 after) // Write PDUs out of order (first the pdu with COUNT 1 and COUNT 0 after)
test8_pdus.push_back(std::move(event_pdu1)); test8_pdus.push_back(std::move(event_pdu1));
test8_pdus.push_back(std::move(event_pdu2)); test8_pdus.push_back(std::move(event_pdu2));
TESTASSERT(test_rx(std::move(test8_pdus), test8_init_state, srslte::PDCP_SN_LEN_12, 1, tst_sdu1, pool, log) == 0); TESTASSERT(test_rx(std::move(test8_pdus), test8_init_state, srslte::PDCP_SN_LEN_12, 1, tst_sdu1, log) == 0);
} }
return 0; return 0;
} }
// Setup all tests // Setup all tests
int run_all_tests(srslte::byte_buffer_pool* pool) int run_all_tests()
{ {
// Setup log // Setup log
srslte::log_ref log("PDCP NR Test RX"); srslte::log_ref log("PDCP NR Test RX");
log->set_level(srslte::LOG_LEVEL_DEBUG); log->set_level(srslte::LOG_LEVEL_DEBUG);
log->set_hex_limit(128); log->set_hex_limit(128);
TESTASSERT(test_rx_all(pool, log) == 0); TESTASSERT(test_rx_all(log) == 0);
return 0; return 0;
} }
int main() int main()
{ {
if (run_all_tests(srslte::byte_buffer_pool::get_instance()) != SRSLTE_SUCCESS) { if (run_all_tests() != SRSLTE_SUCCESS) {
fprintf(stderr, "pdcp_nr_tests_rx() failed\n"); fprintf(stderr, "pdcp_nr_tests_rx() failed\n");
return SRSLTE_ERROR; return SRSLTE_ERROR;
} }

75
lib/test/upper/pdcp_nr_test_tx.cc
Unescape Escape View File

@ -20,7 +20,6 @@ int test_tx(uint32_t n_packets,
uint8_t pdcp_sn_len, uint8_t pdcp_sn_len,
uint64_t n_pdus_exp, uint64_t n_pdus_exp,
srslte::unique_byte_buffer_t pdu_exp, srslte::unique_byte_buffer_t pdu_exp,
srslte::byte_buffer_pool* pool,
srslte::log_ref log) srslte::log_ref log)
{ {
srslte::pdcp_config_t cfg = {1, srslte::pdcp_config_t cfg = {1,
@ -57,7 +56,7 @@ int test_tx(uint32_t n_packets,
* TX Test: PDCP Entity with SN LEN = 12 and 18. * TX Test: PDCP Entity with SN LEN = 12 and 18.
* PDCP entity configured with EIA2 and EEA2 * PDCP entity configured with EIA2 and EEA2
*/ */
int test_tx_all(srslte::byte_buffer_pool* pool, srslte::log_ref log) int test_tx_all(srslte::log_ref log)
{ {
uint64_t n_packets; uint64_t n_packets;
/* /*
@ -69,13 +68,9 @@ int test_tx_all(srslte::byte_buffer_pool* pool, srslte::log_ref log)
n_packets = 1; n_packets = 1;
srslte::unique_byte_buffer_t pdu_exp_count0_len12 = srslte::make_byte_buffer(); srslte::unique_byte_buffer_t pdu_exp_count0_len12 = srslte::make_byte_buffer();
pdu_exp_count0_len12->append_bytes(pdu1_count0_snlen12, sizeof(pdu1_count0_snlen12)); pdu_exp_count0_len12->append_bytes(pdu1_count0_snlen12, sizeof(pdu1_count0_snlen12));
TESTASSERT(test_tx(n_packets, TESTASSERT(
normal_init_state, test_tx(n_packets, normal_init_state, srslte::PDCP_SN_LEN_12, n_packets, std::move(pdu_exp_count0_len12), log) ==
srslte::PDCP_SN_LEN_12, 0);
n_packets,
std::move(pdu_exp_count0_len12),
pool,
log) == 0);
/* /*
* TX Test 2: PDCP Entity with SN LEN = 12 * TX Test 2: PDCP Entity with SN LEN = 12
@ -86,13 +81,10 @@ int test_tx_all(srslte::byte_buffer_pool* pool, srslte::log_ref log)
n_packets = 2049; n_packets = 2049;
srslte::unique_byte_buffer_t pdu_exp_count2048_len12 = srslte::make_byte_buffer(); srslte::unique_byte_buffer_t pdu_exp_count2048_len12 = srslte::make_byte_buffer();
pdu_exp_count2048_len12->append_bytes(pdu1_count2048_snlen12, sizeof(pdu1_count2048_snlen12)); pdu_exp_count2048_len12->append_bytes(pdu1_count2048_snlen12, sizeof(pdu1_count2048_snlen12));
TESTASSERT(test_tx(n_packets, TESTASSERT(
normal_init_state, test_tx(
srslte::PDCP_SN_LEN_12, n_packets, normal_init_state, srslte::PDCP_SN_LEN_12, n_packets, std::move(pdu_exp_count2048_len12), log) ==
n_packets, 0);
std::move(pdu_exp_count2048_len12),
pool,
log) == 0);
/* /*
* TX Test 3: PDCP Entity with SN LEN = 12 * TX Test 3: PDCP Entity with SN LEN = 12
@ -103,13 +95,10 @@ int test_tx_all(srslte::byte_buffer_pool* pool, srslte::log_ref log)
n_packets = 4097; n_packets = 4097;
srslte::unique_byte_buffer_t pdu_exp_count4096_len12 = srslte::make_byte_buffer(); srslte::unique_byte_buffer_t pdu_exp_count4096_len12 = srslte::make_byte_buffer();
pdu_exp_count4096_len12->append_bytes(pdu1_count4096_snlen12, sizeof(pdu1_count4096_snlen12)); pdu_exp_count4096_len12->append_bytes(pdu1_count4096_snlen12, sizeof(pdu1_count4096_snlen12));
TESTASSERT(test_tx(n_packets, TESTASSERT(
normal_init_state, test_tx(
srslte::PDCP_SN_LEN_12, n_packets, normal_init_state, srslte::PDCP_SN_LEN_12, n_packets, std::move(pdu_exp_count4096_len12), log) ==
n_packets, 0);
std::move(pdu_exp_count4096_len12),
pool,
log) == 0);
/* /*
* TX Test 4: PDCP Entity with SN LEN = 18 * TX Test 4: PDCP Entity with SN LEN = 18
@ -120,13 +109,9 @@ int test_tx_all(srslte::byte_buffer_pool* pool, srslte::log_ref log)
n_packets = 1; n_packets = 1;
srslte::unique_byte_buffer_t pdu_exp_count0_len18 = srslte::make_byte_buffer(); srslte::unique_byte_buffer_t pdu_exp_count0_len18 = srslte::make_byte_buffer();
pdu_exp_count0_len18->append_bytes(pdu1_count0_snlen18, sizeof(pdu1_count0_snlen18)); pdu_exp_count0_len18->append_bytes(pdu1_count0_snlen18, sizeof(pdu1_count0_snlen18));
TESTASSERT(test_tx(n_packets, TESTASSERT(
normal_init_state, test_tx(n_packets, normal_init_state, srslte::PDCP_SN_LEN_18, n_packets, std::move(pdu_exp_count0_len18), log) ==
srslte::PDCP_SN_LEN_18, 0);
n_packets,
std::move(pdu_exp_count0_len18),
pool,
log) == 0);
/* /*
* TX Test 5: PDCP Entity with SN LEN = 18 * TX Test 5: PDCP Entity with SN LEN = 18
@ -137,13 +122,10 @@ int test_tx_all(srslte::byte_buffer_pool* pool, srslte::log_ref log)
n_packets = 131073; n_packets = 131073;
srslte::unique_byte_buffer_t pdu_exp_sn131072_len18 = srslte::make_byte_buffer(); srslte::unique_byte_buffer_t pdu_exp_sn131072_len18 = srslte::make_byte_buffer();
pdu_exp_sn131072_len18->append_bytes(pdu1_count131072_snlen18, sizeof(pdu1_count131072_snlen18)); pdu_exp_sn131072_len18->append_bytes(pdu1_count131072_snlen18, sizeof(pdu1_count131072_snlen18));
TESTASSERT(test_tx(n_packets, TESTASSERT(
normal_init_state, test_tx(
srslte::PDCP_SN_LEN_18, n_packets, normal_init_state, srslte::PDCP_SN_LEN_18, n_packets, std::move(pdu_exp_sn131072_len18), log) ==
n_packets, 0);
std::move(pdu_exp_sn131072_len18),
pool,
log) == 0);
/* /*
* TX Test 6: PDCP Entity with SN LEN = 18 * TX Test 6: PDCP Entity with SN LEN = 18
@ -154,13 +136,10 @@ int test_tx_all(srslte::byte_buffer_pool* pool, srslte::log_ref log)
n_packets = 262145; n_packets = 262145;
srslte::unique_byte_buffer_t pdu_exp_count262144_len18 = srslte::make_byte_buffer(); srslte::unique_byte_buffer_t pdu_exp_count262144_len18 = srslte::make_byte_buffer();
pdu_exp_count262144_len18->append_bytes(pdu1_count262144_snlen18, sizeof(pdu1_count262144_snlen18)); pdu_exp_count262144_len18->append_bytes(pdu1_count262144_snlen18, sizeof(pdu1_count262144_snlen18));
TESTASSERT(test_tx(n_packets, TESTASSERT(
normal_init_state, test_tx(
srslte::PDCP_SN_LEN_18, n_packets, normal_init_state, srslte::PDCP_SN_LEN_18, n_packets, std::move(pdu_exp_count262144_len18), log) ==
n_packets, 0);
std::move(pdu_exp_count262144_len18),
pool,
log) == 0);
/* /*
* TX Test 7: PDCP Entity with SN LEN = 12 * TX Test 7: PDCP Entity with SN LEN = 12
@ -175,7 +154,6 @@ int test_tx_all(srslte::byte_buffer_pool* pool, srslte::log_ref log)
srslte::PDCP_SN_LEN_12, srslte::PDCP_SN_LEN_12,
1, 1,
std::move(pdu_exp_count4294967295_len12), std::move(pdu_exp_count4294967295_len12),
pool,
log) == 0); log) == 0);
/* /*
@ -191,26 +169,25 @@ int test_tx_all(srslte::byte_buffer_pool* pool, srslte::log_ref log)
srslte::PDCP_SN_LEN_18, srslte::PDCP_SN_LEN_18,
1, 1,
std::move(pdu_exp_count4294967295_len18), std::move(pdu_exp_count4294967295_len18),
pool,
log) == 0); log) == 0);
return 0; return 0;
} }
// Setup all tests // Setup all tests
int run_all_tests(srslte::byte_buffer_pool* pool) int run_all_tests()
{ {
// Setup log // Setup log
srslte::log_ref log("PDCP NR Test TX"); srslte::log_ref log("PDCP NR Test TX");
log->set_level(srslte::LOG_LEVEL_DEBUG); log->set_level(srslte::LOG_LEVEL_DEBUG);
log->set_hex_limit(128); log->set_hex_limit(128);
TESTASSERT(test_tx_all(pool, log) == 0); TESTASSERT(test_tx_all(log) == 0);
return 0; return 0;
} }
int main() int main()
{ {
if (run_all_tests(srslte::byte_buffer_pool::get_instance()) != SRSLTE_SUCCESS) { if (run_all_tests() != SRSLTE_SUCCESS) {
fprintf(stderr, "pdcp_nr_tests_tx() failed\n"); fprintf(stderr, "pdcp_nr_tests_tx() failed\n");
return SRSLTE_ERROR; return SRSLTE_ERROR;
} }

2
srsenb/hdr/enb.h
Unescape Escape View File

@ -139,8 +139,6 @@ private:
srslog::sink& log_sink; srslog::sink& log_sink;
srslog::basic_logger& enb_log; srslog::basic_logger& enb_log;
srslte::byte_buffer_pool* pool = nullptr;
all_args_t args = {}; all_args_t args = {};
bool started = false; bool started = false;

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

@ -118,13 +118,13 @@ private:
stack_args_t args = {}; stack_args_t args = {};
rrc_cfg_t rrc_cfg = {}; rrc_cfg_t rrc_cfg = {};
srslog::basic_logger &mac_logger; srslog::basic_logger& mac_logger;
srslog::basic_logger &rlc_logger; srslog::basic_logger& rlc_logger;
srslog::basic_logger &pdcp_logger; srslog::basic_logger& pdcp_logger;
srslog::basic_logger &rrc_logger; srslog::basic_logger& rrc_logger;
srslog::basic_logger &s1ap_logger; srslog::basic_logger& s1ap_logger;
srslog::basic_logger &gtpu_logger; srslog::basic_logger& gtpu_logger;
srslog::basic_logger &stack_logger; srslog::basic_logger& stack_logger;
// task handling // task handling
srslte::task_scheduler task_sched; srslte::task_scheduler task_sched;
@ -142,8 +142,7 @@ private:
srsenb::s1ap s1ap; srsenb::s1ap s1ap;
srslte::s1ap_pcap s1ap_pcap; srslte::s1ap_pcap s1ap_pcap;
srslte::logger* logger = nullptr; srslte::logger* logger = nullptr;
srslte::byte_buffer_pool* pool = nullptr;
// Radio and PHY log are in enb.cc // Radio and PHY log are in enb.cc
srslte::log_ref mac_log{"MAC"}; srslte::log_ref mac_log{"MAC"};

7
srsenb/hdr/stack/mac/mac_nr.h
Unescape Escape View File

@ -81,10 +81,9 @@ private:
rlc_interface_mac_nr* rlc_h = nullptr; rlc_interface_mac_nr* rlc_h = nullptr;
rrc_interface_mac_nr* rrc_h = nullptr; rrc_interface_mac_nr* rrc_h = nullptr;
std::unique_ptr<srslte::mac_pcap> pcap = nullptr; std::unique_ptr<srslte::mac_pcap> pcap = nullptr;
srslte::log_ref log_h; srslte::log_ref log_h;
srslte::byte_buffer_pool* pool = nullptr; mac_nr_args_t args = {};
mac_nr_args_t args = {};
bool started = false; bool started = false;

1
srsenb/hdr/stack/rrc/rrc.h
Unescape Escape View File

@ -140,7 +140,6 @@ private:
class ue; class ue;
// args // args
srslte::task_sched_handle task_sched; srslte::task_sched_handle task_sched;
srslte::byte_buffer_pool* pool = nullptr;
phy_interface_rrc_lte* phy = nullptr; phy_interface_rrc_lte* phy = nullptr;
mac_interface_rrc* mac = nullptr; mac_interface_rrc* mac = nullptr;
rlc_interface_rrc* rlc = nullptr; rlc_interface_rrc* rlc = nullptr;

7
srsenb/hdr/stack/rrc/rrc_mobility.h
Unescape Escape View File

@ -66,10 +66,9 @@ private:
uint32_t src_pci); uint32_t src_pci);
bool apply_ho_prep_cfg(const asn1::rrc::ho_prep_info_r8_ies_s& ho_prep, const asn1::s1ap::ho_request_s& ho_req_msg); bool apply_ho_prep_cfg(const asn1::rrc::ho_prep_info_r8_ies_s& ho_prep, const asn1::s1ap::ho_request_s& ho_req_msg);
rrc::ue* rrc_ue = nullptr; rrc::ue* rrc_ue = nullptr;
rrc* rrc_enb = nullptr; rrc* rrc_enb = nullptr;
srslte::byte_buffer_pool* pool = nullptr; srslog::basic_logger& logger;
srslog::basic_logger& logger;
// vars // vars
asn1::rrc::meas_cfg_s current_meas_cfg; asn1::rrc::meas_cfg_s current_meas_cfg;

10
srsenb/hdr/stack/rrc/rrc_nr.h
Unescape Escape View File

@ -106,9 +106,8 @@ public:
// setters // setters
private: private:
srslte::byte_buffer_pool* pool = nullptr; rrc_nr* parent;
rrc_nr* parent; uint16_t rnti;
uint16_t rnti;
// state // state
rrc_nr_state_t state = rrc_nr_state_t::RRC_IDLE; rrc_nr_state_t state = rrc_nr_state_t::RRC_IDLE;
@ -128,9 +127,8 @@ private:
ngap_interface_rrc_nr* ngap = nullptr; ngap_interface_rrc_nr* ngap = nullptr;
// args // args
srslte::byte_buffer_pool* pool = nullptr; srslte::log_ref m_log;
srslte::log_ref m_log; srslte::timer_handler* timers = nullptr;
srslte::timer_handler* timers = nullptr;
// derived // derived
uint32_t slot_dur_ms = 0; uint32_t slot_dur_ms = 0;

1
srsenb/hdr/stack/rrc/rrc_ue.h
Unescape Escape View File

@ -105,7 +105,6 @@ public:
private: private:
// args // args
srslte::byte_buffer_pool* pool = nullptr;
srslte::timer_handler::unique_timer activity_timer; srslte::timer_handler::unique_timer activity_timer;
/// cached ASN1 fields for RRC config update checking, and ease of context transfer during HO /// cached ASN1 fields for RRC config update checking, and ease of context transfer during HO

1
srsenb/hdr/stack/upper/gtpu.h
Unescape Escape View File

@ -63,7 +63,6 @@ private:
void rem_tunnel(uint32_t teidin); void rem_tunnel(uint32_t teidin);
srslte::byte_buffer_pool* pool = nullptr;
stack_interface_gtpu_lte* stack = nullptr; stack_interface_gtpu_lte* stack = nullptr;
bool enable_mbsfn = false; bool enable_mbsfn = false;

1
srsenb/hdr/stack/upper/pdcp.h
Unescape Escape View File

@ -107,7 +107,6 @@ private:
gtpu_interface_pdcp* gtpu; gtpu_interface_pdcp* gtpu;
srslte::task_sched_handle task_sched; srslte::task_sched_handle task_sched;
srslog::basic_logger& logger; srslog::basic_logger& logger;
srslte::byte_buffer_pool* pool;
}; };
} // namespace srsenb } // namespace srsenb

11
srsenb/hdr/stack/upper/pdcp_nr.h
Unescape Escape View File

@ -100,12 +100,11 @@ private:
}; };
// args // args
pdcp_nr_args_t m_args = {}; pdcp_nr_args_t m_args = {};
srslte::byte_buffer_pool* pool = nullptr; srslte::log_ref m_log;
srslte::log_ref m_log; rlc_interface_pdcp_nr* m_rlc = nullptr;
rlc_interface_pdcp_nr* m_rlc = nullptr; rrc_interface_pdcp_nr* m_rrc = nullptr;
rrc_interface_pdcp_nr* m_rrc = nullptr; sdap_interface_pdcp_nr* m_sdap = nullptr;
sdap_interface_pdcp_nr* m_sdap = nullptr;
std::map<uint32_t, user_interface> users; std::map<uint32_t, user_interface> users;

11
srsenb/hdr/stack/upper/rlc.h
Unescape Escape View File

@ -89,12 +89,11 @@ private:
std::map<uint32_t, user_interface> users; std::map<uint32_t, user_interface> users;
std::vector<mch_service_t> mch_services; std::vector<mch_service_t> mch_services;
mac_interface_rlc* mac; mac_interface_rlc* mac;
pdcp_interface_rlc* pdcp; pdcp_interface_rlc* pdcp;
rrc_interface_rlc* rrc; rrc_interface_rlc* rrc;
srslog::basic_logger& logger; srslog::basic_logger& logger;
srslte::byte_buffer_pool* pool; srslte::timer_handler* timers;
srslte::timer_handler* timers;
}; };
} // namespace srsenb } // namespace srsenb

11
srsenb/hdr/stack/upper/rlc_nr.h
Unescape Escape View File

@ -79,12 +79,11 @@ private:
}; };
// args // args
srslte::byte_buffer_pool* pool = nullptr; srslte::log_ref m_log;
srslte::log_ref m_log; srslte::timer_handler* timers = nullptr;
srslte::timer_handler* timers = nullptr; mac_interface_rlc_nr* m_mac = nullptr;
mac_interface_rlc_nr* m_mac = nullptr; pdcp_interface_rlc_nr* m_pdcp = nullptr;
pdcp_interface_rlc_nr* m_pdcp = nullptr; rrc_interface_rlc_nr* m_rrc = nullptr;
rrc_interface_rlc_nr* m_rrc = nullptr;
// state // state
std::map<uint32_t, user_interface> users; std::map<uint32_t, user_interface> users;

1
srsenb/hdr/stack/upper/s1ap.h
Unescape Escape View File

@ -102,7 +102,6 @@ private:
rrc_interface_s1ap* rrc = nullptr; rrc_interface_s1ap* rrc = nullptr;
s1ap_args_t args; s1ap_args_t args;
srslog::basic_logger& logger; srslog::basic_logger& logger;
srslte::byte_buffer_pool* pool = nullptr;
srsenb::stack_interface_s1ap_lte* stack = nullptr; srsenb::stack_interface_s1ap_lte* stack = nullptr;
srslte::task_sched_handle task_sched; srslte::task_sched_handle task_sched;

7
srsenb/src/enb.cc
Unescape Escape View File

@ -25,10 +25,7 @@
namespace srsenb { namespace srsenb {
enb::enb(srslog::sink& log_sink) : enb::enb(srslog::sink& log_sink) :
started(false), started(false), log_sink(log_sink), enb_log(srslog::fetch_basic_logger("ENB", log_sink, false))
log_sink(log_sink),
enb_log(srslog::fetch_basic_logger("ENB", log_sink, false)),
pool(srslte::byte_buffer_pool::get_instance(ENB_POOL_SIZE))
{ {
// print build info // print build info
std::cout << std::endl << get_build_string() << std::endl << std::endl; std::cout << std::endl << get_build_string() << std::endl << std::endl;
@ -55,7 +52,7 @@ int enb::init(const all_args_t& args_, srslte::logger* logger_)
return SRSLTE_ERROR; return SRSLTE_ERROR;
} }
pool->enable_logger(true); srslte::byte_buffer_pool::get_instance()->enable_logger(true);
// Create layers // Create layers
if (args.stack.type == "lte") { if (args.stack.type == "lte") {

2
srsenb/src/stack/enb_stack_lte.cc
Unescape Escape View File

@ -43,8 +43,6 @@ enb_stack_lte::enb_stack_lte(srslte::logger* logger_, srslog::sink& log_sink) :
mme_task_queue = task_sched.make_task_queue(); mme_task_queue = task_sched.make_task_queue();
gtpu_task_queue = task_sched.make_task_queue(); gtpu_task_queue = task_sched.make_task_queue();
// sync_queue is added in init() // sync_queue is added in init()
pool = byte_buffer_pool::get_instance();
} }
enb_stack_lte::~enb_stack_lte() enb_stack_lte::~enb_stack_lte()

2
srsenb/src/stack/mac/mac_nr.cc
Unescape Escape View File

@ -20,7 +20,7 @@
namespace srsenb { namespace srsenb {
mac_nr::mac_nr() : pool(srslte::byte_buffer_pool::get_instance()), log_h("MAC") mac_nr::mac_nr() : log_h("MAC")
{ {
bcch_bch_payload = srslte::make_byte_buffer(); bcch_bch_payload = srslte::make_byte_buffer();

1
srsenb/src/stack/mac/ue.cc
Unescape Escape View File

@ -49,7 +49,6 @@ ue::ue(uint16_t rnti_,
rx_used_buffers(nof_cells_), rx_used_buffers(nof_cells_),
ta_fsm(this) ta_fsm(this)
{ {
srslte::byte_buffer_pool* pool = srslte::byte_buffer_pool::get_instance();
tx_payload_buffer.resize(nof_cells_); tx_payload_buffer.resize(nof_cells_);
for (auto& carrier_buffers : tx_payload_buffer) { for (auto& carrier_buffers : tx_payload_buffer) {
for (auto& harq_buffers : carrier_buffers) { for (auto& harq_buffers : carrier_buffers) {

2
srsenb/src/stack/rrc/rrc.cc
Unescape Escape View File

@ -51,8 +51,6 @@ void rrc::init(const rrc_cfg_t& cfg_,
gtpu = gtpu_; gtpu = gtpu_;
s1ap = s1ap_; s1ap = s1ap_;
pool = srslte::byte_buffer_pool::get_instance();
cfg = cfg_; cfg = cfg_;
if (cfg.sibs[12].type() == asn1::rrc::sys_info_r8_ies_s::sib_type_and_info_item_c_::types::sib13_v920 && if (cfg.sibs[12].type() == asn1::rrc::sys_info_r8_ies_s::sib_type_and_info_item_c_::types::sib13_v920 &&

6
srsenb/src/stack/rrc/rrc_mobility.cc
Unescape Escape View File

@ -184,11 +184,7 @@ uint16_t rrc::start_ho_ue_resource_alloc(const asn1::s1ap::ho_request_s&
************************************************************************************************/ ************************************************************************************************/
rrc::ue::rrc_mobility::rrc_mobility(rrc::ue* outer_ue) : rrc::ue::rrc_mobility::rrc_mobility(rrc::ue* outer_ue) :
base_t(outer_ue->parent->logger), base_t(outer_ue->parent->logger), rrc_ue(outer_ue), rrc_enb(outer_ue->parent), logger(outer_ue->parent->logger)
rrc_ue(outer_ue),
rrc_enb(outer_ue->parent),
pool(outer_ue->pool),
logger(outer_ue->parent->logger)
{} {}
//! Method to add Mobility Info to a RRC Connection Reconfiguration Message //! Method to add Mobility Info to a RRC Connection Reconfiguration Message

6
srsenb/src/stack/rrc/rrc_nr.cc
Unescape Escape View File

@ -19,9 +19,7 @@ using namespace asn1::rrc_nr;
namespace srsenb { namespace srsenb {
rrc_nr::rrc_nr(srslte::timer_handler* timers_) : rrc_nr::rrc_nr(srslte::timer_handler* timers_) : m_log("RRC"), timers(timers_) {}
m_log("RRC"), pool(srslte::byte_buffer_pool::get_instance()), timers(timers_)
{}
void rrc_nr::init(const rrc_nr_cfg_t& cfg_, void rrc_nr::init(const rrc_nr_cfg_t& cfg_,
phy_interface_stack_nr* phy_, phy_interface_stack_nr* phy_,
@ -333,8 +331,6 @@ void rrc_nr::write_pdu(uint16_t rnti, uint32_t lcid, srslte::unique_byte_buffer_
*******************************************************************************/ *******************************************************************************/
rrc_nr::ue::ue(rrc_nr* parent_, uint16_t rnti_) : parent(parent_), rnti(rnti_) rrc_nr::ue::ue(rrc_nr* parent_, uint16_t rnti_) : parent(parent_), rnti(rnti_)
{ {
pool = srslte::byte_buffer_pool::get_instance();
// setup periodic RRCSetup send // setup periodic RRCSetup send
rrc_setup_periodic_timer = parent->timers->get_unique_timer(); rrc_setup_periodic_timer = parent->timers->get_unique_timer();
rrc_setup_periodic_timer.set(5000, [this](uint32_t tid) { rrc_setup_periodic_timer.set(5000, [this](uint32_t tid) {

1
srsenb/src/stack/rrc/rrc_ue.cc
Unescape Escape View File

@ -33,7 +33,6 @@ namespace srsenb {
rrc::ue::ue(rrc* outer_rrc, uint16_t rnti_, const sched_interface::ue_cfg_t& sched_ue_cfg) : rrc::ue::ue(rrc* outer_rrc, uint16_t rnti_, const sched_interface::ue_cfg_t& sched_ue_cfg) :
parent(outer_rrc), parent(outer_rrc),
rnti(rnti_), rnti(rnti_),
pool(srslte::byte_buffer_pool::get_instance()),
phy_rrc_dedicated_list(sched_ue_cfg.supported_cc_list.size()), phy_rrc_dedicated_list(sched_ue_cfg.supported_cc_list.size()),
ue_cell_list(parent->cfg, *outer_rrc->cell_res_list, *outer_rrc->cell_common_list), ue_cell_list(parent->cfg, *outer_rrc->cell_res_list, *outer_rrc->cell_common_list),
bearer_list(rnti_, parent->cfg, outer_rrc->gtpu), bearer_list(rnti_, parent->cfg, outer_rrc->gtpu),

1
srsenb/src/stack/upper/gtpu.cc
Unescape Escape View File

@ -34,7 +34,6 @@ int gtpu::init(std::string gtp_bind_addr_,
pdcp = pdcp_; pdcp = pdcp_;
gtp_bind_addr = gtp_bind_addr_; gtp_bind_addr = gtp_bind_addr_;
mme_addr = mme_addr_; mme_addr = mme_addr_;
pool = byte_buffer_pool::get_instance();
stack = stack_; stack = stack_;
char errbuf[128] = {}; char errbuf[128] = {};

2
srsenb/src/stack/upper/pdcp.cc
Unescape Escape View File

@ -16,7 +16,7 @@
namespace srsenb { namespace srsenb {
pdcp::pdcp(srslte::task_sched_handle task_sched_, srslog::basic_logger& logger_) : pdcp::pdcp(srslte::task_sched_handle task_sched_, srslog::basic_logger& logger_) :
task_sched(task_sched_), logger(logger_), pool(srslte::byte_buffer_pool::get_instance()) task_sched(task_sched_), logger(logger_)
{} {}
void pdcp::init(rlc_interface_pdcp* rlc_, rrc_interface_pdcp* rrc_, gtpu_interface_pdcp* gtpu_) void pdcp::init(rlc_interface_pdcp* rlc_, rrc_interface_pdcp* rrc_, gtpu_interface_pdcp* gtpu_)

3
srsenb/src/stack/upper/pdcp_nr.cc
Unescape Escape View File

@ -15,8 +15,7 @@
namespace srsenb { namespace srsenb {
pdcp_nr::pdcp_nr(srslte::task_sched_handle task_sched_, const char* logname) : pdcp_nr::pdcp_nr(srslte::task_sched_handle task_sched_, const char* logname) : task_sched(task_sched_), m_log(logname)
task_sched(task_sched_), m_log(logname), pool(srslte::byte_buffer_pool::get_instance())
{} {}
void pdcp_nr::init(const pdcp_nr_args_t& args_, void pdcp_nr::init(const pdcp_nr_args_t& args_,

2
srsenb/src/stack/upper/rlc.cc
Unescape Escape View File

@ -25,8 +25,6 @@ void rlc::init(pdcp_interface_rlc* pdcp_,
mac = mac_; mac = mac_;
timers = timers_; timers = timers_;
pool = srslte::byte_buffer_pool::get_instance();
pthread_rwlock_init(&rwlock, nullptr); pthread_rwlock_init(&rwlock, nullptr);
} }

2
srsenb/src/stack/upper/rlc_nr.cc
Unescape Escape View File

@ -15,7 +15,7 @@
namespace srsenb { namespace srsenb {
rlc_nr::rlc_nr(const char* logname) : m_log(logname), pool(srslte::byte_buffer_pool::get_instance()) {} rlc_nr::rlc_nr(const char* logname) : m_log(logname) {}
void rlc_nr::init(pdcp_interface_rlc_nr* pdcp_, void rlc_nr::init(pdcp_interface_rlc_nr* pdcp_,
rrc_interface_rlc_nr* rrc_, rrc_interface_rlc_nr* rrc_,

1
srsenb/src/stack/upper/s1ap.cc
Unescape Escape View File

@ -227,7 +227,6 @@ int s1ap::init(s1ap_args_t args_, rrc_interface_s1ap* rrc_, srsenb::stack_interf
rrc = rrc_; rrc = rrc_;
args = args_; args = args_;
stack = stack_; stack = stack_;
pool = srslte::byte_buffer_pool::get_instance();
build_tai_cgi(); build_tai_cgi();

3
srsenb/test/upper/test_helpers.h
Unescape Escape View File

@ -224,8 +224,7 @@ bool unpack_asn1(ASN1Type& asn1obj, srslte::const_byte_span pdu)
inline void copy_msg_to_buffer(srslte::unique_byte_buffer_t& pdu, srslte::const_byte_span msg) inline void copy_msg_to_buffer(srslte::unique_byte_buffer_t& pdu, srslte::const_byte_span msg)
{ {
srslte::byte_buffer_pool* pool = srslte::byte_buffer_pool::get_instance(); pdu = srslte::make_byte_buffer();
pdu = srslte::make_byte_buffer();
memcpy(pdu->msg, msg.data(), msg.size()); memcpy(pdu->msg, msg.data(), msg.size());
pdu->N_bytes = msg.size(); pdu->N_bytes = msg.size();
} }

5
srsepc/hdr/mme/mme.h
Unescape Escape View File

@ -63,9 +63,8 @@ private:
s1ap* m_s1ap; s1ap* m_s1ap;
mme_gtpc* m_mme_gtpc; mme_gtpc* m_mme_gtpc;
bool m_running; bool m_running;
srslte::byte_buffer_pool* m_pool; fd_set m_set;
fd_set m_set;
// Timer map // Timer map
std::vector<mme_timer_t> timers; std::vector<mme_timer_t> timers;

11
srsepc/hdr/mme/nas.h
Unescape Escape View File

@ -251,12 +251,11 @@ public:
sec_ctx_t m_sec_ctx = {}; sec_ctx_t m_sec_ctx = {};
private: private:
srslte::byte_buffer_pool* m_pool = nullptr; srslog::basic_logger& m_logger = srslog::fetch_basic_logger("NAS");
srslog::basic_logger& m_logger = srslog::fetch_basic_logger("NAS"); gtpc_interface_nas* m_gtpc = nullptr;
gtpc_interface_nas* m_gtpc = nullptr; s1ap_interface_nas* m_s1ap = nullptr;
s1ap_interface_nas* m_s1ap = nullptr; hss_interface_nas* m_hss = nullptr;
hss_interface_nas* m_hss = nullptr; mme_interface_nas* m_mme = nullptr;
mme_interface_nas* m_mme = nullptr;
uint16_t m_mcc = 0; uint16_t m_mcc = 0;
uint16_t m_mnc = 0; uint16_t m_mnc = 0;

3
srsepc/hdr/mme/s1ap.h
Unescape Escape View File

@ -125,8 +125,7 @@ private:
static s1ap* m_instance; static s1ap* m_instance;
uint32_t m_plmn; uint32_t m_plmn;
srslte::byte_buffer_pool* m_pool;
hss_interface_nas* m_hss; hss_interface_nas* m_hss;
int m_s1mme; int m_s1mme;

3
srsepc/hdr/mme/s1ap_ctx_mngmt_proc.h
Unescape Escape View File

@ -48,8 +48,7 @@ private:
s1ap_args_t m_s1ap_args; s1ap_args_t m_s1ap_args;
mme_gtpc* m_mme_gtpc; mme_gtpc* m_mme_gtpc;
srslte::byte_buffer_pool* m_pool;
}; };
} // namespace srsepc } // namespace srsepc

3
srsepc/hdr/mme/s1ap_erab_mngmt_proc.h
Unescape Escape View File

@ -53,8 +53,7 @@ private:
s1ap_args_t m_s1ap_args; s1ap_args_t m_s1ap_args;
mme_gtpc* m_mme_gtpc = nullptr; mme_gtpc* m_mme_gtpc = nullptr;
srslte::byte_buffer_pool* m_pool = nullptr;
}; };
} // namespace srsepc } // namespace srsepc

3
srsepc/hdr/mme/s1ap_paging.h
Unescape Escape View File

@ -41,8 +41,7 @@ private:
s1ap* m_s1ap; s1ap* m_s1ap;
srslog::basic_logger& m_logger = srslog::fetch_basic_logger("S1AP"); srslog::basic_logger& m_logger = srslog::fetch_basic_logger("S1AP");
s1ap_args_t m_s1ap_args; s1ap_args_t m_s1ap_args;
srslte::byte_buffer_pool* m_pool;
}; };
} // namespace srsepc } // namespace srsepc

3
srsepc/hdr/spgw/gtpc.h
Unescape Escape View File

@ -82,8 +82,7 @@ public:
std::set<uint32_t> m_ue_ip_addr_pool; std::set<uint32_t> m_ue_ip_addr_pool;
std::map<uint64_t, struct in_addr> m_imsi_to_ip; std::map<uint64_t, struct in_addr> m_imsi_to_ip;
srslog::basic_logger& m_logger = srslog::fetch_basic_logger("SPGW GTPC"); srslog::basic_logger& m_logger = srslog::fetch_basic_logger("SPGW GTPC");
srslte::byte_buffer_pool* m_pool;
}; };
inline int spgw::gtpc::get_s11() inline int spgw::gtpc::get_s11()

1
srsepc/src/mme/mme.cc
Unescape Escape View File

@ -24,7 +24,6 @@ pthread_mutex_t mme_instance_mutex = PTHREAD_MUTEX_INITIALIZER;
mme::mme() : m_running(false), thread("MME") mme::mme() : m_running(false), thread("MME")
{ {
m_pool = srslte::byte_buffer_pool::get_instance();
return; return;
} }

13
srsepc/src/mme/nas.cc
Unescape Escape View File

@ -23,7 +23,6 @@
namespace srsepc { namespace srsepc {
nas::nas(const nas_init_t& args, const nas_if_t& itf) : nas::nas(const nas_init_t& args, const nas_if_t& itf) :
m_pool(srslte::byte_buffer_pool::get_instance()),
m_gtpc(itf.gtpc), m_gtpc(itf.gtpc),
m_s1ap(itf.s1ap), m_s1ap(itf.s1ap),
m_hss(itf.hss), m_hss(itf.hss),
@ -328,9 +327,8 @@ bool nas::handle_guti_attach_request_unknown_ue(uint32_t
const nas_if_t& itf) const nas_if_t& itf)
{ {
nas* nas_ctx; nas* nas_ctx;
srslte::byte_buffer_pool* pool = srslte::byte_buffer_pool::get_instance(); srslte::byte_buffer_t* nas_tx;
srslte::byte_buffer_t* nas_tx;
// Interfaces // Interfaces
s1ap_interface_nas* s1ap = itf.s1ap; s1ap_interface_nas* s1ap = itf.s1ap;
@ -566,7 +564,6 @@ bool nas::handle_service_request(uint32_t m_tmsi,
bool mac_valid = false; bool mac_valid = false;
LIBLTE_MME_SERVICE_REQUEST_MSG_STRUCT service_req; LIBLTE_MME_SERVICE_REQUEST_MSG_STRUCT service_req;
srslte::byte_buffer_pool* pool = srslte::byte_buffer_pool::get_instance();
// Interfaces // Interfaces
s1ap_interface_nas* s1ap = itf.s1ap; s1ap_interface_nas* s1ap = itf.s1ap;
@ -771,8 +768,7 @@ bool nas::handle_tracking_area_update_request(uint32_t m_tmsi,
const nas_init_t& args, const nas_init_t& args,
const nas_if_t& itf) const nas_if_t& itf)
{ {
auto& nas_logger = srslog::fetch_basic_logger("NAS"); auto& nas_logger = srslog::fetch_basic_logger("NAS");
srslte::byte_buffer_pool* pool = srslte::byte_buffer_pool::get_instance();
nas_logger.info("Tracking Area Update Request -- S-TMSI 0x%x", m_tmsi); nas_logger.info("Tracking Area Update Request -- S-TMSI 0x%x", m_tmsi);
srslte::console("Tracking Area Update Request -- S-TMSI 0x%x\n", m_tmsi); srslte::console("Tracking Area Update Request -- S-TMSI 0x%x\n", m_tmsi);
@ -1146,8 +1142,7 @@ bool nas::handle_tracking_area_update_request(srslte::byte_buffer_t* nas_rx)
srslte::console("Warning: Tracking Area Update Request messages not handled yet.\n"); srslte::console("Warning: Tracking Area Update Request messages not handled yet.\n");
m_logger.warning("Warning: Tracking Area Update Request messages not handled yet."); m_logger.warning("Warning: Tracking Area Update Request messages not handled yet.");
srslte::byte_buffer_pool* pool = srslte::byte_buffer_pool::get_instance(); srslte::byte_buffer_t* nas_tx;
srslte::byte_buffer_t* nas_tx;
/* TAU handling unsupported, therefore send TAU reject with cause IMPLICITLY DETACHED. /* TAU handling unsupported, therefore send TAU reject with cause IMPLICITLY DETACHED.
* this will trigger full re-attach by the UE, instead of going to a TAU request loop */ * this will trigger full re-attach by the UE, instead of going to a TAU request loop */

7
srsepc/src/mme/s1ap.cc
Unescape Escape View File

@ -22,10 +22,7 @@ namespace srsepc {
s1ap* s1ap::m_instance = NULL; s1ap* s1ap::m_instance = NULL;
pthread_mutex_t s1ap_instance_mutex = PTHREAD_MUTEX_INITIALIZER; pthread_mutex_t s1ap_instance_mutex = PTHREAD_MUTEX_INITIALIZER;
s1ap::s1ap() : m_s1mme(-1), m_next_mme_ue_s1ap_id(1), m_mme_gtpc(NULL), m_pool(NULL) s1ap::s1ap() : m_s1mme(-1), m_next_mme_ue_s1ap_id(1), m_mme_gtpc(NULL) {}
{
return;
}
s1ap::~s1ap() s1ap::~s1ap()
{ {
@ -54,8 +51,6 @@ void s1ap::cleanup(void)
int s1ap::init(s1ap_args_t s1ap_args) int s1ap::init(s1ap_args_t s1ap_args)
{ {
m_pool = srslte::byte_buffer_pool::get_instance();
m_s1ap_args = s1ap_args; m_s1ap_args = s1ap_args;
srslte::s1ap_mccmnc_to_plmn(s1ap_args.mcc, s1ap_args.mnc, &m_plmn); srslte::s1ap_mccmnc_to_plmn(s1ap_args.mcc, s1ap_args.mnc, &m_plmn);
m_next_m_tmsi = rand(); m_next_m_tmsi = rand();

1
srsepc/src/mme/s1ap_ctx_mngmt_proc.cc
Unescape Escape View File

@ -58,7 +58,6 @@ void s1ap_ctx_mngmt_proc::init()
m_s1ap = s1ap::get_instance(); m_s1ap = s1ap::get_instance();
m_mme_gtpc = mme_gtpc::get_instance(); m_mme_gtpc = mme_gtpc::get_instance();
m_s1ap_args = m_s1ap->m_s1ap_args; m_s1ap_args = m_s1ap->m_s1ap_args;
m_pool = srslte::byte_buffer_pool::get_instance();
} }
bool s1ap_ctx_mngmt_proc::send_initial_context_setup_request(nas* nas_ctx, uint16_t erab_to_setup) bool s1ap_ctx_mngmt_proc::send_initial_context_setup_request(nas* nas_ctx, uint16_t erab_to_setup)

1
srsepc/src/mme/s1ap_erab_mngmt_proc.cc
Unescape Escape View File

@ -57,7 +57,6 @@ void s1ap_erab_mngmt_proc::init()
{ {
m_s1ap = s1ap::get_instance(); m_s1ap = s1ap::get_instance();
m_s1ap_args = m_s1ap->m_s1ap_args; m_s1ap_args = m_s1ap->m_s1ap_args;
m_pool = srslte::byte_buffer_pool::get_instance();
} }
bool s1ap_erab_mngmt_proc::send_erab_release_command(uint32_t enb_ue_s1ap_id, bool s1ap_erab_mngmt_proc::send_erab_release_command(uint32_t enb_ue_s1ap_id,

1
srsepc/src/mme/s1ap_paging.cc
Unescape Escape View File

@ -29,7 +29,6 @@ void s1ap_paging::init()
m_s1ap = s1ap::get_instance(); m_s1ap = s1ap::get_instance();
m_mme = mme::get_instance(); m_mme = mme::get_instance();
m_s1ap_args = m_s1ap->m_s1ap_args; m_s1ap_args = m_s1ap->m_s1ap_args;
m_pool = srslte::byte_buffer_pool::get_instance();
} }
bool s1ap_paging::send_paging(uint64_t imsi, uint16_t erab_to_setup) bool s1ap_paging::send_paging(uint64_t imsi, uint16_t erab_to_setup)

1
srsepc/src/spgw/gtpc.cc
Unescape Escape View File

@ -48,7 +48,6 @@ int spgw::gtpc::init(spgw_args_t* args,
const std::map<std::string, uint64_t>& ip_to_imsi) const std::map<std::string, uint64_t>& ip_to_imsi)
{ {
int err; int err;
m_pool = srslte::byte_buffer_pool::get_instance();
// Init interfaces // Init interfaces
m_spgw = spgw; m_spgw = spgw;

1
srsue/hdr/stack/mac/mac.h
Unescape Escape View File

@ -152,7 +152,6 @@ private:
/* Queue to dispatch stack tasks */ /* Queue to dispatch stack tasks */
srslte::task_multiqueue::queue_handle stack_task_dispatch_queue; srslte::task_multiqueue::queue_handle stack_task_dispatch_queue;
srslte::byte_buffer_pool* pool = nullptr;
// pointer to MAC PCAP object // pointer to MAC PCAP object
srslte::mac_pcap* pcap = nullptr; srslte::mac_pcap* pcap = nullptr;

8
srsue/hdr/stack/mac_nr/mac_nr.h
Unescape Escape View File

@ -69,7 +69,6 @@ public:
void process_pdus(); void process_pdus();
private: private:
void handle_pdu(srslte::unique_byte_buffer_t pdu); void handle_pdu(srslte::unique_byte_buffer_t pdu);
void get_ul_data(const mac_nr_grant_ul_t& grant, phy_interface_stack_nr::tx_request_t* tx_request); void get_ul_data(const mac_nr_grant_ul_t& grant, phy_interface_stack_nr::tx_request_t* tx_request);
@ -85,10 +84,9 @@ private:
rlc_interface_mac* rlc = nullptr; rlc_interface_mac* rlc = nullptr;
srslte::ext_task_sched_handle task_sched; srslte::ext_task_sched_handle task_sched;
std::unique_ptr<srslte::mac_pcap> pcap = nullptr; std::unique_ptr<srslte::mac_pcap> pcap = nullptr;
srslog::basic_logger& logger; srslog::basic_logger& logger;
srslte::byte_buffer_pool* pool = nullptr; mac_nr_args_t args = {};
mac_nr_args_t args = {};
bool started = false; bool started = false;

1
srsue/hdr/stack/rrc/rrc.h
Unescape Escape View File

@ -175,7 +175,6 @@ private:
stack_interface_rrc* stack = nullptr; stack_interface_rrc* stack = nullptr;
srslte::task_sched_handle task_sched; srslte::task_sched_handle task_sched;
srslte::byte_buffer_pool* pool = nullptr;
srslog::basic_logger& logger; srslog::basic_logger& logger;
phy_interface_rrc_lte* phy = nullptr; phy_interface_rrc_lte* phy = nullptr;
mac_interface_rrc* mac = nullptr; mac_interface_rrc* mac = nullptr;

5
srsue/hdr/stack/upper/gw.h
Unescape Escape View File

@ -69,9 +69,8 @@ public:
private: private:
static const int GW_THREAD_PRIO = -1; static const int GW_THREAD_PRIO = -1;
stack_interface_gw* stack = nullptr; stack_interface_gw* stack = nullptr;
srslte::byte_buffer_pool* pool = nullptr; srslte::logger* old_logger = nullptr;
srslte::logger* old_logger = nullptr;
gw_args_t args = {}; gw_args_t args = {};

9
srsue/hdr/stack/upper/nas.h
Unescape Escape View File

@ -73,11 +73,10 @@ public:
void start_pcap(srslte::nas_pcap* pcap_) { pcap = pcap_; } void start_pcap(srslte::nas_pcap* pcap_) { pcap = pcap_; }
private: private:
srslte::byte_buffer_pool* pool = nullptr; srslog::basic_logger& logger;
srslog::basic_logger& logger; rrc_interface_nas* rrc = nullptr;
rrc_interface_nas* rrc = nullptr; usim_interface_nas* usim = nullptr;
usim_interface_nas* usim = nullptr; gw_interface_nas* gw = nullptr;
gw_interface_nas* gw = nullptr;
bool running = false; bool running = false;

3
srsue/hdr/ue.h
Unescape Escape View File

@ -110,8 +110,7 @@ private:
srslog::sink& log_sink; srslog::sink& log_sink;
srslog::basic_logger& logger; srslog::basic_logger& logger;
all_args_t args; all_args_t args;
srslte::byte_buffer_pool* pool = nullptr;
// Helper functions // Helper functions
int parse_args(const all_args_t& args); // parse and validate arguments int parse_args(const all_args_t& args); // parse and validate arguments

2
srsue/src/stack/mac/mac.cc
Unescape Escape View File

@ -45,8 +45,6 @@ mac::mac(const char* logname, ext_task_sched_handle task_sched_) :
srslte_softbuffer_rx_init(&pch_softbuffer, 100); srslte_softbuffer_rx_init(&pch_softbuffer, 100);
srslte_softbuffer_rx_init(&mch_softbuffer, 100); srslte_softbuffer_rx_init(&mch_softbuffer, 100);
pool = srslte::byte_buffer_pool::get_instance();
// Keep initialising members // Keep initialising members
bzero(&metrics, sizeof(mac_metrics_t)); bzero(&metrics, sizeof(mac_metrics_t));
clear_rntis(); clear_rntis();

2
srsue/src/stack/mac_nr/mac_nr.cc
Unescape Escape View File

@ -15,7 +15,7 @@
namespace srsue { namespace srsue {
mac_nr::mac_nr(srslte::ext_task_sched_handle task_sched_) : mac_nr::mac_nr(srslte::ext_task_sched_handle task_sched_) :
pool(srslte::byte_buffer_pool::get_instance()), task_sched(task_sched_), logger(srslog::fetch_basic_logger("MAC")) task_sched(task_sched_), logger(srslog::fetch_basic_logger("MAC"))
{ {
tx_buffer = srslte::make_byte_buffer(); tx_buffer = srslte::make_byte_buffer();
rlc_buffer = srslte::make_byte_buffer(); rlc_buffer = srslte::make_byte_buffer();

1
srsue/src/stack/rrc/rrc.cc
Unescape Escape View File

@ -104,7 +104,6 @@ void rrc::init(phy_interface_rrc_lte* phy_,
#endif #endif
const rrc_args_t& args_) const rrc_args_t& args_)
{ {
pool = byte_buffer_pool::get_instance();
phy = phy_; phy = phy_;
mac = mac_; mac = mac_;
rlc = rlc_; rlc = rlc_;

7
srsue/src/stack/upper/gw.cc
Unescape Escape View File

@ -25,12 +25,7 @@
namespace srsue { namespace srsue {
gw::gw() : gw::gw() : thread("GW"), logger(srslog::fetch_basic_logger("GW", false)), tft_matcher(logger) {}
thread("GW"),
pool(srslte::byte_buffer_pool::get_instance()),
logger(srslog::fetch_basic_logger("GW", false)),
tft_matcher(logger)
{}
int gw::init(const gw_args_t& args_, srslte::logger* logger_, stack_interface_gw* stack_) int gw::init(const gw_args_t& args_, srslte::logger* logger_, stack_interface_gw* stack_)
{ {

1
srsue/src/stack/upper/nas.cc
Unescape Escape View File

@ -36,7 +36,6 @@ namespace srsue {
********************************************************************/ ********************************************************************/
nas::nas(srslte::task_sched_handle task_sched_) : nas::nas(srslte::task_sched_handle task_sched_) :
pool(byte_buffer_pool::get_instance()),
plmn_searcher(this), plmn_searcher(this),
task_sched(task_sched_), task_sched(task_sched_),
t3402(task_sched_.get_unique_timer()), t3402(task_sched_.get_unique_timer()),

1
srsue/src/ue.cc
Unescape Escape View File

@ -36,7 +36,6 @@ ue::ue(srslog::sink& log_sink) :
{ {
// print build info // print build info
std::cout << std::endl << get_build_string() << std::endl << std::endl; std::cout << std::endl << get_build_string() << std::endl << std::endl;
pool = byte_buffer_pool::get_instance();
} }
ue::~ue() ue::~ue()

5
srsue/test/ttcn3/hdr/ttcn3_drb_interface.h
Unescape Escape View File

@ -27,9 +27,7 @@ using namespace srslte;
class ttcn3_drb_interface : public ttcn3_port_handler class ttcn3_drb_interface : public ttcn3_port_handler
{ {
public: public:
explicit ttcn3_drb_interface(srslog::basic_logger& logger) : explicit ttcn3_drb_interface(srslog::basic_logger& logger) : ttcn3_port_handler(logger) {}
ttcn3_port_handler(logger), pool(byte_buffer_pool::get_instance())
{}
~ttcn3_drb_interface() = default; ~ttcn3_drb_interface() = default;
int init(ss_srb_interface* syssim_, std::string net_ip_, uint32_t net_port_) int init(ss_srb_interface* syssim_, std::string net_ip_, uint32_t net_port_)
@ -133,7 +131,6 @@ private:
} }
ss_srb_interface* syssim = nullptr; ss_srb_interface* syssim = nullptr;
byte_buffer_pool* pool = nullptr;
}; };
#endif // SRSUE_TTCN3_DRB_INTERFACE_H #endif // SRSUE_TTCN3_DRB_INTERFACE_H

2
srsue/test/ttcn3/hdr/ttcn3_syssim.h
Unescape Escape View File

@ -231,8 +231,6 @@ private:
all_args_t args = {}; all_args_t args = {};
srslte::byte_buffer_pool* pool = nullptr;
// Simulator vars // Simulator vars
ttcn3_ue* ue = nullptr; ttcn3_ue* ue = nullptr;
bool running = false; bool running = false;

1
srsue/test/ttcn3/src/ttcn3_syssim.cc
Unescape Escape View File

@ -53,7 +53,6 @@ ttcn3_syssim::ttcn3_syssim(srslte::logger& logger_file_, srslte::logger& logger_
logger_stdout(logger_stdout_), logger_stdout(logger_stdout_),
logger_file(logger_file_), logger_file(logger_file_),
old_logger(&logger_file), old_logger(&logger_file),
pool(byte_buffer_pool::get_instance()),
ue(ue_), ue(ue_),
signal_handler(&running), signal_handler(&running),
timer_handler(create_tti_timer(), [&](uint64_t res) { new_tti_indication(res); }) timer_handler(create_tti_timer(), [&](uint64_t res) { new_tti_indication(res); })

5
srsue/test/upper/nas_test.cc
Unescape Escape View File

@ -361,9 +361,6 @@ int esm_info_request_test()
srsue::usim usim(srslog::fetch_basic_logger("USIM")); srsue::usim usim(srslog::fetch_basic_logger("USIM"));
usim.init(&args); usim.init(&args);
srslte::byte_buffer_pool* pool;
pool = byte_buffer_pool::get_instance();
{ {
srsue::nas nas(&stack.task_sched); srsue::nas nas(&stack.task_sched);
nas_args_t cfg; nas_args_t cfg;
@ -413,8 +410,6 @@ int dedicated_eps_bearer_test()
srsue::usim usim(srslog::fetch_basic_logger("USIM")); srsue::usim usim(srslog::fetch_basic_logger("USIM"));
usim.init(&args); usim.init(&args);
srslte::byte_buffer_pool* pool = byte_buffer_pool::get_instance();
srsue::nas nas(&stack.task_sched); srsue::nas nas(&stack.task_sched);
nas_args_t cfg = {}; nas_args_t cfg = {};
cfg.force_imsi_attach = true; // make sure we get a fresh security context cfg.force_imsi_attach = true; // make sure we get a fresh security context

4
srsue/test/upper/rrc_meas_test.cc
Unescape Escape View File

@ -251,7 +251,6 @@ public:
rrc_test(srslte::log_ref log_, stack_test_dummy* stack_) : rrc_test(srslte::log_ref log_, stack_test_dummy* stack_) :
rrc(stack_, &stack_->task_sched), stack(stack_), mactest(this, &stack_->task_sched) rrc(stack_, &stack_->task_sched), stack(stack_), mactest(this, &stack_->task_sched)
{ {
pool = srslte::byte_buffer_pool::get_instance();
nastest = std::unique_ptr<nas_test>(new nas_test(&stack->task_sched)); nastest = std::unique_ptr<nas_test>(new nas_test(&stack->task_sched));
pdcptest = std::unique_ptr<pdcp_test>(new pdcp_test(log_->get_service_name().c_str(), &stack->task_sched)); pdcptest = std::unique_ptr<pdcp_test>(new pdcp_test(log_->get_service_name().c_str(), &stack->task_sched));
rrcnrtest = std::unique_ptr<rrc_nr_test>(new rrc_nr_test()); rrcnrtest = std::unique_ptr<rrc_nr_test>(new rrc_nr_test());
@ -374,8 +373,7 @@ private:
std::unique_ptr<pdcp_test> pdcptest; std::unique_ptr<pdcp_test> pdcptest;
std::unique_ptr<nas_test> nastest; std::unique_ptr<nas_test> nastest;
std::unique_ptr<rrc_nr_test> rrcnrtest; std::unique_ptr<rrc_nr_test> rrcnrtest;
uint32_t tti = 0; uint32_t tti = 0;
srslte::byte_buffer_pool* pool = nullptr;
}; };
// Test Cell select // Test Cell select

6
srsue/test/upper/tft_test.cc
Unescape Escape View File

@ -106,7 +106,6 @@ uint8_t ipv6_unmatched_packet_lport[] = {
int tft_filter_test_ipv6_combined() int tft_filter_test_ipv6_combined()
{ {
srslog::basic_logger& logger = srslog::fetch_basic_logger("TFT"); srslog::basic_logger& logger = srslog::fetch_basic_logger("TFT");
srslte::byte_buffer_pool* pool = srslte::byte_buffer_pool::get_instance();
srslte::unique_byte_buffer_t ip_msg1, ip_msg2, ip_msg3, ip_msg4, ip_msg5; srslte::unique_byte_buffer_t ip_msg1, ip_msg2, ip_msg3, ip_msg4, ip_msg5;
ip_msg1 = make_byte_buffer(); ip_msg1 = make_byte_buffer();
ip_msg2 = make_byte_buffer(); ip_msg2 = make_byte_buffer();
@ -165,7 +164,6 @@ int tft_filter_test_single_local_port()
{ {
srslog::basic_logger& logger = srslog::fetch_basic_logger("TFT"); srslog::basic_logger& logger = srslog::fetch_basic_logger("TFT");
srslte::byte_buffer_pool* pool = srslte::byte_buffer_pool::get_instance();
srslte::unique_byte_buffer_t ip_msg1, ip_msg2; srslte::unique_byte_buffer_t ip_msg1, ip_msg2;
ip_msg1 = make_byte_buffer(); ip_msg1 = make_byte_buffer();
ip_msg2 = make_byte_buffer(); ip_msg2 = make_byte_buffer();
@ -210,7 +208,6 @@ int tft_filter_test_single_remote_port()
{ {
srslog::basic_logger& logger = srslog::fetch_basic_logger("TFT"); srslog::basic_logger& logger = srslog::fetch_basic_logger("TFT");
srslte::byte_buffer_pool* pool = srslte::byte_buffer_pool::get_instance();
srslte::unique_byte_buffer_t ip_msg1, ip_msg2; srslte::unique_byte_buffer_t ip_msg1, ip_msg2;
ip_msg1 = make_byte_buffer(); ip_msg1 = make_byte_buffer();
ip_msg2 = make_byte_buffer(); ip_msg2 = make_byte_buffer();
@ -255,7 +252,6 @@ int tft_filter_test_ipv4_local_addr()
{ {
srslog::basic_logger& logger = srslog::fetch_basic_logger("TFT"); srslog::basic_logger& logger = srslog::fetch_basic_logger("TFT");
srslte::byte_buffer_pool* pool = srslte::byte_buffer_pool::get_instance();
srslte::unique_byte_buffer_t ip_msg1, ip_msg2; srslte::unique_byte_buffer_t ip_msg1, ip_msg2;
ip_msg1 = make_byte_buffer(); ip_msg1 = make_byte_buffer();
ip_msg2 = make_byte_buffer(); ip_msg2 = make_byte_buffer();
@ -303,7 +299,6 @@ int tft_filter_test_ipv4_remote_addr()
{ {
srslog::basic_logger& logger = srslog::fetch_basic_logger("TFT"); srslog::basic_logger& logger = srslog::fetch_basic_logger("TFT");
srslte::byte_buffer_pool* pool = srslte::byte_buffer_pool::get_instance();
srslte::unique_byte_buffer_t ip_msg1, ip_msg2; srslte::unique_byte_buffer_t ip_msg1, ip_msg2;
ip_msg1 = make_byte_buffer(); ip_msg1 = make_byte_buffer();
ip_msg2 = make_byte_buffer(); ip_msg2 = make_byte_buffer();
@ -350,7 +345,6 @@ int tft_filter_test_ipv4_tos()
{ {
srslog::basic_logger& logger = srslog::fetch_basic_logger("TFT"); srslog::basic_logger& logger = srslog::fetch_basic_logger("TFT");
srslte::byte_buffer_pool* pool = srslte::byte_buffer_pool::get_instance();
srslte::unique_byte_buffer_t ip_msg1, ip_msg2; srslte::unique_byte_buffer_t ip_msg1, ip_msg2;
ip_msg1 = make_byte_buffer(); ip_msg1 = make_byte_buffer();
ip_msg2 = make_byte_buffer(); ip_msg2 = make_byte_buffer();

Write Preview
Loading…
Cancel
Save