all: more srsgnb-to-srsran renaming

dvdgrgrtt · codebot · commit c02dc10533e1 · 2023-02-22T15:53:48.000Z
srsgnb_terminate -&gt; srsran_terminate
srsgnb_srsvec_assert_size -&gt; srsran_srsvec_assert_size
diff --git a/include/srsran/adt/unique_function.h b/include/srsran/adt/unique_function.h
@@ -56,7 +56,7 @@ class empty_table_t final : public oper_table_t<R, Args...>
   constexpr empty_table_t() = default;
   R call(void* src, Args... args) const override
   {
-    srsgnb_terminate("bad function call (cause: function ptr is empty)");
+    srsran_terminate("bad function call (cause: function ptr is empty)");
   }
   void move(void* src, void* dest) const override {}
   void dtor(void* src) const override {}
diff --git a/include/srsran/srsvec/binary.h b/include/srsran/srsvec/binary.h
@@ -25,8 +25,8 @@ void binary_xor(const T& x, const U& y, V&& z)
                 "Template type is not compatible with a span of integers");
   static_assert(detail::is_integral_span_compatible<V>::value,
                 "Template type is not compatible with a span of integers");
-  srsgnb_srsvec_assert_size(x, y);
-  srsgnb_srsvec_assert_size(x, z);
+  srsran_srsvec_assert_size(x, y);
+  srsran_srsvec_assert_size(x, z);
 
   for (std::size_t i = 0, len = x.size(); i != len; ++i) {
     z[i] = x[i] ^ y[i];
@@ -42,8 +42,8 @@ void binary_and(const T& x, const U& y, V&& z)
                 "Template type is not compatible with a span of integers");
   static_assert(detail::is_integral_span_compatible<V>::value,
                 "Template type is not compatible with a span of integers");
-  srsgnb_srsvec_assert_size(x, y);
-  srsgnb_srsvec_assert_size(x, z);
+  srsran_srsvec_assert_size(x, y);
+  srsran_srsvec_assert_size(x, z);
 
   for (std::size_t i = 0, len = x.size(); i != len; ++i) {
     z[i] = x[i] & y[i];
@@ -59,8 +59,8 @@ void binary_or(const T& x, const U& y, V&& z)
                 "Template type is not compatible with a span of integers");
   static_assert(detail::is_integral_span_compatible<V>::value,
                 "Template type is not compatible with a span of integers");
-  srsgnb_srsvec_assert_size(x, y);
-  srsgnb_srsvec_assert_size(x, z);
+  srsran_srsvec_assert_size(x, y);
+  srsran_srsvec_assert_size(x, z);
 
   for (std::size_t i = 0, len = x.size(); i != len; ++i) {
     z[i] = x[i] | y[i];
diff --git a/include/srsran/srsvec/compare.h b/include/srsran/srsvec/compare.h
@@ -25,7 +25,7 @@ bool equal(const T1& s1, const T2& s2)
 {
   static_assert(detail::is_span_compatible<T1>::value, "Template type is not compatible with a span");
   static_assert(detail::is_span_compatible<T2>::value, "Template type is not compatible with a span");
-  srsgnb_srsvec_assert_size(s1, s2);
+  srsran_srsvec_assert_size(s1, s2);
 
   return std::equal(s1.begin(), s1.end(), s2.begin(), s2.end());
 }
diff --git a/include/srsran/srsvec/copy.h b/include/srsran/srsvec/copy.h
@@ -21,7 +21,7 @@ void copy(T&& dst, const U& src)
 {
   static_assert(detail::is_span_compatible<T>::value, "Template type is not compatible with a span");
   static_assert(detail::is_span_compatible<U>::value, "Template type is not compatible with a span");
-  srsgnb_srsvec_assert_size(dst, src);
+  srsran_srsvec_assert_size(dst, src);
 
   std::copy(src.begin(), src.end(), dst.begin());
 }
diff --git a/include/srsran/srsvec/dot_prod.h b/include/srsran/srsvec/dot_prod.h
@@ -43,7 +43,7 @@ inline V dot_prod(const T& x, const U& y, V init)
                 "Template type is not compatible with a span of arithmetics");
   static_assert(detail::is_arithmetic_span_compatible<U>::value,
                 "Template type is not compatible with a span of arithmetics");
