LteRlcUm

simple module

This module implements the functionalities of the Unacknowledged Mode (UM) of the Radio Link Control (RLC) layer. Transmitting- and receiving-side functionalities are provided by the UmTxEntity and UmRxEntity submodules, respectively. The latter are created dynamically whenever a new connection is detected. This module is responsible for identifying the flow to which a RLC Service Data Unit (SDU) or Protocol Data Unit (PDU) belongs and routing it to the corresponding transmitting or receiving entity for further processing.

Inheritance diagram

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

Known subclasses

Name	Type	Description
LteRlcUmD2D	simple module	This module implements the functionalities of the Unacknowledged Mode (UM) of the Radio Link Control (RLC) layer for User Equipments supporting Device-to-Device (D2D) communications. It extends the basic RLC functionalities with specific management functions necessary when a connection is switched from infrastructure mode to D2D mode, and vice versa.

Parameters

Name	Type	Default value	Description
queueSize	int	2MiB
mapAllLcidsToSingleBearer	bool	false	if true, all LCIDs are mapped to a single bearer
nodeType	string

Properties

Name	Value	Description
class	LteRlcUm
display	i=block/wheelbarrow

Gates

Name	Direction	Size	Description
UM_Sap_up	inout
UM_Sap_down	inout		Gate to RLC Mux

Signals

Name	Type	Unit	Description
rlcPacketLossUl
rlcThroughputUl
sentPacketToLowerLayer
rlcCellThroughputUl
rlcPduDelayDl
rlcCellPacketLossUl
rlcDelayDl
receivedPacketFromUpperLayer
sentPacketToUpperLayer
rlcPduPacketLossUl
rlcPduThroughputUl
rlcThroughputDl
rlcPacketLossTotal
rlcCellThroughputDl
rlcCellPacketLossDl
receivedPacketFromLowerLayer
rlcPacketLossDl
rlcPduDelayUl
rlcDelayUl
rlcPduPacketLossDl
rlcPduThroughputDl

Statistics

Name	Title	Source	Record	Unit	Interpolation Mode
rlcPacketLossUl	rlc Packet Loss	rlcPacketLossUl	mean, sum, vector
rlcThroughputUl	Throughput at the rlc layer UL	rlcThroughputUl	mean, vector	Bps
sentPacketToLowerLayer		sentPacketToLowerLayer	count, sum(packetBytes), vector(packetBytes)		none
rlcCellThroughputUl	Cell Throughput at the rlc layer UL	rlcCellThroughputUl	mean	Bps
rlcPduDelayDl	Delay at the rlc layer UL	rlcPduDelayDl	mean, vector	s
rlcCellPacketLossUl	rlc Cell Packet Loss	rlcCellPacketLossUl	mean
rlcDelayDl	Delay at the rlc layer DL	rlcDelayDl	mean, vector	s
receivedPacketFromUpperLayer		receivedPacketFromUpperLayer	count, sum(packetBytes), vector(packetBytes)		none
sentPacketToUpperLayer		sentPacketToUpperLayer	count, sum(packetBytes), vector(packetBytes)		none
rlcPduPacketLossUl	rlc Packet Loss	rlcPduPacketLossUl	mean, vector
rlcPduThroughputUl	Throughput at the rlc layer UL	rlcPduThroughputUl	mean, vector	Bps
rlcThroughputDl	Throughput at the rlc layer DL	rlcThroughputDl	mean, vector	Bps
rlcPacketLossTotal	rlc Packet Loss	rlcPacketLossTotal	mean, vector
rlcCellThroughputDl	Cell Throughput at the rlc layer DL	rlcCellThroughputDl	mean	Bps
rlcCellPacketLossDl	rlc Cell Packet Loss	rlcCellPacketLossDl	mean
receivedPacketFromLowerLayer		receivedPacketFromLowerLayer	count, sum(packetBytes), vector(packetBytes)		none
rlcPacketLossDl	rlc Packet Loss	rlcPacketLossDl	mean, sum, vector
rlcPduDelayUl	Delay at the rlc layer UL	rlcPduDelayUl	mean, vector	s
rlcDelayUl	Delay at the rlc layer UL	rlcDelayUl	mean, vector	s
rlcPduPacketLossDl	rlc Packet Loss	rlcPduPacketLossDl	mean, vector
rlcPduThroughputDl	Throughput at the rlc layer DL	rlcPduThroughputDl	mean, vector	Bps

Source code

