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)