The Georgia Tech Network Simulator (GTNetS) ECE6110 August 25, 2008

1. The Georgia Tech Network Simulator(GTNetS)ECE6110August 25, 2008 George F. Riley

2. Overview • Network Simulation Basics • GTNetS Design Philosophy • GTNetS Details • BGP++ • Scalability Results • FAQ • Future Plans • Demos

3. Network Simulation Basics - 1 • Discrete Event Simulation • Events model packet transmission, receipt, timers, etc. • Future events maintained in sorted Event List • Processing events results in zero or more new events • Packet transmit event generates a future packet receipt event at next hop

4. Network Simulation Basics - 2 • Create Topology • Nodes, Links, Queues, Routing, etc. • Create Data Demand on Network • Web Browsers, FTP transfers, Peer-to-Peer Searching and Downloads, On--Off Data Sources, etc. • Run the Simulation • Analyze Results

5. TCP Server 1 TCP Client 1 100 Mbps, 5ms 100 Mbps, 5ms 10 Mbps, 20ms 100 Mbps, 5ms 100 Mbps, 5ms TCP Server 2 TCP Client 2 Network Simulation Basics - 3

6. GTNetS Designed Like Real Networks • Nodes have one or more Interfaces • Interfaces have IP Address and Mask • Interfaces have an associated Link object • Packets append and remove PDU’s • Clear distinction between protocol stack layers • Packet received at an Interface • Forwards to Layer 2 protocol object for processing • Forwards to Layer 3 based on protocol number (800 is IPV4) • Forwards to Layer 4 based on protocol number (6 is TCP) • Forwards to application based on port number

7. GTNetS Design Philosophy • Written Completely in C++ • Released as Open Source • All network modeling via C++ objects • User Simulation is a C++ main program • Include our supplied “#include” files • Link with our supplied libraries • Run the resulting executable

8. Interface Interface Node Queue Queue Link Link L2 Protocol L2 Protocol Routing Info Port Map Location GTNetS Details - Node

9. GTNetS Details - Packet Header Header Header Header Packet Unique ID Size Timestamp

10. GTNetS Applications • Web Browser (based on Mah’1997) • Web Server - including Gnutella GCache • On-Off Data Source • FTP File Transfer • Bulk Data Sending/Receiving • Gnutella Peer-to-Peer • Syn Flood • UDP Storm • Internet Worms • VOIP

11. GTNetS Protocols • TCP, complete client/server • Tahoe, Reno, New-Reno • Sack (in progress) • Congestion Window, Slow Start, Receiver Window • UDP • IPV4 (IPV6 Planned) • IEEE 802.3 (Ethernet and point-to-point) • IEEE 802.11 (Wireless) • Address Resolution Protocol (ARP) • ICMP (Partial)

12. GTNetS Routing • Static (pre-computed routes) • Nix-Vector (on-demand) • Manual (specified by simulation application) • EIGRP • BGP • OSPF • DSR • AODV

13. GTNetS Support Objects • Random Number Generation • Uniform, Exponential, Pareto, Sequential, Emiprical, Constant • Statistics Collection • Histogram, Average/Min/Max • Command Line Argument Processing • Rate, Time, and IP Address Parsing • Rate(“10Mb”), Time(“10ms”) • IPAddr(“192.168.0.1”)

14. GTNetS Distributed Simulation • Split topology model into several parts • Each part runs on separate workstation or separate CPU in SMP • Each simulator has complete topology picture • “Real” nodes and “Ghost” nodes • Time management and message exchange via Georgia Tech “Federated Developers Kit”. • Allows larger topologies that single simulation • May run faster

