phy: make PDSCH DM-RS processor a thread local pool

Author: xavierarteaga

lib/phy/upper/channel_processors/channel_processor_factories.cpp

@@ -305,39 +305,22 @@ class pdsch_processor_factory_sw : public pdsch_processor_factory
 
 class pdsch_processor_concurrent_factory_sw : public pdsch_processor_factory
 {
-private:
-  std::shared_ptr<crc_calculator_factory>                                    crc_factory;
-  std::shared_ptr<ldpc_encoder_factory>                                      encoder_factory;
-  std::shared_ptr<ldpc_rate_matcher_factory>                                 rate_matcher_factory;
-  std::shared_ptr<pseudo_random_generator_factory>                           prg_factory;
-  std::shared_ptr<channel_modulation_factory>                                modulator_factory;
-  std::shared_ptr<dmrs_pdsch_processor_factory>                              dmrs_factory;
-  task_executor&                                                             executor;
-  std::shared_ptr<pdsch_processor_concurrent_impl::codeblock_processor_pool> cb_processor_pool;
-
 public:
-  pdsch_processor_concurrent_factory_sw(std::shared_ptr<crc_calculator_factory>          crc_factory_,
-                                        std::shared_ptr<ldpc_encoder_factory>            encoder_factory_,
-                                        std::shared_ptr<ldpc_rate_matcher_factory>       rate_matcher_factory_,
+  pdsch_processor_concurrent_factory_sw(std::shared_ptr<crc_calculator_factory>          crc_factory,
+                                        std::shared_ptr<ldpc_encoder_factory>            encoder_factory,
+                                        std::shared_ptr<ldpc_rate_matcher_factory>       rate_matcher_factory,
                                         std::shared_ptr<pseudo_random_generator_factory> prg_factory_,
-                                        std::shared_ptr<channel_modulation_factory>      modulator_factory_,
-                                        std::shared_ptr<dmrs_pdsch_processor_factory>    dmrs_factory_,
+                                        std::shared_ptr<channel_modulation_factory>      modulator_factory,
+                                        std::shared_ptr<dmrs_pdsch_processor_factory>    dmrs_factory,
                                         task_executor&                                   executor_,
                                         unsigned                                         nof_concurrent_threads) :
-    crc_factory(std::move(crc_factory_)),
-    encoder_factory(std::move(encoder_factory_)),
-    rate_matcher_factory(std::move(rate_matcher_factory_)),
-    prg_factory(std::move(prg_factory_)),
-    modulator_factory(std::move(modulator_factory_)),
-    dmrs_factory(std::move(dmrs_factory_)),
-    executor(executor_)
+    prg_factory(std::move(prg_factory_)), executor(executor_)
   {
     srsran_assert(crc_factory, "Invalid CRC calculator factory.");
     srsran_assert(encoder_factory, "Invalid encoder factory.");
     srsran_assert(rate_matcher_factory, "Invalid rate matcher factory.");
     srsran_assert(prg_factory, "Invalid PRG factory.");
     srsran_assert(modulator_factory, "Invalid modulator factory.");
-    srsran_assert(dmrs_factory, "Invalid DM-RS factory.");
     srsran_assert(nof_concurrent_threads > 1, "Number of concurrent threads must be greater than one.");
 
     // Create vector of codeblock processors.
@@ -356,18 +339,34 @@ class pdsch_processor_concurrent_factory_sw : public pdsch_processor_factory
     // Create pool of codeblock processors. It is common for all PDSCH processors.
     cb_processor_pool =
         std::make_shared<pdsch_processor_concurrent_impl::codeblock_processor_pool>(std::move(cb_processors));
+
+    // Create vector of PDSCH DM-RS generators.
+    std::vector<std::unique_ptr<dmrs_pdsch_processor>> dmrs_generators;
+    for (unsigned i_encoder = 0; i_encoder != nof_concurrent_threads; ++i_encoder) {
+      dmrs_generators.emplace_back(dmrs_factory->create());
+    }
+
+    // Create pool of PDSCH DM-RS generators. It is common for all PDSCH processors.
+    dmrs_generator_pool =
+        std::make_shared<pdsch_processor_concurrent_impl::pdsch_dmrs_generator_pool>(std::move(dmrs_generators));
   }
 
   std::unique_ptr<pdsch_processor> create() override
   {
     return std::make_unique<pdsch_processor_concurrent_impl>(
-        cb_processor_pool, prg_factory->create(), dmrs_factory->create(), executor);
+        cb_processor_pool, prg_factory->create(), dmrs_generator_pool, executor);
   }
 
   std::unique_ptr<pdsch_pdu_validator> create_validator() override
   {
     return std::make_unique<pdsch_processor_validator_impl>();
   }
+
+private:
+  std::shared_ptr<pseudo_random_generator_factory>                            prg_factory;
+  task_executor&                                                              executor;
+  std::shared_ptr<pdsch_processor_concurrent_impl::codeblock_processor_pool>  cb_processor_pool;
+  std::shared_ptr<pdsch_processor_concurrent_impl::pdsch_dmrs_generator_pool> dmrs_generator_pool;
 };
 
 class pdsch_processor_lite_factory_sw : public pdsch_processor_factory

