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

rename RLC AM class to RLC AM LTE

Browse Source
master
Andre Puschmann 5 years ago
parent 177e880293
commit 03bd63d9ab
7 changed files with 127 additions and 137 deletions
Show Stats Download Patch File Download Diff File

31
lib/include/srslte/upper/rlc_am.h → lib/include/srslte/upper/rlc_am_lte.h
Unescape Escape View File

@ -19,8 +19,8 @@
* *
*/ */
#ifndef SRSLTE_RLC_AM_H #ifndef SRSLTE_RLC_AM_LTE_H
#define SRSLTE_RLC_AM_H #define SRSLTE_RLC_AM_LTE_H
#include "srslte/common/buffer_pool.h" #include "srslte/common/buffer_pool.h"
#include "srslte/common/log.h" #include "srslte/common/log.h"
@ -60,11 +60,10 @@ struct rlc_amd_retx_t{
uint32_t so_end; uint32_t so_end;
}; };
class rlc_am_lte : public rlc_common
class rlc_am : public rlc_common
{ {
public: public:
rlc_am(srslte::log* log_, rlc_am_lte(srslte::log* log_,
uint32_t lcid_, uint32_t lcid_,
srsue::pdcp_interface_rlc* pdcp_, srsue::pdcp_interface_rlc* pdcp_,
srsue::rrc_interface_rlc* rrc_, srsue::rrc_interface_rlc* rrc_,
@ -94,11 +93,11 @@ public:
private: private:
// Transmitter sub-class // Transmitter sub-class
class rlc_am_tx : public timer_callback class rlc_am_lte_tx : public timer_callback
{ {
public: public:
rlc_am_tx(rlc_am* parent_); rlc_am_lte_tx(rlc_am_lte* parent_);
~rlc_am_tx(); ~rlc_am_lte_tx();
bool configure(rlc_config_t cfg_); bool configure(rlc_config_t cfg_);
@ -137,7 +136,7 @@ private:
bool poll_required(); bool poll_required();
bool do_status(); bool do_status();
rlc_am* parent = nullptr; rlc_am_lte* parent = nullptr;
byte_buffer_pool* pool = nullptr; byte_buffer_pool* pool = nullptr;
srslte::log* log = nullptr; srslte::log* log = nullptr;
@ -191,11 +190,11 @@ private:
}; };
// Receiver sub-class // Receiver sub-class
class rlc_am_rx : public timer_callback class rlc_am_lte_rx : public timer_callback
{ {
public: public:
rlc_am_rx(rlc_am* parent_); rlc_am_lte_rx(rlc_am_lte* parent_);
~rlc_am_rx(); ~rlc_am_lte_rx();
bool configure(rlc_am_config_t cfg_); bool configure(rlc_am_config_t cfg_);
void reestablish(); void reestablish();
@ -224,7 +223,7 @@ private:
void print_rx_segments(); void print_rx_segments();
bool add_segment_and_check(rlc_amd_rx_pdu_segments_t *pdu, rlc_amd_rx_pdu_t *segment); bool add_segment_and_check(rlc_amd_rx_pdu_segments_t *pdu, rlc_amd_rx_pdu_t *segment);
rlc_am* parent = nullptr; rlc_am_lte* parent = nullptr;
byte_buffer_pool* pool = nullptr; byte_buffer_pool* pool = nullptr;
srslte::log* log = nullptr; srslte::log* log = nullptr;
@ -282,8 +281,8 @@ private:
static const int poll_periodicity = 8; // After how many data PDUs a status PDU shall be requested static const int poll_periodicity = 8; // After how many data PDUs a status PDU shall be requested
// Rx and Tx objects // Rx and Tx objects
rlc_am_tx tx; rlc_am_lte_tx tx;
rlc_am_rx rx; rlc_am_lte_rx rx;
}; };
/**************************************************************************** /****************************************************************************
@ -315,4 +314,4 @@ bool rlc_am_not_start_aligned(const uint8_t fi);
} // namespace srslte } // namespace srslte
#endif // SRSLTE_RLC_AM_H #endif // SRSLTE_RLC_AM_LTE_H

2
lib/src/upper/CMakeLists.txt
Unescape Escape View File

@ -18,7 +18,7 @@
# and at http://www.gnu.org/licenses/. # and at http://www.gnu.org/licenses/.
# #
file(GLOB SOURCES "*.cc") set(SOURCES gtpu.cc pdcp.cc pdcp_entity_base.cc pdcp_entity_lte.cc pdcp_entity_nr.cc rlc.cc rlc_am_lte.cc rlc_um.cc rlc_tm.cc)
add_library(srslte_upper STATIC ${SOURCES}) add_library(srslte_upper STATIC ${SOURCES})
target_link_libraries(srslte_upper srslte_common srslte_asn1) target_link_libraries(srslte_upper srslte_common srslte_asn1)
install(TARGETS srslte_upper DESTINATION ${LIBRARY_DIR}) install(TARGETS srslte_upper DESTINATION ${LIBRARY_DIR})

4
lib/src/upper/rlc.cc
Unescape Escape View File

@ -20,9 +20,9 @@
*/ */
#include "srslte/upper/rlc.h" #include "srslte/upper/rlc.h"
#include "srslte/upper/rlc_am_lte.h"
#include "srslte/upper/rlc_tm.h" #include "srslte/upper/rlc_tm.h"
#include "srslte/upper/rlc_um.h" #include "srslte/upper/rlc_um.h"
#include "srslte/upper/rlc_am.h"
namespace srslte { namespace srslte {
@ -387,7 +387,7 @@ void rlc::add_bearer(uint32_t lcid, rlc_config_t cnfg)
rlc_entity = new rlc_tm(rlc_log, lcid, pdcp, rrc, timers); rlc_entity = new rlc_tm(rlc_log, lcid, pdcp, rrc, timers);
break; break;
case rlc_mode_t::am: case rlc_mode_t::am:
rlc_entity = new rlc_am(rlc_log, lcid, pdcp, rrc, timers); rlc_entity = new rlc_am_lte(rlc_log, lcid, pdcp, rrc, timers);
break; break;
case rlc_mode_t::um: case rlc_mode_t::um:
rlc_entity = new rlc_um(rlc_log, lcid, pdcp, rrc, timers); rlc_entity = new rlc_um(rlc_log, lcid, pdcp, rrc, timers);

137
lib/src/upper/rlc_am.cc → lib/src/upper/rlc_am_lte.cc
Unescape Escape View File

@ -19,7 +19,7 @@
* *
*/ */
#include "srslte/upper/rlc_am.h" #include "srslte/upper/rlc_am_lte.h"
#include <iostream> #include <iostream>
#include <sstream> #include <sstream>
@ -32,23 +32,17 @@
namespace srslte { namespace srslte {
rlc_am::rlc_am(srslte::log* log_, rlc_am_lte::rlc_am_lte(srslte::log* log_,
uint32_t lcid_, uint32_t lcid_,
srsue::pdcp_interface_rlc* pdcp_, srsue::pdcp_interface_rlc* pdcp_,
srsue::rrc_interface_rlc* rrc_, srsue::rrc_interface_rlc* rrc_,
srslte::timer_handler* timers_) : srslte::timer_handler* timers_) :
log(log_), log(log_), rrc(rrc_), pdcp(pdcp_), timers(timers_), lcid(lcid_), tx(this), rx(this)
rrc(rrc_),
pdcp(pdcp_),
timers(timers_),
lcid(lcid_),
tx(this),
rx(this)
{ {
} }
// Applies new configuration. Must be just reestablished or initiated // Applies new configuration. Must be just reestablished or initiated
bool rlc_am::configure(rlc_config_t cfg_) bool rlc_am_lte::configure(rlc_config_t cfg_)
{ {
// determine bearer name and configure Rx/Tx objects // determine bearer name and configure Rx/Tx objects
rb_name = rrc->get_rb_name(lcid); rb_name = rrc->get_rb_name(lcid);
@ -78,47 +72,47 @@ bool rlc_am::configure(rlc_config_t cfg_)
return true; return true;
} }
void rlc_am::empty_queue() void rlc_am_lte::empty_queue()
{ {
// Drop all messages in TX SDU queue // Drop all messages in TX SDU queue
tx.empty_queue(); tx.empty_queue();
} }
void rlc_am::reestablish() void rlc_am_lte::reestablish()
{ {
log->debug("Reestablished bearer %s\n", rb_name.c_str()); log->debug("Reestablished bearer %s\n", rb_name.c_str());
tx.reestablish(); // calls stop and enables tx again tx.reestablish(); // calls stop and enables tx again
rx.reestablish(); // calls only stop rx.reestablish(); // calls only stop
} }
void rlc_am::stop() void rlc_am_lte::stop()
{ {
log->debug("Stopped bearer %s\n", rb_name.c_str()); log->debug("Stopped bearer %s\n", rb_name.c_str());
tx.stop(); tx.stop();
rx.stop(); rx.stop();
} }
rlc_mode_t rlc_am::get_mode() rlc_mode_t rlc_am_lte::get_mode()
{ {
return rlc_mode_t::am; return rlc_mode_t::am;
} }
uint32_t rlc_am::get_bearer() uint32_t rlc_am_lte::get_bearer()
{ {
return lcid; return lcid;
} }
uint32_t rlc_am::get_num_rx_bytes() uint32_t rlc_am_lte::get_num_rx_bytes()
{ {
return rx.get_num_rx_bytes(); return rx.get_num_rx_bytes();
} }
uint32_t rlc_am::get_num_tx_bytes() uint32_t rlc_am_lte::get_num_tx_bytes()
{ {
return tx.get_num_tx_bytes(); return tx.get_num_tx_bytes();
} }
void rlc_am::reset_metrics() void rlc_am_lte::reset_metrics()
{ {
tx.reset_metrics(); tx.reset_metrics();
rx.reset_metrics(); rx.reset_metrics();
@ -128,7 +122,7 @@ void rlc_am::reset_metrics()
* PDCP interface * PDCP interface
***************************************************************************/ ***************************************************************************/
void rlc_am::write_sdu(unique_byte_buffer_t sdu, bool blocking) void rlc_am_lte::write_sdu(unique_byte_buffer_t sdu, bool blocking)
{ {
tx.write_sdu(std::move(sdu), blocking); tx.write_sdu(std::move(sdu), blocking);
} }
@ -137,22 +131,22 @@ void rlc_am::write_sdu(unique_byte_buffer_t sdu, bool blocking)
* MAC interface * MAC interface
***************************************************************************/ ***************************************************************************/
bool rlc_am::has_data() bool rlc_am_lte::has_data()
{ {
return tx.has_data(); return tx.has_data();
} }
uint32_t rlc_am::get_buffer_state() uint32_t rlc_am_lte::get_buffer_state()
{ {
return tx.get_buffer_state(); return tx.get_buffer_state();
} }
int rlc_am::read_pdu(uint8_t *payload, uint32_t nof_bytes) int rlc_am_lte::read_pdu(uint8_t* payload, uint32_t nof_bytes)
{ {
return tx.read_pdu(payload, nof_bytes); return tx.read_pdu(payload, nof_bytes);
} }
void rlc_am::write_pdu(uint8_t *payload, uint32_t nof_bytes) void rlc_am_lte::write_pdu(uint8_t* payload, uint32_t nof_bytes)
{ {
rx.write_pdu(payload, nof_bytes); rx.write_pdu(payload, nof_bytes);
} }
@ -161,7 +155,7 @@ void rlc_am::write_pdu(uint8_t *payload, uint32_t nof_bytes)
* Tx subclass implementation * Tx subclass implementation
***************************************************************************/ ***************************************************************************/
rlc_am::rlc_am_tx::rlc_am_tx(rlc_am* parent_) : rlc_am_lte::rlc_am_lte_tx::rlc_am_lte_tx(rlc_am_lte* parent_) :
parent(parent_), parent(parent_),
log(parent_->log), log(parent_->log),
pool(byte_buffer_pool::get_instance()), pool(byte_buffer_pool::get_instance()),
@ -171,12 +165,12 @@ rlc_am::rlc_am_tx::rlc_am_tx(rlc_am* parent_) :
pthread_mutex_init(&mutex, NULL); pthread_mutex_init(&mutex, NULL);
} }
rlc_am::rlc_am_tx::~rlc_am_tx() rlc_am_lte::rlc_am_lte_tx::~rlc_am_lte_tx()
{ {
pthread_mutex_destroy(&mutex); pthread_mutex_destroy(&mutex);
} }
bool rlc_am::rlc_am_tx::configure(rlc_config_t cfg_) bool rlc_am_lte::rlc_am_lte_tx::configure(rlc_config_t cfg_)
{ {
// TODO: add config checks // TODO: add config checks
cfg = cfg_.am; cfg = cfg_.am;
@ -204,7 +198,7 @@ bool rlc_am::rlc_am_tx::configure(rlc_config_t cfg_)
return true; return true;
} }
void rlc_am::rlc_am_tx::stop() void rlc_am_lte::rlc_am_lte_tx::stop()
{ {
empty_queue(); empty_queue();
@ -236,7 +230,7 @@ void rlc_am::rlc_am_tx::stop()
pthread_mutex_unlock(&mutex); pthread_mutex_unlock(&mutex);
} }
void rlc_am::rlc_am_tx::empty_queue() void rlc_am_lte::rlc_am_lte_tx::empty_queue()
{ {
pthread_mutex_lock(&mutex); pthread_mutex_lock(&mutex);
@ -251,19 +245,19 @@ void rlc_am::rlc_am_tx::empty_queue()
pthread_mutex_unlock(&mutex); pthread_mutex_unlock(&mutex);
} }
void rlc_am::rlc_am_tx::reestablish() void rlc_am_lte::rlc_am_lte_tx::reestablish()
{ {
stop(); stop();
tx_enabled = true; tx_enabled = true;
} }
bool rlc_am::rlc_am_tx::do_status() bool rlc_am_lte::rlc_am_lte_tx::do_status()
{ {
return parent->rx.get_do_status(); return parent->rx.get_do_status();
} }
// Function is supposed to return as fast as possible // Function is supposed to return as fast as possible
bool rlc_am::rlc_am_tx::has_data() bool rlc_am_lte::rlc_am_lte_tx::has_data()
{ {
return (((do_status() && not status_prohibit_timer.is_running())) || // if we have a status PDU to transmit return (((do_status() && not status_prohibit_timer.is_running())) || // if we have a status PDU to transmit
(not retx_queue.empty()) || // if we have a retransmission (not retx_queue.empty()) || // if we have a retransmission
@ -271,7 +265,7 @@ bool rlc_am::rlc_am_tx::has_data()
(not tx_sdu_queue.is_empty())); // or if there is a SDU queued up for transmission (not tx_sdu_queue.is_empty())); // or if there is a SDU queued up for transmission
} }
uint32_t rlc_am::rlc_am_tx::get_buffer_state() uint32_t rlc_am_lte::rlc_am_lte_tx::get_buffer_state()
{ {
pthread_mutex_lock(&mutex); pthread_mutex_lock(&mutex);
uint32_t n_bytes = 0; uint32_t n_bytes = 0;
@ -330,7 +324,7 @@ uint32_t rlc_am::rlc_am_tx::get_buffer_state()
return n_bytes; return n_bytes;
} }
void rlc_am::rlc_am_tx::write_sdu(unique_byte_buffer_t sdu, bool blocking) void rlc_am_lte::rlc_am_lte_tx::write_sdu(unique_byte_buffer_t sdu, bool blocking)
{ {
if (!tx_enabled) { if (!tx_enabled) {
return; return;
@ -369,7 +363,7 @@ void rlc_am::rlc_am_tx::write_sdu(unique_byte_buffer_t sdu, bool blocking)
} }
} }
int rlc_am::rlc_am_tx::read_pdu(uint8_t *payload, uint32_t nof_bytes) int rlc_am_lte::rlc_am_lte_tx::read_pdu(uint8_t* payload, uint32_t nof_bytes)
{ {
pthread_mutex_lock(&mutex); pthread_mutex_lock(&mutex);
@ -411,7 +405,7 @@ unlock_and_exit:
return pdu_size; return pdu_size;
} }
void rlc_am::rlc_am_tx::timer_expired(uint32_t timeout_id) void rlc_am_lte::rlc_am_lte_tx::timer_expired(uint32_t timeout_id)
{ {
pthread_mutex_lock(&mutex); pthread_mutex_lock(&mutex);
if (poll_retx_timer.is_valid() && poll_retx_timer.id() == timeout_id) { if (poll_retx_timer.is_valid() && poll_retx_timer.id() == timeout_id) {
@ -426,7 +420,7 @@ void rlc_am::rlc_am_tx::timer_expired(uint32_t timeout_id)
pthread_mutex_unlock(&mutex); pthread_mutex_unlock(&mutex);
} }
void rlc_am::rlc_am_tx::retransmit_random_pdu() void rlc_am_lte::rlc_am_lte_tx::retransmit_random_pdu()
{ {
if (not tx_window.empty()) { if (not tx_window.empty()) {
// randomly select PDU in tx window for retransmission // randomly select PDU in tx window for retransmission
@ -442,12 +436,12 @@ void rlc_am::rlc_am_tx::retransmit_random_pdu()
} }
} }
uint32_t rlc_am::rlc_am_tx::get_num_tx_bytes() uint32_t rlc_am_lte::rlc_am_lte_tx::get_num_tx_bytes()
{ {
return num_tx_bytes; return num_tx_bytes;
} }
void rlc_am::rlc_am_tx::reset_metrics() void rlc_am_lte::rlc_am_lte_tx::reset_metrics()
{ {
pthread_mutex_lock(&mutex); pthread_mutex_lock(&mutex);
num_tx_bytes = 0; num_tx_bytes = 0;
@ -458,7 +452,7 @@ void rlc_am::rlc_am_tx::reset_metrics()
* Helper functions * Helper functions
***************************************************************************/ ***************************************************************************/
bool rlc_am::rlc_am_tx::poll_required() bool rlc_am_lte::rlc_am_lte_tx::poll_required()
{ {
if (cfg.poll_pdu > 0 && pdu_without_poll > static_cast<uint32_t>(cfg.poll_pdu)) { if (cfg.poll_pdu > 0 && pdu_without_poll > static_cast<uint32_t>(cfg.poll_pdu)) {
return true; return true;
@ -496,7 +490,7 @@ bool rlc_am::rlc_am_tx::poll_required()
return false; return false;
} }
int rlc_am::rlc_am_tx::build_status_pdu(uint8_t *payload, uint32_t nof_bytes) int rlc_am_lte::rlc_am_lte_tx::build_status_pdu(uint8_t* payload, uint32_t nof_bytes)
{ {
int pdu_len = parent->rx.get_status_pdu(&tx_status, nof_bytes); int pdu_len = parent->rx.get_status_pdu(&tx_status, nof_bytes);
log->debug("%s\n", rlc_am_status_pdu_to_string(&tx_status).c_str()); log->debug("%s\n", rlc_am_status_pdu_to_string(&tx_status).c_str());
@ -519,7 +513,7 @@ int rlc_am::rlc_am_tx::build_status_pdu(uint8_t *payload, uint32_t nof_bytes)
return pdu_len; return pdu_len;
} }
int rlc_am::rlc_am_tx::build_retx_pdu(uint8_t *payload, uint32_t nof_bytes) int rlc_am_lte::rlc_am_lte_tx::build_retx_pdu(uint8_t* payload, uint32_t nof_bytes)
{ {
// Check there is at least 1 element before calling front() // Check there is at least 1 element before calling front()
if (retx_queue.empty()) { if (retx_queue.empty()) {
@ -591,7 +585,8 @@ int rlc_am::rlc_am_tx::build_retx_pdu(uint8_t *payload, uint32_t nof_bytes)
return (ptr-payload) + tx_window[retx.sn].buf->N_bytes; return (ptr-payload) + tx_window[retx.sn].buf->N_bytes;
} }
int rlc_am::rlc_am_tx::build_segment(uint8_t *payload, uint32_t nof_bytes, rlc_amd_retx_t retx) { int rlc_am_lte::rlc_am_lte_tx::build_segment(uint8_t* payload, uint32_t nof_bytes, rlc_amd_retx_t retx)
{
if (tx_window[retx.sn].buf == NULL) { if (tx_window[retx.sn].buf == NULL) {
log->error("In build_segment: retx.sn=%d has null buffer\n", retx.sn); log->error("In build_segment: retx.sn=%d has null buffer\n", retx.sn);
return 0; return 0;
@ -740,10 +735,9 @@ int rlc_am::rlc_am_tx::build_segment(uint8_t *payload, uint32_t nof_bytes, rlc_a
RB_NAME, retx.sn, pdu_len, retx.so_start, new_header.N_li); RB_NAME, retx.sn, pdu_len, retx.so_start, new_header.N_li);
return pdu_len; return pdu_len;
} }
int rlc_am::rlc_am_tx::build_data_pdu(uint8_t *payload, uint32_t nof_bytes) int rlc_am_lte::rlc_am_lte_tx::build_data_pdu(uint8_t* payload, uint32_t nof_bytes)
{ {
if (tx_sdu == NULL && tx_sdu_queue.size() == 0) { if (tx_sdu == NULL && tx_sdu_queue.size() == 0) {
log->info("No data available to be sent\n"); log->info("No data available to be sent\n");
@ -906,7 +900,7 @@ int rlc_am::rlc_am_tx::build_data_pdu(uint8_t *payload, uint32_t nof_bytes)
return total_len; return total_len;
} }
void rlc_am::rlc_am_tx::handle_control_pdu(uint8_t *payload, uint32_t nof_bytes) void rlc_am_lte::rlc_am_lte_tx::handle_control_pdu(uint8_t* payload, uint32_t nof_bytes)
{ {
pthread_mutex_lock(&mutex); pthread_mutex_lock(&mutex);
@ -1002,15 +996,13 @@ void rlc_am::rlc_am_tx::handle_control_pdu(uint8_t *payload, uint32_t nof_bytes)
pthread_mutex_unlock(&mutex); pthread_mutex_unlock(&mutex);
} }
void rlc_am_lte::rlc_am_lte_tx::debug_state()
void rlc_am::rlc_am_tx::debug_state()
{ {
log->debug("%s vt_a = %d, vt_ms = %d, vt_s = %d, poll_sn = %d\n", log->debug("%s vt_a = %d, vt_ms = %d, vt_s = %d, poll_sn = %d\n",
RB_NAME, vt_a, vt_ms, vt_s, poll_sn); RB_NAME, vt_a, vt_ms, vt_s, poll_sn);
} }
int rlc_am_lte::rlc_am_lte_tx::required_buffer_size(rlc_amd_retx_t retx)
int rlc_am::rlc_am_tx::required_buffer_size(rlc_amd_retx_t retx)
{ {
if (!retx.is_segment) { if (!retx.is_segment) {
if (tx_window.count(retx.sn) == 1) { if (tx_window.count(retx.sn) == 1) {
@ -1083,7 +1075,7 @@ int rlc_am::rlc_am_tx::required_buffer_size(rlc_amd_retx_t retx)
return rlc_am_packed_length(&new_header) + (retx.so_end-retx.so_start); return rlc_am_packed_length(&new_header) + (retx.so_end-retx.so_start);
} }
bool rlc_am::rlc_am_tx::retx_queue_has_sn(uint32_t sn) bool rlc_am_lte::rlc_am_lte_tx::retx_queue_has_sn(uint32_t sn)
{ {
std::deque<rlc_amd_retx_t>::iterator q_it; std::deque<rlc_amd_retx_t>::iterator q_it;
for (q_it = retx_queue.begin(); q_it != retx_queue.end(); ++q_it) { for (q_it = retx_queue.begin(); q_it != retx_queue.end(); ++q_it) {
@ -1100,7 +1092,7 @@ bool rlc_am::rlc_am_tx::retx_queue_has_sn(uint32_t sn)
* Rx subclass implementation * Rx subclass implementation
***************************************************************************/ ***************************************************************************/
rlc_am::rlc_am_rx::rlc_am_rx(rlc_am* parent_) : rlc_am_lte::rlc_am_lte_rx::rlc_am_lte_rx(rlc_am_lte* parent_) :
parent(parent_), parent(parent_),
pool(byte_buffer_pool::get_instance()), pool(byte_buffer_pool::get_instance()),
log(parent_->log), log(parent_->log),
@ -1109,12 +1101,12 @@ rlc_am::rlc_am_rx::rlc_am_rx(rlc_am* parent_) :
pthread_mutex_init(&mutex, NULL); pthread_mutex_init(&mutex, NULL);
} }
rlc_am::rlc_am_rx::~rlc_am_rx() rlc_am_lte::rlc_am_lte_rx::~rlc_am_lte_rx()
{ {
pthread_mutex_destroy(&mutex); pthread_mutex_destroy(&mutex);
} }
bool rlc_am::rlc_am_rx::configure(rlc_am_config_t cfg_) bool rlc_am_lte::rlc_am_lte_rx::configure(rlc_am_config_t cfg_)
{ {
// TODO: add config checks // TODO: add config checks
cfg = cfg_; cfg = cfg_;
@ -1133,12 +1125,12 @@ bool rlc_am::rlc_am_rx::configure(rlc_am_config_t cfg_)
return true; return true;
} }
void rlc_am::rlc_am_rx::reestablish() void rlc_am_lte::rlc_am_lte_rx::reestablish()
{ {
stop(); stop();
} }
void rlc_am::rlc_am_rx::stop() void rlc_am_lte::rlc_am_lte_rx::stop()
{ {
pthread_mutex_lock(&mutex); pthread_mutex_lock(&mutex);
@ -1166,8 +1158,7 @@ void rlc_am::rlc_am_rx::stop()
pthread_mutex_unlock(&mutex); pthread_mutex_unlock(&mutex);
} }
void rlc_am_lte::rlc_am_lte_rx::handle_data_pdu(uint8_t* payload, uint32_t nof_bytes, rlc_amd_pdu_header_t& header)
void rlc_am::rlc_am_rx::handle_data_pdu(uint8_t *payload, uint32_t nof_bytes, rlc_amd_pdu_header_t &header)
{ {
std::map<uint32_t, rlc_amd_rx_pdu_t>::iterator it; std::map<uint32_t, rlc_amd_rx_pdu_t>::iterator it;
@ -1289,8 +1280,9 @@ void rlc_am::rlc_am_rx::handle_data_pdu(uint8_t *payload, uint32_t nof_bytes, rl
debug_state(); debug_state();
} }
void rlc_am_lte::rlc_am_lte_rx::handle_data_pdu_segment(uint8_t* payload,
void rlc_am::rlc_am_rx::handle_data_pdu_segment(uint8_t *payload, uint32_t nof_bytes, rlc_amd_pdu_header_t &header) uint32_t nof_bytes,
rlc_amd_pdu_header_t& header)
{ {
std::map<uint32_t, rlc_amd_rx_pdu_segments_t>::iterator it; std::map<uint32_t, rlc_amd_rx_pdu_segments_t>::iterator it;
@ -1377,8 +1369,7 @@ void rlc_am::rlc_am_rx::handle_data_pdu_segment(uint8_t *payload, uint32_t nof_b
debug_state(); debug_state();
} }
void rlc_am_lte::rlc_am_lte_rx::reassemble_rx_sdus()
void rlc_am::rlc_am_rx::reassemble_rx_sdus()
{ {
uint32_t len = 0; uint32_t len = 0;
if (rx_sdu == NULL) { if (rx_sdu == NULL) {
@ -1500,7 +1491,7 @@ exit:
} }
} }
void rlc_am::rlc_am_rx::reset_status() void rlc_am_lte::rlc_am_lte_rx::reset_status()
{ {
pthread_mutex_lock(&mutex); pthread_mutex_lock(&mutex);
do_status = false; do_status = false;
@ -1508,24 +1499,24 @@ void rlc_am::rlc_am_rx::reset_status()
pthread_mutex_unlock(&mutex); pthread_mutex_unlock(&mutex);
} }
bool rlc_am::rlc_am_rx::get_do_status() bool rlc_am_lte::rlc_am_lte_rx::get_do_status()
{ {
return do_status; return do_status;
} }
uint32_t rlc_am::rlc_am_rx::get_num_rx_bytes() uint32_t rlc_am_lte::rlc_am_lte_rx::get_num_rx_bytes()
{ {
return num_rx_bytes; return num_rx_bytes;
} }
void rlc_am::rlc_am_rx::reset_metrics() void rlc_am_lte::rlc_am_lte_rx::reset_metrics()
{ {
pthread_mutex_lock(&mutex); pthread_mutex_lock(&mutex);
num_rx_bytes = 0; num_rx_bytes = 0;
pthread_mutex_unlock(&mutex); pthread_mutex_unlock(&mutex);
} }
void rlc_am::rlc_am_rx::write_pdu(uint8_t* payload, const uint32_t nof_bytes) void rlc_am_lte::rlc_am_lte_rx::write_pdu(uint8_t* payload, const uint32_t nof_bytes)
{ {
if (nof_bytes < 1) return; if (nof_bytes < 1) return;
@ -1554,7 +1545,7 @@ void rlc_am::rlc_am_rx::write_pdu(uint8_t* payload, const uint32_t nof_bytes)
} }
} }
void rlc_am::rlc_am_rx::timer_expired(uint32_t timeout_id) void rlc_am_lte::rlc_am_lte_rx::timer_expired(uint32_t timeout_id)
{ {
pthread_mutex_lock(&mutex); pthread_mutex_lock(&mutex);
if (reordering_timer.is_valid() and reordering_timer.id() == timeout_id) { if (reordering_timer.is_valid() and reordering_timer.id() == timeout_id) {
@ -1584,7 +1575,7 @@ void rlc_am::rlc_am_rx::timer_expired(uint32_t timeout_id)
} }
// Called from Tx object to pack status PDU that doesn't exceed a given size // Called from Tx object to pack status PDU that doesn't exceed a given size
int rlc_am::rlc_am_rx::get_status_pdu(rlc_status_pdu_t* status, const uint32_t max_pdu_size) int rlc_am_lte::rlc_am_lte_rx::get_status_pdu(rlc_status_pdu_t* status, const uint32_t max_pdu_size)
{ {
pthread_mutex_lock(&mutex); pthread_mutex_lock(&mutex);
status->N_nack = 0; status->N_nack = 0;
@ -1626,7 +1617,7 @@ int rlc_am::rlc_am_rx::get_status_pdu(rlc_status_pdu_t* status, const uint32_t m
} }
// Called from Tx object to obtain length of the full status PDU // Called from Tx object to obtain length of the full status PDU
int rlc_am::rlc_am_rx::get_status_pdu_length() int rlc_am_lte::rlc_am_lte_rx::get_status_pdu_length()
{ {
pthread_mutex_lock(&mutex); pthread_mutex_lock(&mutex);
rlc_status_pdu_t status = {}; rlc_status_pdu_t status = {};
@ -1642,7 +1633,7 @@ int rlc_am::rlc_am_rx::get_status_pdu_length()
return rlc_am_packed_length(&status); return rlc_am_packed_length(&status);
} }
void rlc_am::rlc_am_rx::print_rx_segments() void rlc_am_lte::rlc_am_lte_rx::print_rx_segments()
{ {
std::map<uint32_t, rlc_amd_rx_pdu_segments_t>::iterator it; std::map<uint32_t, rlc_amd_rx_pdu_segments_t>::iterator it;
std::stringstream ss; std::stringstream ss;
@ -1657,7 +1648,7 @@ void rlc_am::rlc_am_rx::print_rx_segments()
} }
// NOTE: Preference would be to capture by value, and then move; but header is stack allocated // NOTE: Preference would be to capture by value, and then move; but header is stack allocated
bool rlc_am::rlc_am_rx::add_segment_and_check(rlc_amd_rx_pdu_segments_t *pdu, rlc_amd_rx_pdu_t *segment) bool rlc_am_lte::rlc_am_lte_rx::add_segment_and_check(rlc_amd_rx_pdu_segments_t* pdu, rlc_amd_rx_pdu_t* segment)
{ {
// Check for first segment // Check for first segment
if(0 == segment->header.so) { if(0 == segment->header.so) {
@ -1768,7 +1759,7 @@ bool rlc_am::rlc_am_rx::add_segment_and_check(rlc_amd_rx_pdu_segments_t *pdu, rl
return true; return true;
} }
bool rlc_am::rlc_am_rx::inside_rx_window(const int16_t sn) bool rlc_am_lte::rlc_am_lte_rx::inside_rx_window(const int16_t sn)
{ {
if (RX_MOD_BASE(sn) >= RX_MOD_BASE(static_cast<int16_t>(vr_r)) && RX_MOD_BASE(sn) < RX_MOD_BASE(vr_mr)) { if (RX_MOD_BASE(sn) >= RX_MOD_BASE(static_cast<int16_t>(vr_r)) && RX_MOD_BASE(sn) < RX_MOD_BASE(vr_mr)) {
return true; return true;
@ -1777,7 +1768,7 @@ bool rlc_am::rlc_am_rx::inside_rx_window(const int16_t sn)
} }
} }
void rlc_am::rlc_am_rx::debug_state() void rlc_am_lte::rlc_am_lte_rx::debug_state()
{ {
log->debug("%s vr_r = %d, vr_mr = %d, vr_x = %d, vr_ms = %d, vr_h = %d\n", log->debug("%s vr_r = %d, vr_mr = %d, vr_x = %d, vr_ms = %d, vr_h = %d\n",
RB_NAME, vr_r, vr_mr, vr_x, vr_ms, vr_h); RB_NAME, vr_r, vr_mr, vr_x, vr_ms, vr_h);

2
lib/test/upper/rlc_am_control_test.cc
Unescape Escape View File

@ -19,9 +19,9 @@
* *
*/ */
#include "srslte/upper/rlc_am_lte.h"
#include <assert.h> #include <assert.h>
#include <iostream> #include <iostream>
#include "srslte/upper/rlc_am.h"
// Simple status PDU // Simple status PDU
uint8_t pdu1[] = {0x00, 0x78}; uint8_t pdu1[] = {0x00, 0x78};

2
lib/test/upper/rlc_am_data_test.cc
Unescape Escape View File

@ -19,9 +19,9 @@
* *
*/ */
#include "srslte/upper/rlc_am_lte.h"
#include <assert.h> #include <assert.h>
#include <iostream> #include <iostream>
#include "srslte/upper/rlc_am.h"
// Fixed header only // Fixed header only
uint8_t pdu1[] = {0x88, 0x06}; uint8_t pdu1[] = {0x88, 0x06};

70
lib/test/upper/rlc_am_test.cc
Unescape Escape View File

@ -19,13 +19,13 @@
* *
*/ */
#include <iostream>
#include "srslte/common/log_filter.h" #include "srslte/common/log_filter.h"
#include "srslte/common/logger_stdout.h" #include "srslte/common/logger_stdout.h"
#include "srslte/common/threads.h"
#include "srslte/upper/rlc_am.h"
#include "srslte/common/rlc_pcap.h" #include "srslte/common/rlc_pcap.h"
#include "srslte/common/threads.h"
#include "srslte/upper/rlc_am_lte.h"
#include <assert.h> #include <assert.h>
#include <iostream>
#define NBUFS 5 #define NBUFS 5
#define HAVE_PCAP 0 #define HAVE_PCAP 0
#define SDU_SIZE 500 #define SDU_SIZE 500
@ -66,7 +66,7 @@ public:
class ul_writer : public thread class ul_writer : public thread
{ {
public: public:
ul_writer(rlc_am* rlc_) : rlc(rlc_), running(false), thread("UL_WRITER") {} ul_writer(rlc_am_lte* rlc_) : rlc(rlc_), running(false), thread("UL_WRITER") {}
~ul_writer() { stop(); } ~ul_writer() { stop(); }
void stop() void stop()
{ {
@ -102,11 +102,11 @@ private:
running = false; running = false;
} }
rlc_am* rlc; rlc_am_lte* rlc;
bool running; bool running;
}; };
void basic_test_tx(rlc_am* rlc, byte_buffer_t pdu_bufs[NBUFS]) void basic_test_tx(rlc_am_lte* rlc, byte_buffer_t pdu_bufs[NBUFS])
{ {
// Push 5 SDUs into RLC1 // Push 5 SDUs into RLC1
@ -143,8 +143,8 @@ bool basic_test()
timer_handler timers(8); timer_handler timers(8);
byte_buffer_t pdu_bufs[NBUFS]; byte_buffer_t pdu_bufs[NBUFS];
rlc_am rlc1(&log1, 1, &tester, &tester, &timers); rlc_am_lte rlc1(&log1, 1, &tester, &tester, &timers);
rlc_am rlc2(&log2, 1, &tester, &tester, &timers); rlc_am_lte rlc2(&log2, 1, &tester, &tester, &timers);
if (not rlc1.configure(rlc_config_t::default_rlc_am_config())) { if (not rlc1.configure(rlc_config_t::default_rlc_am_config())) {
return -1; return -1;
@ -202,8 +202,8 @@ bool concat_test()
rlc_am_tester tester; rlc_am_tester tester;
srslte::timer_handler timers(8); srslte::timer_handler timers(8);
rlc_am rlc1(&log1, 1, &tester, &tester, &timers); rlc_am_lte rlc1(&log1, 1, &tester, &tester, &timers);
rlc_am rlc2(&log2, 1, &tester, &tester, &timers); rlc_am_lte rlc2(&log2, 1, &tester, &tester, &timers);
if (not rlc1.configure(rlc_config_t::default_rlc_am_config())) { if (not rlc1.configure(rlc_config_t::default_rlc_am_config())) {
return -1; return -1;
@ -268,8 +268,8 @@ bool segment_test(bool in_seq_rx)
srslte::timer_handler timers(8); srslte::timer_handler timers(8);
int len = 0; int len = 0;
rlc_am rlc1(&log1, 1, &tester, &tester, &timers); rlc_am_lte rlc1(&log1, 1, &tester, &tester, &timers);
rlc_am rlc2(&log2, 1, &tester, &tester, &timers); rlc_am_lte rlc2(&log2, 1, &tester, &tester, &timers);
if (not rlc1.configure(rlc_config_t::default_rlc_am_config())) { if (not rlc1.configure(rlc_config_t::default_rlc_am_config())) {
return -1; return -1;
@ -362,8 +362,8 @@ bool retx_test()
timer_handler timers(8); timer_handler timers(8);
int len = 0; int len = 0;
rlc_am rlc1(&log1, 1, &tester, &tester, &timers); rlc_am_lte rlc1(&log1, 1, &tester, &tester, &timers);
rlc_am rlc2(&log2, 1, &tester, &tester, &timers); rlc_am_lte rlc2(&log2, 1, &tester, &tester, &timers);
if (not rlc1.configure(rlc_config_t::default_rlc_am_config())) { if (not rlc1.configure(rlc_config_t::default_rlc_am_config())) {
return -1; return -1;
@ -456,8 +456,8 @@ bool resegment_test_1()
timer_handler timers(8); timer_handler timers(8);
int len = 0; int len = 0;
rlc_am rlc1(&log1, 1, &tester, &tester, &timers); rlc_am_lte rlc1(&log1, 1, &tester, &tester, &timers);
rlc_am rlc2(&log2, 1, &tester, &tester, &timers); rlc_am_lte rlc2(&log2, 1, &tester, &tester, &timers);
if (not rlc1.configure(rlc_config_t::default_rlc_am_config())) { if (not rlc1.configure(rlc_config_t::default_rlc_am_config())) {
return -1; return -1;
@ -562,8 +562,8 @@ bool resegment_test_2()
timer_handler timers(8); timer_handler timers(8);
int len = 0; int len = 0;
rlc_am rlc1(&log1, 1, &tester, &tester, &timers); rlc_am_lte rlc1(&log1, 1, &tester, &tester, &timers);
rlc_am rlc2(&log2, 1, &tester, &tester, &timers); rlc_am_lte rlc2(&log2, 1, &tester, &tester, &timers);
if (not rlc1.configure(rlc_config_t::default_rlc_am_config())) { if (not rlc1.configure(rlc_config_t::default_rlc_am_config())) {
return -1; return -1;
@ -664,8 +664,8 @@ bool resegment_test_3()
rlc_am_tester tester; rlc_am_tester tester;
srslte::timer_handler timers(8); srslte::timer_handler timers(8);
rlc_am rlc1(&log1, 1, &tester, &tester, &timers); rlc_am_lte rlc1(&log1, 1, &tester, &tester, &timers);
rlc_am rlc2(&log2, 1, &tester, &tester, &timers); rlc_am_lte rlc2(&log2, 1, &tester, &tester, &timers);
if (not rlc1.configure(rlc_config_t::default_rlc_am_config())) { if (not rlc1.configure(rlc_config_t::default_rlc_am_config())) {
return -1; return -1;
@ -761,8 +761,8 @@ bool resegment_test_4()
rlc_am_tester tester; rlc_am_tester tester;
srslte::timer_handler timers(8); srslte::timer_handler timers(8);
rlc_am rlc1(&log1, 1, &tester, &tester, &timers); rlc_am_lte rlc1(&log1, 1, &tester, &tester, &timers);
rlc_am rlc2(&log2, 1, &tester, &tester, &timers); rlc_am_lte rlc2(&log2, 1, &tester, &tester, &timers);
if (not rlc1.configure(rlc_config_t::default_rlc_am_config())) { if (not rlc1.configure(rlc_config_t::default_rlc_am_config())) {
return -1; return -1;
@ -860,8 +860,8 @@ bool resegment_test_5()
rlc_am_tester tester; rlc_am_tester tester;
srslte::timer_handler timers(8); srslte::timer_handler timers(8);
rlc_am rlc1(&log1, 1, &tester, &tester, &timers); rlc_am_lte rlc1(&log1, 1, &tester, &tester, &timers);
rlc_am rlc2(&log2, 1, &tester, &tester, &timers); rlc_am_lte rlc2(&log2, 1, &tester, &tester, &timers);
if (not rlc1.configure(rlc_config_t::default_rlc_am_config())) { if (not rlc1.configure(rlc_config_t::default_rlc_am_config())) {
return -1; return -1;
@ -960,8 +960,8 @@ bool resegment_test_6()
srslte::timer_handler timers(8); srslte::timer_handler timers(8);
int len = 0; int len = 0;
rlc_am rlc1(&log1, 1, &tester, &tester, &timers); rlc_am_lte rlc1(&log1, 1, &tester, &tester, &timers);
rlc_am rlc2(&log2, 1, &tester, &tester, &timers); rlc_am_lte rlc2(&log2, 1, &tester, &tester, &timers);
if (not rlc1.configure(rlc_config_t::default_rlc_am_config())) { if (not rlc1.configure(rlc_config_t::default_rlc_am_config())) {
return -1; return -1;
@ -1096,8 +1096,8 @@ bool resegment_test_7()
#endif #endif
srslte::timer_handler timers(8); srslte::timer_handler timers(8);
rlc_am rlc1(&log1, 1, &tester, &tester, &timers); rlc_am_lte rlc1(&log1, 1, &tester, &tester, &timers);
rlc_am rlc2(&log2, 1, &tester, &tester, &timers); rlc_am_lte rlc2(&log2, 1, &tester, &tester, &timers);
if (not rlc1.configure(rlc_config_t::default_rlc_am_config())) { if (not rlc1.configure(rlc_config_t::default_rlc_am_config())) {
return -1; return -1;
@ -1269,8 +1269,8 @@ bool resegment_test_8()
#endif #endif
srslte::timer_handler timers(8); srslte::timer_handler timers(8);
rlc_am rlc1(&log1, 1, &tester, &tester, &timers); rlc_am_lte rlc1(&log1, 1, &tester, &tester, &timers);
rlc_am rlc2(&log2, 1, &tester, &tester, &timers); rlc_am_lte rlc2(&log2, 1, &tester, &tester, &timers);
if (not rlc1.configure(rlc_config_t::default_rlc_am_config())) { if (not rlc1.configure(rlc_config_t::default_rlc_am_config())) {
return -1; return -1;
@ -1414,7 +1414,7 @@ bool reset_test()
srslte::timer_handler timers(8); srslte::timer_handler timers(8);
int len = 0; int len = 0;
rlc_am rlc1(&log1, 1, &tester, &tester, &timers); rlc_am_lte rlc1(&log1, 1, &tester, &tester, &timers);
if (not rlc1.configure(rlc_config_t::default_rlc_am_config())) { if (not rlc1.configure(rlc_config_t::default_rlc_am_config())) {
return -1; return -1;
@ -1459,7 +1459,7 @@ bool resume_test()
srslte::timer_handler timers(8); srslte::timer_handler timers(8);
int len = 0; int len = 0;
rlc_am rlc1(&log1, 1, &tester, &tester, &timers); rlc_am_lte rlc1(&log1, 1, &tester, &tester, &timers);
if (not rlc1.configure(rlc_config_t::default_rlc_am_config())) { if (not rlc1.configure(rlc_config_t::default_rlc_am_config())) {
return -1; return -1;
@ -1503,7 +1503,7 @@ bool stop_test()
rlc_am_tester tester; rlc_am_tester tester;
srslte::timer_handler timers(8); srslte::timer_handler timers(8);
rlc_am rlc1(&log1, 1, &tester, &tester, &timers); rlc_am_lte rlc1(&log1, 1, &tester, &tester, &timers);
if (not rlc1.configure(rlc_config_t::default_rlc_am_config())) { if (not rlc1.configure(rlc_config_t::default_rlc_am_config())) {
return -1; return -1;
@ -1536,8 +1536,8 @@ bool status_pdu_test()
srslte::timer_handler timers(8); srslte::timer_handler timers(8);
int len = 0; int len = 0;
rlc_am rlc1(&log1, 1, &tester, &tester, &timers); rlc_am_lte rlc1(&log1, 1, &tester, &tester, &timers);
rlc_am rlc2(&log2, 1, &tester, &tester, &timers); rlc_am_lte rlc2(&log2, 1, &tester, &tester, &timers);
if (not rlc1.configure(rlc_config_t::default_rlc_am_config())) { if (not rlc1.configure(rlc_config_t::default_rlc_am_config())) {
return -1; return -1;

Write Preview
Loading…
Cancel
Save