def setUp(self):
topology = self.my_topology()
model = NetworkModel(topology, cache_policy={'name': 'LRU'})
self.view = NetworkView(model)
self.controller = NetworkController(model)
self.collector = TestCollector(self.view)
self.controller.attach_collector(self.collector)
def setUp(self):
topology = self.nrr_topology()
model = NetworkModel(topology, cache_policy={'name': 'FIFO'})
self.view = NetworkView(model)
self.controller = NetworkController(model)
self.collector = DummyCollector(self.view)
self.controller.attach_collector(self.collector)
def setup_method(self):
topology = self.nrr_topology()
model = NetworkModel(topology, cache_policy={"name": "FIFO"})
self.view = NetworkView(model)
self.controller = NetworkController(model)
self.collector = DummyCollector(self.view)
self.controller.attach_collector(self.collector)
def setUp(self):
topology = off_path_topology()
model = NetworkModel(topology)
self.view = NetworkView(model)
self.controller = NetworkController(model)
self.collector = TestCollector(self.view)
self.controller.attach_collector(self.collector)
def setUp(self):
topology = nrr_topology()
model = NetworkModel(topology, cache_policy={'name': 'FIFO'})
self.view = NetworkView(model)
self.controller = NetworkController(model)
self.collector = TestCollector(self.view)
self.controller.attach_collector(self.collector)
def setUp(self):
topology = off_path_topology()
model = NetworkModel(topology)
self.view = NetworkView(model)
self.controller = NetworkController(model)
self.collector = TestCollector(self.view)
self.controller.attach_collector(self.collector)
def exec_experiment(topology, workload, netconf, strategy, cache_policy,
collectors):
"""Execute the simulation of a specific scenario.
Parameters
----------
topology : Topology
The FNSS Topology object modelling the network topology on which
experiments are run.
workload : iterable
An iterable object whose elements are (time, event) tuples, where time
is a float type indicating the timestamp of the event to be executed
and event is a dictionary storing all the attributes of the event to
execute
netconf : dict
Dictionary of attributes to inizialize the network model
strategy : tree
Strategy definition. It is tree describing the name of the strategy
to use and a list of initialization attributes
cache_policy : tree
Cache policy definition. It is tree describing the name of the cache
policy to use and a list of initialization attributes
collectors: dict
The collectors to be used. It is a dictionary in which keys are the
names of collectors to use and values are dictionaries of attributes
for the collector they refer to.
Returns
-------
results : Tree
A tree with the aggregated simulation results from all collectors
"""
netconf['n_contents'] = workload.n_contents
model = NetworkModel(topology, cache_policy, **netconf)
view = NetworkView(model)
controller = NetworkController(model)
collectors_inst = [
DATA_COLLECTOR[name](view, **params)
for name, params in collectors.items()
]
collector = CollectorProxy(view, collectors_inst)
controller.attach_collector(collector)
strategy_name = strategy['name']
strategy_args = {k: v for k, v in strategy.items() if k != 'name'}
strategy_inst = STRATEGY[strategy_name](view, controller, **strategy_args)
i = 0
for time, event in workload:
strategy_inst.process_event(time, **event)
# i+=1
# if not i%30:
# results = collector.results()
# logger.info('Mean hit ratio: %f | Mean latency: %f | Reward: %f.'%(results['CACHE_HIT_RATIO']['MEAN'], results['LATENCY']['MEAN'], controller.get_avg_reward()))
# workload.reward = controller.get_avg_reward()
return collector.results()
def exec_experiment(topology, workload, netconf, strategy, cache_policy, collectors, desc):
"""Execute the simulation of a specific scenario.
Parameters
----------
topology : Topology
The FNSS Topology object modelling the network topology on which
experiments are run.
workload : iterable
An iterable object whose elements are (time, event) tuples, where time
is a float type indicating the timestamp of the event to be executed
and event is a dictionary storing all the attributes of the event to
execute
netconf : dict
Dictionary of attributes to inizialize the network model
strategy : tree
Strategy definition. It is tree describing the name of the strategy
to use and a list of initialization attributes
cache_policy : tree
Cache policy definition. It is tree describing the name of the cache
policy to use and a list of initialization attributes
collectors: dict
The collectors to be used. It is a dictionary in which keys are the
names of collectors to use and values are dictionaries of attributes
for the collector they refer to.
Returns
-------
results : Tree
A tree with the aggregated simulation results from all collectors
"""
model = NetworkModel(topology, cache_policy, **netconf)
view = NetworkView(model)
controller = NetworkController(model)
collectors_inst = [DATA_COLLECTOR[name](view, **params)
for name, params in list(collectors.items())]
collector = CollectorProxy(view, collectors_inst)
controller.attach_collector(collector)
strategy_name = strategy['name']
strategy_args = {k: v for k, v in list(strategy.items()) if k != 'name'}
strategy_inst = STRATEGY[strategy_name](view, controller, **strategy_args)
processed_events = 0
for time, event in workload:
strategy_inst.process_event(time, **event)
processed_events += 1
if processed_events % 1000000 == 0:
logger.info('Progress: %s, %f' % (desc, float(processed_events) / float(workload.n_measured)))
return collector.results()
def exec_experiment(topology, workload, netconf, strategy, cache_policy,
collectors):
"""Execute the simulation of a specific scenario.
Parameters
----------
topology : Topology
The FNSS Topology object modelling the network topology on which
experiments are run.
workload : iterable
An iterable object whose elements are (time, event) tuples, where time
is a float type indicating the timestamp of the event to be executed
and event is a dictionary storing all the attributes of the event to
execute
netconf : dict
Dictionary of attributes to inizialize the network model
strategy : tree
Strategy definition. It is tree describing the name of the strategy
to use and a list of initialization attributes
cache_policy : tree
Cache policy definition. It is tree describing the name of the cache
policy to use and a list of initialization attributes
collectors: dict
The collectors to be used. It is a dictionary in which keys are the
names of collectors to use and values are dictionaries of attributes
for the collector they refer to.
Returns
-------
results : Tree
A tree with the aggregated simulation results from all collectors
"""
model = NetworkModel(topology, cache_policy, **netconf)
view = NetworkView(model)
controller = NetworkController(model)
collectors_inst = [
DATA_COLLECTOR[name](view, **params)
for name, params in collectors.items()
]
collector = CollectorProxy(view, collectors_inst)
controller.attach_collector(collector)
strategy_name = strategy['name']
strategy_args = {k: v for k, v in strategy.items() if k != 'name'}
strategy_inst = STRATEGY[strategy_name](view, controller, **strategy_args)
for time, event in workload: # e.g. time: 1520036461364, event: {'receiver': 'battery3/receiver', 'content': '/agent4/battery3/charging/v0', 'log': True}
# print('calling process_event with time:', time, ' event', event)
# write_to_file(time)
strategy_inst.process_event(time, **event)
return collector.results()
def exec_experiment(topology, events, strategy, collectors):
"""
Execute the simulation of a specific scenario
Parameters
----------
topology : Topology
An FNSS topology object with the network topology used for the
simulation
events : iterable
An iterable object whose elements are (time, event) tuples, where time
is a float type indicating the timestamp of the event to be executed
and event is a dictionary storing all the attributes of the event to
execute
strategy : 2-tuple
Strategy definition. It is a 2-tuple where the first element is the
name of the strategy and the second element is a dictionary of
strategy attributes
collectors: list of tuples
The collectors to be used. It is a list of 2-tuples. Each tuple has as
first element the name of the collector and as second element a
dictionary of collector parameters
Returns
-------
results : dict
A dictionary with the aggregated simulation results from all collectors.
"""
model = NetworkModel(topology)
view = NetworkView(model)
controller = NetworkController(model)
collectors_inst = [data_collector_register[name](view, **params)
for name, params in collectors]
collector = CollectorProxy(view, collectors_inst)
controller.attach_collector(collector)
str_name, str_params = strategy
strategy_inst = strategy_register[str_name](view, controller, **str_params)
for time, event in events:
strategy_inst.process_event(time, **event)
return collector.results()
class MyTestCase(unittest.TestCase):
def setUpClass(cls):
pass
@classmethod
def tearDownClass(cls):
pass
def my_topology(cls):
"""Return my topology for testing caching strategies
"""
# Topology sketch
# 0
# / \
# / \
# / \
# 1 2
# / \ / \
# 3 4 5 6
# / \ / \ / \ / \
# 7 8 9 10 11 1213 14
#
k = 2
h = 3
delay = 5
topology = IcnTopology(fnss.k_ary_tree_topology(k, h))
receivers = [
v for v in topology.nodes_iter() if topology.node[v]['depth'] == h
]
sources = [
v for v in topology.nodes_iter() if topology.node[v]['depth'] == 0
]
routers = [
v for v in topology.nodes_iter()
if topology.node[v]['depth'] > 0 and topology.node[v]['depth'] < h
]
topology.graph['icr_candidates'] = set(routers)
for v in receivers:
fnss.add_stack(topology, v, 'receiver')
for v in routers:
fnss.add_stack(topology, v, 'router', {'cache_size': 2})
contents = (1, 2, 3)
fnss.add_stack(topology, source, 'source', {'contents': contents})
# set weights and delays on all links
fnss.set_weights_constant(topology, 1.0)
fnss.set_delays_constant(topology, delay, 'ms')
fnss.set_delays_constant(topology, 20, 'ms', [(0, 1), (0, 2)])
# label links as internal
for u, v in topology.edges_iter():
topology.edge[u][v]['type'] = 'internal'
return IcnTopology(topology)
def setUp(self):
topology = self.my_topology()
model = NetworkModel(topology, cache_policy={'name': 'LRU'})
self.view = NetworkView(model)
self.controller = NetworkController(model)
self.collector = TestCollector(self.view)
self.controller.attach_collector(self.collector)
def tearDown(self):
pass
# ²âÊÔÓÃÀý
def test_case1(self):
hr = strategy.CRAN_CountBloomFilter1(self.view, self.controller)
# receiver 7 requests 2, expect miss
hr.process_event(1, 13, 1, True)
loc = self.view.content_locations(2)
self.assertEquals(len(loc), 2)
self.assertIn(1, loc)
self.assertIn(0, loc)
summary = self.collector.session_summary()
#exp_req_hops = [(7, 3), (3, 1), (1, 0)]
#exp_cont_hops = [(0, 1), (1, 3), (3, 7)]
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(set(exp_req_hops), set(req_hops))
self.assertSetEqual(set(exp_cont_hops), set(cont_hops))
hr.process_event(1, 13, 2, True)
for i in range(2, 8):
print "loop", i
hr.process_event(1, 16, i, True)
num = self.view.cache_dump(4)
print "cache of node 4:", num
num2 = self.view.cache_dump(5)
print "cache of node 5:", num2
num1 = self.view.cache_dump(1)
print "cache of node 1:", num1
hr.process_event(1, 13, 6, True)
hr.process_event(1, 13, 6, True)
hr.process_event(1, 13, 6, True)
hr.process_event(1, 13, 7, True)
hr.process_event(1, 13, 7, True)
hr.process_event(1, 13, 5, True)
hr.process_event(1, 13, 5, True)
hr.process_event(1, 13, 1, True)
hr.process_event(1, 13, 8, True)
num = self.view.cache_dump(4)
print "cache of node 4:", num
num2 = self.view.cache_dump(5)
print "cache of node 5:", num2
num1 = self.view.cache_dump(1)
print "cache of node 1:", num1
class TestNrr(unittest.TestCase):
"""Test suite for Nearest Replica Routing strategies"""
@classmethod
def nrr_topology(cls):
"""Return topology for testing NRR caching strategies
"""
# Topology sketch
#
# 0 ---- 2----- 4
# | \
# | s
# | /
# 1 ---- 3 ---- 5
#
topology = IcnTopology(fnss.Topology())
nx.add_path(topology, [0, 2, 4, "s", 5, 3, 1])
topology.add_edge(2, 3)
receivers = (0, 1)
source = "s"
caches = (2, 3, 4, 5)
contents = (1, 2, 3, 4)
fnss.add_stack(topology, source, 'source', {'contents': contents})
for v in caches:
fnss.add_stack(topology, v, 'router', {'cache_size': 1})
for v in receivers:
fnss.add_stack(topology, v, 'receiver', {})
fnss.set_delays_constant(topology, 1, 'ms')
return topology
def setUp(self):
topology = self.nrr_topology()
model = NetworkModel(topology, cache_policy={'name': 'FIFO'})
self.view = NetworkView(model)
self.controller = NetworkController(model)
self.collector = DummyCollector(self.view)
self.controller.attach_collector(self.collector)
def test_lce(self):
hr = strategy.NearestReplicaRouting(self.view,
self.controller,
metacaching='LCE')
# receiver 0 requests 2, expect miss
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEqual(3, len(loc))
self.assertIn(2, loc)
self.assertIn(4, loc)
self.assertIn("s", loc)
self.assertNotIn(3, loc)
self.assertNotIn(5, loc)
summary = self.collector.session_summary()
exp_req_hops = [(0, 2), (2, 4), (4, "s")]
exp_cont_hops = [("s", 4), (4, 2), (2, 0)]
self.assertSetEqual(set(exp_req_hops), set(summary['request_hops']))
self.assertSetEqual(set(exp_cont_hops), set(summary['content_hops']))
self.assertEqual("s", summary['serving_node'])
hr.process_event(1, 1, 2, True)
loc = self.view.content_locations(2)
self.assertEqual(4, len(loc))
self.assertIn(2, loc)
self.assertIn(4, loc)
self.assertIn("s", loc)
self.assertIn(3, loc)
self.assertNotIn(5, loc)
summary = self.collector.session_summary()
exp_req_hops = [(1, 3), (3, 2)]
exp_cont_hops = [(2, 3), (3, 1)]
self.assertSetEqual(set(exp_req_hops), set(summary['request_hops']))
self.assertSetEqual(set(exp_cont_hops), set(summary['content_hops']))
self.assertEqual(2, summary['serving_node'])
hr.process_event(1, 1, 2, True)
loc = self.view.content_locations(2)
self.assertEqual(4, len(loc))
self.assertIn(2, loc)
self.assertIn(4, loc)
self.assertIn("s", loc)
self.assertIn(3, loc)
self.assertNotIn(5, loc)
summary = self.collector.session_summary()
exp_req_hops = [(1, 3)]
exp_cont_hops = [(3, 1)]
self.assertSetEqual(set(exp_req_hops), set(summary['request_hops']))
self.assertSetEqual(set(exp_cont_hops), set(summary['content_hops']))
self.assertEqual(3, summary['serving_node'])
def test_lcd(self):
hr = strategy.NearestReplicaRouting(self.view,
self.controller,
metacaching='LCD')
# receiver 0 requests 2, expect miss
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEqual(2, len(loc))
self.assertNotIn(2, loc)
self.assertIn(4, loc)
self.assertIn("s", loc)
self.assertNotIn(3, loc)
self.assertNotIn(5, loc)
summary = self.collector.session_summary()
exp_req_hops = [(0, 2), (2, 4), (4, "s")]
exp_cont_hops = [("s", 4), (4, 2), (2, 0)]
self.assertSetEqual(set(exp_req_hops), set(summary['request_hops']))
self.assertSetEqual(set(exp_cont_hops), set(summary['content_hops']))
self.assertEqual("s", summary['serving_node'])
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEqual(3, len(loc))
self.assertIn(2, loc)
self.assertIn(4, loc)
self.assertIn("s", loc)
self.assertNotIn(3, loc)
self.assertNotIn(5, loc)
summary = self.collector.session_summary()
exp_req_hops = [(0, 2), (2, 4)]
exp_cont_hops = [(4, 2), (2, 0)]
self.assertSetEqual(set(exp_req_hops), set(summary['request_hops']))
self.assertSetEqual(set(exp_cont_hops), set(summary['content_hops']))
self.assertEqual(4, summary['serving_node'])
hr.process_event(1, 1, 2, True)
loc = self.view.content_locations(2)
self.assertEqual(4, len(loc))
self.assertIn(2, loc)
self.assertIn(4, loc)
self.assertIn("s", loc)
self.assertIn(3, loc)
self.assertNotIn(5, loc)
summary = self.collector.session_summary()
exp_req_hops = [(1, 3), (3, 2)]
exp_cont_hops = [(2, 3), (3, 1)]
self.assertSetEqual(set(exp_req_hops), set(summary['request_hops']))
self.assertSetEqual(set(exp_cont_hops), set(summary['content_hops']))
self.assertEqual(2, summary['serving_node'])
hr.process_event(1, 1, 2, True)
loc = self.view.content_locations(2)
self.assertEqual(4, len(loc))
self.assertIn(2, loc)
self.assertIn(4, loc)
self.assertIn("s", loc)
self.assertIn(3, loc)
self.assertNotIn(5, loc)
summary = self.collector.session_summary()
exp_req_hops = [(1, 3)]
exp_cont_hops = [(3, 1)]
self.assertSetEqual(set(exp_req_hops), set(summary['request_hops']))
self.assertSetEqual(set(exp_cont_hops), set(summary['content_hops']))
self.assertEqual(3, summary['serving_node'])
class TestPartition(unittest.TestCase):
@classmethod
def partition_topology(cls):
#
# +-- s1 --+
# / | \
# c1-----[]----c2
# / \
# r1 r2
#
topo = fnss.Topology()
icr_candidates = ["c1", "router", "c2"]
nx.add_path(topo, icr_candidates)
topo.add_edge("r1", "router")
topo.add_edge("r2", "router")
topo.add_edge("c1", "s1")
topo.add_edge("c2", "s1")
topo.graph['icr_candidates'] = set(icr_candidates)
contents = (1, 2, 3, 4)
for router in icr_candidates:
if router in ("c1", "c2"):
props = {'cache_size': 1}
fnss.add_stack(topo, router, 'router', **props)
for src in ['s1']:
fnss.add_stack(topo, src, 'source', {'contents': contents})
for rcv in ['r1', 'r2']:
fnss.add_stack(topo, rcv, 'receiver')
topo.graph['cache_assignment'] = {"r1": "c1", "r2": "c2"}
return IcnTopology(topo)
def setUp(self):
topology = self.partition_topology()
model = NetworkModel(topology, cache_policy={'name': 'FIFO'})
self.view = NetworkView(model)
self.controller = NetworkController(model)
self.collector = DummyCollector(self.view)
self.controller.attach_collector(self.collector)
def test(self):
hr = strategy.Partition(self.view, self.controller)
# receiver 0 requests 2, expect miss
hr.process_event(1, "r1", 2, True)
loc = self.view.content_locations(2)
self.assertEqual(2, len(loc))
self.assertIn("s1", loc)
self.assertIn("c1", loc)
self.assertNotIn("c2", loc)
summary = self.collector.session_summary()
exp_req_hops = [("r1", "router"), ("router", "c1"), ("c1", "s1")]
exp_cont_hops = [("s1", "c1"), ("c1", "router"), ("router", "r1")]
self.assertSetEqual(set(exp_req_hops), set(summary['request_hops']))
self.assertSetEqual(set(exp_cont_hops), set(summary['content_hops']))
self.assertEqual("s1", summary['serving_node'])
# receiver 0 requests 2, expect hit
hr.process_event(1, "r1", 2, True)
loc = self.view.content_locations(2)
self.assertEqual(2, len(loc))
self.assertIn("s1", loc)
self.assertIn("c1", loc)
self.assertNotIn("c2", loc)
summary = self.collector.session_summary()
exp_req_hops = [("r1", "router"), ("router", "c1")]
exp_cont_hops = [("c1", "router"), ("router", "r1")]
self.assertSetEqual(set(exp_req_hops), set(summary['request_hops']))
self.assertSetEqual(set(exp_cont_hops), set(summary['content_hops']))
self.assertEqual("c1", summary['serving_node'])
# Now try with other partition
hr.process_event(1, "r2", 2, True)
loc = self.view.content_locations(2)
self.assertEqual(3, len(loc))
self.assertIn("s1", loc)
self.assertIn("c1", loc)
self.assertIn("c2", loc)
summary = self.collector.session_summary()
exp_req_hops = [("r2", "router"), ("router", "c2"), ("c2", "s1")]
exp_cont_hops = [("s1", "c2"), ("c2", "router"), ("router", "r2")]
self.assertSetEqual(set(exp_req_hops), set(summary['request_hops']))
self.assertSetEqual(set(exp_cont_hops), set(summary['content_hops']))
self.assertEqual("s1", summary['serving_node'])
hr.process_event(1, "r2", 2, True)
loc = self.view.content_locations(2)
self.assertEqual(3, len(loc))
self.assertIn("s1", loc)
self.assertIn("c1", loc)
self.assertIn("c2", loc)
summary = self.collector.session_summary()
exp_req_hops = [("r2", "router"), ("router", "c2")]
exp_cont_hops = [("c2", "router"), ("router", "r2")]
self.assertSetEqual(set(exp_req_hops), set(summary['request_hops']))
self.assertSetEqual(set(exp_cont_hops), set(summary['content_hops']))
self.assertEqual("c2", summary['serving_node'])
class TestOnPath(unittest.TestCase):
@classmethod
def on_path_topology(cls):
"""Return topology for testing on-path caching strategies
"""
# Topology sketch
#
# 0 ---- 1 ---- 2 ---- 3 ---- 4
# |
# |
# 5
#
topology = IcnTopology(fnss.line_topology(5))
topology.add_edge(2, 5)
source = 4
receivers = (0, 5)
caches = (1, 2, 3)
contents = caches
fnss.add_stack(topology, source, 'source', {'contents': contents})
for v in caches:
fnss.add_stack(topology, v, 'router', {'cache_size': 1})
for v in receivers:
fnss.add_stack(topology, v, 'receiver', {})
return topology
def setUp(self):
topology = self.on_path_topology()
model = NetworkModel(topology, cache_policy={'name': 'FIFO'})
self.view = NetworkView(model)
self.controller = NetworkController(model)
self.collector = DummyCollector(self.view)
self.controller.attach_collector(self.collector)
def test_lce_same_content(self):
hr = strategy.LeaveCopyEverywhere(self.view, self.controller)
# receiver 0 requests 2, expect miss
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEqual(len(loc), 4)
self.assertIn(1, loc)
self.assertIn(2, loc)
self.assertIn(3, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = [(0, 1), (1, 2), (2, 3), (3, 4)]
exp_cont_hops = [(4, 3), (3, 2), (2, 1), (1, 0)]
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(set(exp_req_hops), set(req_hops))
self.assertSetEqual(set(exp_cont_hops), set(cont_hops))
# receiver 0 requests 2, expect hit
hr.process_event(1, 5, 2, True)
loc = self.view.content_locations(2)
self.assertEqual(len(loc), 4)
self.assertIn(1, loc)
self.assertIn(2, loc)
self.assertIn(3, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((5, 2), ))
exp_cont_hops = set(((2, 5), ))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
def test_lce_different_content(self):
hr = strategy.LeaveCopyEverywhere(self.view, self.controller)
# receiver 0 requests 2, expect miss
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEqual(len(loc), 4)
self.assertIn(1, loc)
self.assertIn(2, loc)
self.assertIn(3, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = [(0, 1), (1, 2), (2, 3), (3, 4)]
exp_cont_hops = [(4, 3), (3, 2), (2, 1), (1, 0)]
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(set(exp_req_hops), set(req_hops))
self.assertSetEqual(set(exp_cont_hops), set(cont_hops))
# request content 3 from 5
hr.process_event(1, 5, 3, True)
loc = self.view.content_locations(3)
self.assertEqual(len(loc), 3)
self.assertIn(2, loc)
self.assertIn(3, loc)
self.assertIn(4, loc)
loc = self.view.content_locations(2)
self.assertEqual(len(loc), 2)
self.assertIn(1, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = [(5, 2), (2, 3), (3, 4)]
exp_cont_hops = [(4, 3), (3, 2), (2, 5)]
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(set(exp_req_hops), set(req_hops))
self.assertSetEqual(set(exp_cont_hops), set(cont_hops))
# request content 3 from , hit in 2
hr.process_event(1, 0, 3, True)
loc = self.view.content_locations(3)
self.assertEqual(len(loc), 4)
self.assertIn(1, loc)
self.assertIn(2, loc)
self.assertIn(3, loc)
self.assertIn(4, loc)
loc = self.view.content_locations(2)
self.assertEqual(len(loc), 1)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((0, 1), (1, 2)))
exp_cont_hops = set(((2, 1), (1, 0)))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
def test_edge(self):
hr = strategy.Edge(self.view, self.controller)
# receiver 0 requests 2, expect miss
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEqual(len(loc), 2)
self.assertIn(1, loc)
self.assertNotIn(2, loc)
self.assertNotIn(3, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = [(0, 1), (1, 2), (2, 3), (3, 4)]
exp_cont_hops = [(4, 3), (3, 2), (2, 1), (1, 0)]
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(set(exp_req_hops), set(req_hops))
self.assertSetEqual(set(exp_cont_hops), set(cont_hops))
self.assertEqual(4, summary['serving_node'])
# receiver 0 requests 2, expect hit
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEqual(len(loc), 2)
self.assertIn(1, loc)
self.assertNotIn(2, loc)
self.assertNotIn(3, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = [(0, 1)]
exp_cont_hops = [(1, 0)]
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(set(exp_req_hops), set(req_hops))
self.assertSetEqual(set(exp_cont_hops), set(cont_hops))
self.assertEqual(1, summary['serving_node'])
hr.process_event(1, 5, 2, True)
loc = self.view.content_locations(2)
self.assertEqual(len(loc), 3)
self.assertIn(1, loc)
self.assertIn(2, loc)
self.assertNotIn(3, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = [(5, 2), (2, 3), (3, 4)]
exp_cont_hops = [(4, 3), (3, 2), (2, 5)]
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(set(exp_req_hops), set(req_hops))
self.assertSetEqual(set(exp_cont_hops), set(cont_hops))
self.assertEqual(4, summary['serving_node'])
hr.process_event(1, 5, 2, True)
loc = self.view.content_locations(2)
self.assertEqual(len(loc), 3)
self.assertIn(1, loc)
self.assertIn(2, loc)
self.assertNotIn(3, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = [(5, 2)]
exp_cont_hops = [(2, 5)]
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(set(exp_req_hops), set(req_hops))
self.assertSetEqual(set(exp_cont_hops), set(cont_hops))
self.assertEqual(2, summary['serving_node'])
def test_lcd(self):
hr = strategy.LeaveCopyDown(self.view, self.controller)
# receiver 0 requests 2, expect miss
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEqual(len(loc), 2)
self.assertIn(3, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = [(0, 1), (1, 2), (2, 3), (3, 4)]
exp_cont_hops = [(4, 3), (3, 2), (2, 1), (1, 0)]
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(set(exp_req_hops), set(req_hops))
self.assertSetEqual(set(exp_cont_hops), set(cont_hops))
# receiver 0 requests 2, expect hit in 3
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEqual(len(loc), 3)
self.assertIn(2, loc)
self.assertIn(3, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((0, 1), (1, 2), (2, 3)))
exp_cont_hops = set(((3, 2), (2, 1), (1, 0)))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
# receiver 0 requests 2, expect hit in 2
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEqual(len(loc), 4)
self.assertIn(1, loc)
self.assertIn(2, loc)
self.assertIn(3, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = [(0, 1), (1, 2)]
exp_cont_hops = [(2, 1), (1, 0)]
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(set(exp_req_hops), set(req_hops))
self.assertSetEqual(set(exp_cont_hops), set(cont_hops))
# receiver 0 requests 2, expect hit in 1
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEqual(len(loc), 4)
self.assertIn(1, loc)
self.assertIn(2, loc)
self.assertIn(3, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = [(0, 1)]
exp_cont_hops = [(1, 0)]
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(set(exp_req_hops), set(req_hops))
self.assertSetEqual(set(exp_cont_hops), set(cont_hops))
# receiver 0 requests 3, expect miss and eviction of 2 from 3
hr.process_event(1, 0, 3, True)
loc = self.view.content_locations(2)
self.assertEqual(len(loc), 3)
self.assertIn(1, loc)
self.assertIn(2, loc)
self.assertIn(4, loc)
loc = self.view.content_locations(3)
self.assertEqual(len(loc), 2)
self.assertIn(3, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = [(0, 1), (1, 2), (2, 3), (3, 4)]
exp_cont_hops = [(4, 3), (3, 2), (2, 1), (1, 0)]
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(set(exp_req_hops), set(req_hops))
self.assertSetEqual(set(exp_cont_hops), set(cont_hops))
def test_cl4m(self):
hr = strategy.CacheLessForMore(self.view, self.controller)
# receiver 0 requests 2, expect miss
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEqual(len(loc), 2)
self.assertIn(2, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = [(0, 1), (1, 2), (2, 3), (3, 4)]
exp_cont_hops = [(4, 3), (3, 2), (2, 1), (1, 0)]
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(set(exp_req_hops), set(req_hops))
self.assertSetEqual(set(exp_cont_hops), set(cont_hops))
# receiver 0 requests 2, expect hit
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEqual(len(loc), 3)
self.assertIn(1, loc)
self.assertIn(2, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = [(0, 1), (1, 2)]
exp_cont_hops = [(2, 1), (1, 0)]
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(set(exp_req_hops), set(req_hops))
self.assertSetEqual(set(exp_cont_hops), set(cont_hops))
# receiver 0 requests 3, expect miss
hr.process_event(1, 0, 3, True)
loc = self.view.content_locations(2)
self.assertEqual(len(loc), 2)
self.assertIn(1, loc)
self.assertIn(4, loc)
loc = self.view.content_locations(3)
self.assertEqual(len(loc), 2)
self.assertIn(2, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = [(0, 1), (1, 2), (2, 3), (3, 4)]
exp_cont_hops = [(4, 3), (3, 2), (2, 1), (1, 0)]
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(set(exp_req_hops), set(req_hops))
self.assertSetEqual(set(exp_cont_hops), set(cont_hops))
def test_random_choice(self):
hr = strategy.RandomChoice(self.view, self.controller)
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEqual(len(loc), 2)
self.assertIn(4, loc)
summary = self.collector.session_summary()
self.assertEqual(4, summary['serving_node'])
def test_random_bernoulli(self):
hr = strategy.RandomBernoulli(self.view, self.controller)
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertIn(4, loc)
summary = self.collector.session_summary()
self.assertEqual(4, summary['serving_node'])
def test_random_bernoulli_p_0(self):
hr = strategy.RandomBernoulli(self.view, self.controller, p=0)
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertNotIn(1, loc)
self.assertNotIn(2, loc)
self.assertNotIn(3, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
self.assertEqual(4, summary['serving_node'])
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertNotIn(1, loc)
self.assertNotIn(2, loc)
self.assertNotIn(3, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
self.assertEqual(4, summary['serving_node'])
def test_random_bernoulli_p_1(self):
hr = strategy.RandomBernoulli(self.view, self.controller, p=1)
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertIn(1, loc)
self.assertIn(2, loc)
self.assertIn(3, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
self.assertEqual(4, summary['serving_node'])
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertIn(1, loc)
self.assertIn(2, loc)
self.assertIn(3, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
self.assertEqual(1, summary['serving_node'])
class TestHashrouting(unittest.TestCase):
@classmethod
def setUpClass(cls):
pass
@classmethod
def tearDownClass(cls):
pass
def setUp(self):
topology = off_path_topology()
model = NetworkModel(topology)
self.view = NetworkView(model)
self.controller = NetworkController(model)
self.collector = TestCollector(self.view)
self.controller.attach_collector(self.collector)
def tearDown(self):
pass
def test_hashrouting_symmetric(self):
hr = strategy.HashroutingSymmetric(self.view, self.controller)
hr.authoritative_cache = lambda x: x
# At time 1, receiver 0 requests content 2
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEquals(len(loc), 2)
self.assertIn(2, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((0, 1), (1, 2), (2, 3), (3, 4)))
exp_cont_hops = set(((4, 3), (3, 2), (2, 1), (1, 0)))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
# At time 2 repeat request, expect cache hit
hr.process_event(2, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEquals(len(loc), 2)
self.assertIn(2, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((0, 1), (1, 2)))
exp_cont_hops = set(((2, 1), (1, 0)))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
# Now request from node 6, expect hit
hr.process_event(3, 6, 2, True)
loc = self.view.content_locations(2)
self.assertEquals(len(loc), 2)
self.assertIn(2, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((6, 2),))
exp_cont_hops = set(((2, 6),))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
def test_hashrouting_asymmetric(self):
hr = strategy.HashroutingAsymmetric(self.view, self.controller)
hr.authoritative_cache = lambda x: x
# At time 1, receiver 0 requests content 2
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEquals(len(loc), 1)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((0, 1), (1, 2), (2, 3), (3, 4)))
exp_cont_hops = set(((4, 5), (5, 0)))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
# Now request from node 6, expect miss but cache insertion
hr.process_event(2, 6, 2, True)
loc = self.view.content_locations(2)
self.assertEquals(len(loc), 2)
self.assertIn(2, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((6, 2), (2, 3), (3, 4)))
exp_cont_hops = set(((4, 3), (3, 2), (2, 6)))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
# Now request from node 0 again, expect hit
hr.process_event(3, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEquals(len(loc), 2)
self.assertIn(2, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((0, 1), (1, 2)))
exp_cont_hops = set(((2, 1), (1, 0)))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
def test_hashrouting_multicast(self):
hr = strategy.HashroutingMulticast(self.view, self.controller)
hr.authoritative_cache = lambda x: x
# At time 1, receiver 0 requests content 2
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEquals(len(loc), 2)
self.assertIn(2, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((0, 1), (1, 2), (2, 3), (3, 4)))
exp_cont_hops = set(((4, 3), (3, 2), (4, 5), (5, 0)))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
# At time 2 repeat request, expect cache hit
hr.process_event(2, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEquals(len(loc), 2)
self.assertIn(2, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((0, 1), (1, 2)))
exp_cont_hops = set(((2, 1), (1, 0)))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
# Now request from node 6, expect hit
hr.process_event(3, 6, 2, True)
loc = self.view.content_locations(2)
self.assertEquals(len(loc), 2)
self.assertIn(2, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((6, 2),))
exp_cont_hops = set(((2, 6),))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
def test_hashrouting_hybrid_am(self):
hr = strategy.HashroutingHybridAM(self.view, self.controller, max_stretch=0.3)
hr.authoritative_cache = lambda x: x
# At time 1, receiver 0 requests content 2, expect asymmetric
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEquals(len(loc), 1)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((0, 1), (1, 2), (2, 3), (3, 4)))
exp_cont_hops = set(((4, 5), (5, 0)))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
# At time 2, receiver 0 requests content 3, expect multicast
hr.process_event(3, 0, 3, True)
loc = self.view.content_locations(3)
self.assertEquals(len(loc), 2)
self.assertIn(3, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((0, 1), (1, 2), (2, 3), (3, 4)))
exp_cont_hops = set(((4, 5), (5, 0), (4, 3)))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
# At time 3, receiver 0 requests content 5, expect symm = mcast = asymm
hr.process_event(3, 0, 5, True)
loc = self.view.content_locations(5)
self.assertEquals(len(loc), 2)
self.assertIn(5, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((0, 5), (5, 4)))
exp_cont_hops = set(((4, 5), (5, 0)))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
def test_hashrouting_hybrid_sm(self):
hr = strategy.HashroutingHybridSM(self.view, self.controller)
hr.authoritative_cache = lambda x: x
# At time 1, receiver 0 requests content 2, expect asymmetric
hr.process_event(1, 0, 3, True)
loc = self.view.content_locations(3)
self.assertEquals(len(loc), 2)
self.assertIn(3, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((0, 1), (1, 2), (2, 3), (3, 4)))
exp_cont_hops = set(((4, 5), (5, 0), (4, 3)))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
# At time 2, receiver 0 requests content 5, expect symm = mcast = asymm
hr.process_event(2, 0, 5, True)
loc = self.view.content_locations(5)
self.assertEquals(len(loc), 2)
self.assertIn(5, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((0, 5), (5, 4)))
exp_cont_hops = set(((4, 5), (5, 0)))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
def test_hashrouting_hybrid_sm_multi_options(self):
# NOTE: The following test case will fail because NetworkX returns as
# shortest path from 4 to 1: 4-5-0-1. There is also another shortest
# path: 4-3-2-1. The best delivery strategy overall would be multicast
# but because of NetworkX selecting the least convenient shortest path
# the computed solution is symmetric with path: 4-5-0-1-2-6.
pass
class TestOnPath(unittest.TestCase):
@classmethod
def setUpClass(cls):
pass
@classmethod
def tearDownClass(cls):
pass
def setUp(self):
topology = on_path_topology()
model = NetworkModel(topology)
self.view = NetworkView(model)
self.controller = NetworkController(model)
self.collector = TestCollector(self.view)
self.controller.attach_collector(self.collector)
def tearDown(self):
pass
def test_lce_same_content(self):
hr = strategy.LeaveCopyEverywhere(self.view, self.controller)
# receiver 0 requests 2, expect miss
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEquals(len(loc), 4)
self.assertIn(1, loc)
self.assertIn(2, loc)
self.assertIn(3, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((0, 1), (1, 2), (2, 3), (3, 4)))
exp_cont_hops = set(((4, 3), (3, 2), (2, 1), (1, 0)))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
# receiver 0 requests 2, expect hit
hr.process_event(1, 5, 2, True)
loc = self.view.content_locations(2)
self.assertEquals(len(loc), 4)
self.assertIn(1, loc)
self.assertIn(2, loc)
self.assertIn(3, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((5, 2),))
exp_cont_hops = set(((2, 5),))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
def test_lce_different_content(self):
hr = strategy.LeaveCopyEverywhere(self.view, self.controller)
# receiver 0 requests 2, expect miss
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEquals(len(loc), 4)
self.assertIn(1, loc)
self.assertIn(2, loc)
self.assertIn(3, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((0, 1), (1, 2), (2, 3), (3, 4)))
exp_cont_hops = set(((4, 3), (3, 2), (2, 1), (1, 0)))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
# request content 3 from 5
hr.process_event(1, 5, 3, True)
loc = self.view.content_locations(3)
self.assertEquals(len(loc), 3)
self.assertIn(2, loc)
self.assertIn(3, loc)
self.assertIn(4, loc)
loc = self.view.content_locations(2)
self.assertEquals(len(loc), 2)
self.assertIn(1, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((5, 2), (2, 3), (3, 4)))
exp_cont_hops = set(((4, 3), (3, 2), (2, 5)))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
# request content 3 from , hit in 2
hr.process_event(1, 0, 3, True)
loc = self.view.content_locations(3)
self.assertEquals(len(loc), 4)
self.assertIn(1, loc)
self.assertIn(2, loc)
self.assertIn(3, loc)
self.assertIn(4, loc)
loc = self.view.content_locations(2)
self.assertEquals(len(loc), 1)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((0, 1), (1, 2)))
exp_cont_hops = set(((2, 1), (1, 0)))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
def test_lcd(self):
hr = strategy.LeaveCopyDown(self.view, self.controller)
# receiver 0 requests 2, expect miss
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEquals(len(loc), 2)
self.assertIn(3, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((0, 1), (1, 2), (2, 3), (3, 4)))
exp_cont_hops = set(((4, 3), (3, 2), (2, 1), (1, 0)))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
# receiver 0 requests 2, expect hit in 3
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEquals(len(loc), 3)
self.assertIn(2, loc)
self.assertIn(3, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((0, 1), (1, 2), (2, 3)))
exp_cont_hops = set(((3, 2), (2, 1), (1, 0)))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
# receiver 0 requests 2, expect hit in 2
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEquals(len(loc), 4)
self.assertIn(1, loc)
self.assertIn(2, loc)
self.assertIn(3, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((0, 1), (1, 2),))
exp_cont_hops = set(((2, 1), (1, 0)))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
# receiver 0 requests 2, expect hit in 1
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEquals(len(loc), 4)
self.assertIn(1, loc)
self.assertIn(2, loc)
self.assertIn(3, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((0, 1),))
exp_cont_hops = set(((1, 0),))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
# receiver 0 requests 3, expect miss and eviction of 2 from 3
hr.process_event(1, 0, 3, True)
loc = self.view.content_locations(2)
self.assertEquals(len(loc), 3)
self.assertIn(1, loc)
self.assertIn(2, loc)
self.assertIn(4, loc)
loc = self.view.content_locations(3)
self.assertEquals(len(loc), 2)
self.assertIn(3, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((0, 1), (1, 2), (2, 3), (3, 4)))
exp_cont_hops = set(((4, 3), (3, 2), (2, 1), (1, 0)))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
def test_cl4m(self):
hr = strategy.CacheLessForMore(self.view, self.controller)
# receiver 0 requests 2, expect miss
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEquals(len(loc), 2)
self.assertIn(2, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((0, 1), (1, 2), (2, 3), (3, 4)))
exp_cont_hops = set(((4, 3), (3, 2), (2, 1), (1, 0)))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
# receiver 0 requests 2, expect hit
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEquals(len(loc), 3)
self.assertIn(1, loc)
self.assertIn(2, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((0, 1), (1, 2)))
exp_cont_hops = set(((2, 1), (1, 0)))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
# receiver 0 requests 3, expect miss
hr.process_event(1, 0, 3, True)
loc = self.view.content_locations(2)
self.assertEquals(len(loc), 2)
self.assertIn(1, loc)
self.assertIn(4, loc)
loc = self.view.content_locations(3)
self.assertEquals(len(loc), 2)
self.assertIn(2, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((0, 1), (1, 2), (2, 3), (3, 4)))
exp_cont_hops = set(((4, 3), (3, 2), (2, 1), (1, 0)))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
class TestHashrouting(unittest.TestCase):
@classmethod
def setUpClass(cls):
pass
@classmethod
def tearDownClass(cls):
pass
def setUp(self):
topology = off_path_topology()
model = NetworkModel(topology, cache_policy={'name': 'FIFO'})
self.view = NetworkView(model)
self.controller = NetworkController(model)
self.collector = TestCollector(self.view)
self.controller.attach_collector(self.collector)
def tearDown(self):
pass
def test_hashrouting_symmetric(self):
hr = strategy.HashroutingSymmetric(self.view, self.controller)
hr.authoritative_cache = lambda x: x
# At time 1, receiver 0 requests content 2
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEqual(len(loc), 2)
self.assertIn(2, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((0, 1), (1, 2), (2, 3), (3, 4)))
exp_cont_hops = set(((4, 3), (3, 2), (2, 1), (1, 0)))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
# At time 2 repeat request, expect cache hit
hr.process_event(2, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEqual(len(loc), 2)
self.assertIn(2, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((0, 1), (1, 2)))
exp_cont_hops = set(((2, 1), (1, 0)))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
# Now request from node 6, expect hit
hr.process_event(3, 6, 2, True)
loc = self.view.content_locations(2)
self.assertEqual(len(loc), 2)
self.assertIn(2, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((6, 2), ))
exp_cont_hops = set(((2, 6), ))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
def test_hashrouting_asymmetric(self):
hr = strategy.HashroutingAsymmetric(self.view, self.controller)
hr.authoritative_cache = lambda x: x
# At time 1, receiver 0 requests content 2
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEqual(len(loc), 1)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((0, 1), (1, 2), (2, 3), (3, 4)))
exp_cont_hops = set(((4, 5), (5, 0)))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
# Now request from node 6, expect miss but cache insertion
hr.process_event(2, 6, 2, True)
loc = self.view.content_locations(2)
self.assertEqual(len(loc), 2)
self.assertIn(2, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((6, 2), (2, 3), (3, 4)))
exp_cont_hops = set(((4, 3), (3, 2), (2, 6)))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
# Now request from node 0 again, expect hit
hr.process_event(3, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEqual(len(loc), 2)
self.assertIn(2, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((0, 1), (1, 2)))
exp_cont_hops = set(((2, 1), (1, 0)))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
def test_hashrouting_multicast(self):
hr = strategy.HashroutingMulticast(self.view, self.controller)
hr.authoritative_cache = lambda x: x
# At time 1, receiver 0 requests content 2
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEqual(len(loc), 2)
self.assertIn(2, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((0, 1), (1, 2), (2, 3), (3, 4)))
exp_cont_hops = set(((4, 3), (3, 2), (4, 5), (5, 0)))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
# At time 2 repeat request, expect cache hit
hr.process_event(2, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEqual(len(loc), 2)
self.assertIn(2, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((0, 1), (1, 2)))
exp_cont_hops = set(((2, 1), (1, 0)))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
# Now request from node 6, expect hit
hr.process_event(3, 6, 2, True)
loc = self.view.content_locations(2)
self.assertEqual(len(loc), 2)
self.assertIn(2, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((6, 2), ))
exp_cont_hops = set(((2, 6), ))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
def test_hashrouting_hybrid_am(self):
hr = strategy.HashroutingHybridAM(self.view,
self.controller,
max_stretch=0.3)
hr.authoritative_cache = lambda x: x
# At time 1, receiver 0 requests content 2, expect asymmetric
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEqual(len(loc), 1)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((0, 1), (1, 2), (2, 3), (3, 4)))
exp_cont_hops = set(((4, 5), (5, 0)))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
# At time 2, receiver 0 requests content 3, expect multicast
hr.process_event(3, 0, 3, True)
loc = self.view.content_locations(3)
self.assertEqual(len(loc), 2)
self.assertIn(3, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((0, 1), (1, 2), (2, 3), (3, 4)))
exp_cont_hops = set(((4, 5), (5, 0), (4, 3)))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
# At time 3, receiver 0 requests content 5, expect symm = mcast = asymm
hr.process_event(3, 0, 5, True)
loc = self.view.content_locations(5)
self.assertEqual(len(loc), 2)
self.assertIn(5, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((0, 5), (5, 4)))
exp_cont_hops = set(((4, 5), (5, 0)))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
def test_hashrouting_hybrid_sm(self):
hr = strategy.HashroutingHybridSM(self.view, self.controller)
hr.authoritative_cache = lambda x: x
# At time 1, receiver 0 requests content 2, expect asymmetric
hr.process_event(1, 0, 3, True)
loc = self.view.content_locations(3)
self.assertEqual(len(loc), 2)
self.assertIn(3, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((0, 1), (1, 2), (2, 3), (3, 4)))
exp_cont_hops = set(((4, 5), (5, 0), (4, 3)))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
# At time 2, receiver 0 requests content 5, expect symm = mcast = asymm
hr.process_event(2, 0, 5, True)
loc = self.view.content_locations(5)
self.assertEqual(len(loc), 2)
self.assertIn(5, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((0, 5), (5, 4)))
exp_cont_hops = set(((4, 5), (5, 0)))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
def test_hashrouting_hybrid_sm_multi_options(self):
# NOTE: The following test case will fail because NetworkX returns as
# shortest path from 4 to 1: 4-5-0-1. There is also another shortest
# path: 4-3-2-1. The best delivery strategy overall would be multicast
# but because of NetworkX selecting the least convenient shortest path
# the computed solution is symmetric with path: 4-5-0-1-2-6.
pass
class TestNrr:
"""Test suite for Nearest Replica Routing strategies"""
@classmethod
def nrr_topology(cls):
"""Return topology for testing NRR caching strategies"""
# Topology sketch
#
# 0 ---- 2----- 4
# | \
# | s
# | /
# 1 ---- 3 ---- 5
#
topology = IcnTopology(fnss.Topology())
nx.add_path(topology, [0, 2, 4, "s", 5, 3, 1])
topology.add_edge(2, 3)
receivers = (0, 1)
source = "s"
caches = (2, 3, 4, 5)
contents = (1, 2, 3, 4)
fnss.add_stack(topology, source, "source", {"contents": contents})
for v in caches:
fnss.add_stack(topology, v, "router", {"cache_size": 1})
for v in receivers:
fnss.add_stack(topology, v, "receiver", {})
fnss.set_delays_constant(topology, 1, "ms")
return topology
def setup_method(self):
topology = self.nrr_topology()
model = NetworkModel(topology, cache_policy={"name": "FIFO"})
self.view = NetworkView(model)
self.controller = NetworkController(model)
self.collector = DummyCollector(self.view)
self.controller.attach_collector(self.collector)
def test_lce(self):
hr = strategy.NearestReplicaRouting(self.view,
self.controller,
metacaching="LCE")
# receiver 0 requests 2, expect miss
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
assert 3 == len(loc)
assert 2 in loc
assert 4 in loc
assert "s" in loc
assert 3 not in loc
assert 5 not in loc
summary = self.collector.session_summary()
exp_req_hops = [(0, 2), (2, 4), (4, "s")]
exp_cont_hops = [("s", 4), (4, 2), (2, 0)]
assert set(exp_req_hops) == set(summary["request_hops"])
assert set(exp_cont_hops) == set(summary["content_hops"])
assert "s" == summary["serving_node"]
hr.process_event(1, 1, 2, True)
loc = self.view.content_locations(2)
assert 4 == len(loc)
assert 2 in loc
assert 4 in loc
assert "s" in loc
assert 3 in loc
assert 5 not in loc
summary = self.collector.session_summary()
exp_req_hops = [(1, 3), (3, 2)]
exp_cont_hops = [(2, 3), (3, 1)]
assert set(exp_req_hops) == set(summary["request_hops"])
assert set(exp_cont_hops) == set(summary["content_hops"])
assert 2 == summary["serving_node"]
hr.process_event(1, 1, 2, True)
loc = self.view.content_locations(2)
assert 4 == len(loc)
assert 2 in loc
assert 4 in loc
assert "s" in loc
assert 3 in loc
assert 5 not in loc
summary = self.collector.session_summary()
exp_req_hops = [(1, 3)]
exp_cont_hops = [(3, 1)]
assert set(exp_req_hops) == set(summary["request_hops"])
assert set(exp_cont_hops) == set(summary["content_hops"])
assert 3 == summary["serving_node"]
def test_lcd(self):
hr = strategy.NearestReplicaRouting(self.view,
self.controller,
metacaching="LCD")
# receiver 0 requests 2, expect miss
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
assert 2 == len(loc)
assert 2 not in loc
assert 4 in loc
assert "s" in loc
assert 3 not in loc
assert 5 not in loc
summary = self.collector.session_summary()
exp_req_hops = [(0, 2), (2, 4), (4, "s")]
exp_cont_hops = [("s", 4), (4, 2), (2, 0)]
assert set(exp_req_hops) == set(summary["request_hops"])
assert set(exp_cont_hops) == set(summary["content_hops"])
assert "s" == summary["serving_node"]
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
assert 3 == len(loc)
assert 2 in loc
assert 4 in loc
assert "s" in loc
assert 3 not in loc
assert 5 not in loc
summary = self.collector.session_summary()
exp_req_hops = [(0, 2), (2, 4)]
exp_cont_hops = [(4, 2), (2, 0)]
assert set(exp_req_hops) == set(summary["request_hops"])
assert set(exp_cont_hops) == set(summary["content_hops"])
assert 4 == summary["serving_node"]
hr.process_event(1, 1, 2, True)
loc = self.view.content_locations(2)
assert 4 == len(loc)
assert 2 in loc
assert 4 in loc
assert "s" in loc
assert 3 in loc
assert 5 not in loc
summary = self.collector.session_summary()
exp_req_hops = [(1, 3), (3, 2)]
exp_cont_hops = [(2, 3), (3, 1)]
assert set(exp_req_hops) == set(summary["request_hops"])
assert set(exp_cont_hops) == set(summary["content_hops"])
assert 2 == summary["serving_node"]
hr.process_event(1, 1, 2, True)
loc = self.view.content_locations(2)
assert 4 == len(loc)
assert 2 in loc
assert 4 in loc
assert "s" in loc
assert 3 in loc
assert 5 not in loc
summary = self.collector.session_summary()
exp_req_hops = [(1, 3)]
exp_cont_hops = [(3, 1)]
assert set(exp_req_hops) == set(summary["request_hops"])
assert set(exp_cont_hops) == set(summary["content_hops"])
assert 3 == summary["serving_node"]
class TestNrr(unittest.TestCase):
@classmethod
def setUpClass(cls):
pass
@classmethod
def tearDownClass(cls):
pass
def setUp(self):
topology = nrr_topology()
model = NetworkModel(topology, cache_policy={'name': 'FIFO'})
self.view = NetworkView(model)
self.controller = NetworkController(model)
self.collector = TestCollector(self.view)
self.controller.attach_collector(self.collector)
def tearDown(self):
pass
def test_lce(self):
hr = strategy.NearestReplicaRouting(self.view, self.controller, metacaching='LCE')
# receiver 0 requests 2, expect miss
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEquals(3, len(loc))
self.assertIn(2, loc)
self.assertIn(4, loc)
self.assertIn(6, loc)
self.assertNotIn(3, loc)
self.assertNotIn(5, loc)
summary = self.collector.session_summary()
exp_req_hops = [(0, 2), (2, 4), (4, 6)]
exp_cont_hops = [(6, 4), (4, 2), (2, 0)]
self.assertSetEqual(set(exp_req_hops), set(summary['request_hops']))
self.assertSetEqual(set(exp_cont_hops), set(summary['content_hops']))
self.assertEqual(6, summary['serving_node'])
# receiver 0 requests 2, expect hit
hr.process_event(1, 1, 2, True)
loc = self.view.content_locations(2)
self.assertEquals(4, len(loc))
self.assertIn(2, loc)
self.assertIn(4, loc)
self.assertIn(6, loc)
self.assertIn(3, loc)
self.assertNotIn(5, loc)
summary = self.collector.session_summary()
exp_req_hops = [(1, 3), (3, 2)]
exp_cont_hops = [(2, 3), (3, 1)]
self.assertSetEqual(set(exp_req_hops), set(summary['request_hops']))
self.assertSetEqual(set(exp_cont_hops), set(summary['content_hops']))
self.assertEqual(2, summary['serving_node'])
hr.process_event(1, 1, 2, True)
loc = self.view.content_locations(2)
self.assertEquals(4, len(loc))
self.assertIn(2, loc)
self.assertIn(4, loc)
self.assertIn(6, loc)
self.assertIn(3, loc)
self.assertNotIn(5, loc)
summary = self.collector.session_summary()
exp_req_hops = [(1, 3)]
exp_cont_hops = [(3, 1)]
self.assertSetEqual(set(exp_req_hops), set(summary['request_hops']))
self.assertSetEqual(set(exp_cont_hops), set(summary['content_hops']))
self.assertEqual(3, summary['serving_node'])
def test_lcd(self):
hr = strategy.NearestReplicaRouting(self.view, self.controller, metacaching='LCD')
# receiver 0 requests 2, expect miss
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEquals(2, len(loc))
self.assertNotIn(2, loc)
self.assertIn(4, loc)
self.assertIn(6, loc)
self.assertNotIn(3, loc)
self.assertNotIn(5, loc)
summary = self.collector.session_summary()
exp_req_hops = [(0, 2), (2, 4), (4, 6)]
exp_cont_hops = [(6, 4), (4, 2), (2, 0)]
self.assertSetEqual(set(exp_req_hops), set(summary['request_hops']))
self.assertSetEqual(set(exp_cont_hops), set(summary['content_hops']))
self.assertEqual(6, summary['serving_node'])
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEquals(3, len(loc))
self.assertIn(2, loc)
self.assertIn(4, loc)
self.assertIn(6, loc)
self.assertNotIn(3, loc)
self.assertNotIn(5, loc)
summary = self.collector.session_summary()
exp_req_hops = [(0, 2), (2, 4)]
exp_cont_hops = [(4, 2), (2, 0)]
self.assertSetEqual(set(exp_req_hops), set(summary['request_hops']))
self.assertSetEqual(set(exp_cont_hops), set(summary['content_hops']))
self.assertEqual(4, summary['serving_node'])
# receiver 0 requests 2, expect hit
hr.process_event(1, 1, 2, True)
loc = self.view.content_locations(2)
self.assertEquals(4, len(loc))
self.assertIn(2, loc)
self.assertIn(4, loc)
self.assertIn(6, loc)
self.assertIn(3, loc)
self.assertNotIn(5, loc)
summary = self.collector.session_summary()
exp_req_hops = [(1, 3), (3, 2)]
exp_cont_hops = [(2, 3), (3, 1)]
self.assertSetEqual(set(exp_req_hops), set(summary['request_hops']))
self.assertSetEqual(set(exp_cont_hops), set(summary['content_hops']))
self.assertEqual(2, summary['serving_node'])
hr.process_event(1, 1, 2, True)
loc = self.view.content_locations(2)
self.assertEquals(4, len(loc))
self.assertIn(2, loc)
self.assertIn(4, loc)
self.assertIn(6, loc)
self.assertIn(3, loc)
self.assertNotIn(5, loc)
summary = self.collector.session_summary()
exp_req_hops = [(1, 3)]
exp_cont_hops = [(3, 1)]
self.assertSetEqual(set(exp_req_hops), set(summary['request_hops']))
self.assertSetEqual(set(exp_cont_hops), set(summary['content_hops']))
self.assertEqual(3, summary['serving_node'])
class TestOnPath(unittest.TestCase):
@classmethod
def setUpClass(cls):
pass
@classmethod
def tearDownClass(cls):
pass
def setUp(self):
topology = on_path_topology()
model = NetworkModel(topology, cache_policy={'name': 'FIFO'})
self.view = NetworkView(model)
self.controller = NetworkController(model)
self.collector = TestCollector(self.view)
self.controller.attach_collector(self.collector)
def tearDown(self):
pass
def test_lce_same_content(self):
hr = strategy.LeaveCopyEverywhere(self.view, self.controller)
# receiver 0 requests 2, expect miss
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEquals(len(loc), 4)
self.assertIn(1, loc)
self.assertIn(2, loc)
self.assertIn(3, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((0, 1), (1, 2), (2, 3), (3, 4)))
exp_cont_hops = set(((4, 3), (3, 2), (2, 1), (1, 0)))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
# receiver 0 requests 2, expect hit
hr.process_event(1, 5, 2, True)
loc = self.view.content_locations(2)
self.assertEquals(len(loc), 4)
self.assertIn(1, loc)
self.assertIn(2, loc)
self.assertIn(3, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((5, 2),))
exp_cont_hops = set(((2, 5),))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
def test_lce_different_content(self):
hr = strategy.LeaveCopyEverywhere(self.view, self.controller)
# receiver 0 requests 2, expect miss
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEquals(len(loc), 4)
self.assertIn(1, loc)
self.assertIn(2, loc)
self.assertIn(3, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((0, 1), (1, 2), (2, 3), (3, 4)))
exp_cont_hops = set(((4, 3), (3, 2), (2, 1), (1, 0)))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
# request content 3 from 5
hr.process_event(1, 5, 3, True)
loc = self.view.content_locations(3)
self.assertEquals(len(loc), 3)
self.assertIn(2, loc)
self.assertIn(3, loc)
self.assertIn(4, loc)
loc = self.view.content_locations(2)
self.assertEquals(len(loc), 2)
self.assertIn(1, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((5, 2), (2, 3), (3, 4)))
exp_cont_hops = set(((4, 3), (3, 2), (2, 5)))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
# request content 3 from , hit in 2
hr.process_event(1, 0, 3, True)
loc = self.view.content_locations(3)
self.assertEquals(len(loc), 4)
self.assertIn(1, loc)
self.assertIn(2, loc)
self.assertIn(3, loc)
self.assertIn(4, loc)
loc = self.view.content_locations(2)
self.assertEquals(len(loc), 1)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((0, 1), (1, 2)))
exp_cont_hops = set(((2, 1), (1, 0)))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
def test_edge(self):
hr = strategy.Edge(self.view, self.controller)
# receiver 0 requests 2, expect miss
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEquals(len(loc), 2)
self.assertIn(1, loc)
self.assertNotIn(2, loc)
self.assertNotIn(3, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = [(0, 1), (1, 2), (2, 3), (3, 4)]
exp_cont_hops = [(4, 3), (3, 2), (2, 1), (1, 0)]
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(set(exp_req_hops), set(req_hops))
self.assertSetEqual(set(exp_cont_hops), set(cont_hops))
self.assertEqual(4, summary['serving_node'])
# receiver 0 requests 2, expect hit
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEquals(len(loc), 2)
self.assertIn(1, loc)
self.assertNotIn(2, loc)
self.assertNotIn(3, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = [(0, 1)]
exp_cont_hops = [(1, 0)]
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(set(exp_req_hops), set(req_hops))
self.assertSetEqual(set(exp_cont_hops), set(cont_hops))
self.assertEqual(1, summary['serving_node'])
hr.process_event(1, 5, 2, True)
loc = self.view.content_locations(2)
self.assertEquals(len(loc), 3)
self.assertIn(1, loc)
self.assertIn(2, loc)
self.assertNotIn(3, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = [(5, 2), (2, 3), (3, 4)]
exp_cont_hops = [(4, 3), (3, 2), (2, 5)]
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(set(exp_req_hops), set(req_hops))
self.assertSetEqual(set(exp_cont_hops), set(cont_hops))
self.assertEqual(4, summary['serving_node'])
hr.process_event(1, 5, 2, True)
loc = self.view.content_locations(2)
self.assertEquals(len(loc), 3)
self.assertIn(1, loc)
self.assertIn(2, loc)
self.assertNotIn(3, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = [(5, 2)]
exp_cont_hops = [(2, 5)]
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(set(exp_req_hops), set(req_hops))
self.assertSetEqual(set(exp_cont_hops), set(cont_hops))
self.assertEqual(2, summary['serving_node'])
def test_lcd(self):
hr = strategy.LeaveCopyDown(self.view, self.controller)
# receiver 0 requests 2, expect miss
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEquals(len(loc), 2)
self.assertIn(3, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((0, 1), (1, 2), (2, 3), (3, 4)))
exp_cont_hops = set(((4, 3), (3, 2), (2, 1), (1, 0)))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
# receiver 0 requests 2, expect hit in 3
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEquals(len(loc), 3)
self.assertIn(2, loc)
self.assertIn(3, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((0, 1), (1, 2), (2, 3)))
exp_cont_hops = set(((3, 2), (2, 1), (1, 0)))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
# receiver 0 requests 2, expect hit in 2
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEquals(len(loc), 4)
self.assertIn(1, loc)
self.assertIn(2, loc)
self.assertIn(3, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((0, 1), (1, 2),))
exp_cont_hops = set(((2, 1), (1, 0)))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
# receiver 0 requests 2, expect hit in 1
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEquals(len(loc), 4)
self.assertIn(1, loc)
self.assertIn(2, loc)
self.assertIn(3, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((0, 1),))
exp_cont_hops = set(((1, 0),))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
# receiver 0 requests 3, expect miss and eviction of 2 from 3
hr.process_event(1, 0, 3, True)
loc = self.view.content_locations(2)
self.assertEquals(len(loc), 3)
self.assertIn(1, loc)
self.assertIn(2, loc)
self.assertIn(4, loc)
loc = self.view.content_locations(3)
self.assertEquals(len(loc), 2)
self.assertIn(3, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((0, 1), (1, 2), (2, 3), (3, 4)))
exp_cont_hops = set(((4, 3), (3, 2), (2, 1), (1, 0)))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
def test_cl4m(self):
hr = strategy.CacheLessForMore(self.view, self.controller)
# receiver 0 requests 2, expect miss
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEquals(len(loc), 2)
self.assertIn(2, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((0, 1), (1, 2), (2, 3), (3, 4)))
exp_cont_hops = set(((4, 3), (3, 2), (2, 1), (1, 0)))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
# receiver 0 requests 2, expect hit
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEquals(len(loc), 3)
self.assertIn(1, loc)
self.assertIn(2, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((0, 1), (1, 2)))
exp_cont_hops = set(((2, 1), (1, 0)))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
# receiver 0 requests 3, expect miss
hr.process_event(1, 0, 3, True)
loc = self.view.content_locations(2)
self.assertEquals(len(loc), 2)
self.assertIn(1, loc)
self.assertIn(4, loc)
loc = self.view.content_locations(3)
self.assertEquals(len(loc), 2)
self.assertIn(2, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((0, 1), (1, 2), (2, 3), (3, 4)))
exp_cont_hops = set(((4, 3), (3, 2), (2, 1), (1, 0)))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
def test_random_choice(self):
hr = strategy.RandomChoice(self.view, self.controller)
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEquals(len(loc), 2)
self.assertIn(4, loc)
summary = self.collector.session_summary()
self.assertEqual(4, summary['serving_node'])
def test_random_bernoulli(self):
hr = strategy.RandomBernoulli(self.view, self.controller)
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertIn(4, loc)
summary = self.collector.session_summary()
self.assertEqual(4, summary['serving_node'])
def test_random_bernoulli_p_0(self):
hr = strategy.RandomBernoulli(self.view, self.controller, p=0)
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertNotIn(1, loc)
self.assertNotIn(2, loc)
self.assertNotIn(3, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
self.assertEqual(4, summary['serving_node'])
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertNotIn(1, loc)
self.assertNotIn(2, loc)
self.assertNotIn(3, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
self.assertEqual(4, summary['serving_node'])
def test_random_bernoulli_p_1(self):
hr = strategy.RandomBernoulli(self.view, self.controller, p=1)
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertIn(1, loc)
self.assertIn(2, loc)
self.assertIn(3, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
self.assertEqual(4, summary['serving_node'])
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertIn(1, loc)
self.assertIn(2, loc)
self.assertIn(3, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
self.assertEqual(1, summary['serving_node'])
class TestNrr(unittest.TestCase):
"""Test suite for Nearest Replica Routing strategies"""
@classmethod
def nrr_topology(cls):
"""Return topology for testing NRR caching strategies
"""
# Topology sketch
#
# 0 ---- 2----- 4
# | \
# | s
# | /
# 1 ---- 3 ---- 5
#
topology = IcnTopology(fnss.Topology())
nx.add_path(topology, [0, 2, 4, "s", 5, 3, 1])
topology.add_edge(2, 3)
receivers = (0, 1)
source = "s"
caches = (2, 3, 4, 5)
contents = (1, 2, 3, 4)
fnss.add_stack(topology, source, 'source', {'contents': contents})
for v in caches:
fnss.add_stack(topology, v, 'router', {'cache_size': 1})
for v in receivers:
fnss.add_stack(topology, v, 'receiver', {})
fnss.set_delays_constant(topology, 1, 'ms')
return topology
def setUp(self):
topology = self.nrr_topology()
model = NetworkModel(topology, cache_policy={'name': 'FIFO'})
self.view = NetworkView(model)
self.controller = NetworkController(model)
self.collector = DummyCollector(self.view)
self.controller.attach_collector(self.collector)
def test_lce(self):
hr = strategy.NearestReplicaRouting(self.view, self.controller, metacaching='LCE')
# receiver 0 requests 2, expect miss
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEqual(3, len(loc))
self.assertIn(2, loc)
self.assertIn(4, loc)
self.assertIn("s", loc)
self.assertNotIn(3, loc)
self.assertNotIn(5, loc)
summary = self.collector.session_summary()
exp_req_hops = [(0, 2), (2, 4), (4, "s")]
exp_cont_hops = [("s", 4), (4, 2), (2, 0)]
self.assertSetEqual(set(exp_req_hops), set(summary['request_hops']))
self.assertSetEqual(set(exp_cont_hops), set(summary['content_hops']))
self.assertEqual("s", summary['serving_node'])
hr.process_event(1, 1, 2, True)
loc = self.view.content_locations(2)
self.assertEqual(4, len(loc))
self.assertIn(2, loc)
self.assertIn(4, loc)
self.assertIn("s", loc)
self.assertIn(3, loc)
self.assertNotIn(5, loc)
summary = self.collector.session_summary()
exp_req_hops = [(1, 3), (3, 2)]
exp_cont_hops = [(2, 3), (3, 1)]
self.assertSetEqual(set(exp_req_hops), set(summary['request_hops']))
self.assertSetEqual(set(exp_cont_hops), set(summary['content_hops']))
self.assertEqual(2, summary['serving_node'])
hr.process_event(1, 1, 2, True)
loc = self.view.content_locations(2)
self.assertEqual(4, len(loc))
self.assertIn(2, loc)
self.assertIn(4, loc)
self.assertIn("s", loc)
self.assertIn(3, loc)
self.assertNotIn(5, loc)
summary = self.collector.session_summary()
exp_req_hops = [(1, 3)]
exp_cont_hops = [(3, 1)]
self.assertSetEqual(set(exp_req_hops), set(summary['request_hops']))
self.assertSetEqual(set(exp_cont_hops), set(summary['content_hops']))
self.assertEqual(3, summary['serving_node'])
def test_lcd(self):
hr = strategy.NearestReplicaRouting(self.view, self.controller, metacaching='LCD')
# receiver 0 requests 2, expect miss
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEqual(2, len(loc))
self.assertNotIn(2, loc)
self.assertIn(4, loc)
self.assertIn("s", loc)
self.assertNotIn(3, loc)
self.assertNotIn(5, loc)
summary = self.collector.session_summary()
exp_req_hops = [(0, 2), (2, 4), (4, "s")]
exp_cont_hops = [("s", 4), (4, 2), (2, 0)]
self.assertSetEqual(set(exp_req_hops), set(summary['request_hops']))
self.assertSetEqual(set(exp_cont_hops), set(summary['content_hops']))
self.assertEqual("s", summary['serving_node'])
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEqual(3, len(loc))
self.assertIn(2, loc)
self.assertIn(4, loc)
self.assertIn("s", loc)
self.assertNotIn(3, loc)
self.assertNotIn(5, loc)
summary = self.collector.session_summary()
exp_req_hops = [(0, 2), (2, 4)]
exp_cont_hops = [(4, 2), (2, 0)]
self.assertSetEqual(set(exp_req_hops), set(summary['request_hops']))
self.assertSetEqual(set(exp_cont_hops), set(summary['content_hops']))
self.assertEqual(4, summary['serving_node'])
hr.process_event(1, 1, 2, True)
loc = self.view.content_locations(2)
self.assertEqual(4, len(loc))
self.assertIn(2, loc)
self.assertIn(4, loc)
self.assertIn("s", loc)
self.assertIn(3, loc)
self.assertNotIn(5, loc)
summary = self.collector.session_summary()
exp_req_hops = [(1, 3), (3, 2)]
exp_cont_hops = [(2, 3), (3, 1)]
self.assertSetEqual(set(exp_req_hops), set(summary['request_hops']))
self.assertSetEqual(set(exp_cont_hops), set(summary['content_hops']))
self.assertEqual(2, summary['serving_node'])
hr.process_event(1, 1, 2, True)
loc = self.view.content_locations(2)
self.assertEqual(4, len(loc))
self.assertIn(2, loc)
self.assertIn(4, loc)
self.assertIn("s", loc)
self.assertIn(3, loc)
self.assertNotIn(5, loc)
summary = self.collector.session_summary()
exp_req_hops = [(1, 3)]
exp_cont_hops = [(3, 1)]
self.assertSetEqual(set(exp_req_hops), set(summary['request_hops']))
self.assertSetEqual(set(exp_cont_hops), set(summary['content_hops']))
self.assertEqual(3, summary['serving_node'])
class TestOnPath(unittest.TestCase):
@classmethod
def setUpClass(cls):
pass
@classmethod
def tearDownClass(cls):
pass
def setUp(self):
topology = on_path_topology()
model = NetworkModel(topology, cache_policy={'name': 'FIFO'})
self.view = NetworkView(model)
self.controller = NetworkController(model)
self.collector = TestCollector(self.view)
self.controller.attach_collector(self.collector)
def tearDown(self):
pass
def test_lce_same_content(self):
hr = strategy.LeaveCopyEverywhere(self.view, self.controller)
# receiver 0 requests 2, expect miss
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEqual(len(loc), 4)
self.assertIn(1, loc)
self.assertIn(2, loc)
self.assertIn(3, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((0, 1), (1, 2), (2, 3), (3, 4)))
exp_cont_hops = set(((4, 3), (3, 2), (2, 1), (1, 0)))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
# receiver 0 requests 2, expect hit
hr.process_event(1, 5, 2, True)
loc = self.view.content_locations(2)
self.assertEqual(len(loc), 4)
self.assertIn(1, loc)
self.assertIn(2, loc)
self.assertIn(3, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((5, 2), ))
exp_cont_hops = set(((2, 5), ))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
def test_lce_different_content(self):
hr = strategy.LeaveCopyEverywhere(self.view, self.controller)
# receiver 0 requests 2, expect miss
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEqual(len(loc), 4)
self.assertIn(1, loc)
self.assertIn(2, loc)
self.assertIn(3, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((0, 1), (1, 2), (2, 3), (3, 4)))
exp_cont_hops = set(((4, 3), (3, 2), (2, 1), (1, 0)))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
# request content 3 from 5
hr.process_event(1, 5, 3, True)
loc = self.view.content_locations(3)
self.assertEqual(len(loc), 3)
self.assertIn(2, loc)
self.assertIn(3, loc)
self.assertIn(4, loc)
loc = self.view.content_locations(2)
self.assertEqual(len(loc), 2)
self.assertIn(1, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((5, 2), (2, 3), (3, 4)))
exp_cont_hops = set(((4, 3), (3, 2), (2, 5)))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
# request content 3 from , hit in 2
hr.process_event(1, 0, 3, True)
loc = self.view.content_locations(3)
self.assertEqual(len(loc), 4)
self.assertIn(1, loc)
self.assertIn(2, loc)
self.assertIn(3, loc)
self.assertIn(4, loc)
loc = self.view.content_locations(2)
self.assertEqual(len(loc), 1)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((0, 1), (1, 2)))
exp_cont_hops = set(((2, 1), (1, 0)))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
def test_edge(self):
hr = strategy.Edge(self.view, self.controller)
# receiver 0 requests 2, expect miss
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEqual(len(loc), 2)
self.assertIn(1, loc)
self.assertNotIn(2, loc)
self.assertNotIn(3, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = [(0, 1), (1, 2), (2, 3), (3, 4)]
exp_cont_hops = [(4, 3), (3, 2), (2, 1), (1, 0)]
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(set(exp_req_hops), set(req_hops))
self.assertSetEqual(set(exp_cont_hops), set(cont_hops))
self.assertEqual(4, summary['serving_node'])
# receiver 0 requests 2, expect hit
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEqual(len(loc), 2)
self.assertIn(1, loc)
self.assertNotIn(2, loc)
self.assertNotIn(3, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = [(0, 1)]
exp_cont_hops = [(1, 0)]
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(set(exp_req_hops), set(req_hops))
self.assertSetEqual(set(exp_cont_hops), set(cont_hops))
self.assertEqual(1, summary['serving_node'])
hr.process_event(1, 5, 2, True)
loc = self.view.content_locations(2)
self.assertEqual(len(loc), 3)
self.assertIn(1, loc)
self.assertIn(2, loc)
self.assertNotIn(3, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = [(5, 2), (2, 3), (3, 4)]
exp_cont_hops = [(4, 3), (3, 2), (2, 5)]
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(set(exp_req_hops), set(req_hops))
self.assertSetEqual(set(exp_cont_hops), set(cont_hops))
self.assertEqual(4, summary['serving_node'])
hr.process_event(1, 5, 2, True)
loc = self.view.content_locations(2)
self.assertEqual(len(loc), 3)
self.assertIn(1, loc)
self.assertIn(2, loc)
self.assertNotIn(3, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = [(5, 2)]
exp_cont_hops = [(2, 5)]
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(set(exp_req_hops), set(req_hops))
self.assertSetEqual(set(exp_cont_hops), set(cont_hops))
self.assertEqual(2, summary['serving_node'])
def test_lcd(self):
hr = strategy.LeaveCopyDown(self.view, self.controller)
# receiver 0 requests 2, expect miss
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEqual(len(loc), 2)
self.assertIn(3, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((0, 1), (1, 2), (2, 3), (3, 4)))
exp_cont_hops = set(((4, 3), (3, 2), (2, 1), (1, 0)))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
# receiver 0 requests 2, expect hit in 3
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEqual(len(loc), 3)
self.assertIn(2, loc)
self.assertIn(3, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((0, 1), (1, 2), (2, 3)))
exp_cont_hops = set(((3, 2), (2, 1), (1, 0)))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
# receiver 0 requests 2, expect hit in 2
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEqual(len(loc), 4)
self.assertIn(1, loc)
self.assertIn(2, loc)
self.assertIn(3, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set((
(0, 1),
(1, 2),
))
exp_cont_hops = set(((2, 1), (1, 0)))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
# receiver 0 requests 2, expect hit in 1
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEqual(len(loc), 4)
self.assertIn(1, loc)
self.assertIn(2, loc)
self.assertIn(3, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((0, 1), ))
exp_cont_hops = set(((1, 0), ))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
# receiver 0 requests 3, expect miss and eviction of 2 from 3
hr.process_event(1, 0, 3, True)
loc = self.view.content_locations(2)
self.assertEqual(len(loc), 3)
self.assertIn(1, loc)
self.assertIn(2, loc)
self.assertIn(4, loc)
loc = self.view.content_locations(3)
self.assertEqual(len(loc), 2)
self.assertIn(3, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((0, 1), (1, 2), (2, 3), (3, 4)))
exp_cont_hops = set(((4, 3), (3, 2), (2, 1), (1, 0)))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
def test_cl4m(self):
hr = strategy.CacheLessForMore(self.view, self.controller)
# receiver 0 requests 2, expect miss
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEqual(len(loc), 2)
self.assertIn(2, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((0, 1), (1, 2), (2, 3), (3, 4)))
exp_cont_hops = set(((4, 3), (3, 2), (2, 1), (1, 0)))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
# receiver 0 requests 2, expect hit
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEqual(len(loc), 3)
self.assertIn(1, loc)
self.assertIn(2, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((0, 1), (1, 2)))
exp_cont_hops = set(((2, 1), (1, 0)))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
# receiver 0 requests 3, expect miss
hr.process_event(1, 0, 3, True)
loc = self.view.content_locations(2)
self.assertEqual(len(loc), 2)
self.assertIn(1, loc)
self.assertIn(4, loc)
loc = self.view.content_locations(3)
self.assertEqual(len(loc), 2)
self.assertIn(2, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((0, 1), (1, 2), (2, 3), (3, 4)))
exp_cont_hops = set(((4, 3), (3, 2), (2, 1), (1, 0)))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
def test_random_choice(self):
hr = strategy.RandomChoice(self.view, self.controller)
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEqual(len(loc), 2)
self.assertIn(4, loc)
summary = self.collector.session_summary()
self.assertEqual(4, summary['serving_node'])
def test_random_bernoulli(self):
hr = strategy.RandomBernoulli(self.view, self.controller)
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertIn(4, loc)
summary = self.collector.session_summary()
self.assertEqual(4, summary['serving_node'])
def test_random_bernoulli_p_0(self):
hr = strategy.RandomBernoulli(self.view, self.controller, p=0)
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertNotIn(1, loc)
self.assertNotIn(2, loc)
self.assertNotIn(3, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
self.assertEqual(4, summary['serving_node'])
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertNotIn(1, loc)
self.assertNotIn(2, loc)
self.assertNotIn(3, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
self.assertEqual(4, summary['serving_node'])
def test_random_bernoulli_p_1(self):
hr = strategy.RandomBernoulli(self.view, self.controller, p=1)
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertIn(1, loc)
self.assertIn(2, loc)
self.assertIn(3, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
self.assertEqual(4, summary['serving_node'])
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertIn(1, loc)
self.assertIn(2, loc)
self.assertIn(3, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
self.assertEqual(1, summary['serving_node'])
class TestNrr(unittest.TestCase):
@classmethod
def setUpClass(cls):
pass
@classmethod
def tearDownClass(cls):
pass
def setUp(self):
topology = nrr_topology()
model = NetworkModel(topology, cache_policy={'name': 'FIFO'})
self.view = NetworkView(model)
self.controller = NetworkController(model)
self.collector = TestCollector(self.view)
self.controller.attach_collector(self.collector)
def tearDown(self):
pass
def test_lce(self):
hr = strategy.NearestReplicaRouting(self.view,
self.controller,
metacaching='LCE')
# receiver 0 requests 2, expect miss
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEqual(3, len(loc))
self.assertIn(2, loc)
self.assertIn(4, loc)
self.assertIn(6, loc)
self.assertNotIn(3, loc)
self.assertNotIn(5, loc)
summary = self.collector.session_summary()
exp_req_hops = [(0, 2), (2, 4), (4, 6)]
exp_cont_hops = [(6, 4), (4, 2), (2, 0)]
self.assertSetEqual(set(exp_req_hops), set(summary['request_hops']))
self.assertSetEqual(set(exp_cont_hops), set(summary['content_hops']))
self.assertEqual(6, summary['serving_node'])
# receiver 0 requests 2, expect hit
hr.process_event(1, 1, 2, True)
loc = self.view.content_locations(2)
self.assertEqual(4, len(loc))
self.assertIn(2, loc)
self.assertIn(4, loc)
self.assertIn(6, loc)
self.assertIn(3, loc)
self.assertNotIn(5, loc)
summary = self.collector.session_summary()
exp_req_hops = [(1, 3), (3, 2)]
exp_cont_hops = [(2, 3), (3, 1)]
self.assertSetEqual(set(exp_req_hops), set(summary['request_hops']))
self.assertSetEqual(set(exp_cont_hops), set(summary['content_hops']))
self.assertEqual(2, summary['serving_node'])
hr.process_event(1, 1, 2, True)
loc = self.view.content_locations(2)
self.assertEqual(4, len(loc))
self.assertIn(2, loc)
self.assertIn(4, loc)
self.assertIn(6, loc)
self.assertIn(3, loc)
self.assertNotIn(5, loc)
summary = self.collector.session_summary()
exp_req_hops = [(1, 3)]
exp_cont_hops = [(3, 1)]
self.assertSetEqual(set(exp_req_hops), set(summary['request_hops']))
self.assertSetEqual(set(exp_cont_hops), set(summary['content_hops']))
self.assertEqual(3, summary['serving_node'])
def test_lcd(self):
hr = strategy.NearestReplicaRouting(self.view,
self.controller,
metacaching='LCD')
# receiver 0 requests 2, expect miss
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEqual(2, len(loc))
self.assertNotIn(2, loc)
self.assertIn(4, loc)
self.assertIn(6, loc)
self.assertNotIn(3, loc)
self.assertNotIn(5, loc)
summary = self.collector.session_summary()
exp_req_hops = [(0, 2), (2, 4), (4, 6)]
exp_cont_hops = [(6, 4), (4, 2), (2, 0)]
self.assertSetEqual(set(exp_req_hops), set(summary['request_hops']))
self.assertSetEqual(set(exp_cont_hops), set(summary['content_hops']))
self.assertEqual(6, summary['serving_node'])
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEqual(3, len(loc))
self.assertIn(2, loc)
self.assertIn(4, loc)
self.assertIn(6, loc)
self.assertNotIn(3, loc)
self.assertNotIn(5, loc)
summary = self.collector.session_summary()
exp_req_hops = [(0, 2), (2, 4)]
exp_cont_hops = [(4, 2), (2, 0)]
self.assertSetEqual(set(exp_req_hops), set(summary['request_hops']))
self.assertSetEqual(set(exp_cont_hops), set(summary['content_hops']))
self.assertEqual(4, summary['serving_node'])
# receiver 0 requests 2, expect hit
hr.process_event(1, 1, 2, True)
loc = self.view.content_locations(2)
self.assertEqual(4, len(loc))
self.assertIn(2, loc)
self.assertIn(4, loc)
self.assertIn(6, loc)
self.assertIn(3, loc)
self.assertNotIn(5, loc)
summary = self.collector.session_summary()
exp_req_hops = [(1, 3), (3, 2)]
exp_cont_hops = [(2, 3), (3, 1)]
self.assertSetEqual(set(exp_req_hops), set(summary['request_hops']))
self.assertSetEqual(set(exp_cont_hops), set(summary['content_hops']))
self.assertEqual(2, summary['serving_node'])
hr.process_event(1, 1, 2, True)
loc = self.view.content_locations(2)
self.assertEqual(4, len(loc))
self.assertIn(2, loc)
self.assertIn(4, loc)
self.assertIn(6, loc)
self.assertIn(3, loc)
self.assertNotIn(5, loc)
summary = self.collector.session_summary()
exp_req_hops = [(1, 3)]
exp_cont_hops = [(3, 1)]
self.assertSetEqual(set(exp_req_hops), set(summary['request_hops']))
self.assertSetEqual(set(exp_cont_hops), set(summary['content_hops']))
self.assertEqual(3, summary['serving_node'])
def exec_experiment(topology,
workload,
netconf,
strategy,
cache_policy,
repo_policy,
collectors,
warmup_strategy,
sched_policy={'name': 'EDF'}):
"""Execute the simulation of a specific scenario.
Parameters
----------
topology : Topology
The FNSS Topology object modelling the network topology on which
experiments are run.
workload : iterable
An iterable object whose elements are (time, event) tuples, where time
is a float type indicating the timestamp of the event to be executed
and event is a dictionary storing all the attributes of the event to
execute
netconf : dict
Dictionary of attributes to inizialize the network model
strategy : tree
Strategy definition. It is tree describing the name of the strategy
to use and a list of initialization attributes
cache_policy : tree
Cache policy definition. It is tree describing the name of the cache
policy to use and a list of initialization attributes
collectors: dict
The collectors to be used. It is a dictionary in which keys are the
names of collectors to use and values are dictionaries of attributes
for the collector they refer to.
Returns
-------
results : Tree
A tree with the aggregated simulation results from all collectors
"""
model = NetworkModel(topology, cache_policy, repo_policy,
sched_policy['name'], workload.n_services,
workload.rate, **netconf)
workload.model = model
view = NetworkView(model)
controller = NetworkController(model)
collectors_inst = [
DATA_COLLECTOR[name](view, **params)
for name, params in collectors.items()
]
collector = CollectorProxy(view, collectors_inst)
controller.attach_collector(collector)
strategy_name = strategy['name']
warmup_strategy_name = warmup_strategy['name']
strategy_args = {k: v for k, v in strategy.items() if k != 'name'}
warmup_strategy_args = {
k: v
for k, v in warmup_strategy.iteritems() if k != 'name'
}
strategy_inst = STRATEGY[strategy_name](view, controller, **strategy_args)
warmup_strategy_inst = STRATEGY[warmup_strategy_name](
view, controller, **warmup_strategy_args)
n = 0
for time, event in workload:
#continue
strategy_inst.process_event(time, **event)
if n % 500 == 0 and n:
collector.results()
if event['status'] == 1:
n += 1
return collector.results()
"""
class TestOnPath(unittest.TestCase):
@classmethod
def setUpClass(cls):
pass
@classmethod
def tearDownClass(cls):
pass
def setUp(self):
topology = on_path_topology()
model = NetworkModel(topology)
self.view = NetworkView(model)
self.controller = NetworkController(model)
self.collector = TestCollector(self.view)
self.controller.attach_collector(self.collector)
def tearDown(self):
pass
def test_lce_same_content(self):
hr = strategy.LeaveCopyEverywhere(self.view, self.controller)
# receiver 0 requests 2, expect miss
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEquals(len(loc), 4)
self.assertIn(1, loc)
self.assertIn(2, loc)
self.assertIn(3, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((0, 1), (1, 2), (2, 3), (3, 4)))
exp_cont_hops = set(((4, 3), (3, 2), (2, 1), (1, 0)))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
# receiver 0 requests 2, expect hit
hr.process_event(1, 5, 2, True)
loc = self.view.content_locations(2)
self.assertEquals(len(loc), 4)
self.assertIn(1, loc)
self.assertIn(2, loc)
self.assertIn(3, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((5, 2), ))
exp_cont_hops = set(((2, 5), ))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
def test_lce_different_content(self):
hr = strategy.LeaveCopyEverywhere(self.view, self.controller)
# receiver 0 requests 2, expect miss
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEquals(len(loc), 4)
self.assertIn(1, loc)
self.assertIn(2, loc)
self.assertIn(3, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((0, 1), (1, 2), (2, 3), (3, 4)))
exp_cont_hops = set(((4, 3), (3, 2), (2, 1), (1, 0)))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
# request content 3 from 5
hr.process_event(1, 5, 3, True)
loc = self.view.content_locations(3)
self.assertEquals(len(loc), 3)
self.assertIn(2, loc)
self.assertIn(3, loc)
self.assertIn(4, loc)
loc = self.view.content_locations(2)
self.assertEquals(len(loc), 2)
self.assertIn(1, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((5, 2), (2, 3), (3, 4)))
exp_cont_hops = set(((4, 3), (3, 2), (2, 5)))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
# request content 3 from , hit in 2
hr.process_event(1, 0, 3, True)
loc = self.view.content_locations(3)
self.assertEquals(len(loc), 4)
self.assertIn(1, loc)
self.assertIn(2, loc)
self.assertIn(3, loc)
self.assertIn(4, loc)
loc = self.view.content_locations(2)
self.assertEquals(len(loc), 1)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((0, 1), (1, 2)))
exp_cont_hops = set(((2, 1), (1, 0)))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
def test_lcd(self):
hr = strategy.LeaveCopyDown(self.view, self.controller)
# receiver 0 requests 2, expect miss
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEquals(len(loc), 2)
self.assertIn(3, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((0, 1), (1, 2), (2, 3), (3, 4)))
exp_cont_hops = set(((4, 3), (3, 2), (2, 1), (1, 0)))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
# receiver 0 requests 2, expect hit in 3
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEquals(len(loc), 3)
self.assertIn(2, loc)
self.assertIn(3, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((0, 1), (1, 2), (2, 3)))
exp_cont_hops = set(((3, 2), (2, 1), (1, 0)))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
# receiver 0 requests 2, expect hit in 2
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEquals(len(loc), 4)
self.assertIn(1, loc)
self.assertIn(2, loc)
self.assertIn(3, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set((
(0, 1),
(1, 2),
))
exp_cont_hops = set(((2, 1), (1, 0)))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
# receiver 0 requests 2, expect hit in 1
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEquals(len(loc), 4)
self.assertIn(1, loc)
self.assertIn(2, loc)
self.assertIn(3, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((0, 1), ))
exp_cont_hops = set(((1, 0), ))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
# receiver 0 requests 3, expect miss and eviction of 2 from 3
hr.process_event(1, 0, 3, True)
loc = self.view.content_locations(2)
self.assertEquals(len(loc), 3)
self.assertIn(1, loc)
self.assertIn(2, loc)
self.assertIn(4, loc)
loc = self.view.content_locations(3)
self.assertEquals(len(loc), 2)
self.assertIn(3, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((0, 1), (1, 2), (2, 3), (3, 4)))
exp_cont_hops = set(((4, 3), (3, 2), (2, 1), (1, 0)))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
def test_cl4m(self):
hr = strategy.CacheLessForMore(self.view, self.controller)
# receiver 0 requests 2, expect miss
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEquals(len(loc), 2)
self.assertIn(2, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((0, 1), (1, 2), (2, 3), (3, 4)))
exp_cont_hops = set(((4, 3), (3, 2), (2, 1), (1, 0)))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
# receiver 0 requests 2, expect hit
hr.process_event(1, 0, 2, True)
loc = self.view.content_locations(2)
self.assertEquals(len(loc), 3)
self.assertIn(1, loc)
self.assertIn(2, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((0, 1), (1, 2)))
exp_cont_hops = set(((2, 1), (1, 0)))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
# receiver 0 requests 3, expect miss
hr.process_event(1, 0, 3, True)
loc = self.view.content_locations(2)
self.assertEquals(len(loc), 2)
self.assertIn(1, loc)
self.assertIn(4, loc)
loc = self.view.content_locations(3)
self.assertEquals(len(loc), 2)
self.assertIn(2, loc)
self.assertIn(4, loc)
summary = self.collector.session_summary()
exp_req_hops = set(((0, 1), (1, 2), (2, 3), (3, 4)))
exp_cont_hops = set(((4, 3), (3, 2), (2, 1), (1, 0)))
req_hops = summary['request_hops']
cont_hops = summary['content_hops']
self.assertSetEqual(exp_req_hops, set(req_hops))
self.assertSetEqual(exp_cont_hops, set(cont_hops))
