LteMacBase

Package: simu5g.stack.mac

LteMacBase

simple module

Base module for the Medium Access Control (MAC) layer of the LTE protocol stack.

This module provides common functionalities for MAC operations at both the eNodeB and User Equipment (UE) sides, such as functions to exchange MAC Service Data Units (SDUs) with the Radio Link Control (RLC) layer, and MAC Protocol Data Units (PDUs) with the physical layer.

Inheritance diagram

The following diagram shows inheritance relationships for this type. Unresolved types are missing from the diagram.

Known subclasses

Name Type Description
LteMacEnb simple module

This module extends the LteMacBase(1,2) module by providing specific MAC functions on the eNodeB side. Specifically, it initializes and manages the scheduling classes responsible for resource allocation operations in both uplink and downlink directions, while also supporting Carrier Aggregation (CA). It manages the Random Access procedure (RAC) and the reception of Buffer Status Reports (BSRs) from UEs, as well as the transmission of scheduling grants to UEs allocated within the uplink bandwidth. For downlink connections, it notifies the Radio Link Control (RLC) layer when it is ready to receive MAC Service Data Units (SDUs) to build MAC Protocol Data Units (PDUs) and transmit them to the physical layer.
LteMacUe simple module

This module extends the LteMacBase(1,2) module by providing specific MAC functions at the User Equipment (UE) side. For uplink connections, this module manages the initiation of the Random Access procedure (RAC) and the sending of Buffer Status Reports (BSRs) to the eNodeBs. Once it receives an uplink scheduling grant from the eNodeB, it is responsible for managing the local connections' scheduler and constructing MAC Protocol Data Units (PDUs) to be transmitted to the physical layer.

Parameters

Name Type Default value Description
binderModule string "binder"
packetFlowManagerModule string "^.packetFlowManager"

TODO or nrPacketFlowManager
queueSize int 2MiB
muMimo bool true
harqProcesses int 8
maxHarqRtx int 3
harqFbEvaluationTimer int 4

number of slots for sending back HARQ FB
statDisplay bool false

Properties

Name Value Description
display i=block/mac

Gates

Name Direction Size Description
RLC_to_MAC input

RLC to MAC
MAC_to_RLC output

MAC to RLC
PHY_to_MAC input

PHY to MAC
MAC_to_PHY output

MAC to PHY

Signals

Name Type Unit Description
macCellThroughputUl
macCellPacketLossUl
macDelayUl
harqErrorRateUl
macPacketLossUl
harqErrorRate_1st_Ul
macThroughputUl
harqTxAttemptsDl
macBufferOverFlowDl
harqErrorRate_3rd_Ul
macCellThroughputDl
macCellPacketLossDl
macThroughputDl
harqTxAttemptsUl
macPacketLossDl
harqErrorRate_1st_Dl
sentPacketToLowerLayer
receivedPacketFromUpperLayer
sentPacketToUpperLayer
harqErrorRate_2nd_Dl
harqErrorRate_4th_Dl
macBufferOverFlowD2D
macDelayDl
receivedPacketFromLowerLayer
macBufferOverFlowUl
harqErrorRateDl
harqErrorRate_3rd_Dl
harqErrorRate_2nd_Ul
harqErrorRate_4th_Ul

Statistics

