Attachment #3189 for bug #2995

View | Details | Raw Unified | Return to bug 2995
Collapse All | Expand All




  virtual void UlReceiveMacCe (MacCeListElement_s bsr, uint8_t componentCarrierId);
  virtual void NotifyPrbOccupancy (double prbOccupancy, uint8_t componentCarrierId);
  // inherited from LteMacSapUser
  virtual void NotifyTxOpportunity (LteMacSapUser::TxOpportunityParameters txOpParams);
  virtual void ReceivePdu (LteMacSapUser::ReceivePduParameters rxPduParams);
  virtual void NotifyHarqDeliveryFailure ();



}

template <class C>
void MemberLteCcmMacSapUser<C>::NotifyTxOpportunity (LteMacSapUser::TxOpportunityParameters txOpParams)
{
  m_owner->DoNotifyTxOpportunity (txOpParams);
}

template <class C>
void MemberLteCcmMacSapUser<C>::ReceivePdu (LteMacSapUser::ReceivePduParameters rxPduParams)
{
  m_owner->DoReceivePdu (rxPduParams);
}

template <class C>

(-)a/src/lte/model/lte-enb-mac.cc (-2 / +14 lines)

Lines 765-774 LteEnbMac::DoReceivePhyPdu (Ptr<Packet> p)	Link Here

765

  std::map<uint8_t, LteMacSapUser*>::iterator lcidIt = rntiIt->second.find (lcid);

765

  std::map<uint8_t, LteMacSapUser*>::iterator lcidIt = rntiIt->second.find (lcid);

766

  //NS_ASSERT_MSG (lcidIt != rntiIt->second.end (), "could not find LCID" << lcid);

766

  //NS_ASSERT_MSG (lcidIt != rntiIt->second.end (), "could not find LCID" << lcid);

767

768

  LteMacSapUser::ReceivePduParameters rxPduParams;

769

  rxPduParams.p = p;

770

  rxPduParams.rnti = rnti;

771

  rxPduParams.lcid = lcid;

772

768

  //Receive PDU only if LCID is found

773

  //Receive PDU only if LCID is found

769

  if (lcidIt != rntiIt->second.end ())

774

  if (lcidIt != rntiIt->second.end ())

770

775

771

      (*lcidIt).second->ReceivePdu (p, rnti, lcid);

776

      (*lcidIt).second->ReceivePdu (rxPduParams);

772

777

773

778

774

779

