def test_unschedule_unit(self, mocked_init):
component = Continuous(cfg=None, session=None)
_, cfg = self.setUp()
unit = dict()
unit['description'] = cfg[1]['unit']['description']
unit['slots'] = cfg[1]['setup']['lm']['slots']
component.nodes = cfg[1]['setup']['lm']['slots']['nodes']
component._log = ru.Logger('dummy')
component.unschedule_unit(unit)
try:
self.assertEqual(component.nodes[0]['cores'], [0])
self.assertEqual(component.nodes[0]['gpus'], [0])
except:
with pytest.raises(AssertionError):
raise
def test_nonmpi_unit_with_continuous_scheduler(mocked_init, mocked_method,
mocked_profiler,
mocked_raise_on):
cfg, session = setUp()
component = Continuous(cfg=dict(), session=session)
component._lrms_info = cfg['lrms_info']
component._lrms_lm_info = cfg['lrms_info']['lm_info']
component._lrms_node_list = cfg['lrms_info']['node_list']
component._lrms_cores_per_node = cfg['lrms_info']['cores_per_node']
component._lrms_gpus_per_node = cfg['lrms_info']['gpus_per_node']
component._lrms_lfs_per_node = cfg['lrms_info']['lfs_per_node']
component._tag_history = dict()
component.nodes = []
for node, node_uid in component._lrms_node_list:
component.nodes.append(
copy.deepcopy({
'name': node,
'uid': node_uid,
'cores': [rpc.FREE] * component._lrms_cores_per_node,
'gpus': [rpc.FREE] * component._lrms_gpus_per_node,
'lfs': component._lrms_lfs_per_node
}))
# Allocate first CUD -- should land on first node
cud = nompi()
slot = component._allocate_slot(cud)
assert slot == {
'lm_info':
'INFO',
'cores_per_node':
2,
'gpus_per_node':
1,
'lfs_per_node':
component._lrms_lfs_per_node,
'nodes': [{
'core_map': [[0]],
'name': 'a',
'gpu_map': [],
'uid': 1,
'lfs': {
'size': 1024,
'path': 'abc'
}
}]
}
# Assert resulting node list values after first CUD
assert component.nodes == [{
'uid': 1,
'name': 'a',
'cores': [1, 0],
'gpus': [0],
'lfs': {
'size': 4096,
'path': 'abc'
}
}, {
'uid': 2,
'name': 'b',
'cores': [0, 0],
'gpus': [0],
'lfs': {
'size': 5120,
'path': 'abc'
}
}, {
'uid': 3,
'name': 'c',
'cores': [0, 0],
'gpus': [0],
'lfs': {
'size': 5120,
'path': 'abc'
}
}, {
'uid': 4,
'name': 'd',
'cores': [0, 0],
'gpus': [0],
'lfs': {
'size': 5120,
'path': 'abc'
}
}, {
'uid': 5,
'name': 'e',
'cores': [0, 0],
'gpus': [0],
'lfs': {
'size': 5120,
'path': 'abc'
}
}]
# Allocate second CUD -- should land on first node
cud = nompi()
slot = component._allocate_slot(cud)
assert slot == {
'lm_info':
'INFO',
'cores_per_node':
2,
'gpus_per_node':
1,
'lfs_per_node':
component._lrms_lfs_per_node,
'nodes': [{
'uid': 1,
'name': 'a',
'core_map': [[1]],
'gpu_map': [],
'lfs': {
'size': 1024,
'path': 'abc'
}
}]
}
# Allocate third CUD -- should land on second node
cud = nompi()
slot = component._allocate_slot(cud)
assert slot == {
'lm_info':
'INFO',
'gpus_per_node':
1,
'cores_per_node':
2,
'lfs_per_node':
component._lrms_lfs_per_node,
'nodes': [{
'uid': 2,
'name': 'b',
'core_map': [[0]],
'gpu_map': [],
'lfs': {
'size': 1024,
'path': 'abc'
}
}]
}
# Allocate four CUD -- should land on third node
cud = nompi()
cud['lfs_per_process'] = 5120
slot = component._allocate_slot(cud)
assert slot == {
'lm_info':
'INFO',
'cores_per_node':
2,
'gpus_per_node':
1,
'lfs_per_node':
component._lrms_lfs_per_node,
'nodes': [{
'uid': 3,
'name': 'c',
'core_map': [[0]],
'gpu_map': [],
'lfs': {
'size': 5120,
'path': 'abc'
}
}]
}
# Fail with ValueError if lfs required by cud is more than available
with pytest.raises(ValueError):
cud = nompi()
cud['lfs_per_process'] = 6000
slot = component._allocate_slot(cud)
# Max out available resources
# Allocate two CUDs -- should land on fourth and fifth node
cud = nompi()
cud['lfs_per_process'] = 5120
slot = component._allocate_slot(cud)
assert slot == {
'lm_info':
'INFO',
'cores_per_node':
2,
'gpus_per_node':
1,
'lfs_per_node':
component._lrms_lfs_per_node,
'nodes': [{
'uid': 4,
'name': 'd',
'core_map': [[0]],
'gpu_map': [],
'lfs': {
'size': 5120,
'path': 'abc'
}
}]
}
slot = component._allocate_slot(cud)
assert slot == {
'lm_info':
'INFO',
'cores_per_node':
2,
'gpus_per_node':
1,
'lfs_per_node':
component._lrms_lfs_per_node,
'nodes': [{
'uid': 5,
'name': 'e',
'core_map': [[0]],
'gpu_map': [],
'lfs': {
'size': 5120,
'path': 'abc'
}
}]
}
# Allocate CUD with to land on second node
cud = nompi()
cud['lfs_per_process'] = 4096
slot = component._allocate_slot(cud)
assert slot == {
'lm_info':
'INFO',
'cores_per_node':
2,
'gpus_per_node':
1,
'lfs_per_node':
component._lrms_lfs_per_node,
'nodes': [{
'uid': 2,
'name': 'b',
'core_map': [[1]],
'gpu_map': [],
'lfs': {
'size': 4096,
'path': 'abc'
}
}]
}
# Allocate CUD with no lfs requirement
cud = nompi()
cud['lfs_per_process'] = 0
slot = component._allocate_slot(cud)
assert slot == {
'lm_info':
'INFO',
'gpus_per_node':
1,
'cores_per_node':
2,
'lfs_per_node':
component._lrms_lfs_per_node,
'nodes': [{
'uid': 3,
'name': 'c',
'core_map': [[1]],
'gpu_map': [],
'lfs': {
'size': 0,
'path': 'abc'
}
}]
}
# Deallocate slot
component._release_slot(slot)
assert component.nodes == [{
'uid': 1,
'name': 'a',
'cores': [1, 1],
'gpus': [0],
'lfs': {
'size': 3072,
'path': 'abc'
}
}, {
'uid': 2,
'name': 'b',
'cores': [1, 1],
'gpus': [0],
'lfs': {
'size': 0,
'path': 'abc'
}
}, {
'uid': 3,
'name': 'c',
'cores': [1, 0],
'gpus': [0],
'lfs': {
'size': 0,
'path': 'abc'
}
}, {
'uid': 4,
'name': 'd',
'cores': [1, 0],
'gpus': [0],
'lfs': {
'size': 0,
'path': 'abc'
}
}, {
'uid': 5,
'name': 'e',
'cores': [1, 0],
'gpus': [0],
'lfs': {
'size': 0,
'path': 'abc'
}
}]
# Allocate CUD which cannot fit on available resources
cud = nompi()
cud['lfs_per_process'] = 5120
slot = component._allocate_slot(cud)
assert slot == None
# Deallocate third node
slot = {
'lm_info':
'INFO',
'gpus_per_node':
1,
'cores_per_node':
2,
'lfs_per_node':
component._lrms_lfs_per_node,
'nodes': [{
'uid': 3,
'name': 'c',
'core_map': [[0]],
'gpu_map': [],
'lfs': {
'path': 'abc',
'size': 5120
}
}]
}
component._release_slot(slot)
assert component.nodes == [{
'uid': 1,
'name': 'a',
'cores': [1, 1],
'gpus': [0],
'lfs': {
'size': 3072,
'path': 'abc'
}
}, {
'uid': 2,
'name': 'b',
'cores': [1, 1],
'gpus': [0],
'lfs': {
'size': 0,
'path': 'abc'
}
}, {
'uid': 3,
'name': 'c',
'cores': [0, 0],
'gpus': [0],
'lfs': {
'size': 5120,
'path': 'abc'
}
}, {
'uid': 4,
'name': 'd',
'cores': [1, 0],
'gpus': [0],
'lfs': {
'size': 0,
'path': 'abc'
}
}, {
'uid': 5,
'name': 'e',
'cores': [1, 0],
'gpus': [0],
'lfs': {
'size': 0,
'path': 'abc'
}
}]
# Allocate CUD to run multi threaded application
cud = nompi()
cud['cpu_processes'] = 1
cud['cpu_threads'] = 2
slot = component._allocate_slot(cud)
assert slot == {
'lm_info':
'INFO',
'gpus_per_node':
1,
'cores_per_node':
2,
'lfs_per_node':
component._lrms_lfs_per_node,
'nodes': [{
'uid': 3,
'name': 'c',
'core_map': [[0, 1]],
'gpu_map': [],
'lfs': {
'size': 1024,
'path': 'abc'
}
}]
}
assert component.nodes == [{
'uid': 1,
'name': 'a',
'cores': [1, 1],
'gpus': [0],
'lfs': {
'size': 3072,
'path': 'abc'
}
}, {
'uid': 2,
'name': 'b',
'cores': [1, 1],
'gpus': [0],
'lfs': {
'size': 0,
'path': 'abc'
}
}, {
'uid': 3,
'name': 'c',
'cores': [1, 1],
'gpus': [0],
'lfs': {
'size': 4096,
'path': 'abc'
}
}, {
'uid': 4,
'name': 'd',
'cores': [1, 0],
'gpus': [0],
'lfs': {
'size': 0,
'path': 'abc'
}
}, {
'uid': 5,
'name': 'e',
'cores': [1, 0],
'gpus': [0],
'lfs': {
'size': 0,
'path': 'abc'
}
}]
# Deallocate slot
component._release_slot(slot)
# Allocate CUD to run multi process, non-mpi application
cud = nompi()
cud['cpu_processes'] = 2
cud['cpu_threads'] = 1
cud['lfs_per_process'] = 1024
slot = component._allocate_slot(cud)
assert slot == {
'lm_info':
'INFO',
'gpus_per_node':
1,
'cores_per_node':
2,
'lfs_per_node':
component._lrms_lfs_per_node,
'nodes': [{
'uid': 3,
'name': 'c',
'core_map': [[0], [1]],
'gpu_map': [],
'lfs': {
'size': 2048,
'path': 'abc'
}
}]
}
assert component.nodes == [{
'uid': 1,
'name': 'a',
'cores': [1, 1],
'gpus': [0],
'lfs': {
'size': 3072,
'path': 'abc'
}
}, {
'uid': 2,
'name': 'b',
'cores': [1, 1],
'gpus': [0],
'lfs': {
'size': 0,
'path': 'abc'
}
}, {
'uid': 3,
'name': 'c',
'cores': [1, 1],
'gpus': [0],
'lfs': {
'size': 3072,
'path': 'abc'
}
}, {
'uid': 4,
'name': 'd',
'cores': [1, 0],
'gpus': [0],
'lfs': {
'size': 0,
'path': 'abc'
}
}, {
'uid': 5,
'name': 'e',
'cores': [1, 0],
'gpus': [0],
'lfs': {
'size': 0,
'path': 'abc'
}
}]
tearDown()
def test_mpi_unit_with_continuous_scheduler(mocked_init, mocked_method,
mocked_profiler, mocked_raise_on):
cfg, session = setUp()
component = Continuous(cfg={'owner': 'parent'}, session=session)
component._scattered = True
component._lrms_info = cfg['lrms_info']
component._lrms_lm_info = cfg['lrms_info']['lm_info']
component._lrms_node_list = cfg['lrms_info']['node_list']
component._lrms_cores_per_node = cfg['lrms_info']['cores_per_node']
component._lrms_gpus_per_node = cfg['lrms_info']['gpus_per_node']
component._lrms_lfs_per_node = cfg['lrms_info']['lfs_per_node']
component._tag_history = dict()
component._log = ru.get_logger('test.component')
component.nodes = []
for node, node_uid in component._lrms_node_list:
component.nodes.append(
copy.deepcopy({
'name': node,
'uid': node_uid,
'cores': [rpc.FREE] * component._lrms_cores_per_node,
'gpus': [rpc.FREE] * component._lrms_gpus_per_node,
'lfs': component._lrms_lfs_per_node
}))
# Allocate first CUD -- should land on first node
cud = mpi()
cud['cpu_processes'] = 2
cud['cpu_threads'] = 1
cud['lfs_per_process'] = 1024
slot = component._allocate_slot(cud)
assert slot == {
'cores_per_node':
component._lrms_cores_per_node,
'lfs_per_node':
component._lrms_lfs_per_node,
'nodes': [{
'lfs': {
'size': 2048,
'path': 'abc'
},
'core_map': [[0], [1]],
'name': 'a',
'gpu_map': [],
'uid': 1
}],
'lm_info':
'INFO',
'gpus_per_node':
component._lrms_gpus_per_node
}
# Assert resulting node list values after first CUD
assert component.nodes == [{
'lfs': {
'size': 3072,
'path': 'abc'
},
'cores': [1, 1, 0, 0],
'name': 'a',
'gpus': [0],
'uid': 1
}, {
'lfs': {
'size': 5120,
'path': 'abc'
},
'cores': [0, 0, 0, 0],
'name': 'b',
'gpus': [0],
'uid': 2
}, {
'lfs': {
'size': 5120,
'path': 'abc'
},
'cores': [0, 0, 0, 0],
'name': 'c',
'gpus': [0],
'uid': 3
}, {
'lfs': {
'size': 5120,
'path': 'abc'
},
'cores': [0, 0, 0, 0],
'name': 'd',
'gpus': [0],
'uid': 4
}, {
'lfs': {
'size': 5120,
'path': 'abc'
},
'cores': [0, 0, 0, 0],
'name': 'e',
'gpus': [0],
'uid': 5
}]
# Allocate second CUD -- should land on first node
cud = mpi()
cud['cpu_processes'] = 1
cud['cpu_threads'] = 2
cud['lfs_per_process'] = 1024
slot = component._allocate_slot(cud)
assert slot == {
'cores_per_node':
component._lrms_cores_per_node,
'lfs_per_node':
component._lrms_lfs_per_node,
'nodes': [{
'lfs': {
'size': 1024,
'path': 'abc'
},
'core_map': [[2, 3]],
'name': 'a',
'gpu_map': [],
'uid': 1
}],
'lm_info':
'INFO',
'gpus_per_node':
component._lrms_gpus_per_node
}
# Assert resulting node list values after second CUD
assert component.nodes == [{
'lfs': {
'size': 2048,
'path': 'abc'
},
'cores': [1, 1, 1, 1],
'name': 'a',
'gpus': [0],
'uid': 1
}, {
'lfs': {
'size': 5120,
'path': 'abc'
},
'cores': [0, 0, 0, 0],
'name': 'b',
'gpus': [0],
'uid': 2
}, {
'lfs': {
'size': 5120,
'path': 'abc'
},
'cores': [0, 0, 0, 0],
'name': 'c',
'gpus': [0],
'uid': 3
}, {
'lfs': {
'size': 5120,
'path': 'abc'
},
'cores': [0, 0, 0, 0],
'name': 'd',
'gpus': [0],
'uid': 4
}, {
'lfs': {
'size': 5120,
'path': 'abc'
},
'cores': [0, 0, 0, 0],
'name': 'e',
'gpus': [0],
'uid': 5
}]
# Allocate third CUD -- should land on second node since no cores are
# available on the first
cud = mpi()
cud['cpu_processes'] = 1
cud['cpu_threads'] = 1
cud['lfs_per_process'] = 1024
slot = component._allocate_slot(cud)
assert slot == {
'cores_per_node':
component._lrms_cores_per_node,
'lfs_per_node':
component._lrms_lfs_per_node,
'nodes': [{
'lfs': {
'size': 1024,
'path': 'abc'
},
'core_map': [[0]],
'name': 'b',
'gpu_map': [],
'uid': 2
}],
'lm_info':
'INFO',
'gpus_per_node':
component._lrms_gpus_per_node
}
# Assert resulting node list values after third CUD
assert component.nodes == [{
'lfs': {
'size': 2048,
'path': 'abc'
},
'cores': [1, 1, 1, 1],
'name': 'a',
'gpus': [0],
'uid': 1
}, {
'lfs': {
'size': 4096,
'path': 'abc'
},
'cores': [1, 0, 0, 0],
'name': 'b',
'gpus': [0],
'uid': 2
}, {
'lfs': {
'size': 5120,
'path': 'abc'
},
'cores': [0, 0, 0, 0],
'name': 'c',
'gpus': [0],
'uid': 3
}, {
'lfs': {
'size': 5120,
'path': 'abc'
},
'cores': [0, 0, 0, 0],
'name': 'd',
'gpus': [0],
'uid': 4
}, {
'lfs': {
'size': 5120,
'path': 'abc'
},
'cores': [0, 0, 0, 0],
'name': 'e',
'gpus': [0],
'uid': 5
}]
# Allocate fourth CUD -- should land on second and third nodes
cud = mpi()
cud['cpu_processes'] = 2
cud['cpu_threads'] = 2
cud['lfs_per_process'] = 1024
slot = component._allocate_slot(cud)
assert slot == {
'cores_per_node':
component._lrms_cores_per_node,
'lfs_per_node':
component._lrms_lfs_per_node,
'nodes': [{
'lfs': {
'size': 1024,
'path': 'abc'
},
'core_map': [[1, 2]],
'name': 'b',
'gpu_map': [],
'uid': 2
}, {
'lfs': {
'size': 1024,
'path': 'abc'
},
'core_map': [[0, 1]],
'name': 'c',
'gpu_map': [],
'uid': 3
}],
'lm_info':
'INFO',
'gpus_per_node':
component._lrms_gpus_per_node
}
# Assert resulting node list values after fourth CUD
assert component.nodes == [{
'lfs': {
'size': 2048,
'path': 'abc'
},
'cores': [1, 1, 1, 1],
'name': 'a',
'gpus': [0],
'uid': 1
}, {
'lfs': {
'size': 3072,
'path': 'abc'
},
'cores': [1, 1, 1, 0],
'name': 'b',
'gpus': [0],
'uid': 2
}, {
'lfs': {
'size': 4096,
'path': 'abc'
},
'cores': [1, 1, 0, 0],
'name': 'c',
'gpus': [0],
'uid': 3
}, {
'lfs': {
'size': 5120,
'path': 'abc'
},
'cores': [0, 0, 0, 0],
'name': 'd',
'gpus': [0],
'uid': 4
}, {
'lfs': {
'size': 5120,
'path': 'abc'
},
'cores': [0, 0, 0, 0],
'name': 'e',
'gpus': [0],
'uid': 5
}]
# Deallocate slot
component._release_slot(slot)
assert component.nodes == [{
'lfs': {
'size': 2048,
'path': 'abc'
},
'cores': [1, 1, 1, 1],
'name': 'a',
'gpus': [0],
'uid': 1
}, {
'lfs': {
'size': 4096,
'path': 'abc'
},
'cores': [1, 0, 0, 0],
'name': 'b',
'gpus': [0],
'uid': 2
}, {
'lfs': {
'size': 5120,
'path': 'abc'
},
'cores': [0, 0, 0, 0],
'name': 'c',
'gpus': [0],
'uid': 3
}, {
'lfs': {
'size': 5120,
'path': 'abc'
},
'cores': [0, 0, 0, 0],
'name': 'd',
'gpus': [0],
'uid': 4
}, {
'lfs': {
'size': 5120,
'path': 'abc'
},
'cores': [0, 0, 0, 0],
'name': 'e',
'gpus': [0],
'uid': 5
}]
tearDown()
def test_mpi_unit_with_tagging(mocked_init, mocked_method, mocked_profiler,
mocked_raise_on):
cfg, session = setUp()
component = Continuous(cfg=dict(), session=session)
component._lrms_info = cfg['lrms_info']
component._lrms_lm_info = cfg['lrms_info']['lm_info']
component._lrms_node_list = cfg['lrms_info']['node_list']
component._lrms_cores_per_node = cfg['lrms_info']['cores_per_node']
component._lrms_gpus_per_node = cfg['lrms_info']['gpus_per_node']
component._lrms_lfs_per_node = cfg['lrms_info']['lfs_per_node']
component._slot_lock = threading.RLock()
component._scattered = True
component._log = ru.Logger('test.component')
component._prof = ru.Profiler('test')
component._tag_history = dict()
component.nodes = []
for node, node_uid in component._lrms_node_list:
component.nodes.append(
copy.deepcopy({
'name': node,
'uid': node_uid,
'cores': [rpc.FREE] * component._lrms_cores_per_node,
'gpus': [rpc.FREE] * component._lrms_gpus_per_node,
'lfs': component._lrms_lfs_per_node
}))
# Allocate first CUD -- should land on first node
cu = mpi()
cu['uid'] = 'unit.000000'
cu['description']['cpu_processes'] = 2
cu['description']['cpu_threads'] = 1
cu['description']['lfs_per_process'] = 1024
component._try_allocation(cu)
slot1 = cu['slots']
assert component._tag_history == {'unit.000000': [1]}
assert slot1 == {
'cores_per_node':
2,
'lfs_per_node':
component._lrms_lfs_per_node,
'nodes': [{
'lfs': {
'size': 2048,
'path': 'abc'
},
'core_map': [[0], [1]],
'name': 'a',
'gpu_map': [],
'uid': 1
}],
'lm_info':
'INFO',
'gpus_per_node':
1
}
# Assert resulting node list values after first CUD
assert component.nodes == [{
'lfs': {
'size': 3072,
'path': 'abc'
},
'cores': [1, 1],
'name': 'a',
'gpus': [0],
'uid': 1
}, {
'lfs': {
'size': 5120,
'path': 'abc'
},
'cores': [0, 0],
'name': 'b',
'gpus': [0],
'uid': 2
}, {
'lfs': {
'size': 5120,
'path': 'abc'
},
'cores': [0, 0],
'name': 'c',
'gpus': [0],
'uid': 3
}, {
'lfs': {
'size': 5120,
'path': 'abc'
},
'cores': [0, 0],
'name': 'd',
'gpus': [0],
'uid': 4
}, {
'lfs': {
'size': 5120,
'path': 'abc'
},
'cores': [0, 0],
'name': 'e',
'gpus': [0],
'uid': 5
}]
# Allocate second CUD -- should return None as the first node is
# not yet released
cu = mpi()
cu['uid'] = 'unit.000001'
cu['description']['tag'] = 'unit.000000'
component._try_allocation(cu)
slot2 = cu['slots']
assert slot2 == None
assert component._tag_history == {'unit.000000': [1]}
# Allocate third CUD -- should land on second and third node
cu = mpi()
cu['uid'] = 'unit.000002'
cu['description']['cpu_processes'] = 2
cu['description']['cpu_threads'] = 2
component._try_allocation(cu)
slot3 = cu['slots']
assert slot3 == {
'cores_per_node':
2,
'lfs_per_node':
component._lrms_lfs_per_node,
'nodes': [{
'lfs': {
'size': 1024,
'path': 'abc'
},
'core_map': [[0, 1]],
'name': 'b',
'gpu_map': [],
'uid': 2
}, {
'lfs': {
'size': 1024,
'path': 'abc'
},
'core_map': [[0, 1]],
'name': 'c',
'gpu_map': [],
'uid': 3
}],
'lm_info':
'INFO',
'gpus_per_node':
1
}
assert component._tag_history == {
'unit.000000': [1],
'unit.000002': [2, 3]
}
# Assert resulting node list values after second CUDslot release
assert component.nodes == [{
'lfs': {
'size': 3072,
'path': 'abc'
},
'cores': [1, 1],
'name': 'a',
'gpus': [0],
'uid': 1
}, {
'lfs': {
'size': 4096,
'path': 'abc'
},
'cores': [1, 1],
'name': 'b',
'gpus': [0],
'uid': 2
}, {
'lfs': {
'size': 4096,
'path': 'abc'
},
'cores': [1, 1],
'name': 'c',
'gpus': [0],
'uid': 3
}, {
'lfs': {
'size': 5120,
'path': 'abc'
},
'cores': [0, 0],
'name': 'd',
'gpus': [0],
'uid': 4
}, {
'lfs': {
'size': 5120,
'path': 'abc'
},
'cores': [0, 0],
'name': 'e',
'gpus': [0],
'uid': 5
}]
# Allocate fourth CUD -- should return None as the second node is not
# yet released
cu = mpi()
cu['uid'] = 'unit.000003'
cu['description']['cpu_threads'] = 2
cu['description']['tag'] = 'unit.000002'
component._try_allocation(cu)
slot4 = cu['slots']
assert slot4 == None
assert component._tag_history == {
'unit.000000': [1],
'unit.000002': [2, 3]
}
# Release first node and allocate second CUD again
component._release_slot(slot1)
assert component.nodes == [{
'lfs': {
'size': 5120,
'path': 'abc'
},
'cores': [0, 0],
'name': 'a',
'gpus': [0],
'uid': 1
}, {
'lfs': {
'size': 4096,
'path': 'abc'
},
'cores': [1, 1],
'name': 'b',
'gpus': [0],
'uid': 2
}, {
'lfs': {
'size': 4096,
'path': 'abc'
},
'cores': [1, 1],
'name': 'c',
'gpus': [0],
'uid': 3
}, {
'lfs': {
'size': 5120,
'path': 'abc'
},
'cores': [0, 0],
'name': 'd',
'gpus': [0],
'uid': 4
}, {
'lfs': {
'size': 5120,
'path': 'abc'
},
'cores': [0, 0],
'name': 'e',
'gpus': [0],
'uid': 5
}]
cu = mpi()
cu['uid'] = 'unit.000001'
cu['description']['tag'] = 'unit.000000'
component._try_allocation(cu)
slot2 = cu['slots']
assert slot2 == {
'cores_per_node':
2,
'lfs_per_node':
component._lrms_lfs_per_node,
'nodes': [{
'lfs': {
'size': 1024,
'path': 'abc'
},
'core_map': [[0]],
'name': 'a',
'gpu_map': [],
'uid': 1
}],
'lm_info':
'INFO',
'gpus_per_node':
1
}
assert component._tag_history == {
'unit.000000': [1],
'unit.000001': [1],
'unit.000002': [2, 3]
}
# Release second and third nodes and allocate fourth CUD again
component._release_slot(slot3)
assert component.nodes == [{
'lfs': {
'size': 4096,
'path': 'abc'
},
'cores': [1, 0],
'name': 'a',
'gpus': [0],
'uid': 1
}, {
'lfs': {
'size': 5120,
'path': 'abc'
},
'cores': [0, 0],
'name': 'b',
'gpus': [0],
'uid': 2
}, {
'lfs': {
'size': 5120,
'path': 'abc'
},
'cores': [0, 0],
'name': 'c',
'gpus': [0],
'uid': 3
}, {
'lfs': {
'size': 5120,
'path': 'abc'
},
'cores': [0, 0],
'name': 'd',
'gpus': [0],
'uid': 4
}, {
'lfs': {
'size': 5120,
'path': 'abc'
},
'cores': [0, 0],
'name': 'e',
'gpus': [0],
'uid': 5
}]
cu = mpi()
cu['uid'] = 'unit.000003'
cu['description']['tag'] = 'unit.000002'
cu['description']['cpu_threads'] = 2
component._try_allocation(cu)
slot4 = cu['slots']
assert slot4 == {
'cores_per_node':
2,
'lfs_per_node':
component._lrms_lfs_per_node,
'nodes': [{
'lfs': {
'size': 1024,
'path': 'abc'
},
'core_map': [[0, 1]],
'name': 'b',
'gpu_map': [],
'uid': 2
}],
'lm_info':
'INFO',
'gpus_per_node':
1
}
assert component._tag_history == {
'unit.000000': [1],
'unit.000001': [1],
'unit.000002': [2, 3],
'unit.000003': [2]
}
assert component.nodes == [{
'lfs': {
'size': 4096,
'path': 'abc'
},
'cores': [1, 0],
'name': 'a',
'gpus': [0],
'uid': 1
}, {
'lfs': {
'size': 4096,
'path': 'abc'
},
'cores': [1, 1],
'name': 'b',
'gpus': [0],
'uid': 2
}, {
'lfs': {
'size': 5120,
'path': 'abc'
},
'cores': [0, 0],
'name': 'c',
'gpus': [0],
'uid': 3
}, {
'lfs': {
'size': 5120,
'path': 'abc'
},
'cores': [0, 0],
'name': 'd',
'gpus': [0],
'uid': 4
}, {
'lfs': {
'size': 5120,
'path': 'abc'
},
'cores': [0, 0],
'name': 'e',
'gpus': [0],
'uid': 5
}]
tearDown()
def test_find_resources(self, mocked_init, mocked_configure):
_, cfg = self.setUp()
component = Continuous(cfg=None, session=None)
component.node = {
'name': 'a',
'uid': 2,
'cores': [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
'lfs': {
"size": 1234,
"path": "/dev/null"
},
'mem': 1024,
'gpus': [0, 0]
}
component._log = ru.Logger('dummy')
component._rm_lfs_per_node = {"path": "/dev/null", "size": 1234}
component.cores_per_slot = 16
component.gpus_per_slot = 2
component.lfs_per_slot = 1234
component.mem_per_slot = 1024
component.find_slot = 1
try:
test_slot = component._find_resources(
node=component.node,
find_slots=component.find_slot,
cores_per_slot=component.cores_per_slot,
gpus_per_slot=component.gpus_per_slot,
lfs_per_slot=component.lfs_per_slot,
mem_per_slot=component.mem_per_slot,
partial='None')
self.assertEqual([cfg[1]['setup']['lm']['slots']], test_slot)
except:
with pytest.raises(AssertionError):
raise
def test_configure(self, mocked_init):
cfg, _ = self.setUp()
component = Continuous(cfg=None, session=None)
component._cfg = mock.Mock()
component._log = ru.Logger('dummy')
component._rm_node_list = [["a", 1], ["b", 2], ["c", 3]]
component._rm_cores_per_node = 8
component._rm_gpus_per_node = 2
component._rm_lfs_per_node = {"path": "/dev/null", "size": 0}
component._rm_mem_per_node = 128
component.nodes = [{
'name': 'a',
'uid': 2,
'cores': [1, 2, 3, 4, 6, 0, 9, 8],
'lfs': {
"size": 1234,
"path": "/dev/null"
},
'mem': 1024,
'gpus': [1, 2]
}]
try:
for i in range(len(cfg['cfg']['rm_info'])):
rm_info = cfg['cfg']['rm_info'][i]
component._configure()
self.assertEqual(component.nodes[0]['cores'],
[rpc.FREE] * rm_info['cores_per_node'])
self.assertEqual(component.nodes[0]['gpus'],
[rpc.FREE] * rm_info['gpus_per_node'])
except:
with pytest.raises(AssertionError):
component._configure()
raise
def test_schedule_unit(self, mocked_init, mocked_configure,
mocked_find_resources):
_, cfg = self.setUp()
component = Continuous(cfg=None, session=None)
unit = dict()
unit['uid'] = cfg[1]['unit']['uid']
unit['description'] = cfg[1]['unit']['description']
component.nodes = cfg[1]['setup']['lm']['slots']['nodes']
component._rm_cores_per_node = 32
component._rm_gpus_per_node = 2
component._rm_lfs_per_node = {"size": 0, "path": "/dev/null"}
component._rm_mem_per_node = 1024
component._rm_lm_info = 'INFO'
component._log = ru.Logger('dummy')
component._node_offset = 0
test_slot = {
'cores_per_node':
32,
'gpus_per_node':
2,
'lfs_per_node': {
'path': '/dev/null',
'size': 0
},
'lm_info':
'INFO',
'mem_per_node':
1024,
'nodes': [{
'core_map': [[0]],
'gpu_map': [[0]],
'lfs': {
'path': '/dev/null',
'size': 1234
},
'mem': 128,
'name': 'a',
'uid': 1
}]
}
try:
self.assertEqual(component.schedule_unit(unit), test_slot)
except:
with pytest.raises(AssertionError):
raise