Verification Academy

Search form

My Account Menu

  • Register
  • Log In
  • Topics
  • Courses
  • Forums
  • Patterns Library
  • Cookbooks
  • Events
  • More
  • All Topics
    The Verification Academy offers users multiple entry points to find the information they need. One of these entry points is through Topic collections. These topics are industry standards that all design and verification engineers should recognize. While we continue to add new topics, users are encourage to further refine collection information to meet their specific interests.
    • Languages & Standards

      • Portable Test and Stimulus
      • Functional Safety
      • Design & Verification Languages
    • Methodologies

      • UVM - Universal Verification Methodology
      • UVM Framework
      • UVM Connect
      • FPGA Verification
      • Coverage
    • Techniques & Tools

      • Verification IP
      • Simulation-Based Techniques
      • Planning, Measurement, and Analysis
      • Formal-Based Techniques
      • Debug
      • Clock-Domain Crossing
      • Acceleration
  • All Courses
    The Verification Academy is organized into a collection of free online courses, focusing on various key aspects of advanced functional verification. Each course consists of multiple sessions—allowing the participant to pick and choose specific topics of interest, as well as revisit any specific topics for future reference. After completing a specific course, the participant should be armed with enough knowledge to then understand the necessary steps required for maturing their own organization’s skills and infrastructure on the specific topic of interest. The Verification Academy will provide you with a unique opportunity to develop an understanding of how to mature your organization’s processes so that you can then reap the benefits that advanced functional verification offers.
    • Universal Verification Methodology (UVM)

      • Advanced UVM
      • Basic UVM
      • Introduction to UVM
      • UVM Connect
      • UVM Debug
      • UVMF - One Bite at a Time
    • Featured Courses

      • Introduction to ISO 26262
      • Introduction to DO-254
      • Clock-Domain Crossing Verification
      • Portable Stimulus Basics
      • Power Aware CDC Verification
      • Power Aware Verification
      • SystemVerilog OOP for UVM Verification
    • Additional Courses

      • Assertion-Based Verification
      • An Introduction to Unit Testing with SVUnit
      • Evolving FPGA Verification Capabilities
      • Metrics in SoC Verification
      • SystemVerilog Testbench Acceleration
      • Testbench Co-Emulation: SystemC & TLM-2.0
      • Verification Planning and Management
      • VHDL-2008 Why It Matters
    • Formal-Based Techniques

      • Formal Assertion-Based Verification
      • Formal-Based Technology: Automatic Formal Solutions
      • Formal Coverage
      • Getting Started with Formal-Based Technology
      • Handling Inconclusive Assertions in Formal Verification
      • Sequential Logic Equivalence Checking
    • Analog/Mixed Signal

      • AMS Design Configuration Schemes
      • Improve AMS Verification Performance
      • Improve AMS Verification Quality
  • All Forum Topics
    The Verification Community is eager to answer your UVM, SystemVerilog and Coverage related questions. We encourage you to take an active role in the Forums by answering and commenting to any questions that you are able to.
    • UVM Forum

      • Active Questions
      • Solutions
      • Replies
      • No Replies
      • Search
      • UVM Forum
    • SystemVerilog Forum

      • Active Questions
      • Solutions
      • Replies
      • No Replies
      • Search
      • SystemVerilog Forum
    • Coverage Forum

      • Active Questions
      • Solutions
      • Replies
      • No Replies
      • Search
      • Coverage Forum
    • Additional Forums

      • Announcements
      • Downloads
      • OVM Forum
  • Patterns Library
    The Verification Academy Patterns Library contains a collection of solutions to many of today's verification problems. The patterns contained in the library span across the entire domain of verification (i.e., from specification to methodology to implementation—and across multiple verification engines such as formal, simulation, and emulation).
    • Implementation Patterns

      • Environment Patterns
      • Stimulus Patterns
      • Analysis Patterns
      • All Implementation Patterns
    • Specification Patterns

      • Occurrence Property Patterns
      • Order Property Patterns
      • All Specification Patterns
    • Pattern Resources

      • Start Here - Patterns Library Overview
      • Whitepaper - Taking Reuse to the Next Level
      • Verification Horizons - The Verification Academy Patterns Library
      • Contribute a Pattern to the Library
  • All Cookbooks
    Find all the methodology you need in this comprehensive and vast collection. The UVM and Coverage Cookbooks contain dozens of informative, executable articles covering all aspects of UVM and Coverage.
    • UVM Cookbook

      • UVM Basics
      • Testbench Architecture
      • DUT-Testbench Connections
      • Configuring a Test Environment
      • Analysis Components & Techniques
      • End Of Test Mechanisms
      • Sequences
      • The UVM Messaging System
      • Other Stimulus Techniques
      • Register Abstraction Layer
      • Testbench Acceleration through Co-Emulation
      • Debug of SV and UVM
      • UVM Connect - SV-SystemC interoperability
      • UVM Versions and Compatibility
      • UVM Cookbook
    • Coding Guidelines & Deployment

      • Code Examples
      • UVM Verification Component
      • Package/Organization
      • Questa/Compiling UVM
      • SystemVerilog Guidelines
      • SystemVerilog Performance Guidelines
      • UVM Guidelines
      • UVM Performance Guidelines
    • Coverage Cookbook

      • Introduction
      • What is Coverage?
      • Kinds of Coverage
      • Specification to Testplan
      • Testplan to Functional Coverage
      • Bus Protocol Coverage
      • Block Level Coverage
      • Datapath Coverage
      • SoC Coverage Example
      • Requirements Writing Guidelines
      • Coverage Cookbook
  • All Events
    No one argues that the challenges of verification are growing exponentially. What is needed to meet these challenges are tools, methodologies and processes that can help you transform your verification environment. These recorded seminars from Verification Academy trainers and users provide examples for adoption of new technologies and how to evolve your verification process.
    • Upcoming & Featured Events

      • The Digital Twin: An Aerospace and Defense Revolution - March 9th
      • VIP solutions for Protocol and Memory Verification  - March 11th
      • Advance your Designs with Advances in CDC and RDC - March 23rd
      • Webinar Calendar
    • On Demand Seminars

      • The ABC of Formal Verification
      • I'm Excited About Formal...
      • 2020 Functional Verification Study
      • All On-Demand Seminars
    • Recording Archive

      • Improving Your SystemVerilog & UVM Skills
      • Should I Kill My Formal Run?
      • Visualizer Debug Environment
      • All Recordings
    • Conferences

      • DVCon 2020
      • DAC 2019
      • All Conferences
    • Mentor Learning Center

      • SystemVerilog Fundamentals
      • SystemVerilog UVM
      • View all Learning Paths
  • About Verification Academy
    The Verification Academy will provide you with a unique opportunity to develop an understanding of how to mature your organization's processes so that you can then reap the benefits that advanced functional verification offers.
    • Blog & News

      • Verification Horizons Blog
      • Academy News
      • Academy Newsletter
      • Technical Resources
    • Verification Horizons Publication

      • Verification Horizons - November 2020
      • Verification Horizons - July 2020
      • Verification Horizons - March 2020
      • Issue Archive
    • About Us

      • Verification Academy Overview
      • Subject Matter Experts
      • Contact Us
    • Training

      • Questa® & ModelSim®
      • Questa® inFact
      • Functional Verification Library
