PentHertz
/
srsLTE
mirror of https://github.com/PentHertz/srsLTE.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

rlc_am_lte: refactor PDCP/RLC interface to use fix sized data structure 

this patch replaces the std::vector type used in the interface between
PDCP and RLC to signal delivery status between both layers. The new
data type is a configurable but fixed-size vector.
The RLC AM doesn't need to dynamically allocate the vector for every SN but
uses the tx_window for storage.
This commit is contained in:
Andre Puschmann 2021-03-09 14:41:46 +01:00
parent bea78512e5
commit 20cbc48f90
28 changed files with 109 additions and 78 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
lib/include/srslte/adt/bounded_vector.h
View File

@ -127,6 +127,7 @@ public:
bool empty() const { return size_ == 0; }
std::size_t size() const { return size_; }
std::size_t capacity() const { return MAX_N; }
bool full() const { return size_ == MAX_N; }
// modifiers
void clear()

4
lib/include/srslte/interfaces/enb_pdcp_interfaces.h
View File

@ -53,8 +53,8 @@ class pdcp_interface_rlc
public:
/* RLC calls PDCP to push a PDCP PDU. */
virtual void write_pdu(uint16_t rnti, uint32_t lcid, srslte::unique_byte_buffer_t pdu) = 0;
virtual void notify_delivery(uint16_t rnti, uint32_t lcid, const std::vector<uint32_t>& pdcp_sns) = 0;
virtual void notify_failure(uint16_t rnti, uint32_t lcid, const std::vector<uint32_t>& pdcp_sns) = 0;
virtual void notify_delivery(uint16_t rnti, uint32_t lcid, const srslte::pdcp_sn_vector_t& pdcp_sns) = 0;
virtual void notify_failure(uint16_t rnti, uint32_t lcid, const srslte::pdcp_sn_vector_t& pdcp_sns) = 0;
};
} // namespace srsenb

4
lib/include/srslte/interfaces/gnb_interfaces.h
View File

@ -83,8 +83,8 @@ class pdcp_interface_rlc_nr
public:
/* RLC calls PDCP to push a PDCP PDU. */
virtual void write_pdu(uint16_t rnti, uint32_t lcid, srslte::unique_byte_buffer_t sdu) = 0;
virtual void notify_delivery(uint16_t rnti, uint32_t lcid, const std::vector<uint32_t>& tx_count) = 0;
virtual void notify_failure(uint16_t rnti, uint32_t lcid, const std::vector<uint32_t>& tx_count) = 0;
virtual void notify_delivery(uint16_t rnti, uint32_t lcid, const srslte::pdcp_sn_vector_t& pdcp_sns) = 0;
virtual void notify_failure(uint16_t rnti, uint32_t lcid, const srslte::pdcp_sn_vector_t& pdcp_sns) = 0;
};
class pdcp_interface_rrc_nr

6
lib/include/srslte/interfaces/pdcp_interface_types.h
View File

@ -18,6 +18,7 @@
#ifndef SRSLTE_PDCP_INTERFACE_TYPES_H
#define SRSLTE_PDCP_INTERFACE_TYPES_H
#include "srslte/adt/bounded_vector.h"
#include "srslte/common/security.h"
#include <math.h>
#include <stdint.h>
@ -168,6 +169,11 @@ struct pdcp_lte_state_t {
uint32_t reordering_pdcp_rx_count;
};
// Custom type for interface between PDCP and RLC to convey SDU delivery status
#define MAX_SDUS_PER_RLC_PDU (256) // default to RLC SDU queue length
#define MAX_SDUS_TO_NOTIFY (MAX_SDUS_PER_RLC_PDU) // Arbitrarily chosen limit
typedef srslte::bounded_vector<uint32_t, MAX_SDUS_TO_NOTIFY> pdcp_sn_vector_t;
} // namespace srslte
#endif // SRSLTE_PDCP_INTERFACE_TYPES_H

4
lib/include/srslte/interfaces/ue_pdcp_interfaces.h
View File

