ofh: change compressor to work with cbf16_t input

Author: sauka

include/srsran/ofh/compression/iq_compressor.h

@@ -36,7 +36,7 @@ class iq_compressor
   /// \param[in]  iq_data IQ samples to be compressed.
   /// \param[in]  params  Compression parameters.
   virtual void
-  compress(span<compressed_prb> compressed_prbs, span<const cf_t> iq_data, const ru_compression_params& params) = 0;
+  compress(span<compressed_prb> compressed_prbs, span<const cbf16_t> iq_data, const ru_compression_params& params) = 0;
 };
 
 } // namespace ofh

include/srsran/ofh/serdes/ofh_uplane_message_builder.h

@@ -37,7 +37,7 @@ class uplane_message_builder
   /// \param[in] config  User plane message parameters.
   /// \return Number of bytes serialized in the buffer.
   virtual unsigned
-  build_message(span<uint8_t> buffer, span<const cf_t> iq_data, const uplane_message_params& params) = 0;
+  build_message(span<uint8_t> buffer, span<const cbf16_t> iq_data, const uplane_message_params& params) = 0;
 };
 
 } // namespace ofh

lib/ofh/compression/iq_compression_bfp_avx2.cpp

@@ -17,7 +17,7 @@ using namespace srsran;
 using namespace ofh;
 
 void iq_compression_bfp_avx2::compress(span<compressed_prb>         output,
-                                       span<const cf_t>             input,
+                                       span<const cbf16_t>          input,
                                        const ru_compression_params& params)
 {
   // Use generic implementation if AVX2 utils don't support requested bit width.
@@ -32,16 +32,16 @@ void iq_compression_bfp_avx2::compress(span<compressed_prb>         output,
   // Auxiliary arrays used for float to fixed point conversion of the input data.
   std::array<int16_t, NOF_SAMPLES_PER_PRB * MAX_NOF_PRBS> input_quantized;
 
-  span<const float> float_samples_span(reinterpret_cast<const float*>(input.data()), input.size() * 2U);
-  span<int16_t>     input_quantized_span(input_quantized.data(), input.size() * 2U);
-  // Performs conversion of input complex float values to signed 16bit integers.
+  span<const bf16_t> float_samples_span(reinterpret_cast<const bf16_t*>(input.data()), input.size() * 2U);
+  span<int16_t>      input_quantized_span(input_quantized.data(), float_samples_span.size());
+  // Performs conversion of input complex float values to signed 16-bit integers.
   quantize_input(input_quantized_span, float_samples_span);
 
   // Compression algorithm implemented according to O-RAN.WG4.CUS Annex A.1.2.
   unsigned sample_idx = 0;
   unsigned rb         = 0;
 
-  // One AVX2 register stores 8 16bit IQ pairs. We can process 2 PRBs at a time by using 3 AVX2 registers.
+  // One AVX2 register stores 8 16-bit IQ pairs. We can process 2 PRBs at a time by using 3 AVX2 registers.
   for (size_t rb_index_end = (output.size() / 2) * 2; rb != rb_index_end; rb += 2) {
     span<compressed_prb> c_prbs = output.subspan(rb, 2);
 

lib/ofh/compression/iq_compression_bfp_avx2.h

@@ -26,7 +26,7 @@ class iq_compression_bfp_avx2 : public iq_compression_bfp_impl
   }
 
   // See interface for the documentation.
-  void compress(span<compressed_prb> output, span<const cf_t> input, const ru_compression_params& params) override;
+  void compress(span<compressed_prb> output, span<const cbf16_t> input, const ru_compression_params& params) override;
 
   // See interface for the documentation.
   void decompress(span<cf_t> output, span<const compressed_prb> input, const ru_compression_params& params) override;

lib/ofh/compression/iq_compression_bfp_avx512.cpp

@@ -27,7 +27,7 @@ static inline __m512i loadu_epi16_avx512(const void* mem_address)
 /// \brief Compresses samples of a single resource block using AVX512 intrinsics.
 ///
 /// \param[out] compressed_prb Compressed PRB (stores compressed packed values).
-/// \param[in] uncompr_samples Pointer to an array of uncompressed 16bit samples.
+/// \param[in] uncompr_samples Pointer to an array of uncompressed 16-bit samples.
 /// \param[in] exponent        Exponent used in BFP compression.
 /// \param[in] data_width      Bit width of resulting compressed samples.
 static void
@@ -46,7 +46,7 @@ compress_prb_avx512(compressed_prb& c_prb, const int16_t* uncompr_samples, uint8
 }
 
 void iq_compression_bfp_avx512::compress(span<compressed_prb>         output,
-                                         span<const cf_t>             input,
+                                         span<const cbf16_t>          input,
                                          const ru_compression_params& params)
 {
   // Use generic implementation if AVX512 utils don't support requested bit width.
@@ -55,22 +55,22 @@ void iq_compression_bfp_avx512::compress(span<compressed_prb>         output,
     return;
   }
 
-  // AVX512 register size in a number of 16bit words.
+  // AVX512 register size in a number of 16-bit words.
   static constexpr size_t AVX512_REG_SIZE = 32;
 
   // Auxiliary arrays used for float to fixed point conversion of the input data.
   std::array<int16_t, NOF_SAMPLES_PER_PRB * MAX_NOF_PRBS> input_quantized;
 
-  span<const float> float_samples_span(reinterpret_cast<const float*>(input.data()), input.size() * 2U);
-  span<int16_t>     input_quantized_span(input_quantized.data(), input.size() * 2U);
-  // Performs conversion of input complex float values to signed 16bit integers.
+  span<const bf16_t> float_samples_span(reinterpret_cast<const bf16_t*>(input.data()), input.size() * 2U);
+  span<int16_t>      input_quantized_span(input_quantized.data(), float_samples_span.size());
+  // Performs conversion of input brain float values to signed 16-bit integers.
   quantize_input(input_quantized_span, float_samples_span);
 
   // Compression algorithm implemented according to Annex A.1.2 in O-RAN.WG4.CUS.
   unsigned sample_idx = 0;
   unsigned rb         = 0;
 
-  // With 3 AVX512 registers we can process 4 PRBs at a time (48 16bit IQ pairs).
+  // With 3 AVX512 registers we can process 4 PRBs at a time (48 16-bit IQ pairs).
   for (size_t rb_index_end = (output.size() / 4) * 4; rb != rb_index_end; rb += 4) {
     // Load input.
     __m512i r0_epi16 = loadu_epi16_avx512(&input_quantized[sample_idx]);

lib/ofh/compression/iq_compression_bfp_avx512.h

@@ -26,7 +26,7 @@ class iq_compression_bfp_avx512 : public iq_compression_bfp_impl
   }
 
   // See interface for the documentation.
-  void compress(span<compressed_prb> output, span<const cf_t> input, const ru_compression_params& params) override;
+  void compress(span<compressed_prb> output, span<const cbf16_t> input, const ru_compression_params& params) override;
 
   // See interface for the documentation.
   void decompress(span<cf_t> output, span<const compressed_prb> input, const ru_compression_params& params) override;

lib/ofh/compression/iq_compression_bfp_impl.cpp

@@ -16,7 +16,7 @@
 using namespace srsran;
 using namespace ofh;
 
-void iq_compression_bfp_impl::quantize_input(span<int16_t> out, span<const float> in)
+void iq_compression_bfp_impl::quantize_input(span<int16_t> out, span<const bf16_t> in)
 {
   srsran_assert(in.size() == out.size(), "Input and output spans must have the same size");
 
@@ -63,15 +63,15 @@ void iq_compression_bfp_impl::compress_prb_generic(compressed_prb&     c_prb,
 }
 
 void iq_compression_bfp_impl::compress(span<compressed_prb>         output,
-                                       span<const cf_t>             input,
+                                       span<const cbf16_t>          input,
                                        const ru_compression_params& params)
 {
   // Auxiliary arrays used for float to fixed point conversion of the input data.
   std::array<int16_t, NOF_SAMPLES_PER_PRB * MAX_NOF_PRBS> input_quantized;
 
-  span<const float> float_samples_span(reinterpret_cast<const float*>(input.data()), input.size() * 2U);
-  span<int16_t>     input_quantized_span(input_quantized.data(), input.size() * 2U);
-  // Performs conversion of input complex float values to signed 16bit integers.
+  span<const bf16_t> float_samples_span(reinterpret_cast<const bf16_t*>(input.data()), input.size() * 2U);
+  span<int16_t>      input_quantized_span(input_quantized.data(), float_samples_span.size());
+  // Performs conversion of input brain float values to signed 16-bit integers.
   quantize_input(input_quantized_span, float_samples_span);
 
   unsigned sample_idx = 0;

lib/ofh/compression/iq_compression_bfp_impl.h

@@ -30,7 +30,7 @@ class iq_compression_bfp_impl : public iq_compressor, public iq_decompressor
 
   // See interface for the documentation.
   virtual void
-  compress(span<compressed_prb> output, span<const cf_t> input, const ru_compression_params& params) override;
+  compress(span<compressed_prb> output, span<const cbf16_t> input, const ru_compression_params& params) override;
 
   // See interface for the documentation.
   virtual void
@@ -87,7 +87,7 @@ class iq_compression_bfp_impl : public iq_compressor, public iq_decompressor
   /// \param[out] out      Quantized samples.
   /// \param[in] in        Span of input float samples.
   /// \param[in] bit_width Number of significant bits used by the quantized samples.
-  void quantize_input(span<int16_t> out, span<const float> in);
+  void quantize_input(span<int16_t> out, span<const bf16_t> in);
 
 private:
   srslog::basic_logger& logger;

lib/ofh/compression/iq_compression_bfp_neon.cpp

@@ -59,9 +59,9 @@ static inline void shift_right_x3vector_s16(int16x8x3_t src, int16x8x3_t& dst, u
   }
 }
 
-void iq_compression_bfp_neon::compress(span<srsran::ofh::compressed_prb>         output,
-                                       span<const srsran::cf_t>                  input,
-                                       const srsran::ofh::ru_compression_params& params)
+void iq_compression_bfp_neon::compress(span<compressed_prb>         output,
+                                       span<const cbf16_t>          input,
+                                       const ru_compression_params& params)
 {
   // Use generic implementation if NEON utils don't support requested bit width.
   if (!neon::iq_width_packing_supported(params.data_width)) {
@@ -72,17 +72,17 @@ void iq_compression_bfp_neon::compress(span<srsran::ofh::compressed_prb>
   // Auxiliary arrays used for float to fixed point conversion of the input data.
   std::array<int16_t, NOF_SAMPLES_PER_PRB * MAX_NOF_PRBS> input_quantized;
 
-  span<const float> float_samples_span(reinterpret_cast<const float*>(input.data()), input.size() * 2U);
-  span<int16_t>     input_quantized_span(input_quantized.data(), input.size() * 2U);
+  span<const bf16_t> float_samples_span(reinterpret_cast<const bf16_t*>(input.data()), input.size() * 2U);
+  span<int16_t>      input_quantized_span(input_quantized.data(), float_samples_span.size());
 
-  // Performs conversion of input complex float values to signed 16bit integers.
+  // Performs conversion of input brain float values to signed 16-bit integers.
   quantize_input(input_quantized_span, float_samples_span);
 
   // Compression algorithm implemented according to Annex A.1.2 in O-RAN.WG4.CUS.
   unsigned sample_idx = 0;
   unsigned rb         = 0;
 
-  // One NEON register can store 8 16bit samples. A PRB is comprised of 24 16bit IQ samples, thus we need three NEON
+  // One NEON register can store 8 16-bit samples. A PRB is comprised of 24 16-bit IQ samples, thus we need three NEON
   // registers to process one PRB.
   //
   // The loop below processes four resource blocks at a time.

lib/ofh/compression/iq_compression_bfp_neon.h

@@ -26,7 +26,7 @@ class iq_compression_bfp_neon : public iq_compression_bfp_impl
   }
 
   // See interface for the documentation.
-  void compress(span<compressed_prb> output, span<const cf_t> input, const ru_compression_params& params) override;
+  void compress(span<compressed_prb> output, span<const cbf16_t> input, const ru_compression_params& params) override;
 
   // See interface for the documentation.
   void decompress(span<cf_t> output, span<const compressed_prb> input, const ru_compression_params& params) override;