def test_return_node_number(self):
self.assertEqual(return_node_number(0, 0, 0), 0)
for k in range(0, Config.ag.z_size):
for j in range(0, Config.ag.y_size):
for i in range(0, Config.ag.x_size):
self.assertEqual(return_node_number(i, j, k),
i + j*Config.ag.x_size+k*Config.ag.y_size*Config.ag.x_size)
self.assertEqual(return_node_number(Config.ag.x_size-1, Config.ag.y_size-1, Config.ag.z_size-1),
Config.ag.x_size * Config.ag.y_size * Config.ag.z_size - 1)
def test_return_node_number(self):
self.assertEqual(return_node_number(0, 0, 0), 0)
for k in range(0, Config.Network_Z_Size):
for j in range(0, Config.Network_Y_Size):
for i in range(0, Config.Network_X_Size):
self.assertEqual(
return_node_number(i, j,
k), i + j * Config.Network_X_Size +
k * Config.Network_Y_Size * Config.Network_X_Size)
self.assertEqual(
return_node_number(Config.Network_X_Size - 1,
Config.Network_Y_Size - 1,
Config.Network_Z_Size - 1),
Config.Network_X_Size * Config.Network_Y_Size *
Config.Network_Z_Size - 1)
def merge_node_with_rectangles(rectangle_list, unreachable_node_list):
"""
:param rectangle_list:
:param unreachable_node_list: un-reachable nodes that are initially populating the unreachable list
:return: rectangle list
"""
# todo: in this function if we can not perform any loss-less merge, we terminate the process...
# which is bad... we need to make sure that this node is covered
for unreachable_node in unreachable_node_list:
covered = False
for rectangle in rectangle_list:
if rectangle_list[rectangle][0] is None:
# there is no entry, this is the first node to get in...
rectangle_list[rectangle] = (unreachable_node, unreachable_node)
covered = True
break
else:
if is_node_inside_rectangle(rectangle_list[rectangle], unreachable_node):
covered = True
break
else:
location_1, location_2 = merge_rectangle_with_node(rectangle_list[rectangle][0],
rectangle_list[rectangle][1],
unreachable_node)
# print ("Merged:" location_1, location_2)
loss_less_merge = True
for network_node_x in range(location_1[0], location_2[0]+1): # (merged_x_1, merged_x_2+1)
for network_node_y in range(location_1[1], location_2[1]+1):
for network_node_z in range(location_1[2], location_2[2]+1):
node_number = return_node_number(network_node_x, network_node_y, network_node_z)
if node_number not in unreachable_node_list:
loss_less_merge = False
break
# if we are not losing any Node, we perform Merge...
if loss_less_merge:
# merged X Merged Y Merged Z
merged_1 = return_node_number(location_1[0], location_1[1], location_1[2])
merged_2 = return_node_number(location_2[0], location_2[1], location_2[2])
rectangle_list[rectangle] = deepcopy((merged_1, merged_2))
covered = True
break
if not covered:
pass
# print ("COULD NOT PERFORM ANY LOSS-LESS MERGE FOR:"+str(UnreachableNode))
# print (RectangleList)
return rectangle_list
def test_manhattan_distance(self):
self.assertEqual(manhattan_distance(0, 0), 0)
last_node_number = return_node_number(Config.Network_X_Size - 1,
Config.Network_Y_Size - 1,
Config.Network_Z_Size - 1)
self.assertEqual(
manhattan_distance(0, last_node_number), Config.Network_X_Size +
Config.Network_Y_Size + Config.Network_Z_Size - 3)
def test_return_node_location(self):
for k in range(0, Config.Network_Z_Size):
for j in range(0, Config.Network_Y_Size):
for i in range(0, Config.Network_X_Size):
# we have the assumption that return_node_number is fully tested...
self.assertEqual(
return_node_location(return_node_number(i, j, k)),
(i, j, k))
def test_manhattan_distance(self):
self.assertEqual(manhattan_distance(0, 0), 0)
last_node_number = return_node_number(Config.ag.x_size - 1,
Config.ag.y_size - 1,
Config.ag.z_size - 1)
self.assertEqual(
manhattan_distance(0, last_node_number),
Config.ag.x_size + Config.ag.y_size + Config.ag.z_size - 3)
def test_generate_generic_topology_ag(self):
temp_x = Config.ag.x_size
temp_y = Config.ag.y_size
temp_z = Config.ag.z_size
size_z = 1
for size_y in range(2, 5):
for size_x in range(2, 5):
for topology in ['2DMesh', '2DTorus', '2DRing', '2DLine']:
Config.ag.x_size = size_x
Config.ag.y_size = size_y
Config.ag.z_size = size_z
ag_4_test = copy.deepcopy(generate_generic_topology_ag(topology, None))
self.assertEqual(len(ag_4_test.nodes()), size_x*size_y*size_z, msg=str(ag_4_test.nodes()))
# --------------------------------------------
if topology is '2DMesh':
link_counter = 0
for j in range(0, size_y):
for i in range(0, size_x-1):
source = return_node_number(i, j, 0)
destination = return_node_number(i+1, j, 0)
self.assertTrue(ag_4_test.has_edge(source, destination))
self.assertTrue(ag_4_test.has_edge(destination, source))
link_counter += 2
for j in range(0, size_y-1):
for i in range(0, size_x):
source = return_node_number(i, j, 0)
destination = return_node_number(i, j+1, 0)
self.assertTrue(ag_4_test.has_edge(source, destination))
self.assertTrue(ag_4_test.has_edge(destination, source))
link_counter += 2
self.assertEqual(link_counter, len(ag_4_test.edges()), msg="link_counter: " +
str(link_counter) + " number of edges: " + str(len(ag_4_test.edges())) +
" topology: "+str(topology))
# --------------------------------------------
if topology is '2DTorus':
link_list = []
for j in range(0, size_y):
for i in range(0, size_x-1):
source = return_node_number(i, j, 0)
destination = return_node_number(i+1, j, 0)
self.assertTrue(ag_4_test.has_edge(source, destination))
self.assertTrue(ag_4_test.has_edge(destination, source))
if (source, destination) not in link_list:
link_list.append((source, destination))
if (destination, source) not in link_list:
link_list.append((destination, source))
for j in range(0, size_y-1):
for i in range(0, size_x):
source = return_node_number(i, j, 0)
destination = return_node_number(i, j+1, 0)
self.assertTrue(ag_4_test.has_edge(source, destination),
msg="in topology: "+str(topology)+"\ndid not found path from " +
str(source) +
" to "+str(destination) +
" \nAG nodes: "+str(ag_4_test.nodes()) +
" \nAG edges: "+str(ag_4_test.edges()))
self.assertTrue(ag_4_test.has_edge(destination, source))
if (source, destination) not in link_list:
link_list.append((source, destination))
if (destination, source) not in link_list:
link_list.append((destination, source))
for i in range(0, size_x):
source = return_node_number(i, size_y-1, 0)
destination = return_node_number(i, 0, 0)
self.assertTrue(ag_4_test.has_edge(source, destination))
self.assertTrue(ag_4_test.has_edge(destination, source))
if (source, destination) not in link_list:
link_list.append((source, destination))
if (destination, source) not in link_list:
link_list.append((destination, source))
for j in range(0, size_y):
source = return_node_number(size_x-1, j, 0)
destination = return_node_number(0, j, 0)
self.assertTrue(ag_4_test.has_edge(source, destination))
self.assertTrue(ag_4_test.has_edge(destination, source))
if (source, destination) not in link_list:
link_list.append((source, destination))
if (destination, source) not in link_list:
link_list.append((destination, source))
self.assertEqual(len(link_list), len(ag_4_test.edges()), msg="link_list: "+str(link_list) +
" number of edges: " + str(len(ag_4_test.edges())) + " topology: " +
str(topology))
# --------------------------------------------
if topology is '2DLine':
link_counter = 0
for j in range(0, size_y):
for i in range(0, size_x-1):
source = return_node_number(i, j, 0)
destination = return_node_number(i+1, j, 0)
self.assertTrue(ag_4_test.has_edge(source, destination))
self.assertTrue(ag_4_test.has_edge(destination, source))
link_counter += 2
self.assertEqual(link_counter, len(ag_4_test.edges()), msg="link_counter: " +
str(link_counter) + " number of edges: " +
str(len(ag_4_test.edges())) + " topology: "+str(topology))
# --------------------------------------------
if topology is '2DRing':
link_list = []
for j in range(0, size_y):
for i in range(0, size_x-1):
source = return_node_number(i, j, 0)
destination = return_node_number(i+1, j, 0)
self.assertTrue(ag_4_test.has_edge(source, destination))
self.assertTrue(ag_4_test.has_edge(destination, source))
if (source, destination) not in link_list:
link_list.append((source, destination))
if (destination, source) not in link_list:
link_list.append((destination, source))
for j in range(0, size_y):
source = return_node_number(size_x-1, j, 0)
destination = return_node_number(0, j, 0)
self.assertTrue(ag_4_test.has_edge(source, destination))
self.assertTrue(ag_4_test.has_edge(destination, source))
if (source, destination) not in link_list:
link_list.append((source, destination))
if (destination, source) not in link_list:
link_list.append((destination, source))
self.assertEqual(len(link_list), len(ag_4_test.edges()), msg="link_list: " +
str(link_list) + " number of edges: " + str(len(ag_4_test.edges())) +
" topology: "+str(topology))
del ag_4_test
# --------------------------------------------
for size_z in range(2, 5):
for size_y in range(2, 5):
for size_x in range(2, 5):
for topology in ['3DMesh']:
size_x = 2
size_y = 2
size_z = 2
Config.ag.x_size = size_x
Config.ag.y_size = size_y
Config.ag.z_size = size_z
ag_4_test = generate_generic_topology_ag(topology, None)
link_counter = 0
for k in range(0, size_z):
for j in range(0, size_y):
for i in range(0, size_x-1):
source = return_node_number(i, j, k)
destination = return_node_number(i+1, j, k)
self.assertTrue(ag_4_test.has_edge(source, destination))
self.assertTrue(ag_4_test.has_edge(destination, source))
link_counter += 2
for k in range(0, size_z):
for j in range(0, size_y-1):
for i in range(0, size_x):
source = return_node_number(i, j, k)
destination = return_node_number(i, j+1, k)
self.assertTrue(ag_4_test.has_edge(source, destination))
self.assertTrue(ag_4_test.has_edge(destination, source))
link_counter += 2
for k in range(0, size_z-1):
for j in range(0, size_y):
for i in range(0, size_x):
source = return_node_number(i, j, k)
destination = return_node_number(i, j, k+1)
self.assertTrue(ag_4_test.has_edge(source, destination))
self.assertTrue(ag_4_test.has_edge(destination, source))
link_counter += 2
self.assertEqual(link_counter, len(ag_4_test.edges()), msg="link_counter: " +
str(link_counter) + " number of edges: " + str(len(ag_4_test.edges())) +
" list of edges: "+str(ag_4_test.edges()) + " topology: "+str(topology))
del ag_4_test
Config.ag.x_size = temp_x
Config.ag.y_size = temp_y
Config.ag.z_size = temp_z
def merge_node_with_rectangles(rectangle_list, unreachable_node_list):
"""
:param rectangle_list:
:param unreachable_node_list: un-reachable nodes that are initially populating the unreachable list
:return: rectangle list
"""
# todo: in this function if we can not perform any loss-less merge, we terminate the process...
# which is bad... we need to make sure that this node is covered
for unreachable_node in unreachable_node_list:
covered = False
for rectangle in rectangle_list:
if rectangle_list[rectangle][0] is None:
# there is no entry, this is the first node to get in...
rectangle_list[rectangle] = (unreachable_node,
unreachable_node)
covered = True
break
else:
if is_node_inside_rectangle(rectangle_list[rectangle],
unreachable_node):
covered = True
break
else:
location_1, location_2 = merge_rectangle_with_node(
rectangle_list[rectangle][0],
rectangle_list[rectangle][1], unreachable_node)
#print("Merged:", location_1, location_2)
loss_less_merge = True
for network_node_x in range(
location_1[0],
location_2[0] + 1): # (merged_x_1, merged_x_2+1)
for network_node_y in range(location_1[1],
location_2[1] + 1):
for network_node_z in range(
location_1[2], location_2[2] + 1):
node_number = return_node_number(
network_node_x, network_node_y,
network_node_z)
if node_number not in unreachable_node_list:
loss_less_merge = False
break
# if we are not losing any Node, we perform Merge...
if loss_less_merge:
# merged X Merged Y Merged Z
merged_1 = return_node_number(location_1[0],
location_1[1],
location_1[2])
merged_2 = return_node_number(location_2[0],
location_2[1],
location_2[2])
rectangle_list[rectangle] = deepcopy(
(merged_1, merged_2))
covered = True
break
if not covered:
pass
# print("COULD NOT PERFORM ANY LOSS-LESS MERGE FOR:"+str(UnreachableNode))
# print(RectangleList)
return rectangle_list
def gen_latex_ag(ag, shm):
"""
Generates a latex (.tex) file that will draw the architecture graph along with health of links
and partitioning information
:param ag: Architecture graph
:param shm: System Health Map
:return: None
"""
if Config.ag.z_size > 1:
return None
latex_ag_file = open('Generated_Files/Latex/ag.tex', 'w')
latex_ag_file.write("\\documentclass[12pt]{article}\n")
latex_ag_file.write("\\usepackage{tikz}\n")
latex_ag_file.write("\definecolor{critical}{RGB}{255,204,204}\n")
latex_ag_file.write("\definecolor{non_critical}{RGB}{255,255,255}\n")
latex_ag_file.write("\definecolor{gate_to_critical}{RGB}{204,229,255}\n")
latex_ag_file.write("\definecolor{gate_to_non_critical}{RGB}{178,102,255}\n")
latex_ag_file.write("\\begin{document}\n")
latex_ag_file.write("\\begin{tikzpicture}\n")
node_size = 1
bend = 10
for j in range(0, Config.ag.y_size):
for i in range(0, Config.ag.x_size):
start_x = i*2*node_size
start_y = j*2*node_size
node_number = return_node_number(i, j, 0)
if ag.node[node_number]['Region'] == 'L':
color = 'non_critical'
elif ag.node[node_number]['Region'] == 'H':
color = 'critical'
elif ag.node[node_number]['Region'] == 'GH':
color = 'gate_to_critical'
elif ag.node[node_number]['Region'] == 'GNH':
color = 'gate_to_non_critical'
else:
color = 'white'
latex_ag_file.write("\\draw [fill="+color+"] ("+str(start_x)+","+str(start_y)+") rectangle (" +
str(start_x+node_size)+","+str(start_y+node_size)+");\n")
latex_ag_file.write("\\node[text width=0.5cm] at ("+str(start_x+node_size*0.5)+"," +
str(start_y+node_size*0.5)+") {"+str(node_number)+"};\n")
if i < Config.ag.x_size-1:
if ag.has_edge(return_node_number(i, j, 0), return_node_number(i+1, j, 0)):
if shm.edges[(return_node_number(i, j, 0), return_node_number(i+1, j, 0))]["LinkHealth"]:
color = 'blue'
else:
color = 'red'
latex_ag_file.write("\\draw [line width=0.5mm, "+color+"][ -latex ] (" +
str(start_x+node_size)+","+str(start_y+node_size*0.25) +
") -- ("+str(start_x+2*node_size)+","+str(start_y+node_size*0.25)+");\n")
if ag.has_edge(return_node_number(i+1, j, 0), return_node_number(i, j, 0)):
if shm.edges[(return_node_number(i+1, j, 0), return_node_number(i, j, 0))]["LinkHealth"]:
color = 'blue'
else:
color = 'red'
latex_ag_file.write("\\draw [line width=0.5mm, "+color+"][ -latex ] (" +
str(start_x+2*node_size)+","+str(start_y+node_size*0.75) +
") -- ("+str(start_x+node_size)+","+str(start_y+node_size*0.75)+");\n")
if j < Config.ag.y_size-1:
if ag.has_edge(return_node_number(i, j, 0), return_node_number(i, j+1, 0)):
if shm.edges[(return_node_number(i, j, 0), return_node_number(i, j+1, 0))]["LinkHealth"]:
color = 'blue'
else:
color = 'red'
latex_ag_file.write("\\draw [line width=.5mm, "+color+"][ -latex ] (" +
str(start_x+node_size*0.25)+"," + str(start_y+node_size) +
") -- ("+str(start_x+node_size*0.25)+","+str(start_y+node_size*2)+");\n")
if ag.has_edge(return_node_number(i, j+1, 0), return_node_number(i, j, 0)):
if shm.edges[(return_node_number(i, j+1, 0), return_node_number(i, j, 0))]["LinkHealth"]:
color = 'blue'
else:
color = 'red'
latex_ag_file.write("\\draw [line width=0.5mm, "+color+"][ -latex ] (" +
str(start_x+node_size*0.75)+","+str(start_y+node_size*2) +
") -- ("+str(start_x+node_size*0.75)+","+str(start_y+node_size)+");\n")
if j == Config.ag.y_size-1:
if ag.has_edge(return_node_number(i, j, 0), return_node_number(i, 0, 0)):
if shm.edges[(return_node_number(i, j, 0), return_node_number(i, 0, 0))]["LinkHealth"]:
color = 'blue'
else:
color = 'red'
latex_ag_file.write("\\draw [line width=.5mm, "+color+"][ -latex ] (" +
str(start_x+node_size)+"," + str(start_y) +
") to [bend left="+str(bend)+"] ("+str(start_x+node_size)+"," +
str(node_size)+");\n")
if ag.has_edge(return_node_number(i, 0, 0), return_node_number(i, j, 0)):
if shm.edges[(return_node_number(i, 0, 0), return_node_number(i, j, 0))]["LinkHealth"]:
color = 'blue'
else:
color = 'red'
latex_ag_file.write("\\draw [line width=.5mm, "+color+"][ -latex ] (" +
str(start_x)+"," + str(node_size) +
") to [bend left="+str(bend)+"] ("+str(start_x)+"," +
str(start_y)+");\n")
if i == Config.ag.x_size-1:
if ag.has_edge(return_node_number(i, j, 0), return_node_number(0, j, 0)):
if shm.edges[(return_node_number(i, j, 0), return_node_number(0, j, 0))]["LinkHealth"]:
color = 'blue'
else:
color = 'red'
latex_ag_file.write("\\draw [line width=.5mm, "+color+"][ -latex ] (" +
str(start_x)+"," + str(start_y) +
") to [bend left="+str(bend)+"] ("+str(node_size)+"," +
str(start_y)+");\n")
if ag.has_edge(return_node_number(0, j, 0), return_node_number(i, j, 0)):
if shm.edges[(return_node_number(0, j, 0), return_node_number(i, j, 0))]["LinkHealth"]:
color = 'blue'
else:
color = 'red'
latex_ag_file.write("\\draw [line width=.5mm, "+color+"][ -latex ] (" +
str(node_size)+"," + str(start_y+node_size) +
") to [bend left="+str(bend)+"] ("+str(start_x)+"," +
str(start_y+node_size)+");\n")
latex_ag_file.write("\\end{tikzpicture}\n")
latex_ag_file.write("\\end{document}\n")
latex_ag_file.close()
return None
