phy: review channel equalizer abnormal cases

Author: xavierarteaga

include/srsran/phy/support/re_buffer.h

@@ -278,13 +278,15 @@ class static_re_buffer : public re_buffer_reader<T>, public re_buffer_writer<T>
 /// \ref set_slice method.
 ///
 /// \tparam T Resource element type.
-template <typename T = cf_t>
+template <unsigned MaxNofSlices, typename T = cf_t>
 class modular_re_buffer_reader : public re_buffer_reader<T>
 {
 public:
-  /// \brief Constructs a modular resource element buffer for a given maximum number of slices and resource elements.
-  /// \param[in] max_nof_slices Maximum number of slices.
-  modular_re_buffer_reader(unsigned max_nof_slices) : nof_slices(0), nof_re(0), data(max_nof_slices) {}
+  /// Constructs a modular resource element buffer.
+  modular_re_buffer_reader() : nof_slices(0), nof_re(0) {}
+
+  /// Constructs a modular resource element buffer for a given number of slices and resource elements.
+  modular_re_buffer_reader(unsigned nof_slices_, unsigned nof_re_) { resize(nof_slices_, nof_re_); }
 
   /// \brief Resizes the buffer view to a desired number of RE and slices.
   /// \param[in] nof_slices Number of slices.
@@ -340,7 +342,7 @@ class modular_re_buffer_reader : public re_buffer_reader<T>
   unsigned nof_re;
 
   /// Internal data storage.
-  std::vector<span<const T>> data;
+  std::array<span<const T>, MaxNofSlices> data;
 };
 
 /// \brief Implements a modular resource element buffer writer.

include/srsran/phy/upper/equalization/modular_ch_est_list.h

@@ -16,6 +16,7 @@
 namespace srsran {
 
 /// Implements the list of channel estimates with views to each of the channels.
+template <unsigned MaxNofElements>
 class modular_ch_est_list : public channel_equalizer::ch_est_list
 {
 public:
@@ -25,6 +26,12 @@ class modular_ch_est_list : public channel_equalizer::ch_est_list
   modular_ch_est_list(unsigned max_nof_rx_ports_, unsigned max_nof_layers_) :
     max_nof_rx_ports(max_nof_rx_ports_), max_nof_layers(max_nof_layers_), data({max_nof_rx_ports, max_nof_layers})
   {
+    srsran_assert(max_nof_rx_ports * max_nof_layers <= MaxNofElements,
+                  "The maximum number of layers (i.e., {}) times the maximum number of ports (i.e., {}) exceeds the "
+                  "maximum number of elements (i.e., {})",
+                  max_nof_layers,
+                  max_nof_rx_ports,
+                  MaxNofElements);
   }
 
   /// \brief Sets the contents of a channel.
@@ -97,7 +104,7 @@ class modular_ch_est_list : public channel_equalizer::ch_est_list
   /// Maximum number of layers.
   unsigned max_nof_layers;
   /// Data storage as a tensor of views for each channel.
-  dynamic_tensor<std::underlying_type_t<ch_dims>(ch_dims::nof_dims), span<const cbf16_t>, ch_dims> data;
+  static_tensor<std::underlying_type_t<ch_dims>(ch_dims::nof_dims), span<const cbf16_t>, MaxNofElements, ch_dims> data;
 };
 
 } // namespace srsran

lib/phy/upper/channel_processors/pusch/pusch_demodulator_impl.h

@@ -46,7 +46,6 @@ class pusch_demodulator_impl : public pusch_demodulator
     evm_calc(std::move(evm_calc_)),
     descrambler(std::move(descrambler_)),
     ch_re_copy(MAX_PORTS, max_nof_rb * NRE),
-    ch_re_view(pusch_constants::MAX_NOF_RX_PORTS),
     temp_eq_re(max_nof_rb * NRE * pusch_constants::MAX_NOF_LAYERS),
     temp_eq_noise_vars(max_nof_rb * NRE * pusch_constants::MAX_NOF_LAYERS),
     ch_estimates_copy(max_nof_rb * NRE, pusch_constants::MAX_NOF_RX_PORTS, pusch_constants::MAX_NOF_LAYERS),
