aboutsummaryrefslogtreecommitdiffstats
path: root/manual/manual.tex
blob: 1914df9893a7f6cd6adade049cc99e5e738f7ac9 (plain)
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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
\documentclass[oneside,a4paper]{book}

\usepackage[T1]{fontenc}   % required for luximono!
\usepackage{lmodern}
\usepackage[scaled=0.8]{luximono}  % typewriter font with bold face

% To install the luximono font files:
% getnonfreefonts-sys --all        or
% getnonfreefonts-sys luximono
%
% when there are trouble you might need to:
% - Create /etc/texmf/updmap.d/99local-luximono.cfg
%   containing the single line: Map ul9.map
% - Run update-updmap followed by mktexlsr and updmap-sys
%
% This commands must be executed as root with a root environment
% (i.e. run "sudo su" and then execute the commands in the root
% shell, don't just prefix the commands with "sudo").

% formats the text according the set language
\usepackage[english]{babel}
\usepackage[table,usenames]{xcolor}
% generates indices with the "\index" command
\usepackage{makeidx}
% enables import of graphics. We use pdflatex here so do the pdf optimisation.
%\usepackage[dvips]{graphicx}
\usepackage[pdftex]{graphicx}
\usepackage{pdfpages}
% includes floating objects like tables and figures.
\usepackage{float}
% for generating subfigures with ohne indented captions
\usepackage[hang]{subfigure}
% redefines and smartens captions of figures and tables (indentation, smaller and boldface)
\usepackage[hang,small,bf,center]{caption}
% enables tabstops and the numeration of lines
\usepackage{moreverb}
% enables user defined header and footer lines (former "fancyheadings")
\usepackage{fancyhdr}
% Some smart mathematical stuff
\usepackage{amsmath}
% Package for rotating several objects
\usepackage{rotating}
\usepackage{natbib}
\usepackage{epsf}
\usepackage{dsfont}
\usepackage[algochapter, boxruled, vlined]{algorithm2e}
%Activating and setting of character protruding - if you like
%\usepackage[activate,DVIoutput]{pdfcprot}
% If you really need special chars...
\usepackage[latin1]{inputenc}
% Hyperlinks
\usepackage[colorlinks,hyperindex,plainpages=false,%
pdftitle={Yosys Manual},%
pdfauthor={Claire Xenia Wolf},%
%pdfkeywords={keyword},%
pdfpagelabels,%
pagebackref,%
bookmarksopen=false%
]{hyperref}
% For the two different reference lists ...
\usepackage{multibib}
\usepackage{multirow}
\usepackage{booktabs}
\usepackage{pdfpages}

\usepackage{listings}
\usepackage{pifont}
\usepackage{skull}
% \usepackage{draftwatermark}

\usepackage{tikz}
\usetikzlibrary{calc}
\usetikzlibrary{arrows}
\usetikzlibrary{scopes}
\usetikzlibrary{through}
\usetikzlibrary{shapes.geometric}

\usepackage{calc}
\usepackage[nounderscore]{syntax}

\lstset{basicstyle=\ttfamily}

\def\B#1{{\tt\textbackslash{}#1}}
\def\C#1{\lstinline[language=C++]{#1}}
\def\V#1{\lstinline[language=Verilog]{#1}}

\newsavebox{\fixmebox}
\newenvironment{fixme}%
{\newcommand\colboxcolor{FFBBBB}%
\begin{lrbox}{\fixmebox}%
\begin{minipage}{\dimexpr\columnwidth-2\fboxsep\relax}}
{\end{minipage}\end{lrbox}\textbf{FIXME: }\\%
\colorbox[HTML]{\colboxcolor}{\usebox{\fixmebox}}}

\newcites{weblink}{Internet References}

\setcounter{secnumdepth}{3}
\makeindex

\setlength{\oddsidemargin}{4mm}
\setlength{\evensidemargin}{-6mm}
\setlength{\textwidth}{162mm}
\setlength{\textheight}{230mm}
\setlength{\topmargin}{-5mm}

\setlength{\parskip}{1.5ex plus 1ex minus 0.5ex}
\setlength{\parindent}{0pt}

\lstdefinelanguage{liberty}{
	morecomment=[s]{/*}{*/},
	morekeywords={library,cell,area,pin,direction,function,clocked_on,next_state,clock,ff},
	morestring=[b]",
}

\lstdefinelanguage{rtlil}{
	morecomment=[l]{\#},
	morekeywords={module,attribute,parameter,wire,memory,auto,width,offset,size,input,output,inout,cell,connect,switch,case,assign,sync,low,high,posedge,negedge,edge,always,update,process,end},
	morestring=[b]",
}



\begin{document}

\fancypagestyle{mypagestyle}{%
\fancyhf{}%
\fancyhead[C]{\leftmark}%
\fancyfoot[C]{\thepage}%
\renewcommand{\headrulewidth}{0pt}%
\renewcommand{\footrulewidth}{0pt}}
\pagestyle{mypagestyle}

\thispagestyle{empty}
\null\vfil

\begin{center}
\bf\Huge Yosys Manual

\bigskip
\large Claire Xenia Wolf
\end{center}

\vfil\null
\eject

\chapter*{Abstract}
Most of today's digital design is done in HDL code (mostly Verilog or VHDL) and
with the help of HDL synthesis tools.

In special cases such as synthesis for coarse-grain cell libraries or when
testing new synthesis algorithms it might be necessary to write a custom HDL
synthesis tool or add new features to an existing one. In these cases the
availability of a Free and Open Source (FOSS) synthesis tool that can be used
as basis for custom tools would be helpful.

In the absence of such a tool, the Yosys Open SYnthesis Suite (Yosys) was
developed. This document covers the design and implementation of this tool.
At the moment the main focus of Yosys lies on the high-level aspects of
digital synthesis. The pre-existing FOSS logic-synthesis tool ABC is used
by Yosys to perform advanced gate-level optimizations.

An evaluation of Yosys based on real-world designs is included. It is shown
that Yosys can be used as-is to synthesize such designs. The results produced
by Yosys in this tests where successfully verified using formal verification
and are comparable in quality to the results produced by a commercial
synthesis tool.

\bigskip

This document was originally published as bachelor thesis at the Vienna
University of Technology \cite{BACC}.

\chapter*{Abbreviations}
\begin{tabular}{ll}
AIG         & And-Inverter-Graph \\
ASIC        & Application-Specific Integrated Circuit \\
AST         & Abstract Syntax Tree \\
BDD         & Binary Decision Diagram \\
BLIF        & Berkeley Logic Interchange Format \\
EDA         & Electronic Design Automation \\
EDIF        & Electronic Design Interchange Format \\
ER Diagram  & Entity-Relationship Diagram \\
FOSS        & Free and Open-Source Software \\
FPGA        & Field-Programmable Gate Array \\
FSM         & Finite-state machine \\
HDL         & Hardware Description Language \\
LPM         & Library of Parameterized Modules \\
RTLIL       & RTL Intermediate Language \\
RTL         & Register Transfer Level \\
SAT         & Satisfiability Problem \\
% SSA       & Static Single Assignment Form \\
VHDL        & VHSIC Hardware Description Language \\
VHSIC       & Very-High-Speed Integrated Circuit \\
YOSYS       & Yosys Open SYnthesis Suite \\
\end{tabular}

\tableofcontents

\include{CHAPTER_Intro}
\include{CHAPTER_Basics}
\include{CHAPTER_Approach}
\include{CHAPTER_Overview}
\include{CHAPTER_CellLib}
\include{CHAPTER_Prog}

\include{CHAPTER_Verilog}
\include{CHAPTER_Optimize}
\include{CHAPTER_Techmap}
% \include{CHAPTER_Eval}

\appendix

\include{CHAPTER_Auxlibs}
\include{CHAPTER_Auxprogs}

\chapter{Command Reference Manual}
\label{commandref}
\input{command-reference-manual}

\include{CHAPTER_TextRtlil}
\include{CHAPTER_Appnotes}
% \include{CHAPTER_StateOfTheArt}

\bibliography{literature}
\bibliographystyle{alphadin}

\bibliographyweblink{weblinks}
\bibliographystyleweblink{abbrv}

\end{document}
init(&mp->queue); mp->owner = NULL; #if CH_CFG_USE_MUTEXES_RECURSIVE == TRUE mp->cnt = (cnt_t)0; #endif } /** * @brief Locks the specified mutex. * @post The mutex is locked and inserted in the per-thread stack of owned * mutexes. * * @param[in] mp pointer to the @p mutex_t structure * * @api */ void chMtxLock(mutex_t *mp) { chSysLock(); chMtxLockS(mp); chSysUnlock(); } /** * @brief Locks the specified mutex. * @post The mutex is locked and inserted in the per-thread stack of owned * mutexes. * * @param[in] mp pointer to the @p mutex_t structure * * @sclass */ void chMtxLockS(mutex_t *mp) { thread_t *ctp = currp; chDbgCheckClassS(); chDbgCheck(mp != NULL); /* Is the mutex already locked? */ if (mp->owner != NULL) { #if CH_CFG_USE_MUTEXES_RECURSIVE == TRUE chDbgAssert(mp->cnt >= (cnt_t)1, "counter is not positive"); /* If the mutex is already owned by this thread, the counter is increased and there is no need of more actions.*/ if (mp->owner == ctp) { mp->cnt++; } else { #endif /* Priority inheritance protocol; explores the thread-mutex dependencies boosting the priority of all the affected threads to equal the priority of the running thread requesting the mutex.*/ thread_t *tp = mp->owner; /* Does the running thread have higher priority than the mutex owning thread? */ while (tp->prio < ctp->prio) { /* Make priority of thread tp match the running thread's priority.*/ tp->prio = ctp->prio; /* The following states need priority queues reordering.*/ switch (tp->state) { case CH_STATE_WTMTX: /* Re-enqueues the mutex owner with its new priority.*/ queue_prio_insert(queue_dequeue(tp), &tp->u.wtmtxp->queue); tp = tp->u.wtmtxp->owner; /*lint -e{9042} [16.1] Continues the while.*/ continue; #if (CH_CFG_USE_CONDVARS == TRUE) || \ ((CH_CFG_USE_SEMAPHORES == TRUE) && \ (CH_CFG_USE_SEMAPHORES_PRIORITY == TRUE)) || \ ((CH_CFG_USE_MESSAGES == TRUE) && \ (CH_CFG_USE_MESSAGES_PRIORITY == TRUE)) #if CH_CFG_USE_CONDVARS == TRUE case CH_STATE_WTCOND: #endif #if (CH_CFG_USE_SEMAPHORES == TRUE) && \ (CH_CFG_USE_SEMAPHORES_PRIORITY == TRUE) case CH_STATE_WTSEM: #endif #if (CH_CFG_USE_MESSAGES == TRUE) && (CH_CFG_USE_MESSAGES_PRIORITY == TRUE) case CH_STATE_SNDMSGQ: #endif /* Re-enqueues tp with its new priority on the queue.*/ queue_prio_insert(queue_dequeue(tp), &tp->u.wtmtxp->queue); break; #endif case CH_STATE_READY: #if CH_DBG_ENABLE_ASSERTS == TRUE /* Prevents an assertion in chSchReadyI().*/ tp->state = CH_STATE_CURRENT; #endif /* Re-enqueues tp with its new priority on the ready list.*/ (void) chSchReadyI(queue_dequeue(tp)); break; default: /* Nothing to do for other states.*/ break; } break; } /* Sleep on the mutex.*/ queue_prio_insert(ctp, &mp->queue); ctp->u.wtmtxp = mp; chSchGoSleepS(CH_STATE_WTMTX); /* It is assumed that the thread performing the unlock operation assigns the mutex to this thread.*/ chDbgAssert(mp->owner == ctp, "not owner"); chDbgAssert(ctp->mtxlist == mp, "not owned"); #if CH_CFG_USE_MUTEXES_RECURSIVE == TRUE chDbgAssert(mp->cnt == (cnt_t)1, "counter is not one"); } #endif } else { #if CH_CFG_USE_MUTEXES_RECURSIVE == TRUE chDbgAssert(mp->cnt == (cnt_t)0, "counter is not zero"); mp->cnt++; #endif /* It was not owned, inserted in the owned mutexes list.*/ mp->owner = ctp; mp->next = ctp->mtxlist; ctp->mtxlist = mp; } } /** * @brief Tries to lock a mutex. * @details This function attempts to lock a mutex, if the mutex is already * locked by another thread then the function exits without waiting. * @post The mutex is locked and inserted in the per-thread stack of owned * mutexes. * @note This function does not have any overhead related to the * priority inheritance mechanism because it does not try to * enter a sleep state. * * @param[in] mp pointer to the @p mutex_t structure * @return The operation status. * @retval true if the mutex has been successfully acquired * @retval false if the lock attempt failed. * * @api */ bool chMtxTryLock(mutex_t *mp) { bool b; chSysLock(); b = chMtxTryLockS(mp); chSysUnlock(); return b; } /** * @brief Tries to lock a mutex. * @details This function attempts to lock a mutex, if the mutex is already * taken by another thread then the function exits without waiting. * @post The mutex is locked and inserted in the per-thread stack of owned * mutexes. * @note This function does not have any overhead related to the * priority inheritance mechanism because it does not try to * enter a sleep state. * * @param[in] mp pointer to the @p mutex_t structure * @return The operation status. * @retval true if the mutex has been successfully acquired * @retval false if the lock attempt failed. * * @sclass */ bool chMtxTryLockS(mutex_t *mp) { chDbgCheckClassS(); chDbgCheck(mp != NULL); if (mp->owner != NULL) { #if CH_CFG_USE_MUTEXES_RECURSIVE == TRUE chDbgAssert(mp->cnt >= (cnt_t)1, "counter is not positive"); if (mp->owner == currp) { mp->cnt++; return true; } #endif return false; } #if CH_CFG_USE_MUTEXES_RECURSIVE == TRUE chDbgAssert(mp->cnt == (cnt_t)0, "counter is not zero"); mp->cnt++; #endif mp->owner = currp; mp->next = currp->mtxlist; currp->mtxlist = mp; return true; } /** * @brief Unlocks the specified mutex. * @note Mutexes must be unlocked in reverse lock order. Violating this * rules will result in a panic if assertions are enabled. * @pre The invoking thread <b>must</b> have at least one owned mutex. * @post The mutex is unlocked and removed from the per-thread stack of * owned mutexes. * * @param[in] mp pointer to the @p mutex_t structure * * @api */ void chMtxUnlock(mutex_t *mp) { thread_t *ctp = currp; mutex_t *lmp; chDbgCheck(mp != NULL); chSysLock(); chDbgAssert(ctp->mtxlist != NULL, "owned mutexes list empty"); chDbgAssert(ctp->mtxlist->owner == ctp, "ownership failure"); #if CH_CFG_USE_MUTEXES_RECURSIVE == TRUE chDbgAssert(mp->cnt >= (cnt_t)1, "counter is not positive"); if (--mp->cnt == (cnt_t)0) { #endif chDbgAssert(ctp->mtxlist == mp, "not next in list"); /* Removes the top mutex from the thread's owned mutexes list and marks it as not owned. Note, it is assumed to be the same mutex passed as parameter of this function.*/ ctp->mtxlist = mp->next; /* If a thread is waiting on the mutex then the fun part begins.*/ if (chMtxQueueNotEmptyS(mp)) { thread_t *tp; /* Recalculates the optimal thread priority by scanning the owned mutexes list.*/ tprio_t newprio = ctp->realprio; lmp = ctp->mtxlist; while (lmp != NULL) { /* If the highest priority thread waiting in the mutexes list has a greater priority than the current thread base priority then the final priority will have at least that priority.*/ if (chMtxQueueNotEmptyS(lmp) && (lmp->queue.next->prio > newprio)) { newprio = lmp->queue.next->prio; } lmp = lmp->next; } /* Assigns to the current thread the highest priority among all the waiting threads.*/ ctp->prio = newprio; /* Awakens the highest priority thread waiting for the unlocked mutex and assigns the mutex to it.*/ #if CH_CFG_USE_MUTEXES_RECURSIVE == TRUE mp->cnt = (cnt_t)1; #endif tp = queue_fifo_remove(&mp->queue); mp->owner = tp; mp->next = tp->mtxlist; tp->mtxlist = mp; /* Note, not using chSchWakeupS() becuase that function expects the current thread to have the higher or equal priority than the ones in the ready list. This is not necessarily true here because we just changed priority.*/ (void) chSchReadyI(tp); chSchRescheduleS(); } else { mp->owner = NULL; } #if CH_CFG_USE_MUTEXES_RECURSIVE == TRUE } #endif chSysUnlock(); } /** * @brief Unlocks the specified mutex. * @note Mutexes must be unlocked in reverse lock order. Violating this * rules will result in a panic if assertions are enabled. * @pre The invoking thread <b>must</b> have at least one owned mutex. * @post The mutex is unlocked and removed from the per-thread stack of * owned mutexes. * @post This function does not reschedule so a call to a rescheduling * function must be performed before unlocking the kernel. * * @param[in] mp pointer to the @p mutex_t structure * * @sclass */ void chMtxUnlockS(mutex_t *mp) { thread_t *ctp = currp; mutex_t *lmp; chDbgCheckClassS(); chDbgCheck(mp != NULL); chDbgAssert(ctp->mtxlist != NULL, "owned mutexes list empty"); chDbgAssert(ctp->mtxlist->owner == ctp, "ownership failure"); #if CH_CFG_USE_MUTEXES_RECURSIVE == TRUE chDbgAssert(mp->cnt >= (cnt_t)1, "counter is not positive"); if (--mp->cnt == (cnt_t)0) { #endif chDbgAssert(ctp->mtxlist == mp, "not next in list"); /* Removes the top mutex from the thread's owned mutexes list and marks it as not owned. Note, it is assumed to be the same mutex passed as parameter of this function.*/ ctp->mtxlist = mp->next; /* If a thread is waiting on the mutex then the fun part begins.*/ if (chMtxQueueNotEmptyS(mp)) { thread_t *tp; /* Recalculates the optimal thread priority by scanning the owned mutexes list.*/ tprio_t newprio = ctp->realprio; lmp = ctp->mtxlist; while (lmp != NULL) { /* If the highest priority thread waiting in the mutexes list has a greater priority than the current thread base priority then the final priority will have at least that priority.*/ if (chMtxQueueNotEmptyS(lmp) && (lmp->queue.next->prio > newprio)) { newprio = lmp->queue.next->prio; } lmp = lmp->next; } /* Assigns to the current thread the highest priority among all the waiting threads.*/ ctp->prio = newprio; /* Awakens the highest priority thread waiting for the unlocked mutex and assigns the mutex to it.*/ #if CH_CFG_USE_MUTEXES_RECURSIVE == TRUE mp->cnt = (cnt_t)1; #endif tp = queue_fifo_remove(&mp->queue); mp->owner = tp; mp->next = tp->mtxlist; tp->mtxlist = mp; (void) chSchReadyI(tp); } else { mp->owner = NULL; } #if CH_CFG_USE_MUTEXES_RECURSIVE == TRUE } #endif } /** * @brief Unlocks all mutexes owned by the invoking thread. * @post The stack of owned mutexes is emptied and all the found * mutexes are unlocked. * @post This function does not reschedule so a call to a rescheduling * function must be performed before unlocking the kernel. * @note This function is <b>MUCH MORE</b> efficient than releasing the * mutexes one by one and not just because the call overhead, * this function does not have any overhead related to the priority * inheritance mechanism. * * @sclass */ void chMtxUnlockAllS(void) { thread_t *ctp = currp; while (ctp->mtxlist != NULL) { mutex_t *mp = ctp->mtxlist; ctp->mtxlist = mp->next; if (chMtxQueueNotEmptyS(mp)) { #if CH_CFG_USE_MUTEXES_RECURSIVE == TRUE mp->cnt = (cnt_t)1; #endif thread_t *tp = queue_fifo_remove(&mp->queue); mp->owner = tp; mp->next = tp->mtxlist; tp->mtxlist = mp; (void) chSchReadyI(tp); } else { #if CH_CFG_USE_MUTEXES_RECURSIVE == TRUE mp->cnt = (cnt_t)0; #endif mp->owner = NULL; } } ctp->prio = ctp->realprio; } /** * @brief Unlocks all mutexes owned by the invoking thread. * @post The stack of owned mutexes is emptied and all the found * mutexes are unlocked. * @note This function is <b>MUCH MORE</b> efficient than releasing the * mutexes one by one and not just because the call overhead, * this function does not have any overhead related to the priority * inheritance mechanism. * * @api */ void chMtxUnlockAll(void) { thread_t *ctp = currp; chSysLock(); if (ctp->mtxlist != NULL) { do { mutex_t *mp = ctp->mtxlist; ctp->mtxlist = mp->next; if (chMtxQueueNotEmptyS(mp)) { #if CH_CFG_USE_MUTEXES_RECURSIVE == TRUE mp->cnt = (cnt_t)1; #endif thread_t *tp = queue_fifo_remove(&mp->queue); mp->owner = tp; mp->next = tp->mtxlist; tp->mtxlist = mp; (void) chSchReadyI(tp); } else { #if CH_CFG_USE_MUTEXES_RECURSIVE == TRUE mp->cnt = (cnt_t)0; #endif mp->owner = NULL; } } while (ctp->mtxlist != NULL); ctp->prio = ctp->realprio; chSchRescheduleS(); } chSysUnlock(); } #endif /* CH_CFG_USE_MUTEXES == TRUE */ /** @} */