[SOUND].

So here we are in lecture ten. This is actually sort of the link between

the logic part of this course, and the layout part of this course.

So the course is called VLSI Cad Logic to Layout And the logic stuff.

We've done lots of bouillon algebra, computational bouillon algebra.

Representation, optimization, synthesis, lots of interesting stuff.

And on the layout side, we're going to be placing things.

We're going to be routing things. We're going to be figuring out how their

timing works. There's kind of a link and the link is

interesting. The link is actually a step called

technology mapping and you might think after all that interesting two level and

multilevel optimization that we did that what comes out is logic gates.

And the answer is no, what comes out of multilevel logic synthesis is a Boolean

logic network. Each of whose nodes is a sum of products

form, it's not gates and even worse it's not gates in the actual library of pieces

of gate technology that you get to put on the surface of the chip those are things

called standard cells. So, to start things off, we're just

going to talk about what actually happens at the end of logic synthesis.

And what you actually need to do to get started with layout.

I'm going to talk about the pieces of the optimization problem.

And what the problem is. So let's go talk about technology

mapping. So we are still in, sort of, in the

middle of our transition from logic to layout and one of the things I mentioned

in the last lecture is that there's really a missing step.

And because of our desire to actually start doing some interesting projects

with layout technology, we sort of inverted the order.

So, so we're going to go back to this now.

So, just to review what, what you know from the first half of the class is

computational Boolean algebra. A lot of really interesting

representations, some verification's, some synthesis technology.

This is the so called front end of the ASIC design process.

The back end is the layout the geometry end, and there's a big missing step which

is how do you actually go from the results of multilevel synthesis into real

gates for the layout and perhaps it's a bit of a surprise that you don't actually

get real gates as the result of multilevel synthesis and that's the topic

of this lecture. This stuff goes by a lot of different

names it's most formally called Technology Mapping, it's very frequently

called tech mapping just because it's shorter to say.

It's often just called mapping. depending on the application, sometimes

it's called fitting, sometimes it's called binding, but most commonly, the

stuff is called tech mapping or just mapping.

A nice reference for this stuff is sort of a broad reference of of a variety of

technologies for this stuff is the Nadia McKelly book, Synthesis and Optimization

of Digital Circuits. This is chapter 10 in that book.

So, let's talk about tech mapping, what is the problem?

The problem is that the multi-level model is still a little bit abstract.

So, you know, what happened in the multi-level synthesis technology that we

talked about. We figured out the structure of the

boolean logic network. And so in my, my little example here,

which has input's a, b, c, d. Three nodes in the network, X equals b

plus c, Y equals aX, Z equals Xd. We figured out the right high level

structure of the network. You know, what the nodes are and how

they're connected. And we also did ESPRESSO-style 2-level

simplification on the inside of each of these nodes, the yellow nodes in there,

or so, we optimized them well, but this is not really gates.

And the, the thing to just be, be clear about is that.

This diagram below, those are not logic gates, those are nodes in a graph that

has a particular kind of a structure. The boolean logic network there could be

thousands of those bubbles in a real version of this as the result of

multi-level logic synthesis. What if everyone of those nodes has a

half a dozen or 10 or 15 literals in its sum of products form?

It's not real gates, and the question is how do you get it to be real gates?

So, suppose that you actually have a particular technology library.

And suppose that this is that technology library.

Now, frequently, when we talk about the technology library.

The library of discrete standard cells that we are allowed to use as our basic

logic elements. It's very frequently just called the

technology. So suppose this is the technology that I

get to use. I get to use a 2 input and gate.

AND2 input or gate and a slightly strange looking thing called an OA21.

Its a two input OR gate feeding one of the inputs of an and gate.

And the other one is just a standard input to the and gate.

It's a little bit complicated. So this is the so called complex gate in

our library. The big question that we need to figure

out how to correctly answer, is if I give the output of multilevel optimization, in

this case, my little bouillion logic network with the x-node, the y-node, and

the z-node. How do we build the two Functions, in

this case the y function and the z function.

Functions of a, b, c, and d, specified in this[UNKNOWN] logic network using only

these gates from our library. Now, just drawing this picture again here

in my new slide. So this is a simple example.

So I'm drawing the library as a two input and A2 input or.

And this 0A21 To input or feeding one of the inputs of an and gate.

I'm drawing it with big curly set brackets just to emphasize the fact that

its an important object that we get to, work with and manipulate and play with.

In order to effect our technology mapping.

And I'm coloring this in in yellow, just to highlight it.

What we need to do is look at our Boolean logic network and say, if I only get to

use this and gate, this or gate and this strange OA21 thing, how do I actually

Take the logic function specified in the bouillon logic network.

And turn it into real logic gates. And look, this is just a really simple

example. It's set up to be a simple example.

One of the ways I could do this is I could do this example here.

I'm calling this the obvious mapping because look, you look at the logic

network, the x node is an or gate. The Y note is an end gate.

The Z note is an end gate, maybe we should just make the X note an orgate

