--- /dev/null
+%include talk.fmt
+\section{Introduction}
+\subsection{Hardware as we know it}
+\frame
+{
+\frametitle{Hardware}
+\begin{figure}
+\centerline{
+\includegraphics<1>[height=6cm]{figures/cpus/pmiphone_boardtopbig}
+\includegraphics<2>[height=6cm]{figures/cpus/Intel_core_i7}
+\includegraphics<3>[height=6cm]{figures/cpus/6600GT_GPU}
+\includegraphics<4>[height=6cm]{figures/cpus/Altera_StratixIV}
+}
+\label{img:chips}
+\end{figure}
+}
+\note[itemize]
+{
+\item Iedereen weet wel wat hardware is. Hier een paar voorbeelden.
+\item Binnenkant iPhone met veelvoud aan chips, Laatste Intel CPU, Nvidia Videochip, Altere FPGA
+}
+
+\frame
+{
+\frametitle{Transistor}
+\begin{figure}
+\centerline{
+\includegraphics<1>[height=6cm]{figures/transistor/hr-1sttransistor}
+\includegraphics<2>[height=6cm]{figures/transistor/worldsfastes}
+\includegraphics<3>[height=6cm]{figures/transistor/nehalem_432x315}
+}
+\label{img:chips}
+\end{figure}
+}
+\note[itemize]
+{
+\item Hardware is opgebouwd uit transistoren, simpele schakelaar
+\item Eerste transistor 60 jaar geleden, ter grootte van je hand
+\item Het word allemaal steeds kleiner
+\item Nu: Chip net iets groter dan je duim: 731 miljoen transistoren
+}
+
+\frame
+{
+\frametitle{Transistor Counts}
+\begin{itemize}
+\item Cell (Playstation 3): 241 Million
+\item Intel Core i7: 731 Million
+\item ATI HD5800: 2150 Million
+\item Nvidia GF100 (Expected Summer 2010): 2900 Million
+\end{itemize}
+}
+\note[itemize]
+{
+\item Aantal gebruikte transistoren wordt steeds groter
+}
+
+\frame
+{
+\frametitle{Designing Hardware}
+\centerline{Design with 4 transistors}
+\begin{columns}[c]
+\column{0.5\textwidth}
+\vspace{-0.5cm}
+\begin{figure}
+\centerline{\includegraphics[height=5cm, trim = 0 0 0 2.5cm, clip]{figures/schakelingen/NAND}}
+\end{figure}
+\column{0.5\textwidth}
+\begin{figure}
+\centerline{\includegraphics[height=5cm, trim = 0 4.5cm 0 0, clip]{figures/schakelingen/CMOS_NAND_Layout}}
+\end{figure}
+\end{columns}
+}
+\note[itemize]
+{
+\item NAND: Gaat na dat beide ingangen niet 1 zijn
+\item Een simpel hardware ontwerp met 4 transistoren
+\item Links een schematisch ontwerp, Rechts de layout van de metaal lagen
+}
+
+\frame
+{
+\frametitle{Designing Hardware}
+\vspace{0.5cm}
+\centerline{\Large This won't work for 730 million transistors!}
+\begin{figure}
+\centerline{\includegraphics[height=4cm]{figures/transistor/nehalem-core}}
+\end{figure}
+}
+
+\frame
+{
+\frametitle{Designing Hardware}
+\begin{itemize}
+\item We design hardware in the same format as software
+\item We make designs in plain text!
+\item Software: Programming Languages
+\item Hardware: Hardware Description Languages
+\end{itemize}
+}
+\note[itemize]
+{
+\item Harware designs worden gewoon in tekst opgeschreven.
+\item Maar wel in een special taal voor hardware
+\item Waar je voor software programmeer talen hebt,
+\item Heb je voor hardware zogeheette hardwarebeschrijvingstalen
+}
+
+\frame
+{
+\frametitle{Designing Hardware}
+\begin{itemize}
+\item Algorithmic / Behavioral Descriptions:
+\begin{itemize}
+\item Describe \emph{what} the Hardware does
+\item Relation between input and output
+\end{itemize}
+\item Structural Descriptions:
+\begin{itemize}
+\item Describe \emph{how} the Hardware does it
+\item Hierarchal composition
+\end{itemize}
+\end{itemize}
+}
+\note[itemize]
+{
+\item Algoritmische beschrijvingen beschrijven wat de Hardware moet doen, niet hoe die dat doet
+\item Structurele beschrijvingen beschrijven hoe de Hardware dingen doet
+\item In Structurele beschrijvingen worden componenten opgebouwd uit simpele schakelingen en/of andere componenten
+\item Graag willen wij algorithmische beschrijvingen maken, en de structurele beschrijving hier automatisch van afleiden
+}
+
+\frame
+{
+\frametitle{Why do we make Hardware?}
+\begin{itemize}
+\item We make hardware to solve problems
+\item The solutionss are often described as a set of mathematical equations\footnote{But what is the equation for a CPU?}
+\item `Holy Grail' Hardware Descriptions:
+\begin{itemize}
+\item Input: Set of Mathematical Equations
+\item Output: Hardware that is Provably correct, Fast , Small, Cheap to manufacture, and has a low Energy Usage
+\end{itemize}
+\end{itemize}
+}
+\note[itemize]
+{
+\item We maken hardware omdat we, soms vaag gedefineerde, problemen willen oplossen.
+\item Oplossingen, vooral in de signaalverwerking (video, muziek, TV, etc.), zijn beschreven als een verzameling van wiskundige formules
+\item Wat we dus graag zouden hebben, een zogenaamde heilige graal, is een programma aan welke we deze formules geven, en dat er dan automatisch super efficiente hardware uit komt.
+\item Maar... wat is de formule van een CPU/Processor? Misschien moet is een oplossingen in `normaal nederlands' soms een betere input voor zo'n programma?
+}
+
+\frame
+{
+\frametitle{Functional Languages}
+\begin{itemize}
+\item Functional programming languages allow us to specify programs that are close to a set of mathematical equations.
+\end{itemize}
+}
+\note[itemize]
+{
+\item Functionele talen liggen dicht bij de wiskunde
+}
+
+\frame
+{
+\frametitle{Functional Languages \& Hardware}
+\begin{itemize}
+\item When we want to calculate, 1 + 2 + 3, there is nothing that dictates that we should first calculate 1 + 2
+\item Like mathematical equations, Functional languages do not dictate an order when there is none. So everything can be calculated in parallel.
+\item In hardware, everything also happens in parallel: electrons flow through all the transistors every moment in time.
+\item IDEA: Use functional languages to describe hardware!
+\end{itemize}
+}
+\note[itemize]
+{
+\item In wiskundige formules is er vaak geen volgorde gedefineerd
+\item Dit is dus hetzelfde in functionele talen, wat betekent dat alles tegelijk/parallel kan worden uitgerekent.
+\item Bij `normale' programmeertalen is er vaak wel een volgorde
+\item In hardware gebeurt ook alles tegelijkertijd
+\item Het idee is dus om hardware te beschrijven in een functionele taal
+}
+
+% \frame
+% {
+% \frametitle{Mealy Machine}
+% \begin{figure}
+% \centerline{\includegraphics<1>[width=6.25cm]{mealymachine2}
+% \includegraphics<2>[width=6.25cm]{mealymachine2-func-red}
+% \includegraphics<3>[width=6.25cm]{mealymachine2-state-red}}
+% \label{img:mealymachine}
+% \end{figure}
+% \begin{beamercolorbox}[sep=-2.5ex,rounded=true,shadow=true,vmode]{codebox}
+% \begin{code}
+% run {-"{\color<2>[rgb]{1,0,0}"-}func{-"}"-} {-"{\color<3>[rgb]{1,0,0}"-}state{-"}"-} [] = []
+% run {-"{\color<2>[rgb]{1,0,0}"-}func{-"}"-} {-"{\color<3>[rgb]{1,0,0}"-}state{-"}"-} (i:inputs) = o:outputs
+% where
+% ({-"{\color<3>[rgb]{1,0,0}"-}state'{-"}"-}, o) = {-"{\color<2>[rgb]{1,0,0}"-}func{-"}"-} i {-"{\color<3>[rgb]{1,0,0}"-}state{-"}"-}
+% outputs = run {-"{\color<2>[rgb]{1,0,0}"-}func{-"}"-} {-"{\color<3>[rgb]{1,0,0}"-}state'{-"}"-} inputs
+% \end{code}
+% \end{beamercolorbox}
+% }
+% \note[itemize]{
+% \item A Mealy machine bases its output on the current state and the input
+% \item State is part of the function signature
+% \item Both the current state, and the updated State
+% \item The run function simulates a mealy machine for the provided number of inputs
+% }
+%
+% \frame
+% {
+% \frametitle{Haskell Description}
+% \begin{figure}
+% \centerline{\includegraphics[width=6.25cm]{mealymachine2-func-red}}
+% \end{figure}
+% \begin{beamercolorbox}[sep=-2.5ex,rounded=true,shadow=true,vmode]{codebox}
+% \begin{code}
+% func ::
+% InputSignal ->
+% State ->
+% (State, OutputSignal)
+% \end{code}
+% \end{beamercolorbox}
+% }
+% \note[itemize]{
+% \item In \clash{} you describe the logic part of the mealy machine
+% \item The state in the signature is turned into memory elements when translating to VHDL
+% }
projects / matthijs / master-project / final-presentation.git / blobdiff