-  srsgnb_srsvec_assert_size(x, y);
+  srsran_srsvec_assert_size(x, y);
   return std::inner_product(x.begin(), x.end(), y.begin(), init);
 }
 
diff --git a/include/srsran/srsvec/types.h b/include/srsran/srsvec/types.h
@@ -24,6 +24,6 @@
 //
 // To make the span constant use srsran::span<const T>.
 
-#define srsgnb_srsvec_assert_size(X, Y)                                                                                \
+#define srsran_srsvec_assert_size(X, Y)                                                                                \
   srsran_assert(                                                                                                       \
       X.size() == Y.size(), "The size " #X " (i.e., {}) and " #Y " (i.e., {}) must be equal.", X.size(), Y.size())
diff --git a/include/srsran/support/error_handling.h b/include/srsran/support/error_handling.h
@@ -18,7 +18,7 @@ namespace srsran {
 /// Attribute noinline is used to signal to the compiler that this path should rarely occur and therefore doesn't need
 /// to get optimized.
 template <typename... Args>
-[[gnu::noinline, noreturn]] inline bool srsgnb_terminate(const char* fmt, Args&&... args) noexcept
+[[gnu::noinline, noreturn]] inline bool srsran_terminate(const char* fmt, Args&&... args) noexcept
 {
   srslog::flush();
   fmt::print(stderr, fmt, std::forward<Args>(args)...);
@@ -40,7 +40,7 @@ template <typename... Args>
 template <typename... Args>
 [[gnu::noinline, noreturn]] inline void report_fatal_error(const char* reason_fmt, Args&&... args) noexcept
 {
-  srsgnb_terminate("srsGNB FATAL ERROR: {}\n", fmt::format(reason_fmt, std::forward<Args>(args)...));
+  srsran_terminate("srsGNB FATAL ERROR: {}\n", fmt::format(reason_fmt, std::forward<Args>(args)...));
 }
 
 /// \brief Verifies if condition is true. If not, report a fatal error and close application.
diff --git a/lib/mac/mac_dl/mac_cell_processor.cpp b/lib/mac/mac_dl/mac_cell_processor.cpp
@@ -263,7 +263,7 @@ static dci_payload encode_dci(const pdcch_dl_information& pdcch)
     case dci_dl_rnti_config_type::tc_rnti_f1_0:
       return dci_1_0_tc_rnti_pack(pdcch.dci.tc_rnti_f1_0);
     default:
-      srsgnb_terminate("Invalid DCI format");
+      srsran_terminate("Invalid DCI format");
   }
 }
 
@@ -276,7 +276,7 @@ static dci_payload encode_dci(const pdcch_ul_information& pdcch)
     case dci_ul_rnti_config_type::tc_rnti_f0_0:
       return dci_0_0_tc_rnti_pack(pdcch.dci.tc_rnti_f0_0);
     default:
-      srsgnb_terminate("Invalid DCI format");
+      srsran_terminate("Invalid DCI format");
   }
 }
 
diff --git a/lib/phy/lower/amplitude_controller/amplitude_controller_clipping_impl.cpp b/lib/phy/lower/amplitude_controller/amplitude_controller_clipping_impl.cpp
@@ -18,7 +18,7 @@ using namespace srsran;
 
 amplitude_controller_metrics amplitude_controller_clipping_impl::process(span<cf_t> output, span<const cf_t> input)
 {
-  srsgnb_srsvec_assert_size(output, input);
+  srsran_srsvec_assert_size(output, input);
 
   // Report clipping status.
   metrics.clipping_enabled = clipping_enabled;
diff --git a/lib/phy/upper/sequence_generators/low_papr_sequence_generator_impl.cpp b/lib/phy/upper/sequence_generators/low_papr_sequence_generator_impl.cpp
@@ -177,7 +177,7 @@ void low_papr_sequence_generator_impl::r_uv_arg(span<float> tmp_arg, uint32_t u,
   } else if (M_zc >= 36) {
     r_uv_arg_mprb(tmp_arg, u, v);
   } else {
-    srsgnb_terminate("Invalid sequence length {}", M_zc);
+    srsran_terminate("Invalid sequence length {}", M_zc);
   }
 }
 
