How to Simulate SDN NDN Projects Using OMNeT++

To simulate an aggregated SDN (Software-Defined Networking) and NDN (Named Data Networking) project using OMNeT++, which encompasses modeling a network in which SDN offers the centralized control over forwarding decisions, and NDN allows data-centric networking according to the content instead of hosts. This combination permits to test with the flexibility of SDN and the content-centric method of NDN that is helpful for use cases such as caching, content distribution, and efficient network resource utilization.

We will guide you through step-by-step procedure for simulating SDN and NDN projects using OMNeT++:

Steps to Simulate SDN NDN Projects in OMNeT++

  1. Install OMNeT++ and Required Frameworks
  • OMNeT++: We can download and install OMNeT++ from omnetpp.org.
  • INET Framework: Download and install the INET Framework from inet.omnetpp.org for simple networking and mobility models.
  • NDNSim (Optional): Even though designed for NS3, NDNsim delivers an execution of NDN principles. Some of the ideas from NDNsim can be adjusted to OMNeT++ for modeling NDN functionality.
  • OpenFlow (for SDN): OMNeT++ will want extensions to manage the OpenFlow communication among SDN controllers and switches.
  1. Understand SDN-NDN Components
  • SDN Controller: The centralized entity within SDN, which manages the network flow and forwarding behaviour.
  • NDN Router: Executes NDN functionality such as forwarding content requests according to the content names rather than IP addresses.
  • NDN Forwarding Engine: An NDN router component responsible for forwarding the Interest packets (requests) and Data packets depends on a content name.
  • OpenFlow Protocol: Utilized for SDN controller-switch communication to handle the flow rules.
  1. Set Up the SDN-NDN Network Topology in NED

Describe the network in the NED file with SDN switches, an SDN controller, NDN routers, and nodes are performing as data consumers and producers.

Example NED file for an SDN-NDN setup:

network SDN_NDN_Network

{

submodules:

controller: SDNController;

switch1: SDNSwitch;

switch2: SDNSwitch;

ndnRouter1: NDNRouter;

ndnRouter2: NDNRouter;

producerNode: NDNProducer;

consumerNode: NDNConsumer;

connections:

consumerNode.ethg++ <–> EthLink <–> ndnRouter1.ethg++;

ndnRouter1.ethg++ <–> EthLink <–> switch1.ethg++;

switch1.controllerPort++ <–> EthLink <–> controller.controlPort++;

switch1.ethg++ <–> EthLink <–> switch2.ethg++;

switch2.ethg++ <–> EthLink <–> ndnRouter2.ethg++;

ndnRouter2.ethg++ <–> EthLink <–> producerNode.ethg++;

}

  • SDNController: Handles forwarding rules within the SDN network.
  • NDNRouter: Executes the NDN forwarding strategy (content requests and delivery based on content names).
  • SDNSwitch: SDN switch, which forwards packets rely on the SDN controller’s rules.
  • NDNProducer/Consumer: Nodes which either generate content (producer) or request content (consumer).
  1. Configure SDN and NDN Settings in the INI File

The .ini file describes key metrics for the SDN and NDN simulation, containing packet types, flow rules, and the behaviour of NDN forwarding.

Example .ini file configuration:

[General]

network = SDN_NDN_Network

sim-time-limit = 500s

# SDN Controller settings

*.controller.numApps = 1

*.controller.app[0].typename = “OpenFlowControllerApp”

# NDN settings for routers

*.ndnRouter1.numApps = 1

*.ndnRouter1.app[0].typename = “NDNForwardingApp”

*.ndnRouter1.app[0].cacheSize = 100MB

*.ndnRouter2.numApps = 1

*.ndnRouter2.app[0].typename = “NDNForwardingApp”

*.ndnRouter2.app[0].cacheSize = 100MB

# NDN Consumer sends Interest packets

*.consumerNode.numApps = 1

*.consumerNode.app[0].typename = “NDNConsumerApp”

*.consumerNode.app[0].requestInterval = 1s

*.consumerNode.app[0].contentName = “/video/chunk1”

# NDN Producer generates Data packets

*.producerNode.numApps = 1

*.producerNode.app[0].typename = “NDNProducerApp”

*.producerNode.app[0].contentName = “/video/chunk1”

  • NDNForwardingApp: It denotes the NDN forwarding engine in routers.
  • cacheSize: Size of the cache in each NDN router.
  • NDNConsumerApp: Replicates a node that requests content using Interest packets.
  • NDNProducerApp: Mimics a node, which produces content in response to Interest packets.
  1. Implement SDN Forwarding Logic

