chore: mypy type fixes

Author: lukasrothenberger

discopop_explorer/PETGraphX.py

@@ -11,7 +11,7 @@
 import copy
 import sys
 from time import sleep
-from typing import Dict, List, Sequence, Tuple, Set, Optional, Type, TypeVar, cast, Union, overload
+from typing import Dict, List, Sequence, Tuple, Set, Optional, Type, TypeVar, cast, Union, overload, Any
 from enum import IntEnum, Enum
 import itertools
 
@@ -570,7 +570,7 @@ class PETGraphX(object):
     g: nx.MultiDiGraph
     reduction_vars: List[Dict[str, str]]
     main: Node
-    pos: Dict
+    pos: Dict[Any, Any]
 
     def __init__(self, g: nx.MultiDiGraph, reduction_vars: List[Dict[str, str]], pos):
         self.g = g

discopop_explorer/json_serializer.py

@@ -7,6 +7,7 @@
 # directory for details.
 
 from json import JSONEncoder
+from typing import Dict, Any
 
 from .PETGraphX import Node
 from discopop_library.result_classes.DetectionResult import DetectionResult
@@ -16,7 +17,7 @@
 from .pattern_detectors.task_parallelism.classes import TPIType
 
 
-def filter_members(d: dict) -> dict:
+def filter_members(d: Dict[Any, Any]) -> Dict[Any, Any]:
     """Removes private and protected members (which starts with '_')
 
     :param d: member dictionary

discopop_explorer/pattern_detectors/geometric_decomposition_detector.py

@@ -46,7 +46,7 @@ def __init__(self, pet: PETGraphX, node: Node, min_iter: int):
             self.num_tasks = math.floor(nt)
 
         self.pragma = "for (i = 0; i < num-tasks; i++) #pragma omp task"
-        lp: List = []
+        lp: List[Variable] = []
         fp, p, s, in_dep, out_dep, in_out_dep, r = classify_task_vars(pet, node, "GeometricDecomposition", [], [])
         fp.append(Variable("int", "i", "", sizeInByte=4))
 

discopop_explorer/pattern_detectors/simple_gpu_patterns/GPULoop.py

@@ -145,15 +145,15 @@ def omp_construct_dict(
     line: LineID,
     clauses: List[str],
     positioning: OmpConstructPositioning = OmpConstructPositioning.BEFORE_LINE,
-) -> dict:
+) -> Dict[str, Union[str, LineID, List[str], OmpConstructPositioning]]:
     """
 
     :param name:
     :param line:
     :param clauses:
     :return:
     """
-    result: Dict[str, Union[str, int, List[str]]] = dict()
+    result: Dict[str, Union[str, LineID, List[str], OmpConstructPositioning]] = dict()
     result["name"] = name
     result["line"] = line
     result["clauses"] = clauses
@@ -180,7 +180,7 @@ class GPULoopPattern(PatternInfo):
     parentLoop: str
     collapse: int
     scheduling: str
-    constructs: List[dict]
+    constructs: List[Dict[Any, Any]]
     project_folder_path: str
 
     def __init__(
@@ -281,8 +281,10 @@ def toJson(self, pet: PETGraphX, project_folder_path: str) -> str:
         json_output += "]}"
         return json_output
 
-    def __get_constructs(self, pet: PETGraphX, project_folder_path: str) -> List[dict]:
-        constructs: List[dict] = []
+    def __get_constructs(
+        self, pet: PETGraphX, project_folder_path: str
+    ) -> List[Dict[str, Union[str, LineID, List[str], OmpConstructPositioning]]]:
+        constructs: List[Dict[str, Union[str, LineID, List[str], OmpConstructPositioning]]] = []
 
         # == default construct ==
         clauses: List[str] = []

discopop_explorer/pattern_detectors/simple_gpu_patterns/GPUMemory.py

@@ -7,7 +7,7 @@
 # directory for details.
 
 from enum import Enum
-from typing import List, Set, cast
+from typing import List, Set, cast, Tuple
 from discopop_explorer.variable import Variable
 from discopop_explorer.PETGraphX import (
     PETGraphX,
@@ -19,6 +19,7 @@
     DummyNode,
     FunctionNode,
     LoopNode,
+    Dependency,
 )
 from discopop_explorer.utils import is_func_arg, is_global, __get_dep_of_type as get_dep_of_type
 
@@ -91,12 +92,12 @@ def getCalledFunctions(
 def getDeps(
     cuIDs: List[CUNode],
     pet: PETGraphX,
-    RAWDepsOn: Set,
-    WARDepsOn: Set,
-    WAWDepsOn: Set,
-    reverseRAWDepsOn: Set,
-    reverseWARDepsOn: Set,
-    reverseWAWDepsOn: Set,
+    RAWDepsOn: Set[Tuple[NodeID, NodeID, Dependency]],
+    WARDepsOn: Set[Tuple[NodeID, NodeID, Dependency]],
+    WAWDepsOn: Set[Tuple[NodeID, NodeID, Dependency]],
+    reverseRAWDepsOn: Set[Tuple[NodeID, NodeID, Dependency]],
+    reverseWARDepsOn: Set[Tuple[NodeID, NodeID, Dependency]],
+    reverseWAWDepsOn: Set[Tuple[NodeID, NodeID, Dependency]],
 ) -> None:
     """gather all dependencies of the nodes specified in 'cuIDs'
         ---doesnt work here because addresses---
@@ -127,8 +128,8 @@ def assignMapType(
     var: Variable,
     isScalar: bool,
     pet: PETGraphX,
-    RAWDepsOn: Set,
-    reverseRAWDepsOn: Set,
+    RAWDepsOn: Set[Tuple[NodeID, NodeID, Dependency]],
+    reverseRAWDepsOn: Set[Tuple[NodeID, NodeID, Dependency]],
 ) -> map_type_t:
     """assigns a map-type to the variable 'var'
 

discopop_explorer/pattern_detectors/task_parallelism/alias_detection.py

@@ -10,7 +10,7 @@
 import pathlib
 import re
 import subprocess
-from typing import Dict, List, Optional, Match, cast
+from typing import Dict, List, Optional, Match, cast, Any
 from lxml import objectify  # type: ignore
 
 
@@ -178,7 +178,9 @@ def __get_alias_from_statement(var_name: str, var_type: str, statement: str) ->
     return None
 
 
-def __add_alias_information(function_information_list: List[Dict], statements_file: str) -> List[Dict]:
+def __add_alias_information(
+    function_information_list: List[Dict[str, Any]], statements_file: str
+) -> List[Dict[str, Any]]:
     """Wrapper to gather and append alias information to the entries in function_information as a new field.
     Aliases can be found up to a depth of 2.
     Alias detection ignores scopes.
@@ -241,7 +243,7 @@ def __add_alias_information(function_information_list: List[Dict], statements_fi
     return result_list
 
 
-def __get_function_information(cu_xml: str) -> List[Dict]:
+def __get_function_information(cu_xml: str) -> List[Dict[str, Any]]:
     """Extracts information on functions from given cu_xml file and stores it in a dictionary representation.
     :param cu_xml: path to cu_xml file
     :return: List of dictionaries representing functions from cu_xml"""

discopop_explorer/pattern_detectors/task_parallelism/suggesters/barriers.py

@@ -175,9 +175,9 @@ def __count_adjacent_nodes(
     pet: PETGraphX,
     suggestions: List[PatternInfo],
     out_dep_edges: List[Tuple[Any, Any, Any]],
-    task_nodes: List,
-    barrier_nodes: List,
-    omittable_nodes: List,
+    task_nodes: List[Node],
+    barrier_nodes: List[Node],
+    omittable_nodes: List[Tuple[Node, List[Node]]],
 ) -> Tuple[int, int, int, int]:
     """Checks the types of nodes pointed to by out_dep_edges and increments the respective counters.
     :param pet: PET Graph

discopop_explorer/pattern_detectors/task_parallelism/suggesters/dependency_clauses.py

@@ -7,7 +7,7 @@
 # directory for details.
 
 import os
-from typing import List, Dict, Tuple, Optional, Union, cast
+from typing import List, Dict, Tuple, Optional, Union, cast, Any
 
 from discopop_explorer.PETGraphX import (
     CUNode,
@@ -176,7 +176,7 @@ def get_alias_information(pet: PETGraphX, suggestions: List[PatternInfo], source
     task_suggestions = [s for s in [e for e in suggestions if type(e) == TaskParallelismInfo] if s.type is TPIType.TASK]
     # collect alias information
     aliases: Dict[TaskParallelismInfo, List[List[Tuple[str, str, LineID, LineID]]]] = dict()
-    called_function_cache: Dict = dict()
+    called_function_cache: Dict[Any, Any] = dict()
     for ts in task_suggestions:
         current_alias_entry = []
         potential_parent_functions = __get_potential_parent_functions(pet, ts)
@@ -298,9 +298,9 @@ def get_function_internal_parameter_aliases(
 def identify_dependencies_for_different_functions(
     pet: PETGraphX,
     suggestions: List[PatternInfo],
-    aliases: Dict,
-    source_code_files: Dict,
-    raw_dependency_information: Dict,
+    aliases: Dict[TaskParallelismInfo, List[List[Tuple[str, str, LineID, LineID]]]],
+    source_code_files: Dict[str, str],
+    raw_dependency_information: Dict[str, List[Tuple[str, str]]],
 ) -> List[PatternInfo]:
     """Identify dependency clauses for all combinations of suggested tasks concerning different called functions
      and supplement the suggestions.
@@ -496,8 +496,8 @@ def __get_recursive_calls_from_function(potential_children: List[Node], parent_f
 def identify_dependencies_for_same_functions(
     pet: PETGraphX,
     suggestions: List[PatternInfo],
-    source_code_files: Dict,
-    cu_inst_result_dict: Dict,
+    source_code_files: Dict[str, str],
+    cu_inst_result_dict: dict[str, List[Dict[str, Optional[str]]]],
     function_parameter_alias_dict: Dict[str, List[Tuple[str, str]]],
 ) -> List[PatternInfo]:
     """Identify dependency clauses for all combinations of suggested tasks concerning equal called functions
@@ -700,7 +700,7 @@ def get_alias_for_parameter_at_position(
     parameter_position: int,
     source_code_files: Dict[str, str],
     visited: List[Tuple[Node, int]],
-    called_function_cache: Dict,
+    called_function_cache: Dict[Any, Any],
 ) -> List[Tuple[str, str, LineID, LineID]]:
     """Returns alias information for a parameter at a specific position.
     :param pet: PET Graph
@@ -756,8 +756,8 @@ def get_alias_for_parameter_at_position(
 
 
 def check_dependence_of_task_pair(
-    aliases: Dict,
-    raw_dependency_information: Dict,
+    aliases: Dict[TaskParallelismInfo, List[List[Tuple[str, str, LineID, LineID]]]],
+    raw_dependency_information: Dict[str, List[Tuple[str, str]]],
     task_suggestion_1: TaskParallelismInfo,
     param_names_1: List[Optional[str]],
     task_suggestion_2: TaskParallelismInfo,

discopop_explorer/pattern_detectors/task_parallelism/suggesters/tasks.py

@@ -316,7 +316,9 @@ def find_taskwaits(cu_node: Node, visited: List[Node]):
     return suggestions
 
 
-def __identify_atomic_or_critical_sections(pet: PETGraphX, ts: TaskParallelismInfo, found_cus: List, selector: bool):
+def __identify_atomic_or_critical_sections(
+    pet: PETGraphX, ts: TaskParallelismInfo, found_cus: List[Node], selector: bool
+):
     """Identifies and marks atomic or critical sections.
     :param pet: PET Graph
     :param ts: task suggestion

discopop_explorer/pattern_detectors/task_parallelism/tp_utils.py

@@ -7,7 +7,7 @@
 # directory for details.
 
 import subprocess
-from typing import Union, cast, IO, Dict, List, Tuple, Optional
+from typing import Union, cast, IO, Dict, List, Tuple, Optional, Any
 
 from lxml import objectify  # type: ignore
 from discopop_explorer.PETGraphX import (
@@ -528,7 +528,7 @@ def set_global_llvm_cxxfilt_path(value: str):
 
 
 def get_called_functions_recursively(
-    pet: PETGraphX, root: Node, visited: List[Node], cache: Dict
+    pet: PETGraphX, root: Node, visited: List[Node], cache: Dict[Any, Any]
 ) -> List[Union[FunctionNode, DummyNode]]:
     """returns a recursively generated list of called functions, started at root."""
     visited.append(root)