diff --git a/lib/phy/upper/signal_processors/pucch/pucch_helper.h b/lib/phy/upper/signal_processors/pucch/pucch_helper.h
@@ -44,10 +44,10 @@ class pucch_helper
         f_ss = n_id % low_papr_sequence_collection::NOF_GROUPS;
         break;
       case pucch_group_hopping::ENABLE:
-        srsgnb_terminate("Group hopping is not implemented");
+        srsran_terminate("Group hopping is not implemented");
         return;
       case pucch_group_hopping::DISABLE:
-        srsgnb_terminate("Hopping is not implemented");
+        srsran_terminate("Hopping is not implemented");
         return;
     }
 
diff --git a/lib/rlc/rlc_factory.cpp b/lib/rlc/rlc_factory.cpp
@@ -45,7 +45,7 @@ std::unique_ptr<rlc_entity> srsran::create_rlc_entity(const rlc_entity_creation_
                                              *msg.pcell_executor,
                                              *msg.ue_executor);
     default:
-      srsgnb_terminate("RLC mode not supported.");
+      srsran_terminate("RLC mode not supported.");
   }
   return nullptr;
 }
diff --git a/lib/scheduler/support/dmrs_helpers.h b/lib/scheduler/support/dmrs_helpers.h
@@ -59,7 +59,7 @@ inline dmrs_information make_dmrs_info_common(const pdsch_config_common& pdsch_c
     dmrs.dmrs_symb_pos                        = pdsch_dmrs_symbol_mask_mapping_type_A_single_get(dmrscfg);
 
   } else {
-    srsgnb_terminate("Mapping type B not supported");
+    srsran_terminate("Mapping type B not supported");
   }
 
   dmrs.config_type        = dmrs_config_type::type1;
@@ -103,7 +103,7 @@ inline dmrs_information make_dmrs_info_common(const pusch_config_common& pusch_c
     dmrs.dmrs_symb_pos                        = pdsch_dmrs_symbol_mask_mapping_type_A_single_get(dmrscfg);
 
   } else {
-    srsgnb_terminate("Mapping type B not supported");
+    srsran_terminate("Mapping type B not supported");
   }
 
   dmrs.config_type        = dmrs_config_type::type1;
