Clean-up old test functions

- Removes switch_mp_off/on, as I'm pretty sure that hasn't worked since `multiprocessing_necessary` was used
- Rewrites a few tests that used switch mp off and on to now follow the new logic which makes the decision based on number of images
- Removes multiprocessing_available

Author: Dimitar Tasev

mantidimaging/core/gpu/test/gpu_test.py

@@ -24,16 +24,6 @@ class GPUTest(unittest.TestCase):
     def __init__(self, *args, **kwargs):
         super(GPUTest, self).__init__(*args, **kwargs)
 
-    @staticmethod
-    def run_serial(data, size, mode):
-        """
-        Run the median filter in serial.
-        """
-        th.switch_mp_off()
-        cpu_result = MedianFilter.filter_func(data, size, mode)
-        th.switch_mp_on()
-        return cpu_result
-
     @unittest.skipIf(GPU_NOT_AVAIL, reason=GPU_SKIP_REASON)
     def test_numpy_pad_modes_match_scipy_median_modes(self):
         """
@@ -47,7 +37,7 @@ def test_numpy_pad_modes_match_scipy_median_modes(self):
                 images = th.generate_shared_array()
 
                 gpu_result = MedianFilter.filter_func(images.copy(), size, mode, force_cpu=False)
-                cpu_result = self.run_serial(images.copy(), size, mode)
+                cpu_result = MedianFilter.filter_func(images.copy(), size, mode, force_cpu=True)
 
                 npt.assert_almost_equal(gpu_result[0], cpu_result[0])
 
@@ -80,7 +70,7 @@ def test_gpu_result_matches_cpu_result_for_larger_images(self):
         images = th.generate_shared_array(shape=(20, N, N))
 
         gpu_result = MedianFilter.filter_func(images.copy(), size, mode, force_cpu=False)
-        cpu_result = self.run_serial(images.copy(), size, mode)
+        cpu_result = MedianFilter.filter_func(images.copy(), size, mode, force_cpu=True)
 
         npt.assert_almost_equal(gpu_result, cpu_result)
 
@@ -95,7 +85,7 @@ def test_double_is_used_in_cuda_for_float_64_arrays(self):
         images = th.generate_shared_array(dtype="float64")
 
         gpu_result = MedianFilter.filter_func(images.copy(), size, mode, force_cpu=False)
-        cpu_result = self.run_serial(images.copy(), size, mode)
+        cpu_result = MedianFilter.filter_func(images.copy(), size, mode, force_cpu=True)
 
         npt.assert_almost_equal(gpu_result, cpu_result)
 
@@ -115,7 +105,7 @@ def test_image_slicing_works(self):
         images = th.generate_shared_array(shape=(n_images, N, N))
 
         gpu_result = MedianFilter.filter_func(images.copy(), size, mode, force_cpu=False)
-        cpu_result = self.run_serial(images.copy(), size, mode)
+        cpu_result = MedianFilter.filter_func(images.copy(), size, mode, force_cpu=True)
 
         npt.assert_almost_equal(gpu_result, cpu_result)
 

mantidimaging/core/operations/median_filter/test/median_filter_test.py

@@ -7,8 +7,9 @@
 import numpy as np
 
 import mantidimaging.test_helpers.unit_test_helper as th
-from mantidimaging.core.operations.median_filter import MedianFilter
+from mantidimaging.core.data.images import Images
 from mantidimaging.core.gpu import utility as gpu
+from mantidimaging.core.operations.median_filter import MedianFilter
 from mantidimaging.core.utility.memory_usage import get_memory_usage_linux
 
 GPU_UTIL_LOC = "mantidimaging.core.gpu.utility.gpu_available"
@@ -57,17 +58,18 @@ def test_executed_no_helper_gpu(self):
 
         th.assert_not_equals(result.data, original)
 
-    def test_executed_no_helper_seq(self):
-        images = th.generate_images()
+    def test_executed_seq(self):
+        self.do_execute(th.generate_images())
 
+    def test_executed_par(self):
+        self.do_execute(th.generate_images_for_parallel())
+
+    def do_execute(self, images: Images):
         size = 3
         mode = 'reflect'
 
         original = np.copy(images.data[0])
-        th.switch_mp_off()
         result = MedianFilter.filter_func(images, size, mode)
-        th.switch_mp_on()
-
         th.assert_not_equals(result.data, original)
 
     def test_memory_change_acceptable(self):

mantidimaging/core/operations/rebin/test/rebin_test.py

@@ -48,19 +48,13 @@ def test_executed_uniform_par_5(self):
         self.do_execute_uniform(5.0)
 
     def test_executed_uniform_seq_2(self):
-        th.switch_mp_off()
         self.do_execute_uniform(2.0)
-        th.switch_mp_on()
 
     def test_executed_uniform_seq_5(self):
-        th.switch_mp_off()
         self.do_execute_uniform(5.0)
-        th.switch_mp_on()
 
     def test_executed_uniform_seq_5_int(self):
-        th.switch_mp_off()
         self.do_execute_uniform(5.0, np.int32)
-        th.switch_mp_on()
 
     def do_execute_uniform(self, val=2.0, dtype=np.float32):
         images = th.generate_images(dtype=dtype)
@@ -78,31 +72,28 @@ def do_execute_uniform(self, val=2.0, dtype=np.float32):
         self.assertEqual(result.data.dtype, dtype)
 
     def test_executed_xy_par_128_256(self):
-        self.do_execute_xy((128, 256))
+        self.do_execute_xy(True, (128, 256))
 
     def test_executed_xy_par_512_256(self):
-        self.do_execute_xy((512, 256))
+        self.do_execute_xy(True, (512, 256))
 
     def test_executed_xy_par_1024_1024(self):
-        self.do_execute_xy((1024, 1024))
+        self.do_execute_xy(True, (1024, 1024))
 
     def test_executed_xy_seq_128_256(self):
-        th.switch_mp_off()
-        self.do_execute_xy((128, 256))
-        th.switch_mp_on()
+        self.do_execute_xy(False, (128, 256))
 
     def test_executed_xy_seq_512_256(self):
-        th.switch_mp_off()
-        self.do_execute_xy((512, 256))
-        th.switch_mp_on()
+        self.do_execute_xy(False, (512, 256))
 
     def test_executed_xy_seq_1024_1024(self):
-        th.switch_mp_off()
-        self.do_execute_xy((1024, 1024))
-        th.switch_mp_on()
+        self.do_execute_xy(False, (1024, 1024))
 
-    def do_execute_xy(self, val=(512, 512)):
-        images = th.generate_images()
+    def do_execute_xy(self, is_parallel: bool, val=(512, 512)):
+        if is_parallel:
+            images = th.generate_images((15, 8, 10))
+        else:
+            images = th.generate_images()
         mode = 'reflect'
 
         expected_x = int(val[0])

mantidimaging/core/operations/roi_normalisation/test/roi_normalisation_test.py

@@ -2,12 +2,13 @@
 # SPDX - License - Identifier: GPL-3.0-or-later
 
 import unittest
-
 from unittest import mock
+
 import numpy as np
 import numpy.testing as npt
 
 import mantidimaging.test_helpers.unit_test_helper as th
+from mantidimaging.core.data.images import Images
 from mantidimaging.core.operations.roi_normalisation import RoiNormalisationFilter
 
 
@@ -35,15 +36,12 @@ def test_not_executed_invalid_shape(self):
         npt.assert_raises(ValueError, RoiNormalisationFilter.filter_func, images, air)
 
     def test_executed_par(self):
-        self.do_execute()
+        self.do_execute(th.generate_images_for_parallel())
 
     def test_executed_seq(self):
-        th.switch_mp_off()
-        self.do_execute()
-        th.switch_mp_on()
+        self.do_execute(th.generate_images())
 
-    def do_execute(self):
-        images = th.generate_images()
+    def do_execute(self, images: Images):
 
         original = np.copy(images.data[0])
         air = [3, 3, 4, 4]

mantidimaging/core/parallel/utility.py

@@ -2,6 +2,7 @@
 # SPDX - License - Identifier: GPL-3.0-or-later
 
 import ctypes
+import multiprocessing
 import os
 from contextlib import contextmanager
 from functools import partial
@@ -96,22 +97,8 @@ def temp_shared_array(shape, dtype: NP_DTYPE = np.float32) -> np.ndarray:
         pass
 
 
-def multiprocessing_available():
-    try:
-        # ignore error about unused import
-        import multiprocessing  # noqa: F401
-        return multiprocessing
-    except ImportError:
-        return False
-
-
 def get_cores():
-    mp = multiprocessing_available()
-    # get max cores on the system as default
-    if not mp:
-        return 1
-    else:
-        return mp.cpu_count()
+    return multiprocessing.cpu_count()
 
 
 def generate_indices(num_images):

mantidimaging/helper.py

@@ -53,17 +53,3 @@ def check_data_stack(data, expected_dims=3, expected_class=Images):
 
     if expected_dims != data.data.ndim:
         raise ValueError("Invalid data format. It does not have 3 dimensions. " "Shape: {0}".format(data.data.shape))
-
-
-def run_import_checks(config):
-    """
-    Run the import checks to notify the user which features are available in
-    the execution.
-    """
-    from mantidimaging.core.parallel import utility as pu
-
-    log = logging.getLogger(__name__)
-    if not pu.multiprocessing_available():
-        log.info("Multiprocessing not available.")
-    else:
-        log.info("Running process on {0} cores.".format(config.func.cores))

mantidimaging/test_helpers/unit_test_helper.py

@@ -40,6 +40,15 @@ def generate_images(shape=g_shape, dtype=np.float32) -> Images:
     return _set_random_data(d, shape)
 
 
+def generate_images_for_parallel(shape=(15, 8, 10), dtype=np.float32) -> Images:
+    """
+    Doesn't do anything special, just makes a number of images big enough to be
+    ran in parallel from the logic of multiprocessing_necessary
+    """
+    d = pu.create_array(shape, dtype)
+    return _set_random_data(d, shape)
+
+
 def _set_random_data(data, shape):
     n = np.random.rand(*shape)
     # move the data in the shared array
@@ -90,31 +99,6 @@ def vsdebug():
     ptvsd.wait_for_attach()
 
 
-def switch_mp_off():
-    """
-    This function does very bad things that should never be replicated.
-    But it's a unit test so it's fine.
-    """
-    # backup function so we can restore it
-    global backup_mp_avail
-    backup_mp_avail = pu.multiprocessing_available
-
-    def simple_return_false():
-        return False
-
-    # do bad things, swap out the function to one that returns false
-    pu.multiprocessing_available = simple_return_false
-
-
-def switch_mp_on():
-    """
-    This function does very bad things that should never be replicated.
-    But it's a unit test so it's fine.
-    """
-    # restore the original backed up function from switch_mp_off
-    pu.multiprocessing_available = backup_mp_avail
-
-
 def assert_files_exist(cls, base_name, file_extension, file_extension_separator='.', single_file=True, num_images=1):
     """
     Asserts that a file exists.