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

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

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 3

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 4

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

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 6

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 7

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

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

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 10

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) 11

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

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”) 13

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 14

15. Example UNC Chapel Hill, Feb 3, 200615 // 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" #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; // 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 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")); 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 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); 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)); 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; } // 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; } TCP Client 1 TCP Client 2 TCP Server 1 TCP Server 2

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. 16

17. BGP++ scalability Compact routing table structure. ◦ Observations:  Memory demand, O(n 3 ), 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. 17 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. 18

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 19

20. Questions? 20