def test_allocates_mixed_tasks(self):
index = track.Task("index", op("index", track.OperationType.Bulk))
stats = track.Task("stats",
op("stats", track.OperationType.IndicesStats))
search = track.Task("search", op("search", track.OperationType.Search))
allocator = driver.Allocator([
index,
track.Parallel([index, stats, stats]), index, index,
track.Parallel([search, search, search])
])
self.assertEqual(3, allocator.clients)
# 1 join point, 1 op, 1 jp, 1 (parallel) op, 1 jp, 1 op, 1 jp, 1 op, 1 jp, 1 (parallel) op, 1 jp
self.assertEqual(11, len(allocator.allocations[0]))
self.assertEqual(11, len(allocator.allocations[1]))
self.assertEqual(11, len(allocator.allocations[2]))
self.assertEqual(6, len(allocator.join_points))
self.assertEqual([{index}, {index, stats}, {index}, {index}, {search}],
allocator.tasks_per_joinpoint)
for join_point in allocator.join_points:
self.assertFalse(join_point.preceding_task_completes_parent)
self.assertEqual(0,
join_point.num_clients_executing_completing_task)
def test_allocates_more_tasks_than_clients(self):
op1 = track.Operation("index-a", track.OperationType.Index, param_source="driver-test-param-source")
op2 = track.Operation("index-b", track.OperationType.Index, param_source="driver-test-param-source")
op3 = track.Operation("index-c", track.OperationType.Index, param_source="driver-test-param-source")
op4 = track.Operation("index-d", track.OperationType.Index, param_source="driver-test-param-source")
op5 = track.Operation("index-e", track.OperationType.Index, param_source="driver-test-param-source")
index_a = track.Task(op1)
index_b = track.Task(op2, completes_parent=True)
index_c = track.Task(op3)
index_d = track.Task(op4)
index_e = track.Task(op5)
allocator = driver.Allocator([track.Parallel(tasks=[index_a, index_b, index_c, index_d, index_e], clients=2)])
self.assertEqual(2, allocator.clients)
allocations = allocator.allocations
# 2 clients
self.assertEqual(2, len(allocations))
# join_point, index_a, index_c, index_e, join_point
self.assertEqual(5, len(allocations[0]))
# we really have no chance to extract the join point so we just take what is there...
self.assertEqual([allocations[0][0], index_a, index_c, index_e, allocations[0][4]], allocations[0])
# join_point, index_a, index_c, None, join_point
self.assertEqual(5, len(allocator.allocations[1]))
self.assertEqual([allocations[1][0], index_b, index_d, None, allocations[1][4]], allocations[1])
self.assertEqual([{op1, op2, op3, op4, op5}], allocator.operations_per_joinpoint)
self.assertEqual(2, len(allocator.join_points))
final_join_point = allocator.join_points[1]
self.assertTrue(final_join_point.preceding_task_completes_parent)
self.assertEqual(1, final_join_point.num_clients_executing_completing_task)
self.assertEqual([1], final_join_point.clients_executing_completing_task)
def test_allocates_mixed_tasks(self):
op1 = track.Operation("index",
track.OperationType.Index,
param_source="driver-test-param-source")
op2 = track.Operation("stats",
track.OperationType.IndicesStats,
param_source="driver-test-param-source")
op3 = track.Operation("search",
track.OperationType.Search,
param_source="driver-test-param-source")
index = track.Task(op1)
stats = track.Task(op2)
search = track.Task(op3)
allocator = driver.Allocator([
index,
track.Parallel([index, stats, stats]), index, index,
track.Parallel([search, search, search])
])
self.assertEqual(3, allocator.clients)
# 1 join point, 1 op, 1 jp, 1 (parallel) op, 1 jp, 1 op, 1 jp, 1 op, 1 jp, 1 (parallel) op, 1 jp
self.assertEqual(11, len(allocator.allocations[0]))
self.assertEqual(11, len(allocator.allocations[1]))
self.assertEqual(11, len(allocator.allocations[2]))
self.assertEqual(6, len(allocator.join_points))
self.assertEqual([{op1}, {op1, op2}, {op1}, {op1}, {op3}],
allocator.operations_per_joinpoint)
def test_considers_number_of_clients_per_subtask(self):
op1 = track.Operation("index-a", track.OperationType.Index, param_source="driver-test-param-source")
op2 = track.Operation("index-b", track.OperationType.Index, param_source="driver-test-param-source")
op3 = track.Operation("index-c", track.OperationType.Index, param_source="driver-test-param-source")
index_a = track.Task(op1)
index_b = track.Task(op2)
index_c = track.Task(op3, clients=2)
allocator = driver.Allocator([track.Parallel(tasks=[index_a, index_b, index_c], clients=3)])
self.assertEqual(3, allocator.clients)
allocations = allocator.allocations
self.assertEqual(3, len(allocations))
# join_point, index_a, index_c, join_point
self.assertEqual(4, len(allocations[0]))
# we really have no chance to extract the join point so we just take what is there...
self.assertEqual([allocations[0][0], index_a, index_c, allocations[0][3]], allocations[0])
# join_point, index_b, None, join_point
self.assertEqual(4, len(allocator.allocations[1]))
self.assertEqual([allocations[1][0], index_b, None, allocations[1][3]], allocations[1])
self.assertEqual(4, len(allocator.allocations[2]))
self.assertEqual([allocations[2][0], index_c, None, allocations[2][3]], allocations[2])
self.assertEqual([{op1, op2, op3}], allocator.operations_per_joinpoint)
def test_allocates_more_tasks_than_clients(self):
index_a = track.Task("index-a", op("index-a", track.OperationType.Bulk))
index_b = track.Task("index-b", op("index-b", track.OperationType.Bulk), completes_parent=True)
index_c = track.Task("index-c", op("index-c", track.OperationType.Bulk))
index_d = track.Task("index-d", op("index-d", track.OperationType.Bulk))
index_e = track.Task("index-e", op("index-e", track.OperationType.Bulk))
allocator = driver.Allocator([track.Parallel(tasks=[index_a, index_b, index_c, index_d, index_e], clients=2)])
self.assertEqual(2, allocator.clients)
allocations = allocator.allocations
# 2 clients
self.assertEqual(2, len(allocations))
# join_point, index_a, index_c, index_e, join_point
self.assertEqual(5, len(allocations[0]))
# we really have no chance to extract the join point so we just take what is there...
self.assertEqual([allocations[0][0], self.ta(index_a, 0), self.ta(index_c, 0), self.ta(index_e, 0), allocations[0][4]],
allocations[0])
# join_point, index_a, index_c, None, join_point
self.assertEqual(5, len(allocator.allocations[1]))
self.assertEqual([allocations[1][0], self.ta(index_b, 0), self.ta(index_d, 0), None, allocations[1][4]], allocations[1])
self.assertEqual([{index_a, index_b, index_c, index_d, index_e}], allocator.tasks_per_joinpoint)
self.assertEqual(2, len(allocator.join_points))
final_join_point = allocator.join_points[1]
self.assertTrue(final_join_point.preceding_task_completes_parent)
self.assertEqual(1, final_join_point.num_clients_executing_completing_task)
self.assertEqual([1], final_join_point.clients_executing_completing_task)
def test_allocates_one_task(self):
task = track.Task("index", op("index", track.OperationType.Bulk))
allocator = driver.Allocator([task])
self.assertEqual(1, allocator.clients)
self.assertEqual(3, len(allocator.allocations[0]))
self.assertEqual(2, len(allocator.join_points))
self.assertEqual([{task}], allocator.tasks_per_joinpoint)
def test_allocates_two_serial_tasks(self):
task = track.Task("index", op("index", track.OperationType.Bulk))
allocator = driver.Allocator([task, task])
self.assertEqual(1, allocator.clients)
# we have two operations and three join points
self.assertEqual(5, len(allocator.allocations[0]))
self.assertEqual(3, len(allocator.join_points))
self.assertEqual([{task}, {task}], allocator.tasks_per_joinpoint)
def test_allocates_one_task(self):
op = track.Operation("index", track.OperationType.Index, param_source="driver-test-param-source")
task = track.Task(op)
allocator = driver.Allocator([task])
self.assertEqual(1, allocator.clients)
self.assertEqual(3, len(allocator.allocations[0]))
self.assertEqual(2, len(allocator.join_points))
self.assertEqual([{op}], allocator.operations_per_joinpoint)
def test_considers_number_of_clients_per_subtask(self):
index_a = track.Task("index-a", op("index-a",
track.OperationType.Bulk))
index_b = track.Task("index-b", op("index-b",
track.OperationType.Bulk))
index_c = track.Task("index-c",
op("index-c", track.OperationType.Bulk),
clients=2,
completes_parent=True)
allocator = driver.Allocator(
[track.Parallel(tasks=[index_a, index_b, index_c], clients=3)])
self.assertEqual(3, allocator.clients)
allocations = allocator.allocations
# 3 clients
self.assertEqual(3, len(allocations))
# tasks that client 0 will execute:
# join_point, index_a, index_c, join_point
self.assertEqual(4, len(allocations[0]))
# we really have no chance to extract the join point so we just take what is there...
self.assertEqual([
allocations[0][0],
self.ta(index_a, 0),
self.ta(index_c, 1), allocations[0][3]
], allocations[0])
# task that client 1 will execute:
# join_point, index_b, None, join_point
self.assertEqual(4, len(allocator.allocations[1]))
self.assertEqual(
[allocations[1][0],
self.ta(index_b, 0), None, allocations[1][3]], allocations[1])
# tasks that client 2 will execute:
self.assertEqual(4, len(allocator.allocations[2]))
self.assertEqual(
[allocations[2][0],
self.ta(index_c, 0), None, allocations[2][3]], allocations[2])
self.assertEqual([{index_a, index_b, index_c}],
allocator.tasks_per_joinpoint)
self.assertEqual(2, len(allocator.join_points))
final_join_point = allocator.join_points[1]
self.assertTrue(final_join_point.preceding_task_completes_parent)
# task index_c has two clients, hence we have to wait for two clients to finish
self.assertEqual(
2, final_join_point.num_clients_executing_completing_task)
self.assertEqual([2, 0],
final_join_point.clients_executing_completing_task)
def test_allocates_two_serial_tasks(self):
op = track.Operation("index", track.OperationType.Index, param_source="driver-test-param-source")
task = track.Task(op)
allocator = driver.Allocator([task, task])
self.assertEqual(1, allocator.clients)
# we have two operations and three join points
self.assertEqual(5, len(allocator.allocations[0]))
self.assertEqual(3, len(allocator.join_points))
self.assertEqual([{op}, {op}], allocator.operations_per_joinpoint)
def test_allocates_two_parallel_tasks(self):
task = track.Task("index", op("index", track.OperationType.Bulk))
allocator = driver.Allocator([track.Parallel([task, task])])
self.assertEqual(2, allocator.clients)
self.assertEqual(3, len(allocator.allocations[0]))
self.assertEqual(3, len(allocator.allocations[1]))
self.assertEqual(2, len(allocator.join_points))
self.assertEqual([{task}], allocator.tasks_per_joinpoint)
for join_point in allocator.join_points:
self.assertFalse(join_point.preceding_task_completes_parent)
self.assertEqual(0, join_point.num_clients_executing_completing_task)
def test_allocates_two_parallel_tasks(self):
op = track.Operation("index", track.OperationType.Index, param_source="driver-test-param-source")
task = track.Task(op)
allocator = driver.Allocator([track.Parallel([task, task])])
self.assertEqual(2, allocator.clients)
self.assertEqual(3, len(allocator.allocations[0]))
self.assertEqual(3, len(allocator.allocations[1]))
self.assertEqual(2, len(allocator.join_points))
self.assertEqual([{op}], allocator.operations_per_joinpoint)
for join_point in allocator.join_points:
self.assertFalse(join_point.preceding_task_completes_parent)
self.assertEqual(0, join_point.num_clients_executing_completing_task)
def test_considers_number_of_clients_per_subtask(self):
op1 = track.Operation("index-a",
track.OperationType.Index,
param_source="driver-test-param-source")
op2 = track.Operation("index-b",
track.OperationType.Index,
param_source="driver-test-param-source")
op3 = track.Operation("index-c",
track.OperationType.Index,
param_source="driver-test-param-source")
index_a = track.Task(op1)
index_b = track.Task(op2)
index_c = track.Task(op3, clients=2, completes_parent=True)
allocator = driver.Allocator(
[track.Parallel(tasks=[index_a, index_b, index_c], clients=3)])
self.assertEqual(3, allocator.clients)
allocations = allocator.allocations
# 3 clients
self.assertEqual(3, len(allocations))
# join_point, index_a, index_c, join_point
self.assertEqual(4, len(allocations[0]))
# we really have no chance to extract the join point so we just take what is there...
self.assertEqual(
[allocations[0][0], index_a, index_c, allocations[0][3]],
allocations[0])
# join_point, index_b, None, join_point
self.assertEqual(4, len(allocator.allocations[1]))
self.assertEqual([allocations[1][0], index_b, None, allocations[1][3]],
allocations[1])
self.assertEqual(4, len(allocator.allocations[2]))
self.assertEqual([allocations[2][0], index_c, None, allocations[2][3]],
allocations[2])
self.assertEqual([{op1, op2, op3}], allocator.operations_per_joinpoint)
self.assertEqual(2, len(allocator.join_points))
final_join_point = allocator.join_points[1]
self.assertTrue(final_join_point.preceding_task_completes_parent)
# task index_c has two clients, hence we have to wait for two clients to finish
self.assertEqual(
2, final_join_point.num_clients_executing_completing_task)
self.assertEqual([2, 0],
final_join_point.clients_executing_completing_task)
def test_a_task_completes_the_parallel_structure(self):
taskA = track.Task("index-completing", op("index", track.OperationType.Bulk), completes_parent=True)
taskB = track.Task("index-non-completing", op("index", track.OperationType.Bulk))
allocator = driver.Allocator([track.Parallel([taskA, taskB])])
self.assertEqual(2, allocator.clients)
self.assertEqual(3, len(allocator.allocations[0]))
self.assertEqual(3, len(allocator.allocations[1]))
self.assertEqual(2, len(allocator.join_points))
self.assertEqual([{taskA, taskB}], allocator.tasks_per_joinpoint)
final_join_point = allocator.join_points[1]
self.assertTrue(final_join_point.preceding_task_completes_parent)
self.assertEqual(1, final_join_point.num_clients_executing_completing_task)
self.assertEqual([0], final_join_point.clients_executing_completing_task)
def test_a_task_completes_the_parallel_structure(self):
opA = track.Operation("index-completing", track.OperationType.Index, param_source="driver-test-param-source")
opB = track.Operation("index-non-completing", track.OperationType.Index, param_source="driver-test-param-source")
taskA = track.Task(opA, completes_parent=True)
taskB = track.Task(opB)
allocator = driver.Allocator([track.Parallel([taskA, taskB])])
self.assertEqual(2, allocator.clients)
self.assertEqual(3, len(allocator.allocations[0]))
self.assertEqual(3, len(allocator.allocations[1]))
self.assertEqual(2, len(allocator.join_points))
self.assertEqual([{opA, opB}], allocator.operations_per_joinpoint)
final_join_point = allocator.join_points[1]
self.assertTrue(final_join_point.preceding_task_completes_parent)
self.assertEqual(1, final_join_point.num_clients_executing_completing_task)
self.assertEqual([0], final_join_point.clients_executing_completing_task)
