Hello, this is Steve Silva.
And today I'd like to cover how Signal Integrity Toolbox can
be used for regression analysis when used with SerDes Toolbox.
So let's begin.
So I initially built a transmitter and receiver SerDes
model using SerDes's toolbox, and I did that initially.
And then what I did is, I then turned it
into a Simulink model.
And finally, I went and I opened up the AMI Manager,
and I created a transmitter and receiver.
So those have already been built. I have those now.
So at this point, what I'd like to do is,
I want to take those models and put them into Signal Integrity
Toolbox for regression.
So what's cool is in this configuration block
where you opened up the block to then go
into the IBIS-AMI Manager, you notice over on the right,
there's another button there that's
Open Signal Integrity Link.
So just by pushing that, it now opens up
another window, which enables you
to be able to move the models that you just created over
into Signal Integrity Toolbox.
So here I'm going to create a new serial link project.
I'm going to title it something.
I'll just call it SS.
It's an NRZ model that I created.
And I'll just call it NRZ1.
OK, going to store it in my projects area.
And what I'm going to do is now click on this button, which
is Create Serial Link Project.
Click on that, and what it did is
it actually told me all the different things that it had--
that were already set in those models.
And I don't know if you noticed, but in the background,
it kicked off Signal Integrity Toolbox.
So it started it, it built up a basic topology
with some transmission line in the middle.
And now what it's doing is actually going in
and it's importing the transmitter and receiver
that I just created.
So you may not have noticed before,
but basically, these are the transmitter and receiver
that I had created.
I'm going to close this.
And so if you haven't used Signal Integrity Toolbox,
this is it.
It has an area for schematic to build up a topology
over on the left, and various elements that you
could use to build a topology.
This would be more if you're trying
to build up a specific channel.
But in our application, what I want to do
is basically test out those models.
I want to run some regression analysis.
I want to check out the different parameters
that I created in those models and verify
that those are creating the type of results that I expect.
And then if you look down below here,
this is actually the solution space.
So what this is, is it has all the different controls
that I created in my model.
So in this particular case, I had an FFE,
and it's showing the different taps there.
There's also in the receiver I had a CTLE DFECDR.
So just by clicking on those, it shows me
what those different options.
So let's, for instance, look at the receiver.
And over here on the CTLE, there are some different modes here.
So let's say, for instance, that I
would like to test out the various CTLE settings to verify
that they are giving the type of outputs that I would expect.
So there is, in this particular case, is a mode,
and which is set to--
it has options of being Adapt, Off, or Fixed.
So I'm going to set it to Fix.
Because what I want to do is, I want to basically check out
all the different settings.
And so they happen to be nine settings.
And if I do a right mouse, it'll actually
allow me to set all the values.
And what you'll see is it actually populates
all the different values.
So each column is now a separate simulation.
So I am going to basically run all those different settings
of the CTLE.
Now, I do have a DFE here.
And so if you look at the mode here, it's set to Adapt.
So in this particular case, it may make more sense
to turn that off, because I don't
want the DFE to be adapting to different values
to adapt based on the different CTLE cases.
I want to see each CTLE independently,
without the effect of the DFE.
So I'm turning that off.
So now I've got nine values here.
I can now actually go in and tell it to simulate.
So if you look up above here, this little waveform
is a Simulate button.
There are other ways to get to that as well, including
run the Run button here.
But right now I'm going to just go and hit
that Simulate button.
I'm going to save changes.
And there's a number of different options here.
But what I'm going to do is just do statistical analysis,
because that is relatively fast.
I could also do statistical and time domain,
but right now I'm just going to do statistical again,
for the sake of time.
Another thing that I should point out
is that I can run these simulations
in parallel based on the number of cores that I have.
In this particular laptop that I'm using,
I just have four cores.
So it's going to run four simulations in parallel.
However, if you were using this on--
if you had more cores in your machine,
if you had a server that had a lot,
or let's say you had a server farm,
you could have hundreds-- thousands, even--
that you could run in parallel.
That's very, very useful when it comes to regression,
because you can easily run into some pretty high numbers.
So what I'm going to do is just tell this to run.
It's initializing.
And what it's going to do is basically go and run
these simulations.
Again, as I had indicated, it's going to run the four of them
in parallel.
So it will not take that long for this to complete.
So the other thing I should mention
is, I just have one stage of CTLE.
So this is fairly easy.
It's just zero through eight, so it's nine different settings
that I'm then working on.
So that's really easy.
You may have multiple stages.
And if you have multiple stages--
obviously, if you look at all the permutations,
you could easily run into hundreds or even thousands
of simulations.
This can handle all of that.
This product.
It's-- again, this is a really good way to be able to check
out all the different settings on your model to make sure that
it's producing the kind of results that you expected.
So it's complete now.
And what you can see down below, each row
is a separate simulation.
So if I wanted to, I could actually
scroll over, look at maybe--
here's eye height.
If I click on it, I can look at the--
it'll actually order this by the maximum eye height.
And then if I select that particular one,
tell it to show--
I'll show bit error rate, which also includes the bathtub
curves, but I could also show the statistical eye.
And so here, I can see, OK, that's the eye that I got.
It was open.
Great.
But let's say in this particular case,
there are other ways to be able to look at the data.
Let's say that you've got 30 or 100 or more
of these different cases and you want
to be able to have a way to look at all of them.
So you can put all these on top of each other.
That's one way.
But we also have a way of plotting the metrics.
And you saw that we plotted a lot of different metrics.
In fact, I can just show results here.
There we have all sorts of metrics here.
We're going to show you the eye height, eye width, eye area.
We're going to show you all the different conditions.
It's going to show you--
for instance, if you left the DFE on adapt,
it's going to show you what those tap weights were.
If you left the CTLE on adapted, It'll
show you what that best CTLE curve that it
selected to be able to do that.
So what's nice is you have access to all these metrics,
and you can actually take advantage of them
when you're using plots.
So with plots, plots is a way that you can actually
create some scatter plots of all the different data
that you have.
So in this particular case, as I said,
we've got nine different simulations.
I'm going to select them all.
Actually, I'm going to go over here.
You see right here I'm looking at PDA.
In this particular case, I actually
want to look at the statistical results.
So I just selected that particular tab.
Now let me go and select all the cases.
And what I'm going to do is, I'm going to--
I want to plot eye height versus eye width.
So if I go to this little gear here and click on that,
it allows me to determine what the x-axis is going to be.
So if I open that up and scroll through,
what I could do is go and say, all right,
I want to look at the eye width on the x-axis.
So I have that.
And now, over here, this is my y-axis.
So again, I can go through here and say, OK,
where is my eye height?
I'm going to select that, and I am going to add that.
And so what you can see is that it's plotted on the eye height
on the y-axis, eye width on the x-axis.
And you can see the different--
how that all-- what the results were for each
of the different CTLE curves.
So this is a nice way to visualize your data
and be able to get a good feel for things.
And you may say, you know, I'm not sure
that that's what I expected.
So you can go and click on one of these buttons
and say, oh, let's look at this particular case.
This case, again, is not exactly what I was expecting to see.
Or maybe it was this guy up here, which is nine.
And then what it can do is look and say,
OK, well, nine is this on TTE_8.
That's the label for that particular simulation.
And now what I'd like to do is be
able to take that simulation back into Simulink for debug,
because I'm questioning whether this is giving me
the right results.
I don't know if that's the case or not,
I'm just saying as an example, let's say
that you were questioning this particular case.
So now what I can do is I can actually go back
to Signal Integrity Link, and what I can tell it to do
is, let's go and refresh the data that I ran.
And what you can see is, what it did is it it gave me--
it refreshes data, and now I have
all these different simulations to be able to choose from.
And the one that I saw that I was questioning
is this one, this TTE_8.
So I can select that, and now I can import that directly back
into Simulink.
And this will just take a few seconds.
And again, what it did--
you didn't see it because I put it on the other screen--
it gave me all the settings that I had for that.
And you can see it's CTLE config select number eight,
so that-- which matches what I had just done.
And now let's go back to Simulink.
Simulink is here.
And what's interesting is that the test case that I brought
back is, we did a lot of work to ensure
that everything that is moved between these two products
is exactly the same.
So for instance, the channel.
If I go-- sorry, if I go and open up the channel.
And if you look at the channel model, what is selected
is impulse response.
So this is from--
this is in its name, Signal Integrity Impulse.
So this is an impulse response from Signal Integrity Toolbox.
It could have been a loss model or whatever.
But what had happened is it actually
pushed this back into Simulink, so you didn't
have to do this manually.
Likewise, if you look at the stimulus, same deal.
Signal Integrity Stimulus.
This is a custom stimulus that's exactly the same as what was
in Signal Integrity Toolbox.
And so you'll be able to now again
have this exactly replicated.
Everything starts exactly in the same spot.
There was a lot of effort put in to ensure that you would
get the same results in both.
We can run things here as an example.
It'll then come up again with the same results.
Here you are, seeing that the eye diagram.
And when this completes, it's going
to show you what the statistical eye is,
and the time domain eye.
And there they are, with all the metrics.
OK?
But the beauty here is that you would be able to, for instance,
go into the source code, single step,
set break points, et cetera.
You also, for instance, could go into here
and put a scope maybe between the CTLE and the DFE.
That's something, obviously you can't
do when you're in an EDA tool that
has an IBIS-AMI model, because you can't see inside the model,
or you can't see between these blocks.
But since you created this model and you have the source code,
we are able to do it when you're in Simulink.
So this is some of the things I wanted you to see.
It's quite powerful to be able to utilize Signal Integrity
Toolbox when you're using SerDes Toolbox, particularly
for regression.
I hope this was helpful.
Thank you.