How to Simulate Mobile Computing Projects Using NS3

To simulate Mobile Computing projects using NS3 has needs to design the communication among mobile devices like smartphones, laptops, or IoT devices that depend on wireless communication, mobility, and distributed computing resources. The scope of mobile computing has contain a wide range of applications such as mobile cloud computing, edge computing, vehicular computing, and more. NS3 permits for simulating wireless communication technologies (Wi-Fi, LTE, and 5G), mobility models, and network protocols that can be prolonged for numerous mobile computing scenarios.

Here’s a step-by-step guide on how to simulate Mobile Computing projects using NS3:

Step-by-Step Implementation

Step 1: Install NS3

Ensure NS3 is installed on the system. Follow these steps if you don’t already have it installed:

1. Clone the NS3 Repository:

git clone https://gitlab.com/nsnam/ns-3-dev.git

cd ns-3-dev

1. Configure and Build NS3:

./waf configure

./waf

Step 2: Key Components of a Mobile Computing Simulation

In a mobile computing scenario, the following components are often involved:

1. Mobile Devices (Clients): These are mobile nodes such as smartphones, laptops, or vehicles that request services or distribute resources.
2. Access Points or Base Stations: These are devices such as Wi-Fi Access Points or LTE/5G base stations that deliver connectivity for mobile devices.
3. Cloud or Edge Servers: These are remote servers that mobile devices offload computation to, or edge servers closer to the mobile nodes.
4. Mobility Models: Designs to mimic how the mobile devices move in space, that impacts connectivity.

Step 3: Set Up Mobile Devices and Servers

1. Create Mobile Devices and Servers: Utilize NodeContainer to generate mobile devices and servers such as edge servers or cloud nodes.

NodeContainer mobileDevices, edgeServers;

mobileDevices.Create(3);  // 3 mobile devices

edgeServers.Create(1);  // 1 edge server

Step 4: Select Wireless Communication Technology

For mobile computing, communication technologies such as Wi-Fi, LTE, or 5G are usually used. we can select one depending on the scenario you wish to simulate.

1. Wi-Fi (for local connectivity):

Utilize the Wi-Fi module to emulate local communication among mobile devices and edge servers.

WifiHelper wifi;

wifi.SetStandard(WIFI_PHY_STANDARD_80211n);

YansWifiPhyHelper wifiPhy = YansWifiPhyHelper::Default();

YansWifiChannelHelper wifiChannel = YansWifiChannelHelper::Default();

wifiPhy.SetChannel(wifiChannel.Create());

WifiMacHelper wifiMac;

wifiMac.SetType(“ns3::AdhocWifiMac”);

NetDeviceContainer wifiDevices;

wifiDevices = wifi.Install(wifiPhy, wifiMac, mobileDevices);

wifi.Install(wifiPhy, wifiMac, edgeServers);

2. LTE or 5G (for cellular communication):

For long-range communication, LTE or 5G modules can be used. LTE is directly supported in NS3, and the 5G mmWave module can be added separately.

Ptr<LteHelper> lteHelper = CreateObject<LteHelper>();

Ptr<PointToPointEpcHelper> epcHelper = CreateObject<PointToPointEpcHelper>();

lteHelper->SetEpcHelper(epcHelper);

NodeContainer enbNodes;

enbNodes.Create(1);  // 1 LTE eNodeB

NetDeviceContainer enbDevs = lteHelper->InstallEnbDevice(enbNodes);

NetDeviceContainer ueDevs = lteHelper->InstallUeDevice(mobileDevices);

// Assign IP addresses

Ipv4AddressHelper ipv4;

ipv4.SetBase(“7.0.0.0”, “255.255.255.0”);

Ipv4InterfaceContainer ueIpIface = epcHelper->AssignUeIpv4Address(NetDeviceContainer(ueDevs));

Step 5: Set Up Mobility Models for Mobile Devices

Mobile computing has includes devices moving in space, so mobility models are critical. Use MobilityHelper to setting up the movement of the mobile devices.

1. Configure Mobility for Mobile Devices: Utilize mobility models such as RandomWalk2dMobilityModel or ConstantVelocityMobilityModel to replicate mobile device movement.

MobilityHelper mobility;

