5/26/2015 The IDDQ Mystery

The IDDQ Mystery

Doc Id: 003843   Product: TetraMAX Last Modified: 03/10/2003 

The purpose of this article is to provide a comprehensive introduction to IDDQ Testing and generating
IDDQ Test patterns with TetraMAX

Table of Contents
Chapter One: The Meeting
Chapter Two: The Seminar
Chapter Three: IDDQ Introduction
WHY DO IDDQ TESTING
IDDQ CAN HELP IN THE FOLLOWING WAYS
IDDQ TEST METHODOLOGY
IDDQ TEST FLOW
Chapter Four: The Plan
Chapter Five: What is IDDQ Testing?
WHAT IS IDDQ TESTING SUMMARY
Chapter Six: Why do IDDQ Testing?
IDDQ TESTING DETECTS FAULTS OTHERWISE UNDETECTED
Chapter Seven: IDDQ Testing Advantages and Disadvantages
IDDQ TESTING ADVANTAGES
IDDQ TESTING DISADVANTAGES
IDDQ DESIGN FOR TESTABILITY
Chapter Eight: What is an IDDQ Fault
Chapter Nine: IDDQ Test Flow
TETRAMAX TEST FLOW OUTLINE
DRIVING TETRAMAX FOR IDDQ TESTING
Chapter Ten: What is PowerFault
POWERFAULT DEFINITION
POWERFAULT USES
Chapter Eleven: How to use PowerFault
POWERFAULT FLOW WITH TETRAMAX IDDQ FAULT MODEL
POWERFAULT FLOW WITH TETRAMAX IDDQ STUCK­AT ATPG

Table of Figures
Figure 1: IDDQ Defect
Figure 2: Short­to­Ground Defect
Figure 3: Defect Causes High IDDQ
Figure 4: TetraMAX IDDQ Flows

Chapter One ­ The Meeting
Steve walked out of the meeting with his head held low. He walked slowly, staggering down the hallway. I approached him
to find out what's going on. "Hi Steve how was the meeting?" He looked up, eyes glazed, "They put me in charge of DFT on
the Samson project". "That's great!" I exclaimed. "How can you say that?" he said. "I've only helped with one DFT project
and now Bob and the other program mangers think I'm a test expert. Don't they realize how hard it is to come up to speed
on DFT compiler, BSD compiler, and TetraMAX? Not to mention they want me to do IDDQ testing as well. I don't even
know what IDDQ testing is! " With that he turned and walked away.

Chapter Two ­ The Seminar
The next day Steve was feverishly looking through some papers. "What are you looking at?" I asked. "Schedules,
schedules and more schedules" he explained. "Bob just dropped these off and asked me to review them. In addition, Bob
told me the customer has asked to move the schedule up by a couple of weeks. This job keeps getting better and better,"
he sighed.

https://solvnet.synopsys.com/retrieve/print/003843.html 1/9
5/26/2015 The IDDQ Mystery
"Well, I have some good news for you. Synopsys is having a free Synthesis Seminar next week. Looking over the agenda,
a section on Test and IDDQ testing is going to be discussed! This will be a great way to get introduced to IDDQ. I plan on
attendin. Do you think you can make it?" About this time Rick rounded the corner. Rick is the project lead for the Samson
program. He is a nice guy but very rigid when it comes chitchat in the hallways. "Hi Rick," I said. "I was telling Steve about
the Synopsys Seminar next week" I explained. "Oh", Rick murmured. "The seminar is going to go over the latest features
of the new version of tools. I plan on going and thought Steve might benefit from it as well". With that I ducked out of the
cubicle.

Chapter Three ­ IDDQ Introduction
The seminar was about to start. I looked around and didn't see Steve. I thought, I guess he couldn't make it. The
presenters started discussing RTL synthesis followed by Physical synthesis. Information was provided on new features,
scripts, and known bugs with workarounds. Great data, but my interest was in the Test portion. Unlike Steve I had worked
on several DFT programs. I felt pretty good about using DFT and BSD compiler but was still shaky using TetraMAX. I
hadn't had to do IDDQ testing before, so I was interested in learning about this area. Besides, in the back of my mind I was
thinking I might get pulled onto the Samson program.

Finally the Test section began. Audrey, the presenter, was very knowledgeable with an impressive background. She started
off by asking the question "Why do IDDQ Testing?" My ears perked up.