//
// This module implements the functionalities of the Unacknowledged Mode (UM) of the
// Radio Link Control (RLC) layer.
// Transmitting- and receiving-side functionalities are provided by the ~UmTxEntity and
// ~UmRxEntity submodules, respectively. The latter are created dynamically whenever
// a new connection is detected. This module is responsible for identifying the flow to which
// a RLC Service Data Unit (SDU) or Protocol Data Unit (PDU) belongs and routing it to
// the corresponding transmitting or receiving entity for further processing.
//
simple LteRlcUm like ILteRlcUm
{
    parameters:
        @class("LteRlcUm");

        @display("i=block/wheelbarrow");

        //# Rlc Queue
        int queueSize @unit(B) = default(2MiB);              // RLC TX entity SDU queue size (0: unlimited)
        bool mapAllLcidsToSingleBearer = default(false);     // if true, all LCIDs are mapped to a single bearer
        string nodeType @enum(INTERNET,ENODEB,GNODEB,UE);

        //# SDU-level statistics
        @signal[rlcDelayDl];
        @statistic[rlcDelayDl](title="Delay at the rlc layer DL"; unit="s"; source="rlcDelayDl"; record=mean,vector);
        @signal[rlcThroughputDl];
        @statistic[rlcThroughputDl](title="Throughput at the rlc layer DL"; unit="Bps"; source="rlcThroughputDl"; record=mean,vector);
        @signal[rlcDelayUl];
        @statistic[rlcDelayUl](title="Delay at the rlc layer UL"; unit="s"; source="rlcDelayUl"; record=mean,vector);
        @signal[rlcThroughputUl];
        @statistic[rlcThroughputUl](title="Throughput at the rlc layer UL"; unit="Bps"; source="rlcThroughputUl"; record=mean,vector);
        @signal[rlcPacketLossUl];
        @statistic[rlcPacketLossUl](title="rlc Packet Loss"; unit=""; source="rlcPacketLossUl"; record=mean,sum,vector);
        @signal[rlcPacketLossDl];
        @statistic[rlcPacketLossDl](title="rlc Packet Loss"; unit=""; source="rlcPacketLossDl"; record=mean,sum,vector);
        @signal[rlcPacketLossTotal];
        @statistic[rlcPacketLossTotal](title="rlc Packet Loss"; unit=""; source="rlcPacketLossTotal"; record=mean,vector);

        @signal[rlcCellThroughputUl];
        @statistic[rlcCellThroughputUl](title="Cell Throughput at the rlc layer UL"; unit="Bps"; source="rlcCellThroughputUl"; record=mean);
        @signal[rlcCellThroughputDl];
        @statistic[rlcCellThroughputDl](title="Cell Throughput at the rlc layer DL"; unit="Bps"; source="rlcCellThroughputDl"; record=mean);
        @signal[rlcCellPacketLossDl];
        @statistic[rlcCellPacketLossDl](title="rlc Cell Packet Loss"; unit=""; source="rlcCellPacketLossDl"; record=mean);
        @signal[rlcCellPacketLossUl];
        @statistic[rlcCellPacketLossUl](title="rlc Cell Packet Loss"; unit=""; source="rlcCellPacketLossUl"; record=mean);

        //# PDU-level statistics
        @signal[rlcPduDelayDl];
        @statistic[rlcPduDelayDl](title="Delay at the rlc layer UL"; unit="s"; source="rlcPduDelayDl"; record=mean,vector);
        @signal[rlcPduThroughputDl];
        @statistic[rlcPduThroughputDl](title="Throughput at the rlc layer DL"; unit="Bps"; source="rlcPduThroughputDl"; record=mean,vector);
        @signal[rlcPduDelayUl];
        @statistic[rlcPduDelayUl](title="Delay at the rlc layer UL"; unit="s"; source="rlcPduDelayUl"; record=mean,vector);
        @signal[rlcPduThroughputUl];
        @statistic[rlcPduThroughputUl](title="Throughput at the rlc layer UL"; unit="Bps"; source="rlcPduThroughputUl"; record=mean,vector);
        @signal[rlcPduPacketLossUl];
        @statistic[rlcPduPacketLossUl](title="rlc Packet Loss"; unit=""; source="rlcPduPacketLossUl"; record=mean,vector);
        @signal[rlcPduPacketLossDl];
        @statistic[rlcPduPacketLossDl](title="rlc Packet Loss"; unit=""; source="rlcPduPacketLossDl"; 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 UM
        //#
        inout UM_Sap_up;    // Gate to PDCP
        inout UM_Sap_down;    // Gate to RLC Mux
}

File: src/stack/rlc/um/LteRlcUm.ned