The future of computing: a conversation with John Hennessy (Google I/O ’18)


[MUSIC PLAYING] JOHN HENNESSY: Boy, I’m
delighted to be here today and have a chance
to talk to you about what is one of the biggest challenges
we faced in computing in 40 years, but also a
tremendous opportunity to rethink how we
build computers and how we move forward. You know, there’s been
a lot of discussion about the ending of Moore’s law. The first thing to remember
about the ending of Moore’s law is something Gordon
Moore said to me. He said, all exponentials
come to an end. It’s just a question of when. And that’s what’s
happening with Moore’s law. If we look at– what
does it really mean to say Moore’s law is ending? What does it really mean? Well, look at what’s
happening in DRAMs. That’s probably a
good place to start because we all depend on the
incredible growth in memory capacity. And if you look
at what’s happened in DRAMs, for many
years we were achieving increases of about 50% a year. In other words, going
up slightly faster even than Moore’s law. Then we began a
period of slowdown. And if you look what’s happened
in the last seven years, this technology we were
used to seeing boom, the number of megabits per chip
more than doubling every two years, is now going
up at about 10% a year and it’s going to take
about seven years to double. Now, DRAMs are a
particularly odd technology because they use deep
trench capacitors, so they require a
very particular kind of fabrication technology. What’s happening in
processors, though? And if you look at the
data in processors, you’ll see a similar slowdown. Moore’s law is that
red line going up there on a nice logarithmic plot. Notice the blue line. That’s the number of
transistors on a typical Intel microprocessor at that date. It begins diverging,
slowly at first. But look what’s happened since
in the last 10 years, roughly. The gap has grown. In fact, if you look at
where we are in 2015, 2016, we’re more than a factor
of 10 off, had we stayed on that Moore’s law curve. Now, the thing to remember
is that there’s also a cost factor in here. Fabs are getting a lot more
expensive and the cost of chips is actually not
going down as fast. So a result of that is that
the cost per transistor is actually increasing
at a worse rate. So we’re beginning to
see the effects of that as we think about architecture. But if the slowdown
of Moore’s law, which is what you see all
the press about as one thing, the big issue is the end of
what we call Dennard scaling. So Bob Dennard was
an IBM employee, he was the guy who invented
the one transistor DRAM. And he made a prediction
many years ago that the energy, the power
per square millimeter of silicon would stay
constant, would stay constant because voltage levels
would come down, capacitance would come down. What does that mean? If the energy, if the
power stays constant and the number of transistors
increases exponentially, then the energy per transistor
is actually going down. And in terms of
energy consumption, it’s cheaper and cheaper
and cheaper to compute. Well, what happened
with Dennard scaling? Well, look at that
blue line there. The red line shows
you the technology improving on a standard
Moore’s law curve. The blue line shows you
what’s happening to power. And you all know. I mean, you’ve seen
microprocessors now, right? They slow their clock
down, they turn off cores, they do all kinds of things,
because otherwise they’re going to burn up. They’re going to burn up. I mean, I never thought we’d see
the day where a processor would actually slow itself down to
prevent itself overheating, but we’re there. And so what happens
with Dennard scaling is it began to slow
down starting about ’97. And then since 2007,
it’s essentially halted. The result is a big change. All of a sudden, energy,
power becomes the key limiter. Not the number of transistors
available to designers, but their power consumption
becomes the key limiter. That requires you to think
completely differently about architecture, about
how you design machines. It means inefficiency in the
use of transistors in computing. Inefficiency in how an
architecture computes is penalized much
more heavily than it was in this earlier time. And of course, guess what? All the devices we carry
around, all the devices we use are running off batteries. So all of a sudden, energy is
a critical resource, right? What’s the worst
thing that happens is your cell phone
runs out of power, your smartphone
runs out of power. That’s a disaster, right? But think about all the
devices we walk around with. They’re hooked up to battery. Think about the era,
the coming era of IoT, where we’re going to have
devices that are always on and permanently on,
which are expected to last 10 years
on a single battery by using energy
harvesting techniques. Energy becomes the key resource
in making those things work efficiently. And as we move more and
more to always on devices with things like
Google Assistant, you’re going to want your
device on all the time or at least you’re going to want
the CPU on all the time, if not the screen. So we’re going to have to worry
more and more about power. But the surprising thing that
many people are surprised by is that energy efficiency is
a giant issue in large cloud configurations. This shows you what the
typical capital cost would be like for a Google data center. You’ll notice that green slice
there, those are the servers. But look at the size
of that red slice. That red slice is
the cost of the power plus cooling infrastructure. Spending as much on power
and cooling as you’re spending on processors. So energy efficiency becomes
a really critical issue as we go forward. And the end of
Dennard scaling has meant that there’s
no more free lunch. For a lot of years,
we had a free lunch. It was pretty easy
to figure out how to make computation
more energy efficient. Now, it’s a lot harder. And you can see
the impact of this. This just shows you 40 years of
processor performance, what’s happened to uniprocessor, single
processor performance, and then multiprocessor performance. So there were the early years
of computing, the beginning of the microprocessor era. We were seeing about 22%
improvement per year. The creation of risk
in the mid-1980s, a dramatic use of instruction
level parallelism, pipelining, multiple issue. We saw this incredible
period of about 20 years, where we got roughly
50% performance improvement per year. 50%. That was amazing. Then the beginning of the
end of Dennard scaling. That caused everybody
to move to multi-core. What did multi-core do? Multi-core shoved the
efficiency problem from the hardware designer
to the software people. Now, the software
people had to figure out how to use those multi-core
processors efficiently. But Amdahl’s law came
along, reared its ugly head. I’ll show you some data on that. And now, we’re in
this late stage period where it looks like we’re
getting about 3% performance improvement per year. Doubling could take 20 years. That’s the end of
general purpose processor performance
as we know it, as we’re used to
for so many years. Why did this happen? Why did it grind
to a halt so fast? Well, think about what was
happening during that risk era where we’re building these
deeply pipelined machines. 15, 16, 17 stages
deep pipelines, four issues per clock. That machine needs to
have 60 instructions that it’s working on at once. 60 instructions. How does it possibly
get 60 instructions? It uses speculation. It guesses about branches,
it yanks instructions and tries to execute them. But guess what happens? Nobody can predict
branches perfectly. Every time you predict
a branch incorrectly, you have to undo all the work
associated with that missed prediction. You’ve got to back
it out, you’ve got to restore the
state of the machine. And if you look inside
a typical Intel Core i7 today, on integer
code roughly 25% of the instructions
that get executed end up being thrown away. Guess what? The energy still got burnt to
execute all those instructions. And then, I threw
the results away and I had to restore the
state of the machine. A lot of wasted energy. That’s why the single
processor performance curve ended, basically. But we see similar
challenges when you begin to look at multi-core things. Amdahl’s law, Gene
Amdahl wrote Amdahl’s law more than 40 years ago. It’s still true today. Even if you take
large data centers with heavily parallel
workloads, it’s very hard to write a big
complicated piece of software and not have small sections
of it be sequential, whether it’s synchronization or
coordination or something else. So think about what happens. You’ve got a 64 processor
multi-core in the future. Suppose 1%, just 1% of
the code is sequential. Then that 64 processor
multi-core only runs at the speed of
a 40 processor core. But guess what? You paid all the energy
for a 64 processor core executing all the
time and you only got 40 processors out of
that, slightly more than half. That’s the problem. We’ve got to breakthrough
this efficiency barrier. We’ve got to rethink
how we design machines. So what’s left? Well, software-centric
approaches. Can we make our
systems more efficient? It’s great that we have
these modern scripting languages, they’re
interpreted, dynamically-typed, they encourage reuse. They’ve really
liberated programmers to get a lot more code
written and create incredible functionality. They’re efficient
for programmers. They’re very inefficient
for execution, and I’ll show you
that in a second. And then there are
hardware-centric approaches, what Dave Patterson and I call
domain-specific architectures. Namely, designing
an architecture which isn’t fully
general purpose, but which does a set of
domains, a set of applications really well, much
more efficiently. So let’s take a look at
what the opportunity is. This is a chart that comes out
of a paper by Charles Leiserson and a group of colleagues
at MIT, called “There’s Plenty of Room at the Top.” They take a very simple example,
admittedly, matrix multiply. They write it in Python. They run it on an 18
core Intel processor. And then they proceed
to optimize it. First, rewrite it in C.
That speeds it up 47 times. Now, any compiler in the world
that can get a speed up of 47 would be really remarkable,
even a speed up of 20. Then they rewrite it
with parallel loops. They get almost a factor
of nine out of that. Then they rewrite it by
doing memory optimization. That gives them a factor of 20. They block the matrix, they
allocate it to the caches properly. That gives them a factor of 20. And then finally,
they rewrite it using Intel AVX instructions,
using the vector instructions in the Intel Core, right,
domain-specific instructions that do vector
operations efficiently. That gives them
another factor of 10. The end result is
that final version runs 62,000 times faster
than the initial version. Now admittedly, matrix
multiply is an easy case, small piece of code. But it shows the
potential of rethinking how we write this software
and making it better. So what about these
domain-specific architectures? Really what we’re
going to try to do is make a breakthrough
in how efficient we build the hardware. And by domain-specific,
we’re referring to a class of processors which
do a range of applications. They’re not like, for
example, the modem inside the cell phone, right? That’s programmed once,
it runs modem code. It never does anything else. But think of a set
of processors which do a range of
applications that are related to a particular
application domain. They’re programmable, they’re
useful in that domain, they take advantage
of specific knowledge about that domain
when they run, so they can run much more efficiently. Obvious examples, doing things
for neural network processors, doing things that focus
on machine learning. One example. GPUs are another example of
this kind of thinking, right? They’re programmable
in the context of doing graphics processing. So for any of you who have
ever seen that any of the books that Dave Patterson
and I wrote, you know that we like quantitative
approaches to understand things and we like to analyze
why things work. So the key about
domain-specific architectures is there is no black magic here. Going to a more limited
range of architectures doesn’t automatically
make things faster. We have to make specific
architectural changes that win. And there are three big ones. The first is we make more
effective use of parallelism. We go from a multiple
instruction, multiple data world that you’d see
on a multi-core today to a single instruction
multiple data. So instead of having
each one of my cores fetch separate
instruction streams, have to have
separate caches, I’ve got one set of
instructions and they’re going to a whole set
of functional units. It’s much more efficient. What do I give up? I give up some flexibility
when I do that. I absolutely give
up flexibility. But the efficiency
gain is dramatic. I go from speculative
out-of-order machines, what a typical high-end
processor from ARM or Intel looks like today,
to something that’s more like a VLIW, that uses
a set of operations where the compiler has decided
that a set of operations can occur in parallel. So I shift work from
runtime to compile time. Again, it’s less flexible. But for applications
when it works, it’s much more efficient. I move away from caches. So caches are one of
the great inventions of computer science, one of
the truly great inventions. The problem is when there
is low spatial and low temporal locality, caches
not only don’t work, they actually slow
programs down. They slow them down. So we move away from that to
user control local memories. What’s the trade-off? Now, somebody has
to figure out how to map their application
into a user controlled memory structure. Cache does it automatically for
you, it’s very general purpose. But for certain applications,
I can do a lot better by mapping those things myself. And then finally, I focus on
only the amount of accuracy I need. I’ve move from IEEE to the
lower precision floating point or from 32 and 64-bit integers
to 8-bit and 16-bit integers. If that’s all the
accuracy I need, I can do eight
integer operations, eight 8-bit operations in
the same amount of time that I can do one
64-bit operation. So considerably faster. But to go along
with that, I also need a domain-specific language. I need a language
that will match up to that hardware configuration. We’re not going to be able to
take code written in Python or C, for example, and extract
the kind of information we need to map to a
domain-specific architecture. We’ve got to rethink how
we program these machines. And that’s going to be
high-level operations. It’s going to be
vector-vector multiply or a vector-matrix multiply or
a sparse matrix organization, so that I get that high-level
information that I need and I can compile it down
into the architecture. The key in doing these
domain-specific languages will be to retain enough machine
independence that I don’t have to recode things, that a
compiler can come along, take a domain-specific
language, map it to maybe one architecture
that’s running in the cloud, maybe another
architecture that’s running on my smartphone. That’s going to
be the challenge. Ideas like TensorFlow and OpenGL
are a step in this direction, but it’s really a new space. We’re just beginning to
understand it and understand how to design in this space. You know, I built my first
computer almost 50 years ago, believe it or not. I’ve seen a lot of revolutions
in this incredible IT industry since then– the creation of the internet,
the creation of the World Wide Web, the magic of
the microprocessor, smartphones, personal computers. But the one I think
that is really going to change our
lives is the breakthrough in machine learning and
artificial intelligence. This is a technology
which people have worked on for 50 years. And finally, finally, we
made the breakthrough. And the basis of
that breakthrough? We needed about a million
times more computational power than we thought we needed
to make the technology work. But we finally got
to the point where we could apply that
kind of computer power. And the one thing– this is some
data that Jeff Dean and David Patterson and Cliff
Young collected– that shows there’s one
thing growing just as fast as Moore’s law– the number of papers being
published in machine learning. It is a revolution. It’s going to change our world. And I’m sure some of you saw
the Duplex demo the other day. I mean, in the domain
of making appointments, it passes the Turing
test in that domain, which is an extraordinary
breakthrough. It doesn’t pass it
in the general terms, but it passes it in
a limited domain. And that’s really an
indication of what’s coming. So how do you think
about building a domain-specific architecture
to do deep neural networks? Well, this is a picture
of what’s inside a tensor processing unit. The point I want
to make about this is if you look at this what
uses up the silicon area, notice that it’s not used
for a lot of control, it’s not used for
a lot of caching. It’s used to do things
that are directly relevant to the computation. So this processor
can do 256 by 256– that is 64,000
multiply accumulates, 8-bit multiply accumulates
every single clock. Every single clock. So it can really crunch
through, for inference things, enormous amounts of
computational capability. You’re not going to run
general purpose C code on this. You’re going to run something
that’s a neural network inference problem. And if you look
at the performance and you look at– here we’ve
shown performance per watt. Again, energy being
the key limitation. Whether it’s for your
cell phone and you’re doing some kind of machine
learning on your cell phone or it’s in the cloud, energy
is the key limitation. So what we plotted here is
the performance per watt. And you see that the first
generation tensor processing unit gets roughly more than
30 times the performance per watt compared to a
general purpose processor. It even does considerably
better than a GPU, largely by switching
from floating point to lower density integer,
which is much faster. So again, this notion of
tailoring the architecture to the specific domain
becomes really crucial. So this is a new era. In some sense, it’s
a return to the past. In the early days of computing,
as computers were just being developed,
we often had teams of people working together. We had people who were early
applications experts working with people who were doing
the beginning of the software environment– building
the first compilers and the first
software environment– and people doing
the architecture. And they’re working
as a vertical team. That kind of
integration, where we get a design team
that understands how to go from application
to representation in some domain-specific
language to architecture and can think about how to
rebuild machines in new ways to get this, it’s an
enormous opportunity and it’s a new kind of challenge
for the industry to go forward. But I think there are enough
interesting application domains like this where we can
get incredible performance advantages by tailoring
our machines in a new way. And I think if we can do that,
maybe it will free up some time to worry about another small
problem, namely cybersecurity and whether or not the
hardware designers can finally help the software
designers to improve the security of our system. And that would be a great
problem to focus on. Thank you for your
attention and I’m happy to answer any
questions you might have. [APPLAUSE] Thanks. AUDIENCE: Can you talk
about some of the advances in quantum and
neuromorphic computing? JOHN HENNESSY: Yeah. So quantum– that’s a
really good question. So my view of this
is that we’ve got to build a bridge from where
we are today to post-silicon. The possibilities
for post-silicon, there are a couple. I mean there’s organic,
there’s quantum, there’s carbon
nanofiber, there’s a few different
possibilities out there. I characterize them as
technology of the future. The reason is the people working
on them are still physicists. They’re not computer scientists
yet or electrical engineers, they’re physicists. So they’re still in the lab. On the other hand,
quantum, if it works, the computational power
from a reasonably modest sized qubit, let’s say 128 corrected
qubits, 128 corrected qubits, meaning they’re
accurate, that might take you 1,000 qubits to get
to that level of accuracy. But the computational
power for things that make sense, protein
folding, cryptography, of 128-bit qubit is phenomenal. So we could get an enormous
jump forward there. We need something post-silicon. We need something post-silicon. We’ve got maybe, as
Moore’s law slows down, maybe another decade or so
before it comes to a real halt. And we’ve got to get an
alternative technology out there, because I think there’s
lots of creative software to be written that wants
to run on faster machines. AUDIENCE: I just– at the
end of your presentation, you briefly mentioned how we
could start using hardware to increase security. Would you mind
elaborating on that? JOHN HENNESSY: Sure. Sure. OK, so here’s my
view with security. Everybody knows about
Meltdown and Spectre? First thing about
Meltdown and Spectre is to understand what happened
is an attack that basically undermined architecture in a
way that we never anticipated. I worked on out-of-order
machines in the mid-1990s. That’s how long that bug
has been in those machines, since the 1990s. And we didn’t even realize it. We didn’t even realize it. And the reason is that
basically what happens is our definition
of architecture was there is an instruction set. Programs run. I don’t tell you
how fast they run, all I tell you is what
the right answer is. Side channel attacks that use
performance to leak information basically go around our
definition of architecture. So we need to rethink
about architecture. You know, in the
1960s and 1970s, there was a lot of
thought about how to do a better job of protection. Rings and domains
and capabilities. They all got dropped. And they got dropped
because two things. First of all, we
became convinced that people were going
to verify their software and it was always
going to be perfect. Well, the problem is that the
amount of software we write is far bigger than the amount
of software we ever verify, so that’s not going to help. I think it’s time for architects
to begin to think about how can they help software
people build systems which are more secure? What’s the right
architecture support to make more secure systems? How do we build those? How do we make sure they
get used effectively? And how do we together–
architects and software people working together– create
a more secure environment? And I think it’s going to
mean thinking back about some of those old ideas and bringing
them back in some cases. AUDIENCE: After I took my
processor architecture class, which used your book– JOHN HENNESSY: I hope
it didn’t hurt you. AUDIENCE: Hopefully not. I had a real appreciation
for the simplicity of a risk system. It seems like we’ve
gone towards more complexity with domain-specific
languages and things. Is that just because
of performance or has your philosophy changed? What do you think? JOHN HENNESSY: No, I
actually think they’re not necessarily more complicated. They have a narrower
range of applicability. But they’re not more
complicated in the sense that they are a better match
for what the application is. And the key thing to understand
about risk, the key insight was we weren’t
targeting people writing assembly language anymore. That was the old way
of doing things, right? In the 1980s, the move was on. Unix was the first operating
system ever written in a high level
language, the first ever. The move was on from
assembly language to high level languages. And what you needed to target
was the compiler output. So it’s the same thing here. You’re targeting the output of
a domain-specific language that works well for a
range of domains. And you design the architecture
to match that environment. Make it as simple as
possible, but no simpler. AUDIENCE: With the
domain-specific architectures, do you have examples
of what might be the most promising areas
for future domain-specific architectures? JOHN HENNESSY: So I think the
most obvious one are things related to machine learning. I mean, they’re computationally
extremely intensive, both training as
well as inference. So that’s one big field. Virtual reality. Virtual reality and augmented
reality environments. If we really want to construct a
high-quality environment that’s augmented reality, we’re
going to need enormous amounts of computational power. But again, it’s
well-structured kinds of computations that could match
to those kinds of applications. We’re not going to
do everything with domain-specific architectures. They’re going to give
us a lift on some of the more
computationally-intensive problems. We’re still going to have to
advance and think about how to push forward general purpose,
because the general purpose machines are going to drive
these domain-specific machines. The domain-specific machine
will not do everything for us. So we’re going to have
to figure out ways to go forward on
that front as well. AUDIENCE: Professor, what do
we think about some emerging memory technology? How will it impact the
future computer architecture? Thank you. JOHN HENNESSY: Yeah, that’s
a really great question. So as we get to
the end of DRAMs, I think some of the more
innovative memory technologies are beginning to appear. So-called phase
change technologies, which have the advantage
that they can probably scale better than DRAM
and probably even better than Flash technologies. They have the advantage that
lifetimes are better, too, than Flash. The problem with
Flash is it wears out. Some of these phase change
memories or memristor technologies have the
ability to scale longer. And what you’ll get is probably
not a replacement for DRAM. You’ll probably get a
replacement for Flash and a replacement for disks. And I think that technology
is coming very fast. And it’ll change the way we
think about memory hierarchies and I/O hierarchy, because
you’ll have a device that’s not quite as fast as
DRAM, but a lot faster than the other alternatives. And that will change the way
we want to build machines. AUDIENCE: As a person, you think
about education quite often. We all saw Zuckerberg having
a conversation with Congress. And I’m excited to
see children getting general education around
computing and coding, which is something
that a lot of us didn’t have the
opportunity to have. Where do you see education, not
only for K-12, grad, post-grad, et cetera, but also
existing people in policy-making
decisions, et cetera? JOHN HENNESSY: Yeah. Well, I think first
of all, education has become a lifelong endeavor. Nobody has one job for
a lifetime anymore. They change what they’re doing
and education becomes constant. I mean, you think
about the stuff you learned as an undergrad and
you think how much technology has already changed, right? So we have to do more there. I think we also
have to make more– society needs to be
more technology-savvy. Computing is changing
every single part of the world we live in. To not have some understanding
into that technology, I think, limits your ability
to lead an organization, to make important decisions. So we’re going to have to
educate our young people at the beginning. And we’re going to have to
make an investment in education so that as people’s careers
change over their lifetime, they can go back and
engage in education. Not necessarily going
back to college, it’s going to have to
be online in some way. But it’s going to
have to be engaging. It’s going to have
to be something that really works well for people. AUDIENCE: Hi. Olly [INAUDIBLE] from BBC. Just wondered what your view is
on the amount of energy being used on Bitcoin mining
and other cryptocurrencies and that sort of thing. JOHN HENNESSY: Yeah. So I could build a special
purpose architecture to mine Bitcoins. That’s another
obvious example of a domain-specific
architecture for sure. So I’m a long-term
believer in cryptocurrency as an important
part of our space. And what we’re
going to have to do is figure out how
to make it work, how to make it work
efficiently, how to make it work seamlessly, how
to make it work inexpensively. I think those are all problems
that can be conquered. And I think you’ll
see a bunch of people that have both the algorithmic
heft and the ability to rethink how we do that, and
really make cryptocurrencies go quite quick. And then we can also build
machines which accelerate that even further, so
that we can make– a cryptocurrency transaction
should be faster than a cash transaction and certainly
no slower than a credit card transaction. We’re not there yet. But we can get there. We can get there
with enough work. And I think that’s where
we ought to be moving to. AUDIENCE: What do you think
the future operating system has to have to cope with this? JOHN HENNESSY: Yeah. The future of operating
system, you said, yes? Yeah. So I think operating
systems are really crucial. You know, way back
when in the 1980s, we thought we were going to
solve all our operating system problems by going to
kernel-based operating systems. And the kernel would be this
really small little thing that just did the core functions
of protection and memory management. And then, everything
else around it would be protected, basically. And what happened was
kernel started out really small and then they got
bigger and then they got bigger and then they got bigger. And all of a sudden, almost
the entire operating system was in the kernel, primarily to
make it performance-efficient. And the same thing
happen with hypervisors. They started really small
in the very beginning and then they got bigger. We’re going to
have to figure out how we structure complex
operating systems so that they can deal with
the protection issues, they can deal with efficiency
issues, they can work well. We should be building
operating systems which, from the beginning,
realize that they’re going to run on large
numbers of processors, and organize them in
such a way that they can do that efficiently. Because that’s the future, we’re
going to have to rely on that. AUDIENCE: In your
intro video, you mentioned this chasm between
concept and practice. And also in your
talk, you’ve mentioned that hardware is vital to
the future of computing. Given that most investors
are very hardware-averse, especially this day
and age, where do you expect that money to come from? Is that something that
will come from governments or private investing? How are we going to fund
the future of computing is really what my question is. JOHN HENNESSY: Yeah,
it’s a good question. I mean, I think
the answer is both. You know, certainly Google’s
making large investments in a lot of these technologies
from quantum to other things. I think government
remains a player. So government, you look at
how many of the innovations we’re used to. The internet, risk,
the rise of VLSI, modern computer-aided
design tools. All had funding basically
coming from the government at some point. So I think the government
should still remain a player in thinking about– what’s the one area the
government has probably funded longer than anybody else? Artificial intelligence. They funded it for 50
years before we really saw the breakthrough that came. Right? So they’re big believers. They should be funding
things long-term. They should fund things that
are out over the horizon that we don’t yet
really understand what their practical
implications may be. So I think we’re going
to have to have that and we’re going to have to have
industry playing a big role. And we’re going to have
to make universities work well with industry, because
they complement one another, right? They do two different
kinds of things but they’re complementary. And if we can get
them to work well, then we can have the
best of both worlds. AUDIENCE: You
talked a little bit about the difference
between the memory hierarchy and storage that is coming
up with these new memory technologies. Have you seen any
applications where the compute and the
storage get combined, kind of more like the brain? JOHN HENNESSY: Yeah, I
think increasingly we’ll see things move
towards that direction where the software takes care
of the difference between what is in storage and– “storage,”
quote unquote, right, because it may actually be Flash
or some kind of next generation memory technology–
and what’s in DRAM. What you need to tell
me is what’s volatile and when do I have to ensure
that a particular operation is committed to
nonvolatile storage. But if you know that, we’ve
got log base file systems, you’ve got other ideas which
move in the direction of trying to take advantage of a much
greatly different memory hierarchy, greatly
different storage hierarchy than we’re used to. And we may want to continue
to move in that direction, particularly when you
begin to think about– if you think about things
like networking or I/O and they become major
bottlenecks in applications, which they often
do, then rethinking how we could do
those efficiently and optimize the hardware,
but also the software. Because the minute you stick
an operating system transaction in there, you’ve
added a lot of weight to what it costs to get
to that storage facility. So if we can make that
work better and make it more transparent without
giving up protection, without giving up a guarantee
that once something is written to a certain storage unit
it’s permanently recorded, then I think we can make
much faster systems. AUDIENCE: So do you
see the implementation of a domain-specific
architecture being implemented as hetero type or do you see
it off-die, off-chip type implementations, or both? JOHN HENNESSY: I think both. I mean, I think it’s a
time of great change. The rise of FPGAs,
for example, gives you the opportunity to implement
these machines, try them out. Implement them in
FPGA before you’re committed to design a
custom silicon chip. Put it in an FPGA. Unleash it on the world. Try it out, see
how it works, see how the applications map to it. And then, perhaps,
decide whether or not you want to freeze
the architecture. Or you may just want to build
another next generation FPGA. So I think we’ll see lots
of different implementation approaches. The one thing we have to do– you know, there was a big
breakthrough in how hard it was to design chips that
occurred from about the mid-’80s to
about 1995 or 2000. Things have kind of ground
to a halt since then. We haven’t had another big– we need a big
breakthrough because we’re going to need many more people
designing processors targeting particular application domains. And that’s going to mean we need
to make it much easier and much cheaper to design a processor. AUDIENCE: I’m wondering,
as a deep learning engineer for a private
enterprise, what is my role in pushing forward DSA? JOHN HENNESSY: Yeah. Well, I think your role
is vital because we need people who really
understand the application space. And that’s really critical. And this is a change. I mean, if you think about how
much architects and computer designers, hardware
designers have had to think about
the applications, they haven’t had to
think about them. All of a sudden,
they’re going to have to develop a bunch
of new friends that they can
interact with and talk to and colleagues they can
work with, to really get the insights they need in order
to push forward the technology. And that’s going to be
a big change for us, but I think it’s something
that’s absolutely crucial. And it’s great for
the industry too, because all of a
sudden we get people who are application
experts beginning to talk people who are
software domain experts or talk to hardware people. That’s a terrific thing. AUDIENCE: You mentioned the
performance enhancements of domain-specific languages
over Python, for instance, but they’re also
much harder to use. So do you think software
engineering talent can keep up in the future? JOHN HENNESSY: Yeah. I think the challenge will be– the gain we’ve
gotten in software productivity in the
last 20 or 30 years is absolutely stunning. It is absolutely stunning. I mean, a programmer
now can probably write 10 to 100 times more code
than they could 30 years ago, in terms of functionality. That’s phenomenal. We cannot give that up because
that’s what’s created all these incredible applications we have. What we need to
do is figure out– all of a sudden, we need a new
generation of compiler people to think about how do we
make those run efficiently. And by the way, if the
gap is a factor of 25 between C and
Python, for example, if you get only
half that, that’s a factor of 12 times faster. Any compiler writer
that can produce code that runs 12 times
faster is a hero in my book. So we have to just
think about new ways to approach the problem. And the opportunity
is tremendous. AUDIENCE: Are there any
opportunities still left in x86 as far as, like, lifting
the complexity of the ISA into software and exposing
more microarchitecture to the compiler? JOHN HENNESSY: It’s tough. I mean, I think the Intel
people have spent more time implementing x86s than anybody’s
ever spent implementing one ISA, one instruction set ever. They’ve mined out almost
all the performance. And in fact, if you look at the
tweaks that occur, for example, they do aggressive
prefetching in the i7. But you look at what happens
with prefetching, some programs actually slow down. Now on balance, they get a
little bit of speed up from it, but they actually slow
down other programs. And the problem
right now is it’s very hard to turn that
dial in such a way that we don’t get overwhelmed
with negative things. And I see my producer telling
me it’s the end of the session. Thank you for the
great questions and for your attention. [APPLAUSE] [MUSIC PLAYING]