lib/phy/upper/channel_processors/pdsch_processor_concurrent_impl.cpp

@@ -382,7 +382,7 @@ void pdsch_processor_concurrent_impl::process_dmrs()
   dmrs_config.precoding            = config.precoding;
 
   // Put DM-RS.
-  dmrs->map(*mapper, dmrs_config);
+  dmrs_generator_pool->get().map(*mapper, dmrs_config);
 
   // Decrement asynchronous task counter.
   if (async_task_counter.fetch_sub(1) == 1) {

lib/phy/upper/channel_processors/pdsch_processor_concurrent_impl.h

@@ -27,26 +27,28 @@ class pdsch_processor_concurrent_impl : public pdsch_processor
 public:
   /// Codeblock processor pool type.
   using codeblock_processor_pool = concurrent_thread_local_object_pool<pdsch_codeblock_processor>;
+  /// PDSCH DM-RS generator pool type.
+  using pdsch_dmrs_generator_pool = concurrent_thread_local_object_pool<dmrs_pdsch_processor>;
 
   /// \brief Creates a concurrent PDSCH processor with all the dependencies.
   /// \param[in] segmenter_         LDPC transmitter segmenter.
   /// \param[in] cb_processor_pool_ Codeblock processor pool.
   /// \param[in] scrambler_         Scrambling pseudo-random generator.
   /// \param[in] dmrs_              DM-RS for PDSCH generator.
   /// \param[in] executor_          Asynchronous task executor.
-  pdsch_processor_concurrent_impl(std::shared_ptr<codeblock_processor_pool> cb_processor_pool_,
-                                  std::unique_ptr<pseudo_random_generator>  scrambler_,
-                                  std::unique_ptr<dmrs_pdsch_processor>     dmrs_,
-                                  task_executor&                            executor_) :
+  pdsch_processor_concurrent_impl(std::shared_ptr<codeblock_processor_pool>  cb_processor_pool_,
+                                  std::unique_ptr<pseudo_random_generator>   scrambler_,
+                                  std::shared_ptr<pdsch_dmrs_generator_pool> dmrs_generator_pool_,
+                                  task_executor&                             executor_) :
     scrambler(std::move(scrambler_)),
     cb_processor_pool(std::move(cb_processor_pool_)),
-    dmrs(std::move(dmrs_)),
+    dmrs_generator_pool(std::move(dmrs_generator_pool_)),
     executor(executor_),
     temp_codeword(pdsch_constants::CODEWORD_MAX_SYMBOLS)
   {
-    srsran_assert(scrambler != nullptr, "Invalid scrambler pointer.");
-    srsran_assert(cb_processor_pool != nullptr, "Invalid CB processor pool pointer.");
-    srsran_assert(dmrs != nullptr, "Invalid DM-RS pointer.");
+    srsran_assert(scrambler, "Invalid scrambler pointer.");
+    srsran_assert(cb_processor_pool, "Invalid CB processor pool pointer.");
+    srsran_assert(dmrs_generator_pool, "Invalid DM-RS pointer.");
   }
 
   // See interface for documentation.
@@ -91,7 +93,7 @@ class pdsch_processor_concurrent_impl : public pdsch_processor
   /// Pool of code block processors.
   std::shared_ptr<codeblock_processor_pool> cb_processor_pool;
   /// DM-RS processor.
-  std::unique_ptr<dmrs_pdsch_processor> dmrs;
+  std::shared_ptr<pdsch_dmrs_generator_pool> dmrs_generator_pool;
   /// Asynchronous task executor.
   task_executor& executor;