课程描述：
第一阶段 SystemVerilog Assertions培训
COURSE OUTLINE
* Introduction to assertions
* SVA checker library
* Use Model and debug flow using DVE
* Basic SVA constructs
* Temporal behavior, Data Consistency
* Coverage, Coding Guidelines
第二阶段 SystemVerilog Testbench
Overview
In this intensive, three-day course, you will learn the key features and benefits of the SystemVerilog testbench language and its use in VCS.
This course is a hands-on workshop that reinforces the verification concepts taught in lecture through a series of labs. At the end of this class, students should have the skills required to write an object-oriented SystemVerilog testbench to verify a device under test with coverage-driven constrained-random stimulus using VCS.
Students will first learn how to develop an interface between the SystemVerilog test program and the Device Under Test (DUT). Next the workshop will explain how the intuitive object-oriented technology in SystemVerilog testbench can simplify verification problems. Randomization of data is covered to show how different scenarios for testing may be created. This course concludes with an in-depth discussion of functional coverage including a uniform, measurable definition of functionality and the SystemVerilog constructs that allow you to assess the percentage of functionality covered, both dynamically and through the use of generated reports.
To reinforce the lecture and accelerate mastery of the material, each student will complete a challenging test suite for real-world, system-based design.
- Objectives
- At the end of this workshop the student should be able to:
- Build a SystemVerilog verification environment
- Define testbench components using object-oriented programing.
- Develop a stimulus generator to create constrained random test stimulus
- Develop device driver routines to drive DUT input with stimulus from generator
- Develop device monitor routines to sample DUT output
- Develop self-check routines to verify correctness of DUT output
- Abstract DUT stimulus as data objects
- Execute device drivers, monitors and self-checking routines concurrently
- Communicate among concurrent routines using events, semaphores and mailboxes
- Develop functional coverage to measure completeness of test
- Use SystemVerilog Packages
Course Outline
Uunit 1
- The Device Under Test
- SystemVerilog Verification Environment
- SystemVerilog Testbench Language Basics
- Driving and Sampling DUT Signals
Uunit 2
- Managing Concurrency in SystemVerilog
- Object Oriented Programming: Encapsulation
- Object Oriented Programming: Randomization
Uunit 3
- Object Oriented Programming: Inheritance
- Inter-Thread Communications
- Functional Coverage
- SystemVerilog UVM preview
第三阶段 Synopsys SystemVerilog VMM培训
SystemVerilog Verification Using VMM Methodology
OVERVIEW
In this hands-on workshop, you will learn how to develop a VMM SystemVerilog test environment structure which can implement a number of different test cases with minimal modification. Within this VMM environment structure, you will develop stimulus factories, check and coverage callbacks, message loggers, transactor managers, and data flow managers. Once the VMM environment has been created, you will learn how to easily add extensions for more test cases.
After completing the course, you should have developed the skills to write a coverage-driven random stimulus based VMM testbench that is robust, re-useable and scaleable.
OBJECTIVES
At the end of the course you should be able to:
Develop an VMM environment class in SystemVerilog
Implement and manage message loggers for printing to terminal or file
Build a random stimulus generation factory
Build and manage stimulus transaction channels
Build and manage stimulus transactors
Implement checkers using VMM callback methods
Implement functional coverage using VMM callback methods
COURSE OUTLINE
Unit 1
SystemVerilog class inheritance review
VMM Environment
Message Service
Data model
Unit 2
Stimulus Generator/Factory
Check & Coverage
Transactor Implementation
Data Flow Control
Scenario Generator
Recommendations
第四阶段 SystemVerilog Verification using UVM
Overview
In this hands-on workshop, you will learn how to develop a UVM 1.1 SystemVerilog testbench environment which enables efficient testcase development. Within this UVM 1.1 environment, you will develop stimulus sequencer, driver, monitor, scoreboard and functional coverage. Once the UVM 1.1 environment has been created, you will learn how to easily manage and modify the environment for individual testcases.
- Objectives
- At the end of this workshop the student should be able to:
- Develop UVM 1.1 tests
- Implement and manage report messages for printing to terminal or file
- Create random stimulus and sequences
- Build and manage stimulus sequencers, drivers and monitors
- Create configurable agents containing sequencer, driver and monitor for re-use
- Create and manage configurable environments including agents, scoreboards, TLM ports and functional coverage objects
- Implement a collection of testcases each targeting a corner case of interest
- Create an abstraction of DUT registers and manage these registers during test, including functional coverage and self-test
Audience Profile
Design or Verification engineers who develop SystemVerilog testbenches using UVM 1.1 base classes.
Prerequisites
To benefit the most from the material presented in this workshop, students should have completed the SystemVerilog Testbench workshop.
- Course Outline
- Unit 1
- SystemVerilog OOP Inheritance Review
- Polymophism
- Singleton Class
- Singleton Object
- Proxy Class
- Factory Class
- UVM Overview
- Key Concepts in UVM: Agent, Environment and Tests
- Implement UVM Testbenches for Re-Use across Projects
- Code, Compile and Run UVM Tests
- Inner Workings of UVM Simulation including Phasing
- Implement and Manage User Report Messages
- Modeling Stimulus (Transactions)
- Transaction Property Implementation Guidelines
- Transaction Constraint Guidelines
- Transaction Method Automation Macros
- User Transactiom Method Customization
- Implement Tests to Control Transaction Constraints
- Creating Stimulus Sequences
- Sequence Execution Protocol
- Using UVM Macros to create and manage Stimulus
- Implementing User Sequences
- Implicitly Execute Sequences Through Configuration in Environment
- Explicitly Execute Sequences in Test
- Control Sequences through Configuration
- Unit 2
- Component Configuration and Factory
- Establish and Query Component Parent-Child Relationships
- Set Up Component Virtual SystemVerilog Interfaces with uvm_config_db
- Constructing Components and Transactions with UVM Factory
- Implement Tests to Configure Components
- Implement Tests to Override Components with Modified Behavior
- TLM Communications
- TLM Push, Pull and Fifo Modes
- TLM Analysis Ports
- TLM Pass-Through Ports
- TLM 2.0 Blocking and Non-Blocking Transport Sockets
- DVE Waveform Debugging with Recorded UVM Transactions
- Scoreboard & Coverage
- Implement scoreboard with UVM In-Order Class Comparator
- Implement scoreboard UVM Algorithmic Comparator
- Implement Out-Of-Order Scoreboard
- Implement Configuration/Stimulus/Correctness Coverage
- UVM Callback
- Create User Callback Hooks in Component Methods
- Implement Error Injection with User Defined Callbacks
- Implement Component Functional Coverage with User Defined Callbacks
- Review Default Callbacks in UVM Base Class
- Unit 3
- Virtual Sequence/Sequencer
- Disable Selected Sequencer in Agents through the Sequencer抯 揹efault? Configuration Field
- Implement Virtual Sequence and Sequencer to Manager Sequence Execution within Different Agents
- Implement uvm_event for Synchronization of Execution among Sequences in the Virtual Sequence
- Implement Grab and Ungrab in Sequences for exclusive access to Sequencer
- More on Phasing
- Managing Objections within Component Phases
- Implement Component Phase Drain Time
- Implement Component Phase Domain Synchronization
- Implement User Defined Domain and Phases
- Implement UVM Phase Jumping
- Register Layer Abstraction (RAL)
- DUT Register Configuration Testbench Architecture
- Develop DUT Register Abstration (.ralf) File
- Use ralgen Utility to Create UVM Register Model Class Files
- Create UVM Register Adapter Class
- Develop and Execute Sequences Using UVM Register Models
- Use UVM Built-In Register Tests to Verify DUT Register Operation
- Enable RAL Functional Coverage
- Summary
- Review UVM Methodology
- Review Run-Time Command Line Debug Switche
如果您想学习本课程，请
预约报名
如果没找到合适的课程或有特殊培训需求，请
订制培训
除培训外，同时提供相关技术咨询与技术支持服务，有需求请发需求表到邮箱soft@info-soft.cn,或致电4007991916
技术服务需求表下载请点击
服务优势：
丰富专家资源，精准匹配相关行业，相关项目技术精英，面向用户实际需求，针对性培训或咨询，互动式交流，案例教学，精品小班，实际工程项目经验分享，快捷高效，节省时间与金钱，少走弯路与错路。
专家力量：
中国科学院相关研究所高级研究人员
西门子，TI,vmware，MSC,Ansys，MDI，Mentor, candence,Altium,Atmel 、Freescale,达索，华为等
大型公司高级工程师，项目经理，技术支持专家
中科信软培训中心，资深专家或讲师
大多名牌大学，硕士以上学历，相关学历背景专业，理论素养高
多年实际项目实践，大型复杂项目实战案例分享，热情，乐于技术分享
针对客户实际需要，真实案例演示，互动式沟通，学有所值