Why Do IDDQ Testing

"IDDQ Testing can detect certain types of circuit faults in CMOS circuits that are difficult or impossible to detect by
other methods.
IDDQ testing, when used with standard functional or scan testing, provides an additional measure of quality
assurance against defective devices."

"In addition" she continued, "IDDQ can help in the following ways":

IDDQ Can Help In the Following Ways

"Improve defect coverage beyond stuck­at test
resistive bridges
leaky transistors
Provide coverage of "untestable" stuck­at faults
redundant logic
black­box "shadow" faults
Screen for excessive current draw in low­power devices
Wireless communications and computing, medical electronics, intelligent sensors, remote applications
Identify marginal parts that may later fail burn­in testing
fewer early­life failures"

She went on.

"IDDQ Faults are applicable to static CMOS designs
IDDQ current is observable at the tester power supply
Only a few IDDQ test strobes yield high fault coverage
IDDQ testing detects defects beyond stuck­at fault scan test"

And added "The IDDQ Test Methodology is as follows":

IDDQ Test Methodology

"Inside TetraMAX (pattern generation)
Generates vectors using stuck­at or IDDQ fault model
Writes out at a test bench that contains PowerFault PLI calls
Inside VCS (strobe selection/pattern verification)
Strobe Selection
IDDQ Profiler
Generate IDDQ fault coverage reports
Verification
Verilog simulation with PowerFault PLI routines
Verify quiescence at strobe points
Analyze and debug non­quiescent states"

She continued saying "the IDDQ Test Flow is shown here".

https://solvnet.synopsys.com/retrieve/print/003843.html 2/9
5/26/2015 The IDDQ Mystery
IDDQ Test Flow

TEST> set fault ­model IDDQ
TEST> add faults ­all
TEST> run atpg ­auto
TEST> write patterns testbench.v ­format verilog_single_file ­replace
VCS +acc_2 ­p
          $IDDQ_HOME/lib/iddq_vcs.tab \
$IDDQ_HOME/lib/libSysSciTask.a \
­l mylog testbench.v

I took notes as quickly as I could, but oh how my head hurt.

Chapter Four ­ The Plan
The next day I knew I had my work cut out for me to learn more about IDDQ testing. As I was planning how to acquire this
data Steve stopped by. "Hi Steve I missed you at the seminar" I said. "I planned on going," Steve replied, "but at the last
minute, Rick decided to call a meeting. He insisted the entire team attend. How was the seminar?" "It wasn't bad", I
exclaimed. I described all the different subject areas that were covered, all the new features I could remember and what
food was available. "Synopsys really goes all out on the food" I told him.

"What about IDDQ?", he asked. "Oh, the presenter was great. She really knew what she was talking about. She briefly
went over all aspects of IDDQ testing. Hey, do you think it would be possible to work with you with this portion of your
assignment?" "That would be fantastic," he said. He seemed relieved.

I started working on a plan. First I decided to learn more about IDDQ testing and why it's important. Next, I'll tackle what is
an IDDQ fault. Then, I'll jump into IDDQ test methodology and test flow.

Chapter Five ­ What is IDDQ Testing? 
In the TetraMAX IddQ Test User Guide that IDDQ testing can detect circuit faults by measuring the amount of current
drawn by a CMOS device in the quiescent state, when the amount of current should be very small. Okay great, what does
that mean? Let's see, thinking out loud, "quiescent means inactive or still ­ so if I apply a state, stop the clock and
measure the leakage or quiescent, current then that would be an example of IDDQ testing".

At this point Steve walked in. "Hey Steve listen to this" I said. "Stuck­at fault testing is based on propagating logic values
to an observable point. Then measuring the logic value in the voltage realm. But IDDQ testing is based on the
measurement of supply or return current instead of voltage levels". Steve explained what he had found. "Current­based
tests use an interesting effect of a CMOS­based design, which is that virtually no leakage occurs after the transistors in a
gate element have completed switching. So the leakage current of a chip in which all the transistors have completed
switching should be the sum of the quiescent currents for each transistor in the chip."

"Okay," I said, "then to measure current you would have to wait some amount of time to allow the transistors to stop
switching. Which means the clocks would have to be stopped and the measuring point would have to follow a waiting period
to allow the switching to settle down."

