% !TEX root = dt-slides-dt.tex

\section{Timinganalyse}

\begin{frame}
\frametitle{Timinganalyse}
\begin{center}
{\Huge Timinganalyse}
\vspace{5mm}

Mit welcher Taktfrequenz kann ich eine Schaltung betreiben?
\end{center}
\end{frame}

\begin{frame}
\frametitle{Sequentielle Schaltung}
\begin{center}
\begin{tikzpicture}[circuit logic IEC, circuit ee IEC, scale = 0.9]
\draw (0,0) node[shape=dff] (r0) {r0}; 
\draw (0,1.5) node[shape=dff] (r1) {r1}; 
\draw (0,3) node[shape=dff] (r2) {r2}; 
\draw (r2.Q) -- node[above] {q2} ++(right:2) node[xor gate, anchor=input 1] (xor) {i0};
\draw (r1.Q) -- node[above] {q1} ++(right:1) |- (xor.input 2);
\draw (xor.output) -- ++(right:1) node[contact] (c) {} -- node[above] {d4}  ++(right:3) node[shape=dff,anchor=D] (r4) {r4}; 
\draw (r4) ++(down:1.5)  node[shape=dff] (r3) {r3};
\draw (r3.D) -- node[above] {d3} ++(left:1) node[and gate, anchor=output] (and) (and) {i1};
\draw (c) |- (and.input 1);
\draw (r0.Q) -- node[above] {q0} ++(right:2) |- (and.input 2);
%X inputs
\draw (r2.D) -- node[above] {d2}  ++(left:1) node[anchor=east] {x2};
\draw (r1.D) -- node[above] {d1}  ++(left:1) node[anchor=east] {x1};
\draw (r0.D) -- node[above] {d0}  ++(left:1) node[anchor=east] {x0};
% Y output
\draw (r4.Q) -- node[above] {q4} ++(right:1)  node[anchor=west] {y1};
\draw (r3.Q) -- node[above] {q3} ++(right:1)  node[anchor=west] {y0};
% Clock signal
\draw (r2.CLK) -- ++(left:2mm) coordinate (s4) -- (s4 |- r0.south) -- ++(down:5mm) node[contact] (cclk) {} -- ++(down:5mm) node[anchor = north] {clk}; 
\draw (r1.CLK) -- (r1.CLK -| s4) node[contact] {};
\draw (r0.CLK) -- (r0.CLK -| s4) node[contact] {};
\draw (r4.CLK) -- ++(left:2mm) coordinate (s3) |- (cclk);
\draw (r3.CLK) -- (r3.CLK -| s3) node[contact] {};
\end{tikzpicture}
\end{center}

\begin{itemize}
\item Bei einer steigendenTaktflanke werden die Daten an den D Eingängen der Flipflops übernommen.
\item Die Ausgänge der Flipflops ändern sich nach dem Clock-to-Output Delay der Flipflops
\item Die Ausgänge der Flipflops sind die Eingänge der Kombinatorik
\item Die Ausgänge der Logikgatter ändern sich nach dem jeweiligen Propagationdelay
\item Nach einer gewissen Zeit ändern sich die Werte an den D Eingängen der Flipflops nicht mehr
\item Wenn die Werte an den D Eingängen für die Setupzeit der Flipflops stabil ist, können die Daten an D Eingängen der Flipflops ohne Timingverletzung wieder übernommen werden
\end{itemize}
\end{frame}

