phy: optimize lower phy downlink processor test

joaquim-srs · codebot · commit 50dffd3edd01 · 2023-11-14T14:05:59.000Z
diff --git a/tests/unittests/gateways/baseband/baseband_gateway_buffer_test_doubles.h b/tests/unittests/gateways/baseband/baseband_gateway_buffer_test_doubles.h
@@ -77,11 +77,13 @@ class baseband_gateway_buffer_read_only : public baseband_gateway_buffer_reader
 
   /// Constructor from a writer interface.
   baseband_gateway_buffer_read_only(baseband_gateway_buffer_writer& other) noexcept :
-    nof_channels(other.get_nof_channels()), nof_samples(other.get_nof_samples()), data(nof_channels * nof_samples)
+    nof_channels(other.get_nof_channels()), nof_samples(other.get_nof_samples())
   {
+    data.clear();
+    data.reserve(nof_channels * nof_samples);
     for (unsigned channel = 0; channel != nof_channels; ++channel) {
-      span<cf_t> buffer = span<cf_t>(data).subspan(nof_samples * channel, nof_samples);
-      srsvec::copy(buffer, other[channel]);
+      span<const cf_t> source = other[channel];
+      data.insert(data.end(), source.begin(), source.end());
     }
   }
 
diff --git a/tests/unittests/phy/lower/amplitude_control/amplitude_controller_test_doubles.h b/tests/unittests/phy/lower/amplitude_control/amplitude_controller_test_doubles.h
@@ -24,18 +24,39 @@ class amplitude_controller_spy : public amplitude_controller
     std::vector<cf_t> output;
   };
 
+  amplitude_controller_spy() : random_data(1009)
+  {
+    std::mt19937                          rgen;
+    std::uniform_real_distribution<float> sample_dist(-1, 1);
+    std::generate(random_data.begin(), random_data.end(), [&sample_dist, &rgen]() {
+      return cf_t(sample_dist(rgen), sample_dist(rgen));
+    });
+  }
+
   amplitude_controller_metrics process(span<cf_t> output, span<const cf_t> input) override
   {
     entries.emplace_back();
     entry_t& entry = entries.back();
 
-    entry.input.resize(input.size());
-    srsvec::copy(entry.input, input);
+    entry.input = std::vector<cf_t>(input.begin(), input.end());
+
+    std::size_t remaining = output.size();
+    span<cf_t>  random_data_view(random_data);
+
+    while (remaining > 0) {
+      // Number of samples to copy for this iteration.
+      unsigned   nof_copied_samples = std::min(random_data.size() - random_data_index, remaining);
+      span<cf_t> random_samples     = random_data_view.subspan(random_data_index, nof_copied_samples);
+      span<cf_t> out_samples        = output.subspan(output.size() - remaining, nof_copied_samples);
+
+      srsvec::copy(out_samples, random_samples);
 
-    std::generate(output.begin(), output.end(), [this]() { return cf_t(output_dist(rgen), output_dist(rgen)); });
+      // Update remaining samples and buffer index.
+      remaining -= nof_copied_samples;
+      random_data_index = (random_data_index + nof_copied_samples) % random_data.size();
+    }
 
-    entry.output.resize(output.size());
-    srsvec::copy(entry.output, output);
+    entry.output = std::vector<cf_t>(output.begin(), output.end());
 
     return amplitude_controller_metrics();
   }
@@ -45,7 +66,8 @@ class amplitude_controller_spy : public amplitude_controller
   void clear() { entries.clear(); }
 
 private:
-  std::mt19937                          rgen;
+  unsigned                              random_data_index = 0;
+  std::vector<cf_t>                     random_data;
   std::uniform_real_distribution<float> output_dist;
   std::vector<entry_t>                  entries;
 };
diff --git a/tests/unittests/phy/lower/processors/downlink/lower_phy_downlink_processor_test.cpp b/tests/unittests/phy/lower/processors/downlink/lower_phy_downlink_processor_test.cpp
@@ -106,7 +106,8 @@ bool operator==(const pdxch_processor_configuration& left, const pdxch_processor
 
 } // namespace srsran
 
