agora-doxy/html/ue__worker_8h_source.html

#ifndef UE_WORKER_H_

#define UE_WORKER_H_


#include <complex>

#include <thread>

#include <vector>


#include "concurrentqueue.h"

#include "config.h"

#include "csv_logger.h"

#include "dodecode_client.h"

#include "doencode.h"

#include "doifft_client.h"

#include "message.h"

#include "mkl_dfti.h"

#include "simd_types.h"

#include "stats.h"


class UeWorker {

 public:

  explicit UeWorker(

      size_t tid, Config& config, Stats& shared_stats,

      PhyStats& shared_phy_stats,

      moodycamel::ConcurrentQueue<EventData>& notify_queue,

      moodycamel::ConcurrentQueue<EventData>& work_queue,

      moodycamel::ProducerToken& work_producer, Table<int8_t>& ul_bits_buffer,

      Table<int8_t>& encoded_buffer, Table<complex_float>& modul_buffer,

      Table<complex_float>& ifft_buffer, char* const tx_buffer,

      Table<char>& rx_buffer, Table<complex_float>& csi_buffer,

      std::vector<SimdAlignCxFltVector>& equal_buffer,

      std::vector<size_t>& non_null_sc_ind, Table<complex_float>& fft_buffer,

      PtrCube<kFrameWnd, kMaxSymbols, kMaxUEs, int8_t>& demod_buffer,

      PtrCube<kFrameWnd, kMaxSymbols, kMaxUEs, int8_t>& decoded_buffer,

      std::vector<std::vector<std::complex<float>>>& ue_pilot_vec);

  ~UeWorker();


  void Start(size_t core_offset);

  void Stop();


 private:

  void TaskThread(size_t core_offset);


  void DoEncodeUe(DoEncode* encoder, size_t tag);

  void DoModul(size_t tag);

  void DoIfftUe(DoIFFTClient* iffter, size_t tag);

  void DoIfft(size_t tag);


  void DoFftPilot(size_t tag);

  void DoFftData(size_t tag);


  void DoDemul(size_t tag);

  void DoDecodeUe(DoDecodeClient* decoder, size_t tag);


  size_t tid_;


  DFTI_DESCRIPTOR_HANDLE mkl_handle_;

  std::unique_ptr<moodycamel::ProducerToken> ptok_;

  std::thread thread_;

  std::complex<float>* rx_samps_tmp_;  // Temp buffer for received samples


  // Shared Queues

  moodycamel::ConcurrentQueue<EventData>& notify_queue_;

  moodycamel::ConcurrentQueue<EventData>& work_queue_;

  moodycamel::ProducerToken& work_producer_token_;


  // Shared Objects

  Config& config_;

  Stats& stats_;

  PhyStats& phy_stats_;


  // Shared Buffers

  // Uplink

  Table<int8_t>& ul_bits_buffer_;

  Table<int8_t>& encoded_buffer_;

  Table<complex_float>& modul_buffer_;

  Table<complex_float>& ifft_buffer_;

  char* const tx_buffer_;


  // Downlink

  Table<char>& rx_buffer_;

  Table<complex_float>& csi_buffer_;

  std::vector<SimdAlignCxFltVector>& equal_buffer_;

  std::vector<size_t>& non_null_sc_ind_;

  Table<complex_float>& fft_buffer_;

  PtrCube<kFrameWnd, kMaxSymbols, kMaxUEs, int8_t>& demod_buffer_;

  PtrCube<kFrameWnd, kMaxSymbols, kMaxUEs, int8_t>& decoded_buffer_;


  std::vector<std::vector<std::complex<float>>>& ue_pilot_vec_;

};

#endif  // UE_WORKER_H_