with inputs B and C. And connect the output of the orgates to

2 and end gates. And the top end gate has an input A.

And the bottom end gate has an input D. And one of them makes Y and one of them

makes Z. And that's really just pretty obvious.

Now where this stuff gets interesting is that there are.

Less than obvious mappings and I am calling this an un-obvious, may be a non

obvious mapping and in this mapping I use two of these OA21 gates.

So, to implement the Y function I actually do this as 1 OA21 with inputs a,

b, and c. A goes under the AND gate, b and c go

into the OR gate and for output z I go d into the AND gate and b and c go into

the OR gate and you are thinking. Well this is a little bit strange, and

I'm, I'm just putting a little kind of a question mark here on top of the two OR

gates I'll even write two question marks. it would appear that I've duplicated the

Or gate, why why would I do that? You know, why would I choose the

un-obvious mapping? And let me give you an answer.

Why would you choose the non-obvious mapping?

the answer perhaps is cost. Perhaps it is the case that the

un-obvious mapping is superior in some dimension that I can associate with a

number. So imagine that every gate in my

library[UNKNOWN] has a cost associated with it.

May be it's the amount of silicon area in the, in the standard cell gate, may be it

has something to do with the power. That means there are all kinds of ways of

creating matrix for this but you know low cost is better and so I am just putting

cost numbers. The AND2 has a cost of 2, the OR2 has a

cost of 3 and the OA21 has a cost of 4. These are entirely arbitrary and now

somebody has to figure out what the right costs are but now I have got a picture of

the obvious mapping on the left at the bottom, one or two ends.

And then I've got a picture of the un-obvious mapping 2OA21's at the right

and what we can see immediately is if I put the cost values on the cost mapping

the or costs three. Each of the ands cost three.

This entire mapping cost three plus three plus three that's nine, but what if I put

the cost values on the un-obvious mapping?

Well each of these OA21 gates costs four, and so, putting two of those together

costs eight, eight is better than nine, this is a better mapping now (no period)

This is a quite synthetic examThis is a quite simplified example.

But in the real world, where you have large[UNKNOWN] logic networks.

And you have things that have, you know, hundreds or thousands or tens of

thousands of gates in them. What the right answer is is not at all

obvious. You need some kind of metric to guide you

for what the. What the best answer is associate cost

with all of the gates. Map so that you choose the lowest cost

covering. The lowest cost mapping of the Boolean

logic network on to the library that's going to get you an answer that makes

sense. So, the other way of saying why you

choose a non-obvious mapping, the sort of the second answer is that you know the

non-obvious mapping has better complexity.

And really this is just sort of cost in a, in a different way.

So for example, your library might have a bunch of complicated gates, so-called

complex gates. The are really hard to map to by eye, it

is pretty easy to figure out where you can put in 2, put AND gate or to input OR

gate or input invert but I am showing you to realistic gate cells.

On the left I am showing you OR, AND and Invert structure, this is a so-called

OAI22. So, it's a layer of OR gates connected to

an AND gate with an inverter at the output that's why it's called OAI and the

an answer to the question. How many and gates, sorry, how many or

gates are there and what are their structure?

The reason it's called a two two, is that there are two such gates.

That's why there's two digits there. And each of those gates has two inputs.

So you see a two input or gate. And another two input or gate.

So, that's why this is a two two, and let's say that that costs 6.

And next to that, on the right, is an and or invert structure, a different one and

AOI221. Again, an input bank of and gates, then

an or gate, and then a invert, a bubble. In this case, how many or gates are

there? Well, there's kind of three.

Alright the first 1 has 2 inputs the second 1 has 2 inputs and the third 1 has

1 input and, and you know, kind of the obvious way to think about why I'm just

drawing a wire going into this Or structure this Or Invert structure is

that this is really sort of an AND gate with exactly 1 input going into it and

what's an AND gate with 1 input going into it it's a wire.

So this is an AOI-221. Imagine that the AOI-22 cost 6 and the

AOI-221 cost 7. An interesting thing to note, it seem the

OAI and the AOI gate structures are often very efficient at the transistor level.

A bit more efficient than actually discretely using some ends and[UNKNOWN]

and inverts. And you know, for small versions of these

complex gates. These things are actually a sometimes a

better cost match and its much, much more difficult to match where these things go.

To technology map where these things go which is why we need an algorithim so,

It's helpful to introduce what I'm just referring to as a mental model, a kind of

a conceptual way of thinking about what multilevel synthesis does.

This is what multilevel synthesis does. It structures the multiple vertex Boolean

logic network well. What does well mean?

It means that the number of bubbles the structure of the bubbles, the number of

layers of, of you know, bubbles between the input and the output.

The complexity of the logic inside each of the bubbles, you know, pretty good.

And so, you know, following up on that as it minimizes or as it optimizes the

macroscopic structure of the logic network it minimizes the sum of product

contents inside each vertex so that the two level form that each vertex wants to

implement is also well structured in terms of the number of literals in the

sort of the macroscopic. Graph structure is also good.

