Selecting part of a StructLayout using an Enum signal

[goekce]

I could not find a way to select part of a StructLayout using a Signal of an Enum. I tried with getattr, but getattr requires a str. Does someone have an idea?

from amaranth import *
from amaranth.lib import data
from amaranth.lib.enum import Enum
from amaranth.lib.wiring import Component, In, Out


class Kind(Enum, shape=1):
    STICK = 0
    HIT = 1


LineLayout = data.StructLayout({item.name: unsigned(2) for item in Kind})


class C(Component):
    o: Out(unsigned(8))

    def elaborate(self, platform):
        m = Module()
        l = Signal(LineLayout, init={"STICK": 2, "HIT": 1})
        k = Signal(Kind)
        m.d.sync += self.o.eq(getattr(l, k))

        m.d.sync += Print(self.o)
        m.d.sync += Print(k)
        return m


from amaranth.sim import Period, Simulator

dut = C()


async def bench(ctx):

    for _ in range(5):
        await ctx.tick()


sim = Simulator(dut)
sim.add_clock(Period())
sim.add_testbench(bench)
sim.run()

[whitequark]

Try using an Array, or a function that generates a series of m.Elif() statements for each of the Enum cases. We have an RFC in the works for making this kind of pattern easier to use but it's not in yet (cc @wanda-phi).

[whitequark]

Yeah, this works!

[goekce]

Actually, it does not work 😕. enum_signal_to_str returns immediately (without iterating over other enumeration items).

I have to create a function that can be elaborated. I see two problems:

1. it should not simply return a string but add to m.d.comb logic that returns a str. str as a signal is not a good idea, I believe.
2. getattr during elaboration does not make sense.

Idea: the function finds the enumeration index and combinationally writes this index to a temporary signal. This is then used in word_select. This would avoid getattr. But this defeats the advantage of Enum, so I could use arrays instead.

What do you think?

[goekce]

I think I have a better understanding now. If I want to add logic programmatically, then I have to add logic to a domain:

from amaranth import *
from amaranth.lib import data
from amaranth.lib.enum import Enum, EnumView
from amaranth.lib.wiring import Component, In, Out


class Kind(Enum, shape=1):
    STICK = 0
    HIT = 1


LineLayout = data.StructLayout({item.name: unsigned(2) for item in Kind})

# Alternative using an `Array`
# LineLayout = data.ArrayLayout(unsigned(2), len(Kind))


def select(
    m: Module,
    data_view: data.View,
    enum_view: EnumView,
    out_signal: Signal,
    domain,
):
    for enum_item in Kind:
        with m.If(enum_view.matches(enum_item)):
            domain += out_signal.eq(getattr(data_view, enum_item.name))


class C(Component):
    o: Out(unsigned(8))

    def elaborate(self, platform):
        m = Module()
        k = Signal(Kind, init=Kind.HIT)
        l = Signal(LineLayout, init={"STICK": 2, "HIT": 1})
        select(m, l, k, self.o, m.d.sync)  # Should lead to 1

        # Alternative using an `Array`
        # l = Signal(LineLayout, init=[2, 1])
        # m.d.sync += self.o.eq(l[k])

        m.d.sync += Print(self.o)
        m.d.sync += Print(k)
        return m


from amaranth.sim import Period, Simulator

dut = C()


async def bench(ctx):

    for _ in range(2):
        await ctx.tick()


sim = Simulator(dut)
sim.add_clock(Period())
sim.add_testbench(bench)
sim.run()

The solution is not very readable, but seems to work. I expect that there is a better solution, however.

[goekce]

Using a SwitchValue improves readability:
edit: the solution uses an internal API function, which may change. Read also the following comments.

from amaranth import *
from amaranth.hdl._ast import SwitchValue
from amaranth.lib import data
from amaranth.lib.enum import Enum, EnumView
from amaranth.lib.wiring import Component, In, Out


class Kind(Enum, shape=1):
    STICK = 0
    HIT = 1


LineLayout = data.StructLayout({item.name: unsigned(2) for item in Kind})


def enum_select(
    data_view: data.View,
    enum_view: EnumView,
):
    return SwitchValue(
        enum_view,
        [
            (enum_item, getattr(data_view, enum_item.name))
            for enum_item in enum_view.shape()
        ],
    )


class C(Component):
    o: Out(unsigned(8))

    def elaborate(self, platform):
        m = Module()
        k = Signal(Kind, init=Kind.HIT)
        l = Signal(LineLayout, init={"STICK": 2, "HIT": 1})
        m.d.sync += self.o.eq(enum_select(l, k))  # Should lead to 1

        m.d.sync += Print(self.o)
        m.d.sync += Print(k)
        return m


from amaranth.sim import Period, Simulator

dut = C()


async def bench(ctx):

    for _ in range(2):
        await ctx.tick()


sim = Simulator(dut)
sim.add_clock(Period())
sim.add_testbench(bench)
sim.run()

[whitequark]

SwitchValue isn't a public API so there are no guarantees you will remain able to use it.

[goekce]

I could not find any practical public functional API that takes a Value and returns another Value. There is Mux, but cascading a Mux is probably not readable. Using m.Switch needs m as an argument. Does someone know an alternative?

In the end, this particular solution is only a workaround for the RFC you are working on. Having a functional API is good for coding flexibility, though 🙂.

[whitequark]

Yes. As long as you understand the risks of using this API, it's fine.

[goekce]

So I understand that there is no practical alternative to SwitchValue. Don't you think that the public API should provide something similar?