We were feeling good about what we had learned when in walks Rick. "What's going on?" Rick wanted to know. "Oh, we're
just talking about what is IDDQ testing" I told him. Steve added, "IDDQ testing is a current­based test that measures the
quiescent current of CMOS­based designs after a period of time when the clock has been stopped". He continued, "IDDQ
testing detects CMOS faults that other tests cannot". "Good work" Rick told us, then he added "I'm glad to see the two of
you working together. Frank, I've requested your help on this program and you know the schedule is tight." With that he
turned and left.

We both signed. "Well lets pool our resources and develop a 'what is IDDQ Testing' summary," I suggested. Working
together, cutting and pasting, modifying and drawing, a comprehensive summary and illustration emerged.

What is IDDQ Testing Summary
IDDQ testing is a testing technique that detects circuit faults by measuring the amount of current drawn by a CMOS device
in the quiescent state (a value commonly called "IDDQ"). A device's passing/failing decision criterion is based on the fact
that a CMOS circuit does not draw any significant current when in a stable situation. In a quiescent state, only the leakage
current flows, which in most cases can be neglected. The fact that under certain conditions a significant current flows when
the device under test is in the quiescent state indicates the presence of a physical defect in the circuit. Such a defect that
causes an increase in current may have a direct influence on the functionality of the circuit or may affect the lifetime
reliability of the circuit negatively (early lifetime failure). The following picture illustrates this behavior.

https://solvnet.synopsys.com/retrieve/print/003843.html 3/9
5/26/2015 The IDDQ Mystery

Figure 1: IDDQ Defect

Chapter Six ­ Why do IDDQ Testing?
Before trying to sell the idea of IDDQ testing, we decided to spend some time looking at current test methodologies. We
focused on functional and stuck­at testing techniques because they are the traditional testing methods. Steve developed a
summary on functional testing while I worked on scan testing.

Steve read me his summary. "For functional testing, a tester applies a sequence of input data and detects the results in
the sequence of output data. Then, the output sequence is compared against the expected behavior of the device. An
advantage of functional testing is that it exercises the device as it would actually be used in the target application.
However, this type of testing has only a limited ability to tests the integrity of a device's internal nodes."

"Hmm, then with functional testing only, an internal defect could slide by undetected. Not good," I added.

"Here is what I found out about scan testing," I told Steve. "The methodology for scan testing is all the sequential elements
of the device are connected into chains and used as primary inputs and primary outputs for testing purposes. Using
automatic test­pattern generation (ATPG) techniques, you have the capability to test a much larger number of internal
faults than with functional testing alone. The goal of ATPG is to set all nodes of the circuit to both 0 and 1, and to
propagate any defects to nodes where they can be detected by test equipment."

"Using both functional and scan testing you greatly increases your odds at finding an internal defect, but what if the defect
is not controllable or can't be observed?" Steve asked.

"Ah, that is where IDDQ testing can help," I told him.

As we were generating a description of why do IDDQ testing, Bob poked his head into the cubicle. "Hope everything is
running smoothly. You know how important and tight this schedule is," he said with a grin and turned to leave. "Don't
remind us," we both said.

IDDQ Testing Detects Faults Otherwise Undetected
IDDQ testing is different from functional or stuck­at testing in that instead of looking at the logical behavior of the device,
IDDQ testing checks the integrity of the nodes in the design. This is accomplished by measuring the current drain of the
whole chip at times when the circuit is quiescent. Even a single defective node can easily cause a measurable amount of
excessive current drain. In order to place the circuit into a known state, the test sequence uses ATPG techniques to scan
in data, but it does not scan out any data.

To drive this home, an illustration is required. Lets consider a short­to­ground defect (see the Figure below). Traditional
functional or stuck­at testing might be able to detect the stuck­at 0 fault, depending on the capability of the defective node
to be controlled and observed. But with IDDQ testing, the defect can be detected even in if the node is not observable. The
only requirement is to set the input of the inverter to logic 0, which will turn on the upper transistor and place the output to
of the inverter at logic 1.

While a device is switching, it is normal for current to flow, but after the device has settled for a period of time, no more
current should flow. At this point, an IDDQ strobe detects the excessive current drain through the upper transistor and the
short to ground. The current drain of a single defect such as this can be orders of magnitude larger than the normal current
drain of the entire device in the quiescent state.

https://solvnet.synopsys.com/retrieve/print/003843.html 4/9
5/26/2015 The IDDQ Mystery

