\documentclass[12pt]{report}

%----------------------------------------------------------------------
% package loading
%----------------------------------------------------------------------

\usepackage{psfig}		% For including postscript figures.
\usepackage{makeidx}		% For automatically-generated indexes.
\usepackage{amssymb}		% Extra math fonts and symbols.
\usepackage{amsbsy}		% Bold math symbols.
\usepackage{amstext}		% Text in math formulas.
\usepackage{amsmath}		% Lots more AMS math stuff.
\usepackage{amsthm}		% Theorems and such.
\usepackage{latexsym}		% Some extra math symbols in standard LaTeX.
\usepackage[dvips]{color}	% For color text

\usepackage{urls}		% My package for formatting URLs properly.
\usepackage{myslides}		% My custom package for slides.
\input{macros}			% My custom macros
\input{defmacs}		% defense-specific macros

\begin{document}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%			       INTRO SECTION
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\large
\begin{center}
	 {\Large\textbf{{\rcolor{Reversibility}} for Efficient Computing}}\\
		       Ph.D. Thesis Defense\\[0.2in]

			    Michael P. Frank\\
			MIT EECS Dept./MIT AI Lab\\
		      {\url mpf@ai.mit.edu}\\[0.2in]

		       Monday, May 3, 1999\\[0.5in]
      {\small\url http://www.ai.mit.edu/~mpf/rc/thesis/defense.html}
\end{center}
\endslide
\note{Hello, I'm Michael Frank, of the MIT AI Lab, and I'm going to talk
about my research on how reversible computing techniques can be used to
increase computational efficiency, in several respects.

One respect is energy efficiency, and so you'll notice that in this talk
that reversibility is color-coded green, because it's the ``environmentally
correct'' way to compute.}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\slidetitle{Thesis of doctoral work:}

\noindent
{\rcolor{{\bf Reversible computing}}} techniques (to be described) are:
\begin{mitems}
	\item Not {\emph{too}} different from normal {\irreversible}
		techniques.
	\item Straightforward to implement, at all levels.
	\item Definitely required for future computing efficiency.
	\item Beginning to become useful today.
\end{mitems}
\vspace{.1in}
It's time for this field to start getting more attention!

\endslide
\note{
The thesis of this thesis is that, look: Reversible computing isn't really
that different from ordinary computing.  All the same design methods can be
used; there are just a few new constraints.  I have done design work that
illustrates that it really is pretty easy to do things reversibly.  And I
have done a scaling analysis that shows that for thermodynamic reasons,
reversibility is definely required for overall speed and
hardware-efficiency in the long run.  And there are immediate benefits in
energy-limited applications today.

The basic ideas of reversible computing have been around for a while, but
up till now they've been really obscure.  The main take-home message from
this talk is that these issues really are important, and so it's time now
that they started getting a lot more attention from computer science
theoreticians, hardware engineers, and device physicists.}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\slidetitle{Overview of talk contents}
\vspace{-0.1in}
\noindent
\begin{minipage}[t]{4.7in}
\begin{mitems}
\item Basic principles.
\item {\bf Engineering \& technology}:
	\begin{mitems}
	\item Reversible logic circuits.
	\item Programming reversible computers.
	\item Near-term applications.
	\end{mitems}
\item {\bf Theory \& analysis}:
	\begin{mitems}
	\item Traditional theory of reversible computing.
	\item Physical computing theory, scaling.
	\item Long-term applications.
	\end{mitems}
\item Conclusions
\end{mitems}
\end{minipage}
\begin{minipage}[t]{1in}
\vspace{0.2in}
\psfig{file=toffgate.epsi,width=0.5in}
\vspace{0.05in}
\psfig{file=rcall.epsi,width=0.5in}
\vspace{0.10in}
\psfig{file=ben.epsi,width=0.5in}
\vspace{-0.1in}
\psfig{file=mesh.epsi,width=0.5in}
%\psfig{file=helix.epsi,width=0.5in}
\end{minipage}
\endslide
\note{OK, now let me quickly preview the structure of this talk.
There's a lot of material to cover.  The thesis itself is over 400 pages
long and this is only an hour-long talk, so this is the short, short
version, and we're not going to go into a lot of detail.  But if you're
curious about details, the thesis is on the web.

The basic structure of the talk is from the more concrete to the more
theoretical.

In order to give people a solid grounding for the more abstract theoretical
material in the talk, I'm starting at a more concrete level, by giving you
examples of actual reversible logic circuits, processors, programming
languages, and algorithms that I've created or helped to create.  This will
show you that reversible computing techniques are pretty similar to
ordinary techniques, and are not very difficult to master.

Then, in the second half of the talk, I will discuss scaling issues.  In
traditional models of computation, which ignore thermodynamics, complete
reversibility seems to {\emph{reduce}} your overall computational
efficiency, and another student (Josie Ammer) and I actually came up with a
rigorous proof in complexity theory that establishes this, in a sort of
limited way which I'll mention.

But, if you {\emph{instead}} consider a sort of {\emph{physical}} model of
computation that really takes into account thermodynamics and a number of
other constraints from fundamental physics, then we'll see that if you
allow your computers to be {\em{mostly}} reversible, you can do much
{\emph{better}} than irreversible computers for large-scale parallel
computations, or even at small scales, as the technology improves.}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\figureslidew{determ.epsi}{2.5in}{Forward and Reverse Determinism}{}
%---------------------------------------------------------------------
\note{Now first, before we get into the circuits and such, let me explain
what I mean by reversibility.

Physicists teaches us that at the lowest microscopic level, the laws of
mechanics are completely deterministic, not only in the forwards time
direction, but in the reverse time direction as well.  Just as forwards
determinism says that a single state of physical system cannot evolve to
become either of two states at some single later time, reverse determinism
says that two possible states that are initially distinct cannot evolve to
become the same state at a single later time.

A consequence of this is that if you look at the possible trajectories of a
physical system through its state space, they form a set of
non-intersecting paths, which can twist over and under and around each
other in various ways, but can never intersect or merge.  Physicists
sometimes say ``state space is incompressible,'' and this basic result is
known as Liouville's Theorem.
}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\slidetitle{Information ``erasure'' in {\reversible} physics}
\vspace{-.25in}
\centerline{\psfig{file=erase2.epsi,height=2.4in}}
\vspace{-.28in}
{\normalsize
\begin{tabbing}
Before: $N$ thermal states, entropy $S=\kB\ln N$.\\
After: $2N$ thermal states, entropy $S=\ln 2N=\kB(\ln 2 + \ln N)$.\\
$\Delta S = \kB(\ln 2)$, $\Delta E = T\Delta S = \kB T \ln 2$.\\
\end{tabbing}}\nopagebreak\vspace{-4in}\nopagebreak\eject
\note{Now, this property of the reversibility of physics has an immediate
consequence for what happens when we try to erase a bit of information in a
computer.  This box represents the bit, and this cloud represents the state
of the rest of the computer and its environment, including the thermal
state of all its atoms and molecules; there is some large number N of
possible states.  So if initially, the bit can initially be in either one
of 2 states, 0 or 1, and you want to ``erase'' it so that it becomes 0
afterwards no matter what, well, you can't really reduce the number of
states, the number of states always stays the same, so since you've cut in
half the number of states of this part of the computer, you have to double
the number of states in the rest of the system for make up for it.

The logarithm of the number of states of a system is called its entropy, so
the entropy of the rest of the system has increased by log 2.  Essentially,
the erased bit still exists, but since you're no longer storing it in
digital form anywhere, you've just lost track of it; it has become a bit of
thermal entropy mixed up somewhere in the environment.

Now, the temperature of a system is {\emph{defined}} by the amount of
energy that needs to be added to the system to allow it to hold a given
small increase in entropy, so in order for an environment at temperature T
to accomodate a log 2 increase in entropy, we have to put T log 2 energy
into that environment.  If you want to express this in traditional units,
just stick Boltzmann's constant in front.  So, when we erase a bit, we
{\emph{must}} dissipate kT log 2 energy and generate 1 bit's worth of
entropy.  This was first discovered by Landauer in 1961.

So, the point of reversible computing is that it is a way to compute
{\emph{without}} erasing bits; and this cuts way down on the energy
dissipation and entropy production in your computer, which makes it
possible to do more operations per second in a smaller space at a higher
rate, without having your computer melt down.
}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%		     REVERSIBLE LOGIC CIRCUITS SECTION
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\slidetitle{Part I: Reversible logic circuits}
\centerline{
\begin{minipage}{.75in}\psfig{file=toffgate.epsi,width=.75in}\end{minipage}
\hspace{.25in}
\ctrfig{inv-icon}{.75in}\hspace{.25in}
\begin{minipage}{1in}\psfig{file=celllayout.eps,width=2in}\end{minipage}
}

\vspace{.2in}

\begin{mitems}
	\item Fredkin-Toffoli reversible boolean logic.
	\item Younis-Knight reversible electronic implementation (SCRL).
	\item Our reversible FPGA-like parallel processor ({\FlatTop})
\end{mitems}
\endslide
\note{OK, now let's see what reversible computing looks like, from the
circuit level on up.  We'll look at reversible logic gates, and see that
they look pretty similar to conventional logic.  I'll summarize the basic
principles of the techniques we use to implement this logic in physically
reversible electronic circuits based on conventional semiconductor
technology.  And finally, I'll describe a simple proof-of-concept
programmable mesh processor I designed, that can be used to simulate
arbitrary reversible logic circuits in a scalable 2-D or 3-D mesh.}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\slidetitle{Fredkin-Toffoli reversible logic}
\centerline{
\ctrfig{inv-icon}{.75in}\hspace{.2in}
\ctrfig{noand}{.75in}\hspace{.2in}
\ctrfig{toffgate}{.75in}\hspace{.2in}
}

\vspace{.2in}

\begin{mitems}
\item Normal multi-input logic gates are not reversible.
	\mitem{Output insufficient to determine input.}
\item Toffoli's universal reversible 3-input, 3-output gate:
	\begin{mitems}
	\item Inputs preserved, w.\ a delay.
	\item Output reversibly toggled.
	\item Subsumes {\sc AND}/{\sc NAND}/{\sc XOR}/{\sc NOT}.
	\end{mitems}
\end{mitems}

\endslide
\note{OK, so let's start by seeing what reversibility looks like in
abstract boolean logic circuits.  We imagine information feeding through
these circuits from left to right, being transformed as it goes along.  The
logical behavior of an ordinary NOT gate is reversible; the output is just
the opposite of the input, so you can determine the input by looking at the
output.  But in multi-input logic gates such as AND, there's just not
enough information in the output to uniquely determine the input.  Even if
you were to keep one of the inputs around, there's still not enough
information to always determine what the other one was.  However, if you
preserve {\emph{both}} inputs, you're OK.  Fredkin and Toffoli explored
these issues in the late 70's and early 80's; and here's Toffoli's version
of a 3-input, 3-output logic gate which is reversible and can perform a
variety of operations.  It turns out that if you only have this gate, you
can wire them together to create any desired combinational or sequential
logic.

Now, let's see how to implement this sort of logic in electronics, in a
physically reversible way.  In present electronics, even the simple
inverter is implemented in a way that's fundamentally irreversible.}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\slidetitle{Energy dissipation in {\irreversible} vs.\ {\reversible}
	electronics}
\centerline{
\ctrfig{switch}{2.2in}\hspace{.2in}
\ctrfig{cmos}{2.7in}\hspace{.2in}}

\vspace{.2in}
\begin{mitems}
	\item Dissipation in {\irreversible} circuits at least
		$\frac{1}{2}CV^2$.
	\item Dissipation in {\reversible} circuits is
		$CV^2 (RC/t)$.
	\item For reliability of $N$ ops/error despite thermal noise:
		\begin{mitems}
		\item $\frac{1}{2}CV^2 \geq \kB T\, \ln N$, in both.
		\end{mitems}
	\item Decrease $RC$: less lossage at a given clock speed.
\end{mitems}
\endslide
\note{
What is it about ordinary electronics that makes it irreversible?  It's the
fact that in order to change the voltage on a logic node representing a
bit, ordinary circuits do this by just connecting the node directly to a
constant-voltage power supply.  The energy delivered by the power supply is
C V-squared, where C is the capacitance of the node and V is the change in
voltage, but the energy stored on the node is only one half $CV^2$; the
other half of the energy is dissipated, lost to the form of heat.

We can do better if we switch a node by connecting it to a variable power
supply that is starts out at the {\emph{same}} voltage as the node, and
then ramps up or down gradually to the desired level, over a time $t$.  In
this case, the dissipation is reduced by this factor RC over t.  This
technique was first described by Boyd Watkins in 1967, but at the time, it
didn't go anywhere, because dissipation wasn't a big concern.  Now it's
becoming more important, as processor speed is increasingly limited by
energy dissipation.

Anyway, you might ask, well, why is $CV^2$ dissipation a problem, because
maybe we can eventually reduce $CV^2$ so much that this approaches zero.
But actually, even if we could build switching circuits with really low
capacitances and threshold voltage, we still have to deal with thermal
noise, and you can show by a simple thermodynamic argument that there's no
way that you can reliably store a voltage level unless $CV^2$ is greater
than the thermal energy at your given temperature times the log of this
reliability factor $N$.  So, the irreversible circuit will always generate
log $N$ entropy, every time it switches.

The reversible circuit, on the other hand, even enough it still has to
store this much energy, it doesn't have to dissipate it.

The interesting thing about this formula is that as RC is decreased, which
is happening as semiconductor technology is improved, it proportionally
improves the energy savings from reversibility, when running at a given
clock speed.  So in heat-limited situations, as the technology improves
this kind of charging will become a better and better win.  Present-day
processors already often have to run at below their maximum clock speed
just to give time to get the heat out.

Now, the important thing to notice about this trick is that in order to
change a node in this way, you have to connect it up to the right level to
start with, and to do this you have to keep the information around which
describes what level it was at to start with.  You can never actually throw
that information away, without at some point doing this dissipative type of
changing.  This underscores the general thermodynamic issue that computers
have to be logically reversible in order to be physically reversible.}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\slidetitle{Younis-Knight SCRL {\reversible} electronics}

\vspace{-.15in}
\centerline{
\ctrfig{scrl-invcore}{1.4in}\hspace{.25in}
\ctrfig{pipe2}{2.8in}}

\vspace{.1in}

SCRL = {\em Split-level Charge Recovery Logic}:
\begin{mitems}
    \item Fully reversible sequential circuits.
    \item Ordinary semiconductor transistors.
    \item Resonant supply w.\ 3 levels.
    \item Never turn on trans.\ w.\ voltage across it.
    \item Enough info.\ in outputs to uncompute inputs.
    \item Compute in predefined phases.
    \item Me: voltage scaling analysis, bug fix.
\end{mitems}
\endslide
\note{
OK, now, in 1993 and 94 Younis and Knight developed the first circuit
technique for implementing arbitrary sequential circuits that work in a
fully reversible fashion.  

The technique uses perfectly ordinary semiconductor transistors, such as
you get in any normal chip fabrication process, and the core of its logic
gates have exactly the same structure as ordinary static CMOS circuits.  So
for example, here's an inverter core; the input is presented on the left
and the output is produced on the right.

The differences are that instead of the normal thing of supplying constant
voltages here and here, we have a signal that periodically swings from an
initial neutral level to either a high or low level, and then back.  The
clock swings at specific times, which are synchronized with the input
signal, so that the input is guaranteed never to change except when all
these nodes are equal; this avoids the $CV^2$ dissipation we talked about.

Now, this block represents a set of gates like this, computing some
invertible logic function.  The outputs are stored in this sort of
bidirectional latch here, and then those outputs are used by this reverse
set of gates, to uncompute the original input, pulling the charge back off
of that previous latch and recovering its energy.

I don't really have time to go into any more detail than this about how
SCRL works, but if you're interested in learning more about it, go to
Carlin Vieri's talk on Friday, because he's going to describe it more
thoroughly.

My own contributions to SCRL were that I fixed a small bug, and I analyzed
the voltage scaling issues.  Let me show you the results of that analysis
real quick.
}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\figureslidew{evsvt0.epsi}{3in}{Scaling of SCRL minimum energy with threshold
voltage}{
\[E\tg{min} \propto C\tg{L}V\tg{T0}e^{-\frac{1}{2}V\tg{T0}/\phi'_T}\]}
\note{
When you're using ordinary semiconductor transistors to implement a
technique like SCRL, there is this problem that at the transistors don't
ever turn off completely; there will always be a small residual leakage
current, due to thermal hopping of electrons over the potential barrier.

This means that at any fixed temperature, there will be a minimum energy
per operation in SCRL, which happens at the speed where the switching
energy exactly equals the leakage energy.  If you go faster than this, the
switching energy increases, and if you go slower, the leakage energy
increases; either way you lose.

However, the interesting thing is that the magnitude of that minimum energy
has this dependence on the threshold voltage, relative to the thermal
voltage at the given temperature.  The curve isn't valid for the very low
thresholds over here, because the transistors don't turn off well enough to
do logic reliably, and it isn't valid for very high voltages off in this
direction, because eventually your gate oxides will break down.  But there
is a large region in here in which the minimum energy actually decreases
exponentially as threshold and supply voltages increase.  This is
interesting because it's the opposite of what you get in irreversible
circuits in which to save energy you always want lower voltages because of
that $V^2$ term.  But here, high voltages help because they turn
transistors off more substantially, which exponentially reduces the leakage
currents, and allows you to run exponentially more slowly before leakage
energy becomes significant.  Of course this is not really relevant except
in applications where you really only care about low-energy operation, and
are willing to tolerate very slow speeds.  But, for those applications, the
implication is that you don't really want to use low-threshold
technologies.  Or if you do, you should run at low temperatures, which is
an alternative way of getting farther out on this curve without actually
raising the voltages.  
}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\slidetitle{FlatTop reversible mesh processor}

\vspace{-.1in}

\centerline{
\ctrfig{bbgate}{1.3in}
\begin{minipage}{1in}\psfig{file=celllayout.eps,width=2in}\end{minipage}
\hspace{0.25in}
\begin{minipage}{1.5in}\psfig{file=ftmesh.epsi,width=1.5in}\end{minipage}}

\vspace{.1in}

\begin{mitems}
  \item FPGA-like; simulates any reversible circuit.
  \item Encodes Fredkin ``Billiard Ball Model'' of computation
  \item $\sim300$ transistors / processing element.
  \item Est.\ min.\ room-$T$ diss.: $\sim 2000\times$ less
	than {\icolor{irrev.}}
  \item Chips w.\ 20$\times$20 array just back from fab.
\end{mitems}

\endslide
\note{(No notes on this slide yet.)}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%			    PROGRAMMING SECTION
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\slidetitle{Part II: Programming reversible computers.}
\centerline{\ctrfig{rcall}{2in}\hspace{.25in}\ctrfig{state1}{2in}}
\begin{mitems}
	\item PISA instruction set.
	\item R programming language.
	\item Reversible algorithms.
\end{mitems}
\endslide
\note{(No notes on this slide yet.)}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\slidetitle{Pendulum {\reversible} processor}
\centerline{\ctrfig{clock}{.5in}}
\vspace{.1in}
\begin{mitems}
   \item Carlin Vieri's Ph.D.\ project.
   \item Full RISC-style CPU.
   \item My contributions to PISA (Pend.\ instr.\ set arch.):
	 \begin{mitems}
	 \item Asymptotic efficiency.
	 \item Guaranteed reversibility.
	 \end{mitems}
   \item Chips are being tested.
\end{mitems}
\endslide
\note{(No notes on this slide yet.)}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\slidetitle{Example PISA-type instructions:}

\newcommand{\ct}{\char'136}	% caret

\vspace{-0.4in}
\begin{center}
{\setlength{\parindent}{0pt}\footnotesize
\construct{``Nonexpanding'' arith./logic:}
{NEG\ \ \=ra\ \ \ \ \ \=(ra = -ra)		\\
ADD  \>ra,rb  \>(ra += rb) 		\\
ADDI \>ra,imm \>(ra += [imm])	\\
SUB  \>ra,rb  \>(ra -= rb)		\\
XOR  \>ra,rb  \>(ra {\ct}= rb)		\\
RL   \>ra,imm \>(ra <=< imm)}\construct{``Expanding'' arith./log.:}{
ANDX\ \ \=ra,rb,rc\ \ \=(ra {\ct}= rb\&rc)       \\
ANDIX \>ra,rb,imm \>(ra {\ct}= rb\&[imm])    \\
ORX   \>ra,rb,rc  \>(ra {\ct}= rb|rc)       \\
SLLX  \>ra,rb,imm \>(ra {\ct}= rb<<imm)	    \\
SLTX  \>ra,rb,rc  \>(ra {\ct}= (rb<rc)?1:0) \\
SRAX  \>ra,rb,imm \>(ra {\ct}= rb>>imm)}
\construct{Branch instructions:}{
BEQ\ \ \ \ \=ra,rb,off \=(if ra=rb, BR+=off*dir)\\
BGEZ   \>ra,off    \>(if ra>=0, BR+=off*dir)\\
BGTZ   \>ra,off    \>(if ra>0, BR+=off*dir)\\
BRA    \>loff      \>(BR += loff*dir)\\
RBRA   \>loff      \>(dir=-dir, BR+=loff*dir)\\
SWAPBR \>ra        \>(ra <-> BR)
}
%\construct{Memory \& I/O instructions:}{
%EXCH \=ra,rb \=(ra <-> mem[rb])			\\
%READ \>ra    \>(ra {\ct}= next input word)	\\
%IO   \>ra    \>(ra <-> next word of I/O stream)	\\
%SHOW \>ra    \>(Copy ra to output stream)		\\
%EMIT \>ra    \>(Emit ra to garbage stream)		\\
%}
}
\end{center}

\endslide
\note{(No notes on this slide yet.)}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\figureslidew{controlflow2.epsi}{3.5in}{Some {\reversible} control flow structures:}{}
%---------------------------------------------------------------------
\note{(No notes on this slide yet.)}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\slidetitle{The ``R'' {\reversible} programming language}

\centerline{\fbox{\ctrfig{rlogo}{1.5in}}}

\noindent
Features:
\begin{mitems}
\item Parenthesis-based syntax, for easy parsing.
\item Simple C-like procedural semantics.
\item Permits coding efficient reversible algorithms.
\item The R language compiler:
	\begin{mitems}
	\item Written in Common Lisp.
	\item Targets PISA assembly code.
	\end{mitems}
\end{mitems}

\endslide
\note{(No notes on this slide yet.)}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\slidetitle{Example R language constructs}

\vspace{-0.4in}
\begin{center}
{\setlength{\parindent}{0pt}\footnotesize
\construct{Control flow:}{
(if \={\em condition} then					\\
    \>{\em statement} \ldots)					\\
(for \={\em var\/} = {\em start\/} to {\em end}			\\
     \>{\em statement} \ldots)					\\
(def\=sub {\em subname\/} ({\em arg$_1$ arg$_2$ \ldots})	\\
    \>{\em statement} \ldots)					\\
(call {\em subname arg$_1$ arg$_2$ \ldots})			\\
(rcall {\em subname arg$_1$ arg$_2$ \ldots})}
\construct{Data manipulation:}{(let\=\ ({\em var\/} <- {\em val})				\\
    \>{\em statement} \ldots)						\\
({\em place\/} ++)						\\
({\em place\/} += {\em value\/})				\\
({\em place\/} -= {\em value\/})				\\
({\em place\/} \char'136= {\em value\/})			\\
$\vdots$}\construct{Expressions:}{
({\em val$_1$} + {\em val$_2$})					\\
({\em val$_1$} - {\em val$_2$})					\\
({\em val$_1$} \& {\em val$_2$})				\\
(* {\em address})						\\
({\em array} \char'137\ {\em index})\\
$\vdots$
}
\construct{Data declaration:}{
(defword {\em name value})					\\
(def\=array {\em name}						\\
    \>{\em value$_0$ value$_1$ \ldots} )}
\construct{Output:}{
(printword {\em val\/})						\\
(println)}
}
\end{center}
\endslide
%----------------------------------------------------------------------
\note{(No notes on this slide yet.)}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\slidetitle{Reversible algorithms}
\begin{mitems}
\item Sorting, arithmetic, depth-first \& breadth-first search:
	\mitem{Straightforward, no space or time increase.}
\item Interesting case: All-pairs shortest path graph problem.
	\begin{mitems}
	\item Floyd-Warshall: Time $\Exactly(n^3)$, space $\Exactly(n^2)$.
	\item Direct reversible: Space $\Exactly(n^3)$.
	\item Alt.\ reversible: Time $\Exactly(n^3\log n)$, space
		$\Exactly(n^2\log n)$.
	\item Best reversible algs.\ may have different structure!
	\end{mitems}
\item Physical simulations (Margolus, D'Souza, \ldots)
	\begin{mitems}
	\item No overhead, good stability.
	\item Reflect underlying reversibility of physics.
	\item Example: {\Schroedinger} wave simulation.
	\end{mitems}
\end{mitems}
\endslide
\note{(No notes on this slide yet.)}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\slidetitle{{\Reversible} {\Schroedinger} simulation}
\centerline{
\ctrfig{state0}{2.5in}
\ctrfig{state1}{2.5in}}
\endslide
\note{(No notes on this slide yet.)}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\slidetitle{R source for {\Schroedinger} program:}
\vspace{-.3in}
{\tt\scriptsize
\begin{tabbing}
(defword epsilon 203667001) ; hbar*dt/m*dx{\char'136}2 = .09 rad. (dx=7.8125e-13m, dt=5e-22s)\\
(defarray alphas 458243442 456664951 \ldots [126 others]) ;Potential well.\\
(defarray psiR 2072809 3044772 \ldots [126 others]) ; Real part of wave.\\
(defarray psiI 0 0 \ldots [126 others]) ; Imaginary part of wave.\\
(d\=efsub halfstep (dest src) ; Updates one wave based on the other.  \\
  \>(l\=et (e <- epsilon)\\
  \>  \>(f\=or i = 0 to 127\\
  \>  \>  \>(l\=et (d <-> (dest {\us} i))\\
  \>  \>  \>  \>(d += ((alphas {\us} i) */ (src {\us} i)))\\
  \>  \>  \>  \>(d -= (e */ (src {\us} ((i + 1) \& 127))))\\
  \>  \>  \>  \>(d -= (e */ (src {\us} ((i - 1) \& 127))))))))\\
(d\=efsub printwave (wave) ; Print given wave to output. \\
  \>(f\=or i = 0 to 127\\
  \>  \>(printword (wave {\us} i)))\\
  \>(println))\\
(d\=efmain schroed  ;Main program.\\
  \>(f\=or i = 1 to 1000 ;Time for electron to fall to well bottom.\\
  \>  \>(call halfstep psiR psiI)  (rcall halfstep psiI psiR) ; Update both
components\\
  \>  \>;; Print both components.\\
  \>  \>(call printwave psiR) (call printwave psiI)))\\
\end{tabbing}}
\vspace{-.1in}
830 PISA instructions (395 data, 435 program).
\endslide
\note{(No notes on this slide yet.)}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%		    REVERSIBLE COMPUTING THEORY SECTION
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\slidetitle{Part III: Traditional\\[.05in]reversible computing theory.}
\centerline{\ctrfig{bentrick}{1.5in}\hspace{.25in}
\ctrfig{ben}{1in}}
\vspace{.1in}
\begin{mitems}
	\item Traditional modeling context.
	\item General {\irreversible} $\rightarrow$ {\reversible}
		transformations.
	\item Minimum overheads for reversibility.
\end{mitems}
\endslide
\note{(No notes on this slide yet.)}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\slidetitle{Traditional reversible computing theory---Caveats}

{\setlength{\parindent}{0pt}Previous RC theory in traditional
models of computation:}
\begin{mitems}
   \item Traditional focus on idealized space, time.
   \item Ignore energy cost \& overhead of heat removal.
   \item Frank \& Ammer: In that case, reversibility looks bad.
   \item Later: More {\emph{physical}} models of computation.
   \item In more realistic models, reversible machines look good!
\end{mitems}
\endslide
\note{(No notes on this slide yet.)}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\slidetitle{Bennett's {\reversible} simulation techniques}
\vspace{-.2in}
\centerline{\ctrfig{bentrick}{2.0in} \ctrfig{ben2}{2.5in}}
\vspace{.1in}
\begin{mitems}
\item 1973: Compute w.\ full history, copy output, uncompute.
\item 1989: Do in small segments, \& recursively @ higher levels.
\item Time $\Atmost(\TI^{1+\varepsilon})$, space $\Atmost(\SP\log\TI)$,
w.\ constant $\varepsilon > 0$.
\item Or: Time $\Atmost(\TI)$, space $\Atmost(\SP\cdot\TI^\varepsilon)$.
\item Levine \& Sherman '90: Unrealistic to make $\varepsilon$
	{\emph{too}} small.
\end{mitems}
\endslide
\note{(No notes on this slide yet.)}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\slidetitle{More space-time efficient simulations?}
\vspace{-.1in}
\centerline{\ctrfig{lmt}{2in}}
\vspace{.1in}
\begin{mitems}
\item Lange {\etal} '97:  Space $\Atmost(\SP)$, time $\Atmost(2^\SP)$.
	\mitem{I helped them make result fully general.}
\item Open question: Possible to do space $\Atmost(\SP)$, time $\Atmost(\TI)$?
\item Frank \& Ammer '97: If so, would break if:
	\begin{mitems}
	\item Add a (computable) reversible oracle.
	\item Or, input is a reversible ROM.
	\item Possibly also if 1-way functions exist.
	\end{mitems}
\item Remember: Assumes traditional context!
\end{mitems}
\endslide
\note{Mention that I helped LMT to make their result fully general.}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% PHYSICS & SCALING SECTION
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\slidetitle{Part IV: Physical models \& scaling}
\vspace{-.5in}
\centerline{\ctrfig{mesh}{1.5in}}
\begin{mitems}
\item Fundamental physical constraints on computation.
\item More physically realistic models of computation.
\item Scaling of physical reversible and irreversible machines.
\end{mitems}
\endslide
\note{(No notes on this slide yet.)}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%			FUNDAMENTAL PHYSICS SECTION
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\slidetitle{Physical constraints on computation}
{\footnotesize
\centerline{
\begin{tabular}{|l|l|c|l|l|}
\hline
{\bf Fundamental}& {\bf Constrained}	& 		& {\bf Quantitative}				& {\bf Impact on}          \\
{\bf principle}	& {\bf quantity}	& {\bf Symbol}	& {\bf constraint}				& {\bf our model}          \\
\hline\hline %=================================================================================================================
Quantum		& Entropy		& $\sdens$	& $\lesssim$ 1--10 {$\bit/\Ang$}{$^3$}?	& Finite state/      \\	
mechanics	& density	 	&		&						& processor	     \\
		\cline{2-5} %-------------------------------------------------------------------------------------------------
		& Entropy flux		& $\sflux$	& $\leq\sdens v$				& Finite info.	     \\
		&			&		&						& flux		     \\
		\cline{2-5} %-------------------------------------------------------------------------------------------------
		& Rate of state		& $\orthrate$   & $\leq 4(E-\lowestE)/h$			& Finite oper.	     \\
		& change		& 		& 						& frequency	     \\
\hline %-----------------------------------------------------------------------------------------------------------------------
Locality	& Info. prop.		& $v$		& $\leq c\approx\e{3}{8}\units{m/s}$		& Mesh arch.         \\
		& velocity		&		&						& (Vit\'anyi '88)    \\
\hline %-----------------------------------------------------------------------------------------------------------------------
3-dimensionality& Connec-		&               & $\Atmost(t^3)$				& 3-D mesh	     \\
of space        & tivity             	&		&						&		     \\
\hline %-----------------------------------------------------------------------------------------------------------------------
Micro-		& Entropy		& $\Delta S$	& $\geq 0$ always,				& Logical  \\
{\rcolor{reversibility}},	& change		& 		& $\geq 1$/erasure				& {\rcolor{reversibility}},     \\
		\cline{2-4} %---------------------------------------------------------------------------
thermodynamics	& Energy		& $\Delta E$	& $\geq 0$ always,				& entropy	     \\
		& dissipation		&		& $\geq \kB T\ln 2$/eras.			& accounting	     \\
\hline %-----------------------------------------------------------------------------------------------------------------------
Frictional	& Entropy		& $\entco$	& $>0\units{b/Hz}$?				& Time-prop.	     \\
effects		& coefficient		&		&						& reversibility	     \\
\hline %-----------------------------------------------------------------------------------------------------------------------
\end{tabular}}}
\endslide
\note{(No notes on this slide yet.)}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%			     ULTIMATE SECTION
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\slidetitle{My proposed model: The {\rcolor{R}3M}\\[.05in]
({\Reversible} 3-D Mesh)}
\vspace{-.15in}
\centerline{
\fbox{\parbox{3in}{\centering A locally-connected, 3-D mesh of\\
finite {\em reversible} processors.}}\hspace{.25in}\begin{minipage}{1in}\vspace{-.5in}\psfig{file=mesh.epsi,width=1in}\end{minipage}}
\vspace{-.1in}
Assume only \rcolor{{\em time-proportionate} reversibility}:
	\begin{mitems}
	\item Entropy/op proportional to speed, $S = \entco / t$.
	\item We {\em know} how to do this with $\entco > 0$ (\eg, SCRL).
	\item It {\em still} scales better than {\irreversible} models.
	\item No fundamental lower bound on $\entco$ is known.
	\end{mitems}
\vspace{.1in}
{\bf Conjecture:} ({\em Tight Church's thesis})
The R3M is asymptotically optimal, within a constant factor.
\endslide
%---------------------------------------------------------------------
\note{\scriptsize
Well, not to keep you in suspense, here's our idea of what the ultimate
model ought to look like.  It should be a locally-connected, 3-D mesh of
finite reversible processors.  Ordinary 3-D meshes have been proposed as an
ultimate model before in the parallel architecture community, but we'll see
in a minute that when you take thermodynamics into account, it looks like
reversibility is also necessary.

Now, you might ask, what do we mean by reversible.  This unitary quantum
computation that people are talking about is reversible, and it looks like
it's probably more powerful than anything classical, but we don't really
know yet if it can be scaled up to large problems in any practical way.

So, large controlled superpositions aside, it might conceivably still be
possible to have a machine that evolves purely ballistically, if the
degrees of freedom that contain the kinetic energy being used to carry out
the computation are really well isolated from the machine's thermal degrees
of freedom, perhaps because the system is cooled to the point where
interactions are really unlikely, or its parts are physically well
separated... But the fact is, we really haven't seen any concrete proposals
for how to compute like this, while keeping errors under control.

So finally, there is what I call ``time-proportionate'' type of
reversibility, where the amount of irreversible dissipation is proportional
to the rate at which an operation is performed... We now {\em know} of
several technologies having this behavior, including some very practical
ones that are comparable to today's commercial microprocessor technology.
You might think, well if you have to run more slowly, how could you ever
scale better than just doing things irreversibly?  Well, that's what we're
gonna show.  }
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%			      SCALING SECTION
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\slidetitle{Limit on \underline{\irreversible} processing rate}

\centerline{
\begin{minipage}{2in}\psfig{file=ilim.epsi,width=2in}\end{minipage}
\hspace{.1in}
\begin{minipage}{3in}
{\icolor{$\displaystyle \procrate\leq\frac{\sflux\area}{\entropy}$}}
\vspace{.2in}
\begin{tabbing}
$\procrate$\ \= -- total rate of ops per time\\
$\sflux$ \> -- max. rate entropy flux per area\\
$\area$ \> -- min. area of enclosing surface\\
$\entropy$ \> -- min. entropy generated per op
\end{tabbing}
\end{minipage}}

\vspace{.1in}

\begin{mitems}
\item Note processing rate scales with surface area, not volume.
\item The entropy $\entropy$ can never be less than 1 bit ($\kB\ln 2$) 
	per bit {\icolor{irreversibly erased}} by an operation.
\item We consider $\sflux$ to be a constant, assuming limits on temperature
	and energy density.
\end{mitems}

\endslide
%----------------------------------------------------------------------
\note{
So let's see how this unavoidable entropy generation
affects the processing rate of irreversible computers,
by which I mean computers that generate some minimum
amount of entropy with each logic operation.

Well, since entropy density is bounded inside the computer, in the long run
entropy can't be produced inside the computer any faster than the rate at
which it can get out through the smallest enclosing surface, and so if this
(point) is the minimum entropy per operation, then this is the maximum rate
of operation.  

Note that it only scales with the surface area of the machine, and not with
the volume, as long we make the reasonable assumption that $F$ is bounded.
So basically in irreversible machines, the third dimension is useless.

Also, note that $S$ can never be less than 1 bit per bit that's
irreversibly lost, and irreversible machines generally lose a bit with
every logic gate operation.

Later we'll see some examples as to what this maximum processing rate
actually is, for various technologies.}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\slidetitle{Per-area speed limit for \underline{\reversible} machines}
\vspace{-.1in}
\centerline{
\ctrfig{revrate}{2in}
\begin{minipage}{3in}
\begin{tabbing}
{\rcolor{$\procrate \propto A\sqrt{d}$}} with $t \propto \sqrt{d}$.\\
Beats \=best {\icolor{irrev.}}\ $\displaystyle \procrate = A\frac{\sflux}{S}$\\
      \>when $\displaystyle d > \frac{\sflux\entco V}{S^2}$
\end{tabbing}
\end{minipage}}
\vspace{.1in}
Present/near-future VLSI, w.\ ordinary cooling:
	\begin{mitems}
	\item $\gtrsim 200$-layer circuits are
	      faster if {\reversible}.
	\item $1\units{m^3}$, $1\units{MW}$ {\rcolor{rev.}}\ machine:
	      $\sim~24$ PFLOPS\\
	      (vs.\ 1 PFLOPS in supercond.\ {\icolor{irrev.}}).
	\end{mitems}
Various nano-scale technologies,
	w.\ aggressive cooling:
	\begin{mitems}
	\item {\rcolor{Rev.}}\ beats {\emph{best possible}} {\icolor{irrev.}}\ if 
		$d\gtrsim 1\unit{mm}$.
	\end{mitems}
\endslide
%---------------------------------------------------------------------
\note{So anyway, given devices with that scaling behavior, we can derive the
maximum processing rate for reversible machines and see how it scales with
size.  Suppose we have a slab of computing material of area $A$ and
thickness or depth $d$, filled with devices of volume $V$.  We have to get
all the entropy within the volume out through the surface.  Well, it just
takes a little algebra to show that the rate scales up with the square root
of the thickness, according to this formula.  This contrasts with the
irreversible case where the rate only scaled with the area and the third
dimension was useless.  In our case, it is still somewhat useful, although
we still don't quite achieve the holy grail of a rate that scales with
volume, which we could do if we had purely ballistic reversible operations
that produced zero entropy.

Note that no matter what the values of the various constant factors for
entropy flux $F$, device volume $V$, reversible entropy coefficient
$\entco$, and irreversible entropy $S$, the reversible machine will always
be faster per unit area for machines larger than this diameter $d$ here.
In a minute we'll show some examples.}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\slidetitle{Speed per proc.\ in 3-D mesh computations}
\vspace{-.2in}
\centerline{\ctrfig{meshpic}{2in}
\begin{minipage}{3in}\normalsize
\begin{tabbing}
\color{lred}
Irr.: \=\color{lred}$t$$\sim$$L$$\sim$$\Ndiam^{1/3}$, $A$$\sim$$\Ndiam^{2/3}$\\
              \>\color{lred}{$S/t$$\sim$$\Ndiam^{-1/3}$}/prc., {$\sim$}{$\Ndiam^{2/3}$}/col.\\
\color{lgrn}
Rev.: \=\color{lgrn}$t$$\sim$$L$$\sim$$\Ndiam^{1/4}$, $A$$\sim$$\Ndiam^{1/2}$\\
	      \>\color{lgrn}$S/t$$\sim$$\Ndiam^{-1/2}$/prc., $\sim${$\Ndiam^{1/2}$}/col.
\end{tabbing}
\end{minipage}
}
\begin{mitems}
\item {\Reversible} advantage of $\Revad=\Exactly(\sqrt[12]{\Ndiam})$
	\mitem{\small $10^{36}\times$ more processors to increase
		rev.\ advantage by $10\times$!}
\vspace{-.06in}
\item \rcolor{$\Revad=\Exactly(\sqrt[6]{\Ndiam})$} if communication
	distance is $\sqrt{\Ndiam}$.
	\mitem{Current VLSI: $\gtrsim$ \dlr25B machines benefit}
\vspace{-.06in}
\item {\bcolor{$\Revad=\Exactly(\sqrt[3]{\Ndiam})$}} if $\entco = 0$.
\item \rcolor{$\Revad=\Exactly(\Ndiam^{\frac{1}{12} - \epsilon})$}
	to sim.\ any {\icolor{irrev.}}\ mesh.
\end{mitems}
\endslide
\note{
Depending on the constant factors of the technology, the reversible machine
may be faster to start out with.  Also, as components shrink down to 
the nano-scale, large numbers of processors become more feasible.
}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%
%%%
%%%		      E N G I N E E R I N G   P A R T
%%%
%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%				CONCLUSIONS
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\slidetitle{Summary of major contributions:}
\begin{mitems}
\item My work on circuits, ISAs, languages, algorithms:
	\mitem{Illustrates that reversibility is not hard to work with.}
\vspace{.1in}
\item My work on traditional reversible computing theory:
	\mitem{Helps establish overheads of full reversible computing.}
\vspace{.1in}
\item My work on scaling of physical machines:
	\mitem{Definitively establishes that substantial reversibility is
	best for high-performance computing in the long run.}
\end{mitems}

\endslide
\note{Definitively establishes for the first time!}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\slidetitle{Areas for future work}

{\normalsize
\vspace{-.2in}
Computer science:
	\begin{mitems}
	\item More full-featured reversible programming languages.
	\item Good languages for programming reversible meshes.
	\item More serial and parallel reversible algorithms.
	\end{mitems}
\vspace{-.1in}
Computer engineering:
	\begin{mitems}
	\item Better reversible serial and mesh processor designs.
	\item Short-term applications of partial reversibility\\in
		energy-limited environments.
	\end{mitems}
\vspace{-.1in}
Electrical engineering:
	\begin{mitems}
	\item Lower-resistance switches for reversible ICs.
	\item Better resonant power supplies for reversible ICs.
	\item Adiabatic circuit styles with lower overheads.
	\end{mitems}
\vspace{-.1in}
Physics:
	\begin{mitems}
	\item Better characterize fundamental physical limits.
	\item Work on efficient nano-scale reversible devices.
	\end{mitems}}
\endslide
\note{(No notes on this slide yet.)}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\slidetitle{Conclusion}

Reversible computing {\emph{will}} be a vital aspect of future computer
science and computer engineering.

\setlength{\parindent}{.5in}
Let's proceed to develop the theory and technology more vigorously, and
help facilitate that future!

\begin{center}
\fbox{
\begin{minipage}{5in}
\begin{tabbing}
{\textbf{Reversible computing:}}\\
\hspace{.25in}\=It's here,\\  % -eer, -ere, -ier, -ear
	      \>It's not {\emph{too}} queer,$^*$\\
	      \>Get used to it!
\end{tabbing}
\end{minipage}}
\end{center}

\vfill
{\small $^*$It goes both ways.}

\endslide
\note{(No notes on this slide yet.)}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\end{document}
