How to Implement Network on Chip NoC Topology in OMNeT++

To implement a Network on Chip (NoC) topology in OMNeT++ has encompasses to generate the network that emulates the interconnection of different processing elements   (PEs) on a chip and the usually using a mesh, torus, or custom topology. NoC is used to enable communication among diverse cores in a multi-core processor.

Connect with our developers to discover the best simulation and project ideas for Network on Chip (NoC) Topology using the OMNeT++ program.

The given below are the procedures on how to implement the NoC in OMNeT++ tool:

Step-by-Step Implementation:

1. Set up OMNeT++ and INET Framework

• Make sure that OMNeT++ and the INET framework are installed and correctly configured. Furthermore we consider using the Noxim simulator, which is particularly planned for NoC simulations. However, if you prefer to use OMNeT++, we need to generate custom modules or adjust existing ones to emulate NoC.

2. Define the NoC Topology in a NED File

• Generate a .ned file to describe the network topology. NoC commonly uses a 2D mesh or torus topology, where each node denotes a processing element (PE) and routers are used to connect the nodes.

Example: A 4×4 Mesh Topology

package nocTopologyExample;

import inet.node.inet.StandardHost;

network NoCTopology

{

parameters:

int gridSize = default(4);  // Define the grid size (e.g., 4×4 mesh)

submodules:

node[gridSize][gridSize]: StandardHost {

parameters:

@display(“p=100+100*j,100+100*i”);

}

connections allowunconnected:

// Horizontal connections

for i=0..gridSize-1 {

for j=0..gridSize-2 {

node[i][j].ethg++ <–> EtherChannel <–> node[i][j+1].ethg++;

}

}

// Vertical connections

for i=0..gridSize-2 {

for j=0..gridSize-1 {

node[i][j].ethg++ <–> EtherChannel <–> node[i+1][j].ethg++;

}

}

}

• Grid Size: Adjust the gridSize parameter to generate various sizes of the mesh (e.g., 3×3, 4×4).
• Nodes: Each node signifies a processing element (PE) in the NoC.
• Connections: Nodes are connected horizontally and vertically, forming a 2D mesh.

3. Configure the Nodes in OMNeT++ INI File

• In the omnetpp.ini file, configure the properties of the nodes, like communication parameters and applications that emulate the workload.

Example:

network = nocTopologyExample.NoCTopology

# Configure IP addresses

*.node[*][*].ipv4.arp.typename = “GlobalArp”

*.node[*][*].eth[0].ipv4.address = “10.0.x.y”

*.node[*][*].eth[0].ipv4.netmask = “255.255.255.0”

# Example application setup: node[0][0] sends data to node[3][3]

*.node[0][0].numApps = 1

*.node[0][0].app[0].typename = “UdpBasicApp”

*.node[0][0].app[0].destAddresses = “10.0.0.15”  # IP address of node[3][3]

*.node[0][0].app[0].destPort = 5000

*.node[0][0].app[0].messageLength = 64B

*.node[0][0].app[0].sendInterval = 1ms

*.node[3][3].numApps = 1

*.node[3][3].app[0].typename = “UdpSink”

*.node[3][3].app[0].localPort = 5000

• IP Addressing: Assign IP addresses to each node in the grid.
• Applications: Configure applications on the nodes to emulate traffic, like sending data among PEs.

4. Implement Routing Logic

• Custom Routing Module: Since NoC often needs particular routing techniques like XY routing, adaptive routing, we need to execute a custom routing module. This module would manage the packet forwarding based on the NoC’s topology and routing technique.

Example: Basic XY Routing Logic

// Pseudo-code for XY routing

void XYRouting(Packet* pkt) {

int srcX = pkt->getSrcX();

int srcY = pkt->getSrcY();

int destX = pkt->getDestX();

int destY = pkt->getDestY();

if (srcX != destX) {

// Route horizontally

if (srcX < destX)

send(pkt, “east$o”);

else

send(pkt, “west$o”);

} else if (srcY != destY) {

// Route vertically

if (srcY < destY)

send(pkt, “north$o”);

else

send(pkt, “south$o”);

} else {

// Deliver packet to local node

send(pkt, “local$o”);

}

}

• This example shows the simple idea behind XY routing, where packets are routed horizontally first, then vertically.

5. Run the Simulation

• After setting up the network topology and configuration compile and run the simulation in OMNeT++. Monitor how data flows among the nodes and how the routing techniques manages the traffic.

6. Analyze the Results

• Use OMNeT++’s built-in tools to visualize and measure the network traffic. Investigate how information is routed in the NoC, how routing impacts the performance, and how network latency and throughput vary with diverse workloads.

7. Enhancements and Variations

• Routing Algorithms: To execute and validate different routing techniques like adaptive routing, to compare their performance in NoC.
• Traffic Patterns: Simulate diverse traffic patterns such as uniform, hotspot to study their effects on network performance.
• Fault Tolerance: Introduce node or link failures to see how the NoC adapts and reroutes traffic.

Example Files

1. NoCTopology.ned: Describes the NoC topology.
2. omnetpp.ini: Contains configuration settings for the simulation.
3. XYRoutingModule.cpp: Custom routing logic for NoC.

As we discussed earlier about how the Network on Chip will perform in OMNeT++ simulator and we help to provide further information about how the Network on Chip will adapt in different environments.