Figure 2: Short­to­Ground Defect

Chapter Seven ­ IDDQ Testing Advantages and Disadvantages
The next question begging to be answered is what are the advantages and disadvantages of doing IDDQ Testing. Steve
and I started generating a list.

IDDQ Testing Advantages

Test generation is easier ­ faults must be activated, but not propagated to a primary output.
      IDDQ Testing can detect defects not modeled by the stuck­at model
Bridging faults
Gate oxide faults
Shorts between two of the four terminals of a transistor
Partial defects ­ defects that do not affect the logic of the circuit, but may affect reliability.
Some delay faults
Some stuck­open faults
Increased product quality and reliability
Helps eliminate early lifetime failures
IDDQ testing can provide high fault coverage with just a few strobes.

IDDQ Testing Disadvantages

Since normal IDDQ is very low, measurements must be precise.
Measurement takes a significant amount of time
Setting IDDQ threshold on bad devices can be hard
Circuit­under­test must contain all static devices, i.e.,
No dynamic circuitry
No pull­ups or pull­downs on I/O buffers
No specialized speed­optimized circuitry, such as RAM sense amps that draw significant static current

As we compared the pros and cons of IDDQ testing, we concluded that if the goal is to find and detect all possible faults,
then IDDQ testing needs to be performed. As we were discussing our findings footsteps could be heard outside the cubicle.

Bob and Rick poked their heads in. Rick started, "So what's up?" "We were just going over reasons why IDDQ testing
should or shouldn't be done," I told him. "Great," Bob said, "you can present your findings at the team meeting we're having
in 10 minutes."

At the meeting, Steve summarized the major advantages and disadvantages for IDDQ testing. "The major advantage of
IDDQ testing includes the fact that it can potentially detect faults that are undetectable by other models. Also, test
generation can be easier, because the fault only has to be activated and it will be detected. The fault value doesn't have to
be propagated to a primary output." He continued, "However, the major disadvantage of IDDQ testing is the measurement
of quiescent current, which must be very precise and thus takes a long time relative to voltage testing. Also, to be suitable
for IDDQ testing, certain guidelines must be placed on the design."

"Guidelines? What guidelines?" one designer asked. It was my turn. "I put together a sample guideline for IDDQ Design For
Testability ," I told him. I handed out the list.

IDDQ Design for Testability

https://solvnet.synopsys.com/retrieve/print/003843.html 5/9
5/26/2015 The IDDQ Mystery

General
Define an IDDQ test mode signal that doesn't contend with the scan test mode signal.
Use fully complimentary, fully static CMOS.
Power
Use separate power rails for I/O and core modules.
Use separate power rails for analog and non­static CMOS modules.
Internal Conditions
For RTL modules, specify any known input conditions and sequences that cause internal contention.
Specify any known input conditions or sequences that cause internal floating
Design controllers for non­overlapping bus drivers
Each internal 3­state requires one of the following: a bus holder, one­hot enable logic, or logic to gate off bits,
except for the least significant using the IDDQ test mode signal.
Don't allow any unconnected module or cell inputs.
Pull­ups and Pull­downs
Use transistors to enable and disable pull­ups and pull­downs. Disable them with the IDDQ test mode signal.
Disable three­state and bi­directional outputs that require pull­ups and pull­downs with the IDDQ test mode
signal.
SRAM or ROM
Each compile SRAM or ROM requires one of the following: 100 percent CMOS circuitry, a separate power
rail, or a defined condition controlled by the IDDQ test mode signal that guarantees quiescence.
Don't allow SRAM or DRAM outputs to go to Z­state, unless a bus holder is present on the output.

"Oh this isn't bad," the out­spoken designer said. "I think we can live with this."

Chapter Eight ­ What is an IDDQ Fault
"What do IDDQ Faults look like?" someone asked during the meeting. "First, lets remember that IDDQ testing is based on
the physical fact that fault­free CMOS circuits consume VERY LITTLE current in the quiescent state. The presence of
faults, under the right conditions, can increase the quiescent current by an order of
mahttp://submitit.synopsys.com/htmls/user_guide/text_help.html Text Helpgnitude, which can be used to detect the fault,"
I told them.