diff --git a/lib/srsvec/add.cpp b/lib/srsvec/add.cpp
@@ -109,32 +109,32 @@ static void add_bbb_simd(const int8_t* x, const int8_t* y, int8_t* z, std::size_
 
 void srsran::srsvec::add(span<const cf_t> x, span<const cf_t> y, span<cf_t> z)
 {
-  srsgnb_srsvec_assert_size(x, y);
-  srsgnb_srsvec_assert_size(x, z);
+  srsran_srsvec_assert_size(x, y);
+  srsran_srsvec_assert_size(x, z);
 
   add_fff_simd((float*)x.data(), (float*)y.data(), (float*)z.data(), 2 * z.size());
 }
 
 void srsran::srsvec::add(span<const float> x, span<const float> y, span<float> z)
 {
-  srsgnb_srsvec_assert_size(x, y);
-  srsgnb_srsvec_assert_size(x, z);
+  srsran_srsvec_assert_size(x, y);
+  srsran_srsvec_assert_size(x, z);
 
   add_fff_simd(x.data(), y.data(), z.data(), z.size());
 }
 
 void srsran::srsvec::add(span<const int16_t> x, span<const int16_t> y, span<int16_t> z)
 {
-  srsgnb_srsvec_assert_size(x, y);
-  srsgnb_srsvec_assert_size(x, z);
+  srsran_srsvec_assert_size(x, y);
+  srsran_srsvec_assert_size(x, z);
 
   add_sss_simd(x.data(), y.data(), z.data(), z.size());
 }
 
 void srsran::srsvec::add(span<const int8_t> x, span<const int8_t> y, span<int8_t> z)
 {
-  srsgnb_srsvec_assert_size(x, y);
-  srsgnb_srsvec_assert_size(x, z);
+  srsran_srsvec_assert_size(x, y);
+  srsran_srsvec_assert_size(x, z);
 
   add_bbb_simd(x.data(), y.data(), z.data(), z.size());
 }
diff --git a/lib/srsvec/clip.cpp b/lib/srsvec/clip.cpp
@@ -15,7 +15,7 @@ using namespace srsran;
 
 unsigned srsvec::clip(span<float> y, span<const float> x, const float threshold)
 {
-  srsgnb_srsvec_assert_size(x, y);
+  srsran_srsvec_assert_size(x, y);
 
   unsigned nof_clipped_samples = 0;
   unsigned len                 = x.size();
@@ -45,7 +45,7 @@ unsigned srsvec::clip_iq(span<cf_t> y, span<const cf_t> x, const float threshold
 
 unsigned srsvec::clip_magnitude(span<cf_t> y, span<const cf_t> x, const float threshold)
 {
-  srsgnb_srsvec_assert_size(x, y);
+  srsran_srsvec_assert_size(x, y);
 
   unsigned nof_clipped_samples = 0;
   unsigned len                 = x.size();
diff --git a/lib/srsvec/dot_prod.cpp b/lib/srsvec/dot_prod.cpp
@@ -17,7 +17,7 @@ using namespace srsran;
 cf_t srsran::srsvec::dot_prod(span<const cf_t> x, span<const cf_t> y)
 {
   cf_t result = 0;
-  srsgnb_srsvec_assert_size(x, y);
+  srsran_srsvec_assert_size(x, y);
 
   unsigned i = 0, len = x.size();
 #if SRSRAN_SIMD_CF_SIZE
diff --git a/lib/srsvec/prod.cpp b/lib/srsvec/prod.cpp
@@ -111,24 +111,24 @@ static void prod_conj_ccc_simd(const cf_t* x, const cf_t* y, cf_t* z, std::size_
 
 void srsran::srsvec::prod(span<const cf_t> x, span<const cf_t> y, span<cf_t> z)
 {
-  srsgnb_srsvec_assert_size(x, y);
-  srsgnb_srsvec_assert_size(x, z);
+  srsran_srsvec_assert_size(x, y);
+  srsran_srsvec_assert_size(x, z);
 
   prod_ccc_simd(x.data(), y.data(), z.data(), x.size());
 }
 
 void srsran::srsvec::prod(span<const float> x, span<const float> y, span<float> z)
 {
-  srsgnb_srsvec_assert_size(x, y);
-  srsgnb_srsvec_assert_size(x, z);
+  srsran_srsvec_assert_size(x, y);
+  srsran_srsvec_assert_size(x, z);
 
   prod_fff_simd(x.data(), y.data(), z.data(), x.size());
 }
 
 void srsran::srsvec::prod_conj(span<const cf_t> x, span<const cf_t> y, span<cf_t> z)
 {
-  srsgnb_srsvec_assert_size(x, y);
-  srsgnb_srsvec_assert_size(x, z);
+  srsran_srsvec_assert_size(x, y);
+  srsran_srsvec_assert_size(x, z);
 
   prod_conj_ccc_simd(x.data(), y.data(), z.data(), x.size());
 }
diff --git a/lib/srsvec/sc_prod.cpp b/lib/srsvec/sc_prod.cpp
@@ -77,21 +77,21 @@ static void sc_prod_ccc_simd(const cf_t* x, cf_t h, cf_t* z, std::size_t len)
 
 void srsran::srsvec::sc_prod(span<const cf_t> x, cf_t h, span<cf_t> z)
 {
-  srsgnb_srsvec_assert_size(x, z);
+  srsran_srsvec_assert_size(x, z);
 
   sc_prod_ccc_simd(x.data(), h, z.data(), x.size());
 }
 
 void srsran::srsvec::sc_prod(span<const cf_t> x, float h, span<cf_t> z)
 {
-  srsgnb_srsvec_assert_size(x, z);
+  srsran_srsvec_assert_size(x, z);
 
   sc_prod_fff_simd((float*)x.data(), h, (float*)z.data(), 2 * x.size());
 }
 
 void srsran::srsvec::sc_prod(span<const float> x, float h, span<float> z)
 {
-  srsgnb_srsvec_assert_size(x, z);
+  srsran_srsvec_assert_size(x, z);
 
   sc_prod_fff_simd(x.data(), h, z.data(), x.size());
 }
diff --git a/lib/srsvec/subtract.cpp b/lib/srsvec/subtract.cpp
@@ -109,8 +109,8 @@ static void subtract_bbb_simd(int8_t* z, const int8_t* x, const int8_t* y, std::
 
 void srsran::srsvec::subtract(span<cf_t> z, span<const cf_t> x, span<const cf_t> y)
 {
-  srsgnb_srsvec_assert_size(x, y);
-  srsgnb_srsvec_assert_size(x, z);
+  srsran_srsvec_assert_size(x, y);
+  srsran_srsvec_assert_size(x, z);
 
   subtract_fff_simd(reinterpret_cast<float*>(z.data()),
                     reinterpret_cast<const float*>(x.data()),
@@ -120,24 +120,24 @@ void srsran::srsvec::subtract(span<cf_t> z, span<const cf_t> x, span<const cf_t>
 
 void srsran::srsvec::subtract(span<float> z, span<const float> x, span<const float> y)
 {
-  srsgnb_srsvec_assert_size(x, y);
-  srsgnb_srsvec_assert_size(x, z);
+  srsran_srsvec_assert_size(x, y);
+  srsran_srsvec_assert_size(x, z);
 
   subtract_fff_simd(z.data(), x.data(), y.data(), z.size());
 }
 
 void srsran::srsvec::subtract(span<int16_t> z, span<const int16_t> x, span<const int16_t> y)
 {
-  srsgnb_srsvec_assert_size(x, y);
-  srsgnb_srsvec_assert_size(x, z);
+  srsran_srsvec_assert_size(x, y);
+  srsran_srsvec_assert_size(x, z);
 
   subtract_sss_simd(z.data(), x.data(), y.data(), z.size());
 }
 
 void srsran::srsvec::subtract(span<int8_t> z, span<const int8_t> x, span<const int8_t> y)
 {
-  srsgnb_srsvec_assert_size(x, y);
-  srsgnb_srsvec_assert_size(x, z);
+  srsran_srsvec_assert_size(x, y);
+  srsran_srsvec_assert_size(x, z);
 
   subtract_bbb_simd(z.data(), x.data(), y.data(), z.size());
 }
diff --git a/lib/support/io_broker/io_broker_factory.cpp b/lib/support/io_broker/io_broker_factory.cpp
@@ -19,7 +19,7 @@ std::unique_ptr<io_broker> srsran::create_io_broker(io_broker_type type)
     case io_broker_type::epoll:
       return std::make_unique<io_broker_epoll>(io_broker_config());
     default:
-      srsgnb_terminate("IO broker type not supported");
+      srsran_terminate("IO broker type not supported");
   }
   return nullptr;
 }
diff --git a/lib/support/math_utils.cpp b/lib/support/math_utils.cpp
@@ -52,7 +52,7 @@ unsigned srsran::prime_greater_than(unsigned n)
     }
   }
 
-  srsgnb_terminate("n={} exceeds the maximum prime.", n);
+  srsran_terminate("n={} exceeds the maximum prime.", n);
 }
 
 unsigned srsran::prime_lower_than(unsigned n)
diff --git a/tests/unittests/scheduler/common_scheduling/sib1_scheduler_test.cpp b/tests/unittests/scheduler/common_scheduling/sib1_scheduler_test.cpp
@@ -45,7 +45,7 @@ class dummy_pdcch_resource_allocator : public pdcch_resource_allocator
                                           search_space_id               ss_id,
                                           aggregation_level             aggr_lvl) override
   {
-    srsgnb_terminate("UE-dedicated PDCCHs should not be called while allocating RARs");
+    srsran_terminate("UE-dedicated PDCCHs should not be called while allocating RARs");
     return nullptr;
   }
 
@@ -56,7 +56,7 @@ class dummy_pdcch_resource_allocator : public pdcch_resource_allocator
                                           search_space_id               ss_id,
                                           aggregation_level             aggr_lvl) override
   {
-    srsgnb_terminate("UE-dedicated PDCCHs should not be called while allocating RARs");
+    srsran_terminate("UE-dedicated PDCCHs should not be called while allocating RARs");
     return nullptr;
   }
 
@@ -65,13 +65,13 @@ class dummy_pdcch_resource_allocator : public pdcch_resource_allocator
                                               search_space_id               ss_id,
                                               aggregation_level             aggr_lvl) override
   {
-    srsgnb_terminate("Common PDCCHs should not be called while allocating RARs");
+    srsran_terminate("Common PDCCHs should not be called while allocating RARs");
     return nullptr;
   }
 
   bool cancel_last_pdcch(cell_slot_resource_allocator& slot_alloc) override
   {
-    srsgnb_terminate("Not supported");
+    srsran_terminate("Not supported");
     return true;
   }
 };
diff --git a/tests/unittests/scheduler/test_utils/dummy_test_components.h b/tests/unittests/scheduler/test_utils/dummy_test_components.h
diff --git a/tests/unittests/scheduler/test_utils/scheduler_test_suite.cpp b/tests/unittests/scheduler/test_utils/scheduler_test_suite.cpp

Original file line number	Diff line number	Diff line change
`@@ -56,7 +56,7 @@ class empty_table_t final : public oper_table_t<R, Args...>`
`56`	`56`	`constexpr empty_table_t() = default;`
`57`	`57`	`R call(void* src, Args... args) const override`
`58`	`58`	`{`
`59`		`- srsgnb_terminate("bad function call (cause: function ptr is empty)");`
	`59`	`+ srsran_terminate("bad function call (cause: function ptr is empty)");`
`60`	`60`	`}`
`61`	`61`	`void move(void* src, void* dest) const override {}`
`62`	`62`	`void dtor(void* src) const override {}`
Original file line number	Diff line number	Diff line change
`@@ -25,7 +25,7 @@ bool equal(const T1& s1, const T2& s2)`
`25`	`25`	`{`
`26`	`26`	`static_assert(detail::is_span_compatible<T1>::value, "Template type is not compatible with a span");`
`27`	`27`	`static_assert(detail::is_span_compatible<T2>::value, "Template type is not compatible with a span");`
`28`		`- srsgnb_srsvec_assert_size(s1, s2);`
	`28`	`+ srsran_srsvec_assert_size(s1, s2);`
`29`	`29`
`30`	`30`	`return std::equal(s1.begin(), s1.end(), s2.begin(), s2.end());`
`31`	`31`	`}`
Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,7 @@ void copy(T&& dst, const U& src)`
`21`	`21`	`{`
`22`	`22`	`static_assert(detail::is_span_compatible<T>::value, "Template type is not compatible with a span");`
`23`	`23`	`static_assert(detail::is_span_compatible<U>::value, "Template type is not compatible with a span");`
`24`		`- srsgnb_srsvec_assert_size(dst, src);`
	`24`	`+ srsran_srsvec_assert_size(dst, src);`
`25`	`25`
`26`	`26`	`std::copy(src.begin(), src.end(), dst.begin());`
`27`	`27`	`}`
Original file line number	Diff line number	Diff line change
`@@ -43,7 +43,7 @@ inline V dot_prod(const T& x, const U& y, V init)`
`43`	`43`	`"Template type is not compatible with a span of arithmetics");`
`44`	`44`	`static_assert(detail::is_arithmetic_span_compatible<U>::value,`
`45`	`45`	`"Template type is not compatible with a span of arithmetics");`
`46`		`- srsgnb_srsvec_assert_size(x, y);`
	`46`	`+ srsran_srsvec_assert_size(x, y);`
`47`	`47`	`return std::inner_product(x.begin(), x.end(), y.begin(), init);`
`48`	`48`	`}`
`49`	`49`
Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,7 @@ namespace srsran {`
`18`	`18`	`/// Attribute noinline is used to signal to the compiler that this path should rarely occur and therefore doesn't need`
`19`	`19`	`/// to get optimized.`
`20`	`20`	`template <typename... Args>`
`21`		`-[[gnu::noinline, noreturn]] inline bool srsgnb_terminate(const char* fmt, Args&&... args) noexcept`
	`21`	`+[[gnu::noinline, noreturn]] inline bool srsran_terminate(const char* fmt, Args&&... args) noexcept`
