discopop 4.0.0__tar.gz → 4.1.0__tar.gz

{discopop-4.0.0 → discopop-4.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: discopop
-Version: 4.0.0
+Version: 4.1.0
 Summary: DiscoPoP is a tool that helps software developers parallelize their programs with threads. It discovers potential parallelism in a sequential program and makes recommendations on how to exploit it.
 Home-page: https://www.discopop.tu-darmstadt.de/
 Author: TU Darmstadt and Iowa State University

{discopop-4.0.0 → discopop-4.1.0}/README.md

@@ -34,25 +34,25 @@ For a brief introduction to the command line tools, please refer to the [tools o
 For detailed information on the gathered and stored data as well as the tools themselves, please refer to [data](https://discopop-project.github.io/discopop/Data) and the pages of the individual tools in the [tools overview](https://discopop-project.github.io/discopop/Tools).
 
 ## TL;DR
-This example installs DiscoPoP, instruments and builds the provided example, analyzes the results, and prints the identified parallelization suggestions to the console.
+If you are interested in installing DiscoPoP as a `developer`, please refer to the [DiscoPoP setup wiki page](https://discopop-project.github.io/discopop/setup/discopop/).
+
+The following example installs DiscoPoP for `users`, instruments and builds the provided example, analyzes the results, and prints the identified parallelization suggestions to the console.
 In case any issues arise during the process, please refer to the detailed [setup instructions](https://discopop-project.github.io/discopop/Setup), contact us via GitHub messages, or get in contact by mail to [discopop-support@lists.parallel.informatik.tu-darmstadt.de](mailto:discopop-support@lists.parallel.informatik.tu-darmstadt.de).
+
+### Prerequisites
+- Download `.deb` package from [latest Release](https://github.com/discopop-project/discopop/releases/latest)
+### Example
 ```
-# setup DiscoPoP
-git clone git@github.com:discopop-project/discopop.git
-cd discopop
-mkdir build && cd build
-DP_BUILD=$(pwd)
-cmake .. && make
+# install package
+sudo apt install ./<packagename>.deb
 # instrument and build the example code
-cd ../example
-mkdir build && cd build && cmake -DCMAKE_CXX_COMPILER=${DP_BUILD}/scripts/CXX_wrapper.sh .. && make
+cd /opt/DiscoPoP/example
+mkdir build && cd build && cmake -DCMAKE_CXX_COMPILER=discopop_cxx .. && make
 # execute instrumented code
 ./cmake_example
 # identify parallel patterns
 cd .discopop
 discopop_explorer
-# create applicable patches from patterns
-discopop_patch_generator
 # print patches to the console
 for f in $(find patch_generator -maxdepth 1 -type d); do
     echo "SUGGESTION: $f"

{discopop-4.0.0 → discopop-4.1.0}/discopop.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: discopop
-Version: 4.0.0
+Version: 4.1.0
 Summary: DiscoPoP is a tool that helps software developers parallelize their programs with threads. It discovers potential parallelism in a sequential program and makes recommendations on how to exploit it.
 Home-page: https://www.discopop.tu-darmstadt.de/
 Author: TU Darmstadt and Iowa State University

{discopop-4.0.0 → discopop-4.1.0}/discopop.egg-info/SOURCES.txt

@@ -143,6 +143,8 @@ discopop_explorer/utilities/statistics/utilities/call_path_depth.py
 discopop_explorer/utilities/statistics/utilities/num_function_calls.py
 discopop_library/__init__.py
 discopop_library/py.typed
+discopop_library/Aliases/__init__.py
+discopop_library/Aliases/aliases.py
 discopop_library/ArgumentClasses/GeneralArguments.py
 discopop_library/CodeGenerator/CodeGenerator.py
 discopop_library/CodeGenerator/CodeGeneratorArguments.py
@@ -161,19 +163,31 @@ discopop_library/Compatibility/LegacyDiscoPoP/GEPDependencyRemover/__init__.py
 discopop_library/Compatibility/LegacyDiscoPoP/GEPDependencyRemover/__main__.py
 discopop_library/Compatibility/LegacyDiscoPoP/GEPDependencyRemover/utils.py
 discopop_library/ConfigProvider/ConfigProviderArguments.py
+discopop_library/ConfigProvider/__init__.py
 discopop_library/ConfigProvider/__main__.py
 discopop_library/ConfigProvider/config_provider.py
 discopop_library/ConfigProvider/assets/.gitignore
+discopop_library/ConfigProvider/assets/__init__.py
+discopop_library/DependencyComparator/DependencyComparatorArguments.py
+discopop_library/DependencyComparator/__main__.py
+discopop_library/DependencyComparator/dependency_comparator.py
 discopop_library/DependencyMetadata/compare_metadata.py
 discopop_library/EmpiricalAutotuning/ArgumentClasses.py
 discopop_library/EmpiricalAutotuning/Autotuner.py
 discopop_library/EmpiricalAutotuning/Types.py
 discopop_library/EmpiricalAutotuning/__init__.py
 discopop_library/EmpiricalAutotuning/__main__.py
+discopop_library/EmpiricalAutotuning/priorities.py
 discopop_library/EmpiricalAutotuning/utils.py
 discopop_library/EmpiricalAutotuning/Classes/CodeConfiguration.py
 discopop_library/EmpiricalAutotuning/Classes/ExecutionResult.py
 discopop_library/EmpiricalAutotuning/Statistics/StatisticsGraph.py
+discopop_library/EmpiricalAutotuning/optimization/check_single_combination.py
+discopop_library/EmpiricalAutotuning/optimization/dump_greedy.py.txt
+discopop_library/EmpiricalAutotuning/optimization/linear_hotspot_combination.py
+discopop_library/EmpiricalAutotuning/optimization/linear_hotspot_combination_with_refinement.py
+discopop_library/EmpiricalAutotuning/optimization/measure_only.py
+discopop_library/EmpiricalAutotuning/output/intermediate.py
 discopop_library/FolderStructure/__init__.py
 discopop_library/FolderStructure/setup.py
 discopop_library/FolderStructure/teardown.py
@@ -182,6 +196,7 @@ discopop_library/HostpotLoader/HotspotLoaderArguments.py
 discopop_library/HostpotLoader/HotspotNodeType.py
 discopop_library/HostpotLoader/HotspotType.py
 discopop_library/HostpotLoader/hostpot_loader.py
+discopop_library/HostpotLoader/utilities.py
 discopop_library/JSONHandler/JSONHandler.py
 discopop_library/JSONHandler/__init__.py
 discopop_library/LineMapping/__init__.py
@@ -211,6 +226,45 @@ discopop_library/PatchGenerator/patch_generator.py
 discopop_library/PathManagement/PathManagement.py
 discopop_library/PathManagement/__init__.py
 discopop_library/PatternIdManagement/unique_pattern_id.py
+discopop_library/PreProcessor/PreProcessorArguments.py
+discopop_library/PreProcessor/__init__.py
+discopop_library/PreProcessor/__main__.py
+discopop_library/PreProcessor/pre_processor.py
+discopop_library/PreProcessor/demangle/data_xml.py
+discopop_library/PreProcessor/demangle/dependency_metadata.py
+discopop_library/PreProcessor/demangle/driver.py
+discopop_library/PreProcessor/demangle/dynamic_dependencies.py
+discopop_library/PreProcessor/demangle/reduction.py
+discopop_library/PreProcessor/demangle/static_dependencies.py
+discopop_library/PreProcessor/demangle/utilities.py
+discopop_library/ProjectManager/ProjectManager.py
+discopop_library/ProjectManager/ProjectManagerArguments.py
+discopop_library/ProjectManager/__init__.py
+discopop_library/ProjectManager/__main__.py
+discopop_library/ProjectManager/configurations/copying.py
+discopop_library/ProjectManager/configurations/deletion.py
+discopop_library/ProjectManager/configurations/execution.py
+discopop_library/ProjectManager/reports/console.py
+discopop_library/ProjectManager/reports/csv.py
+discopop_library/ProjectManager/reports/efficiency.py
+discopop_library/ProjectManager/reports/execution_time.py
+discopop_library/ProjectManager/reports/full.py
+discopop_library/ProjectManager/reports/speedup.py
+discopop_library/ProjectManager/utilities/__init__.py
+discopop_library/ProjectManager/utilities/deriveSettingsFiles.py
+discopop_library/ProjectManager/utilities/initializeDirectories.py
+discopop_library/ProjectManager/utilities/initializeFiles.py
+discopop_library/ProjectManager/utilities/reset.py
+discopop_library/ProjectManager/utilities/CLI/__init__.py
+discopop_library/ProjectManager/utilities/CLI/listConfiguration.py
+discopop_library/SanityChecker/ArgumentClasses.py
+discopop_library/SanityChecker/SanityChecker.py
+discopop_library/SanityChecker/Types.py
+discopop_library/SanityChecker/__init__.py
+discopop_library/SanityChecker/__main__.py
+discopop_library/SanityChecker/utils.py
+discopop_library/SanityChecker/Classes/CodeConfiguration.py
+discopop_library/SanityChecker/Classes/ExecutionResult.py
 discopop_library/__pycache__/__init__.cpython-38.pyc
 discopop_library/discopop_optimizer/OptimizationGraph.py
 discopop_library/discopop_optimizer/OptimizerArguments.py

{discopop-4.0.0 → discopop-4.1.0}/discopop.egg-info/entry_points.txt

@@ -1,8 +1,13 @@
 [console_scripts]
 discopop_auto_tuner = discopop_library.EmpiricalAutotuning.__main__:main
 discopop_config_provider = discopop_library.ConfigProvider.__main__:main
+discopop_configuration_manager = discopop_library.ConfigurationManager.__main__:main
+discopop_dependency_comparator = discopop_library.DependencyComparator.__main__:main
 discopop_explorer = discopop_explorer.__main__:main
 discopop_optimizer = discopop_library.discopop_optimizer.__main__:main
 discopop_patch_applicator = discopop_library.PatchApplicator.__main__:main
 discopop_patch_generator = discopop_library.PatchGenerator.__main__:main
+discopop_preprocessor = discopop_library.PreProcessor.__main__:main
+discopop_project_manager = discopop_library.ProjectManager.__main__:main
+discopop_sanity_checker = discopop_library.SanityChecker.__main__:main
 

{discopop-4.0.0 → discopop-4.1.0}/discopop.egg-info/requires.txt

@@ -15,6 +15,7 @@ sympy_plot_backends
 alive_progress
 filelock
 pydot
+tabulate
 
 [ci]
 mypy

{discopop-4.0.0 → discopop-4.1.0}/discopop_explorer/__main__.py

@@ -69,12 +69,13 @@ def parse_args() -> ExplorerArguments:
         help="Dump DetectionResult object to JSON file. If a path is given, the DetectionResult object is written to the given file, otherwise to detection_result_dump.json. Contents are equivalent to the json output. NOTE: This dump contains a dump of the PET Graph!",
     )
     parser.add_argument(
-        "--enable-patterns", type=str, nargs="?", default="reduction,doall,pipeline,geodec",
-        help="Specify comma-separated list of pattern types to be identified. Options: reduction,doall,pipeline,geodec,simplegpu. Default: reduction,doall,pipeline,geodec",
+        "--enable-patterns", type=str, nargs="?", default="reduction,doall",
+        help="Specify comma-separated list of pattern types to be identified. Options: reduction,doall,pipeline,geodec,simplegpu. Default: reduction,doall",
     )
     parser.add_argument("--load-existing-doall-and-reduction-patterns", action="store_true", help="Skip pattern detection and insert existing patterns.json contents into the created detection_result.json")
     parser.add_argument("--log", type=str, default="WARNING", help="Specify log level: DEBUG, INFO, WARNING, ERROR, CRITICAL")
     parser.add_argument("--write-log", action="store_true", help="Create Logfile.")
+    parser.add_argument("-j", "--jobs", type=int, help="Allow the use of N threads. Use 0 or 1 to disable threading. Default: Unlimited", default=None)
 
     # EXPERIMENTAL FLAGS:
     # temporary flag for microbenchmark file
@@ -107,6 +108,10 @@ def parse_args() -> ExplorerArguments:
     experimental_parser.add_argument(
         "--enable-statistics", action="store_true", help="Disable the calculation and storing of statistics for code and generated suggestions."
     )
+    experimental_parser.add_argument(
+        "--plot-pet", type=str, nargs="?", default=None, const="explorer/pet_plot.gexf",
+        help="Plots PET as a GEXF file. If a path is given (file extension has to be .gexf), the PET Graph is written to the given file, otherwise to pet_plot.gexf"
+    )
     # fmt: on
 
     arguments = parser.parse_args()
@@ -134,6 +139,7 @@ def parse_args() -> ExplorerArguments:
     arguments.dump_pet = get_path_or_none(arguments.path, arguments.dump_pet)
     arguments.dump_detection_result = get_path_or_none(arguments.path, arguments.dump_detection_result)
     arguments.microbench_file = get_path_or_none(arguments.path, arguments.microbench_file)
+    arguments.plot_pet = get_path_or_none(arguments.path, arguments.plot_pet)
 
     return ExplorerArguments(
         discopop_build_path=arguments.dp_build_path,
@@ -160,6 +166,8 @@ def parse_args() -> ExplorerArguments:
         write_log=arguments.write_log,
         load_existing_doall_and_reduction_patterns=arguments.load_existing_doall_and_reduction_patterns,
         collect_statistics=arguments.enable_statistics,
+        jobs=arguments.jobs,
+        enable_pet_plot_file=arguments.plot_pet,
     )
 
 

{discopop-4.0.0 → discopop-4.1.0}/discopop_explorer/classes/PEGraph/Node.py

@@ -87,6 +87,12 @@ class Node:
             return True
         return False
 
+    def get_contained_line_ids(self) -> List[LineID]:
+        result: List[LineID] = []
+        for i in range(self.start_line, self.end_line + 1):
+            result.append(LineID(str(self.file_id) + ":" + str(i)))
+        return result
+
     def __str__(self) -> str:
         return self.id
 

{discopop-4.0.0 → discopop-4.1.0}/discopop_explorer/classes/patterns/PatternBase.py

@@ -8,6 +8,7 @@
 
 import json
 import os
+from typing import List, Optional
 
 from filelock import FileLock  # type: ignore
 from discopop_explorer.classes.PEGraph.Node import Node
@@ -19,11 +20,13 @@ class PatternBase(object):
     """Base class for pattern info"""
 
     pattern_id: int
+    pattern_tag: str
     _node: Node
     node_id: NodeID
     start_line: LineID
     end_line: LineID
     applicable_pattern: bool
+    affected_cu_ids: List[NodeID]
 
     def __init__(self, node: Node):
         # create a file lock to synchronize processes
@@ -45,6 +48,8 @@ class PatternBase(object):
         self.start_line = node.start_position()
         self.end_line = node.end_position()
         self.applicable_pattern = True
+        self.pattern_tag = ""
+        self.affected_cu_ids = []
 
     def to_json(self) -> str:
         dic = self.__dict__
@@ -54,3 +59,8 @@ class PatternBase(object):
                 del dic[key]
 
         return json.dumps(dic, indent=2, default=lambda o: o.toJSON())  # , default=lambda o: "<not serializable>")
+
+    def get_tag(self) -> str:
+        result = "" + self.__class__.__name__
+        result += "@" + self.start_line + "-" + self.end_line
+        return result

{discopop-4.0.0 → discopop-4.1.0}/discopop_explorer/discopop_explorer.py

@@ -21,6 +21,7 @@ from typing import Dict, List, Optional, Tuple
 import pstats2  # type:ignore
 from pluginbase import PluginBase  # type: ignore
 from discopop_explorer.functions.PEGraph.output.json import dump_to_pickled_json
+from discopop_explorer.functions.PEGraph.output.gephi import dump_to_gephi_file
 from discopop_explorer.utilities.statistics.collect_statistics import collect_statistics
 from discopop_library.ArgumentClasses.GeneralArguments import GeneralArguments  # type: ignore
 from discopop_library.FolderStructure.setup import setup_explorer
@@ -58,6 +59,7 @@ class ExplorerArguments(GeneralArguments):
     reduction_file: str
     file_mapping_file: str
     plugins: List[str]
+    jobs: Optional[int]
     # output and formatting
     enable_json_file: Optional[str]
     enable_profiling_dump_file: Optional[str]  # None means no dump, otherwise the path
@@ -73,6 +75,7 @@ class ExplorerArguments(GeneralArguments):
     microbench_file: Optional[str]
     load_existing_doall_and_reduction_patterns: bool
     collect_statistics: bool
+    enable_pet_plot_file: Optional[str]  # None means no dump, otherwise the path
 
     def __post_init__(self) -> None:
         self.__validate()
@@ -122,6 +125,7 @@ def __run(
     enable_detection_of_scheduling_clauses: bool = False,
     hotspot_functions: Optional[Dict[HotspotType, List[Tuple[int, int, HotspotNodeType, str, float]]]] = None,
     load_existing_doall_and_reduction_patterns: bool = False,
+    jobs: Optional[int] = None,
 ) -> DetectionResult:
     pet = PEGraphX.from_parsed_input(*parse_inputs(cu_xml, dep_file, reduction_file, file_mapping))  # type: ignore
     print("PET CREATION FINISHED.")
@@ -170,6 +174,7 @@ def __run(
             enable_task_pattern,
             enable_detection_of_scheduling_clauses,
             hotspot_functions,
+            jobs,
         )
 
     for plugin_name in plugins:
@@ -240,6 +245,7 @@ def run(arguments: ExplorerArguments) -> None:
             enable_detection_of_scheduling_clauses=arguments.detect_scheduling_clauses,
             hotspot_functions=hotspots,
             load_existing_doall_and_reduction_patterns=arguments.load_existing_doall_and_reduction_patterns,
+            jobs=arguments.jobs,
         )
 
         end = time.time()
@@ -254,6 +260,11 @@ def run(arguments: ExplorerArguments) -> None:
                 f.flush()
                 f.close()
 
+        # experimental
+        # dumps gexf plot of pet
+        if arguments.enable_pet_plot_file is not None:
+            dump_to_gephi_file(res.pet, arguments.enable_pet_plot_file)
+
         if arguments.enable_detection_result_dump_file is not None:
             with open(arguments.enable_detection_result_dump_file, "w+") as f:
                 f.write(res.dump_to_pickled_json())

{discopop-4.0.0 → discopop-4.1.0}/discopop_explorer/functions/PEGraph/output/gephi.py

@@ -12,7 +12,7 @@ from discopop_explorer.enums.EdgeType import EdgeType
 import networkx as nx  # type: ignore
 
 
-def dump_to_gephi_file(pet: PEGraphX, name: str = "pet.gexf") -> None:
+def dump_to_gephi_file(pet: PEGraphX, name: str) -> None:
     """Note: Destroys the PETGraph!"""
     # replace node data with label
     for node_id in pet.g.nodes:

{discopop-4.0.0 → discopop-4.1.0}/discopop_explorer/functions/PEGraph/traversal/parent.py

@@ -6,7 +6,7 @@
 # the 3-Clause BSD License.  See the LICENSE file in the package base
 # directory for details.
 from __future__ import annotations
-from typing import TYPE_CHECKING, Optional, cast
+from typing import TYPE_CHECKING, List, Optional, cast
 from discopop_explorer.classes.PEGraph.FunctionNode import FunctionNode
 from discopop_explorer.classes.PEGraph.Node import Node
 
@@ -41,3 +41,19 @@ def get_parent_function(pet: PEGraphX, node: Node) -> FunctionNode:
 
     assert node.parent_function_id
     return cast(FunctionNode, pet.node_at(node.parent_function_id))
+
+
+def get_all_parent_functions(pet: PEGraphX, node: Node) -> List[FunctionNode]:
+    queue: List[Node] = [node]
+    result: set[FunctionNode] = set()
+    while queue:
+        current = queue.pop()
+        current_parent = get_parent_function(pet, current)
+        if current_parent not in queue and current_parent not in result:
+            queue.append(current_parent)
+        if current_parent not in result:
+            result.add(current_parent)
+        for in_edge in in_edges(pet, current.id, EdgeType.CALLSNODE):
+            queue.append(pet.node_at(in_edge[0]))
+
+    return list(result)

{discopop-4.0.0 → discopop-4.1.0}/discopop_explorer/pattern_detection.py

@@ -76,6 +76,7 @@ class PatternDetectorX(object):
         enable_task_pattern: bool,
         enable_detection_of_scheduling_clauses: bool,
         hotspots: Optional[Dict[HotspotType, List[Tuple[int, int, HotspotNodeType, str, float]]]],
+        jobs: Optional[int],
     ) -> DetectionResult:
         """Runs pattern discovery on the CU graph"""
         self.__merge(False, True)
@@ -88,11 +89,11 @@ class PatternDetectorX(object):
 
         if "*" in enable_patterns or "reduction" in enable_patterns:
             print("REDUCTIONS...")
-            res.patterns.reduction = detect_reduction(self.pet, hotspots)
+            res.patterns.reduction = detect_reduction(self.pet, hotspots, jobs)
             print("\tDONE.")
         if "*" in enable_patterns or "doall" in enable_patterns:
             print("DOALL...")
-            res.patterns.do_all = detect_do_all(self.pet, hotspots, res.patterns.reduction)
+            res.patterns.do_all = detect_do_all(self.pet, hotspots, res.patterns.reduction, jobs)
             print("\tDONE.")
         if "*" in enable_patterns or "pipeline" in enable_patterns:
             print("PIPELINE...")

{discopop-4.0.0 → discopop-4.1.0}/discopop_explorer/pattern_detectors/combined_gpu_patterns/step_1.py

@@ -106,7 +106,7 @@ def get_cu_and_varname_to_memory_regions(
 
 
 def get_memory_region_to_cu_and_variables_dict(
-    cu_and_variable_to_memory_regions: Dict[NodeID, Dict[VarName, Set[MemoryRegion]]]
+    cu_and_variable_to_memory_regions: Dict[NodeID, Dict[VarName, Set[MemoryRegion]]],
 ) -> Dict[MemoryRegion, Dict[NodeID, Set[VarName]]]:
     # inverts the given cu_and_variable_to_memory_regions dictionary
     result_dict: Dict[MemoryRegion, Dict[NodeID, Set[VarName]]] = dict()

{discopop-4.0.0 → discopop-4.1.0}/discopop_explorer/pattern_detectors/combined_gpu_patterns/step_2.py

@@ -97,7 +97,7 @@ def add_memory_regions_to_device_liveness(
 
 
 def propagate_memory_regions(
-    device_liveness_plus_memory_regions: Dict[VarName, List[Tuple[NodeID, Set[MemoryRegion]]]]
+    device_liveness_plus_memory_regions: Dict[VarName, List[Tuple[NodeID, Set[MemoryRegion]]]],
 ) -> Dict[VarName, List[Tuple[NodeID, Set[MemoryRegion]]]]:
     """Propagate memory regions for variables"""
     result_dict: Dict[VarName, List[Tuple[NodeID, Set[MemoryRegion]]]] = dict()
@@ -117,7 +117,7 @@ def propagate_memory_regions(
 
 
 def convert_liveness(
-    device_liveness_plus_memory_regions: Dict[VarName, List[Tuple[NodeID, Set[MemoryRegion]]]]
+    device_liveness_plus_memory_regions: Dict[VarName, List[Tuple[NodeID, Set[MemoryRegion]]]],
 ) -> Dict[MemoryRegion, List[NodeID]]:
     result_dict: Dict[MemoryRegion, List[NodeID]] = dict()
 

{discopop-4.0.0 → discopop-4.1.0}/discopop_explorer/pattern_detectors/combined_gpu_patterns/step_3.py

@@ -143,7 +143,7 @@ def propagate_writes(
 
 
 def cleanup_writes(
-    writes: Dict[MemoryRegion, Set[Tuple[NodeID, Optional[int]]]]
+    writes: Dict[MemoryRegion, Set[Tuple[NodeID, Optional[int]]]],
 ) -> Dict[MemoryRegion, Set[Tuple[NodeID, Optional[int]]]]:
     """remove entries from the Sets with an second-element entry of None,
     if it is overwritten by a different memory write."""
@@ -164,7 +164,7 @@ def cleanup_writes(
 
 
 def group_writes_by_cu(
-    writes: Dict[MemoryRegion, Set[Tuple[NodeID, Optional[int]]]]
+    writes: Dict[MemoryRegion, Set[Tuple[NodeID, Optional[int]]]],
 ) -> Dict[NodeID, Dict[MemoryRegion, Set[Optional[int]]]]:
     result_dict: Dict[NodeID, Dict[MemoryRegion, Set[Optional[int]]]] = dict()
 

{discopop-4.0.0 → discopop-4.1.0}/discopop_explorer/pattern_detectors/combined_gpu_patterns/step_6.py

@@ -345,7 +345,7 @@ def extend_region_liveness_using_unrolled_functions(
 
 
 def remove_duplicates(
-    target_set: Union[Set[Update], Set[EntryPoint], Set[ExitPoint]]
+    target_set: Union[Set[Update], Set[EntryPoint], Set[ExitPoint]],
 ) -> Union[Set[Update], Set[EntryPoint], Set[ExitPoint]]:
     to_be_removed = []
     for element_1 in target_set:

{discopop-4.0.0 → discopop-4.1.0}/discopop_explorer/pattern_detectors/do_all_detector.py

@@ -17,7 +17,7 @@ from discopop_explorer.functions.PEGraph.queries.edges import in_edges, out_edge
 from discopop_explorer.functions.PEGraph.queries.nodes import all_nodes
 from discopop_explorer.functions.PEGraph.queries.subtree import subtree_of_type
 from discopop_explorer.functions.PEGraph.queries.variables import get_variables
-from discopop_explorer.functions.PEGraph.traversal.parent import get_parent_function
+from discopop_explorer.functions.PEGraph.traversal.parent import get_all_parent_functions, get_parent_function
 from discopop_library.HostpotLoader.HotspotNodeType import HotspotNodeType
 from discopop_library.HostpotLoader.HotspotType import HotspotType  # type: ignore
 
@@ -57,6 +57,19 @@ class DoAllInfo(PatternInfo):
         self.reduction = r
         self.scheduling_clause = "static"
         self.collapse_level = 1
+        self.pattern_tag = self.get_tag()
+
+        # determine affected cu and line ids
+        affected_cus = subtree_of_type(pet, node)
+        self.affected_cu_ids = [n.id for n in affected_cus]
+        self.affected_line_ids: List[LineID] = []
+        for node in affected_cus:
+            self.affected_line_ids += [
+                lid for lid in node.get_contained_line_ids() if lid not in self.affected_line_ids
+            ]
+        self.affected_functions = [
+            str(f.start_position()) + ":" + f.name for f in [get_parent_function(pet, node)]
+        ]  # get_all_parent_functions(pet, node)]
 
     def __str__(self) -> str:
         return (
@@ -76,6 +89,15 @@ class DoAllInfo(PatternInfo):
             f"scheduling clause: {self.scheduling_clause}"
         )
 
+    def get_tag(self) -> str:
+        result = super().get_tag() + "_"
+        result += f"p({[v.name for v in self.private]})_"
+        result += f"s({[v.name for v in self.shared]})_"
+        result += f"fp({[v.name for v in self.first_private]})_"
+        result += f"r({[v.name for v in self.reduction]})_"
+        result += f"lp({[v.name for v in self.last_private]})"
+        return result
+
 
 global_pet = None
 
@@ -84,6 +106,7 @@ def run_detection(
     pet: PEGraphX,
     hotspots: Optional[Dict[HotspotType, List[Tuple[int, int, HotspotNodeType, str, float]]]],
     reduction_info: List[ReductionInfo],
+    jobs: Optional[int] = None,
 ) -> List[DoAllInfo]:
     """Search for do-all loop pattern
 
@@ -107,10 +130,14 @@ def run_detection(
     nodes = cast(List[LoopNode], filter_for_hotspots(pet, cast(List[Node], nodes), hotspots))
 
     param_list = [(node) for node in nodes]
-    with Pool(initializer=__initialize_worker, initargs=(pet,)) as pool:
-        tmp_result = list(tqdm.tqdm(pool.imap_unordered(__check_node, param_list), total=len(param_list)))
-    for local_result in tmp_result:
-        result += local_result
+    if jobs is None or jobs > 1:
+        with Pool(initializer=__initialize_worker, initargs=(pet,)) as pool:
+            tmp_result = list(tqdm.tqdm(pool.imap_unordered(__check_node, param_list), total=len(param_list)))
+        for local_result in tmp_result:
+            result += local_result
+    else:
+        for param_tpl in param_list:
+            result += __check_node(param_tpl)
     print("GLOBAL RES: ", [r.start_line for r in result])
 
     for pattern in result:

{discopop-4.0.0 → discopop-4.1.0}/discopop_explorer/pattern_detectors/geometric_decomposition_detector.py

@@ -111,10 +111,9 @@ def run_detection(
     nodes = cast(List[FunctionNode], filter_for_hotspots(pet, cast(List[Node], nodes), hotspots))
 
     param_list = [(node) for node in nodes]
-    with Pool(initializer=__initialize_worker, initargs=(pet,)) as pool:
-        tmp_result = list(tqdm.tqdm(pool.imap_unordered(__check_node, param_list), total=len(param_list)))
-    for local_result in tmp_result:
-        result += local_result
+
+    for param_tpl in param_list:
+        result += __check_node(param_tpl)
     print("GLOBAL RES: ", result)
 
     for pattern in result:

{discopop-4.0.0 → discopop-4.1.0}/discopop_explorer/pattern_detectors/pipeline_detector.py

@@ -180,10 +180,9 @@ def run_detection(
     nodes = cast(List[LoopNode], filter_for_hotspots(pet, cast(List[Node], nodes), hotspots))
 
     param_list = [(node) for node in nodes]
-    with Pool(initializer=__initialize_worker, initargs=(pet,)) as pool:
-        tmp_result = list(tqdm.tqdm(pool.imap_unordered(__check_node, param_list), total=len(param_list)))
-    for local_result in tmp_result:
-        result += local_result
+
+    for param_tpl in param_list:
+        result += __check_node(param_tpl)
     print("GLOBAL RES: ", result)
 
     for pattern in result:

{discopop-4.0.0 → discopop-4.1.0}/discopop_explorer/pattern_detectors/reduction_detector.py

@@ -17,7 +17,7 @@ from discopop_explorer.functions.PEGraph.queries.edges import in_edges, out_edge
 from discopop_explorer.functions.PEGraph.queries.nodes import all_nodes
 from discopop_explorer.functions.PEGraph.queries.subtree import subtree_of_type
 from discopop_explorer.functions.PEGraph.queries.variables import get_variables
-from discopop_explorer.functions.PEGraph.traversal.parent import get_parent_function
+from discopop_explorer.functions.PEGraph.traversal.parent import get_all_parent_functions, get_parent_function
 from discopop_library.HostpotLoader.HotspotNodeType import HotspotNodeType
 from discopop_library.HostpotLoader.HotspotType import HotspotType  # type: ignore
 
@@ -56,6 +56,19 @@ class ReductionInfo(PatternInfo):
         self.last_private = lp
         self.shared = s
         self.reduction = r
+        self.pattern_tag = self.get_tag()
+
+        # determine affected cu and line ids
+        affected_cus = subtree_of_type(pet, node)
+        self.affected_cu_ids = [n.id for n in affected_cus]
+        self.affected_line_ids: List[LineID] = []
+        for node in affected_cus:
+            self.affected_line_ids += [
+                lid for lid in node.get_contained_line_ids() if lid not in self.affected_line_ids
+            ]
+        self.affected_functions = [
+            str(f.start_position()) + ":" + f.name for f in [get_parent_function(pet, node)]
+        ]  # get_all_parent_functions(pet, node)]
 
     def __str__(self) -> str:
         return (
@@ -70,12 +83,23 @@ class ReductionInfo(PatternInfo):
             f"last private: {[v.name for v in self.last_private]}"
         )
 
+    def get_tag(self) -> str:
+        result = super().get_tag() + "_"
+        result += f"p({[v.name for v in self.private]})_"
+        result += f"s({[v.name for v in self.shared]})_"
+        result += f"fp({[v.name for v in self.first_private]})_"
+        result += f'r({[str(v.operation) + ":" + v.name for v in self.reduction]})_'
+        result += f"lp({[v.name for v in self.last_private]})"
+        return result
+
 
 global_pet = None
 
 
 def run_detection(
-    pet: PEGraphX, hotspots: Optional[Dict[HotspotType, List[Tuple[int, int, HotspotNodeType, str, float]]]]
+    pet: PEGraphX,
+    hotspots: Optional[Dict[HotspotType, List[Tuple[int, int, HotspotNodeType, str, float]]]],
+    jobs: Optional[int] = None,
 ) -> List[ReductionInfo]:
     """Search for reduction pattern
 
@@ -92,10 +116,14 @@ def run_detection(
     nodes = cast(List[LoopNode], filter_for_hotspots(pet, cast(List[Node], nodes), hotspots))
 
     param_list = [(node) for node in nodes]
-    with Pool(initializer=__initialize_worker, initargs=(pet,)) as pool:
-        tmp_result = list(tqdm.tqdm(pool.imap_unordered(__check_node, param_list), total=len(param_list)))
-    for local_result in tmp_result:
-        result += local_result
+    if jobs is None or jobs > 1:
+        with Pool(processes=jobs, initializer=__initialize_worker, initargs=(pet,)) as pool:
+            tmp_result = list(tqdm.tqdm(pool.imap_unordered(__check_node, param_list), total=len(param_list)))
+        for local_result in tmp_result:
+            result += local_result
+    else:
+        for param_tpl in param_list:
+            result += __check_node(param_tpl)
     print("GLOBAL RES: ", [r.start_line for r in result])
 
     for pattern in result:

{discopop-4.0.0 → discopop-4.1.0}/discopop_explorer/utilities/statistics/collect_statistics.py

@@ -37,18 +37,22 @@ logger = logging.getLogger("statistics")
 
 def collect_statistics(arguments: ExplorerArguments, res: DetectionResult) -> None:
     logger.info("Collecting code statistics...")
+
     maximum_call_path_depth = get_maximum_call_path_depth(res.pet)
     logger.debug("--> maximum_call_path_depth: " + str(maximum_call_path_depth))
+
     suggestion_call_path_depths = get_suggestion_call_path_depths(res)
     logger.debug(
         "--> suggestion_call_path_depths: "
         + str([str(key) + " => " + str(suggestion_call_path_depths[key]) for key in suggestion_call_path_depths])
     )
+
     suggestion_num_function_calls = get_suggestion_num_function_calls(res)
     logger.debug(
         "--> suggestion_num_function_calls: "
         + str([str(key) + " => " + str(suggestion_num_function_calls[key]) for key in suggestion_num_function_calls])
     )
+
     suggestion_immediate_lines_of_code = get_suggestion_immediate_lines_of_code(res)
     logger.debug(
         "--> suggestion_immediate_lines_of_code: "