| |
| |
| |
| import os |
| from unittest.mock import patch |
|
|
| import pytest |
|
|
| from haystack.utils import ComponentDevice, Device, DeviceMap, DeviceType |
|
|
|
|
| def test_device_type(): |
| for e in DeviceType: |
| assert e == DeviceType.from_str(e.value) |
|
|
| with pytest.raises(ValueError, match="Unknown device type string"): |
| DeviceType.from_str("tpu") |
|
|
|
|
| def test_device_creation(): |
| assert Device.cpu().type == DeviceType.CPU |
| assert Device.gpu().type == DeviceType.GPU |
| assert Device.mps().type == DeviceType.MPS |
| assert Device.disk().type == DeviceType.DISK |
|
|
| assert Device.from_str("cpu") == Device.cpu() |
| assert Device.from_str("cuda:1") == Device.gpu(1) |
| assert Device.from_str("disk") == Device.disk() |
| assert Device.from_str("mps:0") == Device(DeviceType.MPS, 0) |
|
|
| with pytest.raises(ValueError, match="Device id must be >= 0"): |
| Device.gpu(-1) |
|
|
|
|
| def test_device_map(): |
| map = DeviceMap({"layer1": Device.cpu(), "layer2": Device.gpu(1), "layer3": Device.disk()}) |
|
|
| assert all(x in map for x in ["layer1", "layer2", "layer3"]) |
| assert len(map) == 3 |
| assert map["layer1"] == Device.cpu() |
| assert map["layer2"] == Device.gpu(1) |
| assert map["layer3"] == Device.disk() |
|
|
| for k, d in map: |
| assert k in ["layer1", "layer2", "layer3"] |
| assert d in [Device.cpu(), Device.gpu(1), Device.disk()] |
|
|
| map["layer1"] = Device.gpu(0) |
| assert map["layer1"] == Device.gpu(0) |
|
|
| map["layer2"] = Device.cpu() |
| assert DeviceMap.from_hf({"layer1": 0, "layer2": "cpu", "layer3": "disk"}) == DeviceMap( |
| {"layer1": Device.gpu(0), "layer2": Device.cpu(), "layer3": Device.disk()} |
| ) |
|
|
| with pytest.raises(ValueError, match="unexpected device"): |
| DeviceMap.from_hf({"layer1": 0.1}) |
|
|
| assert map.first_device == Device.gpu(0) |
| assert DeviceMap({}).first_device is None |
|
|
|
|
| def test_component_device_empty_and_full(): |
| with pytest.raises(ValueError, match="neither be empty nor contain"): |
| ComponentDevice().first_device |
|
|
| with pytest.raises(ValueError, match="neither be empty nor contain"): |
| ComponentDevice(Device.cpu(), DeviceMap({})).to_hf() |
|
|
|
|
| def test_component_device_single(): |
| single = ComponentDevice.from_single(Device.gpu(1)) |
| assert not single.has_multiple_devices |
| assert single._single_device == Device.gpu(1) |
| assert single._multiple_devices is None |
|
|
| with pytest.raises(ValueError, match="disk device can only be used as a part of device maps"): |
| ComponentDevice.from_single(Device.disk()) |
|
|
| assert single.to_torch_str() == "cuda:1" |
| assert single.to_spacy() == 1 |
| assert single.to_hf() == "cuda:1" |
| assert single.update_hf_kwargs({}, overwrite=False) == {"device": "cuda:1"} |
| assert single.update_hf_kwargs({"device": 0}, overwrite=True) == {"device": "cuda:1"} |
| assert single.first_device == ComponentDevice.from_single(single._single_device) |
|
|
|
|
| def test_component_device_multiple(): |
| multiple = ComponentDevice.from_multiple( |
| DeviceMap({"layer1": Device.cpu(), "layer2": Device.gpu(1), "layer3": Device.disk()}) |
| ) |
| assert multiple.has_multiple_devices |
| assert multiple._single_device is None |
| assert multiple._multiple_devices == DeviceMap( |
| {"layer1": Device.cpu(), "layer2": Device.gpu(1), "layer3": Device.disk()} |
| ) |
|
|
| with pytest.raises(ValueError, match="Only single devices"): |
| multiple.to_torch() |
|
|
| with pytest.raises(ValueError, match="Only single devices"): |
| multiple.to_torch_str() |
|
|
| with pytest.raises(ValueError, match="Only single devices"): |
| multiple.to_spacy() |
|
|
| assert multiple.to_hf() == {"layer1": "cpu", "layer2": 1, "layer3": "disk"} |
| assert multiple.update_hf_kwargs({}, overwrite=False) == { |
| "device_map": {"layer1": "cpu", "layer2": 1, "layer3": "disk"} |
| } |
| assert multiple.update_hf_kwargs({"device_map": {None: None}}, overwrite=True) == { |
| "device_map": {"layer1": "cpu", "layer2": 1, "layer3": "disk"} |
| } |
| assert multiple.first_device == ComponentDevice.from_single(Device.cpu()) |
|
|
|
|
| @patch("torch.backends.mps.is_available") |
| @patch("torch.cuda.is_available") |
| def test_component_device_resolution(torch_cuda_is_available, torch_backends_mps_is_available): |
| assert ComponentDevice.resolve_device(ComponentDevice.from_single(Device.cpu()))._single_device == Device.cpu() |
|
|
| torch_cuda_is_available.return_value = True |
| assert ComponentDevice.resolve_device(None)._single_device == Device.gpu(0) |
|
|
| torch_cuda_is_available.return_value = False |
| torch_backends_mps_is_available.return_value = True |
| assert ComponentDevice.resolve_device(None)._single_device == Device.mps() |
|
|
| torch_cuda_is_available.return_value = False |
| torch_backends_mps_is_available.return_value = False |
| assert ComponentDevice.resolve_device(None)._single_device == Device.cpu() |
|
|
| torch_cuda_is_available.return_value = False |
| torch_backends_mps_is_available.return_value = True |
| os.environ["HAYSTACK_MPS_ENABLED"] = "false" |
| assert ComponentDevice.resolve_device(None)._single_device == Device.cpu() |
|
|
