Matrix.py

class MatrixRow(Elaboratable):
    def __init__(self, num_values, num_sets, num_sets_per_row, row_id):
        self.num_values = num_values
        self.num_sets = num_sets
        self.id = row_id
        addr_width = (num_values-1).bit_length()

        self.addr = Array(Array(Signal(addr_width, name=f"row_addr_{i}_{j}") for j in range(num_sets_per_row)) for i in range(num_sets))
        self.row_set  = Array(Signal(name=f"row_set_{i}") for i in range(num_sets))

        self.clears = Signal(num_values, name=f"col_clear")

        self.values = Signal(num_values, name=f"row_{row_id}_values")

        # outputs
        self.all_clear = Signal()

    def elaborate(self, platform):
        m = Module()

        for i in range(self.num_values):
            if i == self.id or i == 0: # skip row == col and the zero column
                continue

            col_clear = Signal()
            m.d.comb += col_clear.eq(self.clears[i])

            selected = Const(0)

            for row_set, addrs in zip(self.row_set, self.addr):
                for addr in addrs:
                    new_selected = Signal(name=f"row_{self.id}_col_{i}_selected")
                    m.d.comb += new_selected.eq(selected | (row_set & (addr == Const(self.id))))
                    selected = new_selected

            with m.If(col_clear): # A clear overrides sets
                m.d.sync += self.values[i].eq(False)
            with m.Elif(selected):
                m.d.sync += self.values[i].eq(True)
            with m.Else():
                m.d.sync += self.values[i].eq(self.values[i])


        m.d.comb += self.all_clear.eq(self.values == 0)
        return m