Name Title Source Record Unit Interpolation Mode Description
macCellThroughputUl Cell Throughput at the MAC layer UL macCellThroughputUl mean Bps
macCellPacketLossUl Mac Cell Packet Loss Ul macCellPacketLossUl mean
macDelayUl Delay at the MAC layer UL macDelayUl mean, vector s
harqErrorRateUl Harq Error Rate Ul harqErrorRateUl mean, vector
macPacketLossUl Mac Packet Loss Ul macPacketLossUl mean
harqErrorRate_1st_Ul Harq Error Rate Ul (1st tx) harqErrorRate_1st_Ul mean, vector
macThroughputUl Throughput at the MAC layer UL macThroughputUl mean Bps
harqTxAttemptsDl Harq Tx Attempts Dl harqTxAttemptsDl mean, vector
macBufferOverFlowDl Mac buffer overflow as function of time macBufferOverFlowDl mean Byte/s
harqErrorRate_3rd_Ul Harq Error Rate Ul (3rd tx) harqErrorRate_3rd_Ul mean, vector
macCellThroughputDl Cell Throughput at the MAC layer DL macCellThroughputDl mean Bps
macCellPacketLossDl Mac Cell Packet Loss Dl macCellPacketLossDl mean
macThroughputDl Throughput at the MAC layer DL macThroughputDl mean Bps
harqTxAttemptsUl Harq Tx Attempts Ul harqTxAttemptsUl mean, vector
macPacketLossDl Mac Packet Loss Dl macPacketLossDl mean
harqErrorRate_1st_Dl Harq Error Rate Dl (1st tx) harqErrorRate_1st_Dl mean, vector
sentPacketToLowerLayer sentPacketToLowerLayer count, sum(packetBytes), vector(packetBytes) none
receivedPacketFromUpperLayer receivedPacketFromUpperLayer count, sum(packetBytes), vector(packetBytes) none
sentPacketToUpperLayer sentPacketToUpperLayer count, sum(packetBytes), vector(packetBytes) none
harqErrorRate_2nd_Dl Harq Error Rate Dl (2nd tx) harqErrorRate_2nd_Dl mean, vector
harqErrorRate_4th_Dl Harq Error Rate Dl (4th tx) harqErrorRate_4th_Dl mean, vector
macBufferOverFlowD2D Mac buffer overflow as function of time macBufferOverFlowD2D mean Byte/s
macDelayDl Delay at the MAC layer UL macDelayDl mean, vector s
receivedPacketFromLowerLayer receivedPacketFromLowerLayer count, sum(packetBytes), vector(packetBytes) none
macBufferOverFlowUl Mac buffer overflow as function of time macBufferOverFlowUl mean Byte/s
harqErrorRateDl Harq Error Rate Dl harqErrorRateDl mean, vector
harqErrorRate_3rd_Dl Harq Error Rate Dl (3rd tx) harqErrorRate_3rd_Dl mean, vector
harqErrorRate_2nd_Ul Harq Error Rate Ul (2nd tx) harqErrorRate_2nd_Ul mean, vector
harqErrorRate_4th_Ul Harq Error Rate Ul (4th tx) harqErrorRate_4th_Ul mean, vector

Source code