\begin{frame}
\frametitle{Sequentielle Schaltung}
\begin{center}
\begin{tikzpicture}[circuit logic IEC, circuit ee IEC, scale = 1]
\draw (0,0) node[shape=dff] (r0) {r0}; 
\draw (0,1.5) node[shape=dff] (r1) {r1}; 
\draw (0,3) node[shape=dff] (r2) {r2}; 
\draw (r2.Q) -- node[above] {q2} ++(right:2) node[xor gate, anchor=input 1] (xor) {i0};
\draw (r1.Q) -- node[above] {q1} ++(right:1) |- (xor.input 2);
\draw (xor.output) -- ++(right:1) node[contact] (c) {} -- node[above] {d4}  ++(right:3) node[shape=dff,anchor=D] (r4) {r4}; 
\draw (r4) ++(down:1.5)  node[shape=dff] (r3) {r3};
\draw (r3.D) -- node[above] {d3} ++(left:1) node[and gate, anchor=output] (and) (and) {i1};
\draw (c) |- (and.input 1);
\draw (r0.Q) -- node[above] {q0} ++(right:2) |- (and.input 2);
%X inputs
\draw (r2.D) -- node[above] {d2}  ++(left:1) node[anchor=east] {x2};
\draw (r1.D) -- node[above] {d1}  ++(left:1) node[anchor=east] {x1};
\draw (r0.D) -- node[above] {d0}  ++(left:1) node[anchor=east] {x0};
% Y output
\draw (r4.Q) -- node[above] {q4} ++(right:1)  node[anchor=west] {y1};
\draw (r3.Q) -- node[above] {q3} ++(right:1)  node[anchor=west] {y0};
% Clock signal
\draw (r2.CLK) -- ++(left:2mm) coordinate (s4) -- (s4 |- r0.south) -- ++(down:5mm) node[contact] (cclk) {} -- ++(down:5mm) node[anchor = north] {clk}; 
\draw (r1.CLK) -- (r1.CLK -| s4) node[contact] {};
\draw (r0.CLK) -- (r0.CLK -| s4) node[contact] {};
\draw (r4.CLK) -- ++(left:2mm) coordinate (s3) |- (cclk);
\draw (r3.CLK) -- (r3.CLK -| s3) node[contact] {};
\end{tikzpicture}
\end{center}

\begin{tikztimingtable}[scale=1.0]
clk & LLLC10HC10LC10HC10LC2H\\
q   & 6D{$q_n$}1U{}21D{$q_{n+1}$}1U{}21D{$q_{n+2}$}\\
d    & 11D{$d_n$}8U{}14D{$d_{n+1}$}8U{}9D{$d_{n+2}$}\\
\extracode
\begin{pgfonlayer}{background} 
\draw[<->] (3,2) -- node[above] {$t_{CQ}$}(7,2);
\draw[<->] (7,2) -- node[above] {$t_{comb,max}$}(19,2);
\draw[<->] (23,2) -- node[above] {$t_{su}$}(25,2);
\draw[draw=none, fill=orange, fill opacity = 0.4] (23,1) rectangle ++(+2,-6);
\draw[<->] (25,2) -- node[above] {$t_{h}$}(26,2);
\draw[draw=none, fill=orange, fill opacity = 1.0] (25,1) rectangle ++(+1,-6);
\draw[<->] (19,2) -- node[above] {slack}(23,2);
\begin{scope}[semitransparent ,semithick]
\vertlines[black]{1,3,...,49}
%\horlines{1,2,...,4}
% Horizontal achsis
\draw[->] (all rows.south west) ++(down:0.75) -- ++(right:10cm) node[anchor=west] {time/ps};
%\draw (all rows.south west) ++(right:1) ++(down:0.5)
%\foreach \xtext in {0,100,200,...,800}{
%++(2,0) node[anchor=north] {\tiny \xtext}};
\end{scope}
\end{pgfonlayer}
\end{tikztimingtable}
\begin{equation*}
t_{clkper,min} = t_{CQ} + t_{comb,max} + t_{su}
\end{equation*}
\end{frame}

