You should complete the VLSI CAD Part I: Logic course before beginning this course. A modern VLSI chip is a remarkably complex beast: billions of transistors, millions of logic gates deployed for computation and control, big blocks of memory, embedded blocks of pre-designed functions designed by third parties (called “intellectual property” or IP blocks). How do people manage to design these complicated chips? Answer: a sequence of computer aided design (CAD) tools takes an abstract description of the chip, and refines it step-wise to a final design. This class focuses on the major design tools used in the creation of an Application Specific Integrated Circuit (ASIC) or System on Chip (SoC) design. Our focus in this part of the course is on the key logical and geometric representations that make it possible to map from logic to layout, and in particular, to place, route, and evaluate the timing of large logic networks. Our goal is for students to understand how the tools themselves work, at the level of their fundamental algorithms and data structures. Topics covered will include: technology mapping, timing analysis, and ASIC placement and routing. Recommended Background: Programming experience (C, C++, Java, Python, etc.) and basic knowledge of data structures and algorithms (especially recursive algorithms). An understanding of basic digital design: Boolean algebra, Kmaps, gates and flip flops, finite state machine design. Linear algebra and calculus at the level of a junior or senior in engineering. Elementary knowledge of RC linear circuits (at the level of an introductory physics class).
Basics
Loading...
Do curso por University of Illinois at Urbana-Champaign
VLSI CAD Part II: Layout
36 classificações
Explore Related Videos
At Coursera, you will find the best lectures in the world. Here are some of our personalized recommendations for you
Na lição
ASIC Placement
In this second part of our course, we will talk about geometry. We will begin with an overview of the ASIC layout process, and discuss the role of technology libraries, tech mapping (a topic we delay until the following week, to let those who want to do the Placer programming assignment have more time), and placement and routing. In this set of lectures, we focus on the placement process itself: you have a million gates from the result of synthesis and map, so, where do they go? This process is called “placement”, and we describe an iterative method, and a mathematical optimization method, that can each do very large placement tasks.
Conheça os instrutores
Rob A. RutenbarAdjunct Professor
Department of Computer Science
[SOUND].
So here we are in lecture nine and as you know the title of the course is VLSI Cad
Logic to Layout. So we had to get to layout eventually and
here we are. So we've done lots of work in the boolean
algebra logic hardware universe. We've done representation, we've done
optimization, we've done synthesis. We sort of know how to make the gates.
Right, what we have to do next is we have to figure out geometrically where they go
and how we connect them. And so, we're going to move into the part
of the course where we get to talk about layout.
And we're going to start by talking about ASIC placement And so this is the
question of, now that I have a million gates, where do they go on the surface of
the chip? And so, what we're going to start with is
a sort of an overview of just what's the terminology?
What does the technology landscape look like?
What do we have as the basic placeable elements?
What's the technology components of this problem.
And then we can start actually talking about some interesting new geometric
algorithms. So, let's go look at the basics to get us
started with ASIC placement. So, this is a little bit of review here.
What do you know? I think you know a lot about
computational boolean algebra at this point, I think you know a lot about
representation You know a little bit of verification.
You know a lot of things about synthesis and optimization for two-level and
multilevel logic. This has a name.
This is called the front end of the ASIC design process.
So if you, you want to think of this at a very high level.
Give a high level description. You know, something that comes in, in say
VHDL or Verilog. There's some compiler like things that
happen that, that turn that into a form that, to which we can actually apply, all
of the synthesis and verification technologies that you now know.
And what comes out of that is a connected set of gates and wires in the Technology
associated with your chip, that has a name that's called a netlist, we'll,
we'll revisit that in a minute. What you don't know is the next part of
the ASIC design process, which is called the back end problem.
Turning these IC's into masks to build real chips this is called layout.
it's also called physical design, which is a named that is kind of a hold over
from a very early[INAUDIBLE] . Days of the the electronic business when
people were putting little you know, little packages on big boards in order to
build any kind of electronic system. We're going to start with something
called the placement problem, which is how do you locate those gates on the
surface of a Of a piece of silicon. But, but to do that,
I need to back up just a little bit. So, in honest fact, there's 1 missing key
step. So, what comes out of multi level
synthesis is not actually gates. it's a Boolean network model.
It's a, it's a graph of nodes. Each of which is a, a 2 level sum of
products form. as I'm showing here I'm actually picking
one of the pictures from one of the assignments for this class and and just
showing it here. What comes out of multi-level synthesis
is actually not logic gates. We have to do something to turn it into
logic gates. And there's a key step.
And that step is called Technology Mapping.
That transforms the abstract form of the above network.
The result of multi-level logic synthesis into real logic gates and wires.
I'm going to cover this next week and not this week because.
We're actually going to do a programming assignment in this mook, that's a placer.
And I need to just get you the, the methods and models and mathematics and
algorithms of placement in order to let you do that.
So we're doing this a little bit out of order, and I just want to explain why
we're doing that. So, placement for ASICs.
We're going to focus on the most common tasks in, in layout, and what we're
going to focus on are layout tasks associated with row based standard cells.
So, synthesis and mapping is going to give us a net list of gates and wires.
Our job is to place them optimally in rows on regions of the chip and to route
the wires that connect everything. So this is a chip I showed way back when
at the very early, lecture. introduction to the class.
And I'm just highlighting. Two two regions on this chip that are
actually rows of standard cell logic. that's the job that we're going to do
when we start looking at the layout problem.
Now, what do you start with? You start with something called a
standard cell library. And this is a slightly confusing name.
So, just to very clear about this. This is a library.
And the things that are in this library are themselves called standard cells.
And a standard cell is a basic logic gate or a small logic element, that you get to
use to create the substance of your design.
So, the way to think of this is, this is the set of allowed logic elements you get
to use to build your chip, so you get, for example, you know, inverters, and you
get NAND gates with, let's say, you know, a couple of different numbers of inputs,
and you get NOR gates, and you get some little tiny Useful things that are, are
used all over the place like one bit ADDERs and two to one multiplexers, and
so on. And you also get sequential elements
things like d flip flops and registers. Why do we restrict ourselves to operating
with these, if you will, predefined elements?
And the answer is that there's lots of complicated electricity stuff going on at
the transistor level. Each of these cells in our standard cell
library hides all of this difficult electrical detail and presents a simple
geometric abstraction that we can use for our geometry design algorithms to work
with. So, an interesting question, how big is a
standard cell library? how many cells are there in a cell
library? And the interesting answer is they're
often pretty big. you have to have all of the logic
functions that you need. You have to have all of the input and
output variants, in terms of how many pins.
There are often several timing variants things that are fast but have higher
power or slow and have lower power. Different sorts of electrical drive
strengths, and so on. At a very high level the way to think
about this is that there's a lot of different logic functions.
So, you know, and and nand, or and nor, xor and xnor.
Things like that. And a bunch of different kinds of flip
flops. There's a lot of fan in and fan out
variants, so you probably want NAND gates that have two inputs and three inputs and
four inputs for example. Ditto for all the other kinds of basic
logic gates. There's a lot of different timing
variations. There's a lot of different kinds of flip
flops. there are a lot of, if you understand
anything about how Testability is done on a modern chip with scan chains.
There are a lot of different scan variations on flip flops.
And if you don't know what that means, don't worry about it.
I'm just sort of mentioning it as to one of the things that adds variation to a
cell library. And there's a lot of different electrical
variants, let's say drive strength kinds of variants.
You multiply all those things together, it's easy to have a library with 1,000 or
more. Standard cells.
How should we think about what's inside a standard cell?
think of a standard cell as a, as a, as a geometric container for the circuits, the
electrical circuits, the transistor-level circuits that you need to make the logic
functions. So inside the cell, there's complex
devices, you know, transistors and wires and things, complex geometric mask things
happening right down at the, sort of the nanoscale surface of the, of the
integrated circuit. Complicated electrical issues, but
outside the standard cell, it's a box with pins.
And that sounds you know, a little simple minded, but really in order for the
geometry things that we need to be able to do to optimize at the level of
millions and millions of standard cells and wires, we need a simple abstraction.
And the abstraction that it's a box with pins is going to work for us.
let's look at a few real standard cells. This is in an older technology.
This is 130 nanometers CMOS. You know, where we are today you know,
lots of things are at the 32 nanometer node.
There are some things, you know, popping out at the 22 nanometer node now things
at sort of 15 nanometer node are in, are in, are in research.
So this is an, an older technology. these are some pictures of some things
from a website, www.vlsitetechnology.org, that has a bunch of open-source cells, so
if you want to actually look at Transistor level designs.
And, and, you know? Geometry designs.
It's just an interesting place to go. 2 things that I want you to take away
from this. The first is, here's a first fact.
They all have the same height. And the reason is that we want to be able
to arrange them in rows. And when we arrange them in rows, we can
snap them together, if you will. We can.
Put the power grids down so that the, the vdd and the vss power connect, we can
make all of this stuff work. The second geometric fact to be aware of
is they have very different widths as I'm, I'm showing you here.
So, the cell on the left hand side is a NAND2, that's a, that's just a two input
NAND gate, and the cell on the right is and Edge-triggered, D Flip Flop, so it's,
it's going to have, a D input, it's going to have a queue and a queue bar
going out, it's going to have a clock. Right, going in the D Flip Flop is much,
much bigger than the NAND. And the reason it's got a lot more
transistors in it to be able to do what it does.
So standard cells, they all have the same height.
We snap them together in rows. And they have different widths because
they have different circuit complexity. In a realistic context, what we are
talking about is placing the insides of one block on a, on a big system on chip
kind of design. So here's an actually a real SOC design
courtesy of my My friend and colleague Larry Pileggi at Carnegie Mellon
University, Big, system on chip designs, big SOCs are
often designed hierarchically, which means you figure out how, what each of
the blocks is supposed to be, and then you may have, you know, hundreds of
blocks that get put together in an appropriate way.
To make a big SOC, and what's being shown in this particular picture of an SOC
that's in the middle of being designed is there's a lot of pins around the edges
and those are all the little slice things with the little colors.
And then there's a bunch of blocks inside the SOC and some of them have a colored
boarder, but they're gray. Those things are actually big memories,
and you don't get to play with their insides.
They get generated by some other kinds of CAD tools.
But the things that have blobs of primary color, those are actually blocks that are
being placed. And the reason that there are sort of
funny shapes of the colors is that we are actually tagging and color coding where
the blocks came from in the original source.
let's say the verilog or the VHDL, and we're seeing sort of where did the gates
actually go when we're doing the layout task.
For our purposes, you can pick one of those rectangles and say, how am I going
to place the however many hundred thousand or you know, half a million or a
million gates Associated with the insides of one of those blocks.
How am I going to arrange them in rows in some optimal fashion?
How am I going to place them in rows, and how am I going to route them?
That's actually what we're going to look at.
So, let's just talk for a little bit about the size distribution on standard
cells. The big thing to note is that small cells
dominate but there's lots of wide cells, too.
So this is an old example, but a published example.
It's about 206,000 gates from an IBM ASIC.
It's actually part of an IBM processor, way back when, in the late 1990's.
It's done by Jens Vygen Of the University of Bonne.
And this would be, sort of, 1 small block today on a, on a big SOC.
You know, a big SOC may be, you know, 20 million gates, 50 million gates, 100
million gates, a really, really big one. And what I'm showing on this graph is
that on the horizontal axis, we are showing, basically, the width of the
cells. Right, and you can think of the width as
being how many pins wide is the cell, as I showed on the previous example.
And on the vertical axis we're showing the number of cells, and so there's about
200,000 cells, 200,000 gates in this design.
And what you're seeing is something is one cell wide, that's just some sort of a
filler, but you know, you know how many cells are two pins wide, oh something
like, you know, 27,000, three pins wide, maybe 27,000 Four, five, six pins wide, a
few more than 20,000, seven pins wide, only 10,000, eight pins wide, again
25,000, that's a nice round number, nine, ten, 11, 12, 13, 14 pins wide, you know,
just a couple thousand, but then an interesting bump out around 17 and 18
pins wide, you know, more than 10,000 cells, and then you know, down in the
noise. The way you can sort of think of this is
that most of the small gates dominate, you know, the things with the two, three,
four inputs, that's mostly what the net list is made out of.
and just as a concrete example you know, what is this bar over here with 27 or
28,000 things that are two pins wide? and the answer is that you know, that's
an inverter, right, because as a standard cell that's got one pin for the input and
one pin for the output. And what's this peak out here with things
that are 17 or 18 standard cell widths wide.
Probably, that's a mix of things, like little registers with, maybe, 4 bits,
maybe 8 bits depending on how it was how it was implemented.
But that's also probably things like flip flops, you know, with a D input and a Q
output in a clock. So, mostly small cells dominate.
Very small cells, things like two input NANDs, two input NORs, one input, one
output inverters, but there's also a lot of things like flip flops in a modern
design. there's an interesting, sort of an aside
that I just wanted to share with everybody.
it's, it's sort of the way people use language to talk about chip size.
So this is a strange question. How bit is a 100 million gate ASIC?
And surprisingly, it is almost not 100 million gates.
the numbers are usually referred to in one of two ways, and the most common is,
let's say, equivalent small gates. So the idea is that because there are
lots of things on the surface of the chip, little gates, big gates,
Adders, flip flops, all kinds of other stuff,we sort of transform them into an
equivalent number of let's say 2 input NAND gates.
So if we, as I'm showing you in the middle of this picture so here's a two
input NAND gate, so how big is that? Well that's like one input.
And here's something called a AOI22, so its 22 input and, a two input OR and an
inverter, that's an atomic gate in a lot of cmoss libraries.
That's maybe four gates in size. And then I've got a picture of a one gate
adder, how big is that? maybe six gates.
And then I got a picture of a D flip flop, how big is that?
maybe ten gates, maybe more. the idea is you take all of your real
logic elements, the ones you get to use in your technology library.
And you sort of replace them with an equivalent number of gates.
And when someone says, how big is your design, you add up those numbers of
2-input NANDs and you use that. So, there's two things that people might
tell you when they tell you how many millions of gates in their ASIC.
One of them is gates. This is usually an equivalent little NAND
gates, so this is usually a big number. The other is a term you might not have
heard before called instances. This is the number of things you really
used in your library. This is the number of things you really
placed, you know, the number of things you actually had to find space for and
put wires to connect to on the surface of your chip.
And the basic rule today is that the instances is basically the gates divided
by 4 or 5. So, you know big round numbers, if
someone tells you they have a hundred million gate ASIC, how many instances are
there? Probably 20 million.
Five is probably the best number to use today, and honestly, they might not even
all be gates. people might be taking their very large
static RAM, SRAM memories and other blocks and converting those into, an
approximate equivalent number of gates in terms of their silicon area, so If
someone tells you they have a 100 million gate ASIC, they probably don't actually
have 100 million logic gates. They probably have a maximum of 20
million, might be less. So, what's our first problem as we
actually talk about layout in in our MOOC?
Our first problem is placement, and I've got a nice little diagram here.
Up at the top, there's a picture of a netlist.
The netlist goes through a box that says placement.
And that turns into a bunch of rows of little gates and standard cells.
That goes into a box that's called routing.
And suddenly, little wires appear that connect all the gates.
What does a placer do? A placer starts with a netlist of gates
and wires and the output is the exact location of each gate.
You know, where does it go? And the goal of the placer is to be.
Creating a placement that allows us to route, which is to say to connect all of
the wires. That is the most fundamental plask...uh,
the most fundamental task of the placer. Is this hard?
Oh yes, very, very, hard. A bad placement could lead to an enormous
amount of extra wire, and if you have more wire, your chip may need to be
bigger in order to be able to fit those wires.
And it's going to be slower because there's delay to get your signal through
those wires, and there's going to be more power because taking voltages up and down
on all those wires is actually you know, consuming energy.
It's very bad. And if the placement is extremely bad,
the next tool in the flow, which is called the router, might actually be
unable to connect all the wires or to meet the timing requirements of your
chip. So, placement is an extremely important
task. Very critical task.
Very critical for us to get right and so, it's the first task we're going to focus
on. So, let's go talk about how we really do
placement.
[MUSIC]
Explore nosso catálogo
Registre-se gratuitamente e obtenha recomendações, atualizações e ofertas personalizadas.
O Coursera proporciona acesso universal à melhor educação do mundo fazendo parcerias com as melhores universidades e organizações para oferecer cursos on-line.
© 2019 Coursera Inc. Todos os direitos reservados.