@@ -215,15 +214,15 @@ class pusch_demodulator_impl : public pusch_demodulator
   /// Copy buffer used to transfer channel modulation symbols from the resource grid to the equalizer.
   dynamic_re_buffer<cbf16_t> ch_re_copy;
   /// View buffer used to transfer channel modulation symbols from the resource grid to the equalizer.
-  modular_re_buffer_reader<cbf16_t> ch_re_view;
+  modular_re_buffer_reader<MAX_PORTS, cbf16_t> ch_re_view;
   /// Buffer used to store channel modulation resource elements at the equalizer output.
   std::vector<cf_t> temp_eq_re;
   /// Buffer used to transfer symbol noise variances at the equalizer output.
   std::vector<float> temp_eq_noise_vars;
   /// Copy buffer used to transfer channel estimation coefficients from the channel estimate to the equalizer.
   dynamic_ch_est_list ch_estimates_copy;
   /// View buffer used to transfer channel estimation coefficients from the channel estimate to the equalizer.
-  modular_ch_est_list ch_estimates_view;
+  modular_ch_est_list<pusch_constants::MAX_NOF_RX_PORTS * pusch_constants::MAX_NOF_LAYERS> ch_estimates_view;
   /// Buffer used to transfer noise variance estimates from the channel estimate to the equalizer.
   std::array<float, MAX_PORTS> noise_var_estimates;
 

lib/phy/upper/equalization/channel_equalizer_generic_impl.cpp

@@ -16,6 +16,8 @@
 #include "equalize_zf_1xn.h"
 #include "equalize_zf_2xn.h"
 #include "srsran/adt/interval.h"
+#include "srsran/phy/support/re_buffer.h"
+#include "srsran/phy/upper/equalization/modular_ch_est_list.h"
 
 using namespace srsran;
 
@@ -116,6 +118,61 @@ void equalize_zf_single_tx_layer<1>(unsigned /**/,
   equalize_zf_1xn<1>(eq_symbols, eq_noise_vars, ch_symbols, ch_estimates, noise_var, tx_scaling);
 }
 