//
// Base module for the Medium Access Control (MAC) layer of the LTE protocol stack.
//
// This module provides common functionalities for MAC operations at both the
// eNodeB and User Equipment (UE) sides, such as functions to exchange MAC Service
// Data Units (SDUs) with the Radio Link Control (RLC) layer, and MAC Protocol Data
// Units (PDUs) with the physical layer.
//
simple LteMacBase like ILteMac
{
    parameters:
        @display("i=block/mac");
        string binderModule = default("binder");
        string packetFlowManagerModule = default("^.packetFlowManager"); // TODO or nrPacketFlowManager

        //# Mac Queues
        int queueSize @unit(B) = default(2MiB);              // MAC Buffers queue size

        //# Mac MIB
        bool muMimo = default(true);

        //# H-ARQ
        int harqProcesses = default(8);
        int maxHarqRtx = default(3);
        int harqFbEvaluationTimer = default(4);              // number of slots for sending back HARQ FB

        //# Statistics display (in GUI)
        bool statDisplay = default(false);

        //#
        //# Statistics recording
        //#
        @signal[macDelayDl];
        @statistic[macDelayDl](title="Delay at the MAC layer UL"; unit="s"; source="macDelayDl"; record=mean,vector);
        @signal[macThroughputDl];
        @statistic[macThroughputDl](title="Throughput at the MAC layer DL"; unit="Bps"; source="macThroughputDl"; record=mean);
        @signal[macDelayUl];
        @statistic[macDelayUl](title="Delay at the MAC layer UL"; unit="s"; source="macDelayUl"; record=mean,vector);
        @signal[macThroughputUl];
        @statistic[macThroughputUl](title="Throughput at the MAC layer UL"; unit="Bps"; source="macThroughputUl"; record=mean);
        @signal[macCellThroughputUl];
        @statistic[macCellThroughputUl](title="Cell Throughput at the MAC layer UL"; unit="Bps"; source="macCellThroughputUl"; record=mean);
        @signal[macCellThroughputDl];
        @statistic[macCellThroughputDl](title="Cell Throughput at the MAC layer DL"; unit="Bps"; source="macCellThroughputDl"; record=mean);
        @signal[macCellPacketLossDl];
        @statistic[macCellPacketLossDl](title="Mac Cell Packet Loss Dl"; unit=""; source="macCellPacketLossDl"; record=mean);
        @signal[macCellPacketLossUl];
        @statistic[macCellPacketLossUl](title="Mac Cell Packet Loss Ul"; unit=""; source="macCellPacketLossUl"; record=mean);
        @signal[macPacketLossUl];
        @statistic[macPacketLossUl](title="Mac Packet Loss Ul"; unit=""; source="macPacketLossUl"; record=mean);
        @signal[macPacketLossDl];
        @statistic[macPacketLossDl](title="Mac Packet Loss Dl"; unit=""; source="macPacketLossDl"; record=mean);
        @signal[macBufferOverFlowDl];
        @statistic[macBufferOverFlowDl](title="Mac buffer overflow as function of time"; unit="Byte/s"; source="macBufferOverFlowDl"; record=mean);
        @signal[macBufferOverFlowUl];
        @statistic[macBufferOverFlowUl](title="Mac buffer overflow as function of time"; unit="Byte/s"; source="macBufferOverFlowUl"; record=mean);
        @signal[macBufferOverFlowD2D];
        @statistic[macBufferOverFlowD2D](title="Mac buffer overflow as function of time"; unit="Byte/s"; source="macBufferOverFlowD2D"; record=mean);
        @signal[harqErrorRateUl];
        @statistic[harqErrorRateUl](title="Harq Error Rate Ul"; unit=""; source="harqErrorRateUl"; record=mean,vector);
        @signal[harqErrorRateDl];
        @statistic[harqErrorRateDl](title="Harq Error Rate Dl"; unit=""; source="harqErrorRateDl"; record=mean,vector);
        @signal[harqTxAttemptsDl];
        @statistic[harqTxAttemptsDl](title="Harq Tx Attempts Dl"; unit=""; source="harqTxAttemptsDl"; record=mean,vector);
        @signal[harqTxAttemptsUl];
        @statistic[harqTxAttemptsUl](title="Harq Tx Attempts Ul"; unit=""; source="harqTxAttemptsUl"; record=mean,vector);
        @signal[harqErrorRate_1st_Ul];
        @statistic[harqErrorRate_1st_Ul](title="Harq Error Rate Ul (1st tx)"; unit=""; source="harqErrorRate_1st_Ul"; record=mean,vector);
        @signal[harqErrorRate_1st_Dl];
        @statistic[harqErrorRate_1st_Dl](title="Harq Error Rate Dl (1st tx)"; unit=""; source="harqErrorRate_1st_Dl"; record=mean,vector);
        @signal[harqErrorRate_2nd_Ul];
        @statistic[harqErrorRate_2nd_Ul](title="Harq Error Rate Ul (2nd tx)"; unit=""; source="harqErrorRate_2nd_Ul"; record=mean,vector);
        @signal[harqErrorRate_2nd_Dl];
        @statistic[harqErrorRate_2nd_Dl](title="Harq Error Rate Dl (2nd tx)"; unit=""; source="harqErrorRate_2nd_Dl"; record=mean,vector);
        @signal[harqErrorRate_3rd_Ul];
        @statistic[harqErrorRate_3rd_Ul](title="Harq Error Rate Ul (3rd tx)"; unit=""; source="harqErrorRate_3rd_Ul"; record=mean,vector);
        @signal[harqErrorRate_3rd_Dl];
        @statistic[harqErrorRate_3rd_Dl](title="Harq Error Rate Dl (3rd tx)"; unit=""; source="harqErrorRate_3rd_Dl"; record=mean,vector);
        @signal[harqErrorRate_4th_Ul];
        @statistic[harqErrorRate_4th_Ul](title="Harq Error Rate Ul (4th tx)"; unit=""; source="harqErrorRate_4th_Ul"; record=mean,vector);
        @signal[harqErrorRate_4th_Dl];
        @statistic[harqErrorRate_4th_Dl](title="Harq Error Rate Dl (4th tx)"; unit=""; source="harqErrorRate_4th_Dl"; record=mean,vector);
        @signal[receivedPacketFromUpperLayer];
        @statistic[receivedPacketFromUpperLayer](source="receivedPacketFromUpperLayer"; record=count,"sum(packetBytes)","vector(packetBytes)"; interpolationmode=none);
        @signal[receivedPacketFromLowerLayer];
        @statistic[receivedPacketFromLowerLayer](source="receivedPacketFromLowerLayer"; record=count,"sum(packetBytes)","vector(packetBytes)"; interpolationmode=none);
        @signal[sentPacketToUpperLayer];
        @statistic[sentPacketToUpperLayer](source="sentPacketToUpperLayer"; record=count,"sum(packetBytes)","vector(packetBytes)"; interpolationmode=none);
        @signal[sentPacketToLowerLayer];
        @statistic[sentPacketToLowerLayer](source="sentPacketToLowerLayer"; record=count,"sum(packetBytes)","vector(packetBytes)"; interpolationmode=none);

    gates:
        //#
        //# Gates connecting RLC and MAC Layers
        //#

        input RLC_to_MAC;    // RLC to MAC
        output MAC_to_RLC;    // MAC to RLC

        //#
        //# Gates connecting MAC and PHY Layers
        //#

        input PHY_to_MAC;    // PHY to MAC
        output MAC_to_PHY;    // MAC to PHY
}
File: src/stack/mac/LteMacBase.ned

This documentation is released under the Creative Commons license