35 thoughts on “The future of computing: a conversation with John Hennessy (Google I/O ’18)”

  1. Imagine guys like him, Eric Schmidt, Larry Page, Demis Hassabis sitting in the same room talking about things. Do you really think you can imagine?

  2. The Unity Entity-Component-System is a great move towards better architecture. It allows SIMD architecture at a high level.

  3. Alphabet needs a stronger Hardware company. One that invests in ARM chipset design (if the Qualcomm Centriq ARM Server chipset is for sale then take over that team as one of the projects), new lower power sunlight readable (but also full color/saturation) displays (Pixel Qi, Clearink), new batteries (Broadbit), flexible electronics (IDTechEx), energy harvesting… etc. to invest some of the Alphabet cash into mass manufacturing new technologies and new components and letting the whole market embrace new better technologies, instead of the whole market just waiting for and following Apple.

    I hope John Hennessy pushes Google/Alphabet to make and use new ARM processors in servers, Chromebooks, Desktops, with better/more optimized Linux for ARM on a new mass market Snapdragon 845 (or better) Chromebook with LTE at below $499. In fact I think Google needs to launch $100 One Laptop Per Child priced ARM Chromebooks with not just a perfect web experience but with all Linux and Android productivity apps through Crostini. Google's OLPC would be a separate Alphabet company aiming to bring a laptop with meaningful educational content/apps to every child in the world as soon as possible.

    On my YouTube channel, I interviewed Sophie Wilson, Steve Furber, Hermann Hauser, Sir Robin Saxby even Masayoshi Son (cause I video-blog on my ARMdevices website), I hope some day I could interview David Patterson, John Hennessy and Gordon Moore.

  4. Fantastic talk! I'd be curious to hear more about what people think about FPGAs. If every laptop and phone had an FPGA built in then we can start having compilers target the FPGA. This would span the chasm between domain specific applications (TPUs, GPUs) and general purpose computing. Moving memory closer to the computation for data indexing (trees) would be another win.

  5. Wow, John Hennessy is an excellent successor to Eric Schmidt. This guy is locked in on his role and is great with questions from younger generations. Alphabet is going to eclipse Amazon and Apple.

  6. I leave my phone an and I don't always turn my laptop off, and I'm even thinking why I turn my main computer off.

  7. The last question reminded me of the topic of cache misses, which is sort of "new", and today's languages doesn't really help programmers write programs the right way even if it's possible. If languages, compilers and tools would help "automatically" optimize in such ways, that'd be a nice start. I've also been quite interested in the topic of domain-specific languages, and I'm sort of surprised this topic isn't hotter than it is. Then again, enormous amount of time, work and money are put into writing apps built on HTML and JavaScript. It's ridiculously inefficient. I think people got lazy because of excess computational power. In the early days, a lot of creative solutions found their way into products to squeeze out as much as possible. Programmers have gotten sloppy.

Leave a Reply

Your email address will not be published. Required fields are marked *