From 3f26530cf69abc527f9a24f9258c06fe250a413b Mon Sep 17 00:00:00 2001
From: Oscar Gustafsson <oscar.gustafsson@gmail.com>
Date: Tue, 9 May 2023 08:28:58 +0200
Subject: [PATCH] Fix formatting
---
b_asic/resources.py | 101 ++++++++++++++++++++++++++------------------
1 file changed, 60 insertions(+), 41 deletions(-)
diff --git a/b_asic/resources.py b/b_asic/resources.py
index f38030b7..1d2bb49f 100644
--- a/b_asic/resources.py
+++ b/b_asic/resources.py
@@ -163,20 +163,24 @@ class _ForwardBackwardEntry:
outputs_from: Optional[int] = None,
):
"""
- Single entry in a _ForwardBackwardTable. Aggregate type of input, output and list of registers.
+ Single entry in a _ForwardBackwardTable.
+
+ Aggregate type of input, output and list of registers.
Parameters
----------
- inputs : List[Process], optional
+ inputs : list of Process, optional
input
- outputs : List[Process], optional
+ outputs : list of Process, optional
output
- regs : List[Optional[Process]], optional
+ regs : list of Process, optional
regs
back_edge_to : dict, optional
- Dictionary containing back edges of this entry to registers in the next entry.
+ Dictionary containing back edges of this entry to registers in the next
+ entry.
back_edge_from : dict, optional
- Dictionary containing the back edge of the previous entry to registers in this entry.
+ Dictionary containing the back edge of the previous entry to registers in
+ this entry.
outputs_from : int, optional
"""
self.inputs: List[Process] = [] if inputs is None else inputs
@@ -192,8 +196,10 @@ class _ForwardBackwardEntry:
class _ForwardBackwardTable:
def __init__(self, collection: 'ProcessCollection'):
"""
- Forward-Backward allocation table for ProcessCollections. This structure implements the forward-backward
- register allocation algorithm, which is used to generate hardware from MemoryVariables in a ProcessCollection.
+ Forward-Backward allocation table for ProcessCollections.
+
+ This structure implements the forward-backward register allocation algorithm,
+ which is used to generate hardware from MemoryVariables in a ProcessCollection.
Parameters
----------
@@ -218,10 +224,12 @@ class _ForwardBackwardTable:
self.table.append(entry)
# Insert all processes (one per time-slot) to the table input
- # TODO: "Input each variable at the time step corresponding to the beginning of its lifetime. If multiple
- # variables are input in a given cycle, theses are allocated to multple registers such that the variable
- # with the longest lifetime is allocated to the inital register and the other variables are allocated to
- # consecutive registers in decreasing order of lifetime." -- K. Parhi
+ # TODO: "Input each variable at the time step corresponding to the beginning of
+ # its lifetime. If multiple variables are input in a given cycle, these
+ # are allocated to multple registers such that the variable with the
+ # longest lifetime is allocated to the inital register and the other
+ # variables are allocated to consecutive registers in decreasing order
+ # of lifetime." -- K. Parhi
for mv in collection:
self.table[mv.start_time].inputs.append(mv)
if mv.execution_time:
@@ -245,13 +253,15 @@ class _ForwardBackwardTable:
def _do_forward_allocation(self):
"""
- Forward all Processes as far as possible in the register chain. Processes are forwarded until they reach their
- end time (at which they are added to the output list), or until they reach the end of the register chain.
+ Forward all Processes as far as possible in the register chain.
+
+ Processes are forwarded until they reach their end time (at which they are
+ added to the output list), or until they reach the end of the register chain.
"""
rows = len(self.table)
cols = len(self.table[0].regs)
- # Note that two passes of the forward allocation need to be done, since variables may loop around the schedule
- # cycle boundary.
+ # Note that two passes of the forward allocation need to be done, since
+ # variables may loop around the schedule cycle boundary.
for _ in range(2):
for time, entry in enumerate(self.table):
for reg_idx, reg in enumerate(entry.regs):
@@ -282,9 +292,9 @@ class _ForwardBackwardTable:
cols = len(self.table[0].regs)
outputs = {out for e in self.table for out in e.outputs}
#
- # Pass #1: Find any (one) non-dead variable from the last register and try to backward allocate it to a
- # previous register where it is not blocking an open path. This heuristic helps minimize forward allocation
- # moves later.
+ # Pass #1: Find any (one) non-dead variable from the last register and try to
+ # backward allocate it to a previous register where it is not blocking an open
+ # path. This heuristic helps minimize forward allocation moves later.
#
for time, entry in enumerate(self.table):
reg = entry.regs[-1]
@@ -299,7 +309,8 @@ class _ForwardBackwardTable:
next_entry.back_edge_from[nreg_idx] = cols - 1
return
#
- # Pass #2: Backward allocate the first non-dead variable from the last registers to an empty register.
+ # Pass #2: Backward allocate the first non-dead variable from the last
+ # registers to an empty register.
#
for time, entry in enumerate(self.table):
reg = entry.regs[-1]
@@ -480,12 +491,12 @@ class ProcessCollection:
show_markers : bool, default True
Show markers at read and write times.
row : int, optional
- Render all processes in this collection on a specified row in the matplotlib axes object.
- Defaults to None, which renders all processes on separate rows. This option is useful when
- drawing cell assignments.
+ Render all processes in this collection on a specified row in the Matplotlib
+ axes object. Defaults to None, which renders all processes on separate rows.
+ This option is useful when drawing cell assignments.
allow_excessive_lifetimes : bool, default False
- If set to true, the plot method allows ploting collections of variables with a greater lifetime
- than the schedule time.
+ If set to true, the plot method allows ploting collections of variables with
+ a greater lifetime than the schedule time.
Returns
-------
@@ -606,8 +617,9 @@ class ProcessCollection:
) -> None:
"""
Show the process collection using the current Matplotlib backend.
- Equivalent to creating a Matplotlib figure, passing it and arguments to :func:`plot`
- and invoking :py:meth:`matplotlib.figure.Figure.show`.
+
+ Equivalent to creating a Matplotlib figure, passing it and arguments to
+ :meth:`plot` and invoking :py:meth:`matplotlib.figure.Figure.show`.
Parameters
----------
@@ -624,8 +636,8 @@ class ProcessCollection:
show_markers : bool, default True
Show markers at read and write times.
allow_excessive_lifetimes : bool, default False
- If set to true, the plot method allows ploting collections of variables with a greater lifetime
- than the schedule time.
+ If set to True, the plot method allows ploting collections of variables with
+ a greater lifetime than the schedule time.
title : str, optional
Title of plot.
"""
@@ -690,7 +702,6 @@ class ProcessCollection:
exclusion_graph = nx.Graph()
exclusion_graph.add_nodes_from(self._collection)
for node1 in exclusion_graph:
- # node1_stop_time = (node1.start_time + node1.execution_time) % self.schedule_time
node1_stop_times = tuple(
read_time % self.schedule_time for read_time in node1.read_times
)
@@ -701,7 +712,6 @@ class ProcessCollection:
if node1 == node2:
continue
else:
- # node2_stop_time = (node2.start_time + node2.execution_time) % self.schedule_time
node2_stop_times = tuple(
read_time % self.schedule_time for read_time in node2.read_times
)
@@ -795,7 +805,8 @@ class ProcessCollection:
The heuristic used when splitting based on execution times.
coloring_strategy : str, default: 'saturation_largest_first'
- Node ordering strategy passed to :func:`networkx.algorithms.coloring.greedy_color`.
+ Node ordering strategy passed to
+ :func:`networkx.algorithms.coloring.greedy_color`.
This parameter is only considered if *heuristic* is set to 'graph_color'.
One of
@@ -887,7 +898,8 @@ class ProcessCollection:
The total number of ports used when splitting process collection based on
memory variable access.
coloring_strategy : str, default: 'saturation_largest_first'
- Node ordering strategy passed to :func:`networkx.algorithms.coloring.greedy_color`
+ Node ordering strategy passed to
+ :func:`networkx.algorithms.coloring.greedy_color`
One of
* 'largest_first'
* 'random_sequential'
@@ -911,7 +923,8 @@ class ProcessCollection:
coloring: Dict[Process, int],
) -> Set["ProcessCollection"]:
"""
- Split :class:`Process` objects into a set of :class:`ProcessesCollection` objects based on a provided graph coloring.
+ Split :class:`Process` objects into a set of :class:`ProcessesCollection`
+ objects based on a provided graph coloring.
Resulting :class:`ProcessCollection` will have the same schedule time and cyclic
property as self.
@@ -960,17 +973,21 @@ class ProcessCollection:
coloring: Optional[Dict[Process, int]] = None,
) -> Set["ProcessCollection"]:
"""
- Perform cell assignment of the processes in this collection using graph coloring.
+ Perform cell assignment of the processes in this collection using graph
+ coloring.
- Two or more processes can share a single cell if, and only if, they have no overlaping time alive.
+ Two or more processes can share a single cell if, and only if, they have no
+ overlaping time alive.
Parameters
----------
coloring_strategy : str, default: "saturation_largest_first"
- Graph coloring strategy passed to :func:`networkx.algorithms.coloring.greedy_color`.
+ Graph coloring strategy passed to
+ :func:`networkx.algorithms.coloring.greedy_color`.
coloring : dictionary, optional
- An optional graph coloring, dictionary with Process and its associated color (int).
- If a graph coloring is not provided throught this parameter, one will be created when calling this method.
+ An optional graph coloring, dictionary with Process and its associated color
+ (int). If a graph coloring is not provided throught this parameter, one will
+ be created when calling this method.
Returns
-------
@@ -991,9 +1008,11 @@ class ProcessCollection:
def left_edge_cell_assignment(self) -> Dict[int, "ProcessCollection"]:
"""
- Perform cell assignment of the processes in this collection using the left-edge algorithm.
+ Perform cell assignment of the processes in this collection using the left-edge
+ algorithm.
- Two or more processes can share a single cell if, and only if, they have no overlaping time alive.
+ Two or more processes can share a single cell if, and only if, they have no
+ overlaping time alive.
Returns
-------
--
GitLab