-#!/usr/bin/env python\r
-#\r
-# NEPI, a framework to manage network experiments\r
-# Copyright (C) 2013 INRIA\r
-#\r
-# This program is free software: you can redistribute it and/or modify\r
-# it under the terms of the GNU General Public License version 2 as\r
-# published by the Free Software Foundation;\r
-#\r
-# This program is distributed in the hope that it will be useful,\r
-# but WITHOUT ANY WARRANTY; without even the implied warranty of\r
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r
-# GNU General Public License for more details.\r
-#\r
-# You should have received a copy of the GNU General Public License\r
-# along with this program. If not, see <http://www.gnu.org/licenses/>.\r
-#\r
-# Author: Alina Quereilhac <alina.quereilhac@inria.fr>\r
-\r
-\r
-from nepi.execution.ec import ExperimentController \r
-from nepi.execution.runner import ExperimentRunner\r
-from nepi.util.netgraph import TopologyType\r
-import nepi.data.processing.ccn.parser as ccn_parser\r
-\r
-import networkx\r
-import socket\r
-import os\r
-import numpy\r
-from scipy import stats\r
-from matplotlib import pyplot\r
-import math\r
-import random\r
-\r
-def avg_interest_rtt(ec, run):\r
- logs_dir = ec.run_dir\r
- \r
- # Parse downloaded CCND logs\r
- (graph,\r
- content_names,\r
- interest_expiry_count,\r
- interest_dupnonce_count,\r
- interest_count,\r
- content_count) = ccn_parser.process_content_history_logs(\r
- logs_dir, ec.netgraph.topology)\r
-\r
- # statistics on RTT\r
- rtts = [content_names[content_name]["rtt"] \\r
+#!/usr/bin/env python
+#
+# NEPI, a framework to manage network experiments
+# Copyright (C) 2013 INRIA
+#
+# 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, see <http://www.gnu.org/licenses/>.
+#
+# Author: Alina Quereilhac <alina.quereilhac@inria.fr>
+
+
+from nepi.execution.ec import ExperimentController
+from nepi.execution.runner import ExperimentRunner
+from nepi.util.netgraph import TopologyType
+import nepi.data.processing.ccn.parser as ccn_parser
+
+import networkx
+import socket
+import os
+import numpy
+from scipy import stats
+from matplotlib import pyplot
+import math
+import random
+
+def avg_interest_rtt(ec, run):
+ logs_dir = ec.run_dir
+
+ # Parse downloaded CCND logs
+ (graph,
+ content_names,
+ interest_expiry_count,
+ interest_dupnonce_count,
+ interest_count,
+ content_count) = ccn_parser.process_content_history_logs(
+ logs_dir, ec.netgraph.topology)
+
+ # statistics on RTT
+ rtts = [content_names[content_name]["rtt"] \
for content_name in content_names]
-\r
- # sample mean and standard deviation\r
- sample = numpy.array(rtts)\r
- n, min_max, mean, var, skew, kurt = stats.describe(sample)\r
- std = math.sqrt(var)\r
- ci = stats.t.interval(0.95, n-1, loc = mean, \r
- scale = std/math.sqrt(n))\r
-\r
- global metrics\r
- metrics.append((mean, ci[0], ci[1]))\r
- \r
- return mean\r
-\r
-def normal_law(ec, run, sample):\r
- x = numpy.array(sample)\r
- n = len(sample)\r
- std = x.std()\r
- se = std / math.sqrt(n)\r
- m = x.mean()\r
- se95 = se * 2\r
- \r
- return m * 0.05 >= se95\r
-\r
-def post_process(ec, runs):\r
- global metrics\r
- \r
- # plot convergence graph\r
- y = numpy.array([float(m[0]) for m in metrics])\r
- low = numpy.array([float(m[1]) for m in metrics])\r
- high = numpy.array([float(m[2]) for m in metrics])\r
- error = [y - low, high - y]\r
- x = range(1,runs + 1)\r
-\r
- # plot average RTT and confidence interval for each iteration\r
- pyplot.errorbar(x, y, yerr = error, fmt='o')\r
- pyplot.plot(x, y, 'r-')\r
- pyplot.xlim([0.5, runs + 0.5])\r
- pyplot.xticks(numpy.arange(1, len(y)+1, 1))\r
- pyplot.xlabel('Iteration')\r
- pyplot.ylabel('Average RTT')\r
- pyplot.grid()\r
- pyplot.savefig("plot.png")\r
- pyplot.show()\r
-\r
-content_name = "ccnx:/test/bunny.ts"\r
-\r
-STOP_TIME = "5000s"\r
-\r
-repofile = os.path.join(\r
- os.path.dirname(os.path.realpath(__file__)), \r
- "repoFile1.0.8.2")\r
-\r
-def get_simulator(ec):\r
- simulator = ec.filter_resources("linux::ns3::Simulation")\r
-\r
- if not simulator:\r
- node = ec.register_resource("linux::Node")\r
- ec.set(node, "hostname", "localhost")\r
-\r
- simu = ec.register_resource("linux::ns3::Simulation")\r
- ec.register_connection(simu, node)\r
- return simu\r
-\r
- return simulator[0]\r
-\r
-def add_collector(ec, trace_name, subdir, newname = None):\r
- collector = ec.register_resource("Collector")\r
- ec.set(collector, "traceName", trace_name)\r
- ec.set(collector, "subDir", subdir)\r
- if newname:\r
- ec.set(collector, "rename", newname)\r
-\r
- return collector\r
-\r
-def add_dce_host(ec, nid):\r
- simu = get_simulator(ec)\r
- \r
- host = ec.register_resource("ns3::Node")\r
- ec.set(host, "enableStack", True)\r
- ec.register_connection(host, simu)\r
-\r
- # Annotate the graph\r
- ec.netgraph.annotate_node(nid, "host", host)\r
- \r
-def add_dce_ccnd(ec, nid):\r
- # Retrieve annotation from netgraph\r
- host = ec.netgraph.node_annotation(nid, "host")\r
- \r
- # Add dce ccnd to the dce node\r
- ccnd = ec.register_resource("linux::ns3::dce::CCND")\r
- ec.set (ccnd, "stackSize", 1<<20)\r
- ec.set (ccnd, "debug", 7)\r
- ec.set (ccnd, "capacity", 50000)\r
- ec.set (ccnd, "StartTime", "1s")\r
- ec.set (ccnd, "StopTime", STOP_TIME)\r
- ec.register_connection(ccnd, host)\r
-\r
- # Collector to retrieve ccnd log\r
- collector = add_collector(ec, "stderr", str(nid), "log")\r
- ec.register_connection(collector, ccnd)\r
-\r
- # Annotate the graph\r
- ec.netgraph.annotate_node(nid, "ccnd", ccnd)\r
-\r
-def add_dce_ccnr(ec, nid):\r
- # Retrieve annotation from netgraph\r
- host = ec.netgraph.node_annotation(nid, "host")\r
- \r
- # Add a CCN content repository to the dce node\r
- ccnr = ec.register_resource("linux::ns3::dce::CCNR")\r
- ec.set (ccnr, "repoFile1", repofile) \r
- ec.set (ccnr, "stackSize", 1<<20)\r
- ec.set (ccnr, "StartTime", "2s")\r
- ec.set (ccnr, "StopTime", STOP_TIME)\r
- ec.register_connection(ccnr, host)\r
-\r
-def add_dce_ccncat(ec, nid):\r
- # Retrieve annotation from netgraph\r
- host = ec.netgraph.node_annotation(nid, "host")\r
- \r
- # Add a ccncat application to the dce host\r
- ccncat = ec.register_resource("linux::ns3::dce::CCNCat")\r
- ec.set (ccncat, "contentName", content_name)\r
- ec.set (ccncat, "stackSize", 1<<20)\r
- ec.set (ccncat, "StartTime", "8s")\r
- ec.set (ccncat, "StopTime", STOP_TIME)\r
- ec.register_connection(ccncat, host)\r
-\r
-def add_dce_fib_entry(ec, nid1, nid2):\r
- # Retrieve annotations from netgraph\r
- host1 = ec.netgraph.node_annotation(nid1, "host")\r
- net = ec.netgraph.edge_net_annotation(nid1, nid2)\r
- ip2 = net[nid2]\r
-\r
- # Add FIB entry between peer hosts\r
- ccndc = ec.register_resource("linux::ns3::dce::FIBEntry")\r
- ec.set (ccndc, "protocol", "udp") \r
- ec.set (ccndc, "uri", "ccnx:/") \r
- ec.set (ccndc, "host", ip2)\r
- ec.set (ccndc, "stackSize", 1<<20)\r
- ec.set (ccndc, "StartTime", "2s")\r
- ec.set (ccndc, "StopTime", STOP_TIME)\r
- ec.register_connection(ccndc, host1)\r
-\r
-def add_dce_net_iface(ec, nid1, nid2):\r
- # Retrieve annotations from netgraph\r
- host = ec.netgraph.node_annotation(nid1, "host")\r
- net = ec.netgraph.edge_net_annotation(nid1, nid2)\r
- ip1 = net[nid1]\r
- prefix = net["prefix"]\r
-\r
- dev = ec.register_resource("ns3::PointToPointNetDevice")\r
- ec.set(dev,"DataRate", "5Mbps")\r
- ec.set(dev, "ip", ip1)\r
- ec.set(dev, "prefix", prefix)\r
- ec.register_connection(host, dev)\r
-\r
- queue = ec.register_resource("ns3::DropTailQueue")\r
- ec.register_connection(dev, queue)\r
-\r
- return dev\r
-\r
-def add_edge(ec, nid1, nid2):\r
- ### Add network interfaces to hosts\r
- p2p1 = add_dce_net_iface(ec, nid1, nid2)\r
- p2p2 = add_dce_net_iface(ec, nid2, nid1)\r
-\r
- # Create point to point link between interfaces\r
- chan = ec.register_resource("ns3::PointToPointChannel")\r
- ec.set(chan, "Delay", "0ms")\r
-\r
- ec.register_connection(chan, p2p1)\r
- ec.register_connection(chan, p2p2)\r
-\r
- #### Add routing between CCN nodes\r
- add_dce_fib_entry(ec, nid1, nid2)\r
- add_dce_fib_entry(ec, nid2, nid1)\r
-\r
-def add_node(ec, nid):\r
- ### Add CCN nodes (ec.netgraph holds the topology graph)\r
- add_dce_host(ec, nid)\r
- add_dce_ccnd(ec, nid)\r
- \r
- if nid == ec.netgraph.targets()[0]:\r
- add_dce_ccnr(ec, nid)\r
-\r
- if nid == ec.netgraph.sources()[0]:\r
- add_dce_ccncat(ec, nid)\r
-\r
-def wait_guids(ec):\r
- return ec.filter_resources("linux::ns3::dce::CCNCat")\r
-\r
-if __name__ == '__main__':\r
-\r
- metrics = []\r
-\r
- # topology translation to NEPI model\r
- ec = ExperimentController("dce_4n_linear",\r
- topo_type = TopologyType.LINEAR, \r
- node_count = 4,\r
- assign_st = True,\r
- assign_ips = True,\r
- add_node_callback = add_node,\r
- add_edge_callback = add_edge)\r
-\r
- #### Run experiment until metric convergence\r
- rnr = ExperimentRunner()\r
- runs = rnr.run(ec,\r
- min_runs = 10,\r
- max_runs = 100, \r
- compute_metric_callback = avg_interest_rtt,\r
- evaluate_convergence_callback = normal_law,\r
- wait_guids = wait_guids(ec))\r
- \r
- ### post processing\r
- post_process(ec, runs)\r
-\r
-\r
+
+ # sample mean and standard deviation
+ sample = numpy.array(rtts)
+ n, min_max, mean, var, skew, kurt = stats.describe(sample)
+ std = math.sqrt(var)
+ ci = stats.t.interval(0.95, n-1, loc = mean,
+ scale = std/math.sqrt(n))
+
+ global metrics
+ metrics.append((mean, ci[0], ci[1]))
+
+ return mean
+
+def normal_law(ec, run, sample):
+ x = numpy.array(sample)
+ n = len(sample)
+ std = x.std()
+ se = std / math.sqrt(n)
+ m = x.mean()
+ se95 = se * 2
+
+ return m * 0.05 >= se95
+
+def post_process(ec, runs):
+ global metrics
+
+ # plot convergence graph
+ y = numpy.array([float(m[0]) for m in metrics])
+ low = numpy.array([float(m[1]) for m in metrics])
+ high = numpy.array([float(m[2]) for m in metrics])
+ error = [y - low, high - y]
+ x = range(1,runs + 1)
+
+ # plot average RTT and confidence interval for each iteration
+ pyplot.errorbar(x, y, yerr = error, fmt='o')
+ pyplot.plot(x, y, 'r-')
+ pyplot.xlim([0.5, runs + 0.5])
+ pyplot.xticks(numpy.arange(1, len(y)+1, 1))
+ pyplot.xlabel('Iteration')
+ pyplot.ylabel('Average RTT')
+ pyplot.grid()
+ pyplot.savefig("plot.png")
+ pyplot.show()
+
+content_name = "ccnx:/test/bunny.ts"
+
+STOP_TIME = "5000s"
+
+repofile = os.path.join(
+ os.path.dirname(os.path.realpath(__file__)),
+ "repoFile1.0.8.2")
+
+def get_simulator(ec):
+ simulator = ec.filter_resources("linux::ns3::Simulation")
+
+ if not simulator:
+ node = ec.register_resource("linux::Node")
+ ec.set(node, "hostname", "localhost")
+
+ simu = ec.register_resource("linux::ns3::Simulation")
+ ec.register_connection(simu, node)
+ return simu
+
+ return simulator[0]
+
+def add_collector(ec, trace_name, subdir, newname = None):
+ collector = ec.register_resource("Collector")
+ ec.set(collector, "traceName", trace_name)
+ ec.set(collector, "subDir", subdir)
+ if newname:
+ ec.set(collector, "rename", newname)
+
+ return collector
+
+def add_dce_host(ec, nid):
+ simu = get_simulator(ec)
+
+ host = ec.register_resource("ns3::Node")
+ ec.set(host, "enableStack", True)
+ ec.register_connection(host, simu)
+
+ # Annotate the graph
+ ec.netgraph.annotate_node(nid, "host", host)
+
+def add_dce_ccnd(ec, nid):
+ # Retrieve annotation from netgraph
+ host = ec.netgraph.node_annotation(nid, "host")
+
+ # Add dce ccnd to the dce node
+ ccnd = ec.register_resource("linux::ns3::dce::CCND")
+ ec.set (ccnd, "stackSize", 1<<20)
+ ec.set (ccnd, "debug", 7)
+ ec.set (ccnd, "capacity", 50000)
+ ec.set (ccnd, "StartTime", "1s")
+ ec.set (ccnd, "StopTime", STOP_TIME)
+ ec.register_connection(ccnd, host)
+
+ # Collector to retrieve ccnd log
+ collector = add_collector(ec, "stderr", str(nid), "log")
+ ec.register_connection(collector, ccnd)
+
+ # Annotate the graph
+ ec.netgraph.annotate_node(nid, "ccnd", ccnd)
+
+def add_dce_ccnr(ec, nid):
+ # Retrieve annotation from netgraph
+ host = ec.netgraph.node_annotation(nid, "host")
+
+ # Add a CCN content repository to the dce node
+ ccnr = ec.register_resource("linux::ns3::dce::CCNR")
+ ec.set (ccnr, "repoFile1", repofile)
+ ec.set (ccnr, "stackSize", 1<<20)
+ ec.set (ccnr, "StartTime", "2s")
+ ec.set (ccnr, "StopTime", STOP_TIME)
+ ec.register_connection(ccnr, host)
+
+def add_dce_ccncat(ec, nid):
+ # Retrieve annotation from netgraph
+ host = ec.netgraph.node_annotation(nid, "host")
+
+ # Add a ccncat application to the dce host
+ ccncat = ec.register_resource("linux::ns3::dce::CCNCat")
+ ec.set (ccncat, "contentName", content_name)
+ ec.set (ccncat, "stackSize", 1<<20)
+ ec.set (ccncat, "StartTime", "8s")
+ ec.set (ccncat, "StopTime", STOP_TIME)
+ ec.register_connection(ccncat, host)
+
+def add_dce_fib_entry(ec, nid1, nid2):
+ # Retrieve annotations from netgraph
+ host1 = ec.netgraph.node_annotation(nid1, "host")
+ net = ec.netgraph.edge_net_annotation(nid1, nid2)
+ ip2 = net[nid2]
+
+ # Add FIB entry between peer hosts
+ ccndc = ec.register_resource("linux::ns3::dce::FIBEntry")
+ ec.set (ccndc, "protocol", "udp")
+ ec.set (ccndc, "uri", "ccnx:/")
+ ec.set (ccndc, "host", ip2)
+ ec.set (ccndc, "stackSize", 1<<20)
+ ec.set (ccndc, "StartTime", "2s")
+ ec.set (ccndc, "StopTime", STOP_TIME)
+ ec.register_connection(ccndc, host1)
+
+def add_dce_net_iface(ec, nid1, nid2):
+ # Retrieve annotations from netgraph
+ host = ec.netgraph.node_annotation(nid1, "host")
+ net = ec.netgraph.edge_net_annotation(nid1, nid2)
+ ip1 = net[nid1]
+ prefix = net["prefix"]
+
+ dev = ec.register_resource("ns3::PointToPointNetDevice")
+ ec.set(dev,"DataRate", "5Mbps")
+ ec.set(dev, "ip", ip1)
+ ec.set(dev, "prefix", prefix)
+ ec.register_connection(host, dev)
+
+ queue = ec.register_resource("ns3::DropTailQueue")
+ ec.register_connection(dev, queue)
+
+ return dev
+
+def add_edge(ec, nid1, nid2):
+ ### Add network interfaces to hosts
+ p2p1 = add_dce_net_iface(ec, nid1, nid2)
+ p2p2 = add_dce_net_iface(ec, nid2, nid1)
+
+ # Create point to point link between interfaces
+ chan = ec.register_resource("ns3::PointToPointChannel")
+ ec.set(chan, "Delay", "0ms")
+
+ ec.register_connection(chan, p2p1)
+ ec.register_connection(chan, p2p2)
+
+ #### Add routing between CCN nodes
+ add_dce_fib_entry(ec, nid1, nid2)
+ add_dce_fib_entry(ec, nid2, nid1)
+
+def add_node(ec, nid):
+ ### Add CCN nodes (ec.netgraph holds the topology graph)
+ add_dce_host(ec, nid)
+ add_dce_ccnd(ec, nid)
+
+ if nid == ec.netgraph.targets()[0]:
+ add_dce_ccnr(ec, nid)
+
+ if nid == ec.netgraph.sources()[0]:
+ add_dce_ccncat(ec, nid)
+
+def wait_guids(ec):
+ return ec.filter_resources("linux::ns3::dce::CCNCat")
+
+if __name__ == '__main__':
+
+ metrics = []
+
+ # topology translation to NEPI model
+ ec = ExperimentController("dce_4n_linear",
+ topo_type = TopologyType.LINEAR,
+ node_count = 4,
+ assign_st = True,
+ assign_ips = True,
+ add_node_callback = add_node,
+ add_edge_callback = add_edge)
+
+ #### Run experiment until metric convergence
+ rnr = ExperimentRunner()
+ runs = rnr.run(ec,
+ min_runs = 10,
+ max_runs = 100,
+ compute_metric_callback = avg_interest_rtt,
+ evaluate_convergence_callback = normal_law,
+ wait_guids = wait_guids(ec))
+
+ ### post processing
+ post_process(ec, runs)
+
+
git://git.onelab.eu / nepi.git / commitdiff