nr-mac-scheduler-harq-rr.cc

// Copyright (c) 2019 Centre Tecnologic de Telecomunicacions de Catalunya (CTTC)
//
// SPDX-License-Identifier: GPL-2.0-only
 
#define NS_LOG_APPEND_CONTEXT                                                                      \
    do                                                                                             \
    {                                                                                              \
        std::clog << " [ CellId " << GetCellId() << ", bwpId " << GetBwpId() << "] ";              \
    } while (false);
#include "nr-mac-scheduler-harq-rr.h"
 
#include "nr-fh-control.h"
 
#include <ns3/log.h>
 
#include <algorithm>
 
namespace ns3
{
 
NS_LOG_COMPONENT_DEFINE("NrMacSchedulerHarqRr");
 
NrMacSchedulerHarqRr::NrMacSchedulerHarqRr()
{
}
 
void
NrMacSchedulerHarqRr::InstallGetBwpIdFn(const std::function<uint16_t()>& fn)
{
    m_getBwpId = fn;
}
 
void
NrMacSchedulerHarqRr::InstallGetCellIdFn(const std::function<uint16_t()>& fn)
{
    m_getCellId = fn;
}
 
void
NrMacSchedulerHarqRr::InstallGetBwInRBG(const std::function<uint16_t()>& fn)
{
    m_getBwInRbg = fn;
}
 
void
NrMacSchedulerHarqRr::InstallGetFhControlMethodFn(const std::function<uint8_t()>& fn)
{
    m_getFhControlMethod = fn;
}
 
void
NrMacSchedulerHarqRr::InstallDoesFhAllocationFitFn(
    const std::function<bool(uint16_t bwpId, uint32_t mcs, uint32_t nRegs, uint8_t dlRank)>& fn)
{
    m_getDoesAllocationFit = fn;
}
 
uint8_t
NrMacSchedulerHarqRr::ScheduleDlHarq(
    NrMacSchedulerNs3::PointInFTPlane* startingPoint,
    uint8_t symAvail,
    const Ns3Sched::ActiveHarqMap& activeDlHarq,
    const std::unordered_map<uint16_t, std::shared_ptr<NrMacSchedulerUeInfo>>& ueMap,
    std::vector<DlHarqInfo>* dlHarqToRetransmit,
    const std::vector<DlHarqInfo>& dlHarqFeedback,
    SlotAllocInfo* slotAlloc) const
{
    NS_LOG_FUNCTION(this);
    NS_ASSERT(startingPoint->m_rbg == 0);
    uint8_t usedSym = 0;
    uint8_t symPerBeam = symAvail / activeDlHarq.size();
 
    NS_LOG_INFO("We have " << activeDlHarq.size() << " beams with data to RETX, each beam has "
                           << static_cast<uint32_t>(symPerBeam) << " symb");
 
    for (const auto& beam : activeDlHarq)
    {
        std::vector<uint16_t> allocatedUe;
        NS_LOG_INFO(" Try to assign HARQ resource for Beam sector: "
                    << static_cast<uint32_t>(beam.first.GetSector())
                    << " Beam theta:  " << static_cast<uint32_t>(beam.first.GetElevation())
                    << " # HARQ to Retx=" << beam.second.size());
 
        for (auto it : beam.second)
        {
            HarqProcess& harqProcess = it->second;
            NS_ASSERT_MSG(harqProcess.m_status == HarqProcess::RECEIVED_FEEDBACK,
                          "Process " << static_cast<uint32_t>(it->first)
                                     << " is not in RECEIVED_FEEDBACK status");
 
            harqProcess.m_status = HarqProcess::WAITING_FEEDBACK;
            harqProcess.m_timer = 0;
 
            auto& dciInfoReTx = harqProcess.m_dciElement;
 
            uint32_t rbgAssigned =
                std::count(dciInfoReTx->m_rbgBitmask.begin(), dciInfoReTx->m_rbgBitmask.end(), 1) *
                dciInfoReTx->m_numSym;
            uint32_t rbgAvail = (GetBandwidthInRbg() - startingPoint->m_rbg) * symPerBeam;
 
            NS_LOG_INFO("Evaluating space to retransmit HARQ PID="
                        << static_cast<uint32_t>(dciInfoReTx->m_harqProcess) << " for UE="
                        << static_cast<uint32_t>(dciInfoReTx->m_rnti) << " SYM assigned previously="
                        << static_cast<uint32_t>(dciInfoReTx->m_numSym)
                        << " RBG assigned previously=" << static_cast<uint32_t>(rbgAssigned)
                        << " SYM avail for this beam=" << static_cast<uint32_t>(symPerBeam)
                        << " RBG avail for this beam=" << rbgAvail);
 
            if (std::find(allocatedUe.begin(), allocatedUe.end(), dciInfoReTx->m_rnti) !=
                allocatedUe.end())
            {
                NS_LOG_INFO("UE " << dciInfoReTx->m_rnti
                                  << " already has an HARQ allocated, buffer this HARQ process"
                                  << static_cast<uint32_t>(dciInfoReTx->m_harqProcess));
                BufferHARQFeedback(dlHarqFeedback,
                                   dlHarqToRetransmit,
                                   dciInfoReTx->m_rnti,
                                   dciInfoReTx->m_harqProcess);
                continue;
            }
            else if (rbgAvail < rbgAssigned)
            {
                NS_LOG_INFO("No resource for this retx, we have to buffer it");
                BufferHARQFeedback(dlHarqFeedback,
                                   dlHarqToRetransmit,
                                   dciInfoReTx->m_rnti,
                                   dciInfoReTx->m_harqProcess);
                continue;
            }
            if (GetFromSchedFhControlMethod() == NrFhControl::FhControlMethod::Postponing ||
                GetFromSchedFhControlMethod() == NrFhControl::FhControlMethod::OptimizeMcs ||
                GetFromSchedFhControlMethod() == NrFhControl::FhControlMethod::OptimizeRBs)
            {
                if (GetDoesFhAllocationFit(GetBwpId(),
                                           dciInfoReTx->m_mcs,
                                           rbgAssigned,
                                           dciInfoReTx->m_rank) == 0)
                {
                    NS_LOG_INFO("No FH resources for this retx, we have to buffer it");
                    BufferHARQFeedback(dlHarqFeedback,
                                       dlHarqToRetransmit,
                                       dciInfoReTx->m_rnti,
                                       dciInfoReTx->m_harqProcess);
                    continue;
                }
            }
 
            allocatedUe.push_back(dciInfoReTx->m_rnti);
 
            NS_ASSERT(dciInfoReTx->m_format == DciInfoElementTdma::DL);
            auto dci = std::make_shared<DciInfoElementTdma>(dciInfoReTx->m_rnti,
                                                            dciInfoReTx->m_format,
                                                            startingPoint->m_sym,
                                                            symPerBeam,
                                                            dciInfoReTx->m_mcs,
                                                            dciInfoReTx->m_rank,
                                                            dciInfoReTx->m_precMats,
                                                            dciInfoReTx->m_tbSize,
                                                            0,
                                                            dciInfoReTx->m_rv + 1,
                                                            DciInfoElementTdma::DATA,
                                                            dciInfoReTx->m_bwpIndex,
                                                            dciInfoReTx->m_tpc);
 
            dci->m_rbgBitmask = harqProcess.m_dciElement->m_rbgBitmask;
            dci->m_harqProcess = dciInfoReTx->m_harqProcess;
 
            harqProcess.m_dciElement = dci;
            dciInfoReTx = harqProcess.m_dciElement;
 
            if (rbgAssigned % dciInfoReTx->m_numSym == 0)
            {
                rbgAssigned = rbgAssigned / dciInfoReTx->m_numSym;
            }
            else
            {
                rbgAssigned = rbgAssigned / dciInfoReTx->m_numSym;
                ++rbgAssigned;
            }
 
            NS_ABORT_IF(static_cast<unsigned long>(rbgAssigned) > dciInfoReTx->m_rbgBitmask.size());
 
            for (unsigned int i = 0; i < dciInfoReTx->m_rbgBitmask.size(); ++i)
            {
                if (startingPoint->m_rbg <= i && i < startingPoint->m_rbg + rbgAssigned)
                {
                    dciInfoReTx->m_rbgBitmask.at(i) = true;
                }
                else
                {
                    dciInfoReTx->m_rbgBitmask.at(i) = false;
                }
            }
 
            startingPoint->m_rbg += rbgAssigned;
 
            VarTtiAllocInfo slotInfo(dciInfoReTx);
            NS_LOG_DEBUG(
                "UE" << dciInfoReTx->m_rnti << " gets DL symbols "
                     << static_cast<uint32_t>(dciInfoReTx->m_symStart) << "-"
                     << static_cast<uint32_t>(dciInfoReTx->m_symStart + dciInfoReTx->m_numSym - 1)
                     << " tbs " << dciInfoReTx->m_tbSize << " harqId "
                     << static_cast<uint32_t>(dciInfoReTx->m_harqProcess) << " rv "
                     << static_cast<uint32_t>(dciInfoReTx->m_rv)
                     << " RBG start: " << static_cast<uint32_t>(startingPoint->m_rbg - rbgAssigned)
                     << " RBG end: " << static_cast<uint32_t>(startingPoint->m_rbg) << " RETX");
            for (const auto& rlcPdu : harqProcess.m_rlcPduInfo)
            {
                slotInfo.m_rlcPduInfo.push_back(rlcPdu);
            }
            slotAlloc->m_varTtiAllocInfo.push_back(slotInfo);
 
            ueMap.find(dciInfoReTx->m_rnti)->second->m_dlMRBRetx =
                dciInfoReTx->m_numSym * rbgAssigned;
        }
 
        if (!allocatedUe.empty())
        {
            startingPoint->m_sym += symPerBeam;
            startingPoint->m_rbg = 0;
            usedSym += symPerBeam;
            slotAlloc->m_numSymAlloc += symPerBeam;
            symAvail -= symPerBeam;
        }
    }
    NS_ASSERT(startingPoint->m_rbg == 0);
    return usedSym;
}
 
uint8_t
NrMacSchedulerHarqRr::ScheduleUlHarq(
    NrMacSchedulerNs3::PointInFTPlane* startingPoint,
    uint8_t symAvail,
    const std::unordered_map<uint16_t, std::shared_ptr<NrMacSchedulerUeInfo>>& ueMap,
    std::vector<UlHarqInfo>* ulHarqToRetransmit,
    const std::vector<UlHarqInfo>& ulHarqFeedback,
    SlotAllocInfo* slotAlloc) const
{
    NS_LOG_FUNCTION(this);
    uint8_t symUsed = 0;
    NS_ASSERT(startingPoint->m_rbg == 0);
 
    NS_LOG_INFO("Scheduling UL HARQ starting from sym "
                << +startingPoint->m_sym << " and RBG " << startingPoint->m_rbg
                << ". Available symbols: " << symAvail
                << " number of feedback: " << ulHarqFeedback.size());
 
    for (uint16_t i = 0; i < ulHarqFeedback.size() && symAvail > 0; i++)
    {
        UlHarqInfo harqInfo = ulHarqFeedback.at(i);
        uint8_t harqId = harqInfo.m_harqProcessId;
        uint16_t rnti = harqInfo.m_rnti;
 
        NS_ABORT_IF(harqInfo.IsReceivedOk());
 
        // retx correspondent block: retrieve the UL-DCI
        HarqProcess& harqProcess = ueMap.find(rnti)->second->m_ulHarq.Find(harqId)->second;
        NS_ASSERT(harqProcess.m_status == HarqProcess::RECEIVED_FEEDBACK);
 
        harqProcess.m_status = HarqProcess::WAITING_FEEDBACK;
        harqProcess.m_timer = 0;
        auto& dciInfoReTx = harqProcess.m_dciElement;
 
        NS_LOG_INFO("Feedback is for UE " << rnti << " process " << +harqId
                                          << " sym: " << +dciInfoReTx->m_numSym);
 
        if (symAvail >= dciInfoReTx->m_numSym)
        {
            symAvail -= dciInfoReTx->m_numSym;
            symUsed += dciInfoReTx->m_numSym;
 
            NS_ASSERT(dciInfoReTx->m_format == DciInfoElementTdma::UL);
 
            auto dci =
                std::make_shared<DciInfoElementTdma>(dciInfoReTx->m_rnti,
                                                     dciInfoReTx->m_format,
                                                     startingPoint->m_sym - dciInfoReTx->m_numSym,
                                                     dciInfoReTx->m_numSym,
                                                     dciInfoReTx->m_mcs,
                                                     dciInfoReTx->m_rank,
                                                     dciInfoReTx->m_precMats,
                                                     dciInfoReTx->m_tbSize,
                                                     0,
                                                     dciInfoReTx->m_rv + 1,
                                                     DciInfoElementTdma::DATA,
                                                     dciInfoReTx->m_bwpIndex,
                                                     dciInfoReTx->m_tpc);
            dci->m_rbgBitmask = harqProcess.m_dciElement->m_rbgBitmask;
            dci->m_harqProcess = harqId;
            harqProcess.m_dciElement = dci;
            dciInfoReTx = harqProcess.m_dciElement;
 
            startingPoint->m_sym -= dciInfoReTx->m_numSym;
 
            VarTtiAllocInfo slotInfo(dciInfoReTx);
            NS_LOG_DEBUG(
                "UE" << dciInfoReTx->m_rnti << " gets UL symbols "
                     << static_cast<uint32_t>(dciInfoReTx->m_symStart) << "-"
                     << static_cast<uint32_t>(dciInfoReTx->m_symStart + dciInfoReTx->m_numSym - 1)
                     << " tbs " << dciInfoReTx->m_tbSize << " harqId "
                     << static_cast<uint32_t>(dciInfoReTx->m_harqProcess) << " rv "
                     << static_cast<uint32_t>(dciInfoReTx->m_rv) << " RETX");
            slotAlloc->m_varTtiAllocInfo.push_front(slotInfo);
            slotAlloc->m_numSymAlloc += dciInfoReTx->m_numSym;
 
            ueMap.find(rnti)->second->m_ulMRBRetx = dciInfoReTx->m_numSym * GetBandwidthInRbg();
        }
        else
        {
            ulHarqToRetransmit->push_back(ulHarqFeedback.at(i));
        }
    }
 
    NS_ASSERT(startingPoint->m_rbg == 0);
 
    return symUsed;
}
 
void
NrMacSchedulerHarqRr::SortDlHarq(NrMacSchedulerNs3::ActiveHarqMap* activeDlHarq) const
{
    NS_LOG_FUNCTION(this);
 
    // Order based on required sym
    static struct
    {
        bool operator()(const NrMacSchedulerNs3::HarqVectorIterator& a,
                        const NrMacSchedulerNs3::HarqVectorIterator& b) const
        {
            return a->second.m_dciElement->m_numSym > b->second.m_dciElement->m_numSym;
        }
    } CompareNumSym;
 
    for (auto& it : *activeDlHarq)
    {
        std::stable_sort(it.second.begin(), it.second.end(), CompareNumSym);
    }
}
 
void
NrMacSchedulerHarqRr::SortUlHarq(
    [[maybe_unused]] NrMacSchedulerNs3::ActiveHarqMap* activeUlHarq) const
{
    NS_LOG_FUNCTION(this);
}
 
void
NrMacSchedulerHarqRr::BufferHARQFeedback(const std::vector<DlHarqInfo>& dlHarqFeedback,
                                         std::vector<DlHarqInfo>* dlHarqToRetransmit,
                                         uint16_t rnti,
                                         uint8_t harqProcess) const
{
    NS_LOG_FUNCTION(this);
 
    bool found = false;
    for (const auto& feedback : dlHarqFeedback)
    {
        if (feedback.m_rnti == rnti && feedback.m_harqProcessId == harqProcess)
        {
            dlHarqToRetransmit->push_back(feedback);
            found = true;
            break;
        }
    }
    NS_ASSERT(found);
}
 
uint16_t
NrMacSchedulerHarqRr::GetBwpId() const
{
    return m_getBwpId();
}
 
uint16_t
NrMacSchedulerHarqRr::GetCellId() const
{
    return m_getCellId();
}
 
uint16_t
NrMacSchedulerHarqRr::GetBandwidthInRbg() const
{
    return m_getBwInRbg();
}
 
uint8_t
NrMacSchedulerHarqRr::GetFromSchedFhControlMethod() const
{
    return m_getFhControlMethod();
}
 
bool
NrMacSchedulerHarqRr::GetDoesFhAllocationFit(uint16_t bwpId,
                                             uint32_t mcs,
                                             uint32_t nRegs,
                                             uint8_t dlRank) const
{
    return m_getDoesAllocationFit(bwpId, mcs, nRegs, dlRank);
}
 
} // namespace ns3