def add_new_machine(self, config):
memory = int(config.split()[0])
mapSlots = int(config.split()[1])
redSlots = int(config.split()[2])
self.cluster.totalMapSlots += mapSlots
self.cluster.totalRedSlots += redSlots
self.cluster.nodes.append(NodeManager(self, memory, mapSlots,
redSlots))
def init(self):
self._nodeManager = NodeManager()
self._connectionManager = ConnectionManager()
self._viewerManager = ViewerManager()
# connect undoRedoChanged signal
self._nodeManager.undoRedoChanged.connect(self.emitUndoRedoChanged)
self._connectionManager.undoRedoChanged.connect(
self.emitUndoRedoChanged)
self._viewerManager.undoRedoChanged.connect(self.emitUndoRedoChanged)
return self
def handle_overflow(self, u):
u1, u2 = self.split(u)
# if u is root, create a new root with s1 and s2 as its' children
if u.check_root():
new_root = NodeManager()
self.add_child_node(new_root, u1)
self.add_child_node(new_root, u2)
self.root = new_root
self.update_mbr(new_root)
# if u is not root, delete u, and set s1 and s2 as u's parent's new children
else:
w = u.parent
# copy the information of s1 into u
w.child_nodes.remove(u)
self.add_child_node(w, u1)
self.add_child_node(w, u2)
if w.check_overflow():
self.handle_overflow(w)
self.update_mbr(w)
def __init__(self):
self.root = NodeManager()
def split(self, u):
# split u into s1 and s2
best_s1 = NodeManager()
best_s2 = NodeManager()
best_perimeter = sys.maxsize
# u is a leaf node
if u.check_leaf():
m = u.data_points.__len__()
# create two different kinds of divides
divides = [
sorted(u.data_points, key=lambda data_point: data_point['x']),
sorted(u.data_points, key=lambda data_point: data_point['y'])
]
for divide in divides:
for i in range(math.ceil(0.4 * B), m - math.ceil(0.4 * B) + 1):
s1 = NodeManager()
s1.data_points = divide[0:i]
self.update_mbr(s1)
s2 = NodeManager()
s2.data_points = divide[i:divide.__len__()]
self.update_mbr(s2)
if best_perimeter > s1.calculate_perimeter(
) + s2.calculate_perimeter():
best_perimeter = s1.calculate_perimeter(
) + s2.calculate_perimeter()
best_s1 = s1
best_s2 = s2
# u is a internal node
else:
# create four different kinds of divides
m = u.child_nodes.__len__()
divides = [
sorted(u.child_nodes,
key=lambda child_node: child_node.MBR['x_min']),
sorted(u.child_nodes,
key=lambda child_node: child_node.MBR['x_max']),
sorted(u.child_nodes,
key=lambda child_node: child_node.MBR['y_min']),
sorted(u.child_nodes,
key=lambda child_node: child_node.MBR['y_max'])
]
for divide in divides:
for i in range(math.ceil(0.4 * B), m - math.ceil(0.4 * B) + 1):
s1 = NodeManager()
s1.child_nodes = divide[0:i]
self.update_mbr(s1)
s2 = NodeManager()
s2.child_nodes = divide[i:divide.__len__()]
self.update_mbr(s2)
if best_perimeter > s1.calculate_perimeter(
) + s2.calculate_perimeter():
best_perimeter = s1.calculate_perimeter(
) + s2.calculate_perimeter()
best_s1 = s1
best_s2 = s2
for child in best_s1.child_nodes:
child.parent = best_s1
for child in best_s2.child_nodes:
child.parent = best_s2
return best_s1, best_s2