@ -44,8 +44,8 @@ public:
virtual void write_pdu_bcch_dlsch(srslte::unique_byte_buffer_t sdu) = 0;
virtual void write_pdu_pcch(srslte::unique_byte_buffer_t sdu) = 0;
virtual void write_pdu_mch(uint32_t lcid, srslte::unique_byte_buffer_t sdu) = 0;
virtual void notify_delivery(uint32_t lcid, const std::vector<uint32_t>& pdcp_sn) = 0;
virtual void notify_failure(uint32_t lcid, const std::vector<uint32_t>& pdcp_sn) = 0;
virtual void notify_delivery(uint32_t lcid, const srslte::pdcp_sn_vector_t& pdcp_sn) = 0;
virtual void notify_failure(uint32_t lcid, const srslte::pdcp_sn_vector_t& pdcp_sn) = 0;
};
class pdcp_interface_gw

4
lib/include/srslte/upper/pdcp.h
View File

@ -59,8 +59,8 @@ public:
void write_pdu_bcch_bch(unique_byte_buffer_t sdu) override;
void write_pdu_bcch_dlsch(unique_byte_buffer_t sdu) override;
void write_pdu_pcch(unique_byte_buffer_t sdu) override;
void notify_delivery(uint32_t lcid, const std::vector<uint32_t>& pdcp_sn) override;
void notify_failure(uint32_t lcid, const std::vector<uint32_t>& pdcp_sn) override;
void notify_delivery(uint32_t lcid, const pdcp_sn_vector_t& pdcp_sns) override;
void notify_failure(uint32_t lcid, const pdcp_sn_vector_t& pdcp_sns) override;
// eNB-only methods
std::map<uint32_t, srslte::unique_byte_buffer_t> get_buffered_pdus(uint32_t lcid);

4
lib/include/srslte/upper/pdcp_entity_base.h
View File

@ -113,8 +113,8 @@ public:
// RLC interface
virtual void write_pdu(unique_byte_buffer_t pdu) = 0;
virtual void notify_delivery(const std::vector<uint32_t>& pdcp_sns) = 0;
virtual void notify_failure(const std::vector<uint32_t>& pdcp_sns) = 0;
virtual void notify_delivery(const pdcp_sn_vector_t& pdcp_sns) = 0;
virtual void notify_failure(const pdcp_sn_vector_t& pdcp_sns) = 0;
virtual void get_bearer_state(pdcp_lte_state_t* state) = 0;
virtual void set_bearer_state(const pdcp_lte_state_t& state) = 0;

4
lib/include/srslte/upper/pdcp_entity_lte.h
View File

@ -120,8 +120,8 @@ public:
// RLC interface
void write_pdu(unique_byte_buffer_t pdu) override;
void notify_failure(const std::vector<uint32_t>& pdcp_sns) override;
void notify_delivery(const std::vector<uint32_t>& pdcp_sns) override;
void notify_failure(const pdcp_sn_vector_t& pdcp_sns) override;
void notify_delivery(const pdcp_sn_vector_t& pdcp_sns) override;
// Config helpers
bool check_valid_config();

4
lib/include/srslte/upper/pdcp_entity_nr.h
View File

@ -51,8 +51,8 @@ public:
// RLC interface
void write_pdu(unique_byte_buffer_t pdu) final;
void notify_delivery(const std::vector<uint32_t>& tx_count) final;
void notify_failure(const std::vector<uint32_t>& tx_count) final;
void notify_delivery(const pdcp_sn_vector_t& pdcp_sns) final;
void notify_failure(const pdcp_sn_vector_t& pdcp_sns) final;
// State variable setters (should be used only for testing)
void set_tx_next(uint32_t tx_next_) { tx_next = tx_next_; }

15
lib/include/srslte/upper/rlc_am_lte.h
View File

