1 / 20

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

The Georgia Tech Network Simulator (GTNetS) ECE6110 August 25, 2008. George F. Riley. Overview. Network Simulation Basics GTNetS Design Philosophy GTNetS Details BGP++ Scalability Results FAQ Future Plans Demos. Network Simulation Basics - 1. Discrete Event Simulation

cpender
Télécharger la présentation

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

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  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?

More Related