How to Implement SDN NDN in ns2

To implement Software-Defined Networking (SDN) with Named Data Networking (NDN) in ns2 has a difficult task for the reason is that ns2 basically cannot support these cutting-edge networking scenarios. However we can estimate particular contexts of SDN and NDN by customizing the features of nodes and traffic handling in ns2. SDN usually contains a centralized controller that handles the network flows, since NDN is a data-centric networking technique that where routing and forwarding are based on data names rather than IP addresses. The below is the brief procedure to implement the SDN-NDN in ns2:

Step-by-Step Implementation:

Step 1: Conceptualizing the SDN-NDN Simulation

In an SDN-NDN scenario:

  1. SDN Controller: A central node that controls the routing and forwarding of packets in the network.
  2. NDN Nodes: Nodes that request and forward data according to content names rather than IP addresses.
  3. Data-Centric Forwarding: Execute a simple data-centric forwarding mechanism in which the nodes make forwarding decisions based on the content’s name.

Step 2: Create the Tcl Script

The given is an example Tcl script that emulates a simplified SDN-NDN environment. This script is an abstraction and doesn’t fully execute all SDN and NDN characteristics but gives a simple idea of how to simulate these concepts in ns2.

Example Tcl Script for Simulating SDN-NDN in ns2

# Create a simulator object

set ns [new Simulator]

# Define the topography object

set topo [new Topography]

$topo load_flatgrid 1000 1000  # 1km x 1km area

# Create the General Operations Director (GOD) for wireless simulations

create-god 5  # Number of nodes (3 NDN nodes + 1 SDN controller + 1 data source)

# Configure the nodes

$ns node-config -llType LL \

-macType Mac/802_11 \

-ifqType Queue/DropTail/PriQueue \

-ifqLen 50 \

-antType Antenna/OmniAntenna \

-propType Propagation/TwoRayGround \

-phyType Phy/WirelessPhy \

-channelType Channel/WirelessChannel \

-topoInstance $topo \

-agentTrace ON \

-routerTrace ON \

-macTrace ON \

-movementTrace OFF

# Open trace and NAM files for recording the simulation

set tracefile [open sdn_ndn_out.tr w]

$ns trace-all $tracefile

set namfile [open sdn_ndn_out.nam w]

$ns namtrace-all-wireless $namfile 1000 1000

# Define a finish procedure to close files and end the simulation

proc finish {} {

global ns tracefile namfile

$ns flush-trace

close $tracefile

close $namfile

exec nam sdn_ndn_out.nam &

exit 0

}

# Create NDN nodes

set ndn_node1 [$ns node]

set ndn_node2 [$ns node]

set ndn_node3 [$ns node]

# Create SDN controller node

set sdn_controller [$ns node]

# Create a data source node (representing a content provider)

set data_source [$ns node]

# Set initial positions for nodes

$ndn_node1 set X_ 200.0

$ndn_node1 set Y_ 300.0

$ndn_node1 set Z_ 0.0

$ndn_node2 set X_ 400.0

$ndn_node2 set Y_ 500.0

$ndn_node2 set Z_ 0.0

$ndn_node3 set X_ 600.0

$ndn_node3 set Y_ 300.0

$ndn_node3 set Z_ 0.0

$sdn_controller set X_ 500.0

$sdn_controller set Y_ 800.0

$sdn_controller set Z_ 0.0

$data_source set X_ 800.0

$data_source set Y_ 500.0

$data_source set Z_ 0.0

# Define a custom procedure for NDN packet forwarding

proc ndn_forward {src dst data_name} {

global ns sdn_controller

# SDN controller decides the path based on the data name

set path [$sdn_controller route $data_name]

# Forward the packet along the determined path

foreach node $path {

$ns at [expr $ns now + 0.01] “$src send-packet $node $data_name”

set src $node

}

}

# Define a function for sending packets

proc send-packet {dst data_name} {

global ns

# Create a TCP agent at the sender

set tcp [new Agent/TCP]

$ns attach-agent $dst $tcp

# Create a TCP sink at the receiver

set sink [new Agent/TCPSink]

$ns attach-agent $dst $sink

# Connect the sender to the receiver

$ns connect $tcp $sink

# Create an FTP application to simulate data transmission

set ftp [new Application/FTP]

$ftp attach-agent $tcp

$ftp start

# Stop the FTP after some time (simulate transmission completion)

$ns at 15.0 “$ftp stop”

}

# Define how the SDN controller routes packets based on data names

proc sdn_route {data_name} {

if {$data_name == “content1”} {

return “ndn_node1 ndn_node2 data_source”

} elseif {$data_name == “content2”} {

return “ndn_node2 ndn_node3 data_source”

} else {

return “ndn_node3 ndn_node1 data_source”

}

}

# NDN node 1 requests content1

$ns at 2.0 “ndn_forward $ndn_node1 $data_source content1”

# NDN node 2 requests content2

$ns at 4.0 “ndn_forward $ndn_node2 $data_source content2”

# NDN node 3 requests content1

$ns at 6.0 “ndn_forward $ndn_node3 $data_source content1”

# Schedule the end of the simulation

$ns at 20.0 “finish”

# Run the simulation

$ns run

Step 3: Run the Tcl Script

Save the script with a .tcl extension, for instance, sdn_ndn_simulation.tcl. Then, execute the script using the following command in terminal:

ns sdn_ndn_simulation.tcl

Step 4: Visualize the Simulation

To visualize the simulation, open the generated NAM file using:

nam sdn_ndn_out.nam

Script Explanation

  • NDN Nodes: The nodes ndn_node1, ndn_node2, and ndn_node3 shows NDN-enabled devices that request data based on content names.
  • SDN Controller: The sdn_controller node signifies a centralized controller that handles the routing of data packets according to content names.
  • Data Source Node: The data_source node denotes a content provider that holds the requested data.
  • NDN Forwarding: The ndn_forward procedure emulated the content-based forwarding by having the SDN controller that decides the path according to the content name.
  • SDN Routing: The sdn_route procedure regulates the path based on the data name, that replicate an SDN controller’s role in handling the flow of data in the network.

Customization

  • Multiple Content Sources: Attach more data source nodes to emulate a network with multiple content providers.
  • Different Routing Strategies: Validate with various routing methods in the SDN controller based on data names, node availability, or network conditions.
  • Data Caching: Execute a simple data caching at intermediate nodes to mimic the NDN caching feature.
  • Error Models: Establish error models to emulate the packet loss, delays, or other network impairments.

Limitations

  • Simplified SDN and NDN Models: This script delivers a high-level approximation of SDN and NDN functionalities, without fully executing the complexities of these paradigms, like an OpenFlow in SDN or the full NDN protocol stack.
  • No Physical Layer Simulation: The script does not emulate the physical layer features specific to SDN or NDN, like link failures, varying link capacities, or channel conditions.
  • Limited NDN Features: In this script NDN execution is simple and doesn’t contain the characteristics such as in-network caching, interest aggregation, or multipath forwarding.

In the end, we provide the comprehensive procedure to complete the implementation process for Software-Defined Networking (SDN) with Named Data Networking (NDN) that can handle the network flows that were implemented in ns2 framework. Further details regarding the implementation of the SDN-NDN in different simulations will also be provided.

If you need help with implementation, hit us up at ns2project.com. We’re here to help you with network analysis for your SDN NDN project using ns2tool, and we’ll share the top results with you. Our team of experts is ready to provide you with the best outcomes on the SDN NDN platform.