def _add_onoff_app(self, start_time, end_time, local, remote, on_time, off_time, data_rate, sport, dport): """add one ns3 onoff application to the network """ # ignore the network prefix length if there is if '/' in remote: remote = remote.rsplit('/')[0] if '/' in local: local = local.rsplit('/')[0] ### Install OnOff Application ### socketType = "ns3::UdpSocketFactory" # socketType = "ns3::TcpSocketFactory" helper = ns3.OnOffHelper(socketType, ns3.InetSocketAddress(remote, dport)) helper.SetAttribute("StartTime", ns3.TimeValue(ns3.Time(str(start_time) + 's'))) helper.SetAttribute("StopTime", ns3.TimeValue(ns3.Time(str(end_time) + 's'))) # helper.SetAttribute("Remote", ns3.AddressValue(ns3.Ipv4Address(remote))) local_inet = ns3.InetSocketAddress(local, sport) helper.SetAttribute("Local", ns3.AddressValue(local_inet)) helper.SetAttribute("DataRate", ns3.StringValue(str(data_rate) + 'b/s')) helper.SetAttribute("OnTime", ns3.RandomVariableValue(on_time.to_ns3())) helper.SetAttribute("OffTime", ns3.RandomVariableValue(off_time.to_ns3())) print('local, ', local) local_node = self.net.search_node(local) helper.Install(local_node) ### Install Sink Application #### sinkLocalAddress = ns3.Address( ns3.InetSocketAddress(ns3.Ipv4Address.GetAny(), dport)) sinkHelper = ns3.PacketSinkHelper(socketType, sinkLocalAddress) helper.SetAttribute("StartTime", ns3.TimeValue(ns3.Time(str(start_time) + 's'))) helper.SetAttribute("StopTime", ns3.TimeValue(ns3.Time(str(end_time) + 's'))) remote_node = self.net.search_node(remote) print('remote, ', remote) sinkHelper.Install(remote_node) print("""add an onoff application with start_time: %f end_time: %f local: %s, remote: %s, on_time: %s, off_time: %s""" % (start_time, end_time, local, remote, on_time, off_time))
def onoff_app(network, client_node, server_node, server_device, start, stop, rate, port=9, packet_size=1024, access_class=None, ontime=1, offtime=0): """Set up a OnOff client + sink server.""" server = network.nodes[server_node] assert server_device in server.devices, \ "Device '%s' not found, available: %s" % (server_device, ", ".join(server.devices)) server_address = server.devices[server_device].interfaces[0].address local_address = ns3.InetSocketAddress(ns3.Ipv4Address.GetAny(), port) sink_helper = ns3.PacketSinkHelper("ns3::UdpSocketFactory", local_address) server_apps = sink_helper.Install(server.ns3_node) server_apps.Start(ns3.Seconds(start)) server_apps.Stop(ns3.Seconds(stop)) client = network.nodes[client_node] remote_address = ns3.InetSocketAddress(server_address, port) onoff_helper = ns3.OnOffHelper("ns3::UdpSocketFactory", ns3.Address()) onoff_helper.SetAttribute( "OnTime", ns3.RandomVariableValue(ns3.ConstantVariable(ontime))) onoff_helper.SetAttribute( "OffTime", ns3.RandomVariableValue(ns3.ConstantVariable(offtime))) onoff_helper.SetAttribute("DataRate", ns3.DataRateValue(ns3.DataRate(rate))) onoff_helper.SetAttribute("PacketSize", ns3.UintegerValue(packet_size)) onoff_helper.SetAttribute("Remote", ns3.AddressValue(remote_address)) # Set QoS Access Class -> Tid # Note that this only works with a patched OnOffApplication with QosTid attribute if access_class is not None: access_class_to_qos_tid = { "ac_vo": 6, # AC_VO (Tid: 6, 7) "ac_vi": 4, # AC_VI (Tid: 4, 5) "ac_be": 0, # AC_BE (Tid: 0) "ac_bk": 1, # AC_BK (Tid: 1, 2) "ac_be_nqos": 3, # AC_BE_NQOS (Tid: 3) } qos_tid = access_class_to_qos_tid[access_class.lower()] onoff_helper.SetAttribute("QosTid", ns3.UintegerValue(qos_tid)) client_apps = onoff_helper.Install(client.ns3_node) client_apps.Start(ns3.Seconds(start)) client_apps.Stop(ns3.Seconds(stop))
def main(argv): # # Allow the user to override any of the defaults and the above Bind() at # run-time, via command-line arguments # cmd = ns3.CommandLine() cmd.Parse(argv) # # Explicitly create the nodes required by the topology(shown above). # #print "Create nodes." terminals = ns3.NodeContainer() terminals.Create(4) csmaSwitch = ns3.NodeContainer() csmaSwitch.Create(1) #print "Build Topology" csma = ns3.CsmaHelper() csma.SetChannelAttribute("DataRate", ns3.DataRateValue(ns3.DataRate(5000000))) csma.SetChannelAttribute("Delay", ns3.TimeValue(ns3.MilliSeconds(2))) # Create the csma links, from each terminal to the switch terminalDevices = ns3.NetDeviceContainer() switchDevices = ns3.NetDeviceContainer() for i in range(4): link = csma.Install( ns3.NodeContainer(ns3.NodeContainer(terminals.Get(i)), csmaSwitch)) terminalDevices.Add(link.Get(0)) switchDevices.Add(link.Get(1)) # Create the bridge netdevice, which will do the packet switching switchNode = csmaSwitch.Get(0) bridgeDevice = ns3.BridgeNetDevice() switchNode.AddDevice(bridgeDevice) for portIter in range(switchDevices.GetN()): bridgeDevice.AddBridgePort(switchDevices.Get(portIter)) # Add internet stack to the terminals internet = ns3.InternetStackHelper() internet.Install(terminals) # We've got the "hardware" in place. Now we need to add IP addresses. # #print "Assign IP Addresses." ipv4 = ns3.Ipv4AddressHelper() ipv4.SetBase(ns3.Ipv4Address("10.1.1.0"), ns3.Ipv4Mask("255.255.255.0")) ipv4.Assign(terminalDevices) # # Create an OnOff application to send UDP datagrams from node zero to node 1. # #print "Create Applications." port = 9 # Discard port(RFC 863) onoff = ns3.OnOffHelper( "ns3::UdpSocketFactory", ns3.Address(ns3.InetSocketAddress(ns3.Ipv4Address("10.1.1.2"), port))) onoff.SetAttribute("OnTime", ns3.RandomVariableValue(ns3.ConstantVariable(1))) onoff.SetAttribute("OffTime", ns3.RandomVariableValue(ns3.ConstantVariable(0))) app = onoff.Install(ns3.NodeContainer(terminals.Get(0))) # Start the application app.Start(ns3.Seconds(1.0)) app.Stop(ns3.Seconds(10.0)) # Create an optional packet sink to receive these packets sink = ns3.PacketSinkHelper( "ns3::UdpSocketFactory", ns3.Address(ns3.InetSocketAddress(ns3.Ipv4Address.GetAny(), port))) app = sink.Install(ns3.NodeContainer(terminals.Get(1))) app.Start(ns3.Seconds(0.0)) # # Create a similar flow from n3 to n0, starting at time 1.1 seconds # onoff.SetAttribute( "Remote", ns3.AddressValue( ns3.InetSocketAddress(ns3.Ipv4Address("10.1.1.1"), port))) app = onoff.Install(ns3.NodeContainer(terminals.Get(3))) app.Start(ns3.Seconds(1.1)) app.Stop(ns3.Seconds(10.0)) app = sink.Install(ns3.NodeContainer(terminals.Get(0))) app.Start(ns3.Seconds(0.0)) # # Configure tracing of all enqueue, dequeue, and NetDevice receive events. # Trace output will be sent to the file "csma-bridge.tr" # #print "Configure Tracing." #ascii = ns3.AsciiTraceHelper(); #csma.EnableAsciiAll(ascii.CreateFileStream ("csma-bridge.tr")); # # Also configure some tcpdump traces; each interface will be traced. # The output files will be named: # csma-bridge.pcap-<nodeId>-<interfaceId> # and can be read by the "tcpdump -r" command(use "-tt" option to # display timestamps correctly) # csma.EnablePcapAll("csma-bridge", False) # # Now, do the actual simulation. # #print "Run Simulation." ns3.Simulator.Run() ns3.Simulator.Destroy()
def main(argv): cmd = ns3.CommandLine() cmd.NumNodesSide = None cmd.AddValue( "NumNodesSide", "Grid side number of nodes (total number of nodes will be this number squared)" ) cmd.Results = None cmd.AddValue("Results", "Write XML results to file") cmd.Plot = None cmd.AddValue("Plot", "Plot the results using the matplotlib python module") cmd.Parse(argv) wifi = ns3.WifiHelper.Default() wifiMac = ns3.NqosWifiMacHelper.Default() wifiPhy = ns3.YansWifiPhyHelper.Default() wifiChannel = ns3.YansWifiChannelHelper.Default() wifiPhy.SetChannel(wifiChannel.Create()) ssid = ns3.Ssid("wifi-default") wifi.SetRemoteStationManager("ns3::ArfWifiManager") wifiMac.SetType("ns3::AdhocWifiMac", "Ssid", ns3.SsidValue(ssid)) internet = ns3.InternetStackHelper() list_routing = ns3.Ipv4ListRoutingHelper() olsr_routing = ns3.OlsrHelper() static_routing = ns3.Ipv4StaticRoutingHelper() list_routing.Add(static_routing, 0) list_routing.Add(olsr_routing, 100) internet.SetRoutingHelper(list_routing) ipv4Addresses = ns3.Ipv4AddressHelper() ipv4Addresses.SetBase(ns3.Ipv4Address("10.0.0.0"), ns3.Ipv4Mask("255.255.255.0")) port = 9 # Discard port(RFC 863) onOffHelper = ns3.OnOffHelper( "ns3::UdpSocketFactory", ns3.Address(ns3.InetSocketAddress(ns3.Ipv4Address("10.0.0.1"), port))) onOffHelper.SetAttribute("DataRate", ns3.DataRateValue(ns3.DataRate("100kbps"))) onOffHelper.SetAttribute("OnTime", ns3.RandomVariableValue(ns3.ConstantVariable(1))) onOffHelper.SetAttribute("OffTime", ns3.RandomVariableValue(ns3.ConstantVariable(0))) addresses = [] nodes = [] if cmd.NumNodesSide is None: num_nodes_side = NUM_NODES_SIDE else: num_nodes_side = int(cmd.NumNodesSide) for xi in range(num_nodes_side): for yi in range(num_nodes_side): node = ns3.Node() nodes.append(node) internet.Install(ns3.NodeContainer(node)) mobility = ns3.ConstantPositionMobilityModel() mobility.SetPosition(ns3.Vector(xi * DISTANCE, yi * DISTANCE, 0)) node.AggregateObject(mobility) devices = wifi.Install(wifiPhy, wifiMac, node) ipv4_interfaces = ipv4Addresses.Assign(devices) addresses.append(ipv4_interfaces.GetAddress(0)) for i, node in enumerate(nodes): destaddr = addresses[(len(addresses) - 1 - i) % len(addresses)] #print i, destaddr onOffHelper.SetAttribute( "Remote", ns3.AddressValue(ns3.InetSocketAddress(destaddr, port))) app = onOffHelper.Install(ns3.NodeContainer(node)) app.Start(ns3.Seconds(ns3.UniformVariable(20, 30).GetValue())) #internet.EnablePcapAll("wifi-olsr") flowmon_helper = ns3.FlowMonitorHelper() #flowmon_helper.SetMonitorAttribute("StartTime", ns3.TimeValue(ns3.Seconds(31))) monitor = flowmon_helper.InstallAll() monitor.SetAttribute("DelayBinWidth", ns3.DoubleValue(0.001)) monitor.SetAttribute("JitterBinWidth", ns3.DoubleValue(0.001)) monitor.SetAttribute("PacketSizeBinWidth", ns3.DoubleValue(20)) ns3.Simulator.Stop(ns3.Seconds(44.0)) ns3.Simulator.Run() def print_stats(os, st): print >> os, " Tx Bytes: ", st.txBytes print >> os, " Rx Bytes: ", st.rxBytes print >> os, " Tx Packets: ", st.txPackets print >> os, " Rx Packets: ", st.rxPackets print >> os, " Lost Packets: ", st.lostPackets if st.rxPackets > 0: print >> os, " Mean{Delay}: ", (st.delaySum.GetSeconds() / st.rxPackets) print >> os, " Mean{Jitter}: ", (st.jitterSum.GetSeconds() / (st.rxPackets - 1)) print >> os, " Mean{Hop Count}: ", float( st.timesForwarded) / st.rxPackets + 1 if 0: print >> os, "Delay Histogram" for i in range(st.delayHistogram.GetNBins()): print >> os, " ",i,"(", st.delayHistogram.GetBinStart (i), "-", \ st.delayHistogram.GetBinEnd (i), "): ", st.delayHistogram.GetBinCount (i) print >> os, "Jitter Histogram" for i in range(st.jitterHistogram.GetNBins()): print >> os, " ",i,"(", st.jitterHistogram.GetBinStart (i), "-", \ st.jitterHistogram.GetBinEnd (i), "): ", st.jitterHistogram.GetBinCount (i) print >> os, "PacketSize Histogram" for i in range(st.packetSizeHistogram.GetNBins()): print >> os, " ",i,"(", st.packetSizeHistogram.GetBinStart (i), "-", \ st.packetSizeHistogram.GetBinEnd (i), "): ", st.packetSizeHistogram.GetBinCount (i) for reason, drops in enumerate(st.packetsDropped): print " Packets dropped by reason %i: %i" % (reason, drops) #for reason, drops in enumerate(st.bytesDropped): # print "Bytes dropped by reason %i: %i" % (reason, drops) monitor.CheckForLostPackets() classifier = flowmon_helper.GetClassifier() if cmd.Results is None: for flow_id, flow_stats in monitor.GetFlowStats(): t = classifier.FindFlow(flow_id) proto = {6: 'TCP', 17: 'UDP'}[t.protocol] print "FlowID: %i (%s %s/%s --> %s/%i)" % \ (flow_id, proto, t.sourceAddress, t.sourcePort, t.destinationAddress, t.destinationPort) print_stats(sys.stdout, flow_stats) else: print monitor.SerializeToXmlFile(cmd.Results, True, True) if cmd.Plot is not None: import pylab delays = [] for flow_id, flow_stats in monitor.GetFlowStats(): tupl = classifier.FindFlow(flow_id) if tupl.protocol == 17 and tupl.sourcePort == 698: continue delays.append(flow_stats.delaySum.GetSeconds() / flow_stats.rxPackets) pylab.hist(delays, 20) pylab.xlabel("Delay (s)") pylab.ylabel("Number of Flows") pylab.show() return 0