-using LowerPhyDownlinkProcessorParams = std::tuple<unsigned, sampling_rate, subcarrier_spacing, cyclic_prefix>;
+using LowerPhyDownlinkProcessorParams =
+    std::tuple<unsigned, sampling_rate, std::tuple<subcarrier_spacing, cyclic_prefix>>;
 
 namespace {
 
@@ -115,27 +116,27 @@ class LowerPhyDownlinkProcessorFixture : public ::testing::TestWithParam<LowerPh
 protected:
   static void SetUpTestSuite()
   {
-    if (ul_proc_factory == nullptr) {
+    if (dl_proc_factory == nullptr) {
       pdxch_proc_factory = std::make_shared<pdxch_processor_factory_spy>();
       ASSERT_NE(pdxch_proc_factory, nullptr);
 
       amplitude_control_factory = std::make_shared<amplitude_controller_factory_spy>();
       ASSERT_NE(amplitude_control_factory, nullptr);
 
-      ul_proc_factory = create_downlink_processor_factory_sw(pdxch_proc_factory, amplitude_control_factory);
-      ASSERT_NE(ul_proc_factory, nullptr);
+      dl_proc_factory = create_downlink_processor_factory_sw(pdxch_proc_factory, amplitude_control_factory);
+      ASSERT_NE(dl_proc_factory, nullptr);
     }
   }
 
   void SetUp() override
   {
-    ASSERT_NE(ul_proc_factory, nullptr);
+    ASSERT_NE(dl_proc_factory, nullptr);
 
     // Select parameters.
     unsigned           nof_tx_ports = std::get<0>(GetParam());
     sampling_rate      srate        = std::get<1>(GetParam());
-    subcarrier_spacing scs          = std::get<2>(GetParam());
-    cyclic_prefix      cp           = std::get<3>(GetParam());
+    subcarrier_spacing scs          = std::get<0>(std::get<2>(GetParam()));
+    cyclic_prefix      cp           = std::get<1>(std::get<2>(GetParam()));
 
     // Prepare configurations.
     config.sector_id           = 0;
@@ -148,8 +149,8 @@ class LowerPhyDownlinkProcessorFixture : public ::testing::TestWithParam<LowerPh
     config.logger              = &srslog::fetch_basic_logger("Low-PHY");
 
     // Create processor.
-    ul_processor = ul_proc_factory->create(config);
-    ASSERT_NE(ul_processor, nullptr);
+    dl_processor = dl_proc_factory->create(config);
+    ASSERT_NE(dl_processor, nullptr);
 
     // Select PDxCH processor spy.
     pdxch_proc_spy = &pdxch_proc_factory->get_spy();
@@ -158,16 +159,16 @@ class LowerPhyDownlinkProcessorFixture : public ::testing::TestWithParam<LowerPh
     amplitude_control_spy = amplitude_control_factory->get_entries().back();
   }
 
-  static constexpr unsigned                                    nof_frames_test = 10;
+  static constexpr unsigned                                    nof_frames_test = 3;
   static std::mt19937                                          rgen;
   static std::uniform_int_distribution<unsigned>               dist_bandwidth_prb;
   static std::uniform_real_distribution<double>                dist_center_freq_Hz;
   static std::shared_ptr<pdxch_processor_factory_spy>          pdxch_proc_factory;
   static std::shared_ptr<amplitude_controller_factory_spy>     amplitude_control_factory;
-  static std::shared_ptr<lower_phy_downlink_processor_factory> ul_proc_factory;
+  static std::shared_ptr<lower_phy_downlink_processor_factory> dl_proc_factory;
 
   downlink_processor_configuration              config;
-  std::unique_ptr<lower_phy_downlink_processor> ul_processor          = nullptr;
+  std::unique_ptr<lower_phy_downlink_processor> dl_processor          = nullptr;
   pdxch_processor_spy*                          pdxch_proc_spy        = nullptr;
   amplitude_controller_spy*                     amplitude_control_spy = nullptr;
 };
@@ -177,7 +178,7 @@ std::uniform_int_distribution<unsigned>           LowerPhyDownlinkProcessorFixtu
 std::uniform_real_distribution<double>            LowerPhyDownlinkProcessorFixture::dist_center_freq_Hz(1e8, 6e9);
 std::shared_ptr<pdxch_processor_factory_spy>      LowerPhyDownlinkProcessorFixture::pdxch_proc_factory        = nullptr;
 std::shared_ptr<amplitude_controller_factory_spy> LowerPhyDownlinkProcessorFixture::amplitude_control_factory = nullptr;
-std::shared_ptr<lower_phy_downlink_processor_factory> LowerPhyDownlinkProcessorFixture::ul_proc_factory       = nullptr;
+std::shared_ptr<lower_phy_downlink_processor_factory> LowerPhyDownlinkProcessorFixture::dl_proc_factory       = nullptr;
 
 } // namespace
 