\begin{frame}
\frametitle{Statische Timinganalyse}
\begin{center}
\begin{tikzpicture}[circuit logic IEC, circuit ee IEC, scale = 1]
\draw (0,0) node[shape=dff] (r0) {r0}; 
\draw (0,1.5) node[shape=dff] (r1) {r1}; 
\draw (0,3) node[shape=dff] (r2) {r2}; 
\draw (r2.Q) -- node[above] {q2} ++(right:2) node[xor gate, anchor=input 1] (xor) {i0};
\draw (r1.Q) -- node[above] {q1} ++(right:1) |- (xor.input 2);
\draw (xor.output) -- ++(right:1) node[contact] (c) {} -- node[above] {d4}  ++(right:3) node[shape=dff,anchor=D] (r4) {r4}; 
\draw (r4) ++(down:1.5)  node[shape=dff] (r3) {r3};
\draw (r3.D) -- node[above] {d3} ++(left:1) node[and gate, anchor=output] (and) (and) {i1};
\draw (c) |- (and.input 1);
\draw (r0.Q) -- node[above] {q0} ++(right:2) |- (and.input 2);
%X inputs
\draw (r2.D) -- node[above] {d2}  ++(left:1) node[anchor=east] {x2};
\draw (r1.D) -- node[above] {d1}  ++(left:1) node[anchor=east] {x1};
\draw (r0.D) -- node[above] {d0}  ++(left:1) node[anchor=east] {x0};
% Y output
\draw (r4.Q) -- node[above] {q4} ++(right:1)  node[anchor=west] {y1};
\draw (r3.Q) -- node[above] {q3} ++(right:1)  node[anchor=west] {y0};
% Clock signal
\draw (r2.CLK) -- ++(left:2mm) coordinate (s4) -- (s4 |- r0.south) -- ++(down:5mm) node[contact] (cclk) {} -- ++(down:5mm) node[anchor = north] {clk}; 
\draw (r1.CLK) -- (r1.CLK -| s4) node[contact] {};
\draw (r0.CLK) -- (r0.CLK -| s4) node[contact] {};
\draw (r4.CLK) -- ++(left:2mm) coordinate (s3) |- (cclk);
\draw (r3.CLK) -- (r3.CLK -| s3) node[contact] {};
%Timingpfade
\draw[rounded corners = 8pt, thick, color=red] (r1.CLK) -- (r1.Q) -- ++(right:1) |- (xor.input 2) -- (xor.output) -- ++(right:1.2) -- ++(down:1.2) -- (and.input 1) -- (and.output) -- (r3.D); 
\draw[rounded corners = 8pt, thick, color=blue] (r2.CLK) -- (r2.Q)  -- (xor.input 1) -- (xor.output) -- ++(right:1) -- ++(down:1.3) -- (and.input 1) -- (and.output) -- (r3.D);  
\end{tikzpicture}
\end{center}
\begin{itemize}
\item Wie lange dauert es nach einer steigenden Taktflanke bis die Daten an allen D Eingängen stabil sind?
\item Man könnte alle möglichen Signalwechsel in einem Schaltungssimulator simulieren und damit den spätesten jemals auftretenden Signalwechsel suchen. Das funktioniert wegen der Anzahl der möglichen Wechsel bei echten Schaltungen nicht
\item Deshalb schaut man sich statisch die Struktur der Schaltung an und sucht den "längsten Pfad" vom Takteingang zu einem D Eingang. Das ist der "kritische Pfad".
\item Hier: clk an r2 über i0 und i1 nach d3 ODER clk an r1 über i0 und i1 nach d3 (Gleichlange Pfade)
\item Damit wird die maximal mögliche Taktfrequenz bestimmt
\end{itemize}
\end{frame}

\begin{frame}
\frametitle{Beispiel mit Zahlen}
\begin{center}
\begin{tikzpicture}[circuit logic IEC, circuit ee IEC, scale = 1.0]
\draw (0,0) node[shape=dff] (r0) {r0}; 
\draw (0,1.5) node[shape=dff] (r1) {r1}; 
\draw (0,3) node[shape=dff] (r2) {r2}; 
\draw (r2.Q) -- node[above] {200} ++(right:2) node[xor gate, anchor=input 1] (xor) {i0};
\draw (r1.Q) -- node[above] {200} ++(right:1) |- (xor.input 2);
\draw (xor.output) -- ++(right:1) node[contact] (c) {} -- node[above] {520 ps}  ++(right:3) node[shape=dff,anchor=D] (r4) {r4}; 
\draw (r4) ++(down:1.5)  node[shape=dff] (r3) {r3};
\draw (r3.D) -- node[above] {800 ps} ++(left:1) node[and gate, anchor=output] (and) (and) {i1};
\draw (c) |- (and.input 1);
\draw (r0.Q) -- node[above] {200 ps} ++(right:2) |- (and.input 2);
%X inputs
\draw (r2.D) -- node[above] {d2}  ++(left:1) node[anchor=east] {x2};
\draw (r1.D) -- node[above] {d1}  ++(left:1) node[anchor=east] {x1};
\draw (r0.D) -- node[above] {d0}  ++(left:1) node[anchor=east] {x0};
% Y output
\draw (r4.Q) -- node[above] {q4} ++(right:1)  node[anchor=west] {y1};
\draw (r3.Q) -- node[above] {q3} ++(right:1)  node[anchor=west] {y0};
% Clock signal
\draw (r2.CLK) -- ++(left:2mm) coordinate (s4) -- (s4 |- r0.south) -- ++(down:5mm) node[contact] (cclk) {} -- ++(down:5mm) node[anchor = north] {clk}; 
\draw (r1.CLK) -- (r1.CLK -| s4) node[contact] {};
\draw (r0.CLK) -- (r0.CLK -| s4) node[contact] {};
\draw (r4.CLK) -- ++(left:2mm) coordinate (s3) |- (cclk);
\draw (r3.CLK) -- (r3.CLK -| s3) node[contact] {};
% Timingzeiten
\draw (r2.north) node[anchor=south] {200 ps};
\draw (r1.north) node[anchor=south] {200 ps};
\draw (r0.north) node[anchor=south] {200 ps};
\draw (r3.north) node[anchor=south] {200 ps};
\draw (r4.north) node[anchor=south] {200 ps};
\draw (xor.north) node[anchor=south] {320 ps};
\draw (and.north) node[anchor=south] {280 ps};
\end{tikzpicture}
\end{center}
\begin{tabular}{cccccc}
Gatter & $t_{pLH,max}$ & $t_{pLH,min}$ & $t_{pHL,max}$  & $t_{pHL,min}$ \\\hline
UND & 250 ps & 200 ps & 280 ps & 210 ps  \\
XOR & 320 ps & 240 ps & 310 ps & 250 ps \\
\end{tabular}
\begin{tabular}{ccccc}
FF & $t_{CQ,max}$ & $t_{CQ,min}$ & $t_{su}$  & $t_{h}$ \\\hline
 & 200 ps & 150 ps & 100 ps & 50 ps  \\
