class TestSchedulerDynamicReAllocation(unittest.TestCase):
def setUp(self) -> None:
self.env = simpy.Environment()
sched_algorithm = GreedyAlgorithmFromPlan()
config = Config(LONG_CONFIG)
self.cluster = Cluster(self.env, config)
self.planner = Planner(self.env, PLANNING_ALGORITHM, self.cluster,
SHADOWPlanning('heft'))
self.buffer = Buffer(self.env, self.cluster, config)
self.scheduler = Scheduler(self.env, self.buffer, self.cluster,
sched_algorithm)
self.telescope = Telescope(self.env, config, self.planner,
self.scheduler)
def test_reallocation_with_plan(self):
curr_obs = self.telescope.observations[0]
self.scheduler.observation_queue.append(curr_obs)
curr_obs.ast = self.env.now
curr_obs.plan = self.planner.run(curr_obs, self.buffer,
self.telescope.max_ingest)
self.env.process(self.scheduler.allocate_tasks(curr_obs))
self.env.run(1)
self.buffer.cold[0].observations['stored'].append(curr_obs)
self.env.run(until=299)
self.assertEqual(0, len(self.scheduler.observation_queue))
class TestSchedulerDynamicPlanAllocation(unittest.TestCase):
def setUp(self):
self.env = simpy.Environment()
sched_algorithm = DynamicAlgorithmFromPlan()
config = Config(HEFT_CONFIG)
self.cluster = Cluster(self.env, config)
self.planner = Planner(self.env, PLANNING_ALGORITHM, self.cluster,
SHADOWPlanning('heft'))
self.buffer = Buffer(self.env, self.cluster, config)
self.scheduler = Scheduler(self.env, self.buffer, self.cluster,
sched_algorithm)
self.telescope = Telescope(self.env, config, self.planner,
self.scheduler)
def tearDown(self):
pass
def testAllocationTasksNoObservation(self):
"""
allocate_tasks assumes we have:
* An observation stored in the ColdBuffer
* A plan stored for that observation
* Access to a scheduling algorithm (in this case, FifoAlgorithm).
Need to check:
* If there is no current observation, we can't do anthing
* If there is an observation, but no plan, we assign the
observation planto the current_plan.
* Once things are running, we make sure things are being
scheduled onto the right machines
* They should also be running for the correct period of time.
The allocations for the HEFT algorithm are (in sorted order):
id - mid - (ast,aft)
0 - cat2_m2 - (0,11)
3 - cat2_m2 - (11,21)
2 - cat2_m2 - (21,30)
4 - cat1_m1 - (22, 40)
1 - cat0_m0 - (29,42)
5 - cat2_m2 - (30,45)
6 - cat2_m2 - (45, 55)
8 - cat2_m2 - (58, 71)
7 - cat0_m0 - (60, 61)
9 - cat0_m0 - (84,98)
"""
curr_obs = self.telescope.observations[0]
gen = self.scheduler.allocate_tasks(curr_obs)
self.assertRaises(RuntimeError, next, gen)
l = [0, 3, 2, 4, 1, 5, 6, 8, 7, 9]
exec_ord = [
curr_obs.name + '_' + str(self.env.now) + '_' + str(tid)
for tid in l
]
self.scheduler.observation_queue.append(curr_obs)
curr_obs.ast = self.env.now
curr_obs.plan = self.planner.run(curr_obs, self.buffer,
self.telescope.max_ingest)
self.env.process(self.scheduler.allocate_tasks(curr_obs))
self.env.run(1)
self.assertListEqual(l, [a.task.tid for a in curr_obs.plan.exec_order])
self.buffer.cold[0].observations['stored'].append(curr_obs)
self.env.run(until=99)
self.assertEqual(10, len(self.cluster._tasks['finished']))
self.assertEqual(0, len(self.cluster._tasks['running']))
self.assertEqual(0, len(self.scheduler.observation_queue))