@@ -201,7 +202,7 @@ TEST_P(LowerPhyDownlinkProcessorFixture, PdxchConnection)
   pdxch_processor_notifier_spy    pdxch_proc_notifier_spy;
 
   // Connect.
-  ul_processor->connect(downlink_proc_notifier_spy, pdxch_proc_notifier_spy);
+  dl_processor->connect(downlink_proc_notifier_spy, pdxch_proc_notifier_spy);
 
   // Assert no notifications.
   ASSERT_EQ(downlink_proc_notifier_spy.get_total_count(), 0);
@@ -218,32 +219,32 @@ TEST_P(LowerPhyDownlinkProcessorFixture, PdxchRequestHandler)
   const pdxch_processor_request_handler* expected_request_handler = &pdxch_proc_spy->get_request_handler();
 
   // Get actual request handler.
-  const pdxch_processor_request_handler* request_handler = &ul_processor->get_downlink_request_handler();
+  const pdxch_processor_request_handler* request_handler = &dl_processor->get_downlink_request_handler();
 
   // Assert request handler.
   ASSERT_EQ(reinterpret_cast<const void*>(expected_request_handler), reinterpret_cast<const void*>(request_handler));
 }
 
 TEST_P(LowerPhyDownlinkProcessorFixture, Flow)
 {
-  unsigned           nof_rx_ports = std::get<0>(GetParam());
+  unsigned           nof_tx_ports = std::get<0>(GetParam());
   sampling_rate      srate        = std::get<1>(GetParam());
-  subcarrier_spacing scs          = std::get<2>(GetParam());
-  cyclic_prefix      cp           = std::get<3>(GetParam());
+  subcarrier_spacing scs          = std::get<0>(std::get<2>(GetParam()));
+  cyclic_prefix      cp           = std::get<1>(std::get<2>(GetParam()));
 
   unsigned base_symbol_size = srate.get_dft_size(scs);
 
-  baseband_gateway_buffer_dynamic buffer(nof_rx_ports, 2 * base_symbol_size);
+  baseband_gateway_buffer_dynamic buffer(nof_tx_ports, 2 * base_symbol_size);
 
   unsigned nof_symbols_per_slot   = get_nsymb_per_slot(cp);
   unsigned nof_slots_per_subframe = get_nof_slots_per_subframe(scs);
 
   // Create notifiers and connect.
   downlink_processor_notifier_spy downlink_proc_notifier_spy;
   pdxch_processor_notifier_spy    pdxch_proc_notifier_spy;
-  ul_processor->connect(downlink_proc_notifier_spy, pdxch_proc_notifier_spy);
+  dl_processor->connect(downlink_proc_notifier_spy, pdxch_proc_notifier_spy);
 
-  downlink_processor_baseband& dl_proc_baseband = ul_processor->get_baseband();
+  downlink_processor_baseband& dl_proc_baseband = dl_processor->get_baseband();
 
   baseband_gateway_timestamp timestamp = 0;
   for (unsigned i_frame = 0, i_slot_frame = 0; i_frame != nof_frames_test; ++i_frame) {
@@ -310,10 +311,10 @@ TEST_P(LowerPhyDownlinkProcessorFixture, Flow)
 // Test baseband buffer sizes which are unaligned with OFDM symbol boundaries.
 TEST_P(LowerPhyDownlinkProcessorFixture, FlowUnalignedBuffer)
 {
-  unsigned           nof_rx_ports = std::get<0>(GetParam());
+  unsigned           nof_tx_ports = std::get<0>(GetParam());
   sampling_rate      srate        = std::get<1>(GetParam());
-  subcarrier_spacing scs          = std::get<2>(GetParam());
-  cyclic_prefix      cp           = std::get<3>(GetParam());
+  subcarrier_spacing scs          = std::get<0>(std::get<2>(GetParam()));
+  cyclic_prefix      cp           = std::get<1>(std::get<2>(GetParam()));
 
   unsigned base_symbol_size = srate.get_dft_size(scs);
 
@@ -323,12 +324,12 @@ TEST_P(LowerPhyDownlinkProcessorFixture, FlowUnalignedBuffer)
   // Create notifiers and connect.
   downlink_processor_notifier_spy downlink_proc_notifier_spy;
   pdxch_processor_notifier_spy    pdxch_proc_notifier_spy;
-  ul_processor->connect(downlink_proc_notifier_spy, pdxch_proc_notifier_spy);
+  dl_processor->connect(downlink_proc_notifier_spy, pdxch_proc_notifier_spy);
 
-  downlink_processor_baseband& dl_proc_baseband = ul_processor->get_baseband();
+  downlink_processor_baseband& dl_proc_baseband = dl_processor->get_baseband();
 
   // Create basband buffer.
-  baseband_gateway_buffer_dynamic buffer(nof_rx_ports, 3 * base_symbol_size);
+  baseband_gateway_buffer_dynamic buffer(nof_tx_ports, 3 * base_symbol_size);
 
   // Reset timestamp.
   baseband_gateway_timestamp timestamp = 0;
@@ -438,10 +439,10 @@ TEST_P(LowerPhyDownlinkProcessorFixture, FlowUnalignedBuffer)
 // Test a baseband buffer size comprising an entire slot.
 TEST_P(LowerPhyDownlinkProcessorFixture, FlowLargeBuffer)
 {
-  unsigned           nof_rx_ports = std::get<0>(GetParam());
+  unsigned           nof_tx_ports = std::get<0>(GetParam());
   sampling_rate      srate        = std::get<1>(GetParam());
-  subcarrier_spacing scs          = std::get<2>(GetParam());
-  cyclic_prefix      cp           = std::get<3>(GetParam());
+  subcarrier_spacing scs          = std::get<0>(std::get<2>(GetParam()));
+  cyclic_prefix      cp           = std::get<1>(std::get<2>(GetParam()));
 
   unsigned base_symbol_size = srate.get_dft_size(scs);
 
@@ -451,11 +452,11 @@ TEST_P(LowerPhyDownlinkProcessorFixture, FlowLargeBuffer)
   // Create notifiers and connect.
   downlink_processor_notifier_spy downlink_proc_notifier_spy;
   pdxch_processor_notifier_spy    pdxch_proc_notifier_spy;
-  ul_processor->connect(downlink_proc_notifier_spy, pdxch_proc_notifier_spy);
+  dl_processor->connect(downlink_proc_notifier_spy, pdxch_proc_notifier_spy);
 
-  downlink_processor_baseband& dl_proc_baseband = ul_processor->get_baseband();
+  downlink_processor_baseband& dl_proc_baseband = dl_processor->get_baseband();
 
-  baseband_gateway_buffer_dynamic buffer(nof_rx_ports, 20 * base_symbol_size);
+  baseband_gateway_buffer_dynamic buffer(nof_tx_ports, 20 * base_symbol_size);
 
   // Reset timestamp.
   baseband_gateway_timestamp timestamp = 0;
@@ -534,10 +535,10 @@ TEST_P(LowerPhyDownlinkProcessorFixture, FlowLargeBuffer)
 // Test generation of baseband samples for discontinous timestamps.
 TEST_P(LowerPhyDownlinkProcessorFixture, DiscontinuousProcessing)
 {
-  unsigned           nof_rx_ports = std::get<0>(GetParam());
+  unsigned           nof_tx_ports = std::get<0>(GetParam());
   sampling_rate      srate        = std::get<1>(GetParam());
-  subcarrier_spacing scs          = std::get<2>(GetParam());
-  cyclic_prefix      cp           = std::get<3>(GetParam());
+  subcarrier_spacing scs          = std::get<0>(std::get<2>(GetParam()));
+  cyclic_prefix      cp           = std::get<1>(std::get<2>(GetParam()));
 
   unsigned base_symbol_size = srate.get_dft_size(scs);
   unsigned cp_symbol_0_size = cp.get_length(0, scs).to_samples(srate.to_Hz());
@@ -546,13 +547,13 @@ TEST_P(LowerPhyDownlinkProcessorFixture, DiscontinuousProcessing)
   // Create notifiers and connect.
   downlink_processor_notifier_spy downlink_proc_notifier_spy;
   pdxch_processor_notifier_spy    pdxch_proc_notifier_spy;
-  ul_processor->connect(downlink_proc_notifier_spy, pdxch_proc_notifier_spy);
+  dl_processor->connect(downlink_proc_notifier_spy, pdxch_proc_notifier_spy);
 
-  downlink_processor_baseband& dl_proc_baseband = ul_processor->get_baseband();
+  downlink_processor_baseband& dl_proc_baseband = dl_processor->get_baseband();
 
   // Create baseband buffers.
-  baseband_gateway_buffer_dynamic buffer_symbol_0(nof_rx_ports, base_symbol_size);
-  baseband_gateway_buffer_dynamic buffer_symbol_2(nof_rx_ports, base_symbol_size);
+  baseband_gateway_buffer_dynamic buffer_symbol_0(nof_tx_ports, base_symbol_size);
+  baseband_gateway_buffer_dynamic buffer_symbol_2(nof_tx_ports, base_symbol_size);
 
   // Set an initial timestamp.
   baseband_gateway_timestamp timestamp_symbol_0 = 7;
@@ -622,11 +623,11 @@ TEST_P(LowerPhyDownlinkProcessorFixture, DiscontinuousProcessing)
 }
 
 // Creates test suite that combines all possible parameters.
-INSTANTIATE_TEST_SUITE_P(LowerPhyDownlinkProcessor,
-                         LowerPhyDownlinkProcessorFixture,
-                         ::testing::Combine(::testing::Values(1, 2),
-                                            ::testing::Values(sampling_rate::from_MHz(7.68)),
-                                            ::testing::Values(subcarrier_spacing::kHz15,
-                                                              subcarrier_spacing::kHz30,
-                                                              subcarrier_spacing::kHz60),
-                                            ::testing::Values(cyclic_prefix::NORMAL, cyclic_prefix::EXTENDED)));
+INSTANTIATE_TEST_SUITE_P(
+    LowerPhyDownlinkProcessor,
+    LowerPhyDownlinkProcessorFixture,
+    ::testing::Combine(::testing::Values(1, 4),
+                       ::testing::Values(sampling_rate::from_MHz(7.68)),
+                       ::testing::Values(std::make_tuple(subcarrier_spacing::kHz15, cyclic_prefix::NORMAL),
+                                         std::make_tuple(subcarrier_spacing::kHz30, cyclic_prefix::NORMAL),
+                                         std::make_tuple(subcarrier_spacing::kHz60, cyclic_prefix::EXTENDED))));
diff --git a/tests/unittests/phy/lower/processors/downlink/pdxch/pdxch_processor_test_doubles.h b/tests/unittests/phy/lower/processors/downlink/pdxch/pdxch_processor_test_doubles.h
@@ -31,15 +31,36 @@ class pdxch_processor_baseband_spy : public pdxch_processor_baseband
     symbol_context                    context;
   };
 
-  pdxch_processor_baseband_spy() : sample_dist(-1, 1) {}
+  pdxch_processor_baseband_spy() : random_data(1009)
+  {
+    std::mt19937                          rgen;
+    std::uniform_real_distribution<float> sample_dist(-1, 1);
+    std::generate(random_data.begin(), random_data.end(), [&sample_dist, &rgen]() {
+      return cf_t(sample_dist(rgen), sample_dist(rgen));
+    });
+  }
 
   void process_symbol(baseband_gateway_buffer_writer& samples, const symbol_context& context) override
   {
-    for (unsigned i_channel = 0, i_channel_end = samples.get_nof_channels(); i_channel != i_channel_end; ++i_channel) {
-      span<cf_t> channel_samples = samples.get_channel_buffer(i_channel);
-      std::generate(channel_samples.begin(), channel_samples.end(), [this]() {
-        return cf_t(sample_dist(rgen), sample_dist(rgen));
-      });
+    // Counter for the remaining samples to generate.
+    std::size_t remaining = samples.get_nof_samples();
+    span<cf_t>  random_data_view(random_data);
+
+    while (remaining > 0) {
+      // Number of samples to copy for this iteration.
+      unsigned   nof_copied_samples = std::min(random_data.size() - random_data_index, remaining);
+      span<cf_t> random_samples     = random_data_view.subspan(random_data_index, nof_copied_samples);
+
+      for (unsigned i_ch = 0, i_channel_end = samples.get_nof_channels(); i_ch != i_channel_end; ++i_ch) {
+        span<cf_t> channel_samples =
+            samples.get_channel_buffer(i_ch).subspan(samples.get_nof_samples() - remaining, nof_copied_samples);
+
+        srsvec::copy(channel_samples, random_samples);
+      }
+
+      // Update remaining samples and buffer index.
+      remaining -= nof_copied_samples;
+      random_data_index = (random_data_index + nof_copied_samples) % random_data.size();
     }
 
     entries.emplace_back();
@@ -53,9 +74,9 @@ class pdxch_processor_baseband_spy : public pdxch_processor_baseband
   void clear() { entries.clear(); }
 
 private:
-  std::vector<entry_t>                  entries;
-  std::mt19937                          rgen;
-  std::uniform_real_distribution<float> sample_dist;
+  unsigned             random_data_index = 0;
+  std::vector<cf_t>    random_data;
+  std::vector<entry_t> entries;
 };
 
 class pdxch_processor_request_handler_spy : public pdxch_processor_request_handler

Original file line number	Diff line number	Diff line change
`@@ -77,11 +77,13 @@ class baseband_gateway_buffer_read_only : public baseband_gateway_buffer_reader`
`77`	`77`
`78`	`78`	`/// Constructor from a writer interface.`
`79`	`79`	`baseband_gateway_buffer_read_only(baseband_gateway_buffer_writer& other) noexcept :`
`80`		`- nof_channels(other.get_nof_channels()), nof_samples(other.get_nof_samples()), data(nof_channels * nof_samples)`
	`80`	`+ nof_channels(other.get_nof_channels()), nof_samples(other.get_nof_samples())`
`81`	`81`	`{`
	`82`	`+ data.clear();`
	`83`	`+ data.reserve(nof_channels * nof_samples);`
`82`	`84`	`for (unsigned channel = 0; channel != nof_channels; ++channel) {`
`83`		`- span<cf_t> buffer = span<cf_t>(data).subspan(nof_samples * channel, nof_samples);`
`84`		`- srsvec::copy(buffer, other[channel]);`
	`85`	`+ span<const cf_t> source = other[channel];`
	`86`	`+ data.insert(data.end(), source.begin(), source.end());`
`85`	`87`	`}`
`86`	`88`	`}`
`87`	`89`