The SDN controller wants to handle the forwarding rules for the switches. The rules can be set rely on the content names or flow-based traffic management.

Example pseudocode for an OpenFlow-based SDN controller:

void OpenFlowControllerApp::handlePacket(cMessage *msg) {

if (isInterestPacket(msg)) {

// Extract content name and source information

string contentName = extractContentName(msg);

string source = msg->getSenderAddress();

// Install flow rule to forward Interest packets

installFlowRule(source, contentName, nextHop);

}

}

void OpenFlowControllerApp::installFlowRule(string src, string contentName, string nextHop) {

// Create an OpenFlow rule to forward content requests

FlowRule rule;

rule.match.src = src;

rule.match.contentName = contentName;

rule.action = FORWARD;

rule.nextHop = nextHop;

sendFlowMod(rule);

}

  • handlePacket(): Manages incoming Interest packets and installs forwarding rules.
  • installFlowRule(): Installs flow rules to direct Interest packets in the direction of the next hop depends on the content names.
  1. Implement NDN Forwarding Logic

NDN routers forward packets according to the content names instead of IP addresses. They conserve PIT (Pending Interest Table) and CS (Content Store) to manage the requests and responses.

Example pseudocode for NDN router logic:

void NDNRouter::forwardInterest(cMessage *interest) {

string contentName = extractContentName(interest);

if (cache.contains(contentName)) {

// Respond with cached data

cMessage *data = cache.get(contentName);

send(data, “out”);

} else {

// Forward Interest to the next hop

send(interest, “out”);

}

}

void NDNRouter::handleData(cMessage *data) {

// Cache the received data

string contentName = extractContentName(data);

cache.insert(contentName, data);

// Send data to requesting node from PIT

string requester = pit.getRequester(contentName);

send(data, requester);

}

  • forwardInterest(): Forwards Interest packets and verifies for cached data.
  • handleData(): Manages incoming Data packets and caches them before forwarding to the requester.
  1. Run the Simulation
  • Build the project: We compile the project by choosing Project > Build All in OMNeT++.
  • Run the simulation: We can utilize Run Configurations in OMNeT++ to run the simulation. We can envision how the SDN controller handles forwarding rules and how the NDN routers manage the content requests and responses.
  1. Analyze Simulation Results

After running the simulation, the simulation environment OMNeT++ will be generated scalar and vector result files for analysis. Significant performance parameters in SDN-NDN scenarios contain:

  • Cache Hit Ratio: The percentage of content requests satisfied from the cache.
  • Flow Installation Delay: Time taken by the SDN controller to install forwarding rules.
  • Latency: The delay in receiving requested content from NDN producers.
  • Throughput: The data transmission rate in the network.

We can be used the Plove to visualize these parameters or export the outcomes for further analysis in MATLAB or Python.

  1. Advanced SDN-NDN Simulation Scenarios

We can expand the SDN-NDN simulation with advanced aspects such as:

  • Dynamic Caching: Replicate adaptive caching strategies within NDN routers, in which content is cached according to the demand.
  • QoS-Aware Forwarding: Execute QoS-aware forwarding rules in the SDN controller to prioritize particular kinds of content.
  • Multi-Controller SDN: Mimic a multi-controller SDN environment in which several SDN controllers handle distinct segments of the NDN network.
  • Fault-Tolerant SDN-NDN: Simulate fault-tolerant mechanisms in which SDN controllers or NDN routers retrieve from failures and continue forwarding content.

Example SDN-NDN Project Ideas:

  • Efficient Content Distribution with SDN-NDN: Understand how SDN can be enhanced content distribution within NDN by actively handling flow rules depends on content requests.
  • Caching Strategies in SDN-NDN Networks: Examine distinct caching strategies in NDN and examine how SDN can be handled cache locations effectively.
  • Multi-Controller SDN in NDN: Execute a multi-controller SDN architecture and investigate how numerous controllers manage the content-centric traffic in NDN.
  • Energy-Efficient SDN-NDN Networks: Focus on how SDN can be utilized to minimize energy consumption in NDN-based networks by handling the activation of network components dynamically.

These projects will enable you to gain a deeper understanding of SDN NDN projects, which was simulated and implemented using OMNeT++ tool. We will share another set of details on this subject as per your requests.

To explore SDN NDN projects through the OMNeT++ tool, phdprime.com offers expert guidance to ensure optimal results. For reliable research support, consider phdprime.com as your dependable partner.

Opening Time

9:00am

Lunch Time

12:30pm

Break Time

4:00pm

Closing Time

6:30pm

  • award1
  • award2