def traffic_per_group_per_tenant_for_unicast(self):
_traffic_per_group_per_tenant_for_unicast = []
for t in bar_range(
self.num_tenants,
desc='data:traffic_per_group_per_tenant_for_unicast:'):
tenant_maps = self.tenants_maps[t]
group_count = tenant_maps['group_count']
groups_map = tenant_maps['groups_map']
for g in range(group_count):
group_map = groups_map[g]
leafs_map = group_map['leafs_map']
# pods_map = group_map['pods_map']
leafs_traffic = 0
for l in leafs_map:
leaf_map = leafs_map[l]
leafs_traffic += popcount(leaf_map['bitmap'])
_traffic_per_group_per_tenant_for_unicast += [
6 * leafs_traffic
]
_traffic_per_group_per_tenant_for_unicast = \
pd.Series(_traffic_per_group_per_tenant_for_unicast)
return _traffic_per_group_per_tenant_for_unicast
def traffic_per_group_per_tenant_for_overlay(self):
traffic_per_group_per_tenant_for_overlay = []
for t in bar_range(
self.num_tenants,
desc='data:traffic_per_group_per_tenant_for_overlay:'):
tenant_maps = self.tenants_maps[t]
group_count = tenant_maps['group_count']
groups_map = tenant_maps['groups_map']
for g in range(group_count):
group_map = groups_map[g]
leafs_map = group_map['leafs_map']
# pods_map = group_map['pods_map']
leafs_traffic = 0
for l in leafs_map:
leaf_map = leafs_map[l]
leaf_host_count = popcount(leaf_map['bitmap'])
leafs_traffic += 2 * (leaf_host_count - 1)
traffic_per_group_per_tenant_for_overlay += [
(6 * len(leafs_map)) + leafs_traffic
]
traffic_per_group_per_tenant_for_overlay = \
pd.Series(traffic_per_group_per_tenant_for_overlay)
return traffic_per_group_per_tenant_for_overlay
def traffic_per_group_per_tenant_for_baseerat(self):
_traffic_per_group_per_tenant_for_baseerat = []
for t in bar_range(
self.num_tenants,
desc='data:traffic_per_group_per_tenant_for_baseerat:'):
tenant_maps = self.tenants_maps[t]
group_count = tenant_maps['group_count']
groups_map = tenant_maps['groups_map']
for g in range(group_count):
group_map = groups_map[g]
leafs_map = group_map['leafs_map']
pods_map = group_map['pods_map']
leafs_traffic = 0
redundant_leafs = 0
redundant_leafs_traffic = 0
for p in pods_map:
pod_map = pods_map[p]
if '~bitmap' in pod_map:
redundant_leafs += popcount(pod_map['~bitmap'])
if 'leafs_default_bitmap' in group_map:
redundant_leafs_traffic = redundant_leafs * popcount(
group_map['leafs_default_bitmap'])
for l in leafs_map:
leaf_map = leafs_map[l]
leafs_traffic += popcount(leaf_map['bitmap'])
if '~bitmap' in leaf_map:
leafs_traffic += popcount(leaf_map['~bitmap'])
_traffic_per_group_per_tenant_for_baseerat += [
3 + len(pods_map) + len(leafs_map) + leafs_traffic +
redundant_leafs + redundant_leafs_traffic
]
_traffic_per_group_per_tenant_for_baseerat = \
pd.Series(_traffic_per_group_per_tenant_for_baseerat)
return _traffic_per_group_per_tenant_for_baseerat
def min_k_union(nodes_map, nodes, k):
min_k_bitmap = 0
min_k_nodes = []
for _ in range(k):
node = min(
nodes,
key=lambda l: popcount(nodes_map[l]['bitmap'] | min_k_bitmap))
nodes.remove(node)
min_k_bitmap |= nodes_map[node]['bitmap']
min_k_nodes += [node]
return min_k_bitmap, min_k_nodes
def set_cover(bitmap, submaps):
if reduce(lambda x, y: x | y, submaps) != bitmap:
return None
set_cover_bitmap = 0
set_cover_submaps = []
while set_cover_bitmap != bitmap:
submap = max(submaps, key=lambda s: popcount(s & (~set_cover_bitmap)))
submaps.remove(submap)
set_cover_bitmap |= submap
set_cover_submaps += [submap]
return set_cover_submaps
def traffic_overhead_per_group_per_tenant(self, node_type):
_traffic_overhead_per_group_per_tenant = []
for t in bar_range(self.num_tenants,
desc='data:traffic_overhead_per_group_per_tenant:'):
tenant_maps = self.tenants_maps[t]
group_count = tenant_maps['group_count']
groups_map = tenant_maps['groups_map']
for g in range(group_count):
group_map = groups_map[g]
nodes_map = group_map[
'leafs_map'] if node_type == 'leafs' else group_map[
'pods_map']
_actual_traffic = 0
_redundant_traffic = 0
for n in nodes_map:
node_map = nodes_map[n]
_actual_traffic += popcount(node_map['bitmap'])
if '~bitmap' in node_map:
_redundant_traffic += popcount(node_map['~bitmap'])
_traffic_overhead_per_group_per_tenant += [
_redundant_traffic / _actual_traffic
]
_traffic_overhead_per_group_per_tenant = pd.Series(
_traffic_overhead_per_group_per_tenant)
if self.log_dir is not None:
_traffic_overhead_per_group_per_tenant.to_csv(
self.log_dir +
"/traffic_overhead_per_group_per_tenant_for_%s.csv" %
node_type,
index=False)
return _traffic_overhead_per_group_per_tenant
def traffic_per_group_per_tenant_for_overlay_corrected(self):
traffic_per_group_per_tenant_for_overlay_corrected = []
for t in bar_range(
self.num_tenants,
desc='data:traffic_per_group_per_tenant_for_overlay_corrected:'
):
tenant_maps = self.tenants_maps[t]
group_count = tenant_maps['group_count']
groups_map = tenant_maps['groups_map']
for g in range(group_count):
group_map = groups_map[g]
leafs_map = group_map['leafs_map']
pods_map = group_map['pods_map']
pods_traffic = 0
leafs_traffic = 0
for p in pods_map:
pod_map = pods_map[p]
pod_leaf_count = popcount(pod_map['bitmap'])
pods_traffic += 4 * (pod_leaf_count - 1)
for l in leafs_map:
leaf_map = leafs_map[l]
leaf_host_count = popcount(leaf_map['bitmap'])
leafs_traffic += 2 * (leaf_host_count - 1)
traffic_per_group_per_tenant_for_overlay_corrected += [
(6 * len(pods_map)) + pods_traffic + leafs_traffic
]
traffic_per_group_per_tenant_for_overlay_corrected = \
pd.Series(traffic_per_group_per_tenant_for_overlay_corrected)
return traffic_per_group_per_tenant_for_overlay_corrected
def run(nodes_map, max_bitmaps, max_nodes_per_bitmap, redundancy_per_bitmap, rules_count_map, max_rules,
probability=1.0 * 2 / 3, num_ports_per_node=48, node_id_width=4):
if len(nodes_map) <= max_bitmaps:
header_size = (len(nodes_map) * (num_ports_per_node + node_id_width + 2))
return header_size, 0
unassigned_nodes = [n for n in nodes_map]
num_unassigned_bitmaps = max_bitmaps
header_size = 0
# Assign nodes to bitmaps
for i in range(max_bitmaps):
num_nodes_per_bitmap = int(ceil(1.0 * len(unassigned_nodes) / num_unassigned_bitmaps))
for k in range(min(max_nodes_per_bitmap, num_nodes_per_bitmap), 0, -1):
min_k_bitmap, min_k_nodes = min_k_union(nodes_map, unassigned_nodes, k, probability)
redundancy = sum([popcount(min_k_bitmap ^ nodes_map[l]['bitmap']) for l in min_k_nodes])
if redundancy <= redundancy_per_bitmap:
for n in min_k_nodes:
node = nodes_map[n]
node['has_bitmap'] = i
node['~bitmap'] = min_k_bitmap ^ node['bitmap']
header_size += (num_ports_per_node + 1) + (k * (node_id_width + 1))
break
else:
unassigned_nodes += min_k_nodes
num_unassigned_bitmaps -= 1
# Add a rule or assign nodes to default bitmap
default_bitmap = 0
for n in unassigned_nodes:
node = nodes_map[n]
if rules_count_map[n] < max_rules: # Add a rule in node
node['has_rule'] = True
rules_count_map[n] += 1
else: # Assign leaf to node bitmap
default_bitmap |= node['bitmap']
# Calculate redundancy for nodes assigned to default bitmap
for n in unassigned_nodes:
node = nodes_map[n]
if 'has_rule' not in node:
node['~bitmap'] = default_bitmap ^ node['bitmap']
if default_bitmap != 0:
header_size += num_ports_per_node
return header_size, default_bitmap
def run(nodes_map, max_bitmaps, max_nodes_per_bitmap, redundancy_per_bitmap,
rules_count_map, max_rules):
if len(nodes_map) <= max_bitmaps:
return
unassigned_nodes = [n for n in nodes_map]
num_unassigned_bitmaps = max_bitmaps
# Assign nodes to bitmaps
for i in range(max_bitmaps):
num_nodes_per_bitmap = int(
ceil(1.0 * len(unassigned_nodes) / num_unassigned_bitmaps))
for k in range(min(max_nodes_per_bitmap, num_nodes_per_bitmap), 0, -1):
min_k_bitmap, min_k_nodes = min_k_union(nodes_map,
unassigned_nodes, k)
redundancy = sum([
popcount(min_k_bitmap ^ nodes_map[l]['bitmap'])
for l in min_k_nodes
])
if redundancy <= redundancy_per_bitmap:
for n in min_k_nodes:
node = nodes_map[n]
node['has_bitmap'] = i
node['~bitmap'] = min_k_bitmap ^ node['bitmap']
break
else:
unassigned_nodes += min_k_nodes
num_unassigned_bitmaps -= 1
# Add a rule or assign nodes to default bitmap
default_bitmap = 0
for n in unassigned_nodes:
node = nodes_map[n]
if rules_count_map[n] < max_rules: # Add a rule in node
node['has_rule'] = True
rules_count_map[n] += 1
else: # Assign node to default bitmap
default_bitmap |= node['bitmap']
# Calculate redundancy for leafs assigned to default bitmap
for n in unassigned_nodes:
node = nodes_map[n]
if 'has_rule' not in node:
node['~bitmap'] = default_bitmap ^ node['bitmap']
return default_bitmap
def traffic_per_group_per_tenant_for_overlay_corrected_params(self):
traffic_per_group_per_tenant_for_overlay_pods = []
traffic_per_group_per_tenant_for_overlay_leafs = []
traffic_per_group_per_tenant_for_overlay_pods_traffic = []
for t in bar_range(
self.num_tenants,
desc=
'data:traffic_per_group_per_tenant_for_overlay_corrected_params:'
):
tenant_maps = self.tenants_maps[t]
group_count = tenant_maps['group_count']
groups_map = tenant_maps['groups_map']
for g in range(group_count):
group_map = groups_map[g]
leafs_map = group_map['leafs_map']
pods_map = group_map['pods_map']
pods_traffic = 0
for p in pods_map:
pod_map = pods_map[p]
pod_leaf_count = popcount(pod_map['bitmap'])
pods_traffic += 4 * (pod_leaf_count - 1)
traffic_per_group_per_tenant_for_overlay_pods += [
len(pods_map)
]
traffic_per_group_per_tenant_for_overlay_leafs += [
len(leafs_map)
]
traffic_per_group_per_tenant_for_overlay_pods_traffic += [
pods_traffic
]
traffic_per_group_per_tenant_for_overlay_pods = \
pd.Series(traffic_per_group_per_tenant_for_overlay_pods)
traffic_per_group_per_tenant_for_overlay_leafs = \
pd.Series(traffic_per_group_per_tenant_for_overlay_leafs)
traffic_per_group_per_tenant_for_overlay_pods_traffic = \
pd.Series(traffic_per_group_per_tenant_for_overlay_pods_traffic)
return traffic_per_group_per_tenant_for_overlay_pods, \
traffic_per_group_per_tenant_for_overlay_leafs, \
traffic_per_group_per_tenant_for_overlay_pods_traffic
def min_k_union_random(nodes_map, nodes, k, probability):
min_k_bitmap = 0
min_k_nodes = []
for _ in range(k):
temp_nodes = nodes[:]
while True:
if temp_nodes:
node = min(temp_nodes,
key=lambda l: popcount(nodes_map[l]['bitmap'] |
min_k_bitmap))
if random.random() < probability:
break
temp_nodes.remove(node)
else:
break
nodes.remove(node)
min_k_bitmap |= nodes_map[node]['bitmap']
min_k_nodes += [node]
return min_k_bitmap, min_k_nodes
def set_cover_random(bitmap, submaps, probability):
if reduce(lambda x, y: x | y, submaps) != bitmap:
return None
set_cover_bitmap = 0
set_cover_submaps = []
while set_cover_bitmap != bitmap:
temp_submaps = submaps[:]
while True:
if temp_submaps:
submap = max(temp_submaps,
key=lambda s: popcount(s & (~set_cover_bitmap)))
if random.random() < probability:
break
temp_submaps.remove(submap)
else:
break
submaps.remove(submap)
set_cover_bitmap |= submap
set_cover_submaps += [submap]
return set_cover_submaps
def traffic_per_group_per_tenant_for_baseerat_bytes(self):
_traffic_per_group_per_tenant_for_baseerat_bytes = []
for t in bar_range(
self.num_tenants,
desc='data:traffic_per_group_per_tenant_for_baseerat_bytes:'):
tenant_maps = self.tenants_maps[t]
group_count = tenant_maps['group_count']
groups_map = tenant_maps['groups_map']
for g in range(group_count):
group_map = groups_map[g]
leafs_map = group_map['leafs_map']
pods_map = group_map['pods_map']
leafs_traffic = 0
redundant_leafs = 0
redundant_leafs_traffic = 0
for p in pods_map:
pod_map = pods_map[p]
if '~bitmap' in pod_map:
redundant_leafs += popcount(pod_map['~bitmap'])
if 'leafs_default_bitmap' in group_map:
redundant_leafs_traffic = redundant_leafs * popcount(
group_map['leafs_default_bitmap'])
for l in leafs_map:
leaf_map = leafs_map[l]
leafs_traffic += popcount(leaf_map['bitmap'])
if '~bitmap' in leaf_map:
leafs_traffic += popcount(leaf_map['~bitmap'])
upstream_leaf_bits = self.num_hosts_per_leaf + self.num_spines_per_pod
upstream_spine_bits = self.num_leafs_per_pod + self.num_cores
core_bits = self.num_pods
downstream_spine_bits = group_map['pods_header_size']
downstream_leaf_bits = group_map['leafs_header_size']
header_size_bits = (upstream_leaf_bits + upstream_spine_bits +
core_bits + downstream_spine_bits +
downstream_leaf_bits)
host_to_leaf_edge_bits = header_size_bits
leaf_to_spine_edge_bits = host_to_leaf_edge_bits - upstream_leaf_bits
spine_to_core_edge_bits = leaf_to_spine_edge_bits - upstream_spine_bits
core_to_spine_edge_bits = spine_to_core_edge_bits - core_bits
spine_to_leaf_edge_bits = core_to_spine_edge_bits - downstream_spine_bits
_traffic_per_group_per_tenant_for_baseerat_bytes += \
[(host_to_leaf_edge_bits +
leaf_to_spine_edge_bits +
spine_to_core_edge_bits +
(len(pods_map) * core_to_spine_edge_bits) +
(len(leafs_map) * spine_to_leaf_edge_bits) +
(redundant_leafs * spine_to_leaf_edge_bits)) / 8]
_traffic_per_group_per_tenant_for_baseerat_bytes = \
pd.Series(_traffic_per_group_per_tenant_for_baseerat_bytes)
if self.log_dir is not None:
_traffic_per_group_per_tenant_for_baseerat_bytes.to_csv(
self.log_dir +
"/traffic_per_group_per_tenant_for_baseerat_bytes.csv",
index=False)
return _traffic_per_group_per_tenant_for_baseerat_bytes