From fa351cd285da6c5f8fe04517a6ff6bc0291a398b Mon Sep 17 00:00:00 2001 From: faluco Date: Fri, 24 Sep 2021 14:20:58 +0200 Subject: [PATCH] Rename functions that contain the unsafe word to nolock. The term "unsafe" does not clearly state that the function is not locking the shared date and it sounds "dangerous", so use a more explicit term. --- lib/include/srsran/adt/choice_type.h | 50 ++++++++++---------- lib/include/srsran/adt/pool/batch_mem_pool.h | 4 +- lib/include/srsran/common/block_queue.h | 9 ++-- lib/include/srsran/rlc/rlc_am_lte.h | 2 +- lib/src/phy/rf/rf_uhd_imp.cc | 20 ++++---- lib/src/rlc/rlc_am_lte.cc | 8 ++-- lib/test/common/choice_type_test.cc | 8 ++-- srsenb/hdr/stack/mac/nr/mac_nr.h | 4 +- srsenb/src/stack/mac/nr/mac_nr.cc | 14 +++--- srsue/hdr/phy/lte/cc_worker.h | 12 ++--- srsue/hdr/phy/lte/sf_worker.h | 10 ++-- srsue/hdr/stack/mac/dl_harq.h | 18 +++---- srsue/hdr/stack/mac/mux.h | 2 +- srsue/hdr/stack/mac/proc_ra.h | 2 +- srsue/hdr/stack/mac_nr/proc_sr_nr.h | 2 +- srsue/src/phy/lte/cc_worker.cc | 14 +++--- srsue/src/phy/lte/sf_worker.cc | 22 ++++----- srsue/src/phy/lte/worker_pool.cc | 2 +- srsue/src/phy/phy.cc | 6 +-- srsue/src/phy/sync.cc | 6 +-- srsue/src/stack/mac/dl_harq.cc | 8 ++-- srsue/src/stack/mac/mux.cc | 6 +-- srsue/src/stack/mac/proc_ra.cc | 10 ++-- srsue/src/stack/mac_nr/proc_sr_nr.cc | 8 ++-- 24 files changed, 123 insertions(+), 124 deletions(-) diff --git a/lib/include/srsran/adt/choice_type.h b/lib/include/srsran/adt/choice_type.h index 1fbfd47f0..a79ba5c35 100644 --- a/lib/include/srsran/adt/choice_type.h +++ b/lib/include/srsran/adt/choice_type.h @@ -55,7 +55,7 @@ struct choice_storage_t { } template - void destroy_unsafe() + void destroy_unchecked() { get_unchecked().~U(); }; @@ -71,7 +71,7 @@ struct CopyCtorVisitor { template void operator()(const T& t) { - c->construct_unsafe(t); + c->construct_unchecked(t); } C* c; }; @@ -82,18 +82,18 @@ struct MoveCtorVisitor { template void operator()(T&& t) { - c->construct_unsafe(std::move(t)); + c->construct_unchecked(std::move(t)); } C* c; }; template -struct DtorUnsafeVisitor { - explicit DtorUnsafeVisitor(C* c_) : c(c_) {} +struct DtorUncheckVisitor { + explicit DtorUncheckVisitor(C* c_) : c(c_) {} template void operator()(T& t) { - c->template destroy_unsafe(); + c->template destroy_unchecked(); } C* c; }; @@ -110,12 +110,12 @@ struct tagged_union_t std::size_t type_id; - using base_t::destroy_unsafe; + using base_t::destroy_unchecked; using base_t::get_buffer; using base_t::get_unchecked; template - void construct_emplace_unsafe(Args2&&... args) + void construct_emplace_unchecked(Args2&&... args) { using U2 = typename std::decay::type; static_assert(type_list_contains(), @@ -125,7 +125,7 @@ struct tagged_union_t } template - void construct_unsafe(U&& u) + void construct_unchecked(U&& u) { using U2 = typename std::decay::type; static_assert(type_list_contains(), @@ -134,11 +134,11 @@ struct tagged_union_t new (get_buffer()) U2(std::forward(u)); } - void copy_unsafe(const this_type& other) { visit(CopyCtorVisitor{this}, other); } + void copy_unchecked(const this_type& other) { visit(CopyCtorVisitor{this}, other); } - void move_unsafe(this_type&& other) { visit(MoveCtorVisitor{this}, other); } + void move_unchecked(this_type&& other) { visit(MoveCtorVisitor{this}, other); } - void dtor_unsafe() { visit(choice_details::DtorUnsafeVisitor{this}, *this); } + void dtor_unchecked() { visit(choice_details::DtorUncheckVisitor{this}, *this); } size_t get_type_idx() const { return type_id; } @@ -180,51 +180,51 @@ public: typename = typename std::enable_if::value>::type> explicit choice_t(Args2&&... args) noexcept { - base_t::template construct_emplace_unsafe(std::forward(args)...); + base_t::template construct_emplace_unchecked(std::forward(args)...); } - choice_t(const choice_t& other) noexcept { base_t::copy_unsafe(other); } + choice_t(const choice_t& other) noexcept { base_t::copy_unchecked(other); } - choice_t(choice_t&& other) noexcept { base_t::move_unsafe(std::move(other)); } + choice_t(choice_t&& other) noexcept { base_t::move_unchecked(std::move(other)); } template > choice_t(U&& u) noexcept { - base_t::construct_unsafe(std::forward(u)); + base_t::construct_unchecked(std::forward(u)); } - ~choice_t() { base_t::dtor_unsafe(); } + ~choice_t() { base_t::dtor_unchecked(); } template > choice_t& operator=(U&& u) noexcept { if (not base_t::template is()) { - base_t::dtor_unsafe(); + base_t::dtor_unchecked(); } - base_t::construct_unsafe(std::forward(u)); + base_t::construct_unchecked(std::forward(u)); return *this; } template void emplace(Args2&&... args) noexcept { - base_t::dtor_unsafe(); - base_t::template construct_emplace_unsafe(std::forward(args)...); + base_t::dtor_unchecked(); + base_t::template construct_emplace_unchecked(std::forward(args)...); } choice_t& operator=(const choice_t& other) noexcept { if (this != &other) { - base_t::dtor_unsafe(); - base_t::copy_unsafe(other); + base_t::dtor_unchecked(); + base_t::copy_unchecked(other); } return *this; } choice_t& operator=(choice_t&& other) noexcept { - base_t::dtor_unsafe(); - base_t::move_unsafe(std::move(other)); + base_t::dtor_unchecked(); + base_t::move_unchecked(std::move(other)); return *this; } diff --git a/lib/include/srsran/adt/pool/batch_mem_pool.h b/lib/include/srsran/adt/pool/batch_mem_pool.h index d54f5fff8..648ae0335 100644 --- a/lib/include/srsran/adt/pool/batch_mem_pool.h +++ b/lib/include/srsran/adt/pool/batch_mem_pool.h @@ -121,7 +121,7 @@ public: void* node = grow_pool.allocate_node(); if (grow_pool.size() < batch_threshold) { - allocate_batch_in_background_unlocked(); + allocate_batch_in_background_nolock(); } return node; } @@ -146,7 +146,7 @@ public: } private: - void allocate_batch_in_background_unlocked() + void allocate_batch_in_background_nolock() { if (state->dispatched) { // new batch allocation already ongoing diff --git a/lib/include/srsran/common/block_queue.h b/lib/include/srsran/common/block_queue.h index 479f474d2..7442c9a0b 100644 --- a/lib/include/srsran/common/block_queue.h +++ b/lib/include/srsran/common/block_queue.h @@ -35,7 +35,6 @@ namespace srsran { template class block_queue { - public: // Callback functions for mutexed operations inside pop/push methods class call_mutexed_itf @@ -107,7 +106,7 @@ public: bool full() { // queue is full? pthread_mutex_lock(&mutex); - bool ret = not check_queue_space_unlocked(false); + bool ret = not check_queue_space_nolock(false); pthread_mutex_unlock(&mutex); return ret; } @@ -163,7 +162,7 @@ private: return ret; } - bool check_queue_space_unlocked(bool block) + bool check_queue_space_nolock(bool block) { num_threads++; if (capacity > 0) { @@ -190,7 +189,7 @@ private: return std::move(value); } pthread_mutex_lock(&mutex); - bool ret = check_queue_space_unlocked(block); + bool ret = check_queue_space_nolock(block); if (ret) { if (mutexed_callback) { mutexed_callback->pushing(value); @@ -210,7 +209,7 @@ private: return false; } pthread_mutex_lock(&mutex); - bool ret = check_queue_space_unlocked(block); + bool ret = check_queue_space_nolock(block); if (ret) { if (mutexed_callback) { mutexed_callback->pushing(value); diff --git a/lib/include/srsran/rlc/rlc_am_lte.h b/lib/include/srsran/rlc/rlc_am_lte.h index abfe17504..6512d76a7 100644 --- a/lib/include/srsran/rlc/rlc_am_lte.h +++ b/lib/include/srsran/rlc/rlc_am_lte.h @@ -392,7 +392,7 @@ private: void update_notification_ack_info(uint32_t rlc_sn); void debug_state(); - void empty_queue_unsafe(); + void empty_queue_nolock(); int required_buffer_size(const rlc_amd_retx_t& retx); void retransmit_pdu(uint32_t sn); diff --git a/lib/src/phy/rf/rf_uhd_imp.cc b/lib/src/phy/rf/rf_uhd_imp.cc index be148f2f8..3525174f8 100644 --- a/lib/src/phy/rf/rf_uhd_imp.cc +++ b/lib/src/phy/rf/rf_uhd_imp.cc @@ -489,7 +489,7 @@ bool rf_uhd_rx_wait_lo_locked(void* h) return is_locked; } -static inline int rf_uhd_start_rx_stream_unsafe(rf_uhd_handler_t* handler) +static inline int rf_uhd_start_rx_stream_nolock(rf_uhd_handler_t* handler) { // Check if stream was not created or started if (not handler->uhd->is_rx_ready() or handler->rx_stream_enabled) { @@ -512,10 +512,10 @@ int rf_uhd_start_rx_stream(void* h, bool now) rf_uhd_handler_t* handler = (rf_uhd_handler_t*)h; std::unique_lock lock(handler->rx_mutex); - return rf_uhd_start_rx_stream_unsafe(handler); + return rf_uhd_start_rx_stream_nolock(handler); } -static inline int rf_uhd_stop_rx_stream_unsafe(rf_uhd_handler_t* handler) +static inline int rf_uhd_stop_rx_stream_nolock(rf_uhd_handler_t* handler) { // Check if stream was created or stream was not started if (not handler->uhd->is_rx_ready() or not handler->rx_stream_enabled) { @@ -538,7 +538,7 @@ int rf_uhd_stop_rx_stream(void* h) rf_uhd_handler_t* handler = (rf_uhd_handler_t*)h; std::unique_lock lock(handler->rx_mutex); - if (rf_uhd_stop_rx_stream_unsafe(handler) < SRSRAN_SUCCESS) { + if (rf_uhd_stop_rx_stream_nolock(handler) < SRSRAN_SUCCESS) { return SRSRAN_ERROR; } @@ -937,7 +937,7 @@ int rf_uhd_close(void* h) return SRSRAN_SUCCESS; } -static inline void rf_uhd_set_master_clock_rate_unsafe(rf_uhd_handler_t* handler, double rate) +static inline void rf_uhd_set_master_clock_rate_nolock(rf_uhd_handler_t* handler, double rate) { // Set master clock rate if it is allowed and change is required if (handler->dynamic_master_rate and handler->current_master_clock != rate) { @@ -985,14 +985,14 @@ double rf_uhd_set_rx_srate(void* h, double freq) // Stop RX streamer if (RF_UHD_IMP_PROHIBITED_STOP_START.count(handler->devname) == 0) { - if (rf_uhd_stop_rx_stream_unsafe(handler) != SRSRAN_SUCCESS) { + if (rf_uhd_stop_rx_stream_nolock(handler) != SRSRAN_SUCCESS) { return SRSRAN_ERROR; } } // Set master clock rate if (fmod(handler->current_master_clock, freq) > 0.0) { - rf_uhd_set_master_clock_rate_unsafe(handler, 4 * freq); + rf_uhd_set_master_clock_rate_nolock(handler, 4 * freq); } if (handler->nof_rx_channels > 1) { @@ -1043,7 +1043,7 @@ double rf_uhd_set_tx_srate(void* h, double freq) // Set master clock rate if (fmod(handler->current_master_clock, freq) > 0.0) { - rf_uhd_set_master_clock_rate_unsafe(handler, 4 * freq); + rf_uhd_set_master_clock_rate_nolock(handler, 4 * freq); } if (handler->nof_tx_channels > 1) { @@ -1258,7 +1258,7 @@ int rf_uhd_recv_with_time_multi(void* h, // Start stream if not started if (not handler->rx_stream_enabled) { - if (rf_uhd_start_rx_stream_unsafe(handler) != SRSRAN_SUCCESS) { + if (rf_uhd_start_rx_stream_nolock(handler) != SRSRAN_SUCCESS) { return SRSRAN_ERROR; } } @@ -1303,7 +1303,7 @@ int rf_uhd_recv_with_time_multi(void* h, if (RF_UHD_IMP_PROHIBITED_STOP_START.count(handler->devname) == 0) { // Stop Rx stream - rf_uhd_stop_rx_stream_unsafe(handler); + rf_uhd_stop_rx_stream_nolock(handler); } return -1; diff --git a/lib/src/rlc/rlc_am_lte.cc b/lib/src/rlc/rlc_am_lte.cc index 62fc19f35..3638c04b1 100644 --- a/lib/src/rlc/rlc_am_lte.cc +++ b/lib/src/rlc/rlc_am_lte.cc @@ -327,7 +327,7 @@ bool rlc_am_lte::rlc_am_lte_tx::configure(const rlc_config_t& cfg_) } // make sure Tx queue is empty before attempting to resize - empty_queue_unsafe(); + empty_queue_nolock(); tx_sdu_queue.resize(cfg_.tx_queue_length); tx_enabled = true; @@ -339,7 +339,7 @@ void rlc_am_lte::rlc_am_lte_tx::stop() { std::lock_guard lock(mutex); - empty_queue_unsafe(); + empty_queue_nolock(); tx_enabled = false; @@ -372,10 +372,10 @@ void rlc_am_lte::rlc_am_lte_tx::stop() void rlc_am_lte::rlc_am_lte_tx::empty_queue() { std::lock_guard lock(mutex); - empty_queue_unsafe(); + empty_queue_nolock(); } -void rlc_am_lte::rlc_am_lte_tx::empty_queue_unsafe() +void rlc_am_lte::rlc_am_lte_tx::empty_queue_nolock() { // deallocate all SDUs in transmit queue while (tx_sdu_queue.size() > 0) { diff --git a/lib/test/common/choice_type_test.cc b/lib/test/common/choice_type_test.cc index df8c59e5f..33be694e8 100644 --- a/lib/test/common/choice_type_test.cc +++ b/lib/test/common/choice_type_test.cc @@ -80,15 +80,15 @@ int test_tagged_union() { using srsran::choice_details::tagged_union_t; tagged_union_t u; - u.construct_unsafe(5); + u.construct_unchecked(5); TESTASSERT(u.is()); TESTASSERT(u.get_unchecked() == 5); - u.destroy_unsafe(); + u.destroy_unchecked(); TESTASSERT(C::counter == 0); - u.construct_unsafe(C{}); + u.construct_unchecked(C{}); TESTASSERT(C::counter == 1); - u.destroy_unsafe(); + u.destroy_unchecked(); TESTASSERT(C::counter == 0); return SRSRAN_SUCCESS; diff --git a/srsenb/hdr/stack/mac/nr/mac_nr.h b/srsenb/hdr/stack/mac/nr/mac_nr.h index 313f6cb69..b0fed230a 100644 --- a/srsenb/hdr/stack/mac/nr/mac_nr.h +++ b/srsenb/hdr/stack/mac/nr/mac_nr.h @@ -73,8 +73,8 @@ private: uint16_t alloc_ue(uint32_t enb_cc_idx); // internal misc helpers - bool is_rnti_valid_unsafe(uint16_t rnti); - bool is_rnti_active_unsafe(uint16_t rnti); + bool is_rnti_valid_nolock(uint16_t rnti); + bool is_rnti_active_nolock(uint16_t rnti); // handle UCI data from either PUCCH or PUSCH bool handle_uci_data(const uint16_t rnti, const srsran_uci_cfg_nr_t& cfg, const srsran_uci_value_nr_t& value); diff --git a/srsenb/src/stack/mac/nr/mac_nr.cc b/srsenb/src/stack/mac/nr/mac_nr.cc index 01acff678..44017dd9e 100644 --- a/srsenb/src/stack/mac/nr/mac_nr.cc +++ b/srsenb/src/stack/mac/nr/mac_nr.cc @@ -195,7 +195,7 @@ uint16_t mac_nr::alloc_ue(uint32_t enb_cc_idx) // Pre-check if rnti is valid { srsran::rwlock_read_guard read_lock(rwlock); - if (not is_rnti_valid_unsafe(rnti)) { + if (not is_rnti_valid_nolock(rnti)) { continue; } } @@ -205,7 +205,7 @@ uint16_t mac_nr::alloc_ue(uint32_t enb_cc_idx) // Add UE to rnti map srsran::rwlock_write_guard rw_lock(rwlock); - if (not is_rnti_valid_unsafe(rnti)) { + if (not is_rnti_valid_nolock(rnti)) { continue; } auto ret = ue_db.insert(rnti, std::move(ue_ptr)); @@ -223,7 +223,7 @@ uint16_t mac_nr::alloc_ue(uint32_t enb_cc_idx) int mac_nr::remove_ue(uint16_t rnti) { srsran::rwlock_write_guard lock(rwlock); - if (is_rnti_active_unsafe(rnti)) { + if (is_rnti_active_nolock(rnti)) { ue_db.erase(rnti); } else { logger.error("User rnti=0x%x not found", rnti); @@ -233,7 +233,7 @@ int mac_nr::remove_ue(uint16_t rnti) return SRSRAN_SUCCESS; } -bool mac_nr::is_rnti_valid_unsafe(uint16_t rnti) +bool mac_nr::is_rnti_valid_nolock(uint16_t rnti) { if (not started) { logger.info("RACH ignored as eNB is being shutdown"); @@ -250,7 +250,7 @@ bool mac_nr::is_rnti_valid_unsafe(uint16_t rnti) return true; } -bool mac_nr::is_rnti_active_unsafe(uint16_t rnti) +bool mac_nr::is_rnti_active_nolock(uint16_t rnti) { if (not ue_db.contains(rnti)) { logger.error("User rnti=0x%x not found", rnti); @@ -292,7 +292,7 @@ int mac_nr::get_dl_sched(const srsran_slot_cfg_t& slot_cfg, dl_sched_t& dl_sched for (pdsch_t& pdsch : dl_sched.pdsch) { if (pdsch.sch.grant.rnti_type == srsran_rnti_type_c) { uint16_t rnti = pdsch.sch.grant.rnti; - if (not is_rnti_active_unsafe(rnti)) { + if (not is_rnti_active_nolock(rnti)) { continue; } for (auto& tb_data : pdsch.data) { @@ -372,7 +372,7 @@ int mac_nr::pusch_info(const srsran_slot_cfg_t& slot_cfg, mac_interface_phy_nr:: auto process_pdu_task = [this, rnti](srsran::unique_byte_buffer_t& pdu) { srsran::rwlock_read_guard lock(rwlock); - if (is_rnti_active_unsafe(rnti)) { + if (is_rnti_active_nolock(rnti)) { ue_db[rnti]->process_pdu(std::move(pdu)); } else { logger.debug("Discarding PDU rnti=0x%x", rnti); diff --git a/srsue/hdr/phy/lte/cc_worker.h b/srsue/hdr/phy/lte/cc_worker.h index ada77a0c7..de43e534f 100644 --- a/srsue/hdr/phy/lte/cc_worker.h +++ b/srsue/hdr/phy/lte/cc_worker.h @@ -32,16 +32,16 @@ public: uint32_t get_buffer_len(); void set_tti(uint32_t tti); - void set_cfo_unlocked(float cfo); + void set_cfo_nolock(float cfo); float get_ref_cfo() const; // Functions to set configuration. // Warning: all these functions are unlocked and must be called while the worker is not processing data - void reset_cell_unlocked(); - bool set_cell_unlocked(srsran_cell_t cell_); - void set_tdd_config_unlocked(srsran_tdd_config_t config); - void set_config_unlocked(const srsran::phy_cfg_t& phy_cfg); - void upd_config_dci_unlocked(const srsran_dci_cfg_t& dci_cfg); + void reset_cell_nolock(); + bool set_cell_nolock(srsran_cell_t cell_); + void set_tdd_config_nolock(srsran_tdd_config_t config); + void set_config_nolock(const srsran::phy_cfg_t& phy_cfg); + void upd_config_dci_nolock(const srsran_dci_cfg_t& dci_cfg); void set_uci_periodic_cqi(srsran_uci_data_t* uci_data); diff --git a/srsue/hdr/phy/lte/sf_worker.h b/srsue/hdr/phy/lte/sf_worker.h index 3f1c48db6..98694ecf4 100644 --- a/srsue/hdr/phy/lte/sf_worker.h +++ b/srsue/hdr/phy/lte/sf_worker.h @@ -36,18 +36,18 @@ public: sf_worker(uint32_t max_prb, phy_common* phy_, srslog::basic_logger& logger); virtual ~sf_worker(); - void reset_cell_unlocked(uint32_t cc_idx); - bool set_cell_unlocked(uint32_t cc_idx, srsran_cell_t cell_); + void reset_cell_nolock(uint32_t cc_idx); + bool set_cell_nolock(uint32_t cc_idx, srsran_cell_t cell_); /* Functions used by main PHY thread */ cf_t* get_buffer(uint32_t cc_idx, uint32_t antenna_idx); uint32_t get_buffer_len(); void set_context(const srsran::phy_common_interface::worker_context_t& w_ctx); void set_prach(cf_t* prach_ptr, float prach_power); - void set_cfo_unlocked(const uint32_t& cc_idx, float cfo); + void set_cfo_nolock(const uint32_t& cc_idx, float cfo); - void set_tdd_config_unlocked(srsran_tdd_config_t config); - void set_config_unlocked(uint32_t cc_idx, const srsran::phy_cfg_t& phy_cfg); + void set_tdd_config_nolock(srsran_tdd_config_t config); + void set_config_nolock(uint32_t cc_idx, const srsran::phy_cfg_t& phy_cfg); ///< Methods for plotting called from GUI thread int read_ce_abs(float* ce_abs, uint32_t tx_antenna, uint32_t rx_antenna); diff --git a/srsue/hdr/stack/mac/dl_harq.h b/srsue/hdr/stack/mac/dl_harq.h index 0ca4cc60c..7def18c4c 100644 --- a/srsue/hdr/stack/mac/dl_harq.h +++ b/srsue/hdr/stack/mac/dl_harq.h @@ -76,7 +76,7 @@ private: bool calc_is_new_transmission(mac_interface_phy_lte::mac_grant_dl_t grant); // Internal function to reset process, caller must hold the mutex - void reset_unsafe(); + void reset_nolock(); std::mutex mutex; @@ -109,14 +109,14 @@ private: dl_sps dl_sps_assig; - std::vector proc; - dl_harq_process bcch_proc; - demux* demux_unit = nullptr; - srslog::basic_logger& logger; - srsran::mac_pcap* pcap = nullptr; - ue_rnti* rntis = nullptr; - uint16_t last_temporal_crnti = 0; - int si_window_start = 0; + std::vector proc; + dl_harq_process bcch_proc; + demux* demux_unit = nullptr; + srslog::basic_logger& logger; + srsran::mac_pcap* pcap = nullptr; + ue_rnti* rntis = nullptr; + uint16_t last_temporal_crnti = 0; + int si_window_start = 0; std::mutex retx_cnt_mutex = {}; diff --git a/srsue/hdr/stack/mac/mux.h b/srsue/hdr/stack/mac/mux.h index 46f8a322c..589bccb7f 100644 --- a/srsue/hdr/stack/mac/mux.h +++ b/srsue/hdr/stack/mac/mux.h @@ -57,7 +57,7 @@ public: void print_logical_channel_state(const std::string& info); private: - uint8_t* pdu_get_unsafe(srsran::byte_buffer_t* payload, uint32_t pdu_sz); + uint8_t* pdu_get_nolock(srsran::byte_buffer_t* payload, uint32_t pdu_sz); bool pdu_move_to_msg3(uint32_t pdu_sz); uint32_t allocate_sdu(uint32_t lcid, srsran::sch_pdu* pdu, int max_sdu_sz); bool sched_sdu(srsran::logical_channel_config_t* ch, int* sdu_space, int max_sdu_sz); diff --git a/srsue/hdr/stack/mac/proc_ra.h b/srsue/hdr/stack/mac/proc_ra.h index 46ba9b4df..0d1844333 100644 --- a/srsue/hdr/stack/mac/proc_ra.h +++ b/srsue/hdr/stack/mac/proc_ra.h @@ -78,7 +78,7 @@ private: void response_error(); void complete(); - bool contention_resolution_id_received_unsafe(uint64_t rx_contention_id); + bool contention_resolution_id_received_nolock(uint64_t rx_contention_id); // Buffer to receive RAR PDU static const uint32_t MAX_RAR_PDU_LEN = 2048; diff --git a/srsue/hdr/stack/mac_nr/proc_sr_nr.h b/srsue/hdr/stack/mac_nr/proc_sr_nr.h index ab57b0a5e..894cb2ea5 100644 --- a/srsue/hdr/stack/mac_nr/proc_sr_nr.h +++ b/srsue/hdr/stack/mac_nr/proc_sr_nr.h @@ -40,7 +40,7 @@ public: bool sr_opportunity(uint32_t tti, uint32_t sr_id, bool meas_gap, bool ul_sch_tx); private: - void reset_unsafe(); + void reset_nolock(); int sr_counter = 0; bool is_pending_sr = false; diff --git a/srsue/src/phy/lte/cc_worker.cc b/srsue/src/phy/lte/cc_worker.cc index bf2352d34..bc788d8c7 100644 --- a/srsue/src/phy/lte/cc_worker.cc +++ b/srsue/src/phy/lte/cc_worker.cc @@ -112,15 +112,15 @@ void cc_worker::reset() { // constructor sets defaults srsran::phy_cfg_t empty_cfg; - set_config_unlocked(empty_cfg); + set_config_nolock(empty_cfg); } -void cc_worker::reset_cell_unlocked() +void cc_worker::reset_cell_nolock() { cell_initiated = false; } -bool cc_worker::set_cell_unlocked(srsran_cell_t cell_) +bool cc_worker::set_cell_nolock(srsran_cell_t cell_) { if (cell.id != cell_.id || !cell_initiated) { cell = cell_; @@ -171,7 +171,7 @@ void cc_worker::set_tti(uint32_t tti) sf_cfg_ul.shortened = false; } -void cc_worker::set_cfo_unlocked(float cfo) +void cc_worker::set_cfo_nolock(float cfo) { ue_ul_cfg.cfo_value = cfo; } @@ -181,7 +181,7 @@ float cc_worker::get_ref_cfo() const return ue_dl.chest_res.cfo; } -void cc_worker::set_tdd_config_unlocked(srsran_tdd_config_t config) +void cc_worker::set_tdd_config_nolock(srsran_tdd_config_t config) { sf_cfg_dl.tdd_config = config; sf_cfg_ul.tdd_config = config; @@ -874,7 +874,7 @@ void cc_worker::set_uci_ack(srsran_uci_data_t* uci_data, /* Translates RRC structs into PHY structs */ -void cc_worker::set_config_unlocked(const srsran::phy_cfg_t& phy_cfg) +void cc_worker::set_config_nolock(const srsran::phy_cfg_t& phy_cfg) { // Save configuration ue_dl_cfg.cfg = phy_cfg.dl_cfg; @@ -883,7 +883,7 @@ void cc_worker::set_config_unlocked(const srsran::phy_cfg_t& phy_cfg) phy->set_pdsch_cfg(&ue_dl_cfg.cfg.pdsch); } -void cc_worker::upd_config_dci_unlocked(const srsran_dci_cfg_t& dci_cfg) +void cc_worker::upd_config_dci_nolock(const srsran_dci_cfg_t& dci_cfg) { ue_dl_cfg.cfg.dci = dci_cfg; } diff --git a/srsue/src/phy/lte/sf_worker.cc b/srsue/src/phy/lte/sf_worker.cc index 9627b063e..fd14e896e 100644 --- a/srsue/src/phy/lte/sf_worker.cc +++ b/srsue/src/phy/lte/sf_worker.cc @@ -64,15 +64,15 @@ sf_worker::~sf_worker() } } -void sf_worker::reset_cell_unlocked(uint32_t cc_idx) +void sf_worker::reset_cell_nolock(uint32_t cc_idx) { - cc_workers[cc_idx]->reset_cell_unlocked(); + cc_workers[cc_idx]->reset_cell_nolock(); } -bool sf_worker::set_cell_unlocked(uint32_t cc_idx, srsran_cell_t cell_) +bool sf_worker::set_cell_nolock(uint32_t cc_idx, srsran_cell_t cell_) { if (cc_idx < cc_workers.size()) { - if (!cc_workers[cc_idx]->set_cell_unlocked(cell_)) { + if (!cc_workers[cc_idx]->set_cell_nolock(cell_)) { Error("Setting cell for cc=%d", cc_idx); return false; } @@ -120,26 +120,26 @@ void sf_worker::set_prach(cf_t* prach_ptr_, float prach_power_) prach_power = prach_power_; } -void sf_worker::set_cfo_unlocked(const uint32_t& cc_idx, float cfo) +void sf_worker::set_cfo_nolock(const uint32_t& cc_idx, float cfo) { - cc_workers[cc_idx]->set_cfo_unlocked(cfo); + cc_workers[cc_idx]->set_cfo_nolock(cfo); } -void sf_worker::set_tdd_config_unlocked(srsran_tdd_config_t config) +void sf_worker::set_tdd_config_nolock(srsran_tdd_config_t config) { for (auto& cc_worker : cc_workers) { - cc_worker->set_tdd_config_unlocked(config); + cc_worker->set_tdd_config_nolock(config); } tdd_config = config; } -void sf_worker::set_config_unlocked(uint32_t cc_idx, const srsran::phy_cfg_t& phy_cfg) +void sf_worker::set_config_nolock(uint32_t cc_idx, const srsran::phy_cfg_t& phy_cfg) { if (cc_idx < cc_workers.size()) { - cc_workers[cc_idx]->set_config_unlocked(phy_cfg); + cc_workers[cc_idx]->set_config_nolock(phy_cfg); if (cc_idx > 0) { // Update DCI config for PCell - cc_workers[0]->upd_config_dci_unlocked(phy_cfg.dl_cfg.dci); + cc_workers[0]->upd_config_dci_nolock(phy_cfg.dl_cfg.dci); } } else { Error("Setting config for cc=%d; Invalid cc_idx", cc_idx); diff --git a/srsue/src/phy/lte/worker_pool.cc b/srsue/src/phy/lte/worker_pool.cc index f65bc9b0a..c130e3c71 100644 --- a/srsue/src/phy/lte/worker_pool.cc +++ b/srsue/src/phy/lte/worker_pool.cc @@ -78,7 +78,7 @@ sf_worker* worker_pool::wait_worker(uint32_t tti) uint32_t worker_id = w->get_id(); for (uint32_t cc_idx = 0; cc_idx < SRSRAN_MAX_CARRIERS; cc_idx++) { if (phy_cfg_stash[cc_idx].is_pending(worker_id)) { - w->set_config_unlocked(cc_idx, phy_cfg_stash[cc_idx].get_cfg(worker_id)); + w->set_config_nolock(cc_idx, phy_cfg_stash[cc_idx].get_cfg(worker_id)); } } diff --git a/srsue/src/phy/phy.cc b/srsue/src/phy/phy.cc index 94672b253..4e917a0e8 100644 --- a/srsue/src/phy/phy.cc +++ b/srsue/src/phy/phy.cc @@ -527,10 +527,10 @@ bool phy::set_scell(srsran_cell_t cell_info, uint32_t cc_idx, uint32_t earfcn) if (w) { // Reset secondary serving cell configuration, this needs to be done when the sf_worker is reserved to prevent // resetting the cell while it is working - w->reset_cell_unlocked(cc_idx); + w->reset_cell_nolock(cc_idx); // Set the new cell - w->set_cell_unlocked(cc_idx, cell_info); + w->set_cell_nolock(cc_idx, cell_info); // Release the new worker, it should not start processing until the SCell state is set to configured w->release(); @@ -578,7 +578,7 @@ void phy::set_config_tdd(srsran_tdd_config_t& tdd_config_) // set_tdd_config is not protected so run when worker is finished lte::sf_worker* w = lte_workers.wait_worker_id(i); if (w) { - w->set_tdd_config_unlocked(tdd_config); + w->set_tdd_config_nolock(tdd_config); w->release(); } } diff --git a/srsue/src/phy/sync.cc b/srsue/src/phy/sync.cc index 4acf03daf..4209edeba 100644 --- a/srsue/src/phy/sync.cc +++ b/srsue/src/phy/sync.cc @@ -517,7 +517,7 @@ void sync::run_camping_in_sync_state(lte::sf_worker* lte_worker, // Set CFO for all Carriers for (uint32_t cc = 0; cc < worker_com->args->nof_lte_carriers; cc++) { - lte_worker->set_cfo_unlocked(cc, get_tx_cfo()); + lte_worker->set_cfo_nolock(cc, get_tx_cfo()); worker_com->update_cfo_measurement(cc, cfo); } @@ -853,14 +853,14 @@ bool sync::set_cell(float cfo_in) // Reset cell configuration for (uint32_t i = 0; i < worker_com->args->nof_phy_threads; i++) { - (*lte_worker_pool)[i]->reset_cell_unlocked(0); + (*lte_worker_pool)[i]->reset_cell_nolock(0); } bool success = true; for (uint32_t i = 0; i < worker_com->args->nof_phy_threads; i++) { lte::sf_worker* w = lte_worker_pool->wait_worker_id(i); if (w) { - success &= w->set_cell_unlocked(0, cell.get()); + success &= w->set_cell_nolock(0, cell.get()); w->release(); } } diff --git a/srsue/src/stack/mac/dl_harq.cc b/srsue/src/stack/mac/dl_harq.cc index 900cfe4b8..7d2484b94 100644 --- a/srsue/src/stack/mac/dl_harq.cc +++ b/srsue/src/stack/mac/dl_harq.cc @@ -207,10 +207,10 @@ bool dl_harq_entity::dl_harq_process::dl_tb_process::init(int pid, dl_harq_entit void dl_harq_entity::dl_harq_process::dl_tb_process::reset() { std::lock_guard lock(mutex); - reset_unsafe(); + reset_nolock(); } -void dl_harq_entity::dl_harq_process::dl_tb_process::reset_unsafe() +void dl_harq_entity::dl_harq_process::dl_tb_process::reset_nolock() { bzero(&cur_grant, sizeof(mac_interface_phy_lte::mac_grant_dl_t)); is_first_tb = true; @@ -300,7 +300,7 @@ void dl_harq_entity::dl_harq_process::dl_tb_process::new_grant_dl(mac_interface_ n_retx > RESET_DUPLICATE_TIMEOUT ? "yes" : "no"); if (n_retx > RESET_DUPLICATE_TIMEOUT) { // reset without trying to acquire the mutex again - reset_unsafe(); + reset_nolock(); } } @@ -360,7 +360,7 @@ void dl_harq_entity::dl_harq_process::dl_tb_process::tb_decoded(mac_interface_ph if (ack && is_bcch) { // reset without trying to acquire the mutex again - reset_unsafe(); + reset_nolock(); } mutex.unlock(); diff --git a/srsue/src/stack/mac/mux.cc b/srsue/src/stack/mac/mux.cc index 654f329e5..6cc7d1b1f 100644 --- a/srsue/src/stack/mac/mux.cc +++ b/srsue/src/stack/mac/mux.cc @@ -99,11 +99,11 @@ srsran::ul_sch_lcid bsr_format_convert(bsr_proc::bsr_format_t format) uint8_t* mux::pdu_get(srsran::byte_buffer_t* payload, uint32_t pdu_sz) { std::lock_guard lock(mutex); - return pdu_get_unsafe(payload, pdu_sz); + return pdu_get_nolock(payload, pdu_sz); } // Multiplexing and logical channel priorization as defined in Section 5.4.3 -uint8_t* mux::pdu_get_unsafe(srsran::byte_buffer_t* payload, uint32_t pdu_sz) +uint8_t* mux::pdu_get_nolock(srsran::byte_buffer_t* payload, uint32_t pdu_sz) { // Logical Channel Procedure payload->clear(); @@ -363,7 +363,7 @@ uint8_t* mux::msg3_get(srsran::byte_buffer_t* payload, uint32_t pdu_sz) std::lock_guard lock(mutex); if (pdu_sz < msg3_buff.get_tailroom()) { if (msg3_is_empty()) { - if (!pdu_get_unsafe(&msg3_buff, pdu_sz)) { + if (!pdu_get_nolock(&msg3_buff, pdu_sz)) { Error("Moving PDU from Mux unit to Msg3 buffer"); return NULL; } diff --git a/srsue/src/stack/mac/proc_ra.cc b/srsue/src/stack/mac/proc_ra.cc index 902b09b58..d58f1ef7a 100644 --- a/srsue/src/stack/mac/proc_ra.cc +++ b/srsue/src/stack/mac/proc_ra.cc @@ -152,9 +152,9 @@ void ra_proc::state_pdcch_setup() rInfo("seq=%d, ra-rnti=0x%x, ra-tti=%d, f_id=%d", sel_preamble.load(), ra_rnti, info.tti_ra, info.f_id); srsran::console( "Random Access Transmission: seq=%d, tti=%d, ra-rnti=0x%x\n", sel_preamble.load(), info.tti_ra, ra_rnti); - rar_window_st = ra_tti + 3; + rar_window_st = ra_tti + 3; rntis->set_rar_rnti(ra_rnti); - state = RESPONSE_RECEPTION; + state = RESPONSE_RECEPTION; } else { rDebug("preamble not yet transmitted"); } @@ -219,7 +219,7 @@ void ra_proc::initialization() transmitted_contention_id = 0; preambleTransmissionCounter = 1; mux_unit->msg3_flush(); - backoff_param_ms = 0; + backoff_param_ms = 0; transmitted_crnti = 0; resource_selection(); } @@ -536,14 +536,14 @@ void ra_proc::timer_expired(uint32_t timer_id) */ bool ra_proc::contention_resolution_id_received(uint64_t rx_contention_id) { - task_queue.push([this, rx_contention_id]() { contention_resolution_id_received_unsafe(rx_contention_id); }); + task_queue.push([this, rx_contention_id]() { contention_resolution_id_received_nolock(rx_contention_id); }); return (transmitted_contention_id == rx_contention_id); } /* * Performs the actions defined in 5.1.5 for Temporal C-RNTI Contention Resolution */ -bool ra_proc::contention_resolution_id_received_unsafe(uint64_t rx_contention_id) +bool ra_proc::contention_resolution_id_received_nolock(uint64_t rx_contention_id) { bool uecri_successful = false; diff --git a/srsue/src/stack/mac_nr/proc_sr_nr.cc b/srsue/src/stack/mac_nr/proc_sr_nr.cc index e68b0483b..a5fc7a513 100644 --- a/srsue/src/stack/mac_nr/proc_sr_nr.cc +++ b/srsue/src/stack/mac_nr/proc_sr_nr.cc @@ -35,10 +35,10 @@ int32_t proc_sr_nr::init(mac_interface_sr_nr* mac_, phy_interface_mac_nr* phy_, void proc_sr_nr::reset() { std::lock_guard lock(mutex); - reset_unsafe(); + reset_nolock(); } -void proc_sr_nr::reset_unsafe() +void proc_sr_nr::reset_nolock() { is_pending_sr = false; } @@ -92,7 +92,7 @@ void proc_sr_nr::step(uint32_t tti) // 2> initiate a Random Access procedure (see clause 5.1) on the SpCell and cancel the pending SR. logger.info("SR: PUCCH not configured. Starting RA procedure"); mac->start_ra(); - reset_unsafe(); + reset_nolock(); return; } @@ -110,7 +110,7 @@ void proc_sr_nr::step(uint32_t tti) // ... TODO mac->start_ra(); - reset_unsafe(); + reset_nolock(); } }