--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/utils/flowmon/flowmon-bench.py Mon May 04 18:35:43 2009 +0100
@@ -0,0 +1,212 @@
+# -*- Mode: Python; -*-
+# Copyright (c) 2009 INESC Porto
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 2 as
+# published by the Free Software Foundation;
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# Authors: Gustavo Carneiro <gjc@inescporto.pt>
+
+import sys
+import ns3
+from xml.dom import minidom
+
+DISTANCE = 150 # (m)
+NUM_NODES_SIDE = 3
+
+
+def write_flowmon_results_to_file(file_name, flow_monitor, flow_classifier):
+ results_file = open(file_name, "wb")
+ domimpl = minidom.getDOMImplementation()
+ doc = domimpl.createDocument(None, "flow-monitor", None)
+ results = doc.documentElement
+
+ flows_el = results.appendChild(doc.createElement('flows'))
+
+ for flow_id, stats in flow_monitor.GetFlowStats():
+ flow_el = flows_el.appendChild(doc.createElement('flow'))
+ flow_el.setAttribute('flow-id', str(flow_id))
+
+ #Time timeFirstTxPacket;
+ flow_el.setAttribute("time-first-tx-packet", str(stats.timeFirstTxPacket))
+
+ #Time timeFirstRxPacket;
+ flow_el.setAttribute("time-first-rx-packet", str(stats.timeFirstRxPacket))
+
+ #Time timeLastTxPacket;
+ flow_el.setAttribute("time-last-tx-packet", str(stats.timeLastTxPacket))
+
+ #Time timeLastRxPacket;
+ flow_el.setAttribute("time-last-rx-packet", str(stats.timeLastRxPacket))
+
+ #Time delaySum;
+ flow_el.setAttribute("delay-sum", str(stats.delaySum))
+
+ #uint64_t txBytes;
+ flow_el.setAttribute("tx-bytes", str(stats.txBytes))
+
+ #uint64_t rxBytes;
+ flow_el.setAttribute("rx-bytes", str(stats.rxBytes))
+
+ #uint32_t txPackets;
+ flow_el.setAttribute("tx-packets", str(stats.txPackets))
+
+ #uint32_t rxPackets;
+ flow_el.setAttribute("rx-packets", str(stats.rxPackets))
+
+ #uint32_t lostPackets;
+ flow_el.setAttribute("lost-packets", str(stats.lostPackets))
+
+ #uint32_t timesForwarded;
+ flow_el.setAttribute("times-forwarded", str(stats.timesForwarded))
+
+ # -- add ipv4 flow filtering information
+ five_tuple = flow_classifier.FindFlow(flow_id)
+ five_tuple_el = flow_el.appendChild(doc.createElement('five-tuple'))
+ five_tuple_el.setAttribute("protocol", str(five_tuple.protocol))
+ five_tuple_el.setAttribute("source-address", str(five_tuple.sourceAddress))
+ five_tuple_el.setAttribute("destination-address", str(five_tuple.destinationAddress))
+ five_tuple_el.setAttribute("source-port", str(five_tuple.sourcePort))
+ five_tuple_el.setAttribute("destination-port", str(five_tuple.destinationPort))
+
+ doc.writexml(results_file, addindent=' ', newl='\n', encoding='utf-8')
+ results_file.close()
+
+
+def main(argv):
+
+ cmd = ns3.CommandLine()
+
+ cmd.Viz = None
+ cmd.AddValue("Viz", "Enable visualizer")
+
+ cmd.NumNodesSide = None
+ cmd.AddValue("NumNodesSide", "Grid side number of nodes (total number of nodes will be this number squared)")
+ cmd.AddValue("EnableMonitor", "Set to 0 or 1 to disable/enable flow monitoring")
+ cmd.AddValue("RunNumber", "Run number (statistics)")
+ cmd.AddValue("Results", "Write results to the given file")
+ cmd.AddValue("StopTime", "Simulation stop time")
+
+ cmd.Parse(argv)
+
+ enable_monitor = int(cmd.EnableMonitor)
+ run_number = int(cmd.RunNumber)
+ if cmd.NumNodesSide is None:
+ num_nodes_side = NUM_NODES_SIDE
+ else:
+ num_nodes_side = int(cmd.NumNodesSide)
+
+
+ ns3.RandomVariable.UseGlobalSeed(1, 1, 2, 3, 5, 8)
+ ns3.RandomVariable.SetRunNumber(run_number)
+
+ p2p = ns3.PointToPointHelper()
+ p2p.SetDeviceAttribute("DataRate", ns3.StringValue("5Mbps"))
+ p2p.SetChannelAttribute("Delay", ns3.StringValue("2ms"))
+
+ internet = ns3.InternetStackHelper()
+ ipv4Addresses = ns3.Ipv4AddressHelper()
+ ipv4Addresses.SetBase(ns3.Ipv4Address("10.0.0.0"), ns3.Ipv4Mask("255.255.255.255"))
+
+ olsrHelper = ns3.OlsrHelper()
+
+ 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)))
+
+ nodes = []
+ for yi in range(num_nodes_side):
+ nodes_row = []
+ nodes.append(nodes_row)
+ for xi in range(num_nodes_side):
+
+ node = ns3.Node()
+ nodes_row.append(node)
+
+ internet.Install(ns3.NodeContainer(node))
+
+ mobility = ns3.StaticMobilityModel()
+ mobility.SetPosition(ns3.Vector(xi*DISTANCE, yi*DISTANCE, 0))
+ node.AggregateObject(mobility)
+
+ node_main_address = None
+
+ if xi > 0:
+ node_left = nodes[yi][xi-1]
+ devices = p2p.Install(ns3.NodeContainer(ns3.NodeContainer(node), ns3.NodeContainer(node_left)))
+ ipv4Addresses.Assign(devices)
+
+ if yi > 0:
+ node_above = nodes[yi-1][xi]
+ devices = p2p.Install(ns3.NodeContainer(ns3.NodeContainer(node), ns3.NodeContainer(node_above)))
+ ipv4Addresses.Assign(devices)
+
+ def get_node_address(node):
+ return node.GetObject(ns3.Ipv4.GetTypeId()).GetAddress(1)
+
+
+ for yi, nodes_row in enumerate(nodes):
+ for xi, node in enumerate(nodes_row):
+ olsrHelper.Install(ns3.NodeContainer(node))
+ destaddr = get_node_address(nodes[(yi-1)%num_nodes_side][(xi-1)%num_nodes_side])
+ onOffHelper.SetAttribute("Remote", ns3.AddressValue(ns3.InetSocketAddress(destaddr, port)))
+ app = onOffHelper.Install(ns3.NodeContainer(node))
+ app.Start(ns3.Seconds(ns3.UniformVariable(20, 30).GetValue()))
+
+
+ if enable_monitor:
+ flowmon_helper = ns3.FlowMonitorHelper()
+ flowmon_helper.SetMonitorAttribute("StartTime", ns3.TimeValue(ns3.Seconds(31)))
+ monitor = flowmon_helper.InstallAll()
+ classifier = flowmon_helper.GetClassifier()
+
+ ns3.Simulator.Stop(ns3.Seconds(float(getattr(cmd, "StopTime", "100"))))
+ if cmd.Viz is not None:
+ import visualizer
+ visualizer.start()
+ else:
+ ns3.Simulator.Run()
+
+ def print_stats(os, monitor, classifier):
+ def print_flow_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{Hop Count}: ", float(st.timesForwarded) / st.rxPackets + 1
+
+ monitor.CheckForLostPackets()
+ 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_flow_stats(sys.stdout, flow_stats)
+
+ if enable_monitor:
+ if hasattr(cmd, "Results"):
+ write_flowmon_results_to_file(cmd.Results, monitor, classifier)
+ else:
+ print_stats(sys.stdout, monitor, classifier)
+
+ return 0
+
+
+if __name__ == '__main__':
+ sys.exit(main(sys.argv))
+