The big, important thing to note is that optimizing the macroscopic graph

structure of the logic network, and optimizing the sum of products contents

of all of those bubbles is not logic gates.

And in particular, it's not logic gates in the technology library you are

permitted To use, alright? So this result actually has an

interesting name, a new name. actually a couple of names that you may

or may not have heard of. This is often called uncommitted logic.

Which is to say, I have not committed this to a particular set of gates from my

technology library. It is also called technology independent,

because we often call the library that we get to use, the technology.

And when the stuff that pops out of multi-level synthesis is not mapped yet

to the technology. We say that it's technology independent.

And so I've just got a little picture down here, there's an X node, a W node, a

V node, the X and the W nodes go into the Y node.

The Y node is an output, the W and the V node go into the Z node, The Z node Is an

output. Just to sort of highlight this, what

multilevel synthesis does is it gives a good global structure to the nodes, the

X, the Y, the Z, the W and the V in this diagram.

And it gives a good local structure to the insides, the sum of products forms

the sum of products inside the nodes like Z.

But this is not logic gates. So what does technology mapping do?

Technology mapping does something sort of interesting in an interesting way.

The first thing we do typically, is we transform this into uncommitted logic

that is made up of only very simple gates, but real gates, alright.

So a very common way of doing this is to transform every sum of products

expression inside each node, into something very simple, like NAND and NOT

gates, and nothing else. So, I've got a little picture of my

network from the previous page, you know, X, Y, Z, W and V nodes.

And I've got the X node and the Y node highlighted.

We know that those are sum of products 2-level forms.

What do we do? We turn the X node into.

NOT gates, inverters, and NAND gates. Now, one of the things to remember from

way back when in Boolean algebra, is that if you have a sum of products form, you

know, with AND gates for each product term in a big OR gate connecting it, you

can replace every AND gate and the OR gate itself with a NAND gate, and it will

all work properly. It's sort of an interesting side effect

of the De Morgan laws for how compliments work.

And so we're going to take all of the AND gates in the products and replace them

with NAND gates, and we're going to take the output OR and replace it with a NAND

gate. And then we'll just put inverters

wherever we need the literals to be in the complimented form, and we're going to

build, X the node, as real gates, but real simple gates.

So we're going to build it all out of NOTs and NANDs.

And then similarly we're going to take the Y node and then we're going to build

that, out of NANDs and NOTs. And so, it's got, probably a different

number of products, so it's got a different number of the input NANDs.

It's got, maybe a different. You know number of products and so the

size of the output end is different. Its got complements on different places

on the literals and so then the inverter gates are in different places.

But again, I can build the contents of the individual node, which is a sum of

products form, simple two-level form, as nothing but inverters and NAND gates.

We're going to do that for every single node in this network and then we're

going to connect things so, the X node connects as an input to the Y node.

And I'm just making kind of an arbitrary assumption that it connects to one input

on one gate, it could connect to a whole (no period) Bunch of different places

going in to the y node. But the big important idea is that we

need to take a step away from the abstract form of the Boolean logic

network to something that's real. Gates and our first step is an

interesting simple step. We go from the sum of products forms to

nans and nots and we do that for every node in the Boolean logic network.

And so what we're going to get as a consequence of that is this.

Sort of complicated looking diagram here. Where the X node, the W node, the Y node,

the Z node, the V node. Each one of those things is replaced by

some combination of NAND gates for the product terms.

NOT gates for the literals that appear in complimented form in a big NAND gate at

the output to implement the two level form.

A two level not NAND form for every sum of products form, and then the sum of

products forms themselves are connected properly.

So, what I get here is one big, flat and I'm referring to that in a very

particular way, okay? One big flat network of NANDs and NOTs.

This is what you map, what flat means in this context is that the boundaries,

between the X node, the Y node, the W node, the Z node.

All of those things go away. So one of the really important things to

note is that it's not as though I'm restricted to take the gates in my

technology library. And map them against them against the

insides of every yellow bubble on this diagram.

No, I take the logic function specified by every node in the diagram.

I flatten it out into 2 level NAND, NAND not structure.

I connect up everything appropriately and I throw the bouillon logic network away.

This big messy looking logic network with all of these NAND gates and inverters,

this is what we map, this is what happens next.

So, this is our strange and complicated looking starting point multilevel

synthesis produces well the first thing it produced was a bullion logic network

model with well structured microscopic form and well structured sum of product

form and what we did was we in a sort of a dumb brute force simple minded way.

We push that immediately into real gates, but very simple gates, NANDs and NOTs.

This big network, that I'm again highlighting on the, on the pager here,

this is what we start with, this is what we're going to map.

And the big and interesting question for us is algorithmically, how do I transform

this big network of NAND gates and inverters, how do I map this thing onto

the standard cells in our library in some optimal way?

So, this is a pretty algorithm as it turns out, a very nice application of the

ideas from the computer science universe to a really interesting hard problem, in

the[INAUDIBLE] universe, so let's go see how that works next.

[SOUND]