phy: review PDSCH related constants

Author: xavierarteaga

include/srsran/adt/bit_buffer.h

@@ -289,7 +289,12 @@ class static_bit_buffer : public bit_buffer
   static_bit_buffer(static_bit_buffer&& other) : bit_buffer(buffer, other.size()){};
 
   /// Resizes the bit buffer.
-  void resize(unsigned new_size) { set_buffer(buffer, new_size); }
+  void resize(unsigned new_size)
+  {
+    srsran_assert(
+        new_size <= SizeInBits, "The new size (i.e., {}) exceeds the memory size (i.e., {}).", new_size, SizeInBits);
+    set_buffer(buffer, new_size);
+  }
 
 private:
   /// Static memory container.

include/srsran/phy/upper/channel_processors/pdsch_modulator.h

@@ -32,12 +32,6 @@ class resource_grid_mapper;
 class pdsch_modulator
 {
 public:
-  /// Defines the maximum number of codewords per PDSCH transmission.
-  static constexpr unsigned MAX_NOF_CODEWORDS = 2;
-
-  /// Defines the maximum number of RE per codeword in a PDSCH transmission.
-  static constexpr unsigned MAX_CODEWORD_SIZE = MAX_RB * NRE * MAX_NSYMB_PER_SLOT * MAX_PORTS / 2;
-
   /// Describes the necessary parameters to modulate a PDSCH transmission.
   struct config_t {
     /// Provides \f$n_{RNTI}\f$ from TS38.211 section 7.3.1.1 Scrambling.

include/srsran/phy/upper/channel_processors/pdsch_processor.h

@@ -29,17 +29,8 @@ class resource_grid_mapper;
 class pdsch_processor
 {
 public:
-  /// \brief Maximum number of resource elements per resource block in a shared channel transmission.
-  /// As per TS 38.214 section 5.1.3.2 Transport block size determination.
-  static constexpr unsigned MAX_NRE_PER_RB = 156;
   /// Defines the maximum number of codewords that can be encoded in a PDSCH transmission.
   static constexpr unsigned MAX_NOF_TRANSPORT_BLOCKS = 2;
-  /// \brief Defines the maximum number of layers per codeword.
-  /// As per TS 38.211 table Table 7.3.1.3-1: Codeword-to-layer mapping for spatial multiplexing.
-  static constexpr unsigned MAX_LAYER_PER_CODEWORD = 4;
-  /// Defines the maximum codeword size.
-  static constexpr unsigned MAX_CODEWORD_SIZE =
-      MAX_RB * MAX_NRE_PER_RB * MODULATION_MAX_BITS_PER_SYMBOL * MAX_LAYER_PER_CODEWORD;
 
   /// \brief Describes a codeword configuration.
   /// \note The transport block size is given by the transport block data size.

include/srsran/ran/pdsch/pdsch_constants.h

@@ -7,16 +7,62 @@
  * the distribution.
  *
  */
+///\file
+///\brief pdsch_constants - namespace containing constants related to PDSCH transmissions.
 
 #pragma once
 
+#include "srsran/ran/resource_block.h"
+#include "srsran/support/units.h"
 #include <cstddef>
 
 namespace srsran {
 
-/// \brief Maximum size in bytes of a PDSCH PDU for a given UE.
+namespace pdsch_constants {
+
+/// \brief Maximum number of RE per resource block in a PDSCH transmission.
+///
+/// As per TS38.214 Section 5.1.3.2.
+static constexpr unsigned MAX_NRE_PER_RB = 156;
+
+/// \brief Maximum modulation order supported on PDSCH transmissions.
+///
+/// As per TS38.214 Section 5.1.3.1 with \c mcs-Table set to \c qam256.
+static constexpr unsigned MAX_MODULATION_ORDER = 8;
+
+/// \brief Maximum number of PDSCH transmission layers per codeword.
+///
+/// As per TS38.211 Table 7.3.1.3-1.
+static constexpr unsigned CODEWORD_MAX_NOF_LAYERS = 4;
+
+/// \brief Maximuym number of codewords that can be contained in a PDSCH transmission.
+///
+/// As per TS38.211 Table 7.3.1.3-1.
+static constexpr unsigned MAX_NOF_CODEWORDS = 2;
+
+/// \brief Maximum number of PDSCH transmission layers.
 ///
-/// It is not given by the TS. It assumes 156 resource elements for a maximum of 275 PRB, four layers and 256-QAM.
-static constexpr size_t MAX_DL_PDU_LENGTH = (156 * 275 * 4 * 8) / 8;
+/// As per TS38.211 Table 7.3.1.3-1.
+static constexpr unsigned MAX_NOF_LAYERS = CODEWORD_MAX_NOF_LAYERS * MAX_NOF_CODEWORDS;
+
+/// \brief Maximum number of resource elements that can be mapped into a single codeword.
+///
+/// Calculated as the product of maximum number or RE per PRB and the maximum number of PRB in the a resource grid.
+static constexpr unsigned CODEWORD_MAX_NOF_RE = MAX_NRE_PER_RB * MAX_NOF_PRBS;
+
+/// \brief Maximum number of symbols that can be mapped into a single codeword.
+///
+/// Calculated as the product of the maximum number of resource elements and the maximum layers
+static constexpr unsigned CODEWORD_MAX_SYMBOLS = CODEWORD_MAX_NOF_RE * CODEWORD_MAX_NOF_LAYERS;
+
+/// \brief Maximum number of bits that can be modulated into a single codeword.
+///
+/// Calculated as the product of the maximum number of resource elements and the maximum modulation order.
+static constexpr units::bits CODEWORD_MAX_SIZE{CODEWORD_MAX_SYMBOLS * MAX_MODULATION_ORDER};
+
+} // namespace pdsch_constants
+
+/// \brief Maximum size in bytes of a PDSCH PDU for a given UE.
+static constexpr size_t MAX_DL_PDU_LENGTH = pdsch_constants::CODEWORD_MAX_SIZE.round_up_to_bytes().value();
 
 } // namespace srsran

include/srsran/ran/pusch/pusch_constants.h

@@ -28,7 +28,9 @@ static constexpr unsigned MAX_NRE_PER_RB = 156;
 /// As per TS38.214 Section 6.1.4.1 with \c mcs-Table set to \c qam256.
 static constexpr unsigned MAX_MODULATION_ORDER = 8;
 
-/// Maximum number of PUSCH transmission layers, as per TS38.211 Section 6.3.1.3.
+/// \brief Maximum number of PUSCH transmission layers.
+///
+/// As per TS38.211 Section 6.3.1.3.
 static constexpr unsigned MAX_NOF_LAYERS = 4;
 
 /// Maximum number of OFDM symbols carrying DM-RS in a slot is at most \f$4 \times 2\f$, being 4 the maximum

lib/phy/upper/channel_processors/pdsch_modulator_impl.h

@@ -14,6 +14,7 @@
 #include "srsran/phy/upper/channel_processors/pdsch_modulator.h"
 #include "srsran/phy/upper/sequence_generators/pseudo_random_generator.h"
 #include "srsran/ran/cyclic_prefix.h"
+#include "srsran/ran/pdsch/pdsch_constants.h"
 
 namespace srsran {
 
@@ -52,11 +53,11 @@ class pdsch_modulator_impl : public pdsch_modulator
   static void map(resource_grid_mapper& mapper, const re_buffer_reader& data_re, const config_t& config);
 
   /// Temporary buffer for scrambled sequence.
-  static_bit_buffer<MAX_CODEWORD_SIZE> temp_b_hat;
+  static_bit_buffer<pdsch_constants::CODEWORD_MAX_SIZE.value()> temp_b_hat;
   /// Temporary buffer for the PDSCH modulated symbols.
-  std::array<cf_t, MAX_CODEWORD_SIZE> temp_pdsch_symbols;
+  std::array<cf_t, pdsch_constants::CODEWORD_MAX_SYMBOLS> temp_pdsch_symbols;
   /// Temporary buffer for the PDSCH layer-mapped RE.
-  static_re_buffer<precoding_constants::MAX_NOF_LAYERS, MAX_RB * NRE * MAX_NSYMB_PER_SLOT> temp_re;
+  static_re_buffer<pdsch_constants::MAX_NOF_LAYERS, pdsch_constants::CODEWORD_MAX_NOF_RE> temp_re;
 
 public:
   /// \brief Generic PDSCH modulator instance constructor.

lib/phy/upper/channel_processors/pdsch_processor_concurrent_impl.cpp

@@ -168,7 +168,7 @@ void pdsch_processor_concurrent_impl::process(resource_grid_mapper&
   modulator_config.precoding                   = pdu.precoding;
 
   // Prepare encoded codewords.
-  static_vector<bit_buffer, pdsch_modulator::MAX_NOF_CODEWORDS> codewords = {temp_packed_codeword};
+  static_vector<bit_buffer, pdsch_constants::MAX_NOF_CODEWORDS> codewords = {temp_packed_codeword};
 
   // Actual modulation.
   modulator->modulate(mapper, codewords, modulator_config);

lib/phy/upper/channel_processors/pdsch_processor_concurrent_impl.h

@@ -15,6 +15,7 @@
 #include "srsran/phy/upper/channel_processors/pdsch_modulator.h"
 #include "srsran/phy/upper/channel_processors/pdsch_processor.h"
 #include "srsran/phy/upper/signal_processors/dmrs_pdsch_processor.h"
+#include "srsran/ran/pdsch/pdsch_constants.h"
 #include "srsran/srsvec/bit.h"
 #include "srsran/support/executors/task_executor.h"
 #include <condition_variable>
@@ -87,11 +88,11 @@ class pdsch_processor_concurrent_impl : public pdsch_processor
   std::mutex              cb_count_mutex;
   std::condition_variable cb_count_cvar;
 
-  std::unique_ptr<pdsch_modulator>                      modulator;
-  std::unique_ptr<dmrs_pdsch_processor>                 dmrs;
-  std::array<uint8_t, MAX_CODEWORD_SIZE>                temp_codeword;
-  static_bit_buffer<pdsch_modulator::MAX_CODEWORD_SIZE> temp_packed_codeword;
-  task_executor&                                        executor;
+  std::unique_ptr<pdsch_modulator>                                modulator;
+  std::unique_ptr<dmrs_pdsch_processor>                           dmrs;
+  std::array<uint8_t, pdsch_constants::CODEWORD_MAX_SIZE.value()> temp_codeword;
+  static_bit_buffer<pdsch_constants::CODEWORD_MAX_SIZE.value()>   temp_packed_codeword;
+  task_executor&                                                  executor;
 };
 
 } // namespace srsran

lib/phy/upper/channel_processors/pdsch_processor_impl.cpp

@@ -116,7 +116,7 @@ void pdsch_processor_impl::process(resource_grid_mapper&
   unsigned nof_re_pdsch = compute_nof_data_re(pdu);
 
   // Prepare encoded codewords.
-  static_vector<bit_buffer, pdsch_modulator::MAX_NOF_CODEWORDS> codewords;
+  static_vector<bit_buffer, pdsch_constants::MAX_NOF_CODEWORDS> codewords;
 
   // Encode each codeword.
   for (unsigned codeword_id = 0; codeword_id != nof_codewords; ++codeword_id) {
@@ -222,7 +222,7 @@ const bit_buffer& pdsch_processor_impl::encode(span<const uint8_t> data,
   // Select codeword specific parameters.
   unsigned          rv           = pdu.codewords[codeword_id].rv;
   modulation_scheme modulation   = pdu.codewords[codeword_id].modulation;
-  span<uint8_t>     tmp_codeword = temp_codewords[codeword_id];
+  span<uint8_t>     tmp_codeword = temp_unpacked_codeword;
 
   // Prepare encoder configuration.
   segmenter_config encoder_config;

lib/phy/upper/channel_processors/pdsch_processor_impl.h

@@ -13,6 +13,7 @@
 #include "srsran/phy/upper/channel_processors/pdsch_modulator.h"
 #include "srsran/phy/upper/channel_processors/pdsch_processor.h"
 #include "srsran/phy/upper/signal_processors/dmrs_pdsch_processor.h"
+#include "srsran/ran/pdsch/pdsch_constants.h"
 
 namespace srsran {
 
@@ -78,11 +79,12 @@ class pdsch_processor_impl : public pdsch_processor
   /// \param[in] pdu     Provides the PDSCH processor PDU.
   void put_dmrs(resource_grid_mapper& mapper, const pdu_t& pdu);
 
-  std::unique_ptr<pdsch_encoder>                                                              encoder;
-  std::unique_ptr<pdsch_modulator>                                                            modulator;
-  std::unique_ptr<dmrs_pdsch_processor>                                                       dmrs;
-  std::array<std::array<uint8_t, MAX_CODEWORD_SIZE>, MAX_NOF_TRANSPORT_BLOCKS>                temp_codewords;
-  std::array<static_bit_buffer<pdsch_modulator::MAX_CODEWORD_SIZE>, MAX_NOF_TRANSPORT_BLOCKS> temp_packed_codewords;
+  std::unique_ptr<pdsch_encoder>                                  encoder;
+  std::unique_ptr<pdsch_modulator>                                modulator;
+  std::unique_ptr<dmrs_pdsch_processor>                           dmrs;
+  std::array<uint8_t, pdsch_constants::CODEWORD_MAX_SIZE.value()> temp_unpacked_codeword;
+  std::array<static_bit_buffer<pdsch_constants::CODEWORD_MAX_SIZE.value()>, MAX_NOF_TRANSPORT_BLOCKS>
+      temp_packed_codewords;
 };
 
 } // namespace srsran