15. TCP Server 1 TCP Client 1 TCP Client 2 TCP Server 2 Example // Create the TCP Servers TCPServer* server1 = new TCPServer(TCPTahoe()); TCPServer* server2 = new TCPServer(TCPTahoe()); server1->BindAndListen(s1, 80); server2->BindAndListen(s2, 80); server1->SetTrace(Trace::ENABLED); server2->SetTrace(Trace::ENABLED); // Create the TCP Sending Applications TCPSend* client1 = new TCPSend(TCPTahoe(c1), s1->GetIPAddr(), 80, Uniform(1000,10000)); TCPSend* client2 = new TCPSend(TCPTahoe(c2), s2->GetIPAddr(), 80, Constant(100000)); // Enable TCP trace for all clients client1->SetTrace(Trace::ENABLED); client2->SetTrace(Trace::ENABLED); // Set random starting times for the applications Uniform startRv(0.0, 2.0); client1->Start(startRv.Value()); client2->Start(startRv.Value()); s.Progress(1.0); // Request progress messages s.StopAt(10.0); // Stop the simulation at time 10.0 s.Run(); // Run the simulation std::cout << "Simulation Complete" << std::endl; } // Simple GTNetS example // George F. Riley, Georgia Tech, Winter 2002 #include "simulator.h" #include "node.h" #include "linkp2p.h #include "ratetimeparse.h" #include "application-tcpserver.h" #include "application-tcpsend.h" #include "tcp-tahoe.h" int main() { // Create the simulator object Simulator s; // Create a link object template, //100Mb bandwidth, 5ms delay Linkp2p l(Rate("100Mb"), Time("5ms")); // Add the links to client and server leaf nodes c1->AddDuplexLink(r1, l, IPAddr("192.168.0.1")); c2->AddDuplexLink(r1, l, IPAddr("192.168.0.2")); s1->AddDuplexLink(r2, l, IPAddr("192.168.1.1")); s2->AddDuplexLink(r2, l, IPAddr("192.168.1.2")); // Create a link object template, //10Mb bandwidth, 100ms delay Linkp2p r(Rate("10Mb"), Time("100ms")); // Add the router to router link r1->AddDuplexLink(r2, r); // Create and enable IP packet tracing Trace* tr = Trace::Instance(); tr->IPDotted(true); tr->Open("intro1.txt"); TCP::LogFlagsText(true); IPV4::Instance()->SetTrace(Trace::ENABLED); // Create the nodes Node* c1 = new Node(); // Client node 1 Node* c2 = new Node(); // Client node 2 Node* r1 = new Node(); // Router node 1 Node* r2 = new Node(); // Router node 2 Node* s1 = new Node(); // Server node 1 Node* s2 = new Node(); // Server node 2 // Simple GTNetS example // George F. Riley, Georgia Tech, Winter 2002 #include "simulator.h" // Definitions for the Simulator Object #include "node.h" // Definitions for the Node Object #include "linkp2p.h" // Definitions for point-to-point link objects #include "ratetimeparse.h" // Definitions for Rate and Time objects #include "application-tcpserver.h" // Definitions for TCPServer application #include "application-tcpsend.h" // Definitions for TCP Sending app #include "tcp-tahoe.h" // Definitions for TCP Tahoe int main() { // Create the simulator object Simulator s; // Create and enable IP packet tracing Trace* tr = Trace::Instance(); // Get a pointer to global trace object tr->IPDotted(true); // Trace IP addresses in dotted notation tr->Open("intro1.txt"); // Create the trace file TCP::LogFlagsText(true); // Log TCP flags in text mode IPV4::Instance()->SetTrace(Trace::ENABLED);// Enable IP tracing all nodes // Create the nodes Node* c1 = new Node(); // Client node 1 Node* c2 = new Node(); // Client node 2 Node* r1 = new Node(); // Router node 1 Node* r2 = new Node(); // Router node 2 Node* s1 = new Node(); // Server node 1 Node* s2 = new Node(); // Server node 2 // Create a link object template, 100Mb bandwidth, 5ms delay Linkp2p l(Rate("100Mb"), Time("5ms")); // Add the links to client and server leaf nodes c1->AddDuplexLink(r1, l, IPAddr("192.168.0.1")); // c1 to r1 c2->AddDuplexLink(r1, l, IPAddr("192.168.0.2")); // c2 to r1 s1->AddDuplexLink(r2, l, IPAddr("192.168.1.1")); // s1 to r2 s2->AddDuplexLink(r2, l, IPAddr("192.168.1.2")); // s2 to r2 // Create a link object template, 10Mb bandwidth, 100ms delay Linkp2p r(Rate("10Mb"), Time("100ms")); // Add the router to router link r1->AddDuplexLink(r2, r); // Create the TCP Servers TCPServer* server1 = new TCPServer(TCPTahoe()); TCPServer* server2 = new TCPServer(TCPTahoe()); server1->BindAndListen(s1, 80); // Application on s1, port 80 server2->BindAndListen(s2, 80); // Application on s2, port 80 server1->SetTrace(Trace::ENABLED); // Trace TCP actions at server1 server2->SetTrace(Trace::ENABLED); // Trace TCP actions at server2 // Create the TCP Sending Applications TCPSend* client1 = new TCPSend(TCPTahoe(c1), s1->GetIPAddr(), 80, Uniform(1000,10000)); TCPSend* client2 = new TCPSend(TCPTahoe(c2), s2->GetIPAddr(), 80, Constant(100000)); // Enable TCP trace for all clients client1->SetTrace(Trace::ENABLED); client2->SetTrace(Trace::ENABLED); // Set random starting times for the applications Uniform startRv(0.0, 2.0); client1->Start(startRv.Value()); client2->Start(startRv.Value()); s.Progress(1.0); // Request progress messages s.StopAt(10.0); // Stop the simulation at time 10.0 s.Run(); // Run the simulation std::cout << "Simulation Complete" << std::endl; } // Simple GTNetS example // George F. Riley, Georgia Tech, Winter 2002 #include "simulator.h" // Definitions for the Simulator Object #include "node.h" // Definitions for the Node Object #include "linkp2p.h" // Definitions for point-to-point link objects #include "ratetimeparse.h" // Definitions for Rate and Time objects #include "application-tcpserver.h" // Definitions for TCPServer application #include "application-tcpsend.h" // Definitions for TCP Sending app #include "tcp-tahoe.h" // Definitions for TCP Tahoe int main() { // Create the simulator object Simulator s; // Create and enable IP packet tracing Trace* tr = Trace::Instance(); tr->IPDotted(true); tr->Open("intro1.txt"); TCP::LogFlagsText(true); IPV4::Instance()->SetTrace(Trace::ENABLED); // Create the nodes Node* c1 = new Node(); // Client node 1 Node* c2 = new Node(); // Client node 2 Node* r1 = new Node(); // Router node 1 Node* r2 = new Node(); // Router node 2 Node* s1 = new Node(); // Server node 1 Node* s2 = new Node(); // Server node 2 // Create a link object template, 100Mb bandwidth, 5ms delay Linkp2p l(Rate("100Mb"), Time("5ms")); // Add the links to client and server leaf nodes c1->AddDuplexLink(r1, l, IPAddr("192.168.0.1")); // c1 to r1 c2->AddDuplexLink(r1, l, IPAddr("192.168.0.2")); // c2 to r1 s1->AddDuplexLink(r2, l, IPAddr("192.168.1.1")); // s1 to r2 s2->AddDuplexLink(r2, l, IPAddr("192.168.1.2")); // s2 to r2 // Create a link object template, 10Mb bandwidth, 100ms delay Linkp2p r(Rate("10Mb"), Time("100ms")); // Add the router to router link r1->AddDuplexLink(r2, r); TCPServer* server1 = new TCPServer(TCPTahoe()); TCPServer* server2 = new TCPServer(TCPTahoe()); server1->BindAndListen(s1, 80); // Application on s1, port 80 server2->BindAndListen(s2, 80); // Application on s2, port 80 server1->SetTrace(Trace::ENABLED); // Trace TCP actions at server1 server2->SetTrace(Trace::ENABLED); // Trace TCP actions at server2 // Create the TCP Sending Applications TCPSend* client1 = new TCPSend(TCPTahoe(c1), s1->GetIPAddr(), 80, Uniform(1000,10000)); TCPSend* client2 = new TCPSend(TCPTahoe(c2), s2->GetIPAddr(), 80, Constant(100000)); // Enable TCP trace for all clients client1->SetTrace(Trace::ENABLED); client2->SetTrace(Trace::ENABLED); // Set random starting times for the applications Uniform startRv(0.0, 2.0); client1->Start(startRv.Value()); client2->Start(startRv.Value()); s.Progress(1.0); // Request progress messages s.StopAt(10.0); // Stop the simulation at time 10.0 s.Run(); // Run the simulation std::cout << "Simulation Complete" << std::endl; } UNC Chapel Hill, Feb 3, 2006