Lines 1023-1028 LteEnbMac::DoSchedDlConfigInd (FfMacSchedSapUser::SchedDlConfigIndParameters ind	Link Here

1023

  // Create DL PHY PDU

1028

  // Create DL PHY PDU

1024

  Ptr<PacketBurst> pb = CreateObject<PacketBurst> ();

1029

  Ptr<PacketBurst> pb = CreateObject<PacketBurst> ();

1025

  std::map <LteFlowId_t, LteMacSapUser* >::iterator it;

1030

  std::map <LteFlowId_t, LteMacSapUser* >::iterator it;

1031

  LteMacSapUser::TxOpportunityParameters txOpParams;

1026

1032

1027

  for (unsigned int i = 0; i < ind.m_buildDataList.size (); i++)

1033

  for (unsigned int i = 0; i < ind.m_buildDataList.size (); i++)

1028

1034

Lines 1054-1060 LteEnbMac::DoSchedDlConfigInd (FfMacSchedSapUser::SchedDlConfigIndParameters ind	Link Here

1054

                  std::map<uint8_t, LteMacSapUser*>::iterator lcidIt = rntiIt->second.find (lcid);

1060

                  std::map<uint8_t, LteMacSapUser*>::iterator lcidIt = rntiIt->second.find (lcid);

1055

                  NS_ASSERT_MSG (lcidIt != rntiIt->second.end (), "could not find LCID" << (uint32_t)lcid<<" carrier id:"<<(uint16_t)m_componentCarrierId);

1061

                  NS_ASSERT_MSG (lcidIt != rntiIt->second.end (), "could not find LCID" << (uint32_t)lcid<<" carrier id:"<<(uint16_t)m_componentCarrierId);

1056

                  NS_LOG_DEBUG (this << " rnti= " << rnti << " lcid= " << (uint32_t) lcid << " layer= " << k);

1062

                  NS_LOG_DEBUG (this << " rnti= " << rnti << " lcid= " << (uint32_t) lcid << " layer= " << k);

1057

                  (*lcidIt).second->NotifyTxOpportunity (ind.m_buildDataList.at (i).m_rlcPduList.at (j).at (k).m_size, k, ind.m_buildDataList.at (i).m_dci.m_harqProcess, m_componentCarrierId, rnti, lcid);

1063

                  txOpParams.bytes = ind.m_buildDataList.at (i).m_rlcPduList.at (j).at (k).m_size;

1064

                  txOpParams.layer = k;

1065

                  txOpParams.harqId = ind.m_buildDataList.at (i).m_dci.m_harqProcess;

1066

                  txOpParams.componentCarrierId = m_componentCarrierId;

1067

                  txOpParams.rnti = rnti;

1068

                  txOpParams.lcid = lcid;

1069

                  (*lcidIt).second->NotifyTxOpportunity (txOpParams);

1058

1070

1059

              else

1071

              else

1060

1072




public:
  virtual ~LteMacSapUser ();
  /**
   * Parameters for LteMacSapUser::NotifyTxOpportunity
   *
   */
  struct TxOpportunityParameters
  {
    uint32_t bytes;  /**< the number of bytes to transmit */
    uint8_t layer; /**<  the layer of transmission (MIMO) */
    uint8_t harqId; /**< the HARQ ID */
    uint8_t componentCarrierId; /**< the component carrier id */
    uint16_t rnti; /**< the C-RNTI identifying the UE */
    uint8_t lcid; /**< the logical channel id */
  };
  /**
   * Called by the MAC to notify the RLC that the scheduler granted a
   * transmission opportunity to this RLC instance.
   *
   * \param params the TxOpportunityParameters
   * \param layer the layer of transmission (MIMO)
   * \param harqId the HARQ ID
   * \param componentCarrierId component carrier ID
   * \param rnti the RNTI
   * \param lcid the LCID
   */
  virtual void NotifyTxOpportunity (TxOpportunityParameters params) = 0;

  /**
   * Called by the MAC to notify the RLC that an HARQ process related

   */
  virtual void NotifyHarqDeliveryFailure () = 0;

  /**
   * Parameters for LteMacSapUser::ReceivePdu
   *
   */
  struct ReceivePduParameters
  {
    Ptr<Packet> p;  /**< the RLC PDU to be received */
    uint16_t rnti; /**< the C-RNTI identifying the UE */
    uint8_t lcid; /**< the logical channel id */
  };
  /**
   * Called by the MAC to notify the RLC of the reception of a new PDU
   *
   * \param params the ReceivePduParameters
   * \param rnti the RNTI
   * \param lcid the LCID
   */
  virtual void ReceivePdu (ReceivePduParameters params) = 0;

};





 */

void
LteRlcAm::DoNotifyTxOpportunity (LteMacSapUser::TxOpportunityParameters txOpParams)
{
  NS_LOG_FUNCTION (this << m_rnti << (uint32_t) m_lcid << txOpParams.bytes);

  if (txOpParams.bytes < 4)
    {
      // Stingy MAC: In general, we need more bytes.
      // There are a more restrictive test for each particular case
      NS_LOG_LOGIC ("TxOpportunity (size = " << txOpParams.bytes << ") too small");
      NS_ASSERT_MSG (false, "TxOpportunity (size = " << txOpParams.bytes << ") too small.\n"
                         << "Your MAC scheduler is assigned too few resource blocks.");
      return;
    }

  if ( m_statusPduRequested && ! m_statusProhibitTimer.IsRunning () )
    {
      if (txOpParams.bytes < m_statusPduBufferSize)
        {
          // Stingy MAC: We need more bytes for the STATUS PDU
          NS_LOG_LOGIC ("TxOpportunity (size = " << txOpParams.bytes << ") too small for the STATUS PDU (size = " << m_statusPduBufferSize << ")");
          NS_ASSERT_MSG (false, "TxOpportunity (size = " << txOpParams.bytes << ") too small for the STATUS PDU (size = " << m_statusPduBufferSize << ")\n"
                             << "Your MAC scheduler is assigned too few resource blocks.");
          return;
        }

      for (sn = m_vrR; sn < m_vrMs; sn++) 
        {
          NS_LOG_LOGIC ("SN = " << sn);          
          if (!rlcAmHeader.OneMoreNackWouldFitIn (txOpParams.bytes))
            {
              NS_LOG_LOGIC ("Can't fit more NACKs in STATUS PDU");
              break;

      params.pdu = packet;
      params.rnti = m_rnti;
      params.lcid = m_lcid;
      params.layer = txOpParams.layer;
      params.harqProcessId = txOpParams.harqId;
      params.componentCarrierId = txOpParams.componentCarrierId;

      m_macSapProvider->TransmitPdu (params);



              Ptr<Packet> packet = m_retxBuffer.at (seqNumberValue).m_pdu->Copy ();
              
              if (( packet->GetSize () <= txOpParams.bytes )
                  || m_txOpportunityForRetxAlwaysBigEnough)
                {
                  // According to 5.2.1, the data field is left as is, but we rebuild the header

                  params.pdu = packet;
                  params.rnti = m_rnti;
                  params.lcid = m_lcid;
                  params.layer = txOpParams.layer;
                  params.harqProcessId = txOpParams.harqId;
                  params.componentCarrierId = txOpParams.componentCarrierId;
                  
                  m_macSapProvider->TransmitPdu (params);


                }
              else
                {
                  NS_LOG_LOGIC ("TxOpportunity (size = " << txOpParams.bytes << ") too small for retransmission of the packet (size = " << packet->GetSize () << ")");
                  NS_LOG_LOGIC ("Waiting for bigger TxOpportunity");
                  return;
                }

    }
  else if ( m_txonBufferSize > 0 )
    {
      if (txOpParams.bytes < 7)
      {
        // Stingy MAC: We need more bytes for new DATA PDUs.
        NS_LOG_LOGIC ("TxOpportunity (size = " << txOpParams.bytes << ") too small for DATA PDU");
        NS_ASSERT_MSG (false, "TxOpportunity (size = " << txOpParams.bytes << ") too small for DATA PDU\n"
                           << "Your MAC scheduler is assigned too few resource blocks.");
        return;
      }

  rlcAmHeader.SetDataPdu ();

  // Build Data field
  uint32_t nextSegmentSize = txOpParams.bytes - 4;
  uint32_t nextSegmentId = 1;
  uint32_t dataFieldTotalSize = 0;
  uint32_t dataFieldAddedSize = 0;

  params.pdu = packet;
  params.rnti = m_rnti;
  params.lcid = m_lcid;
  params.layer = txOpParams.layer;
  params.harqProcessId = txOpParams.harqId;
  params.componentCarrierId = txOpParams.componentCarrierId;

  m_macSapProvider->TransmitPdu (params);
}



void
LteRlcAm::DoReceivePdu (LteMacSapUser::ReceivePduParameters rxPduParams)
{
  NS_LOG_FUNCTION (this << m_rnti << (uint32_t) m_lcid << rxPduParams.p->GetSize ());

  // Receiver timestamp
  RlcTag rlcTag;
  Time delay;
  NS_ASSERT_MSG (rxPduParams.p->PeekPacketTag (rlcTag), "RlcTag is missing");
  rxPduParams.p->RemovePacketTag (rlcTag);
  delay = Simulator::Now() - rlcTag.GetSenderTimestamp ();
  m_rxPdu (m_rnti, m_lcid, rxPduParams.p->GetSize (), delay.GetNanoSeconds ());

  // Get RLC header parameters
  LteRlcAmHeader rlcAmHeader;
  rxPduParams.p->PeekHeader (rlcAmHeader);
  NS_LOG_LOGIC ("RLC header: " << rlcAmHeader);

  if ( rlcAmHeader.IsDataPdu () )

          else
            {
              NS_LOG_LOGIC ("Place PDU in the reception buffer ( SN = " << seqNumber << " )");
              m_rxonBuffer[ seqNumber.GetValue () ].m_byteSegments.push_back (rxPduParams.p);
              m_rxonBuffer[ seqNumber.GetValue () ].m_pduComplete = true;
            }





  /**
   * MAC SAP
   *
   * \param txOpParams the LteMacSapUser::TxOpportunityParameters
   * \param layer 
   * \param harqId HARQ ID
   * \param componentCarrierId component carrier ID
   * \param rnti the RNTI
   * \param lcid the LCID
   */
  virtual void DoNotifyTxOpportunity (LteMacSapUser::TxOpportunityParameters txOpParams);
    /**
   * Notify HARQ delivery failure
   */
  virtual void DoNotifyHarqDeliveryFailure ();
  virtual void DoReceivePdu (LteMacSapUser::ReceivePduParameters rxPduParams);

private:
  /**




 */

void
LteRlcTm::DoNotifyTxOpportunity (LteMacSapUser::TxOpportunityParameters txOpParams)
{
  NS_LOG_FUNCTION (this << m_rnti << (uint32_t) m_lcid << txOpParams.bytes  << (uint32_t) txOpParams.layer << (uint32_t) txOpParams.harqId);

  // 5.1.1.1 Transmit operations 
  // 5.1.1.1.1 General


  Ptr<Packet> packet = (*(m_txBuffer.begin ()))->Copy ();

  if (txOpParams.bytes < packet->GetSize ())
    {
      NS_LOG_WARN ("TX opportunity too small = " << txOpParams.bytes << " (PDU size: " << packet->GetSize () << ")");
      return;
    }


  params.pdu = packet;
  params.rnti = m_rnti;
  params.lcid = m_lcid;
  params.layer = txOpParams.layer;
  params.harqProcessId = txOpParams.harqId;
  params.componentCarrierId = txOpParams.componentCarrierId;

  m_macSapProvider->TransmitPdu (params);


}

void
LteRlcTm::DoReceivePdu (LteMacSapUser::ReceivePduParameters rxPduParams)
{
  NS_LOG_FUNCTION (this << m_rnti << (uint32_t) m_lcid << rxPduParams.p->GetSize ());

  // Receiver timestamp
  RlcTag rlcTag;
  Time delay;
  NS_ASSERT_MSG (rxPduParams.p->PeekPacketTag (rlcTag), "RlcTag is missing");
  rxPduParams.p->RemovePacketTag (rlcTag);
  delay = Simulator::Now() - rlcTag.GetSenderTimestamp ();
  m_rxPdu (m_rnti, m_lcid, rxPduParams.p->GetSize (), delay.GetNanoSeconds ());

  // 5.1.1.2 Receive operations 
  // 5.1.1.2.1  General
  // When receiving a new TMD PDU from lower layer, the receiving TM RLC entity shall:
  // - deliver the TMD PDU without any modification to upper layer.

   m_rlcSapUser->ReceivePdcpPdu (rxPduParams.p);
}






  /**
   * MAC SAP
   * 
   * \param txOpParams the LteMacSapUser::TxOpportunityParameters
   * \param layer the layer
   * \param harqId HARQ ID
   * \param componentCarrierId component carrier ID
   * \param rnti the RNTI
   * \param lcid the LCID
   */
  virtual void DoNotifyTxOpportunity (LteMacSapUser::TxOpportunityParameters txOpParams);
  /**
   * Notify HARQ deliver failure
   */
  virtual void DoNotifyHarqDeliveryFailure ();
  virtual void DoReceivePdu (LteMacSapUser::ReceivePduParameters rxPduParams);

private:
  /// Expire RBS timer function




 */

void
LteRlcUm::DoNotifyTxOpportunity (LteMacSapUser::TxOpportunityParameters txOpParams)
{
  NS_LOG_FUNCTION (this << m_rnti << (uint32_t) m_lcid << txOpParams.bytes);

  if (txOpParams.bytes <= 2)
    {
      // Stingy MAC: Header fix part is 2 bytes, we need more bytes for the data
      NS_LOG_LOGIC ("TX opportunity too small = " << txOpParams.bytes);
      return;
    }


  LteRlcHeader rlcHeader;

  // Build Data field
  uint32_t nextSegmentSize = txOpParams.bytes - 2;
  uint32_t nextSegmentId = 1;
  uint32_t dataFieldTotalSize = 0;
  uint32_t dataFieldAddedSize = 0;

  params.pdu = packet;
  params.rnti = m_rnti;
  params.lcid = m_lcid;
  params.layer = txOpParams.layer;
  params.harqProcessId = txOpParams.harqId;
  params.componentCarrierId = txOpParams.componentCarrierId;

  m_macSapProvider->TransmitPdu (params);


}

void
LteRlcUm::DoReceivePdu (LteMacSapUser::ReceivePduParameters rxPduParams)
{
  NS_LOG_FUNCTION (this << m_rnti << (uint32_t) m_lcid << rxPduParams.p->GetSize ());

  // Receiver timestamp
  RlcTag rlcTag;
  Time delay;
  NS_ASSERT_MSG (rxPduParams.p->PeekPacketTag (rlcTag), "RlcTag is missing");
  rxPduParams.p->RemovePacketTag (rlcTag);
  delay = Simulator::Now() - rlcTag.GetSenderTimestamp ();
  m_rxPdu (m_rnti, m_lcid, rxPduParams.p->GetSize (), delay.GetNanoSeconds ());

  // 5.1.2.2 Receive operations

  // Get RLC header parameters
  LteRlcHeader rlcHeader;
  rxPduParams.p->PeekHeader (rlcHeader);
  NS_LOG_LOGIC ("RLC header: " << rlcHeader);
  SequenceNumber10 seqNumber = rlcHeader.GetSequenceNumber ();


     )
    {
      NS_LOG_LOGIC ("PDU discarded");
      rxPduParams.p = 0;
      return;
    }
  else
    {
      NS_LOG_LOGIC ("Place PDU in the reception buffer");
      m_rxBuffer[seqNumber.GetValue ()] = rxPduParams.p;
    }






  /**
   * MAC SAP
   *
   * \param txOpParams the LteMacSapUser::TxOpportunityParameters
   * \param layer the layer
   * \param harqId the HARQ ID
   * \param componentCarrierId component carrier ID
   * \param rnti the RNTI
   * \param lcid the LCID
   */
  virtual void DoNotifyTxOpportunity (LteMacSapUser::TxOpportunityParameters txOpParams);
  virtual void DoNotifyHarqDeliveryFailure ();
  virtual void DoReceivePdu (LteMacSapUser::ReceivePduParameters rxPduParams);

private:
  /// Expire reordering timer




  LteRlcSpecificLteMacSapUser (LteRlc* rlc);

  // Interface implemented from LteMacSapUser
  virtual void NotifyTxOpportunity (LteMacSapUser::TxOpportunityParameters params);
  virtual void NotifyHarqDeliveryFailure ();
  virtual void ReceivePdu (LteMacSapUser::ReceivePduParameters params);

private:
  LteRlcSpecificLteMacSapUser ();

}

void
LteRlcSpecificLteMacSapUser::NotifyTxOpportunity (TxOpportunityParameters params)
{
  m_rlc->DoNotifyTxOpportunity (params);
}

void

}

void
LteRlcSpecificLteMacSapUser::ReceivePdu (LteMacSapUser::ReceivePduParameters params)
{
  m_rlc->DoReceivePdu (params);
}



}

void
LteRlcSm::DoReceivePdu (LteMacSapUser::ReceivePduParameters rxPduParams)
{
  NS_LOG_FUNCTION (this << rxPduParams.p);
  // RLC Performance evaluation
  RlcTag rlcTag;
  Time delay;
  NS_ASSERT_MSG (rxPduParams.p->PeekPacketTag (rlcTag), "RlcTag is missing");
  rxPduParams.p->RemovePacketTag (rlcTag);
  delay = Simulator::Now() - rlcTag.GetSenderTimestamp ();
  NS_LOG_LOGIC (" RNTI=" << m_rnti 
                << " LCID=" << (uint32_t) m_lcid 
                << " size=" << rxPduParams.p->GetSize ()
                << " delay=" << delay.GetNanoSeconds ());
  m_rxPdu(m_rnti, m_lcid, rxPduParams.p->GetSize (), delay.GetNanoSeconds () );
}

void
LteRlcSm::DoNotifyTxOpportunity (LteMacSapUser::TxOpportunityParameters txOpParams)
{
  NS_LOG_FUNCTION (this << txOpParams.bytes);
  LteMacSapProvider::TransmitPduParameters params;
  params.pdu = Create<Packet> (txOpParams.bytes);
  params.rnti = m_rnti;
  params.lcid = m_lcid;
  params.layer = txOpParams.layer;
  params.harqProcessId = txOpParams.harqId;
  params.componentCarrierId = txOpParams.componentCarrierId;

  // RLC Performance evaluation
  RlcTag tag (Simulator::Now());
  params.pdu->AddPacketTag (tag);
  NS_LOG_LOGIC (" RNTI=" << m_rnti 
                << " LCID=" << (uint32_t) m_lcid 
                << " size=" << txOpParams.bytes);
  m_txPdu(m_rnti, m_lcid, txOpParams.bytes);

  m_macSapProvider->TransmitPdu (params);
  ReportBufferStatus ();




  /**
   * Notify transmit opportunity
   *
   * \param params LteMacSapUser::TxOpportunityParameters
   * \param layer the layer
   * \param harqId the HARQ ID
   * \param componentCarrierId component carrier ID
   * \param rnti the RNTI
   * \param lcid the LCID
   */ 
  virtual void DoNotifyTxOpportunity (LteMacSapUser::TxOpportunityParameters params) = 0;
  /**
   * Notify HARQ delivery failure
   */ 

  /**
   * Receive PDU function
   *
   * \param params the LteMacSapUser::ReceivePduParameters
   * \param rnti the RNTI
   * \param lcid the LCID
   */ 
  virtual void DoReceivePdu (LteMacSapUser::ReceivePduParameters params) = 0;

  LteMacSapUser* m_macSapUser; ///< MAC SAP user
  LteMacSapProvider* m_macSapProvider; ///< MAC SAP provider

  virtual void DoDispose ();

  virtual void DoTransmitPdcpPdu (Ptr<Packet> p);
  virtual void DoNotifyTxOpportunity (LteMacSapUser::TxOpportunityParameters txOpParams);
  virtual void DoNotifyHarqDeliveryFailure ();
  virtual void DoReceivePdu (LteMacSapUser::ReceivePduParameters rxPduParams);




(-)a/src/lte/model/lte-ue-mac.cc (-7 / +45 lines)

Lines 463-469 LteUeMac::RecvRaResponse (BuildRarListElement_s raResponse)	Link Here

463

464

          NS_FATAL_ERROR ("Function called on wrong componentCarrier");

464

          NS_FATAL_ERROR ("Function called on wrong componentCarrier");

465

466

      lc0InfoIt->second.macSapUser->NotifyTxOpportunity (raResponse.m_grant.m_tbSize, 0, 0, m_componentCarrierId, m_rnti, lc0Lcid);

466

      LteMacSapUser::TxOpportunityParameters txOpParams;

467

      txOpParams.bytes = raResponse.m_grant.m_tbSize;

468

      txOpParams.layer = 0;

469

      txOpParams.harqId = 0;

470

      txOpParams.componentCarrierId = m_componentCarrierId;

471

      txOpParams.rnti = m_rnti;

472

      txOpParams.lcid = lc0Lcid;

473

      lc0InfoIt->second.macSapUser->NotifyTxOpportunity (txOpParams);

467

      lc0BsrIt->second.txQueueSize = 0;

474

      lc0BsrIt->second.txQueueSize = 0;

468

475

469

476

Lines 589-595 LteUeMac::DoReceivePhyPdu (Ptr<Packet> p)	Link Here

589

      std::map <uint8_t, LcInfo>::const_iterator it = m_lcInfoMap.find (tag.GetLcid ());

596

      std::map <uint8_t, LcInfo>::const_iterator it = m_lcInfoMap.find (tag.GetLcid ());

590

      if (it != m_lcInfoMap.end ())

597

      if (it != m_lcInfoMap.end ())

591

598

592

          it->second.macSapUser->ReceivePdu (p, m_rnti, tag.GetLcid ());

599

          LteMacSapUser::ReceivePduParameters rxPduParams;

600

          rxPduParams.p = p;

601

          rxPduParams.rnti = m_rnti;

602

          rxPduParams.lcid = tag.GetLcid ();

603

          it->second.macSapUser->ReceivePdu (rxPduParams);

593

604

594

      else

605

      else

595

606

Lines 650-655 LteUeMac::DoReceiveLteControlMessage (Ptr<LteControlMessage> msg)	Link Here

650

661

651

662

652

          NS_LOG_LOGIC (this << " UE " << m_rnti << ": UL-CQI notified TxOpportunity of " << dci.m_tbSize << " => " << bytesPerActiveLc << " bytes per active LC" << " statusPduMinSize " << statusPduMinSize);

663

          NS_LOG_LOGIC (this << " UE " << m_rnti << ": UL-CQI notified TxOpportunity of " << dci.m_tbSize << " => " << bytesPerActiveLc << " bytes per active LC" << " statusPduMinSize " << statusPduMinSize);

664

665

          LteMacSapUser::TxOpportunityParameters txOpParams;

666

653

          for (it = m_lcInfoMap.begin (); it != m_lcInfoMap.end (); it++)

667

          for (it = m_lcInfoMap.begin (); it != m_lcInfoMap.end (); it++)

654

668

655

              itBsr = m_ulBsrReceived.find ((*it).first);

669

              itBsr = m_ulBsrReceived.find ((*it).first);

Lines 661-667 LteUeMac::DoReceiveLteControlMessage (Ptr<LteControlMessage> msg)	Link Here

661

675

662

                  if ((statusPduPriority) && ((*itBsr).second.statusPduSize == statusPduMinSize))

676

                  if ((statusPduPriority) && ((*itBsr).second.statusPduSize == statusPduMinSize))

663

677

664

                      (*it).second.macSapUser->NotifyTxOpportunity ((*itBsr).second.statusPduSize, 0, 0, m_componentCarrierId, m_rnti, (*it).first);

678

                      txOpParams.bytes = (*itBsr).second.statusPduSize;

679

                      txOpParams.layer = 0;

680

                      txOpParams.harqId = 0;

681

                      txOpParams.componentCarrierId = m_componentCarrierId;

682

                      txOpParams.rnti = m_rnti;

683

                      txOpParams.lcid = (*it).first;

684

                      (*it).second.macSapUser->NotifyTxOpportunity (txOpParams);

665

                      NS_LOG_LOGIC (this << "\t" << bytesPerActiveLc << " send  " << (*itBsr).second.statusPduSize << " status bytes to LC " << (uint32_t)(*it).first << " statusQueue " << (*itBsr).second.statusPduSize << " retxQueue" << (*itBsr).second.retxQueueSize << " txQueue" <<  (*itBsr).second.txQueueSize);

685

                      NS_LOG_LOGIC (this << "\t" << bytesPerActiveLc << " send  " << (*itBsr).second.statusPduSize << " status bytes to LC " << (uint32_t)(*it).first << " statusQueue " << (*itBsr).second.statusPduSize << " retxQueue" << (*itBsr).second.retxQueueSize << " txQueue" <<  (*itBsr).second.txQueueSize);

666

                      (*itBsr).second.statusPduSize = 0;

686

                      (*itBsr).second.statusPduSize = 0;

667

                      break;

687

                      break;

Lines 672-678 LteUeMac::DoReceiveLteControlMessage (Ptr<LteControlMessage> msg)	Link Here

672

                      NS_LOG_LOGIC (this << "\t" << bytesPerActiveLc << " bytes to LC " << (uint32_t)(*it).first << " statusQueue " << (*itBsr).second.statusPduSize << " retxQueue" << (*itBsr).second.retxQueueSize << " txQueue" <<  (*itBsr).second.txQueueSize);

692

                      NS_LOG_LOGIC (this << "\t" << bytesPerActiveLc << " bytes to LC " << (uint32_t)(*it).first << " statusQueue " << (*itBsr).second.statusPduSize << " retxQueue" << (*itBsr).second.retxQueueSize << " txQueue" <<  (*itBsr).second.txQueueSize);

673

                      if (((*itBsr).second.statusPduSize > 0) && (bytesForThisLc > (*itBsr).second.statusPduSize))

693

                      if (((*itBsr).second.statusPduSize > 0) && (bytesForThisLc > (*itBsr).second.statusPduSize))

674

694

675

                          (*it).second.macSapUser->NotifyTxOpportunity ((*itBsr).second.statusPduSize, 0, 0, m_componentCarrierId, m_rnti, (*it).first);

695

                          txOpParams.bytes = (*itBsr).second.statusPduSize;

696

                          txOpParams.layer = 0;

697

                          txOpParams.harqId = 0;

698

                          txOpParams.componentCarrierId = m_componentCarrierId;

699

                          txOpParams.rnti = m_rnti;

700

                          txOpParams.lcid = (*it).first;

701

                          (*it).second.macSapUser->NotifyTxOpportunity (txOpParams);

676

                          bytesForThisLc -= (*itBsr).second.statusPduSize;

702

                          bytesForThisLc -= (*itBsr).second.statusPduSize;

677

                          NS_LOG_DEBUG (this << " serve STATUS " << (*itBsr).second.statusPduSize);

703

                          NS_LOG_DEBUG (this << " serve STATUS " << (*itBsr).second.statusPduSize);

678

                          (*itBsr).second.statusPduSize = 0;

704

                          (*itBsr).second.statusPduSize = 0;

Lines 692-698 LteUeMac::DoReceiveLteControlMessage (Ptr<LteControlMessage> msg)	Link Here

692

                          if ((*itBsr).second.retxQueueSize > 0)

718

                          if ((*itBsr).second.retxQueueSize > 0)

693

719

694

                              NS_LOG_DEBUG (this << " serve retx DATA, bytes " << bytesForThisLc);

720

                              NS_LOG_DEBUG (this << " serve retx DATA, bytes " << bytesForThisLc);

695

                              (*it).second.macSapUser->NotifyTxOpportunity (bytesForThisLc, 0, 0, m_componentCarrierId, m_rnti, (*it).first);

721

                              txOpParams.bytes = bytesForThisLc;

722

                              txOpParams.layer = 0;

723

                              txOpParams.harqId = 0;

724

                              txOpParams.componentCarrierId = m_componentCarrierId;

725

                              txOpParams.rnti = m_rnti;

726

                              txOpParams.lcid = (*it).first;

727

                              (*it).second.macSapUser->NotifyTxOpportunity (txOpParams);

696

                              if ((*itBsr).second.retxQueueSize >= bytesForThisLc)

728

                              if ((*itBsr).second.retxQueueSize >= bytesForThisLc)

697

729

698

                                  (*itBsr).second.retxQueueSize -= bytesForThisLc;

730

                                  (*itBsr).second.retxQueueSize -= bytesForThisLc;

Lines 712-718 LteUeMac::DoReceiveLteControlMessage (Ptr<LteControlMessage> msg)	Link Here

712

                                  // overestimate RLC overhead rather than

744

                                  // overestimate RLC overhead rather than

713

                                  // underestimate it and risk unneeded

745

                                  // underestimate it and risk unneeded

714

                                  // segmentation which increases delay

746

                                  // segmentation which increases delay

715

                                  rlcOverhead = 4;

747

                                  rlcOverhead = 4;

716

748

717

                              else

749

                              else

718

750

Lines 720-726 LteUeMac::DoReceiveLteControlMessage (Ptr<LteControlMessage> msg)	Link Here

720

                                  rlcOverhead = 2;

752

                                  rlcOverhead = 2;

721

753

722

                              NS_LOG_DEBUG (this << " serve tx DATA, bytes " << bytesForThisLc << ", RLC overhead " << rlcOverhead);

754

                              NS_LOG_DEBUG (this << " serve tx DATA, bytes " << bytesForThisLc << ", RLC overhead " << rlcOverhead);

723

                              (*it).second.macSapUser->NotifyTxOpportunity (bytesForThisLc, 0, 0, m_componentCarrierId, m_rnti, (*it).first);

755

                              txOpParams.bytes = bytesForThisLc;

756

                              txOpParams.layer = 0;

757

                              txOpParams.harqId = 0;

758

                              txOpParams.componentCarrierId = m_componentCarrierId;

759

                              txOpParams.rnti = m_rnti;

760

                              txOpParams.lcid = (*it).first;

761

                              (*it).second.macSapUser->NotifyTxOpportunity (txOpParams);

724

                              if ((*itBsr).second.txQueueSize >= bytesForThisLc - rlcOverhead)

762

                              if ((*itBsr).second.txQueueSize >= bytesForThisLc - rlcOverhead)

725

763

726

                                  (*itBsr).second.txQueueSize -= bytesForThisLc - rlcOverhead;

764

                                  (*itBsr).second.txQueueSize -= bytesForThisLc - rlcOverhead;




}

void
NoOpComponentCarrierManager::DoNotifyTxOpportunity (LteMacSapUser::TxOpportunityParameters txOpParams)
{
  NS_LOG_FUNCTION (this);
  std::map <uint16_t, std::map<uint8_t, LteMacSapUser*> >::iterator rntiIt = m_ueAttached.find (txOpParams.rnti);
  NS_ASSERT_MSG (rntiIt != m_ueAttached.end (), "could not find RNTI" << txOpParams.rnti);
  std::map<uint8_t, LteMacSapUser*>::iterator lcidIt = rntiIt->second.find (txOpParams.lcid);
  NS_ASSERT_MSG (lcidIt != rntiIt->second.end (), "could not find LCID " << (uint16_t) txOpParams.lcid);
  NS_LOG_DEBUG (this << " rnti= " << txOpParams.rnti << " lcid= " << (uint32_t) txOpParams.lcid << " layer= " << (uint32_t)txOpParams.layer<<" ccId="<< (uint32_t)txOpParams.componentCarrierId);
  (*lcidIt).second->NotifyTxOpportunity (txOpParams);

}

void
NoOpComponentCarrierManager::DoReceivePdu (LteMacSapUser::ReceivePduParameters rxPduParams)
{
  NS_LOG_FUNCTION (this);
  std::map <uint16_t, std::map<uint8_t, LteMacSapUser*> >::iterator rntiIt = m_ueAttached.find (rxPduParams.rnti);
  NS_ASSERT_MSG (rntiIt != m_ueAttached.end (), "could not find RNTI" << rxPduParams.rnti);
  std::map<uint8_t, LteMacSapUser*>::iterator lcidIt = rntiIt->second.find (rxPduParams.lcid);
  if (lcidIt != rntiIt->second.end ())
    {
      (*lcidIt).second->ReceivePdu (rxPduParams);
    }
}





  virtual void DoReportBufferStatus (LteMacSapProvider::ReportBufferStatusParameters params);
  /**
   * \brief Notify transmit opportunity.
   *
   * \param txOpParams the LteMacSapUser::TxOpportunityParameters
   * \param harqId the HARQ ID
   * \param componentCarrierId the component carrier ID
   * \param rnti the RNTI
   * \param lcid the LCID
   */
  virtual void DoNotifyTxOpportunity (LteMacSapUser::TxOpportunityParameters txOpParams);
  /**
   * \brief Receive PDU.
   *
   * \param rxPduParams the LteMacSapUser::ReceivePduParameters
   * \param lcid the LCID
   */
  virtual void DoReceivePdu (LteMacSapUser::ReceivePduParameters rxPduParams);
  /// Notify HARQ delivery failure
  virtual void DoNotifyHarqDeliveryFailure ();
  /**




  SimpleUeCcmMacSapUser  (SimpleUeComponentCarrierManager* mac);

  // inherited from LteMacSapUser
  virtual void NotifyTxOpportunity (LteMacSapUser::TxOpportunityParameters txOpParams);
  virtual void ReceivePdu (LteMacSapUser::ReceivePduParameters rxPduParams);
  virtual void NotifyHarqDeliveryFailure ();



}

void
SimpleUeCcmMacSapUser::NotifyTxOpportunity (LteMacSapUser::TxOpportunityParameters txOpParams)
{
  NS_LOG_INFO ("SimpleUeCcmMacSapUser::NotifyTxOpportunity for ccId:"<<(uint32_t)txOpParams.componentCarrierId);
  m_mac->DoNotifyTxOpportunity (txOpParams);
}


void
SimpleUeCcmMacSapUser::ReceivePdu (LteMacSapUser::ReceivePduParameters rxPduParams)
{
  m_mac->DoReceivePdu (rxPduParams);
}

void

  NS_LOG_FUNCTION (this);
  NS_LOG_DEBUG ("BSR from RLC for LCID = " << (uint16_t)params.lcid);
  std::map <uint8_t, LteMacSapProvider*>::iterator it =  m_macSapProvidersMap.find (0);
  NS_ABORT_MSG_IF (it == m_macSapProvidersMap.end (), "could not find Sap for ComponentCarrier");

  NS_LOG_DEBUG ("Size of component carrier LC map "<< m_componentCarrierLcMap.size());




void 
SimpleUeComponentCarrierManager::DoNotifyTxOpportunity (LteMacSapUser::TxOpportunityParameters txOpParams)
{
  NS_LOG_FUNCTION (this);
  std::map<uint8_t, LteMacSapUser*>::iterator lcidIt = m_lcAttached.find (txOpParams.lcid);
  NS_ABORT_MSG_IF (lcidIt == m_lcAttached.end (), "could not find LCID" << (uint16_t) txOpParams.lcid);
  NS_LOG_DEBUG (this << " lcid = " << (uint32_t) txOpParams.lcid << " layer= "
                << (uint16_t) txOpParams.layer << " componentCarierId "
                << (uint16_t) txOpParams.componentCarrierId << " rnti " << txOpParams.rnti);

  NS_LOG_DEBUG (this << " MAC is asking component carrier id = " << (uint16_t) txOpParams.componentCarrierId
                << " with lcid = " << (uint32_t) txOpParams.lcid << " to transmit "<< txOpParams.bytes<< " bytes");
  (*lcidIt).second->NotifyTxOpportunity (txOpParams);
}
void
SimpleUeComponentCarrierManager::DoReceivePdu (LteMacSapUser::ReceivePduParameters rxPduParams)
{
  NS_LOG_FUNCTION (this);
  std::map<uint8_t, LteMacSapUser*>::iterator lcidIt = m_lcAttached.find (rxPduParams.lcid);
  NS_ABORT_MSG_IF (lcidIt == m_lcAttached.end (), "could not find LCID" << (uint16_t) rxPduParams.lcid);
  if (lcidIt != m_lcAttached.end ())
    {
      (*lcidIt).second->ReceivePdu (rxPduParams);
    }
}





  // forwarded from LteMacSapUser
  /**
   * \brief Notify TX opportunity function
   *
   * \param txOpParams the LteMacSapUser::TxOpportunityParameters
   * \param harqId the HARQ ID
   * \param componentCarrierId the component carrier ID
   * \param rnti the RNTI
   * \param lcid the LCID
   */
  void DoNotifyTxOpportunity (LteMacSapUser::TxOpportunityParameters txOpParams);
  /**
   * \brief Receive PDU function
   *
   * \param rxPduParams the LteMacSapUser::ReceivePduParameters
   * \param lcid the LCID
   */
  void DoReceivePdu (LteMacSapUser::ReceivePduParameters rxPduParams);
  //forwarded from LteUeCcmRrcSapProvider
  /**
   * \brief Add LC function

(-)a/src/lte/test/lte-test-entities.cc (-5 / +29 lines)

Lines 484-496 LteTestMac::SendTxOpportunity (Time time, uint32_t bytes)	Link Here

484

          haveContext = true;

484

          haveContext = true;

485

486

487

  LteMacSapUser::TxOpportunityParameters txOpParmas;

488

  txOpParmas.bytes = bytes;

489

  txOpParmas.layer = 0;

490

  txOpParmas.componentCarrierId = 0;

491

  txOpParmas.harqId = 0;

492

  txOpParmas.rnti = 0;

493

  txOpParmas.lcid = 0;

494

487

  if (haveContext)

495

  if (haveContext)

488

496

489

      Simulator::ScheduleWithContext (node->GetId (), time, &LteMacSapUser::NotifyTxOpportunity, m_macSapUser, bytes, 0, 0, 0, 0, 0);

497

      Simulator::ScheduleWithContext (node->GetId (), time, &LteMacSapUser::NotifyTxOpportunity, m_macSapUser, txOpParmas);

490

498

491

  else

499

  else

492

500

493

      Simulator::Schedule (time, &LteMacSapUser::NotifyTxOpportunity, m_macSapUser, bytes, 0, 0, 0, 0, 0);

501

      Simulator::Schedule (time, &LteMacSapUser::NotifyTxOpportunity, m_macSapUser, txOpParmas);

494

502

495

503

496

  if (m_txOpportunityMode == RANDOM_MODE)

504

  if (m_txOpportunityMode == RANDOM_MODE)

Lines 558-563 LteTestMac::DoTransmitPdu (LteMacSapProvider::TransmitPduParameters params)	Link Here

558

  m_txPdus++;

566

  m_txPdus++;

559

  m_txBytes += params.pdu->GetSize ();

567

  m_txBytes += params.pdu->GetSize ();

560

568

569

  LteMacSapUser::ReceivePduParameters rxPduParams;

570

  rxPduParams.p = params.pdu;

571

  rxPduParams.rnti = params.rnti;

572

  rxPduParams.lcid = params.lcid;

573

561

  if (m_device)

574

  if (m_device)

562

575

563

      m_device->Send (params.pdu, m_device->GetBroadcast (), 0);

576

      m_device->Send (params.pdu, m_device->GetBroadcast (), 0);

Lines 565-571 LteTestMac::DoTransmitPdu (LteMacSapProvider::TransmitPduParameters params)	Link Here

565

  else if (m_macLoopback)

578

  else if (m_macLoopback)

566

579

567

      Simulator::Schedule (Seconds (0.1), &LteMacSapUser::ReceivePdu,

580

      Simulator::Schedule (Seconds (0.1), &LteMacSapUser::ReceivePdu,

568

                           m_macLoopback->m_macSapUser, params.pdu, params.rnti, params.lcid);

581

                           m_macLoopback->m_macSapUser, rxPduParams);

569

582

570

  else

583

  else

571

584

Lines 622-632 LteTestMac::DoReportBufferStatus (LteMacSapProvider::ReportBufferStatusParameter	Link Here

622

635

623

      int32_t size = params.statusPduSize + params.txQueueSize  + params.retxQueueSize;

636

      int32_t size = params.statusPduSize + params.txQueueSize  + params.retxQueueSize;

624

      Time time = m_txOppTime;

637

      Time time = m_txOppTime;

638

      LteMacSapUser::TxOpportunityParameters txOpParmas;

639

      txOpParmas.bytes = m_txOppSize;

640

      txOpParmas.layer = 0;

641

      txOpParmas.componentCarrierId = 0;

642

      txOpParmas.harqId = 0;

643

      txOpParmas.rnti = params.rnti;

644

      txOpParmas.lcid = params.lcid;

625

      while (size > 0)

645

      while (size > 0)

626

646

627

          EventId e = Simulator::Schedule (time,

647

          EventId e = Simulator::Schedule (time,

628

                                           &LteMacSapUser::NotifyTxOpportunity,

648

                                           &LteMacSapUser::NotifyTxOpportunity,

629

                                           m_macSapUser, m_txOppSize, 0, 0, 0, params.rnti, params.lcid);

649

                                           m_macSapUser, txOpParmas);

630

          m_nextTxOppList.push_back (e);

650

          m_nextTxOppList.push_back (e);

631

          size -= m_txOppSize;

651

          size -= m_txOppSize;

632

          time += m_txOppTime;

652

          time += m_txOppTime;

Lines 644-650 LteTestMac::Receive (Ptr<NetDevice> nd, Ptr<const Packet> p, uint16_t protocol,	Link Here

644

  m_rxBytes += p->GetSize ();

664

  m_rxBytes += p->GetSize ();

645

665

646

  Ptr<Packet> packet = p->Copy ();

666

  Ptr<Packet> packet = p->Copy ();

647

  m_macSapUser->ReceivePdu (packet, 0, 0);

667

  LteMacSapUser::ReceivePduParameters rxPduParams;

668

  rxPduParams.p = packet;

669

  rxPduParams.rnti = 0;

670

  rxPduParams.lcid = 0;

671

  m_macSapUser->ReceivePdu (rxPduParams);

648

  return true;

672

  return true;

649

673

650

674

Return to bug 2995