def test_setitem(self):
tree = Tree()
tree['a'] = {'b': 1, 'c': 2}
assert isinstance(tree, Tree)
assert isinstance(tree['a'], Tree)
assert tree.getval(['a', 'b']) == 1
assert tree.getval(['a', 'c']) == 2
def results(self):
duration = self.t_end - self.t_start
used_links = set(self.req_count.keys()).union(
set(self.cont_count.keys()))
link_loads = {
link: (self.req_size * self.req_count[link] +
self.content_size * self.cont_count[link]) / duration
for link in used_links
}
link_loads_int = {
link: load
for link, load in link_loads.items()
if self.view.link_type(*link) == "internal"
}
link_loads_ext = {
link: load
for link, load in link_loads.items()
if self.view.link_type(*link) == "external"
}
mean_load_int = (sum(link_loads_int.values()) /
len(link_loads_int) if len(link_loads_int) > 0 else 0)
mean_load_ext = (sum(link_loads_ext.values()) /
len(link_loads_ext) if len(link_loads_ext) > 0 else 0)
return Tree({
"MEAN_INTERNAL": mean_load_int,
"MEAN_EXTERNAL": mean_load_ext,
"PER_LINK_INTERNAL": link_loads_int,
"PER_LINK_EXTERNAL": link_loads_ext,
})
def results(self):
n_sess = self.cache_hits + self.serv_hits
hit_ratio = self.cache_hits / n_sess
results = Tree(**{'MEAN': hit_ratio})
if self.off_path_hits:
results['MEAN_OFF_PATH'] = self.off_path_hit_count / n_sess
results[
'MEAN_ON_PATH'] = results['MEAN'] - results['MEAN_OFF_PATH']
if self.cont_hits:
cont_set = set(
list(self.cont_cache_hits.keys()) +
list(self.cont_serv_hits.keys()))
cont_hits = dict(
(i, (self.cont_cache_hits[i] /
(self.cont_cache_hits[i] + self.cont_serv_hits[i])))
for i in cont_set)
results['PER_CONTENT'] = cont_hits
if self.per_node:
for v in self.per_node_cache_hits:
self.per_node_cache_hits[v] /= n_sess
for v in self.per_node_server_hits:
self.per_node_server_hits[v] /= n_sess
results['PER_NODE_CACHE_HIT_RATIO'] = self.per_node_cache_hits
results['PER_NODE_SERVER_HIT_RATIO'] = self.per_node_server_hits
return results
def test_paths(self):
tree = Tree()
tree["b"]["c"]["e"] = 4
tree["b"]["v"]["d"] = 3
tree["a"] = 1
expected = {("b", "c", "e"): 4, ("b", "v", "d"): 3, ("a", ): 1}
assert expected == tree.paths()
def test_getval_empty(self):
tree = Tree()
_ = tree[1][2][3]
self.assertIsNotNone(tree.getval([1]))
self.assertIsNotNone(tree.getval([1, 2]))
self.assertIsNone(tree.getval([1, 2, 3]))
self.assertIsNone(tree.getval([1, 2, 3, 4]))
def test_update_new_brach(self):
tree = Tree()
tree['a'].update({'b': 1, 'c': 2})
self.assertIsInstance(tree, Tree)
self.assertIsInstance(tree['a'], Tree)
self.assertEqual(tree.getval(['a', 'b']), 1)
self.assertEqual(tree.getval(['a', 'c']), 2)
def test_paths(self):
tree = Tree()
tree['b']['c']['e'] = 4
tree['b']['v']['d'] = 3
tree['a'] = 1
expected = {('b', 'c', 'e'): 4, ('b', 'v', 'd'): 3, ('a', ): 1}
assert expected == tree.paths()
def test_paths(self):
tree = Tree()
tree['b']['c']['e'] = 4
tree['b']['v']['d'] = 3
tree['a'] = 1
expected = {('b', 'c', 'e'): 4, ('b', 'v', 'd'): 3, ('a', ): 1}
self.assertDictEqual(expected, tree.paths())
def results(self):
if self.cdf:
results['CDF'] = cdf(self.latency_data)
results = Tree(
{'SATISFACTION': 1.0 * self.n_satisfied / self.sess_count})
per_service_sats = {}
for service in self.service_requests.keys():
per_service_sats[service] = 1.0 * self.service_satisfied[
service] / self.service_requests[service]
results['PER_SERVICE_SATISFACTION'] = per_service_sats
results['PER_SERVICE_REQUESTS'] = self.service_requests
results['PER_SERVICE_SAT_REQUESTS'] = self.service_satisfied
results['SAT_TIMES'] = self.satrate_times
results['IDLE_TIMES'] = self.idle_times
results['NODE_IDLE_TIMES'] = self.node_idle_times
results['LATENCY'] = self.latency_times
results['DEADLINE_METRIC'] = self.deadline_metric_times
results['CLOUD_SAT_TIMES'] = self.cloud_sat_times
results['INSTANTIATION_OVERHEAD'] = self.instantiations_times
#print "Printing Sat. rate times:"
#for key in sorted(self.satrate_times):
# print (repr(key) + " " + repr(self.satrate_times[key]))
#print "Printing Idle times:"
#for key in sorted(self.idle_times):
# print (repr(key) + " " + repr(self.idle_times[key]))
#results['VMS_PER_SERVICE'] = self.vms_per_service
return results
def test_getval_empty(self):
tree = Tree()
_ = tree[1][2][3]
assert tree.getval([1]) is not None
assert tree.getval([1, 2]) is not None
assert tree.getval([1, 2, 3]) is None
assert tree.getval([1, 2, 3, 4]) is None
def test_update_new_brach(self):
tree = Tree()
tree["a"].update({"b": 1, "c": 2})
assert isinstance(tree, Tree)
assert isinstance(tree["a"], Tree)
assert tree.getval(["a", "b"]) == 1
assert tree.getval(["a", "c"]) == 2
def test_setitem(self):
tree = Tree()
tree["a"] = {"b": 1, "c": 2}
assert isinstance(tree, Tree)
assert isinstance(tree["a"], Tree)
assert tree.getval(["a", "b"]) == 1
assert tree.getval(["a", "c"]) == 2
def test_setitem(self):
tree = Tree()
tree['a'] = {'b': 1, 'c': 2}
self.assertIsInstance(tree, Tree)
self.assertIsInstance(tree['a'], Tree)
self.assertEqual(tree.getval(['a', 'b']), 1)
self.assertEqual(tree.getval(['a', 'c']), 2)
def filter(self, condition):
"""Return subset of results matching specific conditions
Parameters
----------
condition : dict
Dictionary listing all parameters and values to be matched in the
results set. Each parameter, i.e., each key of the dictionary must
be an iterable object containing the path in the parameters tree
to the required parameter
metrics : dict, optional
List of metrics to be reported
Returns
-------
filtered_results : ResultSet
List of 2-tuples of filtered results, where the first element is a
tree of all experiment parameters and the second value is
a tree with experiment results.
"""
filtered_resultset = ResultSet()
for parameters, results in self._results:
parameters = Tree(parameters)
if parameters.match(condition):
filtered_resultset.add(parameters, results)
return filtered_resultset
def test_update_new_brach(self):
tree = Tree()
tree['a'].update({'b': 1, 'c': 2})
assert isinstance(tree, Tree)
assert isinstance(tree['a'], Tree)
assert tree.getval(['a', 'b']) == 1
assert tree.getval(['a', 'c']) == 2
def test_nested_update(self):
tree = Tree()
tree["a"].update({"b": {"c": 1}, "d": 2})
assert isinstance(tree, Tree)
assert isinstance(tree["a"], Tree)
assert isinstance(tree["a"]["b"], Tree)
assert tree.getval(["a", "b", "c"]) == 1
assert tree.getval(["a", "d"]) == 2
def test_nested_update(self):
tree = Tree()
tree['a'].update({'b': {'c': 1}, 'd': 2})
assert isinstance(tree, Tree)
assert isinstance(tree['a'], Tree)
assert isinstance(tree['a']['b'], Tree)
assert tree.getval(['a', 'b', 'c']) == 1
assert tree.getval(['a', 'd']) == 2
def results(self):
result_dict = {}
for node in self.window_sizes:
if self.view.model.cache[node].__class__.__name__ in \
['DataStreamCachingAlgorithmWithAdaptiveWindowSizeCache']:
result_dict['node %d: window sizes' %
node] = self.window_sizes[node]
return Tree(result_dict)
def test_nested_update(self):
tree = Tree()
tree['a'].update({'b': {'c': 1}, 'd': 2})
self.assertIsInstance(tree, Tree)
self.assertIsInstance(tree['a'], Tree)
self.assertIsInstance(tree['a']['b'], Tree)
self.assertEqual(tree.getval(['a', 'b', 'c']), 1)
self.assertEqual(tree.getval(['a', 'd']), 2)
def results(self):
results = Tree({'MEAN': self.mean_stretch/self.sess_count,
'MEAN_REQUEST': self.mean_req_stretch/self.sess_count,
'MEAN_CONTENT': self.mean_cont_stretch/self.sess_count})
if self.cdf:
results['CDF'] = cdf(self.stretch_data)
results['CDF_REQUEST'] = cdf(self.req_stretch_data)
results['CDF_CONTENT'] = cdf(self.cont_stretch_data)
return results
def test_init_from_nested_dict(self):
tree = Tree({"a": {"c": {"e": 1}}, "b": {"d": 2}})
assert tree.getval(["a", "c", "e"]) == 1
assert tree.getval(["b", "d"]) == 2
assert isinstance(tree, Tree)
assert isinstance(tree["a"], Tree)
assert isinstance(tree["a"]["c"], Tree)
assert isinstance(tree.getval(["a", "c"]), Tree)
assert isinstance(tree["b"], Tree)
def test_init_from_nested_dict(self):
tree = Tree({'a': {'c': {'e': 1}}, 'b': {'d': 2}})
self.assertEqual(tree.getval(['a', 'c', 'e']), 1)
self.assertEqual(tree.getval(['b', 'd']), 2)
self.assertIsInstance(tree, Tree)
self.assertIsInstance(tree['a'], Tree)
self.assertIsInstance(tree['a']['c'], Tree)
self.assertIsInstance(tree.getval(['a', 'c']), Tree)
self.assertIsInstance(tree['b'], Tree)
def test_init_from_nested_dict(self):
tree = Tree({'a': {'c': {'e': 1}}, 'b': {'d': 2}})
assert tree.getval(['a', 'c', 'e']) == 1
assert tree.getval(['b', 'd']) == 2
assert isinstance(tree, Tree)
assert isinstance(tree['a'], Tree)
assert isinstance(tree['a']['c'], Tree)
assert isinstance(tree.getval(['a', 'c']), Tree)
assert isinstance(tree['b'], Tree)
def results(self):
duration = self.t_end - self.t_start
return Tree({
'CONTENT_HOP_COUNT_PER_EDGE': self.cont_count,
'REQUESTS_COUNT_PER_EDGE': self.req_count,
'ALL_REQUESTS': self.req_timeline,
'ALL_SOURCES': self.all_sources_dic
})
def test_pickle_empty(self):
tree = Tree()
f = BytesIO()
pickle.dump(tree, f)
f.seek(0)
tree_2 = pickle.load(f)
self.assertEquals(type(tree), type(tree_2))
self.assertEquals(tree, tree_2)
self.assertIsInstance(tree, Tree)
self.assertIsInstance(tree_2, Tree)
def test_pickle_empty(self):
tree = Tree()
f = BytesIO()
pickle.dump(tree, f)
f.seek(0)
tree_2 = pickle.load(f)
assert type(tree) == type(tree_2)
assert tree == tree_2
assert isinstance(tree, Tree)
assert isinstance(tree_2, Tree)
def test_match(self):
t = {"a": {"b": 1}, "c": 2, "d": {"e": 3}}
pos_match_equal = {"a": {"b": 1}, "c": 2, "d": {"e": 3}}
pos_match_subset = {"a": {"b": 1}, "d": {"e": 3}}
neg_match_diff = {"a": {"b": 2}, "c": 2, "d": {"e": 3}}
neg_match_superset = {"a": {"b": 1}, "c": 2, "d": {"e": 3}, "f": 3}
tree = Tree(t)
assert tree.match(pos_match_equal)
assert tree.match(pos_match_subset)
assert not tree.match(neg_match_diff)
assert not tree.match(neg_match_superset)
def test_match(self):
t = {'a': {'b': 1}, 'c': 2, 'd': {'e': 3}}
pos_match_equal = {'a': {'b': 1}, 'c': 2, 'd': {'e': 3}}
pos_match_subset = {'a': {'b': 1}, 'd': {'e': 3}}
neg_match_diff = {'a': {'b': 2}, 'c': 2, 'd': {'e': 3}}
neg_match_superset = {'a': {'b': 1}, 'c': 2, 'd': {'e': 3}, 'f': 3}
tree = Tree(t)
self.assertTrue(tree.match(pos_match_equal))
self.assertTrue(tree.match(pos_match_subset))
self.assertFalse(tree.match(neg_match_diff))
self.assertFalse(tree.match(neg_match_superset))
def test_match(self):
t = {'a': {'b': 1}, 'c': 2, 'd': {'e': 3}}
pos_match_equal = {'a': {'b': 1}, 'c': 2, 'd': {'e': 3}}
pos_match_subset = {'a': {'b': 1}, 'd': {'e': 3}}
neg_match_diff = {'a': {'b': 2}, 'c': 2, 'd': {'e': 3}}
neg_match_superset = {'a': {'b': 1}, 'c': 2, 'd': {'e': 3}, 'f': 3}
tree = Tree(t)
assert tree.match(pos_match_equal)
assert tree.match(pos_match_subset)
assert not tree.match(neg_match_diff)
assert not tree.match(neg_match_superset)
def add(self, parameters, results):
"""Add a result to the result set.
Parameters
----------
parameters : Tree
Tree of experiment parameters
results : Tree
Tree of experiment results
Notes
-----
If parameters and results are dictionaries, this method will attempt to
convert them to trees and storing them anyway. It is necessary that
parameters and results are saved as trees so that plotting functions
can search correctly in them.
"""
if not isinstance(parameters, Tree):
parameters = Tree(parameters)
if not isinstance(results, Tree):
results = Tree(results)
self._results.append((parameters, results))