`22`	`22`	`{`
`23`	`23`	`srslog::flush();`
`24`	`24`	`fmt::print(stderr, fmt, std::forward<Args>(args)...);`
`@@ -40,7 +40,7 @@ template <typename... Args>`
`40`	`40`	`template <typename... Args>`
`41`	`41`	`[[gnu::noinline, noreturn]] inline void report_fatal_error(const char* reason_fmt, Args&&... args) noexcept`
`42`	`42`	`{`
`43`		`- srsgnb_terminate("srsGNB FATAL ERROR: {}\n", fmt::format(reason_fmt, std::forward<Args>(args)...));`
	`43`	`+ srsran_terminate("srsGNB FATAL ERROR: {}\n", fmt::format(reason_fmt, std::forward<Args>(args)...));`
`44`	`44`	`}`
`45`	`45`
`46`	`46`	`/// \brief Verifies if condition is true. If not, report a fatal error and close application.`
Original file line number	Diff line number	Diff line change
`@@ -263,7 +263,7 @@ static dci_payload encode_dci(const pdcch_dl_information& pdcch)`
`263`	`263`	`case dci_dl_rnti_config_type::tc_rnti_f1_0:`
`264`	`264`	`return dci_1_0_tc_rnti_pack(pdcch.dci.tc_rnti_f1_0);`
`265`	`265`	`default:`
`266`		`- srsgnb_terminate("Invalid DCI format");`
	`266`	`+ srsran_terminate("Invalid DCI format");`
