phy: concurrent port channel estimator

This implementation of the port channel estimator provides access to a
pool of channel estimators. This is the first step towards parallelizing
the estimation across multiple antenna ports.

Author: dvdgrgrtt

include/srsran/phy/upper/signal_processors/signal_processor_factories.h

@@ -109,6 +109,10 @@ class port_channel_estimator_factory
 std::shared_ptr<port_channel_estimator_factory>
 create_port_channel_estimator_factory_sw(std::shared_ptr<time_alignment_estimator_factory> ta_estimator_factory);
 
+std::shared_ptr<port_channel_estimator_factory>
+create_port_channel_estimator_pool_factory(std::shared_ptr<port_channel_estimator_factory> ch_est_factory,
+                                           unsigned                                        nof_concurrent_threads);
+
 class pss_processor_factory
 {
 public:

lib/phy/upper/signal_processors/port_channel_estimator_pool.h

@@ -0,0 +1,54 @@
+/*
+ *
+ * Copyright 2021-2025 Software Radio Systems Limited
+ *
+ * By using this file, you agree to the terms and conditions set
+ * forth in the LICENSE file which can be found at the top level of
+ * the distribution.
+ *
+ */
+
+#pragma once
+
+#include "srsran/phy/upper/signal_processors/port_channel_estimator.h"
+#include "srsran/srslog/srslog.h"
+#include "srsran/support/memory_pool/bounded_object_pool.h"
+
+namespace srsran {
+
+/// Concurrent port channel estimator.
+class port_channel_estimator_pool : public port_channel_estimator
+{
+public:
+  using estimator_pool = bounded_unique_object_pool<port_channel_estimator>;
+
+  /// Creates a concurrent channel estimator from a shared pool of estimators.
+  explicit port_channel_estimator_pool(std::shared_ptr<estimator_pool> estimators_) :
+    logger(srslog::fetch_basic_logger("PHY")), estimators(std::move(estimators_))
+  {
+    srsran_assert(estimators, "Invalid port channel estimator pool.");
+  }
+
+  // See interface for documentation.
+  void compute(channel_estimate&           estimate,
+               const resource_grid_reader& grid,
+               unsigned                    port,
+               const dmrs_symbol_list&     pilots,
+               const configuration&        cfg) override
+  {
+    auto estimator = estimators->get();
+    if (!estimator) {
+      logger.error("Failed to retrieve a port channel estimator.");
+      return;
+    }
+
+    estimator->compute(estimate, grid, port, pilots, cfg);
+  }
+
+private:
+  srslog::basic_logger& logger;
+  // Pool of port channel estimators.
+  std::shared_ptr<estimator_pool> estimators;
+};
+
+} // namespace srsran

lib/phy/upper/signal_processors/signal_processor_factories.cpp

@@ -16,6 +16,7 @@
 #include "nzp_csi_rs_generator_impl.h"
 #include "nzp_csi_rs_generator_pool.h"
 #include "port_channel_estimator_average_impl.h"
+#include "port_channel_estimator_pool.h"
 #include "pss_processor_impl.h"
 #include "pucch/dmrs_pucch_estimator_format2.h"
 #include "pucch/dmrs_pucch_estimator_formats3_4.h"
@@ -25,6 +26,7 @@
 #include "srsran/phy/support/support_formatters.h"
 #include "srsran/phy/support/time_alignment_estimator/time_alignment_estimator_factories.h"
 #include "srsran/phy/upper/signal_processors/signal_processor_formatters.h"
+#include <map>
 
 using namespace srsran;
 
@@ -270,6 +272,56 @@ class port_channel_estimator_factory_sw : public port_channel_estimator_factory
   std::shared_ptr<time_alignment_estimator_factory> ta_estimator_factory;
 };
 