@ -20,6 +20,7 @@
#include "srslte/common/log.h"
#include "srslte/common/task_scheduler.h"
#include "srslte/common/timeout.h"
#include "srslte/interfaces/pdcp_interface_types.h"
#include "srslte/upper/byte_buffer_queue.h"
#include "srslte/upper/rlc_am_base.h"
#include "srslte/upper/rlc_common.h"
@ -42,12 +43,12 @@ struct rlc_amd_rx_pdu_segments_t {
};
struct rlc_amd_tx_pdu_t {
rlc_amd_pdu_header_t header;
unique_byte_buffer_t buf;
std::vector<uint32_t> pdcp_sns;
uint32_t retx_count;
uint32_t rlc_sn;
bool is_acked;
rlc_amd_pdu_header_t header;
unique_byte_buffer_t buf;
pdcp_sn_vector_t pdcp_sns;
uint32_t retx_count;
uint32_t rlc_sn;
bool is_acked;
};
struct rlc_amd_retx_t {
@ -346,7 +347,7 @@ private:
// Tx windows
rlc_ringbuffer_t<rlc_amd_tx_pdu_t> tx_window;
pdu_retx_queue retx_queue;
std::vector<uint32_t> notify_info_vec;
pdcp_sn_vector_t notify_info_vec;
// Mutexes
pthread_mutex_t mutex;

1
lib/include/srslte/upper/rlc_common.h
View File

@ -28,6 +28,7 @@ namespace srslte {
#define RLC_AM_WINDOW_SIZE 512
#define RLC_MAX_SDU_SIZE ((1 << 11) - 1) // Length of LI field is 11bits
#define RLC_AM_MIN_DATA_PDU_SIZE (3) // AMD PDU with 10 bit SN (length of LI field is 11 bits) (No LI)
typedef enum {
RLC_FI_FIELD_START_AND_END_ALIGNED = 0,

4
lib/src/upper/pdcp.cc
View File

@ -285,7 +285,7 @@ void pdcp::write_pdu_mch(uint32_t lcid, unique_byte_buffer_t sdu)
}
}
void pdcp::notify_delivery(uint32_t lcid, const std::vector<uint32_t>& pdcp_sns)
void pdcp::notify_delivery(uint32_t lcid, const pdcp_sn_vector_t& pdcp_sns)
{
if (valid_lcid(lcid)) {
pdcp_array.at(lcid)->notify_delivery(pdcp_sns);
@ -294,7 +294,7 @@ void pdcp::notify_delivery(uint32_t lcid, const std::vector<uint32_t>& pdcp_sns)
}
}
void pdcp::notify_failure(uint32_t lcid, const std::vector<uint32_t>& pdcp_sns)
void pdcp::notify_failure(uint32_t lcid, const srslte::pdcp_sn_vector_t& pdcp_sns)
{
if (valid_lcid(lcid)) {
pdcp_array.at(lcid)->notify_failure(pdcp_sns);

4
lib/src/upper/pdcp_entity_lte.cc
View File

@ -652,7 +652,7 @@ void pdcp_entity_lte::discard_callback::operator()(uint32_t timer_id)
/****************************************************************************
* Handle delivery/failure notifications from RLC
***************************************************************************/
void pdcp_entity_lte::notify_delivery(const std::vector<uint32_t>& pdcp_sns)
void pdcp_entity_lte::notify_delivery(const pdcp_sn_vector_t& pdcp_sns)
{
if (not is_drb()) {
return;
@ -682,7 +682,7 @@ void pdcp_entity_lte::notify_delivery(const std::vector<uint32_t>& pdcp_sns)
}
}
void pdcp_entity_lte::notify_failure(const std::vector<uint32_t>& pdcp_sns)
void pdcp_entity_lte::notify_failure(const pdcp_sn_vector_t& pdcp_sns)
{
if (not is_drb()) {
return;

4
lib/src/upper/pdcp_entity_nr.cc
View File

@ -203,12 +203,12 @@ void pdcp_entity_nr::write_pdu(unique_byte_buffer_t pdu)
}
// Notification of delivery/failure
void pdcp_entity_nr::notify_delivery(const std::vector<uint32_t>& pdcp_sns)
void pdcp_entity_nr::notify_delivery(const pdcp_sn_vector_t& pdcp_sns)
{
logger.debug("Received delivery notification from RLC. Nof SNs=%ld", pdcp_sns.size());
}
void pdcp_entity_nr::notify_failure(const std::vector<uint32_t>& pdcp_sns)
void pdcp_entity_nr::notify_failure(const pdcp_sn_vector_t& pdcp_sns)
{
logger.debug("Received failure notification from RLC. Nof SNs=%ld", pdcp_sns.size());
}

70
lib/src/upper/rlc_am_lte.cc
View File

@ -211,7 +211,6 @@ rlc_am_lte::rlc_am_lte_tx::rlc_am_lte_tx(rlc_am_lte* parent_) :
status_prohibit_timer(parent_->timers->get_unique_timer())
{
pthread_mutex_init(&mutex, NULL);
notify_info_vec.reserve(RLC_AM_WINDOW_SIZE);
}
rlc_am_lte::rlc_am_lte_tx::~rlc_am_lte_tx()
@ -226,7 +225,14 @@ void rlc_am_lte::rlc_am_lte_tx::set_bsr_callback(bsr_callback_t callback)
bool rlc_am_lte::rlc_am_lte_tx::configure(const rlc_config_t& cfg_)
{
// TODO: add config checks
if (cfg_.tx_queue_length > MAX_SDUS_PER_RLC_PDU) {
logger.error("Configuring Tx queue length of %d PDUs too big. Maximum value is %d.",
cfg_.tx_queue_length,
MAX_SDUS_PER_RLC_PDU);
return false;
}
// TODO: add more config checks
cfg = cfg_.am;
// check timers
@ -890,6 +896,14 @@ int rlc_am_lte::rlc_am_lte_tx::build_data_pdu(uint8_t* payload, uint32_t nof_byt
return 0;
}
if (nof_bytes < RLC_AM_MIN_DATA_PDU_SIZE) {
logger.info("%s Cannot build data PDU - %d bytes available but at least %d bytes are required ",
RB_NAME,
nof_bytes,
RLC_AM_MIN_DATA_PDU_SIZE);
return 0;
}
unique_byte_buffer_t pdu = srslte::make_byte_buffer();
if (pdu == NULL) {
#ifdef RLC_AM_BUFFER_DEBUG
@ -912,22 +926,20 @@ int rlc_am_lte::rlc_am_lte_tx::build_data_pdu(uint8_t* payload, uint32_t nof_byt
header.fi = RLC_FI_FIELD_START_AND_END_ALIGNED;
header.sn = vt_s;
// insert newly assigned SN into window and use reference for in-place operations
// NOTE: from now on, we can't return from this function anymore before increasing vt_s
rlc_amd_tx_pdu_t& tx_pdu = tx_window.add_pdu(header.sn);
tx_pdu.pdcp_sns.clear();
uint32_t head_len = rlc_am_packed_length(&header);
uint32_t to_move = 0;
uint32_t last_li = 0;
uint32_t pdu_space = SRSLTE_MIN(nof_bytes, pdu->get_tailroom());
uint8_t* pdu_ptr = pdu->msg;
if (pdu_space <= head_len) {
logger.info(
"%s Cannot build a PDU - %d bytes available, %d bytes required for header", RB_NAME, nof_bytes, head_len);
return 0;
}
logger.debug("%s Building PDU - pdu_space: %d, head_len: %d ", RB_NAME, pdu_space, head_len);
// Check for SDU segment
std::vector<uint32_t> pdcp_sns;
if (tx_sdu != nullptr) {
to_move = ((pdu_space - head_len) >= tx_sdu->N_bytes) ? tx_sdu->N_bytes : pdu_space - head_len;
memcpy(pdu_ptr, tx_sdu->msg, to_move);
@ -939,7 +951,11 @@ int rlc_am_lte::rlc_am_lte_tx::build_data_pdu(uint8_t* payload, uint32_t nof_byt
if (undelivered_sdu_info_queue.has_pdcp_sn(tx_sdu->md.pdcp_sn)) {
pdcp_sdu_info_t& pdcp_sdu = undelivered_sdu_info_queue[tx_sdu->md.pdcp_sn];
pdcp_sdu.rlc_sn_info_list.push_back({header.sn, false});
pdcp_sns.push_back(tx_sdu->md.pdcp_sn);
if (not tx_pdu.pdcp_sns.full()) {
tx_pdu.pdcp_sns.push_back(tx_sdu->md.pdcp_sn);
} else {
logger.warning("Cant't store PDCP_SN=%d for delivery notification.", tx_sdu->md.pdcp_sn);
}
if (tx_sdu->N_bytes == 0) {
pdcp_sdu.fully_txed = true;
}
@ -992,7 +1008,11 @@ int rlc_am_lte::rlc_am_lte_tx::build_data_pdu(uint8_t* payload, uint32_t nof_byt
if (undelivered_sdu_info_queue.has_pdcp_sn(tx_sdu->md.pdcp_sn)) {
pdcp_sdu_info_t& pdcp_sdu = undelivered_sdu_info_queue[tx_sdu->md.pdcp_sn];
pdcp_sdu.rlc_sn_info_list.push_back({header.sn, false});
pdcp_sns.push_back(tx_sdu->md.pdcp_sn);
if (not tx_pdu.pdcp_sns.full()) {
tx_pdu.pdcp_sns.push_back(tx_sdu->md.pdcp_sn);
} else {
logger.warning("Cant't store PDCP_SN=%d for delivery notification.", tx_sdu->md.pdcp_sn);
}
if (tx_sdu->N_bytes == 0) {
pdcp_sdu.fully_txed = true;
}
@ -1021,7 +1041,6 @@ int rlc_am_lte::rlc_am_lte_tx::build_data_pdu(uint8_t* payload, uint32_t nof_byt
// Make sure, at least one SDU (segment) has been added until this point
if (pdu->N_bytes == 0) {
logger.error("Generated empty RLC PDU.");
return 0;
}
if (tx_sdu != NULL) {
@ -1044,19 +1063,16 @@ int rlc_am_lte::rlc_am_lte_tx::build_data_pdu(uint8_t* payload, uint32_t nof_byt
}
}
// Set SN
header.sn = vt_s;
// Update Tx window
vt_s = (vt_s + 1) % MOD;
// Place PDU in tx_window, write header and TX
tx_window.add_pdu(header.sn);
tx_window[header.sn].buf = std::move(pdu);
tx_window[header.sn].header = header;
tx_window[header.sn].is_acked = false;
tx_window[header.sn].retx_count = 0;
tx_window[header.sn].rlc_sn = header.sn;
tx_window[header.sn].pdcp_sns = std::move(pdcp_sns);
const byte_buffer_t* buffer_ptr = tx_window[header.sn].buf.get();
// Write final header and TX
tx_pdu.buf = std::move(pdu);
tx_pdu.header = header;
tx_pdu.is_acked = false;
tx_pdu.retx_count = 0;
tx_pdu.rlc_sn = header.sn;
const byte_buffer_t* buffer_ptr = tx_pdu.buf.get();
uint8_t* ptr = payload;
rlc_am_write_data_pdu_header(&header, &ptr);
@ -1204,7 +1220,7 @@ void rlc_am_lte::rlc_am_lte_tx::update_notification_ack_info(const rlc_amd_tx_pd
if (not tx_window.has_sn(tx_pdu.header.sn)) {
return;
}
std::vector<uint32_t>& pdcp_sns = tx_window[tx_pdu.header.sn].pdcp_sns;
pdcp_sn_vector_t& pdcp_sns = tx_window[tx_pdu.header.sn].pdcp_sns;
for (uint32_t pdcp_sn : pdcp_sns) {
// Iterate over all SNs that were TX'ed
auto& info = undelivered_sdu_info_queue[pdcp_sn];
@ -1221,7 +1237,11 @@ void rlc_am_lte::rlc_am_lte_tx::update_notification_ack_info(const rlc_amd_tx_pd
info.rlc_sn_info_list.end(),
[](rlc_sn_info_t rlc_sn_info) { return rlc_sn_info.is_acked; });
if (info.fully_acked) {
notify_info_vec.push_back(pdcp_sn);
if (not notify_info_vec.full()) {
notify_info_vec.push_back(pdcp_sn);
} else {
logger.warning("Can't notify delivery of PDCP_SN=%d.", pdcp_sn);
}
}
}
}

6
lib/test/upper/pdcp_lte_test_discard_sdu.cc
View File

@ -45,7 +45,8 @@ int test_tx_sdu_notify(const srslte::pdcp_lte_state_t& init_state,
TESTASSERT(out_pdu->N_bytes == 4);
TESTASSERT(pdcp->nof_discard_timers() == 1); // One timer should be running
std::vector<uint32_t> sns_notified = {0};
srslte::pdcp_sn_vector_t sns_notified;
sns_notified.push_back(0);
pdcp->notify_delivery(sns_notified);
TESTASSERT(pdcp->nof_discard_timers() == 0); // Timer should have been difused after
@ -103,7 +104,8 @@ int test_tx_sdu_discard(const srslte::pdcp_lte_state_t& init_state,
TESTASSERT(pdcp->nof_discard_timers() == 0); // Timer should have been difused after expiry
TESTASSERT(rlc->discard_count == 1); // RLC should be notified of discard
std::vector<uint32_t> sns_notified = {0};
srslte::pdcp_sn_vector_t sns_notified;
sns_notified.push_back(0);
pdcp->notify_delivery(sns_notified); // PDCP should not find PDU to notify.
return 0;
}

4
lib/test/upper/rlc_am_test.cc
View File

@ -52,7 +52,7 @@ public:
void write_pdu_bcch_dlsch(unique_byte_buffer_t sdu) {}
void write_pdu_pcch(unique_byte_buffer_t sdu) {}
void write_pdu_mch(uint32_t lcid, srslte::unique_byte_buffer_t pdu) {}
void notify_delivery(uint32_t lcid, const std::vector<uint32_t>& pdcp_sn_vec)
void notify_delivery(uint32_t lcid, const srslte::pdcp_sn_vector_t& pdcp_sn_vec)
{
assert(lcid == 1);
for (uint32_t pdcp_sn : pdcp_sn_vec) {
@ -62,7 +62,7 @@ public:
notified_counts[pdcp_sn] += 1;
}
}
void notify_failure(uint32_t lcid, const std::vector<uint32_t>& pdcp_sn_vec)
void notify_failure(uint32_t lcid, const srslte::pdcp_sn_vector_t& pdcp_sn_vec)
{
assert(lcid == 1);
// TODO

4
lib/test/upper/rlc_common_test.cc
View File

@ -46,8 +46,8 @@ public:
}
sdus[n_sdus++] = std::move(sdu);
}
void notify_delivery(uint32_t lcid, const std::vector<uint32_t>& pdcp_sn) {}
void notify_failure(uint32_t lcid, const std::vector<uint32_t>& pdcp_sn) {}
void notify_delivery(uint32_t lcid, const srslte::pdcp_sn_vector_t& pdcp_sn) {}
void notify_failure(uint32_t lcid, const srslte::pdcp_sn_vector_t& pdcp_sn) {}
void write_pdu_bcch_bch(unique_byte_buffer_t sdu) {}
void write_pdu_bcch_dlsch(unique_byte_buffer_t sdu) {}
void write_pdu_pcch(unique_byte_buffer_t sdu) {}

4
lib/test/upper/rlc_stress_test.cc
View File

@ -368,8 +368,8 @@ public:
void write_pdu_bcch_dlsch(unique_byte_buffer_t sdu) {}
void write_pdu_pcch(unique_byte_buffer_t sdu) {}
void write_pdu_mch(uint32_t lcid, srslte::unique_byte_buffer_t sdu) {}
void notify_delivery(uint32_t lcid, const std::vector<uint32_t>& pdcp_sns) {}
void notify_failure(uint32_t lcid, const std::vector<uint32_t>& pdcp_sns) {}
void notify_delivery(uint32_t lcid, const srslte::pdcp_sn_vector_t& pdcp_sns) {}
void notify_failure(uint32_t lcid, const srslte::pdcp_sn_vector_t& pdcp_sns) {}
// RRC interface
void max_retx_attempted()

4
lib/test/upper/rlc_test_common.h
View File

@ -51,8 +51,8 @@ public:
void write_pdu_bcch_dlsch(unique_byte_buffer_t sdu) {}
void write_pdu_pcch(unique_byte_buffer_t sdu) {}
void write_pdu_mch(uint32_t lcid, srslte::unique_byte_buffer_t sdu) { sdus.push_back(std::move(sdu)); }
void notify_delivery(uint32_t lcid, const std::vector<uint32_t>& pdcp_sns) {}
void notify_failure(uint32_t lcid, const std::vector<uint32_t>& pdcp_sns) {}
void notify_delivery(uint32_t lcid, const srslte::pdcp_sn_vector_t& pdcp_sns) {}
void notify_failure(uint32_t lcid, const srslte::pdcp_sn_vector_t& pdcp_sns) {}
// RRC interface
void max_retx_attempted() {}

4
srsenb/hdr/stack/upper/pdcp.h
View File

@ -38,8 +38,8 @@ public:
// pdcp_interface_rlc
void write_pdu(uint16_t rnti, uint32_t lcid, srslte::unique_byte_buffer_t sdu) override;
void notify_delivery(uint16_t rnti, uint32_t lcid, const std::vector<uint32_t>& pdcp_sn) override;
void notify_failure(uint16_t rnti, uint32_t lcid, const std::vector<uint32_t>& pdcp_sn) override;
void notify_delivery(uint16_t rnti, uint32_t lcid, const srslte::pdcp_sn_vector_t& pdcp_sn) override;
void notify_failure(uint16_t rnti, uint32_t lcid, const srslte::pdcp_sn_vector_t& pdcp_sn) override;
void write_pdu_mch(uint32_t lcid, srslte::unique_byte_buffer_t sdu) {}
// pdcp_interface_rrc

4
srsenb/hdr/stack/upper/pdcp_nr.h
View File

@ -42,8 +42,8 @@ public:
// pdcp_interface_rlc_nr
void write_pdu(uint16_t rnti, uint32_t lcid, srslte::unique_byte_buffer_t sdu);
void notify_delivery(uint16_t rnti, uint32_t lcid, const std::vector<uint32_t>& tx_count);
void notify_failure(uint16_t rnti, uint32_t lcid, const std::vector<uint32_t>& tx_count);
void notify_delivery(uint16_t rnti, uint32_t lcid, const srslte::pdcp_sn_vector_t& pdcp_sn);
void notify_failure(uint16_t rnti, uint32_t lcid, const srslte::pdcp_sn_vector_t& pdcp_sn);
void write_pdu_mch(uint32_t lcid, srslte::unique_byte_buffer_t sdu) {}
// pdcp_interface_rrc_nr

4
srsenb/hdr/stack/upper/rlc.h
View File

@ -71,8 +71,8 @@ private:
{
public:
void write_pdu(uint32_t lcid, srslte::unique_byte_buffer_t sdu);
void notify_delivery(uint32_t lcid, const std::vector<uint32_t>& tx_count);
void notify_failure(uint32_t lcid, const std::vector<uint32_t>& tx_count);
void notify_delivery(uint32_t lcid, const srslte::pdcp_sn_vector_t& pdcp_sn);
void notify_failure(uint32_t lcid, const srslte::pdcp_sn_vector_t& pdcp_sn);
void write_pdu_bcch_bch(srslte::unique_byte_buffer_t sdu);
void write_pdu_bcch_dlsch(srslte::unique_byte_buffer_t sdu);
void write_pdu_pcch(srslte::unique_byte_buffer_t sdu);

4
srsenb/hdr/stack/upper/rlc_nr.h
View File

@ -63,8 +63,8 @@ private:
{
public:
void write_pdu(uint32_t lcid, srslte::unique_byte_buffer_t sdu);
void notify_delivery(uint32_t lcid, const std::vector<uint32_t>& pdcp_sns);
void notify_failure(uint32_t lcid, const std::vector<uint32_t>& pdcp_sns);
void notify_delivery(uint32_t lcid, const srslte::pdcp_sn_vector_t& pdcp_sns);
void notify_failure(uint32_t lcid, const srslte::pdcp_sn_vector_t& pdcp_sns);
void write_pdu_bcch_bch(srslte::unique_byte_buffer_t sdu);
void write_pdu_bcch_dlsch(srslte::unique_byte_buffer_t sdu);
void write_pdu_pcch(srslte::unique_byte_buffer_t sdu);

4
srsenb/src/stack/upper/pdcp.cc
View File

@ -143,14 +143,14 @@ void pdcp::send_status_report(uint16_t rnti)
users[rnti].pdcp->send_status_report();
}
void pdcp::notify_delivery(uint16_t rnti, uint32_t lcid, const std::vector<uint32_t>& pdcp_sns)
void pdcp::notify_delivery(uint16_t rnti, uint32_t lcid, const srslte::pdcp_sn_vector_t& pdcp_sns)
{
if (users.count(rnti)) {
users[rnti].pdcp->notify_delivery(lcid, pdcp_sns);
}
}
void pdcp::notify_failure(uint16_t rnti, uint32_t lcid, const std::vector<uint32_t>& pdcp_sns)
void pdcp::notify_failure(uint16_t rnti, uint32_t lcid, const srslte::pdcp_sn_vector_t& pdcp_sns)
{
if (users.count(rnti)) {
users[rnti].pdcp->notify_failure(lcid, pdcp_sns);

4
srsenb/src/stack/upper/pdcp_nr.cc
View File

@ -99,7 +99,7 @@ void pdcp_nr::write_pdu(uint16_t rnti, uint32_t lcid, srslte::unique_byte_buffer
}
}
void pdcp_nr::notify_delivery(uint16_t rnti, uint32_t lcid, const std::vector<uint32_t>& pdcp_sns)
void pdcp_nr::notify_delivery(uint16_t rnti, uint32_t lcid, const srslte::pdcp_sn_vector_t& pdcp_sns)
{
if (users.count(rnti)) {
users[rnti].pdcp->notify_delivery(lcid, pdcp_sns);
@ -108,7 +108,7 @@ void pdcp_nr::notify_delivery(uint16_t rnti, uint32_t lcid, const std::vector<ui
}
}
void pdcp_nr::notify_failure(uint16_t rnti, uint32_t lcid, const std::vector<uint32_t>& pdcp_sns)
void pdcp_nr::notify_failure(uint16_t rnti, uint32_t lcid, const srslte::pdcp_sn_vector_t& pdcp_sns)
{
if (users.count(rnti)) {
users[rnti].pdcp->notify_failure(lcid, pdcp_sns);

4
srsenb/src/stack/upper/rlc.cc
View File

@ -269,12 +269,12 @@ void rlc::user_interface::write_pdu(uint32_t lcid, srslte::unique_byte_buffer_t
}
}
void rlc::user_interface::notify_delivery(uint32_t lcid, const std::vector<uint32_t>& pdcp_sns)
void rlc::user_interface::notify_delivery(uint32_t lcid, const srslte::pdcp_sn_vector_t& pdcp_sns)
{
pdcp->notify_delivery(rnti, lcid, pdcp_sns);
}
void rlc::user_interface::notify_failure(uint32_t lcid, const std::vector<uint32_t>& pdcp_sns)
void rlc::user_interface::notify_failure(uint32_t lcid, const srslte::pdcp_sn_vector_t& pdcp_sns)
{
pdcp->notify_failure(rnti, lcid, pdcp_sns);
}

4
srsenb/src/stack/upper/rlc_nr.cc
View File

@ -207,12 +207,12 @@ std::string rlc_nr::user_interface::get_rb_name(uint32_t lcid)
return srslte::to_string(static_cast<srslte::rb_id_nr_t>(lcid));
}
void rlc_nr::user_interface::notify_delivery(uint32_t lcid, const std::vector<uint32_t>& pdcp_sns)
void rlc_nr::user_interface::notify_delivery(uint32_t lcid, const srslte::pdcp_sn_vector_t& pdcp_sns)
{
m_pdcp->notify_delivery(rnti, lcid, pdcp_sns);
}
void rlc_nr::user_interface::notify_failure(uint32_t lcid, const std::vector<uint32_t>& pdcp_sns)
void rlc_nr::user_interface::notify_failure(uint32_t lcid, const srslte::pdcp_sn_vector_t& pdcp_sns)
{
m_pdcp->notify_failure(rnti, lcid, pdcp_sns);
}