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