Ask a Question
SystemVerilog
  • Home
  • Forums
  • SystemVerilog
  • Foreach usage in randomization constraints

Foreach usage in randomization constraints

SystemVerilog 4979
constrained random... 11 constraint dist 7 #systemverilog #Arrays 43 constraint foreach loop 6 constraint randomization 29
peterjin
peterjin
Full Access
36 posts
May 29, 2018 at 8:07 pm

Hi,

I tried to generate the bath-tub curve distribution using the constraint posted on this verification academy page but got run-time error from the constraint used in it.

Here is the constraint used in the page

  int a[5] = '{1, 11, 21, 31, 41};
  int b[5] = '{10, 20, 30, 40, 50};
  int c[5] = '{30, 15, 10, 15, 30};
  
constraint c_value { foreach (a[i])
value dist { [a[i]:b[i]] :/ c[i] };
}

And during runtime, I got the following errors.
"
Solver failed when solving following set of constraints

integer a[2] = 21;
integer b[2] = 30;
integer c[2] = 10;
integer a[3] = 31;
integer b[3] = 40;
integer c[3] = 15;
rand integer value; // rand_mode = ON

constraint c_value // (from this) (constraint_mode = ON) (testbench.sv:10)
{
(value dist {[a[2]:b[2]] :/ c[2]});
(value dist {[a[3]:b[3]] :/ c[3]});
}

=======================================================
"
Then I manually unrolled the foreach distribution and it worked as expected.

constraint c_value{
    value dist{
      [1:11]:/30,
      [11:20]:/15,
      [21:30]:/10,
      [31:40]:/15,
      [41:50]:/30
    };
  }

Thus I wonder why the first distribution constraints that use "foreach" will cause the solver to fail?

Thanks in advance for your help!

Replies

Log In to Reply
javatea
javatea
Full Access
67 posts
May 30, 2018 at 1:12 pm

In reply to peterjin:

We can't have multiple dist constraints on the same random variable with different sets of values.
So this is just pseudo code like stuff.

constraint c_value { 
    foreach (a[i])
      value dist { [a[i]:b[i]] :/ c[i] };
}

solver failure because that code looks like this:
value has 5 different dist constraints and conflict to each other

constraint c_value { 
      value dist { [a[0]:b[0]] :/ c[0] };
      value dist { [a[1]:b[1]] :/ c[1] };
      value dist { [a[2]:b[2]] :/ c[2] };
      value dist { [a[3]:b[3]] :/ c[3] };
      value dist { [a[4]:b[4]] :/ c[4] };
}

and it seems compiler doesn't support this yet.
so it's tough to making bath-tub curve smooth (depending on giving dynamic array size, e.g. a/b/c size),

any good way to making long dist block short, I don't have a good idea yet.

constraint c_value { 
    value dist { 
       foreach (a[i])
         [a[i]:b[i]] :/ c[i];
    };
}
peterjin
peterjin
Full Access
36 posts
May 30, 2018 at 1:50 pm

In reply to javatea:

Hi Javatea,

Thanks for your explanation!

Yes, it seems pretty hard to make the long dist block short, since foreach cannot be used inside dist{}.

Thanks

Hao

Solution

Solution

dave_59
dave_59
Forum Moderator
8584 posts
May 30, 2018 at 11:28 pm

In reply to peterjin:

I believe the article was showing pseudo-code as a concept. You cannot use a dist constraint without a fixed list of values. There are other ways of constructing random distributions. One way is to select a random number to use in a series of implications where only one can be selected:

class A;
   rand int value;
 
   int a[5] = '{1, 11, 21, 31, 41};
   int b[5] = '{10, 20, 30, 40, 50};
   int c[5] = '{30, 15, 10, 15, 30};
   int d[6] = {0, 30, 45, 55, 70, 100}; // could be computed from c
   rand int range;
   constraint c_range {range inside {[d[$low(d)]:d[$high(d)]-1]};
      solve range before value; } // prevents c_value from skewing distribution
   constraint c_value {foreach (a[ii])
		       range inside {[d[ii]:d[ii+1]-1]} ->
		                        value inside {[a[ii]:b[ii]]};}
endclass

— Dave Rich, Verification Architect, Siemens EDA

javatea
javatea
Full Access
67 posts
May 31, 2018 at 1:13 am

In reply to dave_59:

Hi Dave,

Very good idea.
Another method using $dist_normal(seed, mean, std);
By given range related config, then val will be a bath-tub curve in this range.

class A;
 
   rand int norm;
   // range config
   int high = 100;
   int low = 0;
   int mean = 50;
   int std = 20;
   int val;
   
  constraint c { 
    norm == normal(mean);
  }
  
  function int normal(int mean);
    return $dist_normal($urandom(), mean, std);
  endfunction
  
  function void post_randomize();
    if (norm inside {[low:high]}) begin
      val = high - norm;
    end 
    // val within designed range will be bath-tub
  endfunction
  
endclass : A
peterjin
peterjin
Full Access
36 posts
May 31, 2018 at 1:15 am

In reply to dave_59:
Hi Dave,

That's really a brilliant way to generate bath tub curve.

Thanks so much for your help!

Hao

dave_59
dave_59
Forum Moderator
8584 posts
May 31, 2018 at 9:21 am

In reply to javatea:

Have you verified that you code produces the expected curve? And what is val supposed to be when norm falls outside the low/high range?

— Dave Rich, Verification Architect, Siemens EDA

javatea
javatea
Full Access
67 posts
May 31, 2018 at 12:17 pm

In reply to dave_59:

Hi Dave,

I assume we could discard the val outside of the range from the caller.
if we really want to make all val within range, then just do the following:

  function int normal(int mean);
    do begin
       normal = $dist_normal($urandom(), mean, std);
    end while (!(normal inside {[low:high]}));
    return normal;
  endfunction
dave_59
dave_59
Forum Moderator
8584 posts
May 31, 2018 at 3:43 pm

In reply to javatea:

A while loop might work in this particular case, but you can get stuck into an infinite loop in other cases. That is why we feed our constraints to a constraint solver which has to prove a solution exists before generating a particular solution.

And I do not think your equation gives the desired curve. It simple flips the curve as a mirror image.

— Dave Rich, Verification Architect, Siemens EDA

javatea
javatea
Full Access
67 posts
May 31, 2018 at 4:09 pm

In reply to dave_59:

I just try to provide a solution to have more smooth curve without hardcoded a/b/c/d array definition. with a/b/c/d fixed array, we can't have a smooth curve unless you want to define huge array.
if the user provides bad std/mean/seed, it might break $dist_normal for sure.
everything can be fixed, e.g. just put an iteration_count in while loop to catch this issue.

Siemens Digital Industries Software

Siemens Digital Industries Software

##TodayMeetsTomorrow

Solutions

  • Cloud
  • Mendix
  • Siemens EDA
  • MindSphere
  • Siemens PLM
  • View all portfolio

Explore

  • Digital Journeys
  • Community
  • Blog
  • Online Store

Siemens

  • About Us
  • Careers
  • Events
  • News and Press
  • Newsletter
  • Customer Stories

Contact Us

USA:

phone-office +1 800 547 3000

See our Worldwide Directory

  • Contact Us
  • Support Center
  • Give us Feedback
©2021 Siemens Digital Industries Software. All Rights Reserved.
Terms of Use Privacy Cookie Policy