How to Calculate Mean Opinion Score in ns3

The Mean Opinion Score (MOS) is a measure which is used to calculate the perceived quality of multimedia streams, specifically in voice and video communication. To calculate the MOS in ns3, we need to simulate the transmission of multimedia data, collect relevant Quality of Service (QoS) metrics that includes delay, jitter, and packet loss, and then mapping these metrics to MOS values that uses a suitable model. Here is a complete guide on calculating MOS in ns3.

Steps for calculating Mean Opinion Score

  1. simulate the network:
  • To simulate the network, Set up and run your network simulation in ns3 by ensuring you collect QoS metrics such as packet loss, delay, and jitter.
  1. QoS Metrics Collection :
  • During the simulation, collect metrics such as delay, jitter, and packet loss by using ns3 tracing mechanism.
  1. Use a Mapping Model:
  • To map the collected QoS metrics to MOS, use an appropriate model. The ITU-T G.107 E-model is commonly used for this purpose.

Example implementation

Create a basic example to implement this in ns3.

set up the simulation

Let’s set up a basic network simulation in ns3 and collect QoS metrics.

#include “ns3/core-module.h”

#include “ns3/network-module.h”

#include “ns3/internet-module.h”

#include “ns3/point-to-point-module.h”

#include “ns3/applications-module.h”

#include “ns3/flow-monitor-module.h”

using namespace ns3;

NS_LOG_COMPONENT_DEFINE(“MOSExample”);

int main(int argc, char *argv[]) {

// Set up the default simulation parameters

Time::SetResolution(Time::NS);

LogComponentEnable(“MOSExample”, LOG_LEVEL_INFO);

// Create nodes

NodeContainer nodes;

nodes.Create(2);

// Set up the point-to-point link

PointToPointHelper pointToPoint;

pointToPoint.SetDeviceAttribute(“DataRate”, StringValue(“5Mbps”));

pointToPoint.SetChannelAttribute(“Delay”, StringValue(“2ms”));

NetDeviceContainer devices;

devices = pointToPoint.Install(nodes);

// Install the Internet stack

InternetStackHelper stack;

stack.Install(nodes);

Ipv4AddressHelper address;

address.SetBase(“10.1.1.0”, “255.255.255.0”);

Ipv4InterfaceContainer interfaces = address.Assign(devices);

// Set up a UDP server

UdpEchoServerHelper echoServer(9);

ApplicationContainer serverApps = echoServer.Install(nodes.Get(1));

serverApps.Start(Seconds(1.0));

serverApps.Stop(Seconds(10.0));

// Set up a UDP client

UdpEchoClientHelper echoClient(interfaces.GetAddress(1), 9);

echoClient.SetAttribute(“MaxPackets”, UintegerValue(1));

echoClient.SetAttribute(“Interval”, TimeValue(Seconds(1.0)));

echoClient.SetAttribute(“PacketSize”, UintegerValue(1024));

ApplicationContainer clientApps = echoClient.Install(nodes.Get(0));

clientApps.Start(Seconds(2.0));

clientApps.Stop(Seconds(10.0));

// Set up FlowMonitor to collect QoS metrics

FlowMonitorHelper flowmon;

Ptr<FlowMonitor> monitor = flowmon.InstallAll();

Simulator::Stop(Seconds(10.0));

Simulator::Run();

// Extract QoS metrics

monitor->CheckForLostPackets();

Ptr<Ipv4FlowClassifier> classifier = DynamicCast<Ipv4FlowClassifier>(flowmon.GetClassifier());

std::map<FlowId, FlowMonitor::FlowStats> stats = monitor->GetFlowStats();

for (auto &flow : stats) {

Ipv4FlowClassifier::FiveTuple t = classifier->FindFlow(flow.first);

std::cout << “Flow ID: ” << flow.first << ” Src Addr: ” << t.sourceAddress << ” Dst Addr: ” << t.destinationAddress << std::endl;

std::cout << “Tx Packets = ” << flow.second.txPackets << std::endl;

std::cout << “Rx Packets = ” << flow.second.rxPackets << std::endl;

std::cout << “Lost Packets = ” << flow.second.lostPackets << std::endl;

std::cout << “Delay = ” << flow.second.delaySum.GetSeconds() / flow.second.rxPackets << “s” << std::endl;

}

Simulator::Destroy();

return 0;

}

Mapping QoS Metrics to MOS

After running the simulation and collect the QoS metrics, we can map these metrics to MOS by using an suitable model. Below is an example of a simple mapping using the E-model for VoIP:

#include <iostream>

#include <cmath>

// Function to calculate MOS using E-model

double calculateMOS(double packetLoss, double delay, double jitter) {

// Example coefficients for E-model

double R0 = 94.2; // Signal-to-Noise Ratio for typical speech

double Is = 1.07; // Simulated impairments factor

double Id = 0.024 * delay + 0.11 * (delay – 177.3) * (delay > 177.3);

double Ie = 25.1 * packetLoss + 29.0 * (packetLoss – 1) * (packetLoss > 1);

double MOS = 1 + 0.035 * (R0 – Is – Id – Ie) + 7 * 1e-6 * std::pow(R0 – Is – Id – Ie – 60, 3);

return MOS;

}

int main() {

// Example QoS metrics from ns-3 simulation

double packetLoss = 0.02; // 2% packet loss

double delay = 150; // 150 ms delay

double jitter = 30; // 30 ms jitter

double mos = calculateMOS(packetLoss, delay, jitter);

std::cout << “Mean Opinion Score (MOS): ” << mos << std::endl;

return 0;

}

Explanation

  1. Calculate MOS Function:

To map packet loss, delay, and jitter to a MOS value, this function implements a simplified E-model. Adjust the coefficients based on the specifics of your application and simulation results.

  1. Example QoS Metrics:

Replace these values  with the actual metrics collected from our ns3 simulation.

On the whole, we had a performance analysis on calculating Mean Opinion Score (MOS) in ns3 by simulating a network scenario, which collects relevant Quality of Service (QoS) metrics, and then use a model to map these metrics to MOS.