+class port_channel_estimator_pool_factory : public port_channel_estimator_factory
+{
+public:
+  port_channel_estimator_pool_factory(std::shared_ptr<port_channel_estimator_factory> factory_,
+                                      unsigned                                        nof_concurrent_threads_) :
+    factory(std::move(factory_)), nof_concurrent_threads(nof_concurrent_threads_)
+  {
+    srsran_assert(factory, "Invalid port channel estimator factory.");
+    srsran_assert(nof_concurrent_threads > 1, "Number of concurrent threads must be greater than one.");
+  }
+
+  std::unique_ptr<port_channel_estimator>
+  create(port_channel_estimator_fd_smoothing_strategy     fd_smoothing_strategy,
+         port_channel_estimator_td_interpolation_strategy td_interpolation_strategy,
+         bool                                             compensate_cfo) override
+  {
+    auto& this_estimator_pool = estimators[{fd_smoothing_strategy, td_interpolation_strategy, compensate_cfo}];
+    if (!this_estimator_pool) {
+      std::vector<std::unique_ptr<port_channel_estimator>> instances(nof_concurrent_threads);
+      std::generate(instances.begin(),
+                    instances.end(),
+                    [this, fd_smoothing_strategy, td_interpolation_strategy, compensate_cfo]() {
+                      return factory->create(fd_smoothing_strategy, td_interpolation_strategy, compensate_cfo);
+                    });
+      this_estimator_pool = std::make_shared<port_channel_estimator_pool::estimator_pool>(instances);
+    }
+    return std::make_unique<port_channel_estimator_pool>(this_estimator_pool);
+  }
+
+private:
+  using estimator_config =
+      std::tuple<port_channel_estimator_fd_smoothing_strategy, port_channel_estimator_td_interpolation_strategy, bool>;
+
+  struct config_hash {
+    size_t operator()(const estimator_config& c) const noexcept
+    {
+      size_t h1 = std::hash<int>{}(static_cast<int>(std::get<0>(c)));
+      size_t h2 = std::hash<int>{}(static_cast<int>(std::get<1>(c)));
+      size_t h3 = std::hash<bool>{}(std::get<2>(c));
+
+      return (h1 ^ (h2 << 1) ^ (h3 << 2));
+    }
+  };
+
+  std::shared_ptr<port_channel_estimator_factory> factory;
+  unsigned                                        nof_concurrent_threads;
+  std::unordered_map<estimator_config, std::shared_ptr<port_channel_estimator_pool::estimator_pool>, config_hash>
+      estimators;
+};
+
 class pss_processor_factory_sw : public pss_processor_factory
 {
 public:
@@ -349,6 +401,13 @@ srsran::create_port_channel_estimator_factory_sw(std::shared_ptr<time_alignment_
   return std::make_shared<port_channel_estimator_factory_sw>(std::move(ta_estimator_factory));
 }
 
+std::shared_ptr<port_channel_estimator_factory>
+srsran::create_port_channel_estimator_pool_factory(std::shared_ptr<port_channel_estimator_factory> ch_est_factory,
+                                                   unsigned nof_concurrent_threads)
+{
+  return std::make_shared<port_channel_estimator_pool_factory>(std::move(ch_est_factory), nof_concurrent_threads);
+}
+
 std::shared_ptr<pss_processor_factory> srsran::create_pss_processor_factory_sw()
 {
   return std::make_shared<pss_processor_factory_sw>();

tests/unittests/phy/upper/signal_processors/port_channel_estimator_test.cpp

@@ -62,6 +62,10 @@ class ChannelEstFixture : public ::testing::TestWithParam<test_case_t>
       ASSERT_NE(ta_estimator_factory, nullptr) << "Cannot create TA estimator factory.";
 
       ch_est_factory = create_port_channel_estimator_factory_sw(std::move(ta_estimator_factory));
+      // The concurrent version of the port channel estimator is just a collection of channel estimators which are
+      // called according to their availability. Using the concurrent estimator in the test ensures that
+      // port_channel_estimator can be called from the pool, without broadening too much the scope of the test.
+      ch_est_factory = create_port_channel_estimator_pool_factory(std::move(ch_est_factory), 2);
       ASSERT_NE(ch_est_factory, nullptr);
     }
   }