\end{tabular}
\begin{itemize}
\item Für die Bestimmung der maximalen Taktfrequenz sind nur die maximalen Verzögerungszeiten relevant
\item Hier: Minimale Taktperiodendauer: 800 ps + $t_{su}$ = 900 ps, Maximale Taktfrequenz: 1,11 GHz.
\end{itemize}
\end{frame}

\begin{frame}
\frametitle{Zusammenfassung Maximale Taktfrequenz}
\begin{itemize}
\item Die maximal mögliche Taktfrequenz ist durch die Verzögerungszeiten der Gatter, Clock to Output Delay und die Setupzeit der Flipflops beschränkt
\item Für die statische Timinganalyse wird der längste oder kritische Pfad vom Takt zu den D Eingängen der Flipflops gesucht
\item Eine größere Schaltungstiefe führt in der Regel zu einem längeren kritischen Pfad und deshalb zu einer geringeren Taktfrequenz
\end{itemize}
\end{frame}

\begin{frame}
\frametitle{Pipelining}
\begin{center}
{\Huge Pipelining}
\vspace{5mm}

Erhöhung der Taktfrequenz durch Verringerung der Logiktiefe
\end{center}
\end{frame}

\begin{frame}
\frametitle{Beispiel: Berechnung der Anzahl der Einsen auf zehn Leitungen}
\begin{center}
\begin{tikzpicture}[circuit logic IEC, circuit ee IEC, scale = 1.0]
\draw (0,0) node[shape=dff] (r0) {r0}; 
\draw (r0.Q) -- node[above] {q0} ++(right:1) node[cloud, anchor=west, draw, cloud puffs = 23, aspect=0.7] (cloud) {cntones}; 
\draw (cloud.east) -- node[above] {d1} ++(right:1) node[shape=dff, anchor=D] (r1) {r1};
% X Eingang Y Ausgang
\draw (r0.D) -- node[above] {d0}  ++(left:1) node[anchor=east] {x[9..0]}; 
\draw (r1.Q) -- node[above] {q1} ++(right:1)  node[anchor=west] {y[3..0]};
% Clock signal
\draw (r0.CLK) -- ++(left:2mm) -- ++(down:1) node[contact] (c) {} -- ++(down:0.5) node[anchor=north] {clk};
\draw (r1.CLK) -- ++(left:2mm) |- (c);
\end{tikzpicture}
\end{center}
\begin{itemize}
\item Der Eingang der Schaltung besteht aus 10 Leitungen x[9..0]. Es werden die Anzahl der Einsen gezählt. Wenn x = "1111111111" ist, dann sind 10 Leitungen auf 1 und der Ausgang y[3..0] ist "1010" (= 10 Dezimal).
\item Das Ergebnis der Berechnung $y=f(x)$ steht nach zwei Taktzyklen am Ausgang zur Verfügung. Die Latenz beträgt deshalb 2 Taktzyklen.
\item In jedem Takt kann eine neue Berechnung durchgeführt werden. Der Durchsatz ist also gleich der Taktfrequenz. Wenn die Taktfrequenz 100 MHz beträgt, dann entspricht dies einem Durchsatz von 100 Millionen Berechnungen pro Sekunde.
\end{itemize}
\begin{tikztimingtable}[scale=1.0]
clk & C10{2C}\\
x   & D{}4D{$x_0$}4D{$x_1$}4D{$x_2$}4D{$x_3$}4D{$x_4$}\\
y   & D{}4D{$y_{-2}$}4D{$y_{-1}$}4D{$y_{0}$}4D{$y_{1}$}4D{$y_{2}$}\\
\extracode
\begin{pgfonlayer}{background} 
\begin{scope}[semitransparent ,semithick]
\vertlines[black]{1,5,...,29}
%\horlines{1,2,...,4}
% Horizontal achsis
\draw[->] (all rows.south west) ++(down:0.75) -- ++(right:10cm) node[anchor=west] {time/ps};
%\draw (all rows.south west) ++(right:1) ++(down:0.5)
%\foreach \xtext in {0,100,200,...,800}{
%++(2,0) node[anchor=north] {\tiny \xtext}};
\end{scope}
\end{pgfonlayer}
\end{tikztimingtable}
\end{frame}