mobility.SetMobilityModel(“ns3::RandomWalk2dMobilityModel”,

“Bounds”, RectangleValue(Rectangle(0, 100, 0, 100)));

mobility.Install(mobileDevices);

mobility.SetMobilityModel(“ns3::ConstantPositionMobilityModel”);

mobility.Install(edgeServers);  // Edge servers are stationary

1. Configure Device Movement (Optional): For more controlled movement, utilize WaypointMobilityModel or ConstantVelocityMobilityModel for mobile nodes such as vehicles or pedestrians.

mobility.SetMobilityModel(“ns3::ConstantVelocityMobilityModel”);

Ptr<ConstantVelocityMobilityModel> mob = mobileDevices.Get(0)->GetObject<ConstantVelocityMobilityModel>();

mob->SetVelocity(Vector(20.0, 0.0, 0.0));  // Set a constant velocity of 20 m/s

Step 6: Set Up Mobile Computing Applications

Mobile devices usually offload tasks such as computation or storage to edge servers or the cloud. Replicate this using TCP or UDP applications for data transmission.

1. Install Data Transmission Applications: Utilize UDP Echo or TCP applications to emulate offloading tasks from mobile devices to the server.

// Server on Edge Server (or Cloud)

UdpEchoServerHelper echoServer(9);  // Port 9 for UDP communication

ApplicationContainer serverApps = echoServer.Install(edgeServers.Get(0));

serverApps.Start(Seconds(1.0));

serverApps.Stop(Seconds(20.0));

// Client on Mobile Device

UdpEchoClientHelper echoClient(edgeServers.Get(0)->GetObject<Ipv4>()->GetAddress(1, 0), 9);

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

echoClient.SetAttribute(“Interval”, TimeValue(Seconds(0.5)));  // One packet every 500 ms

echoClient.SetAttribute(“PacketSize”, UintegerValue(1024));  // 1 KB packet size

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

clientApps.Start(Seconds(2.0));

clientApps.Stop(Seconds(20.0));

Step 7: Enable Tracing and Run the Simulation

1. Enable Tracing: Allow tracing to measure packet transmission and communication among the mobile devices and the edge server.

wifiPhy.EnablePcap(“mobile-computing-simulation”, wifiDevices.Get(0));

1. Run the Simulation: Execute the simulation for certain duration.

Simulator::Stop(Seconds(20.0));  // Run the simulation for 20 seconds

Simulator::Run();

Simulator::Destroy();

Step 8: Analyse the Results

Once the simulation done, we can measure the following metrics:

• Throughput: Assess the data transfer rate among mobile devices and the edge server.
• Latency: Estimate the delay in sending and receiving packets, crucial for real-time mobile applications.
• Packet Loss: Measure the reliability of the network by estimating lost packets.
• Energy Consumption: For battery-operated mobile devices, energy consumption is an important factor.

Step 9: Extend the Simulation

We can prolong the simple simulation by adding more complex features:

1. Mobile Cloud Computing: Add a cloud server in addition to the edge server to replicate mobile devices offloading tasks to both edge and cloud. Utilize approaches to decide either to offload to the cloud or the edge according to network conditions.

NodeContainer cloudServers;

cloudServers.Create(1);

// Similar to edge server setup

1. Edge Computing with Task Scheduling: Execute task scheduling mechanisms in which mobile devices offload tasks to the nearest or least-loaded edge server. This is useful for mimic the multi-edge environments.
2. Handover in LTE/5G: Replicate handover among LTE/5G base stations when mobile devices move among different network coverage areas.
3. Energy Efficiency: Execute an energy model for mobile devices to monitor battery usage in the course of computation and communication.

BasicEnergySourceHelper energySourceHelper;

energySourceHelper.Set(“BasicEnergySourceInitialEnergyJ”, DoubleValue(10000));

EnergySourceContainer energySources = energySourceHelper.Install(mobileDevices);

1. Security Mechanisms: Replicate secure communication among mobile devices and edge/cloud servers, integrating encryption and authentication protocols.

We had demonstrated how to setup the simulation and how to implement the Mobile Computing in the network using the ns3 tool. We will deliver more information about the Mobile Computing performance in other scenario.