def generate_fp_pow_component(width: int, int_width: int, is_signed: bool) -> Component:
"""Generates a fixed point `pow` component, which
computes the value x**y, where y must be an integer.
"""
stdlib = Stdlib()
frac_width = width - int_width
pow = CompVar("pow")
count = CompVar("count")
mul = CompVar("mul")
lt = CompVar("lt")
incr = CompVar("incr")
cells = [
Cell(pow, stdlib.register(width)),
Cell(count, stdlib.register(width)),
Cell(
mul,
stdlib.fixed_point_op(
"mult_pipe", width, int_width, frac_width, signed=is_signed
),
),
Cell(lt, stdlib.op("lt", width, signed=is_signed)),
Cell(incr, stdlib.op("add", width, signed=is_signed)),
]
wires = [
Group(
id=CompVar("init"),
connections=[
Connect(
ConstantPort(
width,
numeric_types.FixedPoint(
"1.0", width, int_width, is_signed=is_signed
).unsigned_integer(),
),
CompPort(pow, "in"),
),
Connect(ConstantPort(1, 1), CompPort(pow, "write_en")),
Connect(ConstantPort(width, 0), CompPort(count, "in")),
Connect(ConstantPort(1, 1), CompPort(count, "write_en")),
Connect(
ConstantPort(1, 1),
HolePort(CompVar("init"), "done"),
And(
Atom(CompPort(pow, "done")),
Atom(CompPort(count, "done")),
),
),
],
),
Group(
id=CompVar("execute_mul"),
connections=[
Connect(ThisPort(CompVar("base")), CompPort(mul, "left")),
Connect(CompPort(pow, "out"), CompPort(mul, "right")),
Connect(
ConstantPort(1, 1),
CompPort(mul, "go"),
Not(Atom(CompPort(mul, "done"))),
),
Connect(CompPort(mul, "done"), CompPort(pow, "write_en")),
Connect(CompPort(mul, "out"), CompPort(pow, "in")),
Connect(
CompPort(pow, "done"),
HolePort(CompVar("execute_mul"), "done"),
),
],
),
Group(
id=CompVar("incr_count"),
connections=[
Connect(ConstantPort(width, 1), CompPort(incr, "left")),
Connect(CompPort(count, "out"), CompPort(incr, "right")),
Connect(CompPort(incr, "out"), CompPort(count, "in")),
Connect(ConstantPort(1, 1), CompPort(count, "write_en")),
Connect(
CompPort(count, "done"),
HolePort(CompVar("incr_count"), "done"),
),
],
),
Group(
id=CompVar("cond"),
connections=[
Connect(CompPort(count, "out"), CompPort(lt, "left")),
Connect(ThisPort(CompVar("integer_exp")), CompPort(lt, "right")),
Connect(ConstantPort(1, 1), HolePort(CompVar("cond"), "done")),
],
),
Connect(CompPort(CompVar("pow"), "out"), ThisPort(CompVar("out"))),
]
return Component(
"fp_pow",
inputs=[
PortDef(CompVar("base"), width),
PortDef(CompVar("integer_exp"), width),
],
outputs=[PortDef(CompVar("out"), width)],
structs=cells + wires,
controls=SeqComp(
[
Enable("init"),
While(
CompPort(lt, "out"),
CompVar("cond"),
ParComp([Enable("execute_mul"), Enable("incr_count")]),
),
]
),
)
def visit_let(self, let):
"""Visits a `let` statement in the following manner:
1. Visit the `value`.
2. Visit the `var`, or destination.
3. Return the `body`.
"""
value = self.visit(let.value)
dest = self.visit(let.var)
if isinstance(value, tvm.relay.Constant):
# Generates a constant primitive.
# This is done here since we need
# both the variable id and the value.
width = get_bitwidth(value.data)
if "float" in value.data.dtype:
# Convert to fixed point.
constant = float_to_fixed_point(value.data.asnumpy(), width // 2)
val = numeric_types.FixedPoint(
f"{constant}", width, width // 2, True
).unsigned_integer()
else:
val = value.data
cell = Cell(CompVar(dest.id.name), Stdlib().constant(width, val))
self.id_to_cell[dest.id.name] = cell
elif isinstance(value, tvm.relay.Call):
# Generates cells and control for a Relay Call:
# 1. `Invoke` control
# 2. Component declaration for the invoked component.
# 3. `DahliaFuncDef` to generate the Relay call component.
func_name = value.op.name
# Function names may have a Relay
# namespace prepended, e.g. `nn.bias_add`.
# We want to remove these.
prefix = func_name.find(".")
if prefix is not None:
func_name = func_name[prefix + 1 :]
# Append arity to Calyx component name.
dims = "x".join([str(i) for i in get_dimension_sizes(dest.comp)])
# Given functions with the same operator and arity,
# append a unique identifier to the preceding. Eventually,
# we may want to use the same component and different
# instances. This will require careful manipulation
# of input and output ports of the two components.
comp_name = self.func_id(f"{func_name}_{dims}")
comp_decl = CompVar(f"{comp_name}_")
self.id_to_cell[comp_name] = Cell(comp_decl, CompInst(comp_name, []))
self.controls.append(
# Append Invoke control to the `main` component.
emit_invoke_control(comp_decl, dest, value.args)
)
self.func_defs.append(
DahliaFuncDef(
function_id=func_name,
component_name=comp_name,
dest=dest,
args=value.args,
attributes=value.attrs,
data_type=get_dahlia_data_type(let.var.type_annotation),
)
)
else:
assert 0, f"{value} is not supported yet."
return self.visit(let.body)
def generate_cells(
degree: int, width: int, int_width: int, is_signed: bool
) -> List[Cell]:
stdlib = Stdlib()
frac_width = width - int_width
init_cells = [
Cell(CompVar("exponent_value"), stdlib.register(width)),
Cell(CompVar("int_x"), stdlib.register(width)),
Cell(CompVar("frac_x"), stdlib.register(width)),
Cell(CompVar("m"), stdlib.register(width)),
Cell(CompVar("and0"), stdlib.op("and", width, signed=False)),
Cell(CompVar("and1"), stdlib.op("and", width, signed=False)),
Cell(CompVar("rsh"), stdlib.op("rsh", width, signed=False)),
] + (
[Cell(CompVar("lt"), stdlib.op("lt", width, signed=is_signed))]
if is_signed
else []
)
pow_registers = [
Cell(CompVar(f"p{i}"), stdlib.register(width)) for i in range(2, degree + 1)
]
product_registers = [
Cell(CompVar(f"product{i}"), stdlib.register(width))
for i in range(2, degree + 1)
]
sum_registers = [
Cell(CompVar(f"sum{i}"), stdlib.register(width))
for i in range(1, (degree // 2) + 1)
]
adds = [
Cell(
CompVar(f"add{i}"),
stdlib.fixed_point_op(
"add", width, int_width, frac_width, signed=is_signed
),
)
for i in range(1, (degree // 2) + 1)
]
pipes = [
Cell(
CompVar(f"mult_pipe{i}"),
stdlib.fixed_point_op(
"mult_pipe", width, int_width, frac_width, signed=is_signed
),
)
for i in range(1, degree + 1)
]
# One extra `fp_pow` instance to compute e^{int_value}.
pows = [
Cell(CompVar(f"pow{i}"), CompInst("fp_pow", [])) for i in range(1, degree + 1)
]
reciprocal_factorials = []
for i in range(2, degree + 1):
fixed_point_value = float_to_fixed_point(1.0 / factorial(i), frac_width)
value = numeric_types.FixedPoint(
str(fixed_point_value), width, int_width, is_signed=is_signed
).unsigned_integer()
reciprocal_factorials.append(
Cell(CompVar(f"reciprocal_factorial{i}"), stdlib.constant(width, value))
)
# Constant values for the exponent to the fixed point `pow` function.
constants = [
Cell(CompVar(f"c{i}"), stdlib.constant(width, i)) for i in range(2, degree + 1)
] + [
Cell(
CompVar("one"),
stdlib.constant(
width,
numeric_types.FixedPoint(
"1.0", width, int_width, is_signed=is_signed
).unsigned_integer(),
),
),
Cell(
CompVar("e"),
stdlib.constant(
width,
numeric_types.FixedPoint(
str(float_to_fixed_point(2.7182818284, frac_width)),
width,
int_width,
is_signed=is_signed,
).unsigned_integer(),
),
),
]
if is_signed:
constants.append(
Cell(
CompVar("negative_one"),
stdlib.constant(
width,
numeric_types.FixedPoint(
"-1.0", width, int_width, is_signed=is_signed
).unsigned_integer(),
),
),
)
pipes.append(
Cell(
CompVar(f"div_pipe"),
stdlib.fixed_point_op(
"div_pipe", width, int_width, frac_width, signed=is_signed
),
)
)
return (
init_cells
+ constants
+ product_registers
+ pow_registers
+ sum_registers
+ adds
+ pipes
+ reciprocal_factorials
+ pows
)