phy: integrate transform precoding in PUSCH demodulator

phy: fix typo

Author: xavierarteaga

include/srsran/phy/upper/channel_processors/pusch/factories.h

@@ -11,6 +11,7 @@
 #pragma once
 
 #include "srsran/hal/phy/upper/channel_processors/pusch/hw_accelerator_pusch_dec_factory.h"
+#include "srsran/phy/generic_functions/transform_precoding/transform_precoding_factories.h"
 #include "srsran/phy/upper/channel_coding/channel_coding_factories.h"
 #include "srsran/phy/upper/channel_modulation/channel_modulation_factories.h"
 #include "srsran/phy/upper/channel_processors/pusch/pusch_decoder.h"
@@ -76,8 +77,10 @@ class pusch_demodulator_factory
 
 std::shared_ptr<pusch_demodulator_factory>
 create_pusch_demodulator_factory_sw(std::shared_ptr<channel_equalizer_factory>       equalizer_factory,
+                                    std::shared_ptr<transform_precoder_factory>      precoder_factory,
                                     std::shared_ptr<channel_modulation_factory>      demodulation_factory,
                                     std::shared_ptr<pseudo_random_generator_factory> prg_factory,
+                                    unsigned                                         max_nof_prb,
                                     bool                                             enable_evm          = false,
                                     bool                                             enable_post_eq_sinr = false);
 

include/srsran/phy/upper/channel_processors/pusch/pusch_demodulator.h

@@ -58,6 +58,8 @@ class pusch_demodulator
     unsigned n_id;
     /// Number of transmit layers.
     unsigned nof_tx_layers;
+    /// Set to true for enabling transform precoding.
+    bool enable_transform_precoding;
     /// Receive antenna port indices the PUSCH transmission is mapped to.
     static_vector<uint8_t, MAX_PORTS> rx_ports;
   };

include/srsran/ran/pusch/pusch_constants.h

@@ -51,6 +51,9 @@ inline constexpr units::bits get_max_codeword_size(unsigned nof_prb, unsigned no
   return units::bits{get_codeword_max_symbols(nof_prb, nof_layers) * pusch_constants::MAX_MODULATION_ORDER};
 }
 
+/// Maximum number of bits per OFDM symbol.
+constexpr unsigned MAX_NOF_BITS_PER_OFDM_SYMBOL = MAX_NOF_LAYERS * MAX_RB * NRE * pusch_constants::MAX_MODULATION_ORDER;
+
 /// Maximum number of OFDM symbols carrying DM-RS in a slot is at most \f$4 \times 2\f$, being 4 the maximum
 /// number of positions \f$\bar{l}\f$ and 2 the maximum number of indices \f$l'\f$, as per TS38.211 Section 6.4.1.1.
 static constexpr unsigned MAX_NOF_DMRS_SYMBOLS = 4 * 2;

lib/phy/upper/CMakeLists.txt

@@ -35,6 +35,7 @@ target_link_libraries(srsran_upper_phy
         srsran_uplink_processor
         srsran_phy_support
         srsran_generic_funcs
+        srsran_transform_precoding
         srsran_channel_equalizer)
 
 add_library(log_likelihood_ratio log_likelihood_ratio.cpp)

lib/phy/upper/channel_processors/pusch/factories.cpp

@@ -19,6 +19,7 @@
 #include "pusch_processor_pool.h"
 #include "pusch_processor_validator_impl.h"
 #include "ulsch_demultiplex_impl.h"
+#include "srsran/phy/generic_functions/transform_precoding/transform_precoding_factories.h"
 #include "srsran/phy/upper/channel_modulation/channel_modulation_factories.h"
 #include "srsran/phy/upper/channel_processors/pusch/pusch_processor_result_notifier.h"
 #include "srsran/phy/upper/sequence_generators/sequence_generator_factories.h"
@@ -143,32 +144,41 @@ class pusch_demodulator_factory_generic : public pusch_demodulator_factory
       evm_calc = demodulation_factory->create_evm_calculator();
     }
     return std::make_unique<pusch_demodulator_impl>(equalizer_factory->create(),
+                                                    precoder_factory->create(),
                                                     demodulation_factory->create_demodulation_mapper(),
                                                     std::move(evm_calc),
                                                     prg_factory->create(),
+                                                    max_nof_prb,
                                                     enable_post_eq_sinr);
   }
 
   pusch_demodulator_factory_generic(std::shared_ptr<channel_equalizer_factory>       equalizer_factory_,
+                                    std::shared_ptr<transform_precoder_factory>      precoder_factory_,
                                     std::shared_ptr<channel_modulation_factory>      demodulation_factory_,
                                     std::shared_ptr<pseudo_random_generator_factory> prg_factory_,
+                                    unsigned                                         max_nof_prb_,
                                     bool                                             enable_evm_,
                                     bool                                             enable_post_eq_sinr_) :
     equalizer_factory(std::move(equalizer_factory_)),
