Hello, and welcome to the Physics World weekly
podcast.
In this episode, we meet Hannah Earley,
a mathematician and physicist
who's cofounder of a company that is commercializing
reversible
computing.
This paradigm has the potential
to use less energy than conventional
computation,
something that could prove very useful for power
hungry
AI applications.
Hannah talks to Physics World's Margaret Harris about
the physics,
engineering, and commercialization
of reversible computing.
My guest today is Hannah Early, the chief
technology officer and cofounder of a startup called
VerComputing that aims to build a new type
of computer architecture based on reversible operations.
Hello, Hannah. Welcome to the podcast.
Hi, Margaret. Thanks for having me on.
We talk a lot about quantum computing on
the Physics World Weekly podcast. But while I
understand that Ver's work is in some sense
based on quantum principles,
you're not building a quantum computer in the
usual sense.
Maybe you could start out by giving our
listeners just a quick introduction to what reversible
computing is.
Yeah. Of course. So, in fact, actually, there's
not very much similarity to what we're doing
in quantum computing at all except for the
reversible principles at at the core of it.
So, obviously, in
quantum computers, it's very necessary that all the
operations are unitary. And as a consequence, if
you're doing any classical computation on a quantum
computer,
that means that it is logically reversible, which
means that you can always from once they
get back to the previous state. And that's
very necessary in quantum computing because otherwise, you're
going to get decoherence.
In what we're doing in classical reversible computing,
it's not kind of a physical necessity,
but what it lets us do is,
if we can not only make this computer
logically reversible,
but also also physically reversible,
then that in principle lets us access
significantly lower energy operations
than than conventionally. So this dates back to,
some work from
Rolf Landau and if you trace it back
even further to Leo Szilard and,
Maxwell himself
on
what the energy costs or thermodynamics
are when it comes to information processing.
And so
whilst we're not necessarily trying to break what
is has become known as the Landau limit,
it turns out that there is this limit
when you want to
erase information on on the energy cost of
that. And this turns out to be a
pretty small number,
k t log two, k being Boltzmann's constant,
and t being temperature,
which is something like 10 to the minus
21 joules. So it's a very small amount,
but it turns out that, one, we're actually
kind of closer than you might expect to
this limit, but, two,
even without trying to break this limit, by
making your operations physically reversible, you can significantly
reduce the energy cost of general operations even
just when applying it to what we currently
can do today in competing.
Why is it that you have this
incredible
improvement in energy
efficiency, I guess, if you have
reversible operations?
Yeah. So, it really depends on
the computational medium you're talking about. So for
example, in in CMOS computing, computing, which is,
what we're doing at Ver computing,
when you
do an irreversible operation in a CMOS logic
circuit,
what this corresponds to is,
so you take your logical circuit, and you
have some inputs that are currently supplied to
it and some output. And then later when
you want to change that input,
you're pretty much just you know, there might
be some latch upstream or or some register.
You change that input,
and it's going to then
kind of propagate through that circuit.
And as it propagates through, it's going to
change transistor connectivity, and it's going to then
end up effectively flushing all of these signal
energies
into ground or into VDD.
And as a consequence,
you get
this characteristic
c v squared dissipation.
And so this is kind of just taken
as most axiomatic in in CMOS computing.
And for a very long time, this was
kind of negligible. And for the amount of
computation we wanted to do, we had more
than enough energy, and so it wasn't really
seen as an issue.
But when you change, at least the CMOS
logic circuit to operate reversibly,
what that corresponds to is adding in a
step before you change the input, and that
step is to
first recover that signal energy that is stored
in the gates of transistors.
And you so you recover that,
probably storing it generally in in some kind
of reservoir,
maybe even in inductors magnetic field. And then
once you've recovered that technology, you've put that
circuit into a neutral state, and then you
can supply
new inputs into that circuit.
And when you do that, you're no longer
there's a little bit more complexity to it,
but effectively, you're trying to avoid setting up
these
quite significant potential differences that lead to dissipation.
This is dissipation of heat. Right? You know,
this is this is heat heat that is
generated when you erase
a register of bits and just dump that
information
to the environment.
Yes. Exactly.
How does reversible computing solve that problem?
Reversible computing really solves that problem by just
not generating that heat to begin At the
same signal energy is flowing through the circuit,
at least when you're doing reversible CMOS.
But because you're able to
in principle, you can recover
a large amount of that energy. The amount
of that energy that you can recover depends
on how much you slow down the computation.
I I probably want to revisit that a
bit later in what that means because it
sounds like our computation is much, much slower,
and, that's actually not necessarily the case.
But depending on
this factor by which you slow it down,
that kind of linearly,
proportionally reduces the amount of energy that gets
dissipated in that operation.
There's also other circuit components that enable this
whole thing to work and those have their
own dissipation. But as long as you optimize
those and optimize the the slowdown,
you can save
I I won't say arbitrarily
much energy, but really in CMOS, the limit
seems to be about 4,000 times.
And, you know, you still have the same
currents flowing through. It's just that instead of
having those currents
dumped to ground when when you start a
new computational cycle, you much more carefully manage
that energy flow.
And you mentioned you wanted to talk a
bit more about it's not that this is
a really slow computation, because that's the traditional
way you do things without,
exchanging heat. You do things adiabatically. It's a
really slow process. It doesn't sort of disturb
the system in any way. Is that not
what you're doing?
It actually is, but I'll explain why that's
not surprisingly slow.
So adiabatic operations are kind of the core
of what we're doing. So usually your signals
in in regular CMOS are as close to
a square wave as you can get. And
we change those waves to be more what
we like to call trapezoidal. So you have
kind of flat regions where signals are stable,
and then you have these linear ramps over
a relatively long rise of full time. And
that's where you kind of get the adiabaticness
of what we're doing. So
our approach is really a combination of both
adiabatic computing and reversible computing.
The reason why this is not horrendously slow,
and this was really the worry
back in
the nineties when people were kind of first
trying to build,
these reversible computers. And and then it actually
was more of a problem. The reason why
this isn't a problem now is that
this rise time
is measured as a fraction of
or as a sorry, as a multiple rather
of the transistor's intrinsic switching time.
And for modern processes, these can be on
the order of picoseconds or even less than
picoseconds,
I e, terahertz frequencies.
We obviously do not run our computers at
terahertz frequencies, and there are very good reasons
for that. And this kind of dates back
to the end of de noid scaling back
in 2005
when before then, computational frequency seemed
to double with a cadence similar to Moore's
law, and and then afterwards, it kind of
stagnates that a few gigahertz.
But the transistor switching frequency kept kept going
up. And so as long as we are
significantly slower than this hundreds of gigahertz or
even terahertz,
then that's enough to get reversible
efficiency. So we could operate in the gigahertz
range, and that's still gonna give you 50
or a 100 times energy saving
in principle. I I did also mention that
there are other circuit components that enable adiabatic
switching, and
those are pretty difficult to get good efficiencies
on. And so those kind of end up
dominating,
but we can still get quite significant energy
savings.
But this sounds like, you know, really fascinating
sort of concept in academic research. What is
it that made you decide a few years
ago now that now is the time to
actually start commercializing this technology?
Yeah. Great question. So it was kind of
a almost serendipitous encounter between me and and
my cofounder, Rodolfo Rustini.
So I was doing a PhD in a
number of unconventional computing topics, but, reversible computing
being being one of the primary
ones in that. And I had
one of the
topics I was looking at was what was
the ultimate future of computing. And I kind
of became very convinced
that
all future computers had to be
at least involve a significant amount of reversibility
if you wanted to keep increasing the performance
of your larger and larger computers.
Like, certainly
in the long future, if you are thinking
about building
matrioshka brains and and other huge computers, then
there's really no way to deal with the
heat unless they use reversible computing. What's the
sorry. I'm gonna stop you there. What's a
matrioshka brain?
Yeah. So I I might be mixing this
up with Jupiter brains, but the idea is,
you know, maybe these very advanced civilizations
far beyond what what we are at
might start to build
computers the size
of moons or planets or even larger astronomical
systems.
And
the scaling laws turn out that if you
just want to build
a computer using irreversible techniques, you can only
really cover the surface of some system in
in computational matter. And that's purely because of
the thermodynamics.
If you're generating
a certain amount of heat and you want
to radiate that, then you're going to get
some kind of area metric scaling law. If
you want to go above that scaling law,
then you really need to get this control
over heat, and the only,
approach that gives you that is is reversible
computing.
So I was looking maybe a little bit
longer term, back then than what is maybe
commercially practical right now. But I could also
see that kind of
it may be the case that in the
nearer future, this might be relevant. And my
cofounder
was coming from a different direction. He was
coming from very much looking at
the growth of AI. And and this was
back in 2021.
So, you know, AI was becoming increasingly relevant,
but we hadn't
quite seen the explosion that we have in
in the last couple years. It's been very
fast how much this has increased. It feels
like it's been around forever now. But
he saw that
we were potentially going to get a crisis
in hardware, not least because there were
increasing signs that Moore's Law
is being predicted a number of times in
the past, but perhaps this really was the
time that Moore's law was going to come
to an end. And so these combination of
factors
and a serendipitous meeting between us through a
mutual friend led us realizing that maybe
the solution to
AI's
upcoming energy problem would be reversible computing. And
I wanna link back to what Feynman was
saying in the nineteen eighties about reversible computing,
which was that
as long as you are
significantly above the Landau limit, above a 100
or 300 times the Landau limit, there's no
need for you to ever consider reversible computing
because
we've got back in the eighties, we've got
so much energy available, and our computation is
already so inefficient, etcetera, and we're not really
doing all that much computation.
But now it's forty, fifty years later, and
it turns out that we are actually at
a few 100 times the landau limit. And
so
while it may not have been right in
the nineties back when MIT built some reversible
chips, it it looks like now might be
the time.
Okay. You talk about a chip. Right? Let's
just get quite physical. What do logic gates
look like in this technology? What do circuits
look like in reversible computing?
Yeah.
So this is a great question. And
it can be kind of hard to figure
out what this is from the literature. And
in a sense, this is because it really
depends on on what you're building. So, obviously,
I'm going to talk a lot about what
this means in CMOS. But, traditionally, when you're
looking at reversible computing, you see that
relevant gates are gates or gates. And it's
asking if you're building
classical computations in a quantum computer. These are
the gates that make sense. What are those
gates? Yes. Those those terminologies our listeners might
not have heard of before. Sorry. Yes. In
computers, when you're doing reversible classical computing,
your gates need to be need to have
the same number of inputs as outputs.
And so
whilst in
irreversible computing,
the universal gate might be, say, the NAND
gate, which is two input, one output.
In
reversible computing, this universal gate might be something
called the Tefoli gate. This was discovered in
the nineteen eighties. It's well, you could argue
it was discovered earlier, but it wasn't named
in the nineteen eighties at least. And this
is a three input, three output gate. And
what it does is quite simple. Its first
two inputs are just copies across, so let's
call them a, b, and c. The first
two outputs are a and b.
The third output, we just XOR,
the third input c with the product
of both the logical and of a and
b.
And in quantum computing, you might also see
this referred to as controlled controlled not or
CC not.
So
a lot of the reversible circuits you see
out there make use of of these kinds
of gates.
But seamless, it is interesting, and it actually
deviates
quite a bit from from this paradigm.
And the reason for that is
unlike in, say, a quantum gate where kind
of as you put information
into the inputs, it gets
directly transformed in place to outputs.
It's not really how
switching based logic works.
So if you look at, say, a NAND
gate well, actually, let's take a NOT gate
in CMOS. Right? Because that seems like an
intrinsically reversible gate, and logically, it is. But
physically, it's not necessarily
reversible in CMOS. And the reason for this
is you supply the input, to one side
of of your not gate,
and the output gets generated.
But you haven't consumed the input. You haven't
transformed the input into the output. And so,
actually, you should more think of the not
gate in CMOS as a one input, two
output gate because it kind of intrinsically
keeps around a copy of the input.
And in that sense,
actually, all CMOS gates
just conventionally
have the ability to be used reversibly.
And so the gates we use at fair
computing are not that different from the conventional
gates you'd find in in any standard cell
library.
Rather, we
operate them quite a bit differently from how
they're conventionally
driven. And so we take a lot greater
care of how signals propagate, and we add
a little bit of extra circuitry around so
that we can
kind of both compute a gate, so generate
its output from its input, and also decompose
a gate so that whilst holding its input,
you can actually
ungenerate the output. And so adding this control
lets us transform pretty much any regular gate
into a reversible gate. There's a little bit
more implementation complexity, but but actually the gates
and the logic itself are not not very
much different from how you would build a
conventional
C West chip.
And I think I read that you sort
of store the energy in some sort of
resonator in order to do the uncomputation to
do the reverse operation to make the gate
reversible. How does that work?
Yeah.
So this is the other critical component. So,
you know, it's not enough to just make
your circuit
theoretically logically reversible. You need to add in
some extra circuitry so that you can actually
operatively reverse the the operations.
So one of the simplest approaches is so
as you mentioned, you know,
most of these implementations use a resonator. So
one of the simplest could be, say, an
LC resonator like you might encounter in first
year physics, so just an inductor and a
capacitor.
Now one of the key
developments of the,
MOSFET transistor of, the kind of transistors that
came before is that
its gate is effectively a capacitor.
And so when you supply inputs to a
seamless logic cell,
what you are doing is storing energy on
the capacitors of the gates of of that
logic cell, and then the logic cell will
then generate outputs, and those outputs will
then drive additional capacitive gates.
And so if you can arrange your circuit
so that
these capacitive gates
are effectively
one big capacitor
and then you tie that to an inductor,
then
you're already most of the way there because
now you've built an LC circuit. And so
at some points in time, that,
inductor will have all of the energy stored
within it, and the capacitors will be in
some well, they will have no energy stored,
and they will be computationally neutral.
And then at a later time, that energy
from that inductor can move onto the capacitive
gates of those transistors.
And then those gates are computationally active and
you can generate an output.
And then
because this is an oscillatory circuit, they can
then pull that energy back. And so that's
kind of the fundamental principle.
That's not enough because, you know, you need
to
then control how the outputs are generated. And
so really you have kind of a number
of these, not too many, but a number
of these LC circuits. And so kind of
you divide your computation into
a few different stages,
and then each of those stages has their
own.
Yeah. We we do it a little bit
more compactly, but as a first order, you
could imagine that each of these stages has
their own inductor.
Okay. What stage is Vericomputing at now? I
think you're in the process of building a
chip?
Yeah. So we last year, we got our
seed funding. We built our team, and we
actually
fully taped out our first well, we taped
out our first test chip. It's not come
back yet. So hopefully, we'll be able to
announce that and its results in in the
future. But yeah. So we've
developed our first test chip. And what
that chip does is
really
kind of bring together
all of the different aspects
of what a potentially commercially viable reversible chip
would look like. So back in the nineties
and more recently, people have made purely reversible
chips and that the logic is reversible, but
it doesn't actually have the capability to recover
signal energy. And so our test chip, when
we get it back and announce it, should
be able to actually recover that energy within
the system.
And then we should be able to, well,
measure how much how much better it is.
And then what we're doing now is so
so we want to commercialize this technology as
quickly as possible. And
really within the next few years, we think
that there's
a urgent demand for more energy efficient computing,
but also energy efficient computing that doesn't look
that different. Obviously, there are a lot of
different
various approaches to kind of making computing more
energy efficient, but reversible computing's advantage, and this
was actually something it was criticized for in
the past that
changes have been made, is that
so reversible computing as we implement it has
the same
programming
approach as conventional.
And we, you know, have a little bit
of
extra complexity in in the logic to account
for this. But effectively,
you know, if you build, say, an inference
accelerator,
you should be able to just plug this
into a server, launch PyTorch, and have it
run. And so what we're doing this year
is
we are trying to
take the print source we implemented in our
test chip and really make them
scalable so that we can build powerful chips
and
improve the efficiency of all the individual components.
So last year was more making a proof
of concept or proof of viability, and and
now we're trying to get it to be
actually something that people would want to buy.
And what does success look like for you
in the next few years?
Yeah. So in the next few years, particularly
by, you know, 2027,
2028,
starting to
sell actual
reversible
chips
that,
you know, you could, say,
put in
a data center or put in a mobile
device. You know, there are lots of different
applications. Right? You can make this much more,
obviously, it's intrinsically more energy efficient. But
what that means, you know, whether you want
this in a low power device or whether
that just means you want to do even
more computation for the same amount of energy,
that's that's something you can play around with.
So success would look like we want to
be selling products in a few years. We
want this to actually be
to move out of the lab, out of
academia. We want this to be something
that is commercially viable.
And then we want to build off that
and keep improving the energy efficiency of this
and really get to a new scaling law,
something
akin to Moore's law, something not going to
be identical. You know, scaling down of transistor
size pretty much hitting its its limit, but
we think that, you know, at least energy
efficiency, you can keep doubling that every cell
phone,
maybe all throughout there every two years, but,
that could be ambitious, could be unambitious.
And we want to then,
effectively in twenty years time, have computation that's
a few thousand times more energy efficient than
it is today.
And the ultimate success would be if this
becomes kind of a fundamental part of how
you build
most computing systems. There's always gonna be a
need for traditional irreversible computing, and the reason
for that is
that reversible computing excels
at parallel tasks. But for very serial tasks,
it's
this slowdown
becomes more more significant. So there's always gonna
be a need for kind of a CPU
type architecture, but perhaps anything which is parallel,
might lead to a more reversible architecture. And
maybe in ten, twenty years' time, every computer
you buy might have a little bit of
reversibility or maybe a lot of reversibility in
it.
That's fascinating. We'll have to check back with
you in a few years. It'll be interesting
to see particularly how this develops in parallel
with quantum computing, which I think, likewise, people
who work in that field
recognize that quantum computers are not gonna do
everything,
but they may do some things well. It'll
be interesting to see
an evolution maybe beyond the sort of monolithic
CMOS technology and monolithic irreversible CMOS technology that
we have at the moment towards this quantum
area and towards this,
reversible computing
paradigm.
Yeah. It'd be really interesting to see where
heterogeneous
architectures
end up going. And so obviously, we've had
a huge amount of success in the traditional
digital programming model, and
there were a lot of advances that and
that will probably never go never go away.
But
we've made a lot of progress in the
last
few decades in quantum and analog and photonic
and and all of these other computational paradigms.
And so
I I can very much see that maybe
in in the future, you'll
not just have a CPU and a GPU,
but maybe all of these other,
types of computation
embedded. Maybe not into your into your cell
phone, but maybe into
supercomputing
clusters and data centers at least.
Hannah Early, thank you much for joining us
in the podcast.
Thank you, Margaret.
That was Margaret Harris in conversation with Hannah
Earley,
cofounder
of VerComputing.
You can find out more about Hannah's journey
from getting a PhD in applied mathematics and
theoretical physics
to becoming the cofounder
of a start up company
in the career section
of Physics World.
Just look for the headline,
Ask Me Anything.
Hannah Earley. I love theory, but seeing an
idea get closer and closer to reality
is great.
I'm afraid that's all the time we have
for this week's podcast. Thanks to Hannah and
Margaret for a fascinating
introduction to reversible computing,
and a special thanks to our producer, Fred
Isles.
We'll be back again next week. See you
soon.