def test_simulation_nofile_option(self):
simulation = Simulation(
self.env,
CONFIG,
self.instrument,
planning_algorithm='heft',
planning_model=SHADOWPlanning('heft'),
scheduling=DynamicAlgorithmFromPlan,
delay=None,
timestamp=None,
)
simdf, taskdf = simulation.start()
self.assertEqual(120, len(simdf))
self.env = simpy.Environment()
simulation = Simulation(
self.env,
CONFIG,
self.instrument,
planning_algorithm='fcfs',
planning_model=SHADOWPlanning('fcfs'),
scheduling=DynamicAlgorithmFromPlan,
delay=None,
timestamp=None,
# delimiters=f'test/{algorithm}'
)
simdf, taskdf = simulation.start()
self.assertEqual(128, len(simdf))
def setUp(self):
"""
Repeating above test cases but with delays to determine that delay
flags reach us.
Returns
-------
"""
self.env = simpy.Environment()
config = Config(INTEGRATION)
self.cluster = Cluster(self.env, config)
self.buffer = Buffer(self.env, self.cluster, config)
dm = DelayModel(0.9, "normal",
DelayModel.DelayDegree.HIGH)
self.planner = Planner(
self.env, PLANNING_ALGORITHM,
self.cluster, SHADOWPlanning('heft',delay_model=dm), delay_model=dm
)
self.scheduler = Scheduler(
self.env, self.buffer, self.cluster, DynamicAlgorithmFromPlan()
)
self.telescope = Telescope(
self.env, config, self.planner, self.scheduler
)
self.env.process(self.cluster.run())
self.env.process(self.buffer.run())
self.scheduler.start()
self.env.process(self.scheduler.run())
self.env.process(self.telescope.run())
def test_multi_simulation_data_merge(self):
# global_sim_df = pd.DataFrame()
# global_task_df = pd.DataFrame()
for algorithm in ['heft', 'fcfs']:
env = simpy.Environment()
simulation = Simulation(
env,
CONFIG,
self.instrument,
planning_algorithm=algorithm,
planning_model=SHADOWPlanning(algorithm),
scheduling=DynamicAlgorithmFromPlan,
delay=None,
timestamp='unittest',
hdf5_path='test/simulation_data/test_hdf5.h5',
to_file=True,
delimiters=f'{algorithm}')
simulation.start()
self.assertTrue(os.path.exists('test/simulation_data/test_hdf5.h5'))
heft_key = '/dunittest/heft/heft_single_observation_simulation/sim/'
fcfs_key = '/dunittest/fcfs/heft_single_observation_simulation/sim/'
heft_sim = pd.read_hdf('test/simulation_data/test_hdf5.h5',
key=heft_key)
self.assertEqual(120, len(heft_sim))
self.assertEqual(3, heft_sim.iloc[-1]['available_resources'])
def testBasicConfig(self):
simulation = Simulation(self.env,
CONFIG,
self.instrument,
planning_model=SHADOWPlanning('heft'),
planning_algorithm='heft',
scheduling=DynamicAlgorithmFromPlan,
timestamp=self.timestamp)
self.assertTrue(36, simulation.instrument.total_arrays)
def setUp(self) -> None:
env = simpy.Environment()
self.simulation = Simulation(
env,
LARGE_CONFIG,
Telescope,
planning_algorithm='heft',
planning_model=SHADOWPlanning('heft'),
scheduling=DynamicAlgorithmFromPlan,
delay=None,
timestamp=f'test/basic-workflow-data/output/{0}')
def setUp(self) -> None:
self.env = simpy.Environment()
config = Config(CONFIG)
self.cluster = Cluster(self.env, config)
self.buffer = Buffer(self.env, self.cluster, config)
self.scheduler = Scheduler(self.env, self.buffer, self.cluster,
DynamicAlgorithmFromPlan)
self.planner = Planner(self.env, PLANNING_ALGORITHM, self.cluster,
SHADOWPlanning('heft'))
# planner = None
self.telescope = Telescope(self.env, config, self.planner,
self.scheduler)
def setUp(self) -> None:
self.env = simpy.Environment()
self.simulation = Simulation(
self.env,
BASIC_CONFIG,
Telescope,
planning_algorithm='heft',
planning_model=SHADOWPlanning('heft'),
scheduling=DynamicAlgorithmFromPlan,
delay=None,
timestamp=SIM_TIMESTAMP
)
def setUp(self):
self.env = simpy.Environment()
sched_algorithm = DynamicAlgorithmFromPlan()
config = Config(LONG_CONFIG)
self.cluster = Cluster(self.env, config)
planning_model = SHADOWPlanning(algorithm=PLANNING_ALGORITHM)
self.planner = Planner(self.env, PLANNING_ALGORITHM, self.cluster,
planning_model)
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 setUp(self) -> None:
self.env = simpy.Environment()
self.config = Config(CONFIG)
self.cluster = Cluster(env=self.env, config=self.config)
self.buffer = Buffer(env=self.env,
cluster=self.cluster,
config=self.config)
self.scheduler = Scheduler(env=self.env,
buffer=self.buffer,
cluster=self.cluster,
algorithm=None)
self.planner = Planner(self.env, 'heft', self.cluster,
SHADOWPlanning('heft'))
def setUp(self):
self.env = simpy.Environment()
config = Config(INTEGRATION)
self.cluster = Cluster(self.env, config)
self.buffer = Buffer(self.env, self.cluster, config)
self.planner = Planner(self.env, PLANNING_ALGORITHM, self.cluster,
SHADOWPlanning('heft'))
self.scheduler = Scheduler(self.env, self.buffer, self.cluster,
DynamicAlgorithmFromPlan())
self.telescope = Telescope(self.env, config, self.planner,
self.scheduler)
self.env.process(self.cluster.run())
self.env.process(self.buffer.run())
self.scheduler.start()
self.env.process(self.scheduler.run())
self.env.process(self.telescope.run())
def setUp(self):
self.env = simpy.Environment()
config = Config(CONFIG)
self.model = SHADOWPlanning('heft')
self.cluster = Cluster(self.env, config=config)
self.buffer = Buffer(env=self.env, cluster=self.cluster, config=config)
self.planner = Planner(
self.env,
PLAN_ALGORITHM,
self.cluster,
self.model,
)
self.observation = Observation('planner_observation',
OBS_START_TME,
OBS_DURATION,
OBS_DEMAND,
OBS_WORKFLOW,
data_rate=OBS_DATA_RATE)
def setUp(self):
self.env = simpy.Environment()
sched_algorithm = DynamicAlgorithmFromPlan()
config = Config(HEFT_CONFIG)
dm = DelayModel(0.1, "normal")
self.model = SHADOWPlanning('heft', dm)
self.cluster = Cluster(self.env, config=config)
self.buffer = Buffer(self.env, self.cluster, config)
self.planner = Planner(self.env,
PLAN_ALGORITHM,
self.cluster,
self.model,
delay_model=dm)
self.observation = Observation('planner_observation',
OBS_START_TME,
OBS_DURATION,
OBS_DEMAND,
OBS_WORKFLOW,
data_rate=OBS_DATA_RATE)
def test_simulation_produces_file(self):
ts = f'{datetime.datetime(2021,1,1).strftime("%y_%m_%d_%H_%M_%S")}'
simulation = Simulation(self.env,
CONFIG,
Telescope,
planning_model=SHADOWPlanning('heft'),
planning_algorithm='heft',
scheduling=DynamicAlgorithmFromPlan,
delay=None,
timestamp=ts,
to_file=True,
hdf5_path=self.output)
simulation.start(runtime=60)
self.assertTrue(os.path.exists(self.output))
store = pd.HDFStore(self.output)
store[f'd{ts}/standard_simulation/sim']
def setUp(self) -> None:
"""
Basic simulation using a single observation + heft workflow +
homogenous system configuration.
Returns
-------
"""
env = simpy.Environment()
self.instrument = Telescope
self.simulation = Simulation(
env=env,
config=CONFIG,
instrument=self.instrument,
planning_algorithm='heft',
planning_model=SHADOWPlanning('heft'),
scheduling=DynamicAlgorithmFromPlan,
delay=None,
timestamp='unittest',
to_file=True,
hdf5_path='test/simulation_data/test_hdf5.h5',
delimiters=f'test/')
def setUp(self):
self.env = simpy.Environment()
config = Config(CONFIG)
self.model = SHADOWPlanning('heft')
self.cluster = Cluster(env=self.env, config=config)
self.buffer = Buffer(env=self.env, cluster=self.cluster, config=config)