\begin{frame}
\frametitle{Pipelining}
\begin{center}
\begin{tikzpicture}[circuit logic IEC, circuit ee IEC, scale = 1.0]
\draw (0,0) node[shape=dff] (r0) {r0}; 
\draw (r0.Q) -- node[above] {q0} ++(right:1) node[cloud, anchor=west, draw, cloud puffs = 23, aspect=0.7] (cloud) {Logiktiefe=8}; 
\draw (cloud.east) -- node[above] {d1} ++(right:1) node[shape=dff, anchor=D] (r1) {r1};
% X Eingang Y Ausgang
\draw (r0.D) -- node[above] {d0}  ++(left:1) node[anchor=east] {x}; 
\draw (r1.Q) -- node[above] {q1} ++(right:1)  node[anchor=west] {y};
% Clock signal
\draw (r0.CLK) -- ++(left:2mm) -- ++(down:2) node[contact] (c) {} -- ++(down:0.5) node[anchor=north] {clk};
\draw (r1.CLK) -- ++(left:2mm) |- (c);
\end{tikzpicture}
\end{center}

\begin{itemize}
\item Die maximale Taktfrequenz wird durch die Logiktiefe und die damit einhergehende Verzögerungszeit der kombinatorische Logik begrenzt
\item Idee: Logik in zwei Teile aufteilen und die Logiktiefe halbieren 
\item Dazu wird in der Mitte der Logik ein Pipelineregister eingefügt
\end{itemize}
\end{frame}

\begin{frame}
\frametitle{Pipelining - Einfügen eines Pipelineregisters}
\begin{center}
\begin{tikzpicture}[circuit logic IEC, circuit ee IEC, scale = 1.0]
\draw (0,0) node[shape=dff] (r0) {r0}; 
\draw (r0.Q) -- ++(right:1) node[cloud, anchor=west, draw, cloud puffs = 13, aspect=0.7] (cloud) {Tiefe=4}; 
\draw (cloud.east) -- ++(right:1) node[shape=dff, anchor=D] (rp) {rp};
\draw (rp.Q) -- ++(right:1) node[cloud, anchor=west, draw, cloud puffs = 13, aspect=0.7] (cloud1) {Tiefe=4}; 
\draw (cloud1.east) -- ++(right:1) node[shape=dff, anchor=D] (r1) {r1};
% X Eingang Y Ausgang
\draw (r0.D) --  ++(left:1) node[anchor=east] {x}; 
\draw (r1.Q) --  ++(right:1)  node[anchor=west] {y};
% Clock signal
\draw (r0.CLK) -- ++(left:2mm) -- ++(down:1.5) node[contact] (c) {} -- ++(down:0.5) node[anchor=north] {clk};
\draw (rp.CLK) -- ++(left:2mm) coordinate (sclk) -- (sclk |- c) node[contact] (c1) {} ;
\draw (r1.CLK) -- ++(left:2mm) |- (c);
\end{tikzpicture}
\end{center}

\begin{itemize}
\item Die Logiktiefe wurde halbiert. Die Verzögerungszeit im kritischen Pfad der kombinatorischen Schaltung wird verringert und deshalb kann die Taktfrequenz erhöht werden
\item Durch das zusätzliche Pipelinegister ist das Ergebnis jetzt erst nach drei Takten am Ausgang verfügbar. Es kommt wie vorher mit jedem Takt ein neues Ergebnis am Ausgang an
\item In Bezug auf den Takt bleibt der Durchsatz gleich mit einer Berechnung pro Taktzyklus, aber die Latenz erhöht sich von zwei auf drei Taktzyklen.
\item Wenn durch die kleinere Logiktiefe die Taktfrequenz von 100 MHz auf 150 MHz erhöht werden kann, dann steigt der Durchsatz um 50 Prozent und die Latenz bleibt durch die kürzere Taktperiode bei 20 ns gleich.
\end{itemize}
\end{frame}


