I handed out a picture (shown below) that shows the effect of a defect in terms of a gate­source short in the P transistor of
an inverter. When the input voltage goes low, such that the transistor turns on significant current flows between the source
and gate, the IDDQ increases dramatically. However, because the gate output goes high, as it should, traditional stuck­at
fault testing would not detect this defect.

"If the defect doesn't affect function, why be concerned about detecting it?" Ted wanted to know. "The answer is," Steve
explained, "that the defect might be such that after a certain operating time, it will cause the device to fail, causing a
detectable fault and thus an error."

Figure 3: Defect Causes High IDDQ

Chapter Nine ­ IDDQ Test Flow
We now needed to develop an IDDQ test flow. To aid in the development, the TetraMAX IddQ­Test and ATPG user guides
https://solvnet.synopsys.com/retrieve/print/003843.html 6/9
5/26/2015 The IDDQ Mystery
were used. Steve found that there was a couple of fault models described in the user guides and put together a list.

Stuck­at Fault Model: For this model, the tool tests for the presence of stuck­at­0 and stuck­at­1 faults on as many
nodes as possible, and propagates the effects of these faults to the primary outputs and scan cells of the device,
where they can be detected by measuring the device outputs.

IDDQ Fault Model: The IDDQ fault model is used to generate test patterns for IDDQ testing. For this model, the tool
tries to toggle as many nodes as possible into both states while avoiding conditions that violate quiescence. The
excessive current drain that they cause can detect any node defects.

It was apparent now that two test flows existed. In one flow you can use an existing stuck­at ATPG pattern set and let the
Power­Fault simulation select the best IDDQ strobe times in the pattern set. While the second flow allows TetraMAX to
generate an IDDQ test pattern set targeting an IDDQ fault model rather than the usual stuck­at fault model. I decided a
picture was required.

Figure 4: TetraMAX IDDQ Flows

Now, which flow to use? We decided that since we didn't have an existing ATPG pattern set, the IDDQ fault model
approach would be used.

Using the users guide as a reference, we generated outlines to present at the next meeting. While Steve developed the
outline for the test flow we would be using, I worked on a list of how to drive TetraMAX. Once Steve had his flow together,
he explained it saying, "Basically, TetraMAX generates test patterns and PowerFault simulations that can be used for
verification". He showed me an outline.

TetraMAX Test Flow Outline

TetraMAX generates a test pattern that directly targets IDDQ faults.
The ATPG algorithm attempts to sensitize all IDDQ faults and applies IDDQ strobes to test all such faults.
The tool then compresses and merges the IDDQ test patterns.
By default, the tool avoids any condition that could cause excessive current drain, such as strong or weak
bus contention or floating buses.
An IDDQ test pattern and fault coverage report is generated.
The tool generates quiescent strobes by using ATPG techniques to avoid all bus contention and float states
in every vector generated.
Output is an IDDQ­only test pattern.
Test pattern Verification
TetraMAX generates patterns that have an IDDQ strobe in each pattern.
When writing the patterns in Verilog format, TetraMAX automatically includes the PowerFault tasks
necessary for verifying quiescence at every strobe.
Use the write patterns command to write generated patterns.
To get a leaky note report file, modify the test pattern file and search for all occurrences of the "status driver

https://solvnet.synopsys.com/retrieve/print/003843.html 7/9
5/26/2015 The IDDQ Mystery

leaky" command. Change the default name to your own unique name.
Run a Verilog/Power­Fault simulation using the test pattern file.

"Great outline!" Here is my list on how to drive TetraMAX for IDDQ testing.

Driving TetraMAX for IDDQ Testing

Select the fault type: To select the fault model, use the set faults command.
Select an IDDQ fault model that is either pseudo­stuck­at or toggle model using the set iddq command. The set iddq
command allows you to specify the conditions required for quiescence.
Create a fault list, using add faults or read faults command.
Set the maximum number of IDDQ strobes with the set atpg ­patterns command.
Run pattern generation with the run atpg command.
Write patterns, using the write patterns command.

Putting it all together, here is a basic script for TetraMAX:

Set faults ­model IDDQ
Set IDDQ ­toggle
Add faults ­all
Set atpg ­patterns 19
Run atpg ­auto
Write patterns test.v ­internal ­format verilog_single_file ­parallel ­replace ­measure_forced_bidis

"Whew! I think we're done," Steve exclaimed. "Well almost. We now need to figure out how to verify the patterns," I said.

