discopop 4.0.1__tar.gz → 4.1.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: discopop
-Version: 4.0.1
+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.1 → discopop-4.1.0}/discopop.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: discopop
-Version: 4.0.1
+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.1 → 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.1 → 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.1 → 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.1 → discopop-4.1.0}/discopop_explorer/__main__.py

@@ -108,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()
@@ -135,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,
@@ -162,6 +167,7 @@ def parse_args() -> ExplorerArguments:
         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.1 → 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.1 → 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.1 → 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
@@ -74,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()
@@ -258,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.1 → 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.1 → 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.1 → 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.1 → 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.1 → 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.1 → 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.1 → 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
 

{discopop-4.0.1 → 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,6 +83,15 @@ 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
 

{discopop-4.0.1 → 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: "

{discopop-4.0.1 → discopop-4.1.0}/discopop_explorer/utilities/statistics/cyclomatic_complexity/boxplot.py

@@ -16,7 +16,7 @@ if TYPE_CHECKING:
 # define aliases for readability
 from subprocess import check_output
 from discopop_library.PathManagement.PathManagement import load_file_mapping
-
+import logging
 
 MIN = int
 MAX = int
@@ -24,17 +24,23 @@ AVG = int
 LOWER_QUART = int
 UPPER_QUART = int
 
+logger = logging.getLogger("statistics").getChild("CC").getChild("boxplot")
+
 
 def get_cyclomatic_complexities_for_boxplot(
     arguments: ExplorerArguments, res: DetectionResult
 ) -> Tuple[MIN, MAX, AVG, LOWER_QUART, UPPER_QUART]:
     file_mapping = load_file_mapping(arguments.file_mapping_file)
     # get summed cyclomatic complexity for all functions in all files
-    cmd = ["pmccabe", "-C"]
-    for file_id in file_mapping:
-        file_path = file_mapping[file_id]
-        cmd.append(str(file_path))
-    out = check_output(cmd).decode("utf-8")
+    try:
+        cmd = ["pmccabe", "-C"]
+        for file_id in file_mapping:
+            file_path = file_mapping[file_id]
+            cmd.append(str(file_path))
+        out = check_output(cmd).decode("utf-8")
+    except FileNotFoundError as fnfe:
+        logger.error(str(fnfe))
+        return (0, 0, 0, 0, 0)
 
     # unpack and store results temporarily
     cyclomatic_complexities: List[int] = []

{discopop-4.0.1 → discopop-4.1.0}/discopop_explorer/utilities/statistics/cyclomatic_complexity/cc_dictionary.py

@@ -26,16 +26,20 @@ CC_DICT = Dict[FILE_ID, Dict[FUNC_NAME, CYC_COMP]]
 
 
 def get_cyclomatic_complexity_dictionary(arguments: ExplorerArguments, res: DetectionResult) -> CC_DICT:
+    cc_dict: Dict[FILE_ID, Dict[FUNC_NAME, CYC_COMP]] = dict()
     file_mapping = load_file_mapping(arguments.file_mapping_file)
+
     # get summed cyclomatic complexity for all functions in all files
-    cmd = ["pmccabe", "-C"]
-    for file_id in file_mapping:
-        file_path = file_mapping[file_id]
-        cmd.append(str(file_path))
-    out = check_output(cmd).decode("utf-8")
+    try:
+        cmd = ["pmccabe", "-C"]
+        for file_id in file_mapping:
+            file_path = file_mapping[file_id]
+            cmd.append(str(file_path))
+        out = check_output(cmd).decode("utf-8")
+    except FileNotFoundError:
+        return cc_dict
 
     # unpack and repack results
-    cc_dict: Dict[FILE_ID, Dict[FUNC_NAME, CYC_COMP]] = dict()
     for line in out.split("\n"):
         split_line = line.split("\t")
         if len(split_line) < 9:

{discopop-4.0.1 → discopop-4.1.0}/discopop_explorer/utilities/statistics/cyclomatic_complexity/total.py

@@ -17,16 +17,24 @@ from discopop_library.PathManagement.PathManagement import load_file_mapping
 
 from subprocess import check_output
 
+import logging
+
+logger = logging.getLogger("statistics").getChild("CC").getChild("total")
+
 
 def get_summed_cyclomatic_complexity(arguments: ExplorerArguments, res: DetectionResult) -> int:
     """calculate the total cyclomatic complexity"""
     file_mapping = load_file_mapping(arguments.file_mapping_file)
     # get summed cyclomatic complexity for all functions in all files
-    cmd = ["pmccabe", "-T"]
-    for file_id in file_mapping:
-        file_path = file_mapping[file_id]
-        cmd.append(str(file_path))
-    out = check_output(cmd).decode("utf-8")
-    summed_cyclomatic_complexity = int(out.split("\t")[1])
+    try:
+        cmd = ["pmccabe", "-T"]
+        for file_id in file_mapping:
+            file_path = file_mapping[file_id]
+            cmd.append(str(file_path))
+        out = check_output(cmd).decode("utf-8")
+        summed_cyclomatic_complexity = int(out.split("\t")[1])
+    except FileNotFoundError as fnfe:
+        logger.error(str(fnfe))
+        return 0
 
     return summed_cyclomatic_complexity

{discopop-4.0.1 → discopop-4.1.0}/discopop_explorer/utilities/statistics/utilities/num_function_calls.py

@@ -29,6 +29,8 @@ def get_num_function_calls(pet: PEGraphX, node: Node, visited: List[Node]) -> in
                     continue
                 function_calls += get_num_function_calls(pet, pet.node_at(t), copy.deepcopy(visited))
         else:
+            if child in visited:
+                continue
             function_calls += get_num_function_calls(pet, child, copy.deepcopy(visited))
 
     return function_calls

{discopop-4.0.1 → discopop-4.1.0}/discopop_explorer/utils.py

@@ -820,9 +820,9 @@ def __remove_duplicate_variables(vars: List[Variable]) -> List[Variable]:
     buffer: List[str] = []
     vars_wo_duplicates: List[Variable] = []
     for var in vars:
-        if var.name + var.defLine not in buffer:
+        if str(var.name) + var.defLine not in buffer:
             vars_wo_duplicates.append(var)
-            buffer.append(var.name + var.defLine)
+            buffer.append(str(var.name) + var.defLine)
         else:
             # duplicate found
             continue

discopop-4.1.0/discopop_library/Aliases/aliases.py

@@ -0,0 +1,9 @@
+# This file is part of the DiscoPoP software (http://www.discopop.tu-darmstadt.de)
+#
+# Copyright (c) 2020, Technische Universitaet Darmstadt, Germany
+#
+# This software may be modified and distributed under the terms of
+# the 3-Clause BSD License.  See the LICENSE file in the package base
+# directory for details.
+
+PatternID = int

discopop-4.1.0/discopop_library/DependencyComparator/DependencyComparatorArguments.py

@@ -0,0 +1,20 @@
+# This file is part of the DiscoPoP software (http://www.discopop.tu-darmstadt.de)
+#
+# Copyright (c) 2020, Technische Universitaet Darmstadt, Germany
+#
+# This software may be modified and distributed under the terms of
+# the 3-Clause BSD License.  See the LICENSE file in the package base
+# directory for details.
+from dataclasses import dataclass
+
+
+@dataclass
+class DependencyComparatorArguments(object):
+    """Container Class for the arguments passed to the discopop_dependency_comparator"""
+
+    gold_standard: str
+    test_set: str
+    output: str
+
+    def __str__(self) -> str:
+        return str(self.__dict__)