`267`	`267`	`}`
`268`	`268`	`}`
`269`	`269`
`@@ -276,7 +276,7 @@ static dci_payload encode_dci(const pdcch_ul_information& pdcch)`
`276`	`276`	`case dci_ul_rnti_config_type::tc_rnti_f0_0:`
`277`	`277`	`return dci_0_0_tc_rnti_pack(pdcch.dci.tc_rnti_f0_0);`
`278`	`278`	`default:`
`279`		`- srsgnb_terminate("Invalid DCI format");`
	`279`	`+ srsran_terminate("Invalid DCI format");`
`280`	`280`	`}`
`281`	`281`	`}`
`282`	`282`
Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,7 @@ using namespace srsran;`
`18`	`18`
`19`	`19`	`amplitude_controller_metrics amplitude_controller_clipping_impl::process(span<cf_t> output, span<const cf_t> input)`
`20`	`20`	`{`
`21`		`- srsgnb_srsvec_assert_size(output, input);`
	`21`	`+ srsran_srsvec_assert_size(output, input);`
`22`	`22`
`23`	`23`	`// Report clipping status.`
`24`	`24`	`metrics.clipping_enabled = clipping_enabled;`
Original file line number	Diff line number	Diff line change
`@@ -177,7 +177,7 @@ void low_papr_sequence_generator_impl::r_uv_arg(span<float> tmp_arg, uint32_t u,`
`177`	`177`	`} else if (M_zc >= 36) {`
`178`	`178`	`r_uv_arg_mprb(tmp_arg, u, v);`
`179`	`179`	`} else {`
`180`		`- srsgnb_terminate("Invalid sequence length {}", M_zc);`
	`180`	`+ srsran_terminate("Invalid sequence length {}", M_zc);`
`181`	`181`	`}`
`182`	`182`	`}`
`183`	`183`