+    precoder_factory(std::move(precoder_factory_)),
     demodulation_factory(std::move(demodulation_factory_)),
     prg_factory(std::move(prg_factory_)),
+    max_nof_prb(max_nof_prb_),
     enable_evm(enable_evm_),
     enable_post_eq_sinr(enable_post_eq_sinr_)
   {
     srsran_assert(equalizer_factory, "Invalid equalizer factory.");
+    srsran_assert(precoder_factory, "Invalid transform precoder factory.");
     srsran_assert(demodulation_factory, "Invalid demodulation factory.");
     srsran_assert(prg_factory, "Invalid PRG factory.");
   }
 
 private:
   std::shared_ptr<channel_equalizer_factory>       equalizer_factory;
+  std::shared_ptr<transform_precoder_factory>      precoder_factory;
   std::shared_ptr<channel_modulation_factory>      demodulation_factory;
   std::shared_ptr<pseudo_random_generator_factory> prg_factory;
+  unsigned                                         max_nof_prb;
   bool                                             enable_evm;
   bool                                             enable_post_eq_sinr;
 };
@@ -327,14 +337,18 @@ srsran::create_pusch_decoder_factory_hw(const pusch_decoder_factory_hw_configura
 
 std::shared_ptr<pusch_demodulator_factory>
 srsran::create_pusch_demodulator_factory_sw(std::shared_ptr<channel_equalizer_factory>       equalizer_factory,
+                                            std::shared_ptr<transform_precoder_factory>      precoder_factory,
                                             std::shared_ptr<channel_modulation_factory>      demodulation_factory,
                                             std::shared_ptr<pseudo_random_generator_factory> prg_factory,
+                                            unsigned                                         max_nof_prb,
                                             bool                                             enable_evm,
                                             bool                                             enable_post_eq_sinr)
 {
   return std::make_shared<pusch_demodulator_factory_generic>(std::move(equalizer_factory),
+                                                             std::move(precoder_factory),
                                                              std::move(demodulation_factory),
                                                              std::move(prg_factory),
+                                                             max_nof_prb,
                                                              enable_evm,
                                                              enable_post_eq_sinr);
 }

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

@@ -149,115 +149,110 @@ void pusch_demodulator_impl::demodulate(pusch_codeword_buffer&      codeword_buf
   float                                          noise_var_accumulate = 0.0;
   float                                          evm_accumulate       = 0.0;
 
+  // Process each OFDM symbol.
   for (unsigned i_symbol = config.start_symbol_index, i_symbol_end = config.start_symbol_index + config.nof_symbols;
        i_symbol != i_symbol_end;
        ++i_symbol) {
     // Select RE mask for the symbol.
     re_symbol_mask_type& symbol_re_mask = config.dmrs_symb_pos.test(i_symbol) ? re_mask_dmrs : re_mask;
 
+    // Count the number of active RE in the symbol.
+    unsigned nof_re_symbol = symbol_re_mask.count();
+
     // Skip symbol if it does not contain data.
-    if (symbol_re_mask.none()) {
+    if (nof_re_symbol == 0) {
       continue;
     }
 
-    // Process subcarriers in groups.
-    for (unsigned i_subc = symbol_re_mask.find_lowest(), i_subc_end = symbol_re_mask.find_highest() + 1;
-         i_subc != i_subc_end;) {
-      // Calculate the remainder number of subcarriers to process for the current OFDM symbol.
-      unsigned nof_block_subc = i_subc_end - i_subc;
-
-      // Limit number of RE to the maximum block size.
-      nof_block_subc = std::min(nof_block_subc, MAX_BLOCK_SIZE / nof_bits_per_re);
-
-      // Get a view of the codeword buffer destination.
-      span<log_likelihood_ratio> codeword_block = codeword_buffer.get_next_block_view(nof_block_subc * nof_bits_per_re);
+    // Resize equalizer output buffers.
+    span<cf_t>  eq_re         = span<cf_t>(temp_eq_re).first(nof_re_symbol * config.nof_tx_layers);
+    span<float> eq_noise_vars = span<float>(temp_eq_noise_vars).first(nof_re_symbol * config.nof_tx_layers);
 
-      // If the codeword is empty, skip the rest of the symbol.
-      if (codeword_block.empty()) {
-        unsigned nof_remainder_re = symbol_re_mask.slice(i_subc, symbol_re_mask.size()).count();
-        srsran_assert(nof_remainder_re == 0, "There are {} remaining RE.", nof_remainder_re);
-        break;
-      }
+    // Extract the data symbols and channel estimates from the resource grid.
+    const re_buffer_reader<cbf16_t>&      ch_re = get_ch_data_re(grid, i_symbol, symbol_re_mask, config.rx_ports);
+    const channel_equalizer::ch_est_list& ch_estimates =
+        get_ch_data_estimates(estimates, i_symbol, config.nof_tx_layers, symbol_re_mask, config.rx_ports);
 
-      // Limit block size if the codeword block is smaller.
-      srsran_assert(codeword_block.size() % nof_bits_per_re == 0,
-                    "The codeword block size (i.e., {}) must be multiple of the number of bits per RE (i.e., {}).",
-                    codeword_block.size(),
-                    nof_bits_per_re);
-
-      // Extract mask for the block.
-      // First, get the mask of data REs in the current block of received symbols.
-      re_symbol_mask_type block_re_mask = symbol_re_mask.slice(i_subc, i_subc + nof_block_subc);
-      // Next, get the number of subcarriers needed to carry the current codeword block.
-      unsigned nof_required_subc = static_cast<unsigned>(codeword_block.size()) / nof_bits_per_re;
-      // Ensure the number of data REs in the block of received symbols is not larger than the codeword block (expressed
-      // as a number of subcarriers).
-      while (block_re_mask.count() > nof_required_subc) {
-        --nof_block_subc;
-        block_re_mask = symbol_re_mask.slice(i_subc, i_subc + nof_block_subc);
-      }
+    // Extract the Rx port noise variances from the channel estimation.
+    for (unsigned i_port = 0; i_port != nof_rx_ports; ++i_port) {
+      noise_var_estimates[i_port] = estimates.get_noise_variance(i_port, 0);
+    }
 
-      // Number of data Resource Elements in a slot for a single Rx port.
-      unsigned nof_re_port = static_cast<unsigned>(block_re_mask.count());
+    // Equalize channels and, for each Tx layer, combine contribution from all Rx antenna ports.
+    equalizer->equalize(
+        eq_re, eq_noise_vars, ch_re, ch_estimates, span<float>(noise_var_estimates).first(nof_rx_ports), 1.0F);
 
-      // Skip block if no data.
-      if (nof_re_port == 0) {
-        i_subc += nof_block_subc;
-        continue;
-      }
+    // Revert transform precoding for the entire OFDM symbol.
+    if (config.enable_transform_precoding) {
+      srsran_assert(config.nof_tx_layers == 1,
+                    "Transform precoding is only possible with one layer (i.e. {}).",
+                    config.nof_tx_layers);
+      precoder->deprecode_ofdm_symbol(eq_re, eq_re);
+    }
 
-      // Resize equalizer output buffers.
-      span<cf_t>  eq_re         = span<cf_t>(temp_eq_re).first(nof_re_port * config.nof_tx_layers);
-      span<float> eq_noise_vars = span<float>(temp_eq_noise_vars).first(nof_re_port * config.nof_tx_layers);
+    // Estimate post equalization Signal-to-Interference-plus-Noise Ratio.
+    if (compute_post_eq_sinr) {
+      noise_var_accumulate +=
+          std::accumulate(eq_noise_vars.begin(), eq_noise_vars.end(), 0.0F, [&sinr_softbit_count](float sum, float in) {
+            // Exclude outliers with infinite variance. This makes sure that handling of the DC carrier does not skew
+            // the SINR results.
+            if (std::isinf(in)) {
+              return sum;
+            }
+
+            ++sinr_softbit_count;
+            return sum + in;
+          });
+    }
 
-      // Extract the data symbols and channel estimates from the resource grid.
-      const re_buffer_reader<cbf16_t>& ch_re = get_ch_data_re(grid, i_symbol, i_subc, block_re_mask, config.rx_ports);
-      const channel_equalizer::ch_est_list& ch_estimates =
-          get_ch_data_estimates(estimates, i_symbol, i_subc, config.nof_tx_layers, block_re_mask, config.rx_ports);
+    // Counts the number of processed RE for the OFDM symbol.
+    unsigned count_re_symbol = 0;
 
-      // Increment subcarrier count.
-      i_subc += nof_block_subc;
+    // Process subcarriers in groups.
+    while (count_re_symbol != nof_re_symbol) {
+      // Calculate the remainder number of subcarriers to process for the current OFDM symbol.
+      unsigned remain_nof_subc = nof_re_symbol - count_re_symbol;
 
-      // Extract the Rx port noise variances from the channel estimation.
-      for (unsigned i_port = 0; i_port != nof_rx_ports; ++i_port) {
-        noise_var_estimates[i_port] = estimates.get_noise_variance(i_port, 0);
-      }
+      // Get a view of the codeword buffer destination.
+      span<log_likelihood_ratio> codeword = codeword_buffer.get_next_block_view(remain_nof_subc * nof_bits_per_re);
 
-      // Equalize channels and, for each Tx layer, combine contribution from all Rx antenna ports.
-      equalizer->equalize(
-          eq_re, eq_noise_vars, ch_re, ch_estimates, span<float>(noise_var_estimates).first(nof_rx_ports), 1.0F);
-
-      // Estimate post equalization Signal-to-Interference-plus-Noise Ratio.
-      if (compute_post_eq_sinr) {
-        noise_var_accumulate += std::accumulate(
-            eq_noise_vars.begin(), eq_noise_vars.end(), 0.0F, [&sinr_softbit_count](float sum, float in) {
-              // Exclude outliers with infinite variance. This makes sure that handling of the DC carrier does not skew
-              // the SINR results.
-              if (std::isinf(in)) {
-                return sum;
-              }
-
-              ++sinr_softbit_count;
-              return sum + in;
-            });
-      }
+      // Limit block size if the codeword block is smaller.
+      srsran_assert(codeword.size() % nof_bits_per_re == 0,
+                    "The codeword block size (i.e., {}) must be multiple of the number of bits per RE (i.e., {}).",
+                    codeword.size(),
+                    nof_bits_per_re);
 
-      // Get codeword buffer.
-      unsigned                   nof_block_softbits = nof_re_port * nof_bits_per_re;
-      span<log_likelihood_ratio> codeword           = codeword_block.first(nof_block_softbits);
+      // Select equalizer output.
+      unsigned          nof_block_softbits    = codeword.size();
+      unsigned          codeword_block_offset = count_re_symbol * config.nof_tx_layers;
+      unsigned          codeword_block_size   = nof_block_softbits / get_bits_per_symbol(config.modulation);
+      span<const cf_t>  eq_re_block           = eq_re.subspan(codeword_block_offset, codeword_block_size);
+      span<const float> eq_noise_vars_block   = eq_noise_vars.subspan(codeword_block_offset, codeword_block_size);
 
       // Build LLRs from channel symbols.
-      demapper->demodulate_soft(codeword, eq_re, eq_noise_vars, config.modulation);
+      demapper->demodulate_soft(codeword, eq_re_block, eq_noise_vars_block, config.modulation);
 
       // Calculate EVM only if it is available.
       if (evm_calc) {
-        unsigned nof_re_evm = eq_re.size();
-        evm_accumulate += static_cast<float>(nof_re_evm) * evm_calc->calculate(codeword, eq_re, config.modulation);
-        evm_symbol_count += nof_re_evm;
+        evm_accumulate +=
+            static_cast<float>(codeword_block_size) * evm_calc->calculate(codeword, eq_re_block, config.modulation);
+        evm_symbol_count += codeword_block_size;
       }
 
-      // Update and notify statistics.
-      if (i_subc == i_subc_end) {
+      // Generate scrambling sequence.
+      static_bit_buffer<pusch_constants::MAX_NOF_BITS_PER_OFDM_SYMBOL> scrambling_seq(nof_block_softbits);
+      descrambler->generate(scrambling_seq);
+
+      // Revert scrambling.
+      revert_scrambling(codeword, codeword, scrambling_seq);
+
+      // Increment the number of processed RE within the OFDM symbol.
+      count_re_symbol += nof_block_softbits / nof_bits_per_re;
+
+      // Update and notify statistics if it is the last processed block for the OFDM symbol. The provisional stats must
+      // be notified earlier than the new processed block to ensure the stats are available upon the notification of the
+      // results.
+      if (count_re_symbol == nof_re_symbol) {
         if ((sinr_softbit_count != 0) && (noise_var_accumulate > 0.0)) {
           float mean_noise_var = noise_var_accumulate / static_cast<float>(sinr_softbit_count);
           stats.sinr_dB.emplace(-convert_power_to_dB(mean_noise_var));
@@ -270,13 +265,6 @@ void pusch_demodulator_impl::demodulate(pusch_codeword_buffer&      codeword_buf
         notifier.on_provisional_stats(stats);
       }
 
-      // Generate scrambling sequence.
-      static_bit_buffer<MAX_BLOCK_SIZE> scrambling_seq(nof_block_softbits);
-      descrambler->generate(scrambling_seq);
-
-      // Revert scrambling.
-      revert_scrambling(codeword, codeword, scrambling_seq);
-
       // Notify a new processed block.
       codeword_buffer.on_new_block(codeword, scrambling_seq);
     }