+template <unsigned NOF_PORTS>
+void equalize_zf_single_tx_layer_reduction(unsigned                              nof_ports,
+                                           span<cf_t>                            eq_symbols,
+                                           span<float>                           eq_noise_vars,
+                                           const re_buffer_reader<cbf16_t>&      ch_symbols,
+                                           const channel_equalizer::ch_est_list& ch_estimates,
+                                           span<const float>                     noise_var,
+                                           float                                 tx_scaling)
+{
+  // Function for checking if a noise variance is valid.
+  const auto func_valid_noise_var = [](float nvar) {
+    return (nvar > 0) && (nvar < std::numeric_limits<float>::infinity());
+  };
+
+  // Count the number of valid noise variances.
+  unsigned nof_valid_noise_var = std::count_if(noise_var.begin(), noise_var.end(), func_valid_noise_var);
+
+  // No valid noise variances, fill output with invalid data.
+  if (nof_valid_noise_var == 0) {
+    srsvec::zero(eq_symbols);
+    srsvec::fill(eq_noise_vars, std::numeric_limits<float>::infinity());
+    return;
+  }
+
+  // Exclude the ports that are invalid.
+  if (nof_valid_noise_var != nof_ports) {
+    // Reduce ports.
+    static_vector<float, NOF_PORTS>              reduced_noise_var(nof_valid_noise_var);
+    modular_re_buffer_reader<NOF_PORTS, cbf16_t> reduced_ch_symbols(nof_ports, ch_symbols.get_nof_re());
+    modular_ch_est_list<NOF_PORTS>               reduced_ch_estimates(nof_ports, ch_symbols.get_nof_re());
+    for (unsigned i_port = 0, i_reduced_port = 0; i_port != nof_ports; ++i_port) {
+      if (func_valid_noise_var(noise_var[i_port])) {
+        reduced_noise_var[i_reduced_port] = noise_var[i_port];
+        reduced_ch_symbols.set_slice(i_reduced_port, ch_symbols.get_slice(i_port));
+        reduced_ch_estimates.set_channel(ch_estimates.get_channel(i_port, 0), i_reduced_port, 0);
+        ++i_reduced_port;
+      }
+    }
+
+    // Equalize. The number of ports must be at least one less than before.
+    equalize_zf_single_tx_layer<NOF_PORTS - 1>(nof_valid_noise_var,
+                                               eq_symbols,
+                                               eq_noise_vars,
+                                               reduced_ch_symbols,
+                                               reduced_ch_estimates,
+                                               reduced_noise_var,
+                                               tx_scaling);
+    return;
+  }
+
+  // Perform equalization for all ports.
+  equalize_zf_single_tx_layer<NOF_PORTS>(
+      nof_valid_noise_var, eq_symbols, eq_noise_vars, ch_symbols, ch_estimates, noise_var, tx_scaling);
+}
+
 /// Calls the equalizer function for receive spatial diversity with the appropriate number of receive ports.
 template <unsigned NOF_PORTS>
 void equalize_mmse_single_tx_layer(unsigned                              nof_ports,
@@ -173,7 +230,7 @@ void channel_equalizer_generic_impl::equalize(span<cf_t>                       e
   if (type == channel_equalizer_algorithm_type::zf) {
     // Single transmit layer and any number of receive ports.
     if (nof_tx_layers == 1) {
-      equalize_zf_single_tx_layer<MAX_PORTS>(
+      equalize_zf_single_tx_layer_reduction<MAX_PORTS>(
           nof_rx_ports, eq_symbols, eq_noise_vars, ch_symbols, ch_estimates, noise_var_estimates, tx_scaling);
       return;
     }

lib/phy/upper/equalization/equalize_zf_1xn.h

@@ -74,12 +74,8 @@ void equalize_zf_1xn(span<cf_t>                            symbols_out,
       // Load noise variance in a SIMD register.
       simd_f_t port_noise_var_est = srsran_simd_f_set1(noise_var_est[i_port]);
 
-      // Detect abnormal computation parameters. This detects whether the channel estimate and the port noise variance
-      // estimation are negative, NaN or infinite.
-      simd_sel_t isnormal_mask = srsran_simd_f_max(ch_est_norm, zero);
-      isnormal_mask            = srsran_simd_sel_and(isnormal_mask, srsran_simd_f_max(infinity, ch_est_norm));
-      isnormal_mask            = srsran_simd_sel_and(isnormal_mask, srsran_simd_f_max(port_noise_var_est, zero));
-      isnormal_mask            = srsran_simd_sel_and(isnormal_mask, srsran_simd_f_max(infinity, port_noise_var_est));
+      // Detect an abnormal computation parameter. This detects whether the channel estimate is NaN or infinite.
+      simd_sel_t isnormal_mask = srsran_simd_f_max(infinity, ch_est_norm);
 
       // Compute the channel square norm, by accumulating the channel square absolute values.
       ch_mod_sq = srsran_simd_f_add_sel(ch_mod_sq, ch_est_norm, isnormal_mask);
@@ -106,12 +102,6 @@ void equalize_zf_1xn(span<cf_t>                            symbols_out,
     // Calculate noise variances.
     simd_f_t vars_out = srsran_simd_f_mul(nvar_acc, srsran_simd_f_mul(d_pinv_rcp, d_pinv_rcp));
 
-    // Detect whenever the post-equalization noise variances are zero, negative or NaN.
-    isnormal_mask = srsran_simd_sel_and(isnormal_mask, srsran_simd_f_max(vars_out, zero));
-
-    // Detect whenever the post-equalization noise variances are set to infinity.
-    isnormal_mask = srsran_simd_sel_and(isnormal_mask, srsran_simd_f_max(infinity, vars_out));
-
     // If abnormal calculation parameters are detected, the noise variances are set to infinity.
     srsran_simd_f_storeu(nvars_out.data() + i_re, srsran_simd_f_select(infinity, vars_out, isnormal_mask));