Chapter Ten ­ What is PowerFault
"What is PowerFault?" Steve wanted to know. "Yes, that is a question begging to be answered," I agreed. We started
digging. Steve and I put together a list of what PowerFault is and how it can be used:

PowerFault Definition

PowerFault technology

Uses the same Verilog Simulator, netlist, libraries and test bench used for product sign off.
A standard programmable language interface (PLI)
PowerFault software has two parts
A set of PLI tasks that you add to the Verilog Simulator
The IDDQ Profiler, a program that reads IDDQ output data generated by the PLI tasks, determines the best
strobe times and generates IDDQ fault coverage reports

PowerFault Uses

PowerFault simulation technology can be used for the following:

To verify quiescence at strobe points
To analyze and debug non­quiescent states
To select the best IDDQ strobe points for maximum fault coverage
To generate IDDQ fault coverage reports

As we were reviewing our list, Rick stopped by. "Our PDR is in a couple of weeks, have you guys put together a test plan?"
Rick asked. "Were almost done," I told him. "We just need to cover how to verify IDDQ vectors once TetraMAX generates
them," Steve injected. Rick looked puzzled, so Steve added, "PowerFault is a set of PLI tasks that can be added to a
Verilog simulator test bench to direct the simulator to produce a quiescence analysis report that can be used for debug."
"Oh, okay. Just remember we'll be having a dry run in a week," Rick reminded as he turned and left.

Chapter Eleven ­ How to use PowerFault
"Now that we know what PowerFault is, how in the world do we use it?" I asked. Once again we looked to the TetraMAX
IddQ­Test User Guide for direction. To our relief, we found out that using our selected flow, which is the TetraMAX IDDQ
fault model, the verification process is simplified. In this case, TetraMAX generates test patterns that have an IDDQ strobe
in every pattern. When the patterns are written to a Verilog Format file, TetraMAX automatically includes the PowerFault
tasks necessary for verifying quiescent at every strobe. We put together a summary of the required steps.

https://solvnet.synopsys.com/retrieve/print/003843.html 8/9
5/26/2015 The IDDQ Mystery
PowerFault Flow with TetraMAX IDDQ Fault Model

Write the test patterns using the command write patterns as shown below:
Write patterns test.v ­internal ­format verilog_single_file ­parallel ­replace ­measure_forced_bidis
The ­measure_forced_bidis option with write patterns allows the output patterns to attempt both force and
measure operations in the same tester cycle.
If you want to specify the name of the leaky node report file, open the test pattern file in a text editor and search for
all occurrences of the status drivers leaky command, and change the default name to the name you want to use.
Run a Verilog/PowerFault simulation using the test pattern file.
The simulator produces a quiescence analysis report, which can be used to debug any leaky nodes found in the
design.

Just for grins, we looked into other options for PowerFault and found that instead of generating test patterns specifically for
IDDQ testing you can use TetraMAX to generate ordinary stuck­at ATPG patterns, then use PowerFault simulation
technology to choose the best strobe times from those patterns. To do this you need to modify the Verilog test bench file
to enable the simulator's IDDQ tasks. The steps are shown below:

PowerFault Flow with TetraMAX IDDQ Stuck­At ATPG

Write the patterns using the command write patterns as shown below:
write patterns test.v ­internal ­format verilog_single_file ­parallel ­measure_forced_bidis
Open the test pattern file in text editor

At the beginning of the file find the following comment line:
//'define tmax_iddq
Remove the two forward slashes to change the comment to a statement. This enables PowerFault tasks that
TetraMAX has embedded in the test bench.
Another option is to use '+define+tmax_iddq' on the verilog compile line

If you want to specify the name of the leaky node report file, search for all occurrences of the status driver's leaky
command and change the default name.

Save the edited test pattern file.

Run a Verilog simulation using the edited test pattern file

Run the IDDQ Profiler
When you run the Verilog/PowerFault simulation the IDDQ system tasks, evaluate each strobe time for fault
coverage. When you run the IDDQ Profiler, it selects the best strobe times.

"Hey did you see this?" I asked Steve. "I found a tutorial in an appendix of the user guide. We can use this during the
presentation." "Yes," Steve said. "We can recommend that for additional information and hands­on experience, the user
guide will provide both."

success

© 2015 Synopsys, Inc. All Rights Reserved.

https://solvnet.synopsys.com/retrieve/print/003843.html 9/9