def get_benchmark_task(self,
trial_result_id,
benchmark_id,
num_cpus=1,
num_gpus=0,
memory_requirements='3GB',
expected_duration='1:00:00'):
"""
Get a task to benchmark a trial result.
Most of the parameters are resources requirements passed to the job system.
:param trial_result_id: The id of the trial result to benchmark
:param benchmark_id: The id of the benchmark to use
:param num_cpus: The number of CPUs required for the job. Default 1.
:param num_gpus: The number of GPUs required for the job. Default 0.
:param memory_requirements: The memory required for this job. Default 3 GB.
:param expected_duration: The expected time this job will take. Default 1 hour.
:return: A BenchmarkTrialTask
"""
existing = self._collection.find_one({
'trial_result_id': trial_result_id,
'benchmark_id': benchmark_id
})
if existing is not None:
return self._db_client.deserialize_entity(existing)
else:
return benchmark_task.BenchmarkTrialTask(
trial_result_id=trial_result_id,
benchmark_id=benchmark_id,
num_cpus=num_cpus,
num_gpus=num_gpus,
memory_requirements=memory_requirements,
expected_duration=expected_duration)
def setUp(self):
self.zombie_db_client = mock_client_factory.create()
self.mock_db_client = self.zombie_db_client.mock
# Create the basic image sources, systems, and benchmarks.
self.image_collections = [
make_image_collection(self.mock_db_client).identifier
for _ in range(2)
]
self.systems = [
self.mock_db_client.system_collection.insert_one(
mock_core.MockSystem().serialize()).inserted_id
for _ in range(2)
]
self.benchmarks = [
self.mock_db_client.benchmarks_collection.insert_one(
mock_core.MockBenchmark().serialize()).inserted_id
for _ in range(2)
]
# Create run system tasks and trial results
self.run_system_tasks = {}
self.trial_results = []
for image_collection_id in self.image_collections:
for system_id in self.systems:
trial_result_id = self.mock_db_client.trials_collection.insert_one(
core.trial_result.TrialResult(
system_id, True,
core.sequence_type.ImageSequenceType.NON_SEQUENTIAL,
{}).serialize()).inserted_id
self.trial_results.append(trial_result_id)
self.run_system_tasks[
trial_result_id] = self.mock_db_client.tasks_collection.insert_one(
run_system_task.RunSystemTask(
system_id,
image_collection_id,
result=trial_result_id,
state=batch_analysis.task.JobState.DONE).serialize(
)).inserted_id
self.benchmark_trial_tasks = {}
self.benchmark_results = {}
for trial_result_id in self.trial_results:
self.benchmark_trial_tasks[trial_result_id] = []
self.benchmark_results[trial_result_id] = []
for benchmark_id in self.benchmarks:
result_id = self.mock_db_client.results_collection.insert_one(
core.benchmark.BenchmarkResult(
benchmark_id, trial_result_id,
True).serialize()).inserted_id
self.benchmark_results[trial_result_id].append(result_id)
self.benchmark_trial_tasks[trial_result_id].append(
self.mock_db_client.tasks_collection.insert_one(
benchmark_trial_task.BenchmarkTrialTask(
trial_result_id,
benchmark_id,
result=result_id,
state=batch_analysis.task.JobState.DONE).serialize(
)).inserted_id)
def get_benchmark_task(self, trial_result_id, benchmark_id):
"""
Get a task to benchmark a trial result.
Most of the parameters are resources requirements passed to the job system.
:param trial_result_id: The id of the trial result to benchmark
:param benchmark_id: The id of the benchmark to use
:return: A BenchmarkTrialTask
"""
if trial_result_id not in self._benchmark_tasks:
self._benchmark_tasks[trial_result_id] = {}
if benchmark_id not in self._benchmark_tasks[trial_result_id]:
self._benchmark_tasks[trial_result_id][
benchmark_id] = btt.BenchmarkTrialTask(
trial_result_id=trial_result_id, benchmark_id=benchmark_id)
return self._benchmark_tasks[trial_result_id][benchmark_id]
def test_do_task_checks_benchmark_task_is_unique(self):
mock_collection = mock.create_autospec(pymongo.collection.Collection)
mock_db_client = mock.create_autospec(database.client.DatabaseClient)
subject = manager.TaskManager(mock_collection, mock_db_client)
trial_result_id = bson.ObjectId()
benchmark_id = bson.ObjectId()
task = benchmark_task.BenchmarkTrialTask(trial_result_id, benchmark_id)
subject.do_task(task)
self.assertTrue(mock_collection.find.called)
query = mock_collection.find.call_args[0][0]
self.assertIn('trial_result_id', query)
self.assertEqual(trial_result_id, query['trial_result_id'])
self.assertIn('benchmark_id', query)
self.assertEqual(benchmark_id, query['benchmark_id'])
def setUp(self):
self.zombie_db_client = mock_client_factory.create()
self.mock_db_client = self.zombie_db_client.mock
# Create benchmark results and tasks
self.benchmark_trial_tasks = {}
self.benchmark_results = []
for _ in range(2):
result_id = self.mock_db_client.results_collection.insert_one(
core.benchmark.BenchmarkResult(bson.ObjectId(),
bson.ObjectId(),
True).serialize()).inserted_id
self.benchmark_results.append(result_id)
self.benchmark_trial_tasks[
result_id] = self.mock_db_client.tasks_collection.insert_one(
benchmark_trial_task.BenchmarkTrialTask(
bson.ObjectId(),
bson.ObjectId(),
result=result_id,
state=batch_analysis.task.JobState.DONE).serialize()
).inserted_id
def setUp(self):
self.zombie_db_client = mock_client_factory.create()
self.mock_db_client = self.zombie_db_client.mock
# Create the basic trial results and benchmarks
self.trial_results = [
self.mock_db_client.trials_collection.insert_one(
core.trial_result.TrialResult(
bson.ObjectId(), True,
core.sequence_type.ImageSequenceType.NON_SEQUENTIAL,
{}).serialize()).inserted_id for _ in range(2)
]
self.benchmarks = [
self.mock_db_client.benchmarks_collection.insert_one(
mock_core.MockBenchmark().serialize()).inserted_id
for _ in range(2)
]
self.benchmark_trial_tasks = {}
self.benchmark_results = {}
# Create the benchmark results and tasks
for benchmark_id in self.benchmarks:
self.benchmark_trial_tasks[benchmark_id] = []
self.benchmark_results[benchmark_id] = []
for trial_result_id in self.trial_results:
result_id = self.mock_db_client.results_collection.insert_one(
core.benchmark.BenchmarkResult(
benchmark_id, trial_result_id,
True).serialize()).inserted_id
self.benchmark_results[benchmark_id].append(result_id)
self.benchmark_trial_tasks[benchmark_id].append(
self.mock_db_client.tasks_collection.insert_one(
benchmark_trial_task.BenchmarkTrialTask(
trial_result_id,
benchmark_id,
result=result_id,
state=batch_analysis.task.JobState.DONE).serialize(
)).inserted_id)