16. Integration of Zebra bgpd into ns-2/GTNetS • Zebra bgpd: • One BGP router per process (C). • Works on real-time. • Blocking routines. • BSD sockets. • ns-2/GTNetS: • Multiple BGP routers per process (C++). • Works on simulation-time. • Non-blocking routines. • Simulator’s TCP implementation. • Convert C code to C++. • Convert real-time to simulation-time functions. • Remove blocking routines and interleave schedulers. • Replace sockets with the simulator TCP implementation.

17. BGP++ scalability • Compact routing table structure. • Observations: • Memory demand, O(n3), driven by memory required for representing routing tables. • BGP attributes account for most of the memory required for a single routing table entry. • Different entries often have common BGP attributes. • Solution: Use a global data structure to store and share BGP attributes. Avoid replication. • Proof of concept simulations of up to 4,000 ASs in a single workstation with 2GB RAM. • Extend BGP++ to support parallel/distributed BGP simulations. Solve memory bottleneck problem. Up to 62% memory savings, 47% on average.

18. Other BGP++ features • BGP++ inherits Zebra’s CISCO-like configuration language. • Develop a tool to automatically generate ns-2/GTNets configuration from simple user input. • Develop a tool to automatically partition topology and generate pdns configuration from ns-2 configuration, or distributed GTNetS topology. • Model simulation topology as a weighted graph: node weights reflect expected workload, link weights reflect expected traffic. • Graph partitioning problem: find a partition in k parts that minimizes the edge-cut under the constraint that the sum of the nodes’ weights in each part is balanced.

19. Scalability Results - PSC • Pittsburgh Supercomputer Center • 128 Systems, 512 CPU’s, 64-bit HP Systems • Topology Size • 15,064 Nodes per System • 1,928,192 Nodes Total Topology • 1,820,672 Total Flows • 18,650,757,866 Simulation Events • 1,289 Seconds Execution Time

20. Questions?