+++ /dev/null
-# SPDX-License-Identifier: LGPL-3-or-later
-# Copyright 2022 Jacob Lifshay programmerjake@gmail.com
-
-""" Draw Textual Tree from list of operations
-
-https://bugs.libre-soc.org/show_bug.cgi?id=697
-"""
-
-
-from dataclasses import dataclass, field
-from enum import Enum
-from re import T
-from typing import Iterable
-from cached_property import cached_property
-
-
-class Op:
- """Generic N-in M-out operation."""
-
- def __init__(self, outs, ins):
- self.outs = tuple(map(int, outs))
- self.ins = tuple(map(int, ins))
-
- @property
- def name(self):
- return self.__class__.__name__
-
- def __str__(self):
- outs = repr(self.outs) if len(self.outs) != 1 else repr(self.outs[0])
- ins = repr(self.ins) if len(self.ins) != 1 else repr(self.ins[0])
- return f"{self.name} {outs} <= {ins}"
-
- def __repr__(self):
- return f"{self.name}({self.outs!r}, {self.ins!r})"
-
-
-@dataclass(frozen=True, unsafe_hash=True)
-class _SSAReg:
- reg: int
- counter: int
-
-
-@dataclass
-class _RegState:
- ssa_reg: _SSAReg
- written_by: "_Cell | None"
-
- @property
- def tree_depth(self):
- if self.written_by is None:
- return 0
- return self.written_by.tree_depth
-
-
-@dataclass
-class _Cell:
- op: "Op | None"
- outs: "tuple[_SSAReg, ...]"
- ins: "tuple[_SSAReg, ...]"
- tree_depth: int
-
- @cached_property
- def __op_text(self):
- # only cache if op is set, otherwise debuggers could cache the empty
- # value prematurely, causing the code to fail when debugged
- assert self.op is not None
- return str(self.op)
-
- @property
- def text(self):
- if self.op is None:
- return ""
- return self.__op_text
-
- @property
- def io_coords_count(self):
- return max(len(self.outs), len(self.ins))
-
- @property
- def cell_part_text_width(self):
- """return the terminal width used by text"""
- # Python doesn't have the right function needed to implement this,
- # the correct function is something like:
- # https://docs.rs/unicode-width/0.1.9/unicode_width/trait.UnicodeWidthStr.html#tymethod.width
- # so, we just return something kinda sorta ok, sorry non-ascii people
- text_width = len(self.text)
- io_text_width = self.io_coords_count
- return max(text_width, io_text_width)
-
- @property
- def cell_part_text_height(self):
- return 1
-
- @property
- def grid_x(self):
- if len(self.outs):
- return self.outs[0].reg
- if len(self.ins):
- return self.ins[0].reg
- return 0
-
- @property
- def grid_y(self):
- return self.tree_depth
-
- @property
- def grid_pos(self):
- return self.grid_x, self.grid_y
-
- def clear_after_size_bump(self):
- # TODO: add clearing locals with routing info
- pass
-
-
-class _RestartWithBiggerChannel(Exception):
- pass
-
-
-class _CheckIfFitsResult(Enum):
- FITS = True
- KEEP_LOOKING = False
- CANCEL = "cancel"
-
-
-@dataclass
-class _RoutingChannelBase:
- cell_coord: int
- used: "set[tuple[_Coord, _Coord]]" = field(default_factory=set, init=False)
- size: int = 0
-
- def clear_after_size_bump(self):
- self.used.clear()
-
- def _allocate_segment(self, coord_range, flip_coords, check_if_fits=None):
- """allocate a segment of a horizontal line extending to every x
- in coord_range.
- returns the allocated y _Coord.
- flip_coords: bool
- true if we're allocating a vertical line segment rather than
- horizontal. exchanges x and y.
- """
- subcell_coord = 0
- coord_range = list(coord_range)
- while True:
- y = _Coord(cell_coord=self.cell_coord, in_routing_channel=True,
- subcell_coord=subcell_coord)
- fits = True
- for x in coord_range:
- assert isinstance(x, _Coord)
- pos = (y, x) if flip_coords else (x, y)
- if pos in self.used:
- fits = False
- break
- if fits and check_if_fits is not None:
- result = check_if_fits(y)
- if result == _CheckIfFitsResult.CANCEL:
- return None
- elif result == _CheckIfFitsResult.KEEP_LOOKING:
- fits = False
- else:
- assert result == _CheckIfFitsResult.FITS
- if not fits:
- subcell_coord += 1
- if subcell_coord >= self.size:
- self.size += 1
- raise _RestartWithBiggerChannel
- continue
- for x in coord_range:
- assert isinstance(x, _Coord)
- pos = (y, x) if flip_coords else (x, y)
- self.used.add(pos)
- return y
-
-
-@dataclass
-class _HorizontalRoutingChannel(_RoutingChannelBase):
- def alloc_h_seg(self, x_range, check_if_fits=None):
- """allocate a segment of a horizontal line extending to every x
- in x_range.
- returns the allocated y _Coord.
- """
- return self._allocate_segment(x_range, flip_coords=False,
- check_if_fits=check_if_fits)
-
-
-@dataclass
-class _VerticalRoutingChannel(_RoutingChannelBase):
- def alloc_v_seg(self, y_range, check_if_fits=None):
- """allocate a segment of a vertical line extending to every y
- in y_range.
- returns the allocated x _Coord.
- """
- return self._allocate_segment(y_range, flip_coords=True,
- check_if_fits=check_if_fits)
-
-
-@dataclass(frozen=True, unsafe_hash=True)
-class _Coord:
- r"""
- Coordinates:
- cell_x
- /---------------------------^-------------------------\
- | |
- rx=0 rx=1 rx=2 rx=3 ox=0 ox=1 ox=2 ox=3
- /- +--------------------------+--------------------------+
- ry=0 | | Routing Channel -------- | Routing Channel -------- | ry=0
- | | horizontal coord: | | horizontal coord: | |
- ry=1 | | cell_coord=cell_x ------ | cell_coord=cell_x ------ | ry=1
- | | in_routing_channel=True | in_routing_channel=False |
- ry=2 | | subcell_coord=rx ------- | subcell_coord=ox ------- | ry=2
- | | vertical coord: | | vertical coord: | |
- ry=3 | | cell_coord=cell_y ------ | cell_coord=cell_y ------ | ry=3
- | | in_routing_channel=True | in_routing_channel=True |
- ry=4 | | subcell_coord=ry ------- | subcell_coord=ry ------- | ry=4
- | | | | | | | | | | | |
- | +--------------------------+--------------------------+
- cell_y < | Routing Channel | | horizontal coord: | |
- | | horizontal coord: | | cell_coord=cell_x | |
- | | cell_coord=cell_x | | in_routing_channel=False |
- | | in_routing_channel=True | subcell_coord=ox | |
- | | subcell_coord=rx | | vertical coord: | |
- | | vertical coord: | | cell_coord=cell_y | |
- | | cell_coord=cell_y | | in_routing_channel=False |
- | | in_routing_channel=False | subcell_coord=oy | |
- | | subcell_coord=oy | | | | | | |
- | | | | | | | V V V V |
- oy=0 | | | | | | | +-In0--In1--In2--In3--+ | oy=0
- | | | | | | | | Op | |
- oy=1 | | | | | | | +-Out0-Out1-Out2------+ | oy=1
- | | | | | | | | | | |
- \- +--------------------------+--------------------------+
- rx=0 rx=1 rx=2 rx=3 ox=0 ox=1 ox=2 ox=3
- """
- cell_coord: int
- in_routing_channel: bool
- subcell_coord: int
-
- def __lt__(self, other):
- if not isinstance(other, _Coord):
- return NotImplemented
- if self.cell_coord < other.cell_coord:
- return True
- if self.cell_coord > other.cell_coord:
- return False
- if self.in_routing_channel and not other.in_routing_channel:
- return True
- if not self.in_routing_channel and other.in_routing_channel:
- return False
- return self.subcell_coord < other.subcell_coord
-
- def __le__(self, other):
- if not isinstance(other, _Coord):
- return NotImplemented
- return not other.__lt__(self)
-
- def __gt__(self, other):
- if not isinstance(other, _Coord):
- return NotImplemented
- return other.__lt__(self)
-
- def __ge__(self, other):
- if not isinstance(other, _Coord):
- return NotImplemented
- return not self.__lt__(other)
-
-
-@dataclass
-class _Route:
- """route, made of horizontal and vertical lines,
- from some op's output to another op's input.
- """
- coords: "list[_Coord]" = field(default_factory=list)
- """alternating x and y coords for the route, starting with y"""
-
- def __len__(self):
- """number of points in this route"""
- return max(len(self.coords) - 1, 0)
-
- def __getitem__(self, index):
- assert isinstance(index, int)
- if index < 0:
- index += len(self)
- assert 0 <= index < len(self)
- c0 = self.coords[index]
- c1 = self.coords[index + 1]
- if index % 2 != 0:
- return c0, c1
- return c1, c0
-
- def __iter__(self):
- for i in range(len(self)):
- yield self[i]
-
- @property
- def start_pos(self):
- return self[0]
-
- @property
- def end_pos(self):
- return self[-1]
-
- def __str__(self):
- return f"Route{{{' -> '.join(map(repr, self))}}}"
-
-
-@dataclass
-class _GridRow:
- cells: "list[_Cell | None]"
- routing_channel: _HorizontalRoutingChannel
- cell_part_text_height: int = 0
- text_y_start: "int | None" = None
-
- @property
- def text_height(self):
- return self.cell_part_text_height + self.routing_channel.size
-
- def __init__(self, cell_y, x_size):
- assert isinstance(x_size, int)
- self.cells = [None] * x_size
- self.routing_channel = _HorizontalRoutingChannel(cell_coord=cell_y)
-
- def clear_after_size_bump(self):
- for cell in self.cells:
- if cell is not None:
- cell.clear_after_size_bump()
- self.routing_channel.clear_after_size_bump()
- self.cell_part_text_height = 0
- self.text_y_start = None
-
-
-@dataclass
-class _GridCol:
- routing_channel: _VerticalRoutingChannel
- cell_part_text_width: int = 0
- io_coords_count: int = 0
- text_x_start: "int | None" = None
-
- @property
- def text_width(self):
- return self.cell_part_text_width + self.routing_channel.size
-
- def __init__(self, cell_x):
- self.routing_channel = _VerticalRoutingChannel(cell_coord=cell_x)
-
- def clear_after_size_bump(self):
- self.routing_channel.clear_after_size_bump()
- self.cell_part_text_width = 0
- self.text_x_start = None
-
-
-@dataclass
-class _Grid:
- cols: "list[_GridCol]"
- rows: "list[_GridRow]"
- x_coords: "list[_Coord]"
- x_coords_indexes: "dict[_Coord, int]"
- y_coords: "list[_Coord]"
- y_coords_indexes: "dict[_Coord, int]"
-
- def __init__(self, x_size, y_size):
- self.cols = [_GridCol(cell_x) for cell_x in range(x_size)]
- self.rows = [_GridRow(cell_y, x_size) for cell_y in range(y_size)]
- self.x_coords = []
- self.x_coords_indexes = {}
- self.y_coords = []
- self.y_coords_indexes = {}
-
- def clear_after_size_bump(self):
- for col in self.cols:
- col.clear_after_size_bump()
- for row in self.rows:
- row.clear_after_size_bump()
-
- def calc_positions_and_sizes(self):
- self.x_coords = []
- self.y_coords = []
- text_y = 0
- for cell_y, row in enumerate(self.rows):
- row.text_y_start = text_y
- for cell_x, cell in enumerate(row.cells):
- if cell is None:
- continue
- col = self.cols[cell_x]
- col.cell_part_text_width = max(col.cell_part_text_width,
- cell.cell_part_text_width)
- row.cell_part_text_height = max(row.cell_part_text_height,
- cell.cell_part_text_height)
- col.io_coords_count = max(col.io_coords_count,
- cell.io_coords_count)
- for subcell_coord in range(row.routing_channel.size):
- self.y_coords.append(_Coord(cell_coord=cell_y,
- in_routing_channel=True,
- subcell_coord=subcell_coord))
- self.y_coords.append(_Coord(cell_coord=cell_y,
- in_routing_channel=False,
- subcell_coord=0))
- self.y_coords.append(_Coord(cell_coord=cell_y,
- in_routing_channel=False,
- subcell_coord=1))
- text_y += row.text_height
- text_x = 0
- for cell_x, col in enumerate(self.cols):
- col.text_x_start = text_x
- for subcell_coord in range(col.routing_channel.size):
- self.x_coords.append(_Coord(cell_coord=cell_x,
- in_routing_channel=True,
- subcell_coord=subcell_coord))
- for subcell_coord in range(col.io_coords_count):
- self.x_coords.append(_Coord(cell_coord=cell_x,
- in_routing_channel=False,
- subcell_coord=subcell_coord))
- text_x += col.text_width
- assert self.x_coords == sorted(self.x_coords), \
- "mismatch with _Coord comparison"
- assert self.y_coords == sorted(self.y_coords), \
- "mismatch with _Coord comparison"
- self.x_coords_indexes = {x: i for i, x in enumerate(self.x_coords)}
- self.y_coords_indexes = {y: i for i, y in enumerate(self.y_coords)}
-
- def text_x(self, x_coord):
- assert isinstance(x_coord, _Coord)
- col = self.cols[x_coord.cell_coord]
- assert col.text_x_start is not None
- if x_coord.in_routing_channel:
- return col.text_x_start + x_coord.subcell_coord
- else:
- return (col.text_x_start + col.routing_channel.size
- + x_coord.subcell_coord)
-
- def text_y(self, y_coord):
- assert isinstance(y_coord, _Coord)
- row = self.rows[y_coord.cell_coord]
- assert row.text_y_start is not None
- if y_coord.in_routing_channel:
- return row.text_y_start + y_coord.subcell_coord
- else:
- return (row.text_y_start + row.routing_channel.size
- + y_coord.subcell_coord)
-
- def __getitem__(self, pos):
- x, y = pos
- assert isinstance(x, int)
- assert isinstance(y, int)
- return self.rows[y].cells[x]
-
- def __setitem__(self, pos, value):
- assert value is None or isinstance(value, _Cell)
- x, y = pos
- assert isinstance(x, int)
- assert isinstance(y, int)
- self.rows[y].cells[x] = value
-
- def range_x_coord(self, first_x, last_x):
- """return all x `_Coord`s in first_x to last_x inclusive"""
- assert isinstance(first_x, _Coord)
- assert isinstance(last_x, _Coord)
- first = self.x_coords_indexes[first_x]
- last = self.x_coords_indexes[last_x]
- if first < last:
- return self.x_coords[first:last + 1]
- return self.x_coords[last:first + 1]
-
- def range_y_coord(self, first_y, last_y):
- """return all y `_Coord`s in first_y to last_y inclusive"""
- assert isinstance(first_y, _Coord)
- assert isinstance(last_y, _Coord)
- first = self.y_coords_indexes[first_y]
- last = self.y_coords_indexes[last_y]
- if first < last:
- return self.y_coords[first:last + 1]
- return self.y_coords[last:first + 1]
-
- def alloc_h_seg(self, src_x, dest_x, cell_y, check_if_fits=None):
- assert isinstance(src_x, _Coord)
- assert isinstance(dest_x, _Coord)
- assert isinstance(cell_y, int)
- horiz_rc = self.rows[cell_y].routing_channel
- r = self.range_x_coord(src_x, dest_x)
- return horiz_rc.alloc_h_seg(r, check_if_fits=check_if_fits)
-
- def alloc_v_seg(self, cell_x, src_y, dest_y, check_if_fits=None):
- assert isinstance(cell_x, int)
- assert isinstance(src_y, _Coord)
- assert isinstance(dest_y, _Coord)
- vert_rc = self.cols[cell_x].routing_channel
- r = self.range_y_coord(src_y, dest_y)
- return vert_rc.alloc_v_seg(r, check_if_fits=check_if_fits)
-
- def allocate_route(self, dest_op_input_index, dest_cell_pos,
- src_op_output_index, src_cell_pos):
- assert isinstance(dest_op_input_index, int)
- dest_cell_x, dest_cell_y = dest_cell_pos
- assert isinstance(dest_cell_x, int)
- assert isinstance(dest_cell_y, int)
- assert isinstance(src_op_output_index, int)
- src_cell_x, src_cell_y = src_cell_pos
- assert isinstance(src_cell_x, int)
- assert isinstance(src_cell_y, int)
- assert dest_cell_y > src_cell_y, "bad route passed in"
- src_x = _Coord(cell_coord=src_cell_x,
- in_routing_channel=False,
- subcell_coord=src_op_output_index)
- src_y = _Coord(cell_coord=src_cell_y,
- in_routing_channel=False,
- subcell_coord=1)
- dest_x = _Coord(cell_coord=dest_cell_x,
- in_routing_channel=False,
- subcell_coord=dest_op_input_index)
- dest_y = _Coord(cell_coord=dest_cell_y,
- in_routing_channel=False,
- subcell_coord=0)
- if dest_cell_y == src_cell_y + 1:
- # no intervening cells vertically
- if src_x == dest_x:
- # straight line from src to dest
- return _Route([src_y, src_x, dest_y])
- rc_y = self.alloc_h_seg(src_x, dest_x, dest_cell_y)
- assert rc_y is not None
- return _Route([
- # start
- src_y, src_x,
- # go to routing channel
- rc_y,
- # go horizontally to dest x
- dest_x,
- # go vertically to dest y
- dest_y,
- ])
- else:
- def check_if_fits(y):
- raise NotImplementedError
- raise NotImplementedError
- todo_x = ... # FIXME finish
- src_horiz_rc_y = self.alloc_h_seg(src_x, todo_x, dest_cell_y,
- check_if_fits=check_if_fits)
- raise NotImplementedError
-
-
-@dataclass
-class _Regs:
- __regs: "list[_RegState]" = field(default_factory=list)
-
- def get(self, reg):
- assert isinstance(reg, int) and reg >= 0
- for i in range(len(self.__regs), reg + 1):
- self.__regs.append(_RegState(_SSAReg(i, 0), None))
- return self.__regs[reg]
-
- def __len__(self):
- return len(self.__regs)
-
-
-def render_tree(program, indent_str=""):
- """draw a tree of operations. returns a string with the rendered tree.
- program: Iterable[Op]
- """
- # build ops_graph
- ops_graph: "dict[_SSAReg, _Cell]"
- ops_graph = {}
- regs = _Regs()
- cells: "list[_Cell]" = []
- for op in program:
- assert isinstance(op, Op)
- ins = tuple(regs.get(reg).ssa_reg for reg in op.ins)
- tree_depth = max(regs.get(reg).tree_depth for reg in op.ins) + 1
- outs = tuple(regs.get(reg).ssa_reg for reg in op.outs)
- assert len(set(outs)) == len(outs), \
- f"duplicate output registers on the same instruction: {op}"
- cell = _Cell(
- op=op, outs=outs, ins=ins, tree_depth=tree_depth)
- for out in op.outs:
- out_reg = regs.get(out)
- out_reg.ssa_reg = out = _SSAReg(out, out_reg.ssa_reg.counter + 1)
- ops_graph[out] = out_reg.written_by = cell
- cells.append(cell)
-
- # generate output grid
- grid = _Grid(x_size=len(regs),
- y_size=max(i.grid_y for i in ops_graph.values()) + 1)
- for cell in cells:
- grid[cell.grid_pos] = cell
- raise NotImplementedError
-
-
-def print_tree(program, indent_str=""):
- """draw a tree of operations. prints the tree to stdout.
- program: Iterable[Op]
- """
- print(render_tree(program, indent_str=indent_str))
projects / openpower-isa.git / commitdiff