• Guides
  • Videos
  • Publications
  • API
  • Github
  • Community
  • Release Notes
  • Plugins
Installing Origen
  • Introduction
  • How to Install
  • How to Install (Windows)
  • Company Customization
  • Understanding Gems
  • Invoking Considerations
  • Workspace Management
Getting Started with Origen
  • Core concepts
  • Creating a New App
  • Directory Structure
  • The Initial Commit
  • Creating New Files
  • Understanding Blocks
  • Application Architecture
Runtime Environment
  • Introduction
  • Mode
  • Environment
  • Target
  • Production Targets
  • Global Setup
  • Load Order
  • Programming
Models
  • Introduction
  • Naming
  • Definition & Hierarchy
  • Adding Attributes
  • Versioning
  • Bugs & Features
  • Package, Mode & Configuration
  • Registers
  • Pins
  • Power Domains
  • Hardware Attributes
  • Parameters
  • Specifications
  • Fuses
  • Generic Components
  • Creating Your Own Components
Compiler (Views)
  • Introduction
  • Creating Templates
  • Using Sub-Templates
  • Helpers
  • Running The Compiler
  • Inline Compiler
Controllers
  • Introduction
  • Shadow Controllers
  • Direct Controllers
Pattern Generator
  • Introduction
  • Creating Patterns
  • Pins
  • Timing and Waiting
  • Registers
  • Documenting Patterns
  • Generating by Name
  • Common API
  • J750 API
  • V93K API
  • UltraFlex API
  • STIL & Other Formats
  • Custom Testers
  • Running The PatGen
  • Concurrent Patterns
Test Program Generator
  • Introduction
  • Philosophy
  • Creating Flows
  • Managing Flow Control
  • Creating an Interface
  • Additional Resources
  • Dynamic Custom Code
  • Characterization API
  • J750 API
  • V93K Common API
  • V93K SMT7 API
  • V93K SMT8 API
  • UltraFLEX API
  • Documenting the Program
  • Creating Custom Testers
  • Running the ProgGen
Decompilation
  • Overview & Example
  • Decompiling, Adding Pins, & Executing
  • Working with Decompiled Patterns
  • Platform Specifics
Simulation
  • Introduction
  • How It Works
  • Compiling the DUT
  • AMS Support
  • Environment Setup
  • Application Setup
  • Simulating Patterns
  • Simulating Flows
  • Direct DUT Manipulation
  • Simulator Log Output
  • Artifacts
  • Debugging
Documentation Generator
  • Introduction
  • Markdown
  • Linking
  • Styling
  • Testing
  • API Generation
  • Deploying
Plugins
  • Introduction
  • Using a Plugin
  • Creating a Plugin
  • Current & Default Plugins
  • Dev Environment
  • Dev Considerations
  • Paths & Origen.root
  • Config & Origen.app
Miscellaneous
  • Revision Control
  • Origen Remotes
  • Lint Testing
  • Session Store
  • LSF API
  • Users, Emails & Maillists
  • Utilities & Helpers
  • Ruby Extensions
  • Logger
  • Adding Commands
  • Overriding Commands
  • Callbacks
  • Application Callbacks
  • Miscellaneous Topics
Advanced Topics
  • Introduction
  • Invocation Customization
  • Custom App Generators

Simulation

Simulating Flows


A flow, meaning a sequence of patterns, can be simulated in two ways - by supplying a list of patterns or by configuring a test program generator flow to support simulation.

Simulating a Pattern List

If you were to run this:

origen g my_pat_1 my_pat_2 -e environment/sim.rb

then it would run the two patterns as two independent simulations, creating two waveforms named after each pattern.

They can be combined into a single simulation by adding a --flow option:

origen g my_pat_1 my_pat_2 -e environment/sim.rb --flow my_flow

This will simulate the given patterns back-back and dump them to a waveform named after the flow option, in this case “my_flow”.

The list of patterns can also be supplied via a list file:

origen g list/regression.list -e environment/sim.rb --flow regression

Simulating a Test Program Flow

To simulate a pattern sequence defined by a test program flow, it is necessary to setup your interface to support the simulation tester driver as if it were another ATE.

The simulation tester driver has no concept of test methods, suites or instances, so its interface setup is very simple - once you have the pattern name simply pass that to the test method:

# Example interface method
def func(name, options = {})
  # Resolve the pattern name as required
  pattern = extract_pattern_name(name, options)

  if tester.sim?
    test(pattern, options)

  elsif tester.v93k?
    t = test_suites.add(:vreg_func)
    t.test_method = test_methods.origen.functional_test
    t.pattern = pattern
    test(t, options)

  else
    fail "The test program interface has not been setup for #{tester.class}!"
  end
end

To simulate the flow, run the program generator as normal but with the simulation environment selected:

origen p program/my_flow.rb -e environment/sim.rb

The generated wave will be named after the flow, my_flow in this example.


Comments

Generated with the Origen Semiconductor Developer's Kit

Origen is released under the terms of the MIT license