1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
|
\section{Turning CompCert into an HLS tool}
%% Should maybe go in the introduction instead.
\begin{figure}
\centering
\begin{tikzpicture}
[language/.style={fill=white,rounded corners=2pt}]
\fill[compcert,rounded corners=3pt] (-1,-1) rectangle (9,1.5);
\fill[formalhls,rounded corners=3pt] (-1,-1.5) rectangle (9,-2.5);
\node[language] at (0,0) (clight) {Clight};
\node[language] at (2,0) (cminor) {C\#minor};
\node[language] at (4,0) (rtl) {RTL};
\node[language] at (6,0) (ltl) {LTL};
\node[language] at (8,0) (ppc) {PPC};
\node[language] at (4,-2) (dfgstmd) {HTL};
\node[language] at (7,-2) (verilog) {Verilog};
\node at (0,1) {CompCert};
\node at (0,-2) {CoqUp};
\draw[->] (clight) -- (cminor);
\draw[->,dashed] (cminor) -- (rtl);
\draw[->] (rtl) -- (ltl);
\draw[->,dashed] (ltl) -- (ppc);
\draw[->] (rtl) -- (dfgstmd);
\draw[->] (dfgstmd) -- (verilog);
\end{tikzpicture}
\caption{Verilog backend branching off at the RTL stage.}\label{fig:rtlbranch}
\end{figure}
This section covers the main architecture of the HLS tool, and how the backend was added to CompCert. CompCert is made up of 11 intermediate languages in between the Clight input and the assembly output. These intermediate languages each serve a different purpose and contain various different optimisations. When designing a new backend for CompCert, it is therefore crucial to know where to branch off and start the hardware generation. Many of the optimisations that the CompCert backend performs are not necessary when generating custom hardware and not relying on a CPU anymore, such as register allocation or even scheduling. It is therefore important to find the right intermediate language so that the HLS tool still benefits from many of the generic optimisations that CompCert performs, but does not receive the code transformations that are specific to CPU architectures.
Existing HLS compilers usually use LLVM IR as an intermediate representation when performing HLS specific optimisations, as each instruction can be mapped quite well to hardware which performs the same behaviour. CompCert's RTL is the intermediate language that resembles LLVM IR the most, as it also has an infinite number of pseudo-registers and each instruction maps well to hardware. In addition to that, many optimisations that are also useful for HLS are performed in RTL, which means that if it is supported as the input language, the HLS algorithm benefits from the same optimisations. It is therefore a good candidate to be chosen as the input language to the HLS backend. The complete flow that CoqUp takes is show in figure~\ref{fig:rtlbranch}.
%%TODO: Maybe add why LTL and the other smaller languages are not that well suited
\begin{figure}
\centering
\begin{minipage}{0.5\linewidth}
\begin{minted}{c}
int main() {
int x[5] = {1, 2, 3, 4, 5};
int sum = 0;
for (int i = 0; i < 5; i++)
sum += x[i];
return sum;
}
\end{minted}
\end{minipage}
\caption{Accumulator example C code.}\label{fig:accumulator_c}
\end{figure}
To describe the translation, we start with an example of how to translate a simple accumulator example, which is shown in figure~\ref{fig:accumulator_c}. Using this example, the different stages in the translation can be explained, together with how they were proven. The example includes constructs such as arrays, for loops and addition, however, CoqUp also supports all other operators like multiplication and division, as well as conditional statements. Function calls are also supported by inlining all of the functions, meaning recursive function calls are not supported.
\subsection{CompCert RTL}
All CompCert intermediate language follow the similar structure below:
\begin{align*}
\mathit{program} \quad ::= \{ &\mathbf{variables} : (\mathit{id} * \mathit{data}) \text{ list}, \\
&\mathbf{functions} : (\mathit{id} * \mathit{function\_def}) \text{ list},\\
&\mathbf{main} : \mathit{id} \}
\end{align*}
\noindent where function definitions can either be internal or external. External functions are functions that are not defined in the current translation unit, and are therefore not part of the current translation. The difference in between the CompCert intermediate languages is therefore how the internal function is defined, as that defines the structure of the language itself.
\begin{figure}
\centering
\begin{minipage}{0.5\linewidth}
\begin{minted}{c}
main() {
19: x10 = 1
18: int32[stack(0)] = x10
17: x9 = 2
16: int32[stack(4)] = x9
15: x8 = 3
14: int32[stack(8)] = x8
13: x7 = 4
12: int32[stack(12)] = x7
11: x6 = 5
10: int32[stack(16)] = x6
9: x2 = 0
8: x1 = 0
7: x5 = stack(0) (int)
6: x4 = int32[x5 + x1 * 4 + 0]
5: x2 = x2 + x4 + 0 (int)
4: x1 = x1 + 1 (int)
3: if (x1 <s 5) goto 7 else goto 2
2: x3 = x2
1: return x3
}
\end{minted}
\end{minipage}
\caption{Accumulator example RTL code.}\label{fig:accumulator_rtl}
\end{figure}
%% Describe RTL
The accumulator example in RTL function definitions are a sequence of instructions encoded in a control-flow graph, with each instruction linking to the next instruction that should be executed.
%%TODO: Finish this section and describe the syntax and semantics of RTL.
\subsection{HTL}
RTL is first translated to an intermediate language called hardware transfer language (HTL), which is a finite state machine with datapath (FSMD) representation of the RTL code. HTL, like all CompCert intermediate languages, has the same program structure as RTL, but internal functions now contain logic to control the order of execution, and a datapath that transforms the data in the registers. This is represented by having two maps that link states to the control logic and to the current position in the datapath, which are both expressed using Verilog statements. The syntax for HTL functions are the following:
\begin{align*}
g \quad &::= \quad n \mapsto s\\
d_{r} \quad &::= \quad r \mapsto (io? * n)\\
d_{a} \quad &::= \quad r \mapsto (io? * n * n)\\
F \quad &::= \quad \big\{\ \texttt{params} : \vec{r}\\
&\texttt{datapath} : g\\
&\texttt{controllogic} : g\\
&\texttt{entrypoint} : n\\
&\texttt{st, stk, finish, return, start, reset, clk} : r\\
&\texttt{scldecls} : d_{r}\\
&\texttt{arrdecls} : d_{a}\ \big\}
\end{align*}
\subsection{HLS Algorithm}
%%% Local Variables:
%%% mode: latex
%%% TeX-master: "main"
%%% End:
|
