}
}
- \define[3]\transexample{
- \placeexample[here]{#1}
+ \define[4]\transexample{
+ \placeexample[here][ex:trans:#1]{#2}
\startcombination[2*1]
- {\example{#2}}{Original program}
- {\example{#3}}{Transformed program}
+ {\example{#3}}{Original program}
+ {\example{#4}}{Transformed program}
\stopcombination
}
\VHDL we want to generate should look like.}
\section{Normal form}
+ \todo{Refresh or refer to distinct hardware per application principle}
The transformations described here have a well-defined goal: To bring the
program in a well-defined form that is directly translatable to hardware,
while fully preserving the semantics of the program. We refer to this form as
\item Any complex \emph{nested scopes} must be removed. In the \small{VHDL}
description, every signal is in a single scope. Also, full expressions are
- not supported everywhere (in particular port maps can only map signal names,
- not expressions). To make the \small{VHDL} generation easy, all values must be bound
- on the \quote{top level}.
+ not supported everywhere (in particular port maps can only map signal
+ names and constants, not complete expressions). To make the \small{VHDL}
+ generation easy, a separate binder must be bound to ever application or
+ other expression.
\stopitemize
\todo{Intermezzo: functions vs plain values}
A very simple example of a program in normal form is given in
\in{example}[ex:MulSum]. As you can see, all arguments to the function (which
- will become input ports in the final hardware) are at the top. This means that
- the body of the final lambda abstraction is never a function, but always a
- plain value.
+ will become input ports in the final hardware) are at the outer level.
+ This means that the body of the inner lambda abstraction is never a
+ function, but always a plain value.
- After the lambda abstractions, we see a single let expression, that binds two
- variables (\lam{mul} and \lam{sum}). These variables will be signals in the
- final hardware, bound to the output port of the \lam{*} and \lam{+}
- components.
+ As the body of the inner lambda abstraction, we see a single (recursive)
+ let expression, that binds two variables (\lam{mul} and \lam{sum}). These
+ variables will be signals in the final hardware, bound to the output port
+ of the \lam{*} and \lam{+} components.
The final line (the \quote{return value} of the function) selects the
\lam{sum} signal to be the output port of the function. This \quote{return
value} can always only be a variable reference, never a more complex
expression.
+ \todo{Add generated VHDL}
+
\startbuffer[MulSum]
alu :: Bit -> Word -> Word -> Word
alu = λa.λb.λc.
newCircle.sum(btex $res$ etex) "framed(false)";
% Components
- newCircle.mul(btex - etex);
+ newCircle.mul(btex * etex);
newCircle.add(btex + etex);
a.c - b.c = (0cm, 2cm);
ncline(add)(sum);
\stopuseMPgraphic
- \placeexample[here][ex:MulSum]{Simple architecture consisting of an adder and a
- subtractor.}
+ \placeexample[here][ex:MulSum]{Simple architecture consisting of a
+ multiplier and a subtractor.}
\startcombination[2*1]
{\typebufferlam{MulSum}}{Core description in normal form.}
{\boxedgraphic{MulSum}}{The architecture described by the normal form.}
\stopcombination
The previous example described composing an architecture by calling other
- functions (operators), resulting in a simple architecture with component and
- connection. There is of course also some mechanism for choice in the normal
+ functions (operators), resulting in a simple architecture with components and
+ connections. There is of course also some mechanism for choice in the normal
form. In a normal Core program, the \emph{case} expression can be used in a
few different ways to describe choice. In normal form, this is limited to a
very specific form.
\in{Example}[ex:AddSubAlu] shows an example describing a
simple \small{ALU}, which chooses between two operations based on an opcode
- bit. The main structure is the same as in \in{example}[ex:MulSum], but this
+ bit. The main structure is similar to \in{example}[ex:MulSum], but this
time the \lam{res} variable is bound to a case expression. This case
expression scrutinizes the variable \lam{opcode} (and scrutinizing more
complex expressions is not supported). The case expression can select a
architecture contains a slightly simplified version, since the state tuple
packing and unpacking have been left out. Instead, two seperate registers are
drawn. Also note that most synthesis tools will further optimize this
- architecture by removing the multiplexers at the register input and replace
- them with some logic in the clock inputs, but we want to show the architecture
- as close to the description as possible.
+ architecture by removing the multiplexers at the register input and
+ instead put some gates in front of the register's clock input, but we want
+ to show the architecture as close to the description as possible.
+
+ As you can see from the previous examples, the generation of the final
+ architecture from the normal form is straightforward. In each of the
+ examples, there is a direct match between the normal form structure,
+ the generated VHDL and the architecture shown in the images.
\startbuffer[NormalComplete]
regbank :: Bit
-> State (Word, Word)
-> (State (Word, Word), Word)
- -- All arguments are an inital lambda
+ -- All arguments are an inital lambda (address, data, packed state)
regbank = λa.λd.λsp.
-- There are nested let expressions at top level
let
-- State (Word, Word) to (Word, Word))
s = sp :: (Word, Word)
-- Extract both registers from the state
- r1 = case s of (fst, snd) -> fst
- r2 = case s of (fst, snd) -> snd
+ r1 = case s of (a, b) -> a
+ r2 = case s of (a, b) -> b
-- Calling some other user-defined function.
d' = foo d
-- Conditional connections
ncline(muxout)(out) "posA(out)";
\stopuseMPgraphic
+ \todo{Don't split registers in this image?}
\placeexample[here][ex:NormalComplete]{Simple architecture consisting of an adder and a
subtractor.}
\startcombination[2*1]
{\typebufferlam{NormalComplete}}{Core description in normal form.}
{\boxedgraphic{NormalComplete}}{The architecture described by the normal form.}
\stopcombination
+
+
\subsection{Intended normal form definition}
Now we have some intuition for the normal form, we can describe how we want
Some clauses have an expression listed in parentheses. These are conditions
that need to apply to the clause.
+ \todo{Fix indentation}
\startlambda
\italic{normal} = \italic{lambda}
\italic{lambda} = λvar.\italic{lambda} (representable(var))
no longer true, btw}
When looking at such a program from a hardware perspective, the top level
- lambda's define the input ports. The value produced by the let expression is
- the output port. Most function applications bound by the let expression
- define a component instantiation, where the input and output ports are mapped
- to local signals or arguments. Some of the others use a builtin
- construction (\eg the \lam{case} statement) or call a builtin function
- (\eg \lam{add} or \lam{sub}). For these, a hardcoded \small{VHDL} translation is
+ lambda's define the input ports. The variable referenc in the body of
+ the recursive let expression is the output port. Most function
+ applications bound by the let expression define a component
+ instantiation, where the input and output ports are mapped to local
+ signals or arguments. Some of the others use a builtin construction (\eg
+ the \lam{case} expression) or call a builtin function (\eg \lam{+} or
+ \lam{map}). For these, a hardcoded \small{VHDL} translation is
available.
- \section{Transformation notation}
- To be able to concisely present transformations, we use a specific format to
- them. It is a simple format, similar to one used in logic reasoning.
+ \section[sec:normalization:transformation]{Transformation notation}
+ To be able to concisely present transformations, we use a specific format
+ for them. It is a simple format, similar to one used in logic reasoning.
Such a transformation description looks like the following.
<context additions>
\stoptrans
- This format desribes a transformation that applies to \lam{original
- expresssion} and transforms it into \lam{transformed expression}, assuming
+ This format desribes a transformation that applies to \lam{<original
+ expresssion>} and transforms it into \lam{<transformed expression>}, assuming
that all conditions apply. In this format, there are a number of placeholders
in pointy brackets, most of which should be rather obvious in their meaning.
Nevertheless, we will more precisely specify their meaning below:
against (subexpressions of) the expression to be transformed. We call this a
pattern, because it can contain \emph{placeholders} (variables), which match
any expression or binder. Any such placeholder is said to be \emph{bound} to
- the expression it matches. It is convention to use an uppercase latter (\eg
- \lam{M} or \lam{E} to refer to any expression (including a simple variable
+ the expression it matches. It is convention to use an uppercase letter (\eg
+ \lam{M} or \lam{E}) to refer to any expression (including a simple variable
reference) and lowercase letters (\eg \lam{v} or \lam{b}) to refer to
(references to) binders.
For example, the pattern \lam{a + B} will match the expression
- \lam{v + (2 * w)} (and bind \lam{a} to \lam{v} and \lam{B} to
- \lam{(2 * 2)}), but not \lam{v + (2 * w)}.
+ \lam{v + (2 * w)} (binding \lam{a} to \lam{v} and \lam{B} to
+ \lam{(2 * w)}), but not \lam{(2 * w) + v}.
\stopdesc
\startdesc{<expression conditions>}
These are extra conditions on the expression that is matched. These
conditions can be used to further limit the cases in which the
- transformation applies, in particular to prevent a transformation from
+ transformation applies, commonly to prevent a transformation from
causing a loop with itself or another transformation.
- Only if these if these conditions are \emph{all} true, this transformation
+ Only if these conditions are \emph{all} true, the transformation
applies.
\stopdesc
\startdesc{<context conditions>}
These are a number of extra conditions on the context of the function. In
- particular, these conditions can require some other top level function to be
+ particular, these conditions can require some (other) top level function to be
present, whose value matches the pattern given here. The format of each of
these conditions is: \lam{binder = <pattern>}.
expression>}, while the pattern contains some placeholders that are used in
the \lam{transformed expression}.
- Only if a top level binder exists that matches each binder and pattern, this
- transformation applies.
+ Only if a top level binder exists that matches each binder and pattern,
+ the transformation applies.
\stopdesc
\startdesc{<transformed expression>}
This is the expression template that is the result of the transformation. If, looking
- at the above three items, the transformation applies, the \lam{original
- expression} is completely replaced with the \lam{<transformed expression>}.
+ at the above three items, the transformation applies, the \lam{<original
+ expression>} is completely replaced with the \lam{<transformed expression>}.
We call this a template, because it can contain placeholders, referring to
any placeholder bound by the \lam{<original expression>} or the
\lam{<context conditions>}. The resulting expression will have those
\startdesc{<context additions>}
These are templates for new functions to add to the context. This is a way
- to have a transformation create new top level functiosn.
+ to have a transformation create new top level functions.
Each addition has the form \lam{binder = template}. As above, any
placeholder in the addition is replaced with the value bound to it, and any
λx.E x \lam{E} is not a lambda abstraction.
\stoptrans
+ η-abstraction is a well known transformation from lambda calculus. What
+ this transformation does, is take any expression that has a function type
+ and turn it into a lambda expression (giving an explicit name to the
+ argument). There are some extra conditions that ensure that this
+ transformation does not apply infinitely (which are not necessarily part
+ of the conventional definition of η-abstraction).
+
Consider the following function, which is a fairly obvious way to specify a
- simple ALU (Note \at{example}[ex:AddSubAlu] is the normal form of this
- function):
+ simple ALU (Note that \in{example}[ex:AddSubAlu] shows the normal form of this
+ function). The parentheses around the \lam{+} and \lam{-} operators are
+ commonly used in Haskell to show that the operators are used as normal
+ functions, instead of \emph{infix} operators (\eg, the operators appear
+ before their arguments, instead of in between).
\startlambda
alu :: Bit -> Word -> Word -> Word
Continuing with this expression, we see that the transformation does not
apply again (it is a lambda expression). Next we look at the body of this
- labmda abstraction:
+ lambda abstraction:
\startlambda
(case opcode of
\stoplambda
Obviously, the transformation does not apply here, since it occurs in
- function position. In the same way the transformation does not apply to both
- components of this expression (\lam{case opcode of Low -> (+); High -> (-)}
- and \lam{a}), so we'll skip to the components of the case expression: The
- scrutinee and both alternatives. Since the opcode is not a function, it does
- not apply here, and we'll leave both alternatives as an exercise to the
- reader. The final function, after all these transformations becomes:
+ function position (which makes the second condition false). In the same
+ way the transformation does not apply to both components of this
+ expression (\lam{case opcode of Low -> (+); High -> (-)} and \lam{a}), so
+ we'll skip to the components of the case expression: The scrutinee and
+ both alternatives. Since the opcode is not a function, it does not apply
+ here.
+
+ The first alternative is \lam{(+)}. This expression has a function type
+ (the operator still needs two arguments). It does not occur in function
+ position of an application and it is not a lambda expression, so the
+ transformation applies.
+
+ We look at the \lam{<original expression>} pattern, which is \lam{E}.
+ This means we bind \lam{E} to \lam{(+)}. We then replace the expression
+ with the \lam{<transformed expression>}, replacing all occurences of
+ \lam{E} with \lam{(+)}. In the \lam{<transformed expression>}, the This gives us the replacement expression:
+ \lam{λx.(+) x} (A lambda expression binding \lam{x}, with a body that
+ applies the addition operator to \lam{x}).
+
+ The complete function then becomes:
+ \startlambda
+ (case opcode of Low -> λa1.(+) a1; High -> (-)) a
+ \stoplambda
+
+ Now the transformation no longer applies to the complete first alternative
+ (since it is a lambda expression). It does not apply to the addition
+ operator again, since it is now in function position in an application. It
+ does, however, apply to the application of the addition operator, since
+ that is neither a lambda expression nor does it occur in function
+ position. This means after one more application of the transformation, the
+ function becomes:
+
+ \startlambda
+ (case opcode of Low -> λa1.λb1.(+) a1 b1; High -> (-)) a
+ \stoplambda
+
+ The other alternative is left as an exercise to the reader. The final
+ function, after applying η-abstraction until it does no longer apply is:
\startlambda
alu :: Bit -> Word -> Word -> Word
High -> λa2.λb2 (-) a2 b2) a b
\stoplambda
- In this case, the transformation does not apply anymore, though this might
- not always be the case (e.g., the application of a transformation on a
- subexpression might open up possibilities to apply the transformation
- further up in the expression).
-
\subsection{Transformation application}
In this chapter we define a number of transformations, but how will we apply
these? As stated before, our normal form is reached as soon as no
an efficient implementation.
When applying a single transformation, we try to apply it to every (sub)expression
- in a function, not just the top level function. This allows us to keep the
- transformation descriptions concise and powerful.
+ in a function, not just the top level function body. This allows us to
+ keep the transformation descriptions concise and powerful.
\subsection{Definitions}
In the following sections, we will be using a number of functions and
\todo{Define substitution (notation)}
- \subsubsection{Other concepts}
- A \emph{global variable} is any variable that is bound at the
+ \subsubsection{Concepts}
+ A \emph{global variable} is any variable (binder) that is bound at the
top level of a program, or an external module. A \emph{local variable} is any
other variable (\eg, variables local to a function, which can be bound by
lambda abstractions, let expressions and pattern matches of case
A \emph{hardware representable} (or just \emph{representable}) type or value
is (a value of) a type that we can generate a signal for in hardware. For
- example, a bit, a vector of bits, a 32 bit unsigned word, etc. Types that are
+ example, a bit, a vector of bits, a 32 bit unsigned word, etc. Values that are
not runtime representable notably include (but are not limited to): Types,
dictionaries, functions.
\defref{representable}
A \emph{user-defined} function is a function for which we do have a Cλash
implementation available.
- \subsubsection{Functions}
- Here, we define a number of functions that can be used below to concisely
- specify conditions.
+ \subsubsection{Predicates}
+ Here, we define a number of predicates that can be used below to concisely
+ specify conditions.\refdef{global variable}
- \refdef{global variable}\emph{gvar(expr)} is true when \emph{expr} is a variable that references a
+ \emph{gvar(expr)} is true when \emph{expr} is a variable that references a
global variable. It is false when it references a local variable.
\refdef{local variable}\emph{lvar(expr)} is the complement of \emph{gvar}; it is true when \emph{expr}
\refdef{representable}\emph{representable(expr)} or \emph{representable(var)} is true when
\emph{expr} or \emph{var} is \emph{representable}.
- \subsection{Binder uniqueness}
+ \subsection[sec:normalization:uniq]{Binder uniqueness}
A common problem in transformation systems, is binder uniqueness. When not
considering this problem, it is easy to create transformations that mix up
bindings and cause name collisions. Take for example, the following core
(λa.λb.λc. a * b * c) x c
\stoplambda
- By applying β-reduction (see below) once, we can simplify this expression to:
+ By applying β-reduction (see \in{section}[sec:normalization:beta]) once,
+ we can simplify this expression to:
\startlambda
(λb.λc. x * b * c) c
In our transformation system, maintaining this non-shadowing invariant is
a bit harder to do (mostly due to implementation issues, the prototype doesn't
- use \small{GHC}'s subsitution code). Also, we can observe the following
- points.
+ use \small{GHC}'s subsitution code). Also, the following points can be
+ observed.
\startitemize
\item Deshadowing does not guarantee overall uniqueness. For example, the
\stoplambda
\item In our normal form (and the resulting \small{VHDL}), all binders
- (signals) will end up in the same scope. To allow this, all binders within the
- same function should be unique.
+ (signals) within the same function (entity) will end up in the same
+ scope. To allow this, all binders within the same function should be
+ unique.
\item When we know that all binders in an expression are unique, moving around
or removing a subexpression will never cause any binder conflicts. If we have
\stopitemize
Given the above, our prototype maintains a unique binder invariant. This
- meanst that in any given moment during normalization, all binders \emph{within
+ means that in any given moment during normalization, all binders \emph{within
a single function} must be unique. To achieve this, we apply the following
technique.
\startitemize
\item Before starting normalization, all binders in the function are made
unique. This is done by generating a fresh binder for every binder used. This
- also replaces binders that did not pose any conflict, but it does ensure that
- all binders within the function are generated by the same unique supply. See
+ also replaces binders that did not cause any conflict, but it does ensure that
+ all binders within the function are generated by the same unique supply.
\refdef{fresh binder}
\item Whenever a new binder must be generated, we generate a fresh binder that
is guaranteed to be different from \emph{all binders generated so far}. This
can thus never introduce duplication and will maintain the invariant.
- \item Whenever (part of) an expression is duplicated (for example when
+ \item Whenever (a part of) an expression is duplicated (for example when
inlining), all binders in the expression are replaced with fresh binders
(using the same method as at the start of normalization). These fresh binders
can never introduce duplication, so this will maintain the invariant.
\stopitemize
\section{Transform passes}
- In this section we describe the actual transforms. Here we're using
- the core language in a notation that resembles lambda calculus.
-
- Each of these transforms is meant to be applied to every (sub)expression
- in a program, for as long as it applies. Only when none of the
- transformations can be applied anymore, the program is in normal form (by
- definition). We hope to be able to prove that this form will obey all of the
- constraints defined above, but this has yet to happen (though it seems likely
- that it will).
-
- Each of the transforms will be described informally first, explaining
- the need for and goal of the transform. Then, a formal definition is
- given, using a familiar syntax from the world of logic. Each transform
- is specified as a number of conditions (above the horizontal line) and a
- number of conclusions (below the horizontal line). The details of using
- this notation are still a bit fuzzy, so comments are welcom.
+ In this section we describe the actual transforms.
+
+ Each transformation will be described informally first, explaining
+ the need for and goal of the transformation. Then, we will formally define
+ the transformation using the syntax introduced in
+ \in{section}[sec:normalization:transformation].
\subsection{General cleanup}
These transformations are general cleanup transformations, that aim to
Most of these transformations are standard optimizations in other
compilers as well. However, in our compiler, most of these are not just
- optimizations, but they are required to get our program into normal
- form.
+ optimizations, but they are required to get our program into intended
+ normal form.
- \subsubsection{β-reduction}
+ \subsubsection[sec:normalization:beta]{β-reduction}
β-reduction is a well known transformation from lambda calculus, where it is
- the main reduction step. It reduces applications of labmda abstractions,
+ the main reduction step. It reduces applications of lambda abstractions,
removing both the lambda abstraction and the application.
In our transformation system, this step helps to remove unwanted lambda
\starttrans
(λx.E) M
-----------------
- E[M/x]
+ E[x=>M]
\stoptrans
% And an example
2 * (2 * b)
\stopbuffer
- \transexample{β-reduction}{from}{to}
+ \transexample{beta}{β-reduction}{from}{to}
\subsubsection{Empty let removal}
This transformation is simple: It removes recursive lets that have no bindings
(which usually occurs when unused let binding removal removes the last
binding from it).
+ Note that there is no need to define this transformation for
+ non-recursive lets, since they always contain exactly one binding.
+
\starttrans
letrec in M
--------------
\todo{Example}
\subsubsection{Simple let binding removal}
- This transformation inlines simple let bindings (\eg a = b).
-
- This transformation is not needed to get into normal form, but makes the
- resulting \small{VHDL} a lot shorter.
-
+ This transformation inlines simple let bindings, that bind some
+ binder to some other binder instead of a more complex expression (\ie
+ a = b).
+
+ This transformation is not needed to get an expression into intended
+ normal form (since these bindings are part of the intended normal
+ form), but makes the resulting \small{VHDL} a lot shorter.
+
\starttrans
letrec
a0 = E0
in
M
----------------------------- \lam{b} is a variable reference
- letrec
- a0 = E0 [b/ai]
+ letrec \lam{ai} ≠ \lam{b}
+ a0 = E0 [ai=>b]
\vdots
- ai-1 = Ei-1 [b/ai]
- ai+1 = Ei+1 [b/ai]
+ ai-1 = Ei-1 [ai=>b]
+ ai+1 = Ei+1 [ai=>b]
\vdots
- an = En [b/ai]
+ an = En [ai=>b]
in
- M[b/ai]
+ M[ai=>b]
\stoptrans
\todo{example}
\subsubsection{Unused let binding removal}
- This transformation removes let bindings that are never used. Usually,
- the desugarer introduces some unused let bindings.
+ This transformation removes let bindings that are never used.
+ Occasionally, \GHC's desugarer introduces some unused let bindings.
- This normalization pass should really be unneeded to get into normal form
+ This normalization pass should really be unneeded to get into intended normal form
(since unused bindings are not forbidden by the normal form), but in practice
the desugarer or simplifier emits some unused bindings that cannot be
- normalized (e.g., calls to a \type{PatError} (\todo{Check this name}). Also,
+ normalized (e.g., calls to a \type{PatError}\todo{Check this name}). Also,
this transformation makes the resulting \small{VHDL} a lot shorter.
+ \todo{Don't use old-style numerals in transformations}
\starttrans
letrec
a0 = E0
\vdots
an = En
in
- M \lam{a} does not occur free in \lam{M}
- ---------------------------- \forall j, 0 <= j <= n, j ≠ i (\lam{a} does not occur free in \lam{Ej})
+ M \lam{ai} does not occur free in \lam{M}
+ ---------------------------- \forall j, 0 ≤ j ≤ n, j ≠ i (\lam{ai} does not occur free in \lam{Ej})
letrec
a0 = E0
\vdots
references.
Note that this transformation is completely optional. It is not
- required to get any function into normal form, but it does help making
+ required to get any function into intended normal form, but it does help making
the resulting VHDL output easier to read (since it removes a bunch of
components that are really boring).
GHC.Num.(+) @ Alu.Word $dNum a b
\stopbuffer
- \transexample{Top level binding inlining}{from}{to}
+ \transexample{toplevelinline}{Top level binding inlining}{from}{to}
- Without this transformation, the (+) function would generate an
+ Example \in{ex:trans:toplevelinline} shows a typical application of
+ the addition operator generated by \GHC. The type and dictionary
+ arguments used here are described in
+ \in{section:prototype:polymorphism}.
+
+ Without this transformation, there would be a (+) entity in the
architecture which would just add its inputs. This generates a lot of
overhead in the VHDL, which is particularly annoying when browsing the
generated RTL schematic (especially since + is not allowed in VHDL
\subsection{Program structure}
These transformations are aimed at normalizing the overall structure
into the intended form. This means ensuring there is a lambda abstraction
- at the top for every argument (input port), putting all of the other
- value definitions in let bindings and making the final return value a
- simple variable reference.
+ at the top for every argument (input port or current state), putting all
+ of the other value definitions in let bindings and making the final
+ return value a simple variable reference.
\subsubsection{η-abstraction}
This transformation makes sure that all arguments of a function-typed
False -> λy.id y) x
\stopbuffer
- \transexample{η-abstraction}{from}{to}
+ \transexample{eta}{η-abstraction}{from}{to}
\subsubsection{Application propagation}
This transformation is meant to propagate application expressions downwards
opportunities for other transformations (like β-reduction and
specialization).
+ Since all binders in our expression are unique (see
+ \in{section}[sec:normalization:uniq]), there is no risk that we will
+ introduce unintended shadowing by moving an expression into a lower
+ scope. Also, since only move expression into smaller scopes (down into
+ our expression), there is no risk of moving a variable reference out
+ of the scope in which it is defined.
+
\starttrans
(letrec binds in E) M
------------------------
add val 3
\stopbuffer
- \transexample{Application propagation for a let expression}{from}{to}
+ \transexample{appproplet}{Application propagation for a let expression}{from}{to}
\starttrans
(case x of
False -> neg 1
\stopbuffer
- \transexample{Application propagation for a case expression}{from}{to}
+ \transexample{apppropcase}{Application propagation for a case expression}{from}{to}
\subsubsection{Let recursification}
This transformation makes all non-recursive lets recursive. In the
\subsubsection{Let flattening}
This transformation puts nested lets in the same scope, by lifting the
- binding(s) of the inner let into a new let around the outer let. Eventually,
- this will cause all let bindings to appear in the same scope (they will all be
- in scope for the function return value).
+ binding(s) of the inner let into the outer let. Eventually, this will
+ cause all let bindings to appear in the same scope.
+
+ This transformation only applies to recursive lets, since all
+ non-recursive lets will be made recursive (see
+ \in{section}[sec:normalization:letrecurse]).
+
+ Since we are joining two scopes together, there is no risk of moving a
+ variable reference out of the scope where it is defined.
\starttrans
letrec
+ a0 = E0
\vdots
- x = (letrec bindings in M)
+ ai = (letrec bindings in M)
\vdots
+ an = En
in
N
------------------------------------------
letrec
+ a0 = E0
\vdots
- bindings
- x = M
+ ai = M
\vdots
+ an = En
+ bindings
in
N
\stoptrans
\startbuffer[from]
letrec
- a = letrec
- x = 1
- y = 2
+ a = 1
+ b = letrec
+ x = a
+ y = c
in
x + y
+ c = 2
in
- a
+ b
\stopbuffer
\startbuffer[to]
letrec
- x = 1
- y = 2
- a = x + y
+ a = 1
+ b = x + y
+ c = 2
+ x = a
+ y = c
in
- a
+ b
\stopbuffer
- \transexample{Let flattening}{from}{to}
+ \transexample{letflat}{Let flattening}{from}{to}
\subsubsection{Return value simplification}
This transformation ensures that the return value of a function is always a
Note that the return value is not simplified if its not representable.
Otherwise, this would cause a direct loop with the inlining of
- unrepresentable bindings, of course. If the return value is not
+ unrepresentable bindings. If the return value is not
representable because it has a function type, η-abstraction should
make sure that this transformation will eventually apply. If the value
is not representable for other reasons, the function result itself is
- not representable, meaning this function is not representable anyway!
+ not representable, meaning this function is not translatable anyway.
\starttrans
x = E \lam{E} is representable
x = λv0 ... λvn.let ... in E
~ \lam{E} is representable
E \lam{E} is not a local variable reference
- ---------------------------
+ -----------------------------
letrec x = E in x
\stoptrans
x = letrec x = add 1 2 in x
\stopbuffer
- \transexample{Return value simplification}{from}{to}
+ \transexample{retvalsimpl}{Return value simplification}{from}{to}
+
+ \todo{More examples}
\subsection{Argument simplification}
The transforms in this section deal with simplifying application
arguments into normal form. The goal here is to:
+ \todo{This section should only talk about representable arguments. Non
+ representable arguments are treated by specialization.}
+
\startitemize
\item Make all arguments of user-defined functions (\eg, of which
we have a function body) simple variable references of a runtime
reduced to simple variables (for which signals will be
produced). This is taken care of by the argument extraction
transform.
- \item Non-runtime representable typed arguments.
+ \item Non-runtime representable typed arguments. \todo{Move this
+ bullet to specialization}
These arguments cannot be preserved in the program, since we
cannot represent them as input or output ports in the resulting
inlining.
\stopitemize
- \todo{Check the following itemization.}
-
+ \todo{Move this itemization into a new section about builtin functions}
When looking at the arguments of a builtin function, we can divide them
into categories:
\subsubsection{Argument simplification}
This transform deals with arguments to functions that
are of a runtime representable type. It ensures that they will all become
- references to global variables, or local signals in the resulting \small{VHDL}.
+ references to global variables, or local signals in the resulting
+ \small{VHDL}, which is required due to limitations in the component
+ instantiation code in \VHDL (one can only assign a signal or constant
+ to an input port). By ensuring that all arguments are always simple
+ variable references, we always have a signal available to assign to
+ input ports.
- \todo{It seems we can map an expression to a port, not only a signal.}
- Perhaps this makes this transformation not needed?
\todo{Say something about dataconstructors (without arguments, like True
or False), which are variable references of a runtime representable
type, but do not result in a signal.}
expression to a new variable. The original function is then applied to
this variable.
+ Note that a reference to a \emph{global variable} (like a top level
+ function without arguments, but also an argumentless dataconstructors
+ like \lam{True}) is also simplified. Only local variables generate
+ signals in the resulting architecture.
+
+ \refdef{representable}
\starttrans
M N
- -------------------- \lam{N} is of a representable type
+ -------------------- \lam{N} is representable
letrec x = N in M x \lam{N} is not a local variable reference
\stoptrans
+ \refdef{local variable}
\startbuffer[from]
add (add a 1) 1
letrec x = add a 1 in add x 1
\stopbuffer
- \transexample{Argument extraction}{from}{to}
-
+ \transexample{argextract}{Argument extraction}{from}{to}
+
\subsubsection{Function extraction}
- This transform deals with function-typed arguments to builtin functions.
- Since these arguments cannot be propagated, we choose to extract them
- into a new global function instead.
+ \todo{Move to section about builtin functions}
+ This transform deals with function-typed arguments to builtin
+ functions. Since builtin functions cannot be specialized to remove
+ the arguments, we choose to extract these arguments into a new global
+ function instead. This greatly simplifies the translation rules needed
+ for builtin functions. \todo{Should we talk about these? Reference
+ Christiaan?}
Any free variables occuring in the extracted arguments will become
parameters to the new global function. The original argument is replaced
even more complicated expressions).
\starttrans
- M N \lam{M} is a (partial aplication of a) builtin function.
- --------------------- \lam{f0 ... fn} = free local variables of \lam{N}
+ M N \lam{M} is (a partial aplication of) a builtin function.
+ --------------------- \lam{f0 ... fn} are all free local variables of \lam{N}
M (x f0 ... fn) \lam{N :: a -> b}
~ \lam{N} is not a (partial application of) a top level function
x = λf0 ... λfn.N
\stoptrans
+ \todo{Split this example}
\startbuffer[from]
map (λa . add a b) xs
x1 = λb.add b
\stopbuffer
- \transexample{Function extraction}{from}{to}
+ \transexample{funextract}{Function extraction}{from}{to}
Note that \lam{x0} and {x1} will still need normalization after this.
\subsubsection{Argument propagation}
- \fxnote{This section should be generalized and describe
- specialization, so other transformations can refer to this (since
- specialization is really used in multiple categories).}
+ \todo{Rename this section to specialization and move it into a
+ separate section}
This transform deals with arguments to user-defined functions that are
not representable at runtime. This means these arguments cannot be
Special care must be taken when the to-be-propagated expression has any
free variables. If this is the case, the original argument should not be
- removed alltogether, but replaced by all the free variables of the
+ removed completely, but replaced by all the free variables of the
expression. In this way, the original expression can still be evaluated
inside the new function. Also, this brings us closer to our goal: All
these free variables will be simple variable references.
~
x Y0 ... Yi ... Yn \lam{Yi} is not of a runtime representable type
--------------------------------------------- \lam{Yi} is not a local variable reference
- x' y0 ... yi-1 f0 ... fm Yi+1 ... Yn \lam{f0 ... fm} = free local vars of \lam{Yi}
+ x' y0 ... yi-1 f0 ... fm Yi+1 ... Yn \lam{f0 ... fm} are all free local vars of \lam{Yi}
~
- x' = λy0 ... yi-1 f0 ... fm yi+1 ... yn .
+ x' = λy0 ... λyi-1. λf0 ... λfm. λyi+1 ... λyn .
E y0 ... yi-1 Yi yi+1 ... yn
-
\stoptrans
+ \todo{Describe what the formal specification means}
+ \todo{Note that we don't change the sepcialised function body, only
+ wrap it}
+
\todo{Example}
- \subsection{Case simplification}
+
+ \subsection{Case normalisation}
\subsubsection{Scrutinee simplification}
This transform ensures that the scrutinee of a case expression is always
a simple variable reference.
False -> b
\stopbuffer
- \transexample{Let flattening}{from}{to}
+ \transexample{letflat}{Let flattening}{from}{to}
\subsubsection{Case simplification}
makes a choice between expressions based on the constructor of another
expression, \eg \lam{case x of Low -> a; High -> b}.
\stopitemize
-
+
+ \defref{wild binder}
\starttrans
case E of
C0 v0,0 ... v0,m -> E0
\vdots
Cn vn,0 ... vn,m -> En
- --------------------------------------------------- \forall i \forall j, 0 <= i <= n, 0 <= i < m (\lam{wi,j} is a wild (unused) binder)
+ --------------------------------------------------- \forall i \forall j, 0 ≤ i ≤ n, 0 ≤ i < m (\lam{wi,j} is a wild (unused) binder)
letrec
- v0,0 = case x of C0 v0,0 .. v0,m -> v0,0
+ v0,0 = case E of C0 v0,0 .. v0,m -> v0,0
\vdots
- v0,m = case x of C0 v0,0 .. v0,m -> v0,m
+ v0,m = case E of C0 v0,0 .. v0,m -> v0,m
+ \vdots
+ vn,m = case E of Cn vn,0 .. vn,m -> vn,m
x0 = E0
- \dots
- vn,m = case x of Cn vn,0 .. vn,m -> vn,m
+ \vdots
xn = En
in
case E of
\vdots
Cn wn,0 ... wn,m -> xn
\stoptrans
+ \todo{Check the subscripts of this transformation}
+
+ Note that this transformation applies to case statements with any
+ scrutinee. If the scrutinee is a complex expression, this might result
+ in duplicate hardware. An extra condition to only apply this
+ transformation when the scrutinee is already simple (effectively
+ causing this transformation to be only applied after the scrutinee
+ simplification transformation) might be in order.
\fxnote{This transformation specified like this is complicated and misses
conditions to prevent looping with itself. Perhaps it should be split here for
False -> x1
\stopbuffer
- \transexample{Selector case simplification}{from}{to}
+ \transexample{selcasesimpl}{Selector case simplification}{from}{to}
\startbuffer[from]
case a of
(,) w0 w1 -> x0
\stopbuffer
- \transexample{Extractor case simplification}{from}{to}
+ \transexample{excasesimpl}{Extractor case simplification}{from}{to}
- \subsubsection{Case removal}
+ \refdef{selector case}
+ In \in{example}[ex:trans:excasesimpl] the case expression is expanded
+ into multiple case expressions, including a pretty useless expression
+ (that is neither a selector or extractor case). This case can be
+ removed by the Case removal transformation in
+ \in{section}[sec:transformation:caseremoval].
+
+ \subsubsection[sec:transformation:caseremoval]{Case removal}
This transform removes any case statements with a single alternative and
only wild binders.
\starttrans
case x of
C v0 ... vm -> E
- ---------------------- \lam{\forall i, 0 <= i <= m} (\lam{vi} does not occur free in E)
+ ---------------------- \lam{\forall i, 0 ≤ i ≤ m} (\lam{vi} does not occur free in E)
E
\stoptrans
x0
\stopbuffer
- \transexample{Case removal}{from}{to}
+ \transexample{caserem}{Case removal}{from}{to}
+ \todo{Move these two sections somewhere? Perhaps not?}
\subsection{Removing polymorphism}
Reference type-specialization (== argument propagation)
Reference higher-order-specialization (== argument propagation)
\subsubsection{Non-representable binding inlining}
- This transform inlines let bindings that have a non-representable type. Since
- we can never generate a signal assignment for these bindings (we cannot
- declare a signal assignment with a non-representable type, for obvious
- reasons), we have no choice but to inline the binding to remove it.
+ \todo{Move this section into a new section (together with
+ specialization?)}
+ This transform inlines let bindings that are bound to a
+ non-representable value. Since we can never generate a signal
+ assignment for these bindings (we cannot declare a signal assignment
+ with a non-representable type, for obvious reasons), we have no choice
+ but to inline the binding to remove it.
If the binding is non-representable because it is a lambda abstraction, it is
likely that it will inlined into an application and β-reduction will remove
literal \hs{SizedInt} in Haskell, like \hs{1 :: SizedInt D8}, this results in
the following core: \lam{fromInteger (smallInteger 10)}, where for example
\lam{10 :: GHC.Prim.Int\#} and \lam{smallInteger 10 :: Integer} have
- non-representable types. \todo{This/these paragraph(s) should probably become a
- separate discussion somewhere else}
+ non-representable types. \todo{Expand on this. This/these paragraph(s)
+ should probably become a separate discussion somewhere else}
+ \todo{Can this duplicate work?}
\starttrans
letrec
M
-------------------------- \lam{Ei} has a non-representable type.
letrec
- a0 = E0 [Ei/ai]
- \vdots
- ai-1 = Ei-1 [Ei/ai]
- ai+1 = Ei+1 [Ei/ai]
+ a0 = E0 [ai=>Ei] \vdots
+ ai-1 = Ei-1 [ai=>Ei]
+ ai+1 = Ei+1 [ai=>Ei]
\vdots
- an = En [Ei/ai]
+ an = En [ai=>Ei]
in
- M[Ei/ai]
+ M[ai=>Ei]
\stoptrans
\startbuffer[from]
(λb -> add b 1) (add 1 x)
\stopbuffer
- \transexample{None representable binding inlining}{from}{to}
+ \transexample{nonrepinline}{Nonrepresentable binding inlining}{from}{to}
\section{Provable properties}
\startitemize[KR]
\item[q:termination] Does our system \emph{terminate}? Since our system will
keep running as long as transformations apply, there is an obvious risk that
- it will keep running indefinitely. One transformation produces a result that
- is transformed back to the original by another transformation, for example.
+ it will keep running indefinitely. This typically happens when one
+ transformation produces a result that is transformed back to the original
+ by another transformation, or when one or more transformations keep
+ expanding some expression.
\item[q:soundness] Is our system \emph{sound}? Since our transformations
continuously modify the expression, there is an obvious risk that the final
normal form will not be equivalent to the original program: Its meaning could
drawObj(a, b, c, d);
\stopuseMPgraphic
- \placeexample[right][ex:TransformGraph]{Partial graph of a labmda calculus
+ \placeexample[right][ex:TransformGraph]{Partial graph of a lambda calculus
system with β and η reduction (solid lines) and expansion (dotted lines).}
\boxedgraphic{TransformGraph}
simple lambda calculus that contains just the expressions \lam{(λx.λy. (+) x
y) 1}, \lam{λy. (+) 1 y}, \lam{(λx.(+) x) 1} and \lam{(+) 1}. The
transformation system consists of β-reduction and η-reduction (solid edges) or
- β-reduction and η-reduction (dotted edges).
+ β-expansion and η-expansion (dotted edges).
\todo{Define β-reduction and η-reduction?}
From such a graph, we can derive some properties easily:
\startitemize[KR]
\item A system will \emph{terminate} if there is no path of infinite length
- in the graph (this includes cycles).
+ in the graph (this includes cycles, but can also happen without cycles).
\item Soundness is not easily represented in the graph.
\item A system is \emph{complete} if all of the nodes in the normal set have
the intended normal form. The inverse (that all of the nodes outside of
the normal set are \emph{not} in the intended normal form) is not
strictly required.
- \item A system is deterministic if all paths from a node, which end in a node
- in the normal set, end at the same node.
+ \item A system is deterministic if all paths starting at a particular
+ node, which end in a node in the normal set, end at the same node.
\stopitemize
When looking at the \in{example}[ex:TransformGraph], we see that the system
terminates for both the reduction and expansion systems (but note that, for
- expansion, this is only true because we've limited the possible expressions!
- In comlete lambda calculus, there would be a path from \lam{(λx.λy. (+) x y)
- 1} to \lam{(λx.λy.(λz.(+) z) x y) 1} to \lam{(λx.λy.(λz.(λq.(+) q) z) x y) 1}
- etc.)
+ expansion, this is only true because we've limited the possible
+ expressions. In comlete lambda calculus, there would be a path from
+ \lam{(λx.λy. (+) x y) 1} to \lam{(λx.λy.(λz.(+) z) x y) 1} to
+ \lam{(λx.λy.(λz.(λq.(+) q) z) x y) 1} etc.)
- If we would consider the system with both expansion and reduction, there would
- no longer be termination, since there would be cycles all over the place.
+ If we would consider the system with both expansion and reduction, there
+ would no longer be termination either, since there would be cycles all
+ over the place.
The reduction and expansion systems have a normal set of containing just
\lam{(+) 1} or \lam{(λx.λy. (+) x y) 1} respectively. Since all paths in
either system end up in these normal forms, both systems are \emph{complete}.
- Also, since there is only one normal form, it must obviously be
+ Also, since there is only one node in the normal set, it must obviously be
\emph{deterministic} as well.
+ \todo{Add content to these sections}
\subsection{Termination}
Approach: Counting.
projects / matthijs / master-project / report.git / commitdiff