WIP

.pre-commit-config.yaml

@@ -0,0 +1,40 @@
+exclude: |
+    (?x)^(
+        docs/.*
+    )$
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.4.0
+    hooks:
+      - id: debug-statements
+      - id: check-merge-conflict
+  - repo: https://github.com/asottile/pyupgrade
+    rev: v3.3.1
+    hooks:
+    - id: pyupgrade
+      args: ["--py38-plus"] 
+  - repo: https://github.com/psf/black
+    rev: 23.1.0
+    hooks:
+      - id: black
+        language_version: python3
+  - repo: https://github.com/pycqa/flake8
+    rev: 6.0.0
+    hooks:
+      - id: flake8
+  - repo: https://github.com/pycqa/isort
+    rev: 5.11.5
+    hooks:
+      - id: isort
+  - repo: https://github.com/humitos/mirrors-autoflake.git
+    rev: v1.1
+    hooks:
+      - id: autoflake
+        args: ['--in-place', '--remove-all-unused-imports', '--remove-unused-variable']
+  - repo: https://github.com/pre-commit/mirrors-mypy
+    rev: v1.1.1
+    hooks:
+      - id: mypy
+        additional_dependencies:
+        - types-filelock
+        - types-setuptools

README.md

@@ -12,7 +12,7 @@ within Numba.
 The code in this repository is an implementation of the CFG restructuring
 algorithms in Bahmann2015, specifically those from section 4.1 and 4.2: namely
 "loop restructuring" and "branch restructuring". These are interesting for
-Numba because they serve to clearly identify regions withing the Python
+Numba because they serve to clearly identify regions within the Python
 bytecode.
 
 ## dependencies
@@ -42,16 +42,16 @@ numba_rvsdg
 ├── core
 │   ├── datastructures
 │   │   ├── basic_block.py  # BasicBlock implementation
-│   │   ├── block_map.py    # BlockMap implementation, maps labels to blocks
-│   │   ├── byte_flow.py    # ByteFlow implementation, BlockMap + bytecode
+│   │   ├── scfg.py         # SCFG implementation, maps labels to blocks
+│   │   ├── byte_flow.py    # ByteFlow implementation, SCFG + bytecode
 │   │   ├── flow_info.py    # Converts program to ByteFlow
 │   │   └── labels.py       # Collection of Label classes
 │   ├── transformations.py  # Algorithms
 │   └── utils.py            # Miscellaneous utilities
 ├── networkx_vendored
 │   └── scc.py              # Strongly Connected Componets (loop detection)
 ├── rendering
-│   └── rendering.py        # Graphivz based rendering of BlockMaps
+│   └── rendering.py        # Graphivz based rendering of SCFGs
 ├── tests
 │   ├── simulator.py        # Simulator utility for running SCFGs
 │   ├── test_byteflow.py    # Testung ByteFlow and others

numba_rvsdg/core/datastructures/basic_block.py

@@ -1,47 +1,31 @@
 import dis
-from collections import ChainMap
-from typing import Tuple, Dict, List
-from dataclasses import dataclass, field, replace
+from typing import Dict, List
+from dataclasses import dataclass, field, InitVar
 
-from numba_rvsdg.core.datastructures.labels import Label
+from numba_rvsdg.core.datastructures.labels import Label, NameGenerator, BlockName
 from numba_rvsdg.core.utils import _next_inst_offset
 
 
 @dataclass(frozen=True)
-class BasicBlock:
-    label: Label
-    """The corresponding Label for this block.  """
-
-    _jump_targets: Tuple[Label] = tuple()
-    """Jump targets (branch destinations) for this block"""
-
-    backedges: Tuple[Label] = tuple()
-    """Backedges for this block."""
+class Block:
+    name_gen: InitVar[NameGenerator]
+    """Block Name Generator associated with this Block.
+       Note: This is an initialization only argument and not
+       a class attribute."""
 
-    @property
-    def is_exiting(self) -> bool:
-        return not self.jump_targets
+    label: Label
+    """The corresponding Label for this block."""
 
-    @property
-    def fallthrough(self) -> bool:
-        return len(self._jump_targets) == 1
 
-    @property
-    def jump_targets(self) -> Tuple[Label]:
-        acc = []
-        for j in self._jump_targets:
-            if j not in self.backedges:
-                acc.append(j)
-        return tuple(acc)
+@dataclass(frozen=True)
+class BasicBlock(Block):
 
-    def replace_backedge(self, target: Label) -> "BasicBlock":
-        if target in self.jump_targets:
-            assert not self.backedges
-            return replace(self, backedges=(target,))
-        return self
+    block_name: BlockName = field(init=False)
+    """Unique name identifier for this block"""
 
-    def replace_jump_targets(self, jump_targets: Tuple) -> "BasicBlock":
-        return replace(self, _jump_targets=jump_targets)
+    def __post_init__(self, name_gen: NameGenerator):
+        block_name = name_gen.new_block_name(label=self.label)
+        object.__setattr__(self, "block_name", block_name)
 
 
 @dataclass(frozen=True)
@@ -83,44 +67,25 @@ class BranchBlock(BasicBlock):
     variable: str = None
     branch_value_table: dict = None
 
-    def replace_jump_targets(self, jump_targets: Tuple) -> "BasicBlock":
-        fallthrough = len(jump_targets) == 1
-        old_branch_value_table = self.branch_value_table
-        new_branch_value_table = {}
-        for target in self.jump_targets:
-            if target not in jump_targets:
-                # ASSUMPTION: only one jump_target is being updated
-                diff = set(jump_targets).difference(self.jump_targets)
-                assert len(diff) == 1
-                new_target = next(iter(diff))
-                for k, v in old_branch_value_table.items():
-                    if v == target:
-                        new_branch_value_table[k] = new_target
-            else:
-                # copy all old values
-                for k, v in old_branch_value_table.items():
-                    if v == target:
-                        new_branch_value_table[k] = v
-
-        return replace(
-            self,
-            _jump_targets=jump_targets,
-            branch_value_table=new_branch_value_table,
-        )
 
+# Maybe we can register new blocks over here instead of static lists
+block_types = {
+    "basic": BasicBlock,
+    "python_bytecode": PythonBytecodeBlock,
+    "control_variable": ControlVariableBlock,
+    "branch": BranchBlock,
+}
 
-@dataclass(frozen=True)
-class RegionBlock(BasicBlock):
-    kind: str = None
-    headers: Dict[Label, BasicBlock] = None
-    """The header of the region"""
-    subregion: "BlockMap" = None
-    """The subgraph excluding the headers
-    """
-    exit: Label = None
-    """The exit node.
-    """
 
-    def get_full_graph(self):
-        graph = ChainMap(self.subregion.graph, self.headers)
-        return graph
+def get_block_class(block_type_string: str):
+    if block_type_string in block_types:
+        return block_types[block_type_string]
+    else:
+        raise TypeError(f"Block Type {block_type_string} not recognized.")
+
+def get_block_class_str(basic_block: BasicBlock):
+    for key, value in block_types.items():
+        if isinstance(basic_block, value):
+            return key
+    else:
+        raise TypeError(f"Block Type of {basic_block} not recognized.")