extrap 4.2.2__tar.gz → 4.2.3__tar.gz

{extrap-4.2.2/extrap.egg-info → extrap-4.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: extrap
-Version: 4.2.2
+Version: 4.2.3
 Summary: Extra-P, automated performance modeling for HPC applications
 Home-page: https://github.com/extra-p/extrap
 Author: Extra-P project

{extrap-4.2.2 → extrap-4.2.3}/extrap/__init__.py

@@ -6,7 +6,7 @@
 # See the LICENSE file in the base directory for details.
 
 __title__ = "Extra-P"
-__version__ = "4.2.2"
+__version__ = "4.2.3"
 __description__ = "Extra-P, automated performance modeling for HPC applications"
 __copyright__ = "Copyright (c) 2020-2024 Technical University of Darmstadt, Darmstadt, Germany"
 __documentation_link__ = f"https://github.com/extra-p/extrap/tree/v{__version__}/docs"

{extrap-4.2.2 → extrap-4.2.3}/extrap/entities/measurement.py

@@ -88,6 +88,8 @@ class Measurement:
             return values
         if isinstance(values, np.ndarray):
             return values
+        if all(isinstance(v, np.ndarray) for v in values):
+            return np.ma.array(values)
 
         dim_max_len = [(len(values), len(values))]
 

{extrap-4.2.2 → extrap-4.2.3}/extrap/fileio/file_reader/cube_file_reader2.py

@@ -220,8 +220,9 @@ class CubeFileReader2(AbstractDirectoryReader, AbstractScalingConversionReader,
                                     total_values[callpaths[r_cnode.id]].append(cnode_values.astype(float))
                                 elif self.scaling_type == ScalingType.WEAK_THREADED:
                                     values = cnode_values.astype(float)
-                                    non_zero_value_mask = values != 0
-                                    masked_array = ma.array(values, mask=non_zero_value_mask)
+                                    if values.any():
+                                        zero_value_mask = values == 0
+                                        masked_array = ma.array(values, mask=zero_value_mask)
                                     total_values[callpaths[r_cnode.id]].append(masked_array)
                                 elif self.scaling_type == ScalingType.STRONG:
                                     total_values[callpaths[r_cnode.id]].append(cnode_values.sum().astype(float))
@@ -241,8 +242,11 @@ class CubeFileReader2(AbstractDirectoryReader, AbstractScalingConversionReader,
                                 aggregated_values[(callpath, metric)].append(cnode_values.astype(float))
                             elif self.scaling_type == ScalingType.WEAK_THREADED:
                                 values = cnode_values.astype(float)
-                                non_zero_value_mask = values != 0
-                                aggregated_values[(callpath, metric)].append(ma.array(values, mask=non_zero_value_mask))
+                                if not values.any():
+                                    aggregated_values[(callpath, metric)].append(ma.array(values))
+                                else:
+                                    zero_value_mask = (values == 0)
+                                    aggregated_values[(callpath, metric)].append(ma.array(values, mask=zero_value_mask))
                             # in case of strong scaling calculate the sum over all mpi process values
                             elif self.scaling_type == ScalingType.STRONG:
                                 aggregated_values[(callpath, metric)].append(cnode_values.sum().astype(float))

{extrap-4.2.2 → extrap-4.2.3/extrap.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: extrap
-Version: 4.2.2
+Version: 4.2.3
 Summary: Extra-P, automated performance modeling for HPC applications
 Home-page: https://github.com/extra-p/extrap
 Author: Extra-P project

{extrap-4.2.2 → extrap-4.2.3}/tests/test_load_cube_files.py

@@ -1,6 +1,6 @@
 # This file is part of the Extra-P software (http://www.scalasca.org/software/extra-p)
 #
-# Copyright (c) 2020-2023, Technical University of Darmstadt, Germany
+# Copyright (c) 2020-2024, Technical University of Darmstadt, Germany
 #
 # This software may be modified and distributed under the terms of a BSD-style license.
 # See the LICENSE file in the base directory for details.
@@ -13,6 +13,7 @@ from extrap.entities.calltree import CallTree, Node
 from extrap.entities.coordinate import Coordinate
 from extrap.entities.metric import Metric
 from extrap.entities.parameter import Parameter
+from extrap.entities.scaling_type import ScalingType
 from extrap.fileio.file_reader.cube_file_reader2 import CubeFileReader2
 from extrap.util.exceptions import FileFormatError
 
@@ -129,6 +130,75 @@ class TestCubeFileLoader(unittest.TestCase):
             CubeFileReader2().read_cube_file('data/cubeset/multi_parameter', 'weak')
         self.assertFalse(record)
 
+    def test_weak_threaded_loading(self):
+        cfr = CubeFileReader2()
+        cfr.scaling_type = ScalingType.WEAK_THREADED
+        experiment = cfr.read_experiment('data/cubeset/simple_threaded')
+        self.assertListEqual([Parameter('f')], experiment.parameters)
+        expected_coordinates = {Coordinate(1), Coordinate(2), Coordinate(3), Coordinate(4), Coordinate(5)}
+        self.assertSetEqual(expected_coordinates, set(experiment.coordinates))
+        self.assertSetEqual({Callpath('main'), Callpath('main->foo'), Callpath('main->bar'),
+                             Callpath('main->omp parallel'), Callpath('main->zero')}, set(experiment.callpaths))
+        self.assertSetEqual({Metric('visits'), Metric('time')},
+                            set(experiment.metrics))
+
+        for measurements in experiment.measurements.values():
+            self.assertEqual(len(expected_coordinates), len(measurements))
+
+        cp = Callpath('main->foo')
+        met = Metric('time')
+        for measurement in experiment.measurements[cp, met]:
+            self.assertEqual(cp, measurement.callpath)
+            self.assertEqual(met, measurement.metric)
+            expected_value = 4.95 * measurement.coordinate[0]
+            self.assertAlmostEqual(expected_value, measurement.mean)
+            self.assertAlmostEqual(expected_value, measurement.median)
+
+        cp = Callpath('main->bar')
+        met = Metric('time')
+        for measurement in experiment.measurements[cp, met]:
+            self.assertEqual(cp, measurement.callpath)
+            self.assertEqual(met, measurement.metric)
+            expected_value = 4.15 * measurement.coordinate[0]
+            self.assertAlmostEqual(expected_value, measurement.mean)
+            self.assertAlmostEqual(expected_value, measurement.median)
+
+        cp = Callpath('main->omp parallel')
+        met = Metric('time')
+        for measurement in experiment.measurements[cp, met]:
+            self.assertEqual(cp, measurement.callpath)
+            self.assertEqual(met, measurement.metric)
+            expected_value = 3.3 * measurement.coordinate[0]
+            self.assertAlmostEqual(expected_value, measurement.mean)
+            self.assertAlmostEqual(expected_value, measurement.median)
+
+        cp = Callpath('main->foo')
+        met = Metric('visits')
+        for measurement in experiment.measurements[cp, met]:
+            self.assertEqual(cp, measurement.callpath)
+            self.assertEqual(met, measurement.metric)
+            expected_value = 8
+            self.assertAlmostEqual(expected_value, measurement.mean)
+            self.assertAlmostEqual(expected_value, measurement.median)
+
+        cp = Callpath('main->omp parallel')
+        met = Metric('visits')
+        for measurement in experiment.measurements[cp, met]:
+            self.assertEqual(cp, measurement.callpath)
+            self.assertEqual(met, measurement.metric)
+            expected_value = 6 * measurement.coordinate[0]
+            self.assertAlmostEqual(expected_value, measurement.mean)
+            self.assertAlmostEqual(expected_value, measurement.median)
+
+        cp = Callpath('main->zero')
+        met = Metric('visits')
+        for measurement in experiment.measurements[cp, met]:
+            self.assertEqual(cp, measurement.callpath)
+            self.assertEqual(met, measurement.metric)
+            expected_value = 1
+            self.assertAlmostEqual(expected_value, measurement.mean)
+            self.assertAlmostEqual(expected_value, measurement.median)
+
 
 if __name__ == '__main__':
     unittest.main()