You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
5044 lines
204 KiB
5044 lines
204 KiB
--
|
|
-- File Name: CoveragePkg.vhd
|
|
-- Design Unit Name: CoveragePkg
|
|
-- Revision: STANDARD VERSION
|
|
--
|
|
-- Maintainer: Jim Lewis email: jim@synthworks.com
|
|
-- Contributor(s):
|
|
-- Jim Lewis SynthWorks
|
|
-- Matthias Alles Creonic. Inspired GetMinBinVal, GetMinPoint, GetCov
|
|
-- Jerry Kaczynski Aldec. Inspired GetBin function
|
|
-- Sebastian Dunst Inspired GetBinName function
|
|
-- ... Aldec Worked on VendorCov functional coverage interface
|
|
--
|
|
-- Package Defines
|
|
-- Functional coverage modeling utilities and data structure
|
|
--
|
|
-- Developed by/for:
|
|
-- SynthWorks Design Inc.
|
|
-- VHDL Training Classes
|
|
-- 11898 SW 128th Ave. Tigard, Or 97223
|
|
-- http://www.SynthWorks.com
|
|
--
|
|
-- Latest standard version available at:
|
|
-- http://www.SynthWorks.com/downloads
|
|
--
|
|
-- Revision History: For more details, see CoveragePkg_release_notes.pdf
|
|
-- Date Version Description
|
|
-- 06/2010: 0.1 Initial revision
|
|
-- 09/2010 Release in SynthWorks' VHDL Testbenches and Verification classes
|
|
-- 02/2011: 1.0 Changed CoverBinType to facilitage long term support of cross coverage
|
|
-- 02/2011: 1.1 Added GetMinCov, GetMaxCov, CountCovHoles, GetCovHole
|
|
-- 04/2011: 2.0 Added protected type based data structure: CovPType
|
|
-- 06/2011: 2.1 Removed signal based coverage modeling
|
|
-- 07/2011: 2.2 Added randomization with coverage goals (AtLeast), weight, and percentage thresholds
|
|
-- 11/2011: 2.2a Changed constants ALL_RANGE, ZERO_BIN, and ONE_BIN to have a 1 index
|
|
-- 12/2011: 2.2b Fixed minor inconsistencies on interface declarations.
|
|
-- 01/2012: 2.3 Added Function GetBin from Jerry K. Made write for RangeArrayType visible
|
|
-- 01/2012: 2.4 Added Merging of bins
|
|
-- 04/2013: 2013.04 Thresholding, CovTarget, Merging off by default,
|
|
-- 5/2013 2013.05 Release with updated RandomPkg. Minimal changes.
|
|
-- 1/2014 2014.01 Merging of Cov Models, LastIndex
|
|
-- 7/2014 2014.07 Bin Naming (for requirements tracking), WriteBin with Pass/Fail, GenBin[integer_vector]
|
|
-- 12/2014 2014.07a Fix memory leak in deallocate. Removed initialied pointers which can lead to leaks.
|
|
-- 01/2015 2015.01 Use AlertLogPkg to count assertions and filter log messages
|
|
-- 06/2015 2015.06 AddCross[CovMatrix?Type], Mirroring for WriteBin
|
|
-- 01/2016 2016.01 Fixes for pure functions. Added bounds checking on ICover
|
|
-- 03/2016 2016.03 Added GetBinName(Index) to retrieve a bin's name
|
|
-- 11/2016 2016.11 Added VendorCovApiPkg and calls to bind it in.
|
|
-- 05/2017 2017.05 Updated WriteBin name printing
|
|
-- ClearCov (deprecates SetCovZero)
|
|
--
|
|
--
|
|
-- Development Notes:
|
|
-- The coverage procedures are named ICover to avoid conflicts with
|
|
-- future language changes which may add cover as a keyword
|
|
-- Procedure WriteBin writes each CovBin on a separate line, as such
|
|
-- it was inappropriate to overload either textio write or to_string
|
|
-- In the notes VHDL-2008 notes refers to
|
|
-- composites with unconstrained elements
|
|
--
|
|
--
|
|
-- Copyright (c) 2010 - 2017 by SynthWorks Design Inc. All rights reserved.
|
|
--
|
|
-- Verbatim copies of this source file may be used and
|
|
-- distributed without restriction.
|
|
--
|
|
-- This source file is free software; you can redistribute it
|
|
-- and/or modify it under the terms of the ARTISTIC License
|
|
-- as published by The Perl Foundation; either version 2.0 of
|
|
-- the License, or (at your option) any later version.
|
|
--
|
|
-- This source is distributed in the hope that it will be
|
|
-- useful, but WITHOUT ANY WARRANTY; without even the implied
|
|
-- warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
|
-- PURPOSE. See the Artistic License for details.
|
|
--
|
|
-- You should have received a copy of the license with this source.
|
|
-- If not download it from,
|
|
-- http://www.perlfoundation.org/artistic_license_2_0
|
|
--
|
|
-- Credits:
|
|
-- CovBinBaseType is inspired by a structure proposed in the
|
|
-- paper "Functional Coverage - without SystemVerilog!"
|
|
-- by Alan Fitch and Doug Smith. Presented at DVCon 2010
|
|
-- However the approach in their paper uses entities and
|
|
-- architectures where this approach relies on functions
|
|
-- and procedures, so the usage models differ greatly however.
|
|
--
|
|
|
|
library ieee ;
|
|
use ieee.std_logic_1164.all ;
|
|
use ieee.numeric_std.all ;
|
|
use ieee.math_real.all ;
|
|
use std.textio.all ;
|
|
|
|
-- comment out following 2 lines with VHDL-2008. Leave in for VHDL-2002
|
|
-- library ieee_proposed ; -- remove with VHDL-2008
|
|
-- use ieee_proposed.standard_additions.all ; -- remove with VHDL-2008
|
|
|
|
use work.TextUtilPkg.all ;
|
|
use work.TranscriptPkg.all ;
|
|
use work.AlertLogPkg.all ;
|
|
use work.RandomBasePkg.all ;
|
|
use work.RandomPkg.all ;
|
|
use work.NamePkg.all ;
|
|
use work.MessagePkg.all ;
|
|
use work.OsvvmGlobalPkg.all ;
|
|
use work.VendorCovApiPkg.all ;
|
|
|
|
package CoveragePkg is
|
|
|
|
-- CovPType allocates bins that are multiples of MIN_NUM_BINS
|
|
constant MIN_NUM_BINS : integer := 2**7 ; -- power of 2
|
|
|
|
type RangeType is record
|
|
min : integer ;
|
|
max : integer ;
|
|
end record ;
|
|
type RangeArrayType is array (integer range <>) of RangeType ;
|
|
constant ALL_RANGE : RangeArrayType := (1=>(Integer'left, Integer'right)) ;
|
|
|
|
procedure write ( file f : text ; BinVal : RangeArrayType ) ;
|
|
procedure write ( variable buf : inout line ; constant BinVal : in RangeArrayType) ;
|
|
|
|
-- CovBinBaseType.action values.
|
|
-- Note that coverage counting depends on these values
|
|
constant COV_COUNT : integer := 1 ;
|
|
constant COV_IGNORE : integer := 0 ;
|
|
constant COV_ILLEGAL : integer := -1 ;
|
|
|
|
-- type OsvvmOptionsType is (OPT_DEFAULT, FALSE, TRUE) ;
|
|
alias CovOptionsType is work.OsvvmGlobalPkg.OsvvmOptionsType ;
|
|
constant COV_OPT_INIT_PARM_DETECT : CovOptionsType := work.OsvvmGlobalPkg.OPT_INIT_PARM_DETECT ;
|
|
-- For backward compatibility. Don't add to other packages.
|
|
alias DISABLED is work.OsvvmGlobalPkg.DISABLED [return work.OsvvmGlobalPkg.OsvvmOptionsType ];
|
|
alias ENABLED is work.OsvvmGlobalPkg.ENABLED [return work.OsvvmGlobalPkg.OsvvmOptionsType ];
|
|
|
|
-- Deprecated
|
|
-- Used for easy manual entry. Order: min, max, action
|
|
-- Intentionally did not use a record to allow other input
|
|
-- formats in the future with VHDL-2008 unconstrained arrays
|
|
-- of unconstrained elements
|
|
-- type CovBinManualType is array (natural range <>) of integer_vector(0 to 2) ;
|
|
|
|
type CovBinBaseType is record
|
|
BinVal : RangeArrayType(1 to 1) ;
|
|
Action : integer ;
|
|
Count : integer ;
|
|
AtLeast : integer ;
|
|
Weight : integer ;
|
|
end record ;
|
|
type CovBinType is array (natural range <>) of CovBinBaseType ;
|
|
|
|
constant ALL_BIN : CovBinType := (0 => ( BinVal => ALL_RANGE, Action => COV_COUNT, Count => 0, AtLeast => 1, Weight => 1 )) ;
|
|
constant ALL_COUNT : CovBinType := (0 => ( BinVal => ALL_RANGE, Action => COV_COUNT, Count => 0, AtLeast => 1, Weight => 1 )) ;
|
|
constant ALL_ILLEGAL : CovBinType := (0 => ( BinVal => ALL_RANGE, Action => COV_ILLEGAL, Count => 0, AtLeast => 0, Weight => 0 )) ;
|
|
constant ALL_IGNORE : CovBinType := (0 => ( BinVal => ALL_RANGE, Action => COV_IGNORE, Count => 0, AtLeast => 0, Weight => 0 )) ;
|
|
constant ZERO_BIN : CovBinType := (0 => ( BinVal => (1=>(0,0)), Action => COV_COUNT, Count => 0, AtLeast => 1, Weight => 1 )) ;
|
|
constant ONE_BIN : CovBinType := (0 => ( BinVal => (1=>(1,1)), Action => COV_COUNT, Count => 0, AtLeast => 1, Weight => 1 )) ;
|
|
constant NULL_BIN : CovBinType(work.RandomPkg.NULL_RANGE_TYPE) := (others => ( BinVal => ALL_RANGE, Action => integer'high, Count => 0, AtLeast => integer'high, Weight => integer'high )) ;
|
|
|
|
type CountModeType is (COUNT_FIRST, COUNT_ALL) ;
|
|
type IllegalModeType is (ILLEGAL_ON, ILLEGAL_FAILURE, ILLEGAL_OFF) ;
|
|
type WeightModeType is (AT_LEAST, WEIGHT, REMAIN, REMAIN_EXP, REMAIN_SCALED, REMAIN_WEIGHT ) ;
|
|
|
|
|
|
-- In VHDL-2008 CovMatrix?BaseType and CovMatrix?Type will be subsumed
|
|
-- by CovBinBaseType and CovBinType with RangeArrayType as an unconstrained array.
|
|
type CovMatrix2BaseType is record
|
|
BinVal : RangeArrayType(1 to 2) ;
|
|
Action : integer ;
|
|
Count : integer ;
|
|
AtLeast : integer ;
|
|
Weight : integer ;
|
|
end record ;
|
|
type CovMatrix2Type is array (natural range <>) of CovMatrix2BaseType ;
|
|
|
|
type CovMatrix3BaseType is record
|
|
BinVal : RangeArrayType(1 to 3) ;
|
|
Action : integer ;
|
|
Count : integer ;
|
|
AtLeast : integer ;
|
|
Weight : integer ;
|
|
end record ;
|
|
type CovMatrix3Type is array (natural range <>) of CovMatrix3BaseType ;
|
|
|
|
type CovMatrix4BaseType is record
|
|
BinVal : RangeArrayType(1 to 4) ;
|
|
Action : integer ;
|
|
Count : integer ;
|
|
AtLeast : integer ;
|
|
Weight : integer ;
|
|
end record ;
|
|
type CovMatrix4Type is array (natural range <>) of CovMatrix4BaseType ;
|
|
|
|
type CovMatrix5BaseType is record
|
|
BinVal : RangeArrayType(1 to 5) ;
|
|
Action : integer ;
|
|
Count : integer ;
|
|
AtLeast : integer ;
|
|
Weight : integer ;
|
|
end record ;
|
|
type CovMatrix5Type is array (natural range <>) of CovMatrix5BaseType ;
|
|
|
|
type CovMatrix6BaseType is record
|
|
BinVal : RangeArrayType(1 to 6) ;
|
|
Action : integer ;
|
|
Count : integer ;
|
|
AtLeast : integer ;
|
|
Weight : integer ;
|
|
end record ;
|
|
type CovMatrix6Type is array (natural range <>) of CovMatrix6BaseType ;
|
|
|
|
type CovMatrix7BaseType is record
|
|
BinVal : RangeArrayType(1 to 7) ;
|
|
Action : integer ;
|
|
Count : integer ;
|
|
AtLeast : integer ;
|
|
Weight : integer ;
|
|
end record ;
|
|
type CovMatrix7Type is array (natural range <>) of CovMatrix7BaseType ;
|
|
|
|
type CovMatrix8BaseType is record
|
|
BinVal : RangeArrayType(1 to 8) ;
|
|
Action : integer ;
|
|
Count : integer ;
|
|
AtLeast : integer ;
|
|
Weight : integer ;
|
|
end record ;
|
|
type CovMatrix8Type is array (natural range <>) of CovMatrix8BaseType ;
|
|
|
|
type CovMatrix9BaseType is record
|
|
BinVal : RangeArrayType(1 to 9) ;
|
|
Action : integer ;
|
|
Count : integer ;
|
|
AtLeast : integer ;
|
|
Weight : integer ;
|
|
end record ;
|
|
type CovMatrix9Type is array (natural range <>) of CovMatrix9BaseType ;
|
|
|
|
------------------------------------------------------------ VendorCov
|
|
-- VendorCov Conversion for Vendor supported functional coverage modeling
|
|
function ToVendorCovBinVal (BinVal : RangeArrayType) return VendorCovRangeArrayType ;
|
|
|
|
------------------------------------------------------------
|
|
function ToMinPoint (A : RangeArrayType) return integer ;
|
|
function ToMinPoint (A : RangeArrayType) return integer_vector ;
|
|
-- BinVal to Minimum Point
|
|
|
|
------------------------------------------------------------
|
|
procedure ToRandPoint(
|
|
-- BinVal to Random Point
|
|
-- better as a function, however, inout not supported on functions
|
|
------------------------------------------------------------
|
|
variable RV : inout RandomPType ;
|
|
constant BinVal : in RangeArrayType ;
|
|
variable result : out integer
|
|
) ;
|
|
|
|
------------------------------------------------------------
|
|
procedure ToRandPoint(
|
|
-- BinVal to Random Point
|
|
------------------------------------------------------------
|
|
variable RV : inout RandomPType ;
|
|
constant BinVal : in RangeArrayType ;
|
|
variable result : out integer_vector
|
|
) ;
|
|
|
|
|
|
------------------------------------------------------------------------------------------
|
|
-- XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX CovPType XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
|
|
-- XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX CovPType XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
|
|
-- XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX CovPType XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
|
|
------------------------------------------------------------------------------------------
|
|
type CovPType is protected
|
|
procedure FileOpenWriteBin (FileName : string; OpenKind : File_Open_Kind ) ;
|
|
procedure FileCloseWriteBin ;
|
|
procedure SetAlertLogID (A : AlertLogIDType) ;
|
|
procedure SetAlertLogID(Name : string ; ParentID : AlertLogIDType := ALERTLOG_BASE_ID ; CreateHierarchy : Boolean := TRUE) ;
|
|
impure function GetAlertLogID return AlertLogIDType ;
|
|
|
|
-- procedure FileOpenWriteCovDb (FileName : string; OpenKind : File_Open_Kind ) ;
|
|
-- procedure FileCloseWriteCovDb ;
|
|
procedure SetIllegalMode (A : IllegalModeType) ;
|
|
procedure SetWeightMode (A : WeightModeType; Scale : real := 1.0) ;
|
|
procedure SetName (Name : String) ;
|
|
impure function SetName (Name : String) return string ;
|
|
impure function GetName return String ;
|
|
impure function GetCovModelName return String ;
|
|
procedure SetMessage (Message : String) ;
|
|
procedure DeallocateName ; -- clear name
|
|
procedure DeallocateMessage ; -- clear message
|
|
procedure SetThresholding(A : boolean := TRUE ) ; -- 2.5
|
|
procedure SetCovThreshold (Percent : real) ;
|
|
procedure SetCovTarget (Percent : real) ; -- 2.5
|
|
impure function GetCovTarget return real ; -- 2.5
|
|
procedure SetMerging(A : boolean := TRUE ) ; -- 2.5
|
|
procedure SetCountMode (A : CountModeType) ;
|
|
procedure InitSeed (S : string ) ;
|
|
impure function InitSeed (S : string ) return string ;
|
|
procedure InitSeed (I : integer ) ;
|
|
procedure SetSeed (RandomSeedIn : RandomSeedType ) ;
|
|
impure function GetSeed return RandomSeedType ;
|
|
|
|
------------------------------------------------------------
|
|
procedure SetReportOptions (
|
|
WritePassFail : CovOptionsType := COV_OPT_INIT_PARM_DETECT ;
|
|
WriteBinInfo : CovOptionsType := COV_OPT_INIT_PARM_DETECT ;
|
|
WriteCount : CovOptionsType := COV_OPT_INIT_PARM_DETECT ;
|
|
WriteAnyIllegal : CovOptionsType := COV_OPT_INIT_PARM_DETECT ;
|
|
WritePrefix : string := OSVVM_STRING_INIT_PARM_DETECT ;
|
|
PassName : string := OSVVM_STRING_INIT_PARM_DETECT ;
|
|
FailName : string := OSVVM_STRING_INIT_PARM_DETECT
|
|
) ;
|
|
|
|
procedure SetBinSize (NewNumBins : integer) ;
|
|
|
|
------------------------------------------------------------
|
|
procedure AddBins (
|
|
------------------------------------------------------------
|
|
Name : String ;
|
|
AtLeast : integer ;
|
|
Weight : integer ;
|
|
CovBin : CovBinType
|
|
) ;
|
|
procedure AddBins ( Name : String ; AtLeast : integer ; CovBin : CovBinType ) ;
|
|
procedure AddBins ( Name : String ; CovBin : CovBinType) ;
|
|
procedure AddBins ( AtLeast : integer ; Weight : integer ; CovBin : CovBinType ) ;
|
|
procedure AddBins ( AtLeast : integer ; CovBin : CovBinType ) ;
|
|
procedure AddBins ( CovBin : CovBinType ) ;
|
|
|
|
------------------------------------------------------------
|
|
procedure AddCross(
|
|
------------------------------------------------------------
|
|
Name : string ;
|
|
AtLeast : integer ;
|
|
Weight : integer ;
|
|
Bin1, Bin2 : CovBinType ;
|
|
Bin3, Bin4, Bin5, Bin6, Bin7, Bin8, Bin9, Bin10, Bin11, Bin12, Bin13,
|
|
Bin14, Bin15, Bin16, Bin17, Bin18, Bin19, Bin20 : CovBinType := NULL_BIN
|
|
) ;
|
|
|
|
------------------------------------------------------------
|
|
procedure AddCross(
|
|
Name : string ;
|
|
AtLeast : integer ;
|
|
Bin1, Bin2 : CovBinType ;
|
|
Bin3, Bin4, Bin5, Bin6, Bin7, Bin8, Bin9, Bin10, Bin11, Bin12, Bin13,
|
|
Bin14, Bin15, Bin16, Bin17, Bin18, Bin19, Bin20 : CovBinType := NULL_BIN
|
|
) ;
|
|
|
|
------------------------------------------------------------
|
|
procedure AddCross(
|
|
Name : string ;
|
|
Bin1, Bin2 : CovBinType ;
|
|
Bin3, Bin4, Bin5, Bin6, Bin7, Bin8, Bin9, Bin10, Bin11, Bin12, Bin13,
|
|
Bin14, Bin15, Bin16, Bin17, Bin18, Bin19, Bin20 : CovBinType := NULL_BIN
|
|
) ;
|
|
|
|
------------------------------------------------------------
|
|
procedure AddCross(
|
|
AtLeast : integer ;
|
|
Weight : integer ;
|
|
Bin1, Bin2 : CovBinType ;
|
|
Bin3, Bin4, Bin5, Bin6, Bin7, Bin8, Bin9, Bin10, Bin11, Bin12, Bin13,
|
|
Bin14, Bin15, Bin16, Bin17, Bin18, Bin19, Bin20 : CovBinType := NULL_BIN
|
|
) ;
|
|
|
|
------------------------------------------------------------
|
|
procedure AddCross(
|
|
AtLeast : integer ;
|
|
Bin1, Bin2 : CovBinType ;
|
|
Bin3, Bin4, Bin5, Bin6, Bin7, Bin8, Bin9, Bin10, Bin11, Bin12, Bin13,
|
|
Bin14, Bin15, Bin16, Bin17, Bin18, Bin19, Bin20 : CovBinType := NULL_BIN
|
|
) ;
|
|
|
|
------------------------------------------------------------
|
|
procedure AddCross(
|
|
Bin1, Bin2 : CovBinType ;
|
|
Bin3, Bin4, Bin5, Bin6, Bin7, Bin8, Bin9, Bin10, Bin11, Bin12, Bin13,
|
|
Bin14, Bin15, Bin16, Bin17, Bin18, Bin19, Bin20 : CovBinType := NULL_BIN
|
|
) ;
|
|
|
|
|
|
procedure Deallocate ;
|
|
|
|
procedure ICoverLast ;
|
|
procedure ICover( CovPoint : integer) ;
|
|
procedure ICover( CovPoint : integer_vector) ;
|
|
|
|
procedure ClearCov ;
|
|
procedure SetCovZero ;
|
|
|
|
impure function IsInitialized return boolean ;
|
|
impure function GetNumBins return integer ;
|
|
impure function GetMinIndex return integer ;
|
|
impure function GetMinCov return real ; -- PercentCov
|
|
impure function GetMinCount return integer ; -- Count
|
|
impure function GetMaxIndex return integer ;
|
|
impure function GetMaxCov return real ; -- PercentCov
|
|
impure function GetMaxCount return integer ; -- Count
|
|
impure function CountCovHoles ( PercentCov : real ) return integer ;
|
|
impure function CountCovHoles return integer ;
|
|
impure function IsCovered return boolean ;
|
|
impure function IsCovered ( PercentCov : real ) return boolean ;
|
|
impure function GetCov ( PercentCov : real ) return real ;
|
|
impure function GetCov return real ; -- PercentCov of entire model/all bins
|
|
impure function GetItemCount return integer ;
|
|
impure function GetTotalCovGoal ( PercentCov : real ) return integer ;
|
|
impure function GetTotalCovGoal return integer ;
|
|
impure function GetLastIndex return integer ;
|
|
|
|
-- Return BinVal
|
|
impure function GetBinVal ( BinIndex : integer ) return RangeArrayType ;
|
|
impure function GetLastBinVal return RangeArrayType ;
|
|
impure function RandCovBinVal ( PercentCov : real ) return RangeArrayType ;
|
|
impure function RandCovBinVal return RangeArrayType ;
|
|
impure function GetMinBinVal return RangeArrayType ;
|
|
impure function GetMaxBinVal return RangeArrayType ;
|
|
impure function GetHoleBinVal ( ReqHoleNum : integer ; PercentCov : real ) return RangeArrayType ;
|
|
impure function GetHoleBinVal ( PercentCov : real ) return RangeArrayType ;
|
|
impure function GetHoleBinVal ( ReqHoleNum : integer := 1 ) return RangeArrayType ;
|
|
|
|
-- Return Points
|
|
impure function RandCovPoint return integer ;
|
|
impure function RandCovPoint ( PercentCov : real ) return integer ;
|
|
impure function RandCovPoint return integer_vector ;
|
|
impure function RandCovPoint ( PercentCov : real ) return integer_vector ;
|
|
impure function GetPoint ( BinIndex : integer ) return integer ;
|
|
impure function GetPoint ( BinIndex : integer ) return integer_vector ;
|
|
impure function GetMinPoint return integer ;
|
|
impure function GetMinPoint return integer_vector ;
|
|
impure function GetMaxPoint return integer ;
|
|
impure function GetMaxPoint return integer_vector ;
|
|
|
|
-- GetBin returns an internal value of the coverage data structure
|
|
-- The return value may change as the package evolves
|
|
-- Use it only for debugging.
|
|
-- GetBinInfo is a for development only.
|
|
impure function GetBinInfo ( BinIndex : integer ) return CovBinBaseType ;
|
|
impure function GetBinValLength return integer ;
|
|
impure function GetBin ( BinIndex : integer ) return CovBinBaseType ;
|
|
impure function GetBin ( BinIndex : integer ) return CovMatrix2BaseType ;
|
|
impure function GetBin ( BinIndex : integer ) return CovMatrix3BaseType ;
|
|
impure function GetBin ( BinIndex : integer ) return CovMatrix4BaseType ;
|
|
impure function GetBin ( BinIndex : integer ) return CovMatrix5BaseType ;
|
|
impure function GetBin ( BinIndex : integer ) return CovMatrix6BaseType ;
|
|
impure function GetBin ( BinIndex : integer ) return CovMatrix7BaseType ;
|
|
impure function GetBin ( BinIndex : integer ) return CovMatrix8BaseType ;
|
|
impure function GetBin ( BinIndex : integer ) return CovMatrix9BaseType ;
|
|
impure function GetBinName ( BinIndex : integer; DefaultName : string := "" ) return string ;
|
|
|
|
------------------------------------------------------------
|
|
procedure WriteBin (
|
|
WritePassFail : CovOptionsType := COV_OPT_INIT_PARM_DETECT ;
|
|
WriteBinInfo : CovOptionsType := COV_OPT_INIT_PARM_DETECT ;
|
|
WriteCount : CovOptionsType := COV_OPT_INIT_PARM_DETECT ;
|
|
WriteAnyIllegal : CovOptionsType := COV_OPT_INIT_PARM_DETECT ;
|
|
WritePrefix : string := OSVVM_STRING_INIT_PARM_DETECT ;
|
|
PassName : string := OSVVM_STRING_INIT_PARM_DETECT ;
|
|
FailName : string := OSVVM_STRING_INIT_PARM_DETECT
|
|
) ;
|
|
|
|
------------------------------------------------------------
|
|
procedure WriteBin ( -- With LogLevel
|
|
LogLevel : LogType ;
|
|
WritePassFail : CovOptionsType := COV_OPT_INIT_PARM_DETECT ;
|
|
WriteBinInfo : CovOptionsType := COV_OPT_INIT_PARM_DETECT ;
|
|
WriteCount : CovOptionsType := COV_OPT_INIT_PARM_DETECT ;
|
|
WriteAnyIllegal : CovOptionsType := COV_OPT_INIT_PARM_DETECT ;
|
|
WritePrefix : string := OSVVM_STRING_INIT_PARM_DETECT ;
|
|
PassName : string := OSVVM_STRING_INIT_PARM_DETECT ;
|
|
FailName : string := OSVVM_STRING_INIT_PARM_DETECT
|
|
) ;
|
|
|
|
------------------------------------------------------------
|
|
procedure WriteBin (
|
|
FileName : string;
|
|
OpenKind : File_Open_Kind := APPEND_MODE ;
|
|
WritePassFail : CovOptionsType := COV_OPT_INIT_PARM_DETECT ;
|
|
WriteBinInfo : CovOptionsType := COV_OPT_INIT_PARM_DETECT ;
|
|
WriteCount : CovOptionsType := COV_OPT_INIT_PARM_DETECT ;
|
|
WriteAnyIllegal : CovOptionsType := COV_OPT_INIT_PARM_DETECT ;
|
|
WritePrefix : string := OSVVM_STRING_INIT_PARM_DETECT ;
|
|
PassName : string := OSVVM_STRING_INIT_PARM_DETECT ;
|
|
FailName : string := OSVVM_STRING_INIT_PARM_DETECT
|
|
) ;
|
|
|
|
------------------------------------------------------------
|
|
procedure WriteBin ( -- With LogLevel
|
|
LogLevel : LogType ;
|
|
FileName : string;
|
|
OpenKind : File_Open_Kind := APPEND_MODE ;
|
|
WritePassFail : CovOptionsType := COV_OPT_INIT_PARM_DETECT ;
|
|
WriteBinInfo : CovOptionsType := COV_OPT_INIT_PARM_DETECT ;
|
|
WriteCount : CovOptionsType := COV_OPT_INIT_PARM_DETECT ;
|
|
WriteAnyIllegal : CovOptionsType := COV_OPT_INIT_PARM_DETECT ;
|
|
WritePrefix : string := OSVVM_STRING_INIT_PARM_DETECT ;
|
|
PassName : string := OSVVM_STRING_INIT_PARM_DETECT ;
|
|
FailName : string := OSVVM_STRING_INIT_PARM_DETECT
|
|
) ;
|
|
|
|
procedure WriteCovHoles ( LogLevel : LogType := ALWAYS ) ;
|
|
procedure WriteCovHoles ( PercentCov : real ) ;
|
|
procedure WriteCovHoles ( LogLevel : LogType ; PercentCov : real ) ;
|
|
procedure WriteCovHoles ( FileName : string; OpenKind : File_Open_Kind := APPEND_MODE ) ;
|
|
procedure WriteCovHoles ( LogLevel : LogType ; FileName : string; OpenKind : File_Open_Kind := APPEND_MODE ) ;
|
|
procedure WriteCovHoles ( FileName : string; PercentCov : real ; OpenKind : File_Open_Kind := APPEND_MODE ) ;
|
|
procedure WriteCovHoles ( LogLevel : LogType ; FileName : string; PercentCov : real ; OpenKind : File_Open_Kind := APPEND_MODE ) ;
|
|
procedure DumpBin (LogLevel : LogType := DEBUG) ; -- Development only
|
|
|
|
procedure ReadCovDb (FileName : string; Merge : boolean := FALSE) ;
|
|
procedure WriteCovDb (FileName : string; OpenKind : File_Open_Kind := WRITE_MODE ) ;
|
|
impure function GetErrorCount return integer ;
|
|
|
|
-- These support usage of cross coverage constants
|
|
-- Also support the older AddBins(GenCross(...)) methodology
|
|
-- which has been replaced by AddCross
|
|
procedure AddCross (CovBin : CovMatrix2Type ; Name : String := "") ;
|
|
procedure AddCross (CovBin : CovMatrix3Type ; Name : String := "") ;
|
|
procedure AddCross (CovBin : CovMatrix4Type ; Name : String := "") ;
|
|
procedure AddCross (CovBin : CovMatrix5Type ; Name : String := "") ;
|
|
procedure AddCross (CovBin : CovMatrix6Type ; Name : String := "") ;
|
|
procedure AddCross (CovBin : CovMatrix7Type ; Name : String := "") ;
|
|
procedure AddCross (CovBin : CovMatrix8Type ; Name : String := "") ;
|
|
procedure AddCross (CovBin : CovMatrix9Type ; Name : String := "") ;
|
|
|
|
------------------------------------------------------------
|
|
-- Remaining are Deprecated
|
|
--
|
|
-- Deprecated. Replaced by SetName with multi-line support
|
|
procedure SetItemName (ItemNameIn : String) ; -- deprecated
|
|
|
|
-- Deprecated. Consistency across packages
|
|
impure function CovBinErrCnt return integer ;
|
|
|
|
-- Deprecated. Due to name changes to promote greater consistency
|
|
-- Maintained for backward compatibility.
|
|
-- RandCovHole replaced by RandCovBinVal
|
|
impure function RandCovHole ( PercentCov : real ) return RangeArrayType ; -- Deprecated
|
|
impure function RandCovHole return RangeArrayType ; -- Deprecated
|
|
|
|
-- GetCovHole replaced by GetHoleBinVal
|
|
impure function GetCovHole ( ReqHoleNum : integer ; PercentCov : real ) return RangeArrayType ;
|
|
impure function GetCovHole ( PercentCov : real ) return RangeArrayType ;
|
|
impure function GetCovHole ( ReqHoleNum : integer := 1 ) return RangeArrayType ;
|
|
|
|
|
|
-- Deprecated/ Subsumed by versions with PercentCov Parameter
|
|
-- Maintained for backward compatibility only and
|
|
-- may be removed in the future.
|
|
impure function GetMinCov return integer ;
|
|
impure function GetMaxCov return integer ;
|
|
impure function CountCovHoles ( AtLeast : integer ) return integer ;
|
|
impure function IsCovered ( AtLeast : integer ) return boolean ;
|
|
impure function RandCovBinVal ( AtLeast : integer ) return RangeArrayType ;
|
|
impure function RandCovHole ( AtLeast : integer ) return RangeArrayType ; -- Deprecated
|
|
impure function RandCovPoint (AtLeast : integer ) return integer ;
|
|
impure function RandCovPoint (AtLeast : integer ) return integer_vector ;
|
|
impure function GetHoleBinVal ( ReqHoleNum : integer ; AtLeast : integer ) return RangeArrayType ;
|
|
impure function GetCovHole ( ReqHoleNum : integer ; AtLeast : integer ) return RangeArrayType ;
|
|
|
|
procedure WriteCovHoles ( AtLeast : integer ) ;
|
|
procedure WriteCovHoles ( LogLevel : LogType ; AtLeast : integer ) ;
|
|
procedure WriteCovHoles ( FileName : string; AtLeast : integer ; OpenKind : File_Open_Kind := APPEND_MODE ) ;
|
|
procedure WriteCovHoles ( LogLevel : LogType ; FileName : string; AtLeast : integer ; OpenKind : File_Open_Kind := APPEND_MODE ) ;
|
|
|
|
-- Replaced by a more appropriately named AddCross
|
|
procedure AddBins (CovBin : CovMatrix2Type ; Name : String := "") ;
|
|
procedure AddBins (CovBin : CovMatrix3Type ; Name : String := "") ;
|
|
procedure AddBins (CovBin : CovMatrix4Type ; Name : String := "") ;
|
|
procedure AddBins (CovBin : CovMatrix5Type ; Name : String := "") ;
|
|
procedure AddBins (CovBin : CovMatrix6Type ; Name : String := "") ;
|
|
procedure AddBins (CovBin : CovMatrix7Type ; Name : String := "") ;
|
|
procedure AddBins (CovBin : CovMatrix8Type ; Name : String := "") ;
|
|
procedure AddBins (CovBin : CovMatrix9Type ; Name : String := "") ;
|
|
|
|
end protected CovPType ;
|
|
------------------------------------------------------------------------------------------
|
|
-- XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX CovPType XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
|
|
-- XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX CovPType XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
|
|
------------------------------------------------------------------------------------------
|
|
|
|
|
|
------------------------------------------------------------
|
|
-- Experimental. Intended primarily for development.
|
|
procedure CompareBins (
|
|
------------------------------------------------------------
|
|
variable Bin1 : inout CovPType ;
|
|
variable Bin2 : inout CovPType ;
|
|
variable ErrorCount : inout integer
|
|
) ;
|
|
|
|
------------------------------------------------------------
|
|
-- Experimental. Intended primarily for development.
|
|
procedure CompareBins (
|
|
------------------------------------------------------------
|
|
variable Bin1 : inout CovPType ;
|
|
variable Bin2 : inout CovPType
|
|
) ;
|
|
|
|
--
|
|
-- Support for AddBins and AddCross
|
|
--
|
|
|
|
------------------------------------------------------------
|
|
function GenBin(
|
|
------------------------------------------------------------
|
|
AtLeast : integer ;
|
|
Weight : integer ;
|
|
Min, Max : integer ;
|
|
NumBin : integer
|
|
) return CovBinType ;
|
|
|
|
-- Each item in range in a separate CovBin
|
|
function GenBin(AtLeast : integer ; Min, Max, NumBin : integer ) return CovBinType ;
|
|
function GenBin(Min, Max, NumBin : integer ) return CovBinType ;
|
|
function GenBin(Min, Max : integer) return CovBinType ;
|
|
function GenBin(A : integer) return CovBinType ;
|
|
|
|
------------------------------------------------------------
|
|
function GenBin(
|
|
------------------------------------------------------------
|
|
AtLeast : integer ;
|
|
Weight : integer ;
|
|
A : integer_vector
|
|
) return CovBinType ;
|
|
|
|
function GenBin ( AtLeast : integer ; A : integer_vector ) return CovBinType ;
|
|
function GenBin ( A : integer_vector ) return CovBinType ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
function IllegalBin ( Min, Max, NumBin : integer ) return CovBinType ;
|
|
------------------------------------------------------------
|
|
|
|
-- All items in range in a single CovBin
|
|
function IllegalBin ( Min, Max : integer ) return CovBinType ;
|
|
function IllegalBin ( A : integer ) return CovBinType ;
|
|
|
|
|
|
-- IgnoreBin should never have an AtLeast parameter
|
|
------------------------------------------------------------
|
|
function IgnoreBin (Min, Max, NumBin : integer) return CovBinType ;
|
|
------------------------------------------------------------
|
|
function IgnoreBin (Min, Max : integer) return CovBinType ; -- All items in range in a single CovBin
|
|
function IgnoreBin (A : integer) return CovBinType ;
|
|
|
|
|
|
-- With VHDL-2008, there will be one GenCross that returns CovBinType
|
|
-- and has inputs initialized to NULL_BIN - see AddCross
|
|
------------------------------------------------------------
|
|
function GenCross( -- 2
|
|
-- Cross existing bins
|
|
-- Use AddCross for adding values directly to coverage database
|
|
-- Use GenCross for constants
|
|
------------------------------------------------------------
|
|
AtLeast : integer ;
|
|
Weight : integer ;
|
|
Bin1, Bin2 : CovBinType
|
|
) return CovMatrix2Type ;
|
|
|
|
function GenCross(AtLeast : integer ; Bin1, Bin2 : CovBinType) return CovMatrix2Type ;
|
|
function GenCross(Bin1, Bin2 : CovBinType) return CovMatrix2Type ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
function GenCross( -- 3
|
|
------------------------------------------------------------
|
|
AtLeast : integer ;
|
|
Weight : integer ;
|
|
Bin1, Bin2, Bin3 : CovBinType
|
|
) return CovMatrix3Type ;
|
|
|
|
function GenCross( AtLeast : integer ; Bin1, Bin2, Bin3 : CovBinType ) return CovMatrix3Type ;
|
|
function GenCross( Bin1, Bin2, Bin3 : CovBinType ) return CovMatrix3Type ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
function GenCross( -- 4
|
|
------------------------------------------------------------
|
|
AtLeast : integer ;
|
|
Weight : integer ;
|
|
Bin1, Bin2, Bin3, Bin4 : CovBinType
|
|
) return CovMatrix4Type ;
|
|
|
|
function GenCross( AtLeast : integer ; Bin1, Bin2, Bin3, Bin4 : CovBinType ) return CovMatrix4Type ;
|
|
function GenCross( Bin1, Bin2, Bin3, Bin4 : CovBinType ) return CovMatrix4Type ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
function GenCross( -- 5
|
|
------------------------------------------------------------
|
|
AtLeast : integer ;
|
|
Weight : integer ;
|
|
Bin1, Bin2, Bin3, Bin4, Bin5 : CovBinType
|
|
) return CovMatrix5Type ;
|
|
|
|
function GenCross( AtLeast : integer ; Bin1, Bin2, Bin3, Bin4, Bin5 : CovBinType ) return CovMatrix5Type ;
|
|
function GenCross( Bin1, Bin2, Bin3, Bin4, Bin5 : CovBinType ) return CovMatrix5Type ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
function GenCross( -- 6
|
|
------------------------------------------------------------
|
|
AtLeast : integer ;
|
|
Weight : integer ;
|
|
Bin1, Bin2, Bin3, Bin4, Bin5, Bin6 : CovBinType
|
|
) return CovMatrix6Type ;
|
|
|
|
function GenCross( AtLeast : integer ; Bin1, Bin2, Bin3, Bin4, Bin5, Bin6 : CovBinType ) return CovMatrix6Type ;
|
|
function GenCross( Bin1, Bin2, Bin3, Bin4, Bin5, Bin6 : CovBinType ) return CovMatrix6Type ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
function GenCross( -- 7
|
|
------------------------------------------------------------
|
|
AtLeast : integer ;
|
|
Weight : integer ;
|
|
Bin1, Bin2, Bin3, Bin4, Bin5, Bin6, Bin7 : CovBinType
|
|
) return CovMatrix7Type ;
|
|
|
|
function GenCross( AtLeast : integer ; Bin1, Bin2, Bin3, Bin4, Bin5, Bin6, Bin7 : CovBinType ) return CovMatrix7Type ;
|
|
function GenCross( Bin1, Bin2, Bin3, Bin4, Bin5, Bin6, Bin7 : CovBinType ) return CovMatrix7Type ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
function GenCross( -- 8
|
|
------------------------------------------------------------
|
|
AtLeast : integer ;
|
|
Weight : integer ;
|
|
Bin1, Bin2, Bin3, Bin4, Bin5, Bin6, Bin7, Bin8 : CovBinType
|
|
) return CovMatrix8Type ;
|
|
|
|
function GenCross( AtLeast : integer ; Bin1, Bin2, Bin3, Bin4, Bin5, Bin6, Bin7, Bin8 : CovBinType ) return CovMatrix8Type ;
|
|
function GenCross( Bin1, Bin2, Bin3, Bin4, Bin5, Bin6, Bin7, Bin8 : CovBinType ) return CovMatrix8Type ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
function GenCross( -- 9
|
|
------------------------------------------------------------
|
|
AtLeast : integer ;
|
|
Weight : integer ;
|
|
Bin1, Bin2, Bin3, Bin4, Bin5, Bin6, Bin7, Bin8, Bin9 : CovBinType
|
|
) return CovMatrix9Type ;
|
|
|
|
function GenCross( AtLeast : integer ; Bin1, Bin2, Bin3, Bin4, Bin5, Bin6, Bin7, Bin8, Bin9 : CovBinType ) return CovMatrix9Type ;
|
|
function GenCross( Bin1, Bin2, Bin3, Bin4, Bin5, Bin6, Bin7, Bin8, Bin9 : CovBinType ) return CovMatrix9Type ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
-- Utilities. Remove if added to std.standard
|
|
function to_integer ( B : boolean ) return integer ;
|
|
function to_integer ( SL : std_logic ) return integer ;
|
|
function to_integer_vector ( BV : boolean_vector ) return integer_vector ;
|
|
function to_integer_vector ( SLV : std_logic_vector ) return integer_vector ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
------------------------------------------------------------
|
|
-- Deprecated: These are not part of the coverage model
|
|
|
|
procedure increment( signal Count : inout integer ) ;
|
|
procedure increment( signal Count : inout integer ; enable : boolean ) ;
|
|
procedure increment( signal Count : inout integer ; enable : std_ulogic ) ;
|
|
|
|
|
|
|
|
|
|
end package CoveragePkg ;
|
|
|
|
--- ///////////////////////////////////////////////////////////////////////////
|
|
--- ///////////////////////////////////////////////////////////////////////////
|
|
--- ///////////////////////////////////////////////////////////////////////////
|
|
|
|
package body CoveragePkg is
|
|
------------------------------------------------------------
|
|
function inside (
|
|
-- package local
|
|
------------------------------------------------------------
|
|
CovPoint : integer_vector ;
|
|
BinVal : RangeArrayType
|
|
) return boolean is
|
|
alias iCovPoint : integer_vector(BinVal'range) is CovPoint ;
|
|
begin
|
|
for i in BinVal'range loop
|
|
if not (iCovPoint(i) >= BinVal(i).min and iCovPoint(i) <= BinVal(i).max) then
|
|
return FALSE ;
|
|
end if ;
|
|
end loop ;
|
|
return TRUE ;
|
|
end function inside ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
function inside (
|
|
-- package local, used by InsertBin
|
|
-- True when BinVal1 is inside BinVal2
|
|
------------------------------------------------------------
|
|
BinVal1 : RangeArrayType ;
|
|
BinVal2 : RangeArrayType
|
|
) return boolean is
|
|
alias iBinVal2 : RangeArrayType(BinVal1'range) is BinVal2 ;
|
|
begin
|
|
for i in BinVal1'range loop
|
|
if not (BinVal1(i).min >= iBinVal2(i).min and BinVal1(i).max <= iBinVal2(i).max) then
|
|
return FALSE ;
|
|
end if ;
|
|
end loop ;
|
|
return TRUE ;
|
|
end function inside ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
procedure write (
|
|
variable buf : inout line ;
|
|
CovPoint : integer_vector
|
|
) is
|
|
-- package local. called by ICover
|
|
------------------------------------------------------------
|
|
alias iCovPoint : integer_vector(1 to CovPoint'length) is CovPoint ;
|
|
begin
|
|
write(buf, "(" & integer'image(iCovPoint(1)) ) ;
|
|
for i in 2 to iCovPoint'right loop
|
|
write(buf, "," & integer'image(iCovPoint(i)) ) ;
|
|
end loop ;
|
|
swrite(buf, ")") ;
|
|
end procedure write ;
|
|
|
|
------------------------------------------------------------
|
|
procedure write ( file f : text ; BinVal : RangeArrayType ) is
|
|
-- called by WriteBin and WriteCovHoles
|
|
------------------------------------------------------------
|
|
begin
|
|
for i in BinVal'range loop
|
|
if BinVal(i).min = BinVal(i).max then
|
|
write(f, "(" & integer'image(BinVal(i).min) & ") " ) ;
|
|
elsif (BinVal(i).min = integer'left) and (BinVal(i).max = integer'right) then
|
|
write(f, "(ALL) " ) ;
|
|
else
|
|
write(f, "(" & integer'image(BinVal(i).min) & " to " &
|
|
integer'image(BinVal(i).max) & ") " ) ;
|
|
end if ;
|
|
end loop ;
|
|
end procedure write ;
|
|
|
|
------------------------------------------------------------
|
|
procedure write (
|
|
-- called by WriteBin and WriteCovHoles
|
|
------------------------------------------------------------
|
|
variable buf : inout line ;
|
|
constant BinVal : in RangeArrayType
|
|
) is
|
|
------------------------------------------------------------
|
|
begin
|
|
for i in BinVal'range loop
|
|
if BinVal(i).min = BinVal(i).max then
|
|
write(buf, "(" & integer'image(BinVal(i).min) & ") " ) ;
|
|
elsif (BinVal(i).min = integer'left) and (BinVal(i).max = integer'right) then
|
|
swrite(buf, "(ALL) " ) ;
|
|
else
|
|
write(buf, "(" & integer'image(BinVal(i).min) & " to " &
|
|
integer'image(BinVal(i).max) & ") " ) ;
|
|
end if ;
|
|
end loop ;
|
|
end procedure write ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
procedure WriteBinVal (
|
|
-- package local for now
|
|
------------------------------------------------------------
|
|
variable buf : inout line ;
|
|
constant BinVal : in RangeArrayType
|
|
) is
|
|
begin
|
|
for i in BinVal'range loop
|
|
write(buf, BinVal(i).min) ;
|
|
write(buf, ' ') ;
|
|
write(buf, BinVal(i).max) ;
|
|
write(buf, ' ') ;
|
|
end loop ;
|
|
end procedure WriteBinVal ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
-- package local for now
|
|
procedure read (
|
|
-- if public, also create one that does not use valid flag
|
|
------------------------------------------------------------
|
|
variable buf : inout line ;
|
|
variable BinVal : out RangeArrayType ;
|
|
variable Valid : out boolean
|
|
) is
|
|
variable ReadValid : boolean ;
|
|
begin
|
|
for i in BinVal'range loop
|
|
read(buf, BinVal(i).min, ReadValid) ;
|
|
exit when not ReadValid ;
|
|
read(buf, BinVal(i).max, ReadValid) ;
|
|
exit when not ReadValid ;
|
|
end loop ;
|
|
Valid := ReadValid ;
|
|
end procedure read ;
|
|
|
|
|
|
-- ------------------------------------------------------------
|
|
function BinLengths (
|
|
-- package local, used by AddCross, GenCross
|
|
-- ------------------------------------------------------------
|
|
Bin1, Bin2, Bin3, Bin4, Bin5, Bin6, Bin7, Bin8, Bin9, Bin10, Bin11,
|
|
Bin12, Bin13, Bin14, Bin15, Bin16, Bin17, Bin18, Bin19, Bin20 : CovBinType := NULL_BIN
|
|
) return integer_vector is
|
|
variable result : integer_vector(1 to 20) := (others => 0 ) ;
|
|
variable i : integer := result'left ;
|
|
variable Len : integer ;
|
|
begin
|
|
loop
|
|
case i is
|
|
when 1 => Len := Bin1'length ;
|
|
when 2 => Len := Bin2'length ;
|
|
when 3 => Len := Bin3'length ;
|
|
when 4 => Len := Bin4'length ;
|
|
when 5 => Len := Bin5'length ;
|
|
when 6 => Len := Bin6'length ;
|
|
when 7 => Len := Bin7'length ;
|
|
when 8 => Len := Bin8'length ;
|
|
when 9 => Len := Bin9'length ;
|
|
when 10 => Len := Bin10'length ;
|
|
when 11 => Len := Bin11'length ;
|
|
when 12 => Len := Bin12'length ;
|
|
when 13 => Len := Bin13'length ;
|
|
when 14 => Len := Bin14'length ;
|
|
when 15 => Len := Bin15'length ;
|
|
when 16 => Len := Bin16'length ;
|
|
when 17 => Len := Bin17'length ;
|
|
when 18 => Len := Bin18'length ;
|
|
when 19 => Len := Bin19'length ;
|
|
when 20 => Len := Bin20'length ;
|
|
when others => Len := 0 ;
|
|
end case ;
|
|
result(i) := Len ;
|
|
exit when Len = 0 ;
|
|
i := i + 1 ;
|
|
exit when i = 21 ;
|
|
end loop ;
|
|
return result(1 to (i-1)) ;
|
|
end function BinLengths ;
|
|
|
|
|
|
-- ------------------------------------------------------------
|
|
function CalcNumCrossBins ( BinLens : integer_vector ) return integer is
|
|
-- package local, used by AddCross
|
|
-- ------------------------------------------------------------
|
|
variable result : integer := 1 ;
|
|
begin
|
|
for i in BinLens'range loop
|
|
result := result * BinLens(i) ;
|
|
end loop ;
|
|
return result ;
|
|
end function CalcNumCrossBins ;
|
|
|
|
|
|
-- ------------------------------------------------------------
|
|
procedure IncBinIndex (
|
|
-- package local, used by AddCross
|
|
-- ------------------------------------------------------------
|
|
variable BinIndex : inout integer_vector ;
|
|
constant BinLens : in integer_vector
|
|
) is
|
|
alias aBinIndex : integer_vector(1 to BinIndex'length) is BinIndex ;
|
|
alias aBinLens : integer_vector(aBinIndex'range) is BinLens ;
|
|
begin
|
|
-- increment right most one, then if overflow, increment next
|
|
-- assumes bins numbered from 1 to N. - assured by ConcatenateBins
|
|
for i in aBinIndex'reverse_range loop
|
|
aBinIndex(i) := aBinIndex(i) + 1 ;
|
|
exit when aBinIndex(i) <= aBinLens(i) ;
|
|
aBinIndex(i) := 1 ;
|
|
end loop ;
|
|
end procedure IncBinIndex ;
|
|
|
|
|
|
-- ------------------------------------------------------------
|
|
function ConcatenateBins (
|
|
-- package local, used by AddCross and GenCross
|
|
-- ------------------------------------------------------------
|
|
BinIndex : integer_vector ;
|
|
Bin1, Bin2, Bin3, Bin4, Bin5, Bin6, Bin7, Bin8, Bin9, Bin10, Bin11,
|
|
Bin12, Bin13, Bin14, Bin15, Bin16, Bin17, Bin18, Bin19, Bin20 : CovBinType := NULL_BIN
|
|
) return CovBinType is
|
|
alias aBin1 : CovBinType (1 to Bin1'length) is Bin1 ;
|
|
alias aBin2 : CovBinType (1 to Bin2'length) is Bin2 ;
|
|
alias aBin3 : CovBinType (1 to Bin3'length) is Bin3 ;
|
|
alias aBin4 : CovBinType (1 to Bin4'length) is Bin4 ;
|
|
alias aBin5 : CovBinType (1 to Bin5'length) is Bin5 ;
|
|
alias aBin6 : CovBinType (1 to Bin6'length) is Bin6 ;
|
|
alias aBin7 : CovBinType (1 to Bin7'length) is Bin7 ;
|
|
alias aBin8 : CovBinType (1 to Bin8'length) is Bin8 ;
|
|
alias aBin9 : CovBinType (1 to Bin9'length) is Bin9 ;
|
|
alias aBin10 : CovBinType (1 to Bin10'length) is Bin10 ;
|
|
alias aBin11 : CovBinType (1 to Bin11'length) is Bin11 ;
|
|
alias aBin12 : CovBinType (1 to Bin12'length) is Bin12 ;
|
|
alias aBin13 : CovBinType (1 to Bin13'length) is Bin13 ;
|
|
alias aBin14 : CovBinType (1 to Bin14'length) is Bin14 ;
|
|
alias aBin15 : CovBinType (1 to Bin15'length) is Bin15 ;
|
|
alias aBin16 : CovBinType (1 to Bin16'length) is Bin16 ;
|
|
alias aBin17 : CovBinType (1 to Bin17'length) is Bin17 ;
|
|
alias aBin18 : CovBinType (1 to Bin18'length) is Bin18 ;
|
|
alias aBin19 : CovBinType (1 to Bin19'length) is Bin19 ;
|
|
alias aBin20 : CovBinType (1 to Bin20'length) is Bin20 ;
|
|
alias aBinIndex : integer_vector(1 to BinIndex'length) is BinIndex ;
|
|
variable result : CovBinType(aBinIndex'range) ;
|
|
begin
|
|
for i in aBinIndex'range loop
|
|
case i is
|
|
when 1 => result(i) := aBin1(aBinIndex(i)) ;
|
|
when 2 => result(i) := aBin2(aBinIndex(i)) ;
|
|
when 3 => result(i) := aBin3(aBinIndex(i)) ;
|
|
when 4 => result(i) := aBin4(aBinIndex(i)) ;
|
|
when 5 => result(i) := aBin5(aBinIndex(i)) ;
|
|
when 6 => result(i) := aBin6(aBinIndex(i)) ;
|
|
when 7 => result(i) := aBin7(aBinIndex(i)) ;
|
|
when 8 => result(i) := aBin8(aBinIndex(i)) ;
|
|
when 9 => result(i) := aBin9(aBinIndex(i)) ;
|
|
when 10 => result(i) := aBin10(aBinIndex(i)) ;
|
|
when 11 => result(i) := aBin11(aBinIndex(i)) ;
|
|
when 12 => result(i) := aBin12(aBinIndex(i)) ;
|
|
when 13 => result(i) := aBin13(aBinIndex(i)) ;
|
|
when 14 => result(i) := aBin14(aBinIndex(i)) ;
|
|
when 15 => result(i) := aBin15(aBinIndex(i)) ;
|
|
when 16 => result(i) := aBin16(aBinIndex(i)) ;
|
|
when 17 => result(i) := aBin17(aBinIndex(i)) ;
|
|
when 18 => result(i) := aBin18(aBinIndex(i)) ;
|
|
when 19 => result(i) := aBin19(aBinIndex(i)) ;
|
|
when 20 => result(i) := aBin20(aBinIndex(i)) ;
|
|
when others =>
|
|
-- pure functions cannot use alert and/or print
|
|
report "CoveragePkg.AddCross: More than 20 bins not supported"
|
|
severity FAILURE ;
|
|
end case ;
|
|
end loop ;
|
|
return result ;
|
|
end function ConcatenateBins ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
function MergeState( CrossBins : CovBinType) return integer is
|
|
-- package local, Used by AddCross, GenCross
|
|
------------------------------------------------------------
|
|
variable resultState : integer ;
|
|
begin
|
|
resultState := COV_COUNT ;
|
|
for i in CrossBins'range loop
|
|
if CrossBins(i).action = COV_ILLEGAL then
|
|
return COV_ILLEGAL ;
|
|
end if ;
|
|
if CrossBins(i).action = COV_IGNORE then
|
|
resultState := COV_IGNORE ;
|
|
end if ;
|
|
end loop ;
|
|
return resultState ;
|
|
end function MergeState ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
function MergeBinVal( CrossBins : CovBinType) return RangeArrayType is
|
|
-- package local, Used by AddCross, GenCross
|
|
------------------------------------------------------------
|
|
alias aCrossBins : CovBinType(1 to CrossBins'length) is CrossBins ;
|
|
variable BinVal : RangeArrayType(aCrossBins'range) ;
|
|
begin
|
|
for i in aCrossBins'range loop
|
|
BinVal(i to i) := aCrossBins(i).BinVal ;
|
|
end loop ;
|
|
return BinVal ;
|
|
end function MergeBinVal ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
function MergeAtLeast(
|
|
-- package local, Used by AddCross, GenCross
|
|
------------------------------------------------------------
|
|
Action : in integer ;
|
|
AtLeast : in integer ;
|
|
CrossBins : in CovBinType
|
|
) return integer is
|
|
variable Result : integer := AtLeast ;
|
|
begin
|
|
if Action /= COV_COUNT then
|
|
return 0 ;
|
|
end if ;
|
|
for i in CrossBins'range loop
|
|
if CrossBins(i).Action = Action then
|
|
Result := maximum (Result, CrossBins(i).AtLeast) ;
|
|
end if ;
|
|
end loop ;
|
|
return result ;
|
|
end function MergeAtLeast ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
function MergeWeight(
|
|
-- package local, Used by AddCross, GenCross
|
|
------------------------------------------------------------
|
|
Action : in integer ;
|
|
Weight : in integer ;
|
|
CrossBins : in CovBinType
|
|
) return integer is
|
|
variable Result : integer := Weight ;
|
|
begin
|
|
if Action /= COV_COUNT then
|
|
return 0 ;
|
|
end if ;
|
|
for i in CrossBins'range loop
|
|
if CrossBins(i).Action = Action then
|
|
Result := maximum (Result, CrossBins(i).Weight) ;
|
|
end if ;
|
|
end loop ;
|
|
return result ;
|
|
end function MergeWeight ;
|
|
|
|
|
|
------------------------------------------------------------ VendorCov
|
|
-- VendorCov Conversion for Vendor supported functional coverage modeling
|
|
function ToVendorCovBinVal (BinVal : RangeArrayType) return VendorCovRangeArrayType is
|
|
------------------------------------------------------------
|
|
variable VendorCovBinVal : VendorCovRangeArrayType(BinVal'range);
|
|
begin -- VendorCov
|
|
for ArrIdx in BinVal'LEFT to BinVal'RIGHT loop -- VendorCov
|
|
VendorCovBinVal(ArrIdx) := (min => BinVal(ArrIdx).min, -- VendorCov
|
|
max => BinVal(ArrIdx).max) ; -- VendorCov
|
|
end loop; -- VendorCov
|
|
return VendorCovBinVal ;
|
|
end function ToVendorCovBinVal ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
function ToMinPoint (A : RangeArrayType) return integer is
|
|
-- Used in testing
|
|
------------------------------------------------------------
|
|
begin
|
|
return A(A'left).min ;
|
|
end function ToMinPoint ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
function ToMinPoint (A : RangeArrayType) return integer_vector is
|
|
-- Used in testing
|
|
------------------------------------------------------------
|
|
variable result : integer_vector(A'range) ;
|
|
begin
|
|
for i in A'range loop
|
|
result(i) := A(i).min ;
|
|
end loop ;
|
|
return result ;
|
|
end function ToMinPoint ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
procedure ToRandPoint(
|
|
------------------------------------------------------------
|
|
variable RV : inout RandomPType ;
|
|
constant BinVal : in RangeArrayType ;
|
|
variable result : out integer
|
|
) is
|
|
begin
|
|
result := RV.RandInt(BinVal(BinVal'left).min, BinVal(BinVal'left).max) ;
|
|
end procedure ToRandPoint ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
procedure ToRandPoint(
|
|
------------------------------------------------------------
|
|
variable RV : inout RandomPType ;
|
|
constant BinVal : in RangeArrayType ;
|
|
variable result : out integer_vector
|
|
) is
|
|
variable VectorVal : integer_vector(BinVal'range) ;
|
|
begin
|
|
for i in BinVal'range loop
|
|
VectorVal(i) := RV.RandInt(BinVal(i).min, BinVal(i).max) ;
|
|
end loop ;
|
|
result := VectorVal ;
|
|
end procedure ToRandPoint ;
|
|
|
|
------------------------------------------------------------
|
|
-- Local. Get first word from a string
|
|
function GetWord (Message : string) return string is
|
|
------------------------------------------------------------
|
|
alias aMessage : string( 1 to Message'length) is Message ;
|
|
begin
|
|
for i in aMessage'range loop
|
|
if aMessage(i) = ' ' or aMessage(i) = HT then
|
|
return aMessage(1 to i-1) ;
|
|
end if ;
|
|
end loop ;
|
|
return aMessage ;
|
|
end function GetWord ;
|
|
|
|
------------------------------------------------------------
|
|
-- Local -- long term move to MessagePkg? Used by WriteCovDb
|
|
procedure WriteMessage ( file f : text ; variable Message : inout MessagePType ) is
|
|
------------------------------------------------------------
|
|
variable buf : line ;
|
|
begin
|
|
for i in 1 to Message.GetCount loop
|
|
write(buf, string'(Message.Get(i))) ;
|
|
writeline(f, buf) ;
|
|
end loop ;
|
|
end procedure WriteMessage ;
|
|
|
|
------------------------------------------------------------------------------------------
|
|
-- XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX CovPType XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
|
|
-- XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX CovPType XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
|
|
-- XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX CovPType XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
|
|
------------------------------------------------------------------------------------------
|
|
type CovPType is protected body
|
|
|
|
-- Name Data Structure
|
|
variable CovNameVar : NamePType ;
|
|
variable CovMessageVar : MessagePType ;
|
|
|
|
-- Handle into Vendor Data Structure -- VendorCov
|
|
variable VendorCovHandleVar : VendorCovHandleType := 0 ; -- VendorCov
|
|
|
|
-- CoverageBin Data Structures
|
|
type RangeArrayPtrType is access RangeArrayType ;
|
|
|
|
type CovBinBaseTempType is record
|
|
BinVal : RangeArrayPtrType ;
|
|
Action : integer ;
|
|
Count : integer ;
|
|
AtLeast : integer ;
|
|
Weight : integer ;
|
|
PercentCov : real ;
|
|
OrderCount : integer ;
|
|
Name : line ;
|
|
end record CovBinBaseTempType ;
|
|
type CovBinTempType is array (natural range <>) of CovBinBaseTempType ;
|
|
type CovBinPtrType is access CovBinTempType ;
|
|
|
|
variable CovBinPtr : CovBinPtrType ;
|
|
variable NumBins : integer := 0 ;
|
|
variable BinValLength : integer := 1 ;
|
|
variable OrderCount : integer := 0 ; -- for statistics
|
|
variable ItemCount : integer := 0 ; -- Count of randomizations
|
|
variable LastIndex : integer := 1 ; -- Index of last randomization
|
|
|
|
-- Internal Modes and Names
|
|
variable IllegalMode : IllegalModeType := ILLEGAL_ON ;
|
|
variable IllegalModeLevel : AlertType := ERROR ;
|
|
variable WeightMode : WeightModeType := AT_LEAST ;
|
|
variable WeightScale : real := 1.0 ;
|
|
|
|
variable ThresholdingEnable : boolean := FALSE ; -- thresholding disabled by default
|
|
variable CovThreshold : real := 45.0 ;
|
|
variable CovTarget : real := 100.0 ;
|
|
|
|
variable MergingEnable : boolean := FALSE ; -- merging disabled by default
|
|
variable CountMode : CountModeType := COUNT_FIRST ;
|
|
|
|
-- Randomization Variable
|
|
variable RV : RandomPType ;
|
|
variable RvSeedInit : boolean := FALSE ;
|
|
|
|
file WriteBinFile : text ;
|
|
variable WriteBinFileInit : boolean := FALSE ;
|
|
variable UsingLocalFile : boolean := FALSE ;
|
|
variable AlertLogIDVar : AlertLogIDType := OSVVM_ALERTLOG_ID ;
|
|
|
|
-- file WriteCovDbFile : text ;
|
|
-- variable WriteCovDbFileInit : boolean := FALSE ;
|
|
|
|
-- Local WriteBin and WriteCovHoles formatting settings, defaults determined by CoverageGlobals
|
|
variable WritePassFailVar : CovOptionsType := COV_OPT_INIT_PARM_DETECT ;
|
|
variable WriteBinInfoVar : CovOptionsType := COV_OPT_INIT_PARM_DETECT ;
|
|
variable WriteCountVar : CovOptionsType := COV_OPT_INIT_PARM_DETECT ;
|
|
variable WriteAnyIllegalVar : CovOptionsType := COV_OPT_INIT_PARM_DETECT ;
|
|
variable WritePrefixVar : NamePType ;
|
|
variable PassNameVar : NamePType ;
|
|
variable FailNameVar : NamePType ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
procedure FileOpenWriteBin (FileName : string; OpenKind : File_Open_Kind ) is
|
|
------------------------------------------------------------
|
|
begin
|
|
WriteBinFileInit := TRUE ;
|
|
file_open( WriteBinFile , FileName , OpenKind );
|
|
end procedure FileOpenWriteBin ;
|
|
|
|
------------------------------------------------------------
|
|
procedure FileCloseWriteBin is
|
|
------------------------------------------------------------
|
|
begin
|
|
WriteBinFileInit := FALSE ;
|
|
file_close( WriteBinFile) ;
|
|
end procedure FileCloseWriteBin ;
|
|
|
|
------------------------------------------------------------
|
|
procedure SetAlertLogID (A : AlertLogIDType) is
|
|
------------------------------------------------------------
|
|
begin
|
|
AlertLogIDVar := A ;
|
|
end procedure SetAlertLogID ;
|
|
|
|
------------------------------------------------------------
|
|
procedure SetAlertLogID(Name : string ; ParentID : AlertLogIDType := ALERTLOG_BASE_ID ; CreateHierarchy : Boolean := TRUE) is
|
|
------------------------------------------------------------
|
|
begin
|
|
AlertLogIDVar := GetAlertLogID(Name, ParentID, CreateHierarchy) ;
|
|
if not RvSeedInit then -- Init seed if not initialized
|
|
RV.InitSeed(Name) ;
|
|
RvSeedInit := TRUE ;
|
|
end if ;
|
|
end procedure SetAlertLogID ;
|
|
|
|
------------------------------------------------------------
|
|
impure function GetAlertLogID return AlertLogIDType is
|
|
------------------------------------------------------------
|
|
begin
|
|
return AlertLogIDVar ;
|
|
end function GetAlertLogID ;
|
|
|
|
|
|
-- ------------------------------------------------------------
|
|
-- procedure FileOpen (FileName : string; OpenKind : File_Open_Kind ) is
|
|
-- ------------------------------------------------------------
|
|
-- begin
|
|
-- WriteCovDbFileInit := TRUE ;
|
|
-- file_open( WriteCovDbFile , FileName , OpenKind );
|
|
-- end procedure FileOpenWriteCovDb ;
|
|
--
|
|
-- ------------------------------------------------------------
|
|
-- procedure FileCloseWriteCovDb is
|
|
-- ------------------------------------------------------------
|
|
-- begin
|
|
-- WriteCovDbFileInit := FALSE ;
|
|
-- file_close( WriteCovDbFile );
|
|
-- end procedure FileCloseWriteCovDb ;
|
|
|
|
------------------------------------------------------------
|
|
procedure SetName (Name : String) is
|
|
------------------------------------------------------------
|
|
begin
|
|
CovNameVar.Set(Name) ;
|
|
-- Update if name updated after model created -- VendorCov
|
|
if IsInitialized then -- VendorCov
|
|
VendorCovSetName(VendorCovHandleVar, Name) ; -- VendorCov
|
|
end if ; -- VendorCov
|
|
if not RvSeedInit then -- Init seed if not initialized
|
|
RV.InitSeed(Name) ;
|
|
RvSeedInit := TRUE ;
|
|
end if ;
|
|
end procedure SetName ;
|
|
|
|
------------------------------------------------------------
|
|
impure function SetName (Name : String) return string is
|
|
------------------------------------------------------------
|
|
begin
|
|
SetName(Name) ; -- call procedure above
|
|
return Name ;
|
|
end function SetName ;
|
|
|
|
------------------------------------------------------------
|
|
impure function GetName return String is
|
|
------------------------------------------------------------
|
|
begin
|
|
return CovNameVar.Get("") ;
|
|
end function GetName ;
|
|
|
|
------------------------------------------------------------
|
|
impure function GetCovModelName return String is
|
|
------------------------------------------------------------
|
|
begin
|
|
if CovNameVar.IsSet then
|
|
-- return Name if set
|
|
return CovNameVar.Get ;
|
|
elsif AlertLogIDVar /= OSVVM_ALERTLOG_ID then
|
|
-- otherwise return AlertLogName if it is set
|
|
return GetAlertLogName(AlertLogIDVar) ;
|
|
elsif CovMessageVar.IsSet then
|
|
-- otherwise Get the first word of the Message if it is set
|
|
return GetWord(string'(CovMessageVar.Get(1))) ;
|
|
else
|
|
return "" ;
|
|
end if ;
|
|
end function GetCovModelName ;
|
|
|
|
------------------------------------------------------------
|
|
impure function GetNamePlus(prefix, suffix : string) return String is
|
|
------------------------------------------------------------
|
|
begin
|
|
if CovNameVar.IsSet then
|
|
-- return Name if set
|
|
return prefix & CovNameVar.Get & suffix ;
|
|
elsif AlertLogIDVar = OSVVM_ALERTLOG_ID and CovMessageVar.IsSet then
|
|
-- If AlertLogID not set, then use Message
|
|
return prefix & GetWord(string'(CovMessageVar.Get(1))) & suffix ;
|
|
else
|
|
return "" ;
|
|
end if ;
|
|
end function GetNamePlus ;
|
|
|
|
------------------------------------------------------------
|
|
procedure SetMessage (Message : String) is
|
|
------------------------------------------------------------
|
|
begin
|
|
CovMessageVar.Set(Message) ;
|
|
-- VendorCov update if name updated after model created
|
|
if IsInitialized then -- VendorCov
|
|
-- Refine this? If CovNameVar or AlertLogIDName is set, -- VendorCov
|
|
-- it may be set to the same name again. -- VendorCov
|
|
VendorCovSetName(VendorCovHandleVar, GetCovModelName) ; -- VendorCov
|
|
end if ; -- VendorCov
|
|
if not RvSeedInit then -- Init seed if not initialized
|
|
RV.InitSeed(Message) ;
|
|
RvSeedInit := TRUE ;
|
|
end if ;
|
|
end procedure SetMessage ;
|
|
|
|
------------------------------------------------------------
|
|
procedure SetIllegalMode (A : IllegalModeType) is
|
|
------------------------------------------------------------
|
|
begin
|
|
IllegalMode := A ;
|
|
if IllegalMode = ILLEGAL_FAILURE then
|
|
IllegalModeLevel := FAILURE ;
|
|
else
|
|
IllegalModeLevel := ERROR ;
|
|
end if ;
|
|
end procedure SetIllegalMode ;
|
|
|
|
------------------------------------------------------------
|
|
procedure SetWeightMode (A : WeightModeType; Scale : real := 1.0) is
|
|
------------------------------------------------------------
|
|
variable buf : line ;
|
|
begin
|
|
WeightMode := A ;
|
|
WeightScale := Scale ;
|
|
|
|
if (WeightMode = REMAIN_EXP) and (WeightScale > 2.0) then
|
|
Alert(AlertLogIDVar, GetNamePlus(prefix => "in ", suffix => ", ") & "CoveragePkg.SetWeightMode:" &
|
|
" WeightScale > 2.0 and large Counts can cause RandCovPoint to fail due to integer values out of range", WARNING) ;
|
|
end if ;
|
|
if (WeightScale < 1.0) and (WeightMode = REMAIN_WEIGHT or WeightMode = REMAIN_SCALED) then
|
|
Alert(AlertLogIDVar, GetNamePlus(prefix => "in ", suffix => ", ") & "CoveragePkg.SetWeightMode:" &
|
|
" WeightScale must be > 1.0 when WeightMode = REMAIN_WEIGHT or WeightMode = REMAIN_SCALED", FAILURE) ;
|
|
WeightScale := 1.0 ;
|
|
end if;
|
|
if WeightScale <= 0.0 then
|
|
Alert(AlertLogIDVar, GetNamePlus(prefix => "in ", suffix => ", ") & "CoveragePkg.SetWeightMode:" &
|
|
" WeightScale must be > 0.0", FAILURE) ;
|
|
WeightScale := 1.0 ;
|
|
end if;
|
|
end procedure SetWeightMode ;
|
|
|
|
------------------------------------------------------------
|
|
-- pt local for now -- file formal parameter not allowed with a public method
|
|
procedure WriteBinName ( file f : text ; S : string ; Prefix : string := "%% " ) is
|
|
------------------------------------------------------------
|
|
variable MessageCount : integer ;
|
|
variable MessageIndex : integer := 1 ;
|
|
variable buf : line ;
|
|
begin
|
|
MessageCount := CovMessageVar.GetCount ;
|
|
if MessageCount = 0 then
|
|
write(buf, Prefix & S & GetCovModelName) ; -- Print name when no message
|
|
writeline(f, buf) ;
|
|
else
|
|
if CovNameVar.IsSet then
|
|
-- Print Name if set
|
|
write(buf, Prefix & S & CovNameVar.Get) ;
|
|
elsif AlertLogIDVar /= OSVVM_ALERTLOG_ID then
|
|
-- otherwise Print AlertLogName if it is set
|
|
write(buf, Prefix & S & string'(GetAlertLogName(AlertLogIDVar))) ;
|
|
else
|
|
-- otherwise print the first line of the message
|
|
MessageIndex := 2 ;
|
|
write(buf, Prefix & S & string'(CovMessageVar.Get(1))) ;
|
|
end if ;
|
|
writeline(f, buf) ;
|
|
for i in MessageIndex to MessageCount loop
|
|
write(buf, Prefix & string'(CovMessageVar.Get(i))) ;
|
|
writeline(f, buf) ;
|
|
end loop ;
|
|
end if ;
|
|
end procedure WriteBinName ;
|
|
|
|
------------------------------------------------------------
|
|
procedure DeallocateMessage is
|
|
------------------------------------------------------------
|
|
begin
|
|
CovMessageVar.Deallocate ;
|
|
end procedure DeallocateMessage ;
|
|
|
|
------------------------------------------------------------
|
|
procedure DeallocateName is
|
|
------------------------------------------------------------
|
|
begin
|
|
CovNameVar.Clear ;
|
|
end procedure DeallocateName ;
|
|
|
|
------------------------------------------------------------
|
|
procedure SetThresholding (A : boolean := TRUE ) is
|
|
------------------------------------------------------------
|
|
begin
|
|
ThresholdingEnable := A ;
|
|
end procedure SetThresholding ;
|
|
|
|
------------------------------------------------------------
|
|
procedure SetCovThreshold (Percent : real) is
|
|
------------------------------------------------------------
|
|
begin
|
|
ThresholdingEnable := TRUE ;
|
|
if Percent >= 0.0 then
|
|
CovThreshold := Percent + 0.0001 ; -- used in less than
|
|
else
|
|
CovThreshold := 0.0001 ; -- used in less than
|
|
Alert(AlertLogIDVar, GetNamePlus(prefix => "in ", suffix => ", ") & "CoveragePkg.SetCovThreshold:" &
|
|
" Invalid Threshold Value " & real'image(Percent), FAILURE) ;
|
|
end if ;
|
|
end procedure SetCovThreshold ;
|
|
|
|
------------------------------------------------------------
|
|
procedure SetCovTarget (Percent : real) is
|
|
------------------------------------------------------------
|
|
begin
|
|
CovTarget := Percent ;
|
|
end procedure SetCovTarget ;
|
|
|
|
------------------------------------------------------------
|
|
impure function GetCovTarget return real is
|
|
------------------------------------------------------------
|
|
begin
|
|
return CovTarget ;
|
|
end function GetCovTarget ;
|
|
|
|
------------------------------------------------------------
|
|
procedure SetMerging (A : boolean := TRUE ) is
|
|
------------------------------------------------------------
|
|
begin
|
|
MergingEnable := A ;
|
|
end procedure SetMerging ;
|
|
|
|
------------------------------------------------------------
|
|
procedure SetCountMode (A : CountModeType) is
|
|
------------------------------------------------------------
|
|
begin
|
|
CountMode := A ;
|
|
end procedure SetCountMode ;
|
|
|
|
------------------------------------------------------------
|
|
procedure InitSeed (S : string ) is
|
|
------------------------------------------------------------
|
|
begin
|
|
RV.InitSeed(S) ;
|
|
RvSeedInit := TRUE ;
|
|
end procedure InitSeed ;
|
|
|
|
------------------------------------------------------------
|
|
impure function InitSeed (S : string ) return string is
|
|
------------------------------------------------------------
|
|
begin
|
|
RV.InitSeed(S) ;
|
|
RvSeedInit := TRUE ;
|
|
return S ;
|
|
end function InitSeed ;
|
|
|
|
------------------------------------------------------------
|
|
procedure InitSeed (I : integer ) is
|
|
------------------------------------------------------------
|
|
begin
|
|
RV.InitSeed(I) ;
|
|
RvSeedInit := TRUE ;
|
|
end procedure InitSeed ;
|
|
|
|
------------------------------------------------------------
|
|
procedure SetSeed (RandomSeedIn : RandomSeedType ) is
|
|
------------------------------------------------------------
|
|
begin
|
|
RV.SetSeed(RandomSeedIn) ;
|
|
RvSeedInit := TRUE ;
|
|
end procedure SetSeed ;
|
|
|
|
------------------------------------------------------------
|
|
impure function GetSeed return RandomSeedType is
|
|
------------------------------------------------------------
|
|
begin
|
|
return RV.GetSeed ;
|
|
end function GetSeed ;
|
|
|
|
------------------------------------------------------------
|
|
procedure SetReportOptions (
|
|
------------------------------------------------------------
|
|
WritePassFail : CovOptionsType := COV_OPT_INIT_PARM_DETECT ;
|
|
WriteBinInfo : CovOptionsType := COV_OPT_INIT_PARM_DETECT ;
|
|
WriteCount : CovOptionsType := COV_OPT_INIT_PARM_DETECT ;
|
|
WriteAnyIllegal : CovOptionsType := COV_OPT_INIT_PARM_DETECT ;
|
|
WritePrefix : string := OSVVM_STRING_INIT_PARM_DETECT ;
|
|
PassName : string := OSVVM_STRING_INIT_PARM_DETECT ;
|
|
FailName : string := OSVVM_STRING_INIT_PARM_DETECT
|
|
) is
|
|
begin
|
|
if WritePassFail /= COV_OPT_INIT_PARM_DETECT then
|
|
WritePassFailVar := WritePassFail ;
|
|
end if ;
|
|
if WriteBinInfo /= COV_OPT_INIT_PARM_DETECT then
|
|
WriteBinInfoVar := WriteBinInfo ;
|
|
end if ;
|
|
if WriteCount /= COV_OPT_INIT_PARM_DETECT then
|
|
WriteCountVar := WriteCount ;
|
|
end if ;
|
|
if WriteAnyIllegal /= COV_OPT_INIT_PARM_DETECT then
|
|
WriteAnyIllegalVar := WriteAnyIllegal ;
|
|
end if ;
|
|
if WritePrefix /= OSVVM_STRING_INIT_PARM_DETECT then
|
|
WritePrefixVar.Set(WritePrefix) ;
|
|
end if ;
|
|
if PassName /= OSVVM_STRING_INIT_PARM_DETECT then
|
|
PassNameVar.Set(PassName) ;
|
|
end if ;
|
|
if FailName /= OSVVM_STRING_INIT_PARM_DETECT then
|
|
FailNameVar.Set(FailName) ;
|
|
end if ;
|
|
end procedure SetReportOptions ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
procedure SetBinSize (NewNumBins : integer) is
|
|
-- Sets a CovBin to a particular size
|
|
-- Use for small bins to save space or large bins to
|
|
-- suppress the resize and copy as a CovBin autosizes.
|
|
------------------------------------------------------------
|
|
variable oldCovBinPtr : CovBinPtrType ;
|
|
begin
|
|
if CovBinPtr = NULL then
|
|
CovBinPtr := new CovBinTempType(1 to NewNumBins) ;
|
|
elsif NewNumBins > CovBinPtr'length then
|
|
-- make message bigger
|
|
oldCovBinPtr := CovBinPtr ;
|
|
CovBinPtr := new CovBinTempType(1 to NewNumBins) ;
|
|
CovBinPtr.all(1 to NumBins) := oldCovBinPtr.all(1 to NumBins) ;
|
|
deallocate(oldCovBinPtr) ;
|
|
end if ;
|
|
end procedure SetBinSize ;
|
|
|
|
------------------------------------------------------------
|
|
-- pt local
|
|
procedure CheckBinValLength( CurBinValLength : integer ; Caller : string ) is
|
|
begin
|
|
if NumBins = 0 then
|
|
BinValLength := CurBinValLength ; -- number of points in cross
|
|
else
|
|
AlertIf(AlertLogIDVar, BinValLength /= CurBinValLength, GetNamePlus(prefix => "in ", suffix => ", ") & "CoveragePkg." & Caller & ":" &
|
|
" Cross coverage bins of different dimensions prohibited", FAILURE) ;
|
|
end if;
|
|
end procedure CheckBinValLength ;
|
|
|
|
------------------------------------------------------------
|
|
-- pt local
|
|
impure function NormalizeNumBins( ReqNumBins : integer ) return integer is
|
|
variable NormNumBins : integer := MIN_NUM_BINS ;
|
|
begin
|
|
while NormNumBins < ReqNumBins loop
|
|
NormNumBins := NormNumBins + MIN_NUM_BINS ;
|
|
end loop ;
|
|
return NormNumBins ;
|
|
end function NormalizeNumBins ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
-- pt local
|
|
procedure GrowBins (ReqNumBins : integer) is
|
|
variable oldCovBinPtr : CovBinPtrType ;
|
|
variable NewNumBins : integer ;
|
|
begin
|
|
NewNumBins := NumBins + ReqNumBins ;
|
|
if CovBinPtr = NULL then
|
|
CovBinPtr := new CovBinTempType(1 to NormalizeNumBins(NewNumBins)) ;
|
|
elsif NewNumBins > CovBinPtr'length then
|
|
-- make message bigger
|
|
oldCovBinPtr := CovBinPtr ;
|
|
CovBinPtr := new CovBinTempType(1 to NormalizeNumBins(NewNumBins)) ;
|
|
CovBinPtr.all(1 to NumBins) := oldCovBinPtr.all(1 to NumBins) ;
|
|
deallocate(oldCovBinPtr) ;
|
|
end if ;
|
|
end procedure GrowBins ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
-- pt local, called by InsertBin
|
|
-- Finds index of bin if it is inside an existing bins
|
|
procedure FindBinInside(
|
|
BinVal : RangeArrayType ;
|
|
Position : out integer ;
|
|
FoundInside : out boolean
|
|
) is
|
|
begin
|
|
Position := NumBins + 1 ;
|
|
FoundInside := FALSE ;
|
|
FindLoop : for i in NumBins downto 1 loop
|
|
-- skip this CovBin if CovPoint is not in it
|
|
next FindLoop when not inside(BinVal, CovBinPtr(i).BinVal.all) ;
|
|
Position := i ;
|
|
FoundInside := TRUE ;
|
|
exit ;
|
|
end loop ;
|
|
end procedure FindBinInside ;
|
|
|
|
------------------------------------------------------------
|
|
-- pt local
|
|
-- Inserts values into a new bin.
|
|
-- Called by InsertBin
|
|
procedure InsertNewBin(
|
|
BinVal : RangeArrayType ;
|
|
Action : integer ;
|
|
Count : integer ;
|
|
AtLeast : integer ;
|
|
Weight : integer ;
|
|
Name : string ;
|
|
PercentCov : real := 0.0
|
|
) is
|
|
begin
|
|
if (not IsInitialized) then -- VendorCov
|
|
if (BinVal'length > 1) then -- Cross Bin -- VendorCov
|
|
VendorCovHandleVar := VendorCovCrossCreate(GetCovModelName) ; -- VendorCov
|
|
else -- VendorCov
|
|
VendorCovHandleVar := VendorCovPointCreate(GetCovModelName); -- VendorCov
|
|
end if; -- VendorCov
|
|
end if; -- VendorCov
|
|
VendorCovBinAdd(VendorCovHandleVar, ToVendorCovBinVal(BinVal), Action, AtLeast, Name) ; -- VendorCov
|
|
NumBins := NumBins + 1 ;
|
|
CovBinPtr.all(NumBins).BinVal := new RangeArrayType'(BinVal) ;
|
|
CovBinPtr.all(NumBins).Action := Action ;
|
|
CovBinPtr.all(NumBins).Count := Count ;
|
|
CovBinPtr.all(NumBins).AtLeast := AtLeast ;
|
|
CovBinPtr.all(NumBins).Weight := Weight ;
|
|
CovBinPtr.all(NumBins).Name := new String'(Name) ;
|
|
CovBinPtr.all(NumBins).PercentCov := PercentCov ;
|
|
CovBinPtr.all(NumBins).OrderCount := 0 ; --- Metrics for evaluating randomization order Temp
|
|
end procedure InsertNewBin ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
-- pt local
|
|
-- Inserts values into a new bin.
|
|
-- Called by InsertBin
|
|
procedure MergeBin (
|
|
Position : Natural ;
|
|
Count : integer ;
|
|
AtLeast : integer ;
|
|
Weight : integer
|
|
) is
|
|
begin
|
|
CovBinPtr.all(Position).Count := CovBinPtr.all(Position).Count + Count ;
|
|
CovBinPtr.all(Position).AtLeast := CovBinPtr.all(Position).AtLeast + AtLeast ;
|
|
CovBinPtr.all(Position).Weight := CovBinPtr.all(Position).Weight + Weight ;
|
|
CovBinPtr.all(Position).PercentCov :=
|
|
real(CovBinPtr.all(Position).Count)*100.0/maximum(real(CovBinPtr.all(Position).AtLeast), 1.0) ;
|
|
end procedure MergeBin ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
-- pt local
|
|
-- All insertion comes here
|
|
-- Enforces the general insertion use model:
|
|
-- Earlier bins supercede later bins - except with COUNT_ALL
|
|
-- Add Illegal and Ignore bins first to remove regions of larger count bins
|
|
-- Later ignore bins can be used to miss an illegal catch-all
|
|
-- Add Illegal bins last as a catch-all to find things that missed other bins
|
|
procedure InsertBin(
|
|
BinVal : RangeArrayType ;
|
|
Action : integer ;
|
|
Count : integer ;
|
|
AtLeast : integer ;
|
|
Weight : integer ;
|
|
Name : string ;
|
|
PercentCov : real := 0.0
|
|
) is
|
|
variable Position : integer ;
|
|
variable FoundInside : boolean ;
|
|
begin
|
|
if not MergingEnable then
|
|
InsertNewBin(BinVal, Action, Count, AtLeast, Weight, Name, PercentCov) ;
|
|
|
|
else -- handle merging
|
|
-- future optimization, FindBinInside only checks against Ignore and Illegal bins
|
|
FindBinInside(BinVal, Position, FoundInside) ;
|
|
|
|
if not FoundInside then
|
|
InsertNewBin(BinVal, Action, Count, AtLeast, Weight, Name, PercentCov) ;
|
|
|
|
elsif Action = COV_COUNT then
|
|
-- when check only ignore and illegal bins, only action is to drop
|
|
if CovBinPtr.all(Position).Action /= COV_COUNT then
|
|
null ; -- drop count bin when it is inside a Illegal or Ignore bin
|
|
|
|
elsif CovBinPtr.all(Position).BinVal.all = BinVal and CovBinPtr.all(Position).Name.all = Name then
|
|
-- Bins match, so merge the count values
|
|
MergeBin (Position, Count, AtLeast, Weight) ;
|
|
else
|
|
-- Bins overlap, but do not match, insert new bin
|
|
InsertNewBin(BinVal, Action, Count, AtLeast, Weight, Name, PercentCov) ;
|
|
end if;
|
|
|
|
elsif Action = COV_IGNORE then
|
|
-- when check only ignore and illegal bins, only action is to report error
|
|
if CovBinPtr.all(Position).Action = COV_COUNT then
|
|
InsertNewBin(BinVal, Action, Count, AtLeast, Weight, Name, PercentCov) ;
|
|
else
|
|
Alert(AlertLogIDVar, GetNamePlus(prefix => "in ", suffix => ", ") & "CoveragePkg.InsertBin (AddBins/AddCross):" &
|
|
" ignore bin dropped. It is a subset of prior bin", ERROR) ;
|
|
end if;
|
|
|
|
elsif Action = COV_ILLEGAL then
|
|
-- when check only ignore and illegal bins, only action is to report error
|
|
if CovBinPtr.all(Position).Action = COV_COUNT then
|
|
InsertNewBin(BinVal, Action, Count, AtLeast, Weight, Name, PercentCov) ;
|
|
else
|
|
Alert(AlertLogIDVar, GetNamePlus(prefix => "in ", suffix => ", ") & "CoveragePkg.InsertBin (AddBins/AddCross):" &
|
|
" illegal bin dropped. It is a subset of prior bin", ERROR) ;
|
|
end if;
|
|
end if ;
|
|
end if ; -- merging enabled
|
|
end procedure InsertBin ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
procedure AddBins (
|
|
------------------------------------------------------------
|
|
Name : String ;
|
|
AtLeast : integer ;
|
|
Weight : integer ;
|
|
CovBin : CovBinType
|
|
) is
|
|
variable calcAtLeast : integer ;
|
|
variable calcWeight : integer ;
|
|
begin
|
|
CheckBinValLength( 1, "AddBins") ;
|
|
|
|
GrowBins(CovBin'length) ;
|
|
for i in CovBin'range loop
|
|
if CovBin(i).Action = COV_COUNT then
|
|
calcAtLeast := maximum(AtLeast, CovBin(i).AtLeast) ;
|
|
calcWeight := maximum(Weight, CovBin(i).Weight) ;
|
|
else
|
|
calcAtLeast := 0 ;
|
|
calcWeight := 0 ;
|
|
end if ;
|
|
InsertBin(
|
|
BinVal => CovBin(i).BinVal,
|
|
Action => CovBin(i).Action,
|
|
Count => CovBin(i).Count,
|
|
AtLeast => calcAtLeast,
|
|
Weight => calcWeight,
|
|
Name => Name
|
|
) ;
|
|
end loop ;
|
|
end procedure AddBins ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
procedure AddBins ( Name : String ; AtLeast : integer ; CovBin : CovBinType ) is
|
|
------------------------------------------------------------
|
|
begin
|
|
AddBins(Name, AtLeast, 0, CovBin) ;
|
|
end procedure AddBins ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
procedure AddBins (Name : String ; CovBin : CovBinType) is
|
|
------------------------------------------------------------
|
|
begin
|
|
AddBins(Name, 0, 0, CovBin) ;
|
|
end procedure AddBins ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
procedure AddBins ( AtLeast : integer ; Weight : integer ; CovBin : CovBinType ) is
|
|
------------------------------------------------------------
|
|
begin
|
|
AddBins("", AtLeast, Weight, CovBin) ;
|
|
end procedure AddBins ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
procedure AddBins ( AtLeast : integer ; CovBin : CovBinType ) is
|
|
------------------------------------------------------------
|
|
begin
|
|
AddBins("", AtLeast, 0, CovBin) ;
|
|
end procedure AddBins ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
procedure AddBins ( CovBin : CovBinType ) is
|
|
------------------------------------------------------------
|
|
begin
|
|
AddBins("", 0, 0, CovBin) ;
|
|
end procedure AddBins ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
procedure AddCross(
|
|
------------------------------------------------------------
|
|
Name : string ;
|
|
AtLeast : integer ;
|
|
Weight : integer ;
|
|
Bin1, Bin2 : CovBinType ;
|
|
Bin3, Bin4, Bin5, Bin6, Bin7, Bin8, Bin9, Bin10, Bin11, Bin12, Bin13,
|
|
Bin14, Bin15, Bin16, Bin17, Bin18, Bin19, Bin20 : CovBinType := NULL_BIN
|
|
) is
|
|
constant BIN_LENS : integer_vector :=
|
|
BinLengths(
|
|
Bin1, Bin2, Bin3, Bin4, Bin5, Bin6, Bin7, Bin8, Bin9, Bin10, Bin11,
|
|
Bin12, Bin13, Bin14, Bin15, Bin16, Bin17, Bin18, Bin19, Bin20
|
|
) ;
|
|
constant NUM_NEW_BINS : integer := CalcNumCrossBins(BIN_LENS) ;
|
|
variable BinIndex : integer_vector(1 to BIN_LENS'length) := (others => 1) ;
|
|
variable CrossBins : CovBinType(BinIndex'range) ;
|
|
variable calcAction, calcCount, calcAtLeast, calcWeight : integer ;
|
|
variable calcBinVal : RangeArrayType(BinIndex'range) ;
|
|
begin
|
|
CheckBinValLength( BIN_LENS'length, "AddCross") ;
|
|
|
|
GrowBins(NUM_NEW_BINS) ;
|
|
calcCount := 0 ;
|
|
for MatrixIndex in 1 to NUM_NEW_BINS loop
|
|
CrossBins := ConcatenateBins(BinIndex,
|
|
Bin1, Bin2, Bin3, Bin4, Bin5, Bin6, Bin7, Bin8, Bin9, Bin10, Bin11,
|
|
Bin12, Bin13, Bin14, Bin15, Bin16, Bin17, Bin18, Bin19, Bin20
|
|
) ;
|
|
calcAction := MergeState(CrossBins) ;
|
|
calcBinVal := MergeBinVal(CrossBins) ;
|
|
calcAtLeast := MergeAtLeast( calcAction, AtLeast, CrossBins) ;
|
|
calcWeight := MergeWeight ( calcAction, Weight, CrossBins) ;
|
|
InsertBin(calcBinVal, calcAction, calcCount, calcAtLeast, calcWeight, Name) ;
|
|
IncBinIndex( BinIndex, BIN_LENS) ; -- increment right most one, then if overflow, increment next
|
|
end loop ;
|
|
end procedure AddCross ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
procedure AddCross(
|
|
------------------------------------------------------------
|
|
Name : string ;
|
|
AtLeast : integer ;
|
|
Bin1, Bin2 : CovBinType ;
|
|
Bin3, Bin4, Bin5, Bin6, Bin7, Bin8, Bin9, Bin10, Bin11, Bin12, Bin13,
|
|
Bin14, Bin15, Bin16, Bin17, Bin18, Bin19, Bin20 : CovBinType := NULL_BIN
|
|
) is
|
|
begin
|
|
AddCross(Name, AtLeast, 0,
|
|
Bin1, Bin2, Bin3, Bin4, Bin5, Bin6, Bin7, Bin8, Bin9, Bin10, Bin11,
|
|
Bin12, Bin13, Bin14, Bin15, Bin16, Bin17, Bin18, Bin19, Bin20
|
|
) ;
|
|
end procedure AddCross ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
procedure AddCross(
|
|
------------------------------------------------------------
|
|
Name : string ;
|
|
Bin1, Bin2 : CovBinType ;
|
|
Bin3, Bin4, Bin5, Bin6, Bin7, Bin8, Bin9, Bin10, Bin11, Bin12, Bin13,
|
|
Bin14, Bin15, Bin16, Bin17, Bin18, Bin19, Bin20 : CovBinType := NULL_BIN
|
|
) is
|
|
begin
|
|
AddCross(Name, 0, 0,
|
|
Bin1, Bin2, Bin3, Bin4, Bin5, Bin6, Bin7, Bin8, Bin9, Bin10, Bin11,
|
|
Bin12, Bin13, Bin14, Bin15, Bin16, Bin17, Bin18, Bin19, Bin20
|
|
) ;
|
|
end procedure AddCross ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
procedure AddCross(
|
|
------------------------------------------------------------
|
|
AtLeast : integer ;
|
|
Weight : integer ;
|
|
Bin1, Bin2 : CovBinType ;
|
|
Bin3, Bin4, Bin5, Bin6, Bin7, Bin8, Bin9, Bin10, Bin11, Bin12, Bin13,
|
|
Bin14, Bin15, Bin16, Bin17, Bin18, Bin19, Bin20 : CovBinType := NULL_BIN
|
|
) is
|
|
begin
|
|
AddCross("", AtLeast, Weight,
|
|
Bin1, Bin2, Bin3, Bin4, Bin5, Bin6, Bin7, Bin8, Bin9, Bin10, Bin11,
|
|
Bin12, Bin13, Bin14, Bin15, Bin16, Bin17, Bin18, Bin19, Bin20
|
|
) ;
|
|
end procedure AddCross ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
procedure AddCross(
|
|
------------------------------------------------------------
|
|
AtLeast : integer ;
|
|
Bin1, Bin2 : CovBinType ;
|
|
Bin3, Bin4, Bin5, Bin6, Bin7, Bin8, Bin9, Bin10, Bin11, Bin12, Bin13,
|
|
Bin14, Bin15, Bin16, Bin17, Bin18, Bin19, Bin20 : CovBinType := NULL_BIN
|
|
) is
|
|
begin
|
|
AddCross("", AtLeast, 0,
|
|
Bin1, Bin2, Bin3, Bin4, Bin5, Bin6, Bin7, Bin8, Bin9, Bin10, Bin11,
|
|
Bin12, Bin13, Bin14, Bin15, Bin16, Bin17, Bin18, Bin19, Bin20
|
|
) ;
|
|
end procedure AddCross ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
procedure AddCross(
|
|
------------------------------------------------------------
|
|
Bin1, Bin2 : CovBinType ;
|
|
Bin3, Bin4, Bin5, Bin6, Bin7, Bin8, Bin9, Bin10, Bin11, Bin12, Bin13,
|
|
Bin14, Bin15, Bin16, Bin17, Bin18, Bin19, Bin20 : CovBinType := NULL_BIN
|
|
) is
|
|
begin
|
|
AddCross("", 0, 0,
|
|
Bin1, Bin2, Bin3, Bin4, Bin5, Bin6, Bin7, Bin8, Bin9, Bin10, Bin11,
|
|
Bin12, Bin13, Bin14, Bin15, Bin16, Bin17, Bin18, Bin19, Bin20
|
|
) ;
|
|
end procedure AddCross ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
procedure Deallocate is
|
|
------------------------------------------------------------
|
|
begin
|
|
for i in 1 to NumBins loop
|
|
deallocate(CovBinPtr(i).BinVal) ;
|
|
deallocate(CovBinPtr(i).Name) ;
|
|
end loop ;
|
|
deallocate(CovBinPtr) ;
|
|
DeallocateName ;
|
|
DeallocateMessage ;
|
|
-- Restore internal variables to their default values
|
|
NumBins := 0 ;
|
|
OrderCount := 0 ;
|
|
BinValLength := 1 ;
|
|
IllegalMode := ILLEGAL_ON ;
|
|
WeightMode := AT_LEAST ;
|
|
WeightScale := 1.0 ;
|
|
ThresholdingEnable := FALSE ;
|
|
CovThreshold := 45.0 ;
|
|
CovTarget := 100.0 ;
|
|
MergingEnable := FALSE ;
|
|
CountMode := COUNT_FIRST ;
|
|
AlertLogIDVar := OSVVM_ALERTLOG_ID ;
|
|
-- RvSeedInit := FALSE ;
|
|
WritePassFailVar := COV_OPT_INIT_PARM_DETECT ;
|
|
WriteBinInfoVar := COV_OPT_INIT_PARM_DETECT ;
|
|
WriteCountVar := COV_OPT_INIT_PARM_DETECT ;
|
|
WriteAnyIllegalVar := COV_OPT_INIT_PARM_DETECT ;
|
|
WritePrefixVar.deallocate ;
|
|
PassNameVar.deallocate ;
|
|
FailNameVar.deallocate ;
|
|
end procedure deallocate ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
-- Local
|
|
procedure ICoverIndex( Index : integer ; CovPoint : integer_vector ) is
|
|
------------------------------------------------------------
|
|
variable buf : line ;
|
|
begin
|
|
-- Update Count, PercentCov
|
|
CovBinPtr(Index).Count := CovBinPtr(Index).Count + CovBinPtr(Index).action ;
|
|
VendorCovBinInc(VendorCovHandleVar, Index); -- VendorCov
|
|
CovBinPtr(Index).PercentCov := real(CovBinPtr(Index).Count)*100.0/maximum(real(CovBinPtr(Index).AtLeast), 1.0) ;
|
|
-- OrderCount handling - Statistics
|
|
OrderCount := OrderCount + 1 ;
|
|
CovBinPtr(Index).OrderCount := OrderCount + CovBinPtr(Index).OrderCount ;
|
|
if CovBinPtr(Index).action = COV_ILLEGAL then
|
|
if IllegalMode /= ILLEGAL_OFF then
|
|
if CovPoint = NULL_INTV then
|
|
alert(AlertLogIDVar, GetNamePlus(prefix => "in ", suffix => ", ") & "CoveragePkg.ICoverLast:" &
|
|
" Value randomized is in an illegal bin.", IllegalModeLevel) ;
|
|
else
|
|
write(buf, CovPoint) ;
|
|
alert(AlertLogIDVar, GetNamePlus(prefix => "in ", suffix => ", ") & "CoveragePkg.ICover:" &
|
|
" Value " & buf.all & " is in an illegal bin.", IllegalModeLevel) ;
|
|
deallocate(buf) ;
|
|
end if ;
|
|
else
|
|
IncAlertCount(AlertLogIDVar, ERROR) ; -- silent alert.
|
|
end if ;
|
|
end if ;
|
|
end procedure ICoverIndex ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
procedure ICoverLast is
|
|
------------------------------------------------------------
|
|
begin
|
|
ICoverIndex(LastIndex, NULL_INTV) ;
|
|
end procedure ICoverLast ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
procedure ICover ( CovPoint : integer) is
|
|
------------------------------------------------------------
|
|
begin
|
|
ICover((1=> CovPoint)) ;
|
|
end procedure ICover ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
procedure ICover( CovPoint : integer_vector) is
|
|
------------------------------------------------------------
|
|
begin
|
|
if CovPoint'length /= BinValLength then
|
|
Alert(AlertLogIDVar, GetNamePlus(prefix => "in ", suffix => ", ") & "CoveragePkg." &
|
|
" ICover: CovPoint length = " & to_string(CovPoint'length) &
|
|
" does not match Coverage Bin dimensions = " & to_string(BinValLength), FAILURE) ;
|
|
elsif CountMode = COUNT_FIRST and inside(CovPoint, CovBinPtr(LastIndex).BinVal.all) then
|
|
ICoverIndex(LastIndex, CovPoint) ;
|
|
else
|
|
CovLoop : for i in 1 to NumBins loop
|
|
-- skip this CovBin if CovPoint is not in it
|
|
next CovLoop when not inside(CovPoint, CovBinPtr(i).BinVal.all) ;
|
|
-- Mark Covered
|
|
ICoverIndex(i, CovPoint) ;
|
|
exit CovLoop when CountMode = COUNT_FIRST ; -- only find first one
|
|
end loop CovLoop ;
|
|
end if ;
|
|
end procedure ICover ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
procedure ClearCov is
|
|
------------------------------------------------------------
|
|
begin
|
|
for i in 1 to NumBins loop
|
|
CovBinPtr(i).Count := 0 ;
|
|
CovBinPtr(i).PercentCov := 0.0 ;
|
|
CovBinPtr(i).OrderCount := 0 ;
|
|
end loop ;
|
|
OrderCount := 0 ;
|
|
end procedure ClearCov ;
|
|
|
|
------------------------------------------------------------
|
|
-- deprecated
|
|
procedure SetCovZero is
|
|
------------------------------------------------------------
|
|
begin
|
|
ClearCov ;
|
|
end procedure SetCovZero ;
|
|
|
|
------------------------------------------------------------
|
|
impure function IsInitialized return boolean is
|
|
------------------------------------------------------------
|
|
begin
|
|
return NumBins > 0 ;
|
|
end function IsInitialized ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
impure function GetNumBins return integer is
|
|
------------------------------------------------------------
|
|
begin
|
|
return NumBins ;
|
|
end function GetNumBins ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
impure function GetMinIndex return integer is
|
|
------------------------------------------------------------
|
|
variable MinCov : real := real'right ; -- big number
|
|
variable MinIndex : integer := NumBins ;
|
|
begin
|
|
CovLoop : for i in 1 to NumBins loop
|
|
if CovBinPtr(i).action = COV_COUNT and CovBinPtr(i).PercentCov < MinCov then
|
|
MinCov := CovBinPtr(i).PercentCov ;
|
|
MinIndex := i ;
|
|
end if ;
|
|
end loop CovLoop ;
|
|
return MinIndex ;
|
|
end function GetMinIndex ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
impure function GetMinCov return real is
|
|
------------------------------------------------------------
|
|
variable MinCov : real := real'right ; -- big number
|
|
begin
|
|
CovLoop : for i in 1 to NumBins loop
|
|
if CovBinPtr(i).action = COV_COUNT and CovBinPtr(i).PercentCov < MinCov then
|
|
MinCov := CovBinPtr(i).PercentCov ;
|
|
end if ;
|
|
end loop CovLoop ;
|
|
return MinCov ;
|
|
end function GetMinCov ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
impure function GetMinCount return integer is
|
|
------------------------------------------------------------
|
|
variable MinCount : integer := integer'right ; -- big number
|
|
begin
|
|
CovLoop : for i in 1 to NumBins loop
|
|
if CovBinPtr(i).action = COV_COUNT and CovBinPtr(i).Count < MinCount then
|
|
MinCount := CovBinPtr(i).Count ;
|
|
end if ;
|
|
end loop CovLoop ;
|
|
return MinCount ;
|
|
end function GetMinCount ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
impure function GetMaxIndex return integer is
|
|
------------------------------------------------------------
|
|
variable MaxCov : real := 0.0 ;
|
|
variable MaxIndex : integer := NumBins ;
|
|
begin
|
|
CovLoop : for i in 1 to NumBins loop
|
|
if CovBinPtr(i).action = COV_COUNT and CovBinPtr(i).PercentCov > MaxCov then
|
|
MaxCov := CovBinPtr(i).PercentCov ;
|
|
MaxIndex := i ;
|
|
end if ;
|
|
end loop CovLoop ;
|
|
return MaxIndex ;
|
|
end function GetMaxIndex ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
impure function GetMaxCov return real is
|
|
------------------------------------------------------------
|
|
variable MaxCov : real := 0.0 ;
|
|
begin
|
|
CovLoop : for i in 1 to NumBins loop
|
|
if CovBinPtr(i).action = COV_COUNT and CovBinPtr(i).PercentCov > MaxCov then
|
|
MaxCov := CovBinPtr(i).PercentCov ;
|
|
end if ;
|
|
end loop CovLoop ;
|
|
return MaxCov ;
|
|
end function GetMaxCov ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
impure function GetMaxCount return integer is
|
|
------------------------------------------------------------
|
|
variable MaxCount : integer := 0 ;
|
|
begin
|
|
CovLoop : for i in 1 to NumBins loop
|
|
if CovBinPtr(i).action = COV_COUNT and CovBinPtr(i).Count > MaxCount then
|
|
MaxCount := CovBinPtr(i).Count ;
|
|
end if ;
|
|
end loop CovLoop ;
|
|
return MaxCount ;
|
|
end function GetMaxCount ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
impure function CountCovHoles ( PercentCov : real ) return integer is
|
|
------------------------------------------------------------
|
|
variable HoleCount : integer := 0 ;
|
|
begin
|
|
CovLoop : for i in 1 to NumBins loop
|
|
if CovBinPtr(i).action = COV_COUNT and CovBinPtr(i).PercentCov < PercentCov then
|
|
HoleCount := HoleCount + 1 ;
|
|
end if ;
|
|
end loop CovLoop ;
|
|
return HoleCount ;
|
|
end function CountCovHoles ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
impure function CountCovHoles return integer is
|
|
------------------------------------------------------------
|
|
begin
|
|
return CountCovHoles(CovTarget) ;
|
|
end function CountCovHoles ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
impure function IsCovered ( PercentCov : real ) return boolean is
|
|
------------------------------------------------------------
|
|
begin
|
|
-- AlertIf(NumBins < 1, OSVVM_ALERTLOG_ID, "CoveragePkg.IsCovered: Empty Coverage Model", failure) ;
|
|
return CountCovHoles(PercentCov) = 0 ;
|
|
end function IsCovered ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
impure function IsCovered return boolean is
|
|
------------------------------------------------------------
|
|
begin
|
|
-- AlertIf(NumBins < 1, OSVVM_ALERTLOG_ID, "CoveragePkg.IsCovered: Empty Coverage Model", failure) ;
|
|
return CountCovHoles(CovTarget) = 0 ;
|
|
end function IsCovered ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
impure function GetCov ( PercentCov : real ) return real is
|
|
------------------------------------------------------------
|
|
variable TotalCovGoal, TotalCovCount, ScaledCovGoal : integer := 0 ;
|
|
begin
|
|
BinLoop : for i in 1 to NumBins loop
|
|
if CovBinPtr(i).action = COV_COUNT then
|
|
ScaledCovGoal := integer(ceil(PercentCov * real(CovBinPtr(i).AtLeast)/100.0)) ;
|
|
TotalCovGoal := TotalCovGoal + ScaledCovGoal ;
|
|
if CovBinPtr(i).Count <= ScaledCovGoal then
|
|
TotalCovCount := TotalCovCount + CovBinPtr(i).Count ;
|
|
else
|
|
-- do not count the extra values that exceed their cov goal
|
|
TotalCovCount := TotalCovCount + ScaledCovGoal ;
|
|
end if ;
|
|
end if ;
|
|
end loop BinLoop ;
|
|
return 100.0 * real(TotalCovCount) / real(TotalCovGoal) ;
|
|
end function GetCov ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
impure function GetCov return real is
|
|
------------------------------------------------------------
|
|
variable TotalCovGoal, TotalCovCount : integer := 0 ;
|
|
begin
|
|
return GetCov( CovTarget ) ;
|
|
end function GetCov ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
impure function GetItemCount return integer is
|
|
------------------------------------------------------------
|
|
begin
|
|
return ItemCount ;
|
|
end function GetItemCount ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
impure function GetTotalCovGoal ( PercentCov : real ) return integer is
|
|
------------------------------------------------------------
|
|
variable TotalCovGoal, ScaledCovGoal : integer := 0 ;
|
|
begin
|
|
BinLoop : for i in 1 to NumBins loop
|
|
if CovBinPtr(i).action = COV_COUNT then
|
|
ScaledCovGoal := integer(ceil(PercentCov * real(CovBinPtr(i).AtLeast)/100.0)) ;
|
|
TotalCovGoal := TotalCovGoal + ScaledCovGoal ;
|
|
end if ;
|
|
end loop BinLoop ;
|
|
return TotalCovGoal ;
|
|
end function GetTotalCovGoal ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
impure function GetTotalCovGoal return integer is
|
|
------------------------------------------------------------
|
|
begin
|
|
return GetTotalCovGoal(CovTarget) ;
|
|
end function GetTotalCovGoal ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
impure function GetLastIndex return integer is
|
|
------------------------------------------------------------
|
|
begin
|
|
return LastIndex ;
|
|
end function GetLastIndex ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
impure function GetHoleBinVal ( ReqHoleNum : integer ; PercentCov : real ) return RangeArrayType is
|
|
------------------------------------------------------------
|
|
variable HoleCount : integer := 0 ;
|
|
variable buf : line ;
|
|
begin
|
|
CovLoop : for i in 1 to NumBins loop
|
|
if CovBinPtr(i).action = COV_COUNT and CovBinPtr(i).PercentCov < PercentCov then
|
|
HoleCount := HoleCount + 1 ;
|
|
if HoleCount = ReqHoleNum then
|
|
return CovBinPtr(i).BinVal.all ;
|
|
end if ;
|
|
end if ;
|
|
end loop CovLoop ;
|
|
Alert(AlertLogIDVar, GetNamePlus(prefix => "in ", suffix => ", ") & "CoveragePkg.GetHoleBinVal:" &
|
|
" did not find a coverage hole. HoleCount = " & integer'image(HoleCount) &
|
|
" ReqHoleNum = " & integer'image(ReqHoleNum), ERROR
|
|
) ;
|
|
return CovBinPtr(NumBins).BinVal.all ;
|
|
|
|
end function GetHoleBinVal ;
|
|
|
|
------------------------------------------------------------
|
|
impure function GetHoleBinVal ( PercentCov : real ) return RangeArrayType is
|
|
------------------------------------------------------------
|
|
begin
|
|
return GetHoleBinVal(1, PercentCov) ;
|
|
end function GetHoleBinVal ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
impure function GetHoleBinVal ( ReqHoleNum : integer := 1 ) return RangeArrayType is
|
|
------------------------------------------------------------
|
|
begin
|
|
return GetHoleBinVal(ReqHoleNum, CovTarget) ;
|
|
end function GetHoleBinVal ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
impure function CalcWeight ( BinIndex : integer ; MaxCovPercent : real ) return integer is
|
|
-- pt local
|
|
------------------------------------------------------------
|
|
begin
|
|
case WeightMode is
|
|
when AT_LEAST => -- AtLeast
|
|
return CovBinPtr(BinIndex).AtLeast ;
|
|
|
|
when WEIGHT => -- Weight
|
|
return CovBinPtr(BinIndex).Weight ;
|
|
|
|
when REMAIN => -- (Adjust * AtLeast) - Count
|
|
return integer( Ceil( MaxCovPercent * real(CovBinPtr(BinIndex).AtLeast)/100.0)) -
|
|
CovBinPtr(BinIndex).Count ;
|
|
|
|
when REMAIN_EXP => -- Weight * (REMAIN **WeightScale)
|
|
-- Experimental may be removed
|
|
-- CAUTION: for large numbers and/or WeightScale > 2.0, result can be > 2**31 (max integer value)
|
|
-- both Weight and WeightScale default to 1
|
|
return CovBinPtr(BinIndex).Weight *
|
|
integer( Ceil (
|
|
( (MaxCovPercent * real(CovBinPtr(BinIndex).AtLeast)/100.0) -
|
|
real(CovBinPtr(BinIndex).Count) ) ** WeightScale ) );
|
|
|
|
when REMAIN_SCALED => -- (WeightScale * Adjust * AtLeast) - Count
|
|
-- Experimental may be removed
|
|
-- Biases remainder toward AT_LEAST value.
|
|
-- WeightScale must be > 1.0
|
|
return integer( Ceil( WeightScale * MaxCovPercent * real(CovBinPtr(BinIndex).AtLeast)/100.0)) -
|
|
CovBinPtr(BinIndex).Count ;
|
|
|
|
when REMAIN_WEIGHT => -- Weight * ((WeightScale * Adjust * AtLeast) - Count)
|
|
-- Experimental may be removed
|
|
-- WeightScale must be > 1.0
|
|
return CovBinPtr(BinIndex).Weight * (
|
|
integer( Ceil( WeightScale * MaxCovPercent * real(CovBinPtr(BinIndex).AtLeast)/100.0)) -
|
|
CovBinPtr(BinIndex).Count) ;
|
|
|
|
end case ;
|
|
end function CalcWeight ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
impure function RandHoleIndex ( CovTargetPercent : real ) return integer is
|
|
-- pt local
|
|
------------------------------------------------------------
|
|
variable WeightVec : integer_vector(0 to NumBins-1) ; -- Prep for change to DistInt
|
|
variable MaxCovPercent : real ;
|
|
variable MinCovPercent : real ;
|
|
begin
|
|
ItemCount := ItemCount + 1 ;
|
|
MinCovPercent := GetMinCov ;
|
|
if ThresholdingEnable then
|
|
MaxCovPercent := MinCovPercent + CovThreshold ;
|
|
if MinCovPercent < CovTargetPercent then
|
|
-- Clip at CovTargetPercent until reach CovTargetPercent
|
|
MaxCovPercent := minimum(MaxCovPercent, CovTargetPercent);
|
|
end if ;
|
|
else
|
|
if MinCovPercent < CovTargetPercent then
|
|
MaxCovPercent := CovTargetPercent ;
|
|
else
|
|
-- Done, Enable all bins
|
|
MaxCovPercent := GetMaxCov + 1.0 ;
|
|
-- MaxCovPercent := real'right ; -- weight scale issues
|
|
end if ;
|
|
end if ;
|
|
CovLoop : for i in 1 to NumBins loop
|
|
if CovBinPtr(i).action = COV_COUNT and CovBinPtr(i).PercentCov < MaxCovPercent then
|
|
-- Calculate Weight based on WeightMode
|
|
-- Scale to current percentage goal: MaxCov which can be < or > 100.0
|
|
WeightVec(i-1) := CalcWeight(i, MaxCovPercent) ;
|
|
else
|
|
WeightVec(i-1) := 0 ;
|
|
end if ;
|
|
end loop CovLoop ;
|
|
-- DistInt returns integer range 0 to Numbins-1
|
|
-- Caution: DistInt can fail when sum(WeightVec) > 2**31
|
|
-- See notes in CalcWeight for REMAIN_EXP
|
|
LastIndex := 1 + RV.DistInt( WeightVec ) ; -- return range 1 to NumBins
|
|
return LastIndex ;
|
|
end function RandHoleIndex ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
impure function GetBinVal ( BinIndex : integer ) return RangeArrayType is
|
|
------------------------------------------------------------
|
|
begin
|
|
return CovBinPtr( BinIndex ).BinVal.all ;
|
|
end function GetBinVal ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
impure function GetLastBinVal return RangeArrayType is
|
|
------------------------------------------------------------
|
|
begin
|
|
return CovBinPtr( LastIndex ).BinVal.all ;
|
|
end function GetLastBinVal ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
impure function RandCovBinVal ( PercentCov : real ) return RangeArrayType is
|
|
------------------------------------------------------------
|
|
begin
|
|
return CovBinPtr( RandHoleIndex(PercentCov) ).BinVal.all ; -- GetBinVal
|
|
end function RandCovBinVal ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
impure function RandCovBinVal return RangeArrayType is
|
|
------------------------------------------------------------
|
|
begin
|
|
-- use global coverage target
|
|
return CovBinPtr( RandHoleIndex( CovTarget ) ).BinVal.all ; -- GetBinVal
|
|
end function RandCovBinVal ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
impure function GetMinBinVal return RangeArrayType is
|
|
------------------------------------------------------------
|
|
begin
|
|
-- use global coverage target
|
|
return GetBinVal( GetMinIndex ) ;
|
|
end function GetMinBinVal ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
impure function GetMaxBinVal return RangeArrayType is
|
|
------------------------------------------------------------
|
|
begin
|
|
-- use global coverage target
|
|
return GetBinVal( GetMaxIndex ) ;
|
|
end function GetMaxBinVal ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
-- impure function RandCovPoint( BinVal : RangeArrayType ) return integer_vector is
|
|
impure function ToRandPoint( BinVal : RangeArrayType ) return integer_vector is
|
|
-- pt local
|
|
------------------------------------------------------------
|
|
variable CovPoint : integer_vector(BinVal'range) ;
|
|
variable normCovPoint : integer_vector(1 to BinVal'length) ;
|
|
begin
|
|
for i in BinVal'range loop
|
|
CovPoint(i) := RV.RandInt(BinVal(i).min, BinVal(i).max) ;
|
|
end loop ;
|
|
normCovPoint := CovPoint ;
|
|
return normCovPoint ;
|
|
end function ToRandPoint ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
impure function ToRandPoint( BinVal : RangeArrayType ) return integer is
|
|
-- pt local
|
|
------------------------------------------------------------
|
|
begin
|
|
return RV.RandInt(BinVal(BinVal'left).min, BinVal(BinVal'left).max) ;
|
|
end function ToRandPoint ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
impure function RandCovPoint return integer is
|
|
------------------------------------------------------------
|
|
begin
|
|
return ToRandPoint(RandCovBinVal(CovTarget)) ;
|
|
end function RandCovPoint ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
impure function RandCovPoint ( PercentCov : real ) return integer is
|
|
------------------------------------------------------------
|
|
begin
|
|
return ToRandPoint(RandCovBinVal(PercentCov)) ;
|
|
end function RandCovPoint ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
impure function RandCovPoint return integer_vector is
|
|
------------------------------------------------------------
|
|
begin
|
|
return ToRandPoint(RandCovBinVal(CovTarget)) ;
|
|
end function RandCovPoint ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
impure function RandCovPoint ( PercentCov : real ) return integer_vector is
|
|
------------------------------------------------------------
|
|
begin
|
|
return ToRandPoint(RandCovBinVal(PercentCov)) ;
|
|
end function RandCovPoint ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
impure function GetPoint ( BinIndex : integer ) return integer is
|
|
------------------------------------------------------------
|
|
begin
|
|
return ToRandPoint(GetBinVal(BinIndex)) ;
|
|
end function GetPoint ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
impure function GetPoint ( BinIndex : integer ) return integer_vector is
|
|
------------------------------------------------------------
|
|
begin
|
|
return ToRandPoint(GetBinVal(BinIndex)) ;
|
|
end function GetPoint ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
impure function GetMinPoint return integer is
|
|
------------------------------------------------------------
|
|
begin
|
|
return ToRandPoint(GetBinVal( GetMinIndex )) ;
|
|
end function GetMinPoint ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
impure function GetMinPoint return integer_vector is
|
|
------------------------------------------------------------
|
|
begin
|
|
return ToRandPoint(GetBinVal( GetMinIndex )) ;
|
|
end function GetMinPoint ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
impure function GetMaxPoint return integer is
|
|
------------------------------------------------------------
|
|
begin
|
|
return ToRandPoint(GetBinVal( GetMaxIndex )) ;
|
|
end function GetMaxPoint ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
impure function GetMaxPoint return integer_vector is
|
|
------------------------------------------------------------
|
|
begin
|
|
return ToRandPoint(GetBinVal( GetMaxIndex )) ;
|
|
end function GetMaxPoint ;
|
|
|
|
|
|
-- ------------------------------------------------------------
|
|
-- Intended as a stand in until we get a more general GetBin
|
|
impure function GetBinInfo ( BinIndex : integer ) return CovBinBaseType is
|
|
-- ------------------------------------------------------------
|
|
variable result : CovBinBaseType ;
|
|
begin
|
|
result.BinVal := ALL_RANGE;
|
|
result.Action := CovBinPtr(BinIndex).Action;
|
|
result.Count := CovBinPtr(BinIndex).Count;
|
|
result.AtLeast := CovBinPtr(BinIndex).AtLeast;
|
|
result.Weight := CovBinPtr(BinIndex).Weight;
|
|
return result ;
|
|
end function GetBinInfo ;
|
|
|
|
|
|
-- ------------------------------------------------------------
|
|
-- Intended as a stand in until we get a more general GetBin
|
|
impure function GetBinValLength return integer is
|
|
-- ------------------------------------------------------------
|
|
begin
|
|
return BinValLength ;
|
|
end function GetBinValLength ;
|
|
|
|
|
|
-- Eventually the multiple GetBin functions will be replaced by a
|
|
-- a single GetBin that returns CovBinBaseType with BinVal as an
|
|
-- unconstrained element
|
|
-- ------------------------------------------------------------
|
|
impure function GetBin ( BinIndex : integer ) return CovBinBaseType is
|
|
-- ------------------------------------------------------------
|
|
variable result : CovBinBaseType ;
|
|
begin
|
|
result.BinVal := CovBinPtr(BinIndex).BinVal.all;
|
|
result.Action := CovBinPtr(BinIndex).Action;
|
|
result.Count := CovBinPtr(BinIndex).Count;
|
|
result.AtLeast := CovBinPtr(BinIndex).AtLeast;
|
|
result.Weight := CovBinPtr(BinIndex).Weight;
|
|
return result ;
|
|
end function GetBin ;
|
|
|
|
|
|
-- ------------------------------------------------------------
|
|
impure function GetBin ( BinIndex : integer ) return CovMatrix2BaseType is
|
|
-- ------------------------------------------------------------
|
|
variable result : CovMatrix2BaseType ;
|
|
begin
|
|
result.BinVal := CovBinPtr(BinIndex).BinVal.all;
|
|
result.Action := CovBinPtr(BinIndex).Action;
|
|
result.Count := CovBinPtr(BinIndex).Count;
|
|
result.AtLeast := CovBinPtr(BinIndex).AtLeast;
|
|
result.Weight := CovBinPtr(BinIndex).Weight;
|
|
return result ;
|
|
end function GetBin ;
|
|
|
|
|
|
-- ------------------------------------------------------------
|
|
impure function GetBin ( BinIndex : integer ) return CovMatrix3BaseType is
|
|
-- ------------------------------------------------------------
|
|
variable result : CovMatrix3BaseType ;
|
|
begin
|
|
result.BinVal := CovBinPtr(BinIndex).BinVal.all;
|
|
result.Action := CovBinPtr(BinIndex).Action;
|
|
result.Count := CovBinPtr(BinIndex).Count;
|
|
result.AtLeast := CovBinPtr(BinIndex).AtLeast;
|
|
result.Weight := CovBinPtr(BinIndex).Weight;
|
|
return result ;
|
|
end function GetBin ;
|
|
|
|
|
|
-- ------------------------------------------------------------
|
|
impure function GetBin ( BinIndex : integer ) return CovMatrix4BaseType is
|
|
-- ------------------------------------------------------------
|
|
variable result : CovMatrix4BaseType ;
|
|
begin
|
|
result.BinVal := CovBinPtr(BinIndex).BinVal.all;
|
|
result.Action := CovBinPtr(BinIndex).Action;
|
|
result.Count := CovBinPtr(BinIndex).Count;
|
|
result.AtLeast := CovBinPtr(BinIndex).AtLeast;
|
|
result.Weight := CovBinPtr(BinIndex).Weight;
|
|
return result ;
|
|
end function GetBin ;
|
|
|
|
|
|
-- ------------------------------------------------------------
|
|
impure function GetBin ( BinIndex : integer ) return CovMatrix5BaseType is
|
|
-- ------------------------------------------------------------
|
|
variable result : CovMatrix5BaseType ;
|
|
begin
|
|
result.BinVal := CovBinPtr(BinIndex).BinVal.all;
|
|
result.Action := CovBinPtr(BinIndex).Action;
|
|
result.Count := CovBinPtr(BinIndex).Count;
|
|
result.AtLeast := CovBinPtr(BinIndex).AtLeast;
|
|
result.Weight := CovBinPtr(BinIndex).Weight;
|
|
return result ;
|
|
end function GetBin ;
|
|
|
|
|
|
-- ------------------------------------------------------------
|
|
impure function GetBin ( BinIndex : integer ) return CovMatrix6BaseType is
|
|
-- ------------------------------------------------------------
|
|
variable result : CovMatrix6BaseType ;
|
|
begin
|
|
result.BinVal := CovBinPtr(BinIndex).BinVal.all;
|
|
result.Action := CovBinPtr(BinIndex).Action;
|
|
result.Count := CovBinPtr(BinIndex).Count;
|
|
result.AtLeast := CovBinPtr(BinIndex).AtLeast;
|
|
result.Weight := CovBinPtr(BinIndex).Weight;
|
|
return result ;
|
|
end function GetBin ;
|
|
|
|
|
|
-- ------------------------------------------------------------
|
|
impure function GetBin ( BinIndex : integer ) return CovMatrix7BaseType is
|
|
-- ------------------------------------------------------------
|
|
variable result : CovMatrix7BaseType ;
|
|
begin
|
|
result.BinVal := CovBinPtr(BinIndex).BinVal.all;
|
|
result.Action := CovBinPtr(BinIndex).Action;
|
|
result.Count := CovBinPtr(BinIndex).Count;
|
|
result.AtLeast := CovBinPtr(BinIndex).AtLeast;
|
|
result.Weight := CovBinPtr(BinIndex).Weight;
|
|
return result ;
|
|
end function GetBin ;
|
|
|
|
|
|
-- ------------------------------------------------------------
|
|
impure function GetBin ( BinIndex : integer ) return CovMatrix8BaseType is
|
|
-- ------------------------------------------------------------
|
|
variable result : CovMatrix8BaseType ;
|
|
begin
|
|
result.BinVal := CovBinPtr(BinIndex).BinVal.all;
|
|
result.Action := CovBinPtr(BinIndex).Action;
|
|
result.Count := CovBinPtr(BinIndex).Count;
|
|
result.AtLeast := CovBinPtr(BinIndex).AtLeast;
|
|
result.Weight := CovBinPtr(BinIndex).Weight;
|
|
return result ;
|
|
end function GetBin ;
|
|
|
|
|
|
-- ------------------------------------------------------------
|
|
impure function GetBin ( BinIndex : integer ) return CovMatrix9BaseType is
|
|
-- ------------------------------------------------------------
|
|
variable result : CovMatrix9BaseType ;
|
|
begin
|
|
result.BinVal := CovBinPtr(BinIndex).BinVal.all;
|
|
result.Action := CovBinPtr(BinIndex).Action;
|
|
result.Count := CovBinPtr(BinIndex).Count;
|
|
result.AtLeast := CovBinPtr(BinIndex).AtLeast;
|
|
result.Weight := CovBinPtr(BinIndex).Weight;
|
|
return result ;
|
|
end function GetBin ;
|
|
|
|
-- ------------------------------------------------------------
|
|
impure function GetBinName ( BinIndex : integer; DefaultName : string := "" ) return string is
|
|
-- ------------------------------------------------------------
|
|
begin
|
|
if CovBinPtr(BinIndex).Name.all /= "" then
|
|
return CovBinPtr(BinIndex).Name.all ;
|
|
else
|
|
return DefaultName ;
|
|
end if;
|
|
end function GetBinName;
|
|
|
|
------------------------------------------------------------
|
|
-- pt local for now -- file formal parameter not allowed with method
|
|
procedure WriteBin (
|
|
file f : text ;
|
|
WritePassFail : CovOptionsType ;
|
|
WriteBinInfo : CovOptionsType ;
|
|
WriteCount : CovOptionsType ;
|
|
WriteAnyIllegal : CovOptionsType ;
|
|
WritePrefix : string ;
|
|
PassName : string ;
|
|
FailName : string
|
|
) is
|
|
------------------------------------------------------------
|
|
variable buf : line ;
|
|
begin
|
|
if NumBins < 1 then
|
|
if WriteBinFileInit or UsingLocalFile then
|
|
swrite(buf, WritePrefix & " " & FailName & " ") ;
|
|
swrite(buf, GetNamePlus(prefix => "in ", suffix => ", ") & "CoveragePkg.WriteBin: Coverage model is empty. Nothing to print.") ;
|
|
writeline(f, buf) ;
|
|
end if ;
|
|
Alert(AlertLogIDVar, GetNamePlus(prefix => "in ", suffix => ", ") & "CoveragePkg.WriteBin:" &
|
|
" Coverage model is empty. Nothing to print.", FAILURE) ;
|
|
return ;
|
|
end if ;
|
|
-- Models with Bins
|
|
WriteBinName(f, "WriteBin: ", WritePrefix) ;
|
|
for i in 1 to NumBins loop -- CovBinPtr.all'range
|
|
if CovBinPtr(i).action = COV_COUNT or
|
|
(CovBinPtr(i).action = COV_ILLEGAL and IsEnabled(WriteAnyIllegal)) or
|
|
CovBinPtr(i).count < 0 -- Illegal bin with errors
|
|
then
|
|
-- WriteBin Info
|
|
swrite(buf, WritePrefix) ;
|
|
if CovBinPtr(i).Name.all /= "" then
|
|
swrite(buf, CovBinPtr(i).Name.all & " ") ;
|
|
end if ;
|
|
if IsEnabled(WritePassFail) then
|
|
-- For illegal bins, AtLeast = 0 and count is negative.
|
|
if CovBinPtr(i).count >= CovBinPtr(i).AtLeast then
|
|
swrite(buf, PassName & ' ') ;
|
|
else
|
|
swrite(buf, FailName & ' ') ;
|
|
end if ;
|
|
end if ;
|
|
if IsEnabled(WriteBinInfo) then
|
|
if CovBinPtr(i).action = COV_COUNT then
|
|
swrite(buf, "Bin:") ;
|
|
else
|
|
swrite(buf, "Illegal Bin:") ;
|
|
end if;
|
|
write(buf, CovBinPtr(i).BinVal.all) ;
|
|
end if ;
|
|
if IsEnabled(WriteCount) then
|
|
write(buf, " Count = " & integer'image(abs(CovBinPtr(i).count))) ;
|
|
write(buf, " AtLeast = " & integer'image(CovBinPtr(i).AtLeast)) ;
|
|
if WeightMode = WEIGHT or WeightMode = REMAIN_WEIGHT then
|
|
-- Print Weight only when it is used
|
|
write(buf, " Weight = " & integer'image(CovBinPtr(i).Weight)) ;
|
|
end if ;
|
|
end if ;
|
|
writeline(f, buf) ;
|
|
end if ;
|
|
end loop ;
|
|
swrite(buf, "") ;
|
|
writeline(f, buf) ;
|
|
end procedure WriteBin ;
|
|
|
|
------------------------------------------------------------
|
|
procedure WriteBin (
|
|
------------------------------------------------------------
|
|
WritePassFail : CovOptionsType := COV_OPT_INIT_PARM_DETECT ;
|
|
WriteBinInfo : CovOptionsType := COV_OPT_INIT_PARM_DETECT ;
|
|
WriteCount : CovOptionsType := COV_OPT_INIT_PARM_DETECT ;
|
|
WriteAnyIllegal : CovOptionsType := COV_OPT_INIT_PARM_DETECT ;
|
|
WritePrefix : string := OSVVM_STRING_INIT_PARM_DETECT ;
|
|
PassName : string := OSVVM_STRING_INIT_PARM_DETECT ;
|
|
FailName : string := OSVVM_STRING_INIT_PARM_DETECT
|
|
) is
|
|
constant rWritePassFail : CovOptionsType := ResolveCovWritePassFail(WritePassFail, WritePassFailVar) ;
|
|
constant rWriteBinInfo : CovOptionsType := ResolveCovWriteBinInfo(WriteBinInfo, WriteBinInfoVar ) ;
|
|
constant rWriteCount : CovOptionsType := ResolveCovWriteCount(WriteCount, WriteCountVar ) ;
|
|
constant rWriteAnyIllegal : CovOptionsType := ResolveCovWriteAnyIllegal(WriteAnyIllegal, WriteAnyIllegalVar) ;
|
|
constant rWritePrefix : string := ResolveOsvvmWritePrefix(WritePrefix, WritePrefixVar.GetOpt) ;
|
|
constant rPassName : string := ResolveOsvvmPassName(PassName, PassNameVar.GetOpt ) ;
|
|
constant rFailName : string := ResolveOsvvmFailName(FailName, FailNameVar.GetOpt ) ;
|
|
begin
|
|
if WriteBinFileInit then
|
|
-- Write to Local WriteBinFile - Deprecated, recommend use TranscriptFile instead
|
|
WriteBin (
|
|
f => WriteBinFile,
|
|
WritePassFail => rWritePassFail,
|
|
WriteBinInfo => rWriteBinInfo,
|
|
WriteCount => rWriteCount,
|
|
WriteAnyIllegal => rWriteAnyIllegal,
|
|
WritePrefix => rWritePrefix,
|
|
PassName => rPassName,
|
|
FailName => rFailName
|
|
) ;
|
|
elsif IsTranscriptEnabled then
|
|
-- Write to TranscriptFile
|
|
WriteBin (
|
|
f => TranscriptFile,
|
|
WritePassFail => rWritePassFail,
|
|
WriteBinInfo => rWriteBinInfo,
|
|
WriteCount => rWriteCount,
|
|
WriteAnyIllegal => rWriteAnyIllegal,
|
|
WritePrefix => rWritePrefix,
|
|
PassName => rPassName,
|
|
FailName => rFailName
|
|
) ;
|
|
if IsTranscriptMirrored then
|
|
-- Mirrored to OUTPUT
|
|
WriteBin (
|
|
f => OUTPUT,
|
|
WritePassFail => rWritePassFail,
|
|
WriteBinInfo => rWriteBinInfo,
|
|
WriteCount => rWriteCount,
|
|
WriteAnyIllegal => rWriteAnyIllegal,
|
|
WritePrefix => rWritePrefix,
|
|
PassName => rPassName,
|
|
FailName => rFailName
|
|
) ;
|
|
end if ;
|
|
else
|
|
-- Default Write to OUTPUT
|
|
WriteBin (
|
|
f => OUTPUT,
|
|
WritePassFail => rWritePassFail,
|
|
WriteBinInfo => rWriteBinInfo,
|
|
WriteCount => rWriteCount,
|
|
WriteAnyIllegal => rWriteAnyIllegal,
|
|
WritePrefix => rWritePrefix,
|
|
PassName => rPassName,
|
|
FailName => rFailName
|
|
) ;
|
|
end if ;
|
|
|
|
end procedure WriteBin ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
procedure WriteBin ( -- With LogLevel
|
|
------------------------------------------------------------
|
|
LogLevel : LogType ;
|
|
WritePassFail : CovOptionsType := COV_OPT_INIT_PARM_DETECT ;
|
|
WriteBinInfo : CovOptionsType := COV_OPT_INIT_PARM_DETECT ;
|
|
WriteCount : CovOptionsType := COV_OPT_INIT_PARM_DETECT ;
|
|
WriteAnyIllegal : CovOptionsType := COV_OPT_INIT_PARM_DETECT ;
|
|
WritePrefix : string := OSVVM_STRING_INIT_PARM_DETECT ;
|
|
PassName : string := OSVVM_STRING_INIT_PARM_DETECT ;
|
|
FailName : string := OSVVM_STRING_INIT_PARM_DETECT
|
|
) is
|
|
begin
|
|
if IsLogEnabled(AlertLogIDVar, LogLevel) then
|
|
WriteBin (
|
|
WritePassFail => WritePassFail,
|
|
WriteBinInfo => WriteBinInfo,
|
|
WriteCount => WriteCount,
|
|
WriteAnyIllegal => WriteAnyIllegal,
|
|
WritePrefix => WritePrefix,
|
|
PassName => PassName,
|
|
FailName => FailName
|
|
) ;
|
|
end if ;
|
|
end procedure WriteBin ; -- With LogLevel
|
|
|
|
|
|
------------------------------------------------------------
|
|
procedure WriteBin (
|
|
------------------------------------------------------------
|
|
FileName : string;
|
|
OpenKind : File_Open_Kind := APPEND_MODE ;
|
|
WritePassFail : CovOptionsType := COV_OPT_INIT_PARM_DETECT ;
|
|
WriteBinInfo : CovOptionsType := COV_OPT_INIT_PARM_DETECT ;
|
|
WriteCount : CovOptionsType := COV_OPT_INIT_PARM_DETECT ;
|
|
WriteAnyIllegal : CovOptionsType := COV_OPT_INIT_PARM_DETECT ;
|
|
WritePrefix : string := OSVVM_STRING_INIT_PARM_DETECT ;
|
|
PassName : string := OSVVM_STRING_INIT_PARM_DETECT ;
|
|
FailName : string := OSVVM_STRING_INIT_PARM_DETECT
|
|
) is
|
|
file LocalWriteBinFile : text open OpenKind is FileName ;
|
|
constant rWritePassFail : CovOptionsType := ResolveCovWritePassFail(WritePassFail, WritePassFailVar) ;
|
|
constant rWriteBinInfo : CovOptionsType := ResolveCovWriteBinInfo(WriteBinInfo, WriteBinInfoVar ) ;
|
|
constant rWriteCount : CovOptionsType := ResolveCovWriteCount(WriteCount, WriteCountVar ) ;
|
|
constant rWriteAnyIllegal : CovOptionsType := ResolveCovWriteAnyIllegal(WriteAnyIllegal, WriteAnyIllegalVar) ;
|
|
constant rWritePrefix : string := ResolveOsvvmWritePrefix(WritePrefix, WritePrefixVar.GetOpt) ;
|
|
constant rPassName : string := ResolveOsvvmPassName(PassName, PassNameVar.GetOpt ) ;
|
|
constant rFailName : string := ResolveOsvvmFailName(FailName, FailNameVar.GetOpt ) ;
|
|
begin
|
|
UsingLocalFile := TRUE ;
|
|
WriteBin (
|
|
f => LocalWriteBinFile,
|
|
WritePassFail => rWritePassFail,
|
|
WriteBinInfo => rWriteBinInfo,
|
|
WriteCount => rWriteCount,
|
|
WriteAnyIllegal => rWriteAnyIllegal,
|
|
WritePrefix => rWritePrefix,
|
|
PassName => rPassName,
|
|
FailName => rFailName
|
|
);
|
|
UsingLocalFile := FALSE ;
|
|
end procedure WriteBin ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
procedure WriteBin ( -- With LogLevel
|
|
------------------------------------------------------------
|
|
LogLevel : LogType ;
|
|
FileName : string;
|
|
OpenKind : File_Open_Kind := APPEND_MODE ;
|
|
WritePassFail : CovOptionsType := COV_OPT_INIT_PARM_DETECT ;
|
|
WriteBinInfo : CovOptionsType := COV_OPT_INIT_PARM_DETECT ;
|
|
WriteCount : CovOptionsType := COV_OPT_INIT_PARM_DETECT ;
|
|
WriteAnyIllegal : CovOptionsType := COV_OPT_INIT_PARM_DETECT ;
|
|
WritePrefix : string := OSVVM_STRING_INIT_PARM_DETECT ;
|
|
PassName : string := OSVVM_STRING_INIT_PARM_DETECT ;
|
|
FailName : string := OSVVM_STRING_INIT_PARM_DETECT
|
|
) is
|
|
begin
|
|
if IsLogEnabled(AlertLogIDVar, LogLevel) then
|
|
UsingLocalFile := TRUE ;
|
|
WriteBin (
|
|
FileName => FileName,
|
|
OpenKind => OpenKind,
|
|
WritePassFail => WritePassFail,
|
|
WriteBinInfo => WriteBinInfo,
|
|
WriteCount => WriteCount,
|
|
WriteAnyIllegal => WriteAnyIllegal,
|
|
WritePrefix => WritePrefix,
|
|
PassName => PassName,
|
|
FailName => FailName
|
|
) ;
|
|
UsingLocalFile := FALSE ;
|
|
end if ;
|
|
end procedure WriteBin ; -- With LogLevel
|
|
|
|
|
|
------------------------------------------------------------
|
|
-- Development only
|
|
-- pt local for now -- file formal parameter not allowed with method
|
|
procedure DumpBin ( file f : text ) is
|
|
------------------------------------------------------------
|
|
variable buf : line ;
|
|
begin
|
|
WriteBinName(f, "DumpBin: ") ;
|
|
-- if NumBins < 1 then
|
|
-- Write(f, "%%FATAL, Coverage Model is empty. Nothing to print." & LF ) ;
|
|
-- end if ;
|
|
for i in 1 to NumBins loop -- CovBinPtr.all'range
|
|
swrite(buf, "%% ") ;
|
|
if CovBinPtr(i).Name.all /= "" then
|
|
swrite(buf, CovBinPtr(i).Name.all & " ") ;
|
|
end if ;
|
|
swrite(buf, "Bin:") ;
|
|
write(buf, CovBinPtr(i).BinVal.all) ;
|
|
case CovBinPtr(i).action is
|
|
when COV_COUNT => swrite(buf, " Count = ") ;
|
|
when COV_IGNORE => swrite(buf, " Ignore = ") ;
|
|
when COV_ILLEGAL => swrite(buf, " Illegal = ") ;
|
|
when others => swrite(buf, " BOGUS BOGUS BOGUS = ") ;
|
|
end case ;
|
|
write(buf, CovBinPtr(i).count) ;
|
|
-- write(f, " Count = " & integer'image(CovBinPtr(i).count)) ;
|
|
write(buf, " AtLeast = " & integer'image(CovBinPtr(i).AtLeast)) ;
|
|
write(buf, " Weight = " & integer'image(CovBinPtr(i).Weight)) ;
|
|
write(buf, " OrderCount = " & integer'image(CovBinPtr(i).OrderCount)) ;
|
|
if CovBinPtr(i).count > 0 then
|
|
write(buf, " Normalized OrderCount = " & integer'image(CovBinPtr(i).OrderCount/CovBinPtr(i).count)) ;
|
|
end if ;
|
|
writeline(f, buf) ;
|
|
end loop ;
|
|
swrite(buf, "") ;
|
|
writeline(f,buf) ;
|
|
end procedure DumpBin ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
procedure DumpBin (LogLevel : LogType := DEBUG) is
|
|
------------------------------------------------------------
|
|
begin
|
|
if IsLogEnabled(AlertLogIDVar, LogLevel) then
|
|
if WriteBinFileInit then
|
|
-- Write to Local WriteBinFile - Deprecated, recommend use TranscriptFile instead
|
|
DumpBin(WriteBinFile) ;
|
|
elsif IsTranscriptEnabled then
|
|
-- Write to TranscriptFile
|
|
DumpBin(TranscriptFile) ;
|
|
if IsTranscriptMirrored then
|
|
-- Mirrored to OUTPUT
|
|
DumpBin(OUTPUT) ;
|
|
end if ;
|
|
else
|
|
-- Default Write to OUTPUT
|
|
DumpBin(OUTPUT) ;
|
|
end if ;
|
|
end if ;
|
|
end procedure DumpBin ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
-- pt local
|
|
procedure WriteCovHoles ( file f : text; PercentCov : real := 100.0 ) is
|
|
------------------------------------------------------------
|
|
variable buf : line ;
|
|
begin
|
|
if NumBins < 1 then
|
|
if WriteBinFileInit or UsingLocalFile then
|
|
-- Duplicate Alert in specified file
|
|
swrite(buf, "%% Alert FAILURE " & GetNamePlus(prefix => "in ", suffix => ", ") & "CoveragePkg.WriteCovHoles:" &
|
|
" coverage model empty. Nothing to print.") ;
|
|
writeline(f, buf) ;
|
|
end if ;
|
|
Alert(AlertLogIDVar, GetNamePlus(prefix => "in ", suffix => ", ") & "CoveragePkg.WriteCovHoles:" &
|
|
" coverage model empty. Nothing to print.", FAILURE) ;
|
|
return ;
|
|
end if ;
|
|
-- Models with Bins
|
|
WriteBinName(f, "WriteCovHoles: ") ;
|
|
CovLoop : for i in 1 to NumBins loop
|
|
if CovBinPtr(i).action = COV_COUNT and CovBinPtr(i).PercentCov < PercentCov then
|
|
swrite(buf, "%% ") ;
|
|
if CovBinPtr(i).Name.all /= "" then
|
|
swrite(buf, CovBinPtr(i).Name.all & " ") ;
|
|
end if ;
|
|
swrite(buf, "Bin:") ;
|
|
write(buf, CovBinPtr(i).BinVal.all) ;
|
|
write(buf, " Count = " & integer'image(CovBinPtr(i).Count)) ;
|
|
write(buf, " AtLeast = " & integer'image(CovBinPtr(i).AtLeast)) ;
|
|
if WeightMode = WEIGHT or WeightMode = REMAIN_WEIGHT then
|
|
-- Print Weight only when it is used
|
|
write(buf, " Weight = " & integer'image(CovBinPtr(i).Weight)) ;
|
|
end if ;
|
|
writeline(f, buf) ;
|
|
end if ;
|
|
end loop CovLoop ;
|
|
swrite(buf, "") ;
|
|
writeline(f, buf) ;
|
|
end procedure WriteCovHoles ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
procedure WriteCovHoles ( PercentCov : real ) is
|
|
------------------------------------------------------------
|
|
begin
|
|
if WriteBinFileInit then
|
|
-- Write to Local WriteBinFile - Deprecated, recommend use TranscriptFile instead
|
|
WriteCovHoles(WriteBinFile, PercentCov) ;
|
|
elsif IsTranscriptEnabled then
|
|
-- Write to TranscriptFile
|
|
WriteCovHoles(TranscriptFile, PercentCov) ;
|
|
if IsTranscriptMirrored then
|
|
-- Mirrored to OUTPUT
|
|
WriteCovHoles(OUTPUT, PercentCov) ;
|
|
end if ;
|
|
else
|
|
-- Default Write to OUTPUT
|
|
WriteCovHoles(OUTPUT, PercentCov) ;
|
|
end if;
|
|
end procedure WriteCovHoles ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
procedure WriteCovHoles ( LogLevel : LogType := ALWAYS ) is
|
|
------------------------------------------------------------
|
|
begin
|
|
if IsLogEnabled(AlertLogIDVar, LogLevel) then
|
|
WriteCovHoles(CovTarget) ;
|
|
end if;
|
|
end procedure WriteCovHoles ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
procedure WriteCovHoles ( LogLevel : LogType ; PercentCov : real ) is
|
|
------------------------------------------------------------
|
|
begin
|
|
if IsLogEnabled(AlertLogIDVar, LogLevel) then
|
|
WriteCovHoles(PercentCov) ;
|
|
end if;
|
|
end procedure WriteCovHoles ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
procedure WriteCovHoles ( FileName : string; OpenKind : File_Open_Kind := APPEND_MODE ) is
|
|
------------------------------------------------------------
|
|
file CovHoleFile : text open OpenKind is FileName ;
|
|
begin
|
|
UsingLocalFile := TRUE ;
|
|
WriteCovHoles(CovHoleFile, CovTarget) ;
|
|
UsingLocalFile := FALSE ;
|
|
end procedure WriteCovHoles ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
procedure WriteCovHoles ( LogLevel : LogType ; FileName : string; OpenKind : File_Open_Kind := APPEND_MODE ) is
|
|
------------------------------------------------------------
|
|
begin
|
|
if IsLogEnabled(AlertLogIDVar, LogLevel) then
|
|
WriteCovHoles(FileName, OpenKind) ;
|
|
end if;
|
|
end procedure WriteCovHoles ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
procedure WriteCovHoles ( FileName : string; PercentCov : real ; OpenKind : File_Open_Kind := APPEND_MODE ) is
|
|
------------------------------------------------------------
|
|
file CovHoleFile : text open OpenKind is FileName ;
|
|
begin
|
|
UsingLocalFile := TRUE ;
|
|
WriteCovHoles(CovHoleFile, PercentCov) ;
|
|
UsingLocalFile := FALSE ;
|
|
end procedure WriteCovHoles ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
procedure WriteCovHoles ( LogLevel : LogType ; FileName : string; PercentCov : real ; OpenKind : File_Open_Kind := APPEND_MODE ) is
|
|
------------------------------------------------------------
|
|
begin
|
|
if IsLogEnabled(AlertLogIDVar, LogLevel) then
|
|
WriteCovHoles(FileName, PercentCov, OpenKind) ;
|
|
end if;
|
|
end procedure WriteCovHoles ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
-- pt local
|
|
impure function FindExactBin (
|
|
-- find an exact match to a bin wrt BinVal, Action, AtLeast, Weight, and Name
|
|
------------------------------------------------------------
|
|
Merge : boolean ;
|
|
BinVal : RangeArrayType ;
|
|
Action : integer ;
|
|
AtLeast : integer ;
|
|
Weight : integer ;
|
|
Name : string
|
|
) return integer is
|
|
begin
|
|
if Merge then
|
|
for i in 1 to NumBins loop
|
|
if (BinVal = CovBinPtr(i).BinVal.all) and (Action = CovBinPtr(i).Action) and
|
|
(AtLeast = CovBinPtr(i).AtLeast) and (Weight = CovBinPtr(i).Weight) and
|
|
(Name = CovBinPtr(i).Name.all) then
|
|
return i ;
|
|
end if;
|
|
end loop ;
|
|
end if ;
|
|
return 0 ;
|
|
end function FindExactBin ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
-- pt local
|
|
procedure read (
|
|
------------------------------------------------------------
|
|
buf : inout line ;
|
|
NamePtr : inout line ;
|
|
NameLength : in integer ;
|
|
ReadValid : out boolean
|
|
) is
|
|
variable Name : string(1 to NameLength) ;
|
|
begin
|
|
if NameLength > 0 then
|
|
read(buf, Name, ReadValid) ;
|
|
NamePtr := new string'(Name) ;
|
|
else
|
|
ReadValid := TRUE ;
|
|
NamePtr := new string'("") ;
|
|
end if ;
|
|
end procedure read ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
-- pt local
|
|
procedure ReadCovVars (file CovDbFile : text; Good : out boolean ) is
|
|
------------------------------------------------------------
|
|
variable buf : line ;
|
|
variable Empty : boolean ;
|
|
variable MultiLineComment : boolean := FALSE ;
|
|
variable ReadValid : boolean ;
|
|
variable GoodLoop1 : boolean ;
|
|
variable iSeed : RandomSeedType ;
|
|
variable iIllegalMode : integer ;
|
|
variable iWeightMode : integer ;
|
|
variable iWeightScale : real ;
|
|
variable iCovThreshold : real ;
|
|
variable iCountMode : integer ;
|
|
variable iNumberOfMessages : integer ;
|
|
variable iThresholdingEnable : boolean ;
|
|
variable iCovTarget : real ;
|
|
variable iMergingEnable : boolean ;
|
|
begin
|
|
-- ReadLoop0 : while not EndFile(CovDbFile) loop
|
|
ReadLoop0 : loop -- allows emulation of "return when"
|
|
-- ReadLine to Get Coverage Model Name, skip blank and comment lines, fails when file empty
|
|
exit when AlertIf(AlertLogIDVar, EndFile(CovDbFile), GetNamePlus(prefix => "in ", suffix => ", ") &
|
|
"CoveragePkg.ReadCovDb: No Coverage Data to read", FAILURE) ;
|
|
ReadLine(CovDbFile, buf) ;
|
|
EmptyOrCommentLine(buf, Empty, MultiLineComment) ;
|
|
next when Empty ;
|
|
|
|
if buf.all /= "Coverage_Model_Not_Named" then
|
|
SetName(buf.all) ;
|
|
end if ;
|
|
|
|
exit ReadLoop0 ;
|
|
end loop ReadLoop0 ;
|
|
|
|
|
|
-- ReadLoop1 : while not EndFile(CovDbFile) loop
|
|
ReadLoop1 : loop
|
|
-- ReadLine to Get Variables, skip blank and comment lines, fails when file empty
|
|
exit when AlertIf(AlertLogIDVar, EndFile(CovDbFile), GetNamePlus(prefix => "in ", suffix => ", ") &
|
|
"CoveragePkg.ReadCovDb: Coverage DB File Incomplete", FAILURE) ;
|
|
ReadLine(CovDbFile, buf) ;
|
|
EmptyOrCommentLine(buf, Empty, MultiLineComment) ;
|
|
next when Empty ;
|
|
|
|
read(buf, iSeed, ReadValid) ;
|
|
exit when AlertIfNot(AlertLogIDVar, ReadValid, GetNamePlus(prefix => "in ", suffix => ", ") &
|
|
"CoveragePkg.ReadCovDb: Failed while reading Seed", FAILURE) ;
|
|
RV.SetSeed( iSeed ) ;
|
|
RvSeedInit := TRUE ;
|
|
|
|
read(buf, iCovThreshold, ReadValid) ;
|
|
exit when AlertIfNot(AlertLogIDVar, ReadValid, GetNamePlus(prefix => "in ", suffix => ", ") &
|
|
"CoveragePkg.ReadCovDb: Failed while reading CovThreshold", FAILURE) ;
|
|
CovThreshold := iCovThreshold ;
|
|
|
|
read(buf, iIllegalMode, ReadValid) ;
|
|
exit when AlertIfNot(AlertLogIDVar, ReadValid, GetNamePlus(prefix => "in ", suffix => ", ") &
|
|
"CoveragePkg.ReadCovDb: Failed while reading IllegalMode", FAILURE) ;
|
|
SetIllegalMode(IllegalModeType'val( iIllegalMode )) ;
|
|
|
|
read(buf, iWeightMode, ReadValid) ;
|
|
exit when AlertIfNot(AlertLogIDVar, ReadValid, GetNamePlus(prefix => "in ", suffix => ", ") &
|
|
"CoveragePkg.ReadCovDb: Failed while reading WeightMode", FAILURE) ;
|
|
WeightMode := WeightModeType'val( iWeightMode ) ;
|
|
|
|
read(buf, iWeightScale, ReadValid) ;
|
|
exit when AlertIfNot(AlertLogIDVar, ReadValid, GetNamePlus(prefix => "in ", suffix => ", ") &
|
|
"CoveragePkg.ReadCovDb: Failed while reading WeightScale", FAILURE) ;
|
|
WeightScale := iWeightScale ;
|
|
|
|
read(buf, iCountMode, ReadValid) ;
|
|
exit when AlertIfNot(AlertLogIDVar, ReadValid, GetNamePlus(prefix => "in ", suffix => ", ") &
|
|
"CoveragePkg.ReadCovDb: Failed while reading CountMode", FAILURE) ;
|
|
CountMode := CountModeType'val( iCountMode ) ;
|
|
|
|
read(buf, iThresholdingEnable, ReadValid) ;
|
|
exit when AlertIfNot(AlertLogIDVar, ReadValid, GetNamePlus(prefix => "in ", suffix => ", ") &
|
|
"CoveragePkg.ReadCovDb: Failed while reading CountMode", FAILURE) ;
|
|
ThresholdingEnable := iThresholdingEnable ;
|
|
|
|
read(buf, iCovTarget, ReadValid) ;
|
|
exit when AlertIfNot(AlertLogIDVar, ReadValid, GetNamePlus(prefix => "in ", suffix => ", ") &
|
|
"CoveragePkg.ReadCovDb: Failed while reading CountMode", FAILURE) ;
|
|
CovTarget := iCovTarget ;
|
|
|
|
read(buf, iMergingEnable, ReadValid) ;
|
|
exit when AlertIfNot(AlertLogIDVar, ReadValid, GetNamePlus(prefix => "in ", suffix => ", ") &
|
|
"CoveragePkg.ReadCovDb: Failed while reading CountMode", FAILURE) ;
|
|
MergingEnable := iMergingEnable ;
|
|
|
|
exit ReadLoop1 ;
|
|
end loop ReadLoop1 ;
|
|
|
|
GoodLoop1 := ReadValid ;
|
|
|
|
-- ReadLoop2 : while not EndFile(CovDbFile) loop
|
|
ReadLoop2 : while ReadValid loop
|
|
-- ReadLine to Coverage Model Header WriteBin Message, skip blank and comment lines, fails when file empty
|
|
exit when AlertIf(AlertLogIDVar, EndFile(CovDbFile), GetNamePlus(prefix => "in ", suffix => ", ") &
|
|
"CoveragePkg.ReadCovDb: Coverage DB File Incomplete", FAILURE) ;
|
|
ReadLine(CovDbFile, buf) ;
|
|
EmptyOrCommentLine(buf, Empty, MultiLineComment) ;
|
|
next when Empty ;
|
|
|
|
read(buf, iNumberOfMessages, ReadValid) ;
|
|
exit when AlertIfNot(AlertLogIDVar, ReadValid, GetNamePlus(prefix => "in ", suffix => ", ") &
|
|
"CoveragePkg.ReadCovDb: Failed while reading NumberOfMessages", FAILURE) ;
|
|
|
|
for i in 1 to iNumberOfMessages loop
|
|
exit when AlertIf(AlertLogIDVar, EndFile(CovDbFile), GetNamePlus(prefix => "in ", suffix => ", ") &
|
|
"CoveragePkg.ReadCovDb: End of File while reading Messages", FAILURE) ;
|
|
ReadLine(CovDbFile, buf) ;
|
|
SetMessage(buf.all) ;
|
|
end loop ;
|
|
|
|
exit ReadLoop2 ;
|
|
end loop ReadLoop2 ;
|
|
|
|
Good := ReadValid and GoodLoop1 ;
|
|
end procedure ReadCovVars ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
-- pt local
|
|
procedure ReadCovDbInfo (
|
|
------------------------------------------------------------
|
|
File CovDbFile : text ;
|
|
variable NumRangeItems : out integer ;
|
|
variable NumLines : out integer ;
|
|
variable Good : out boolean
|
|
) is
|
|
variable buf : line ;
|
|
variable ReadValid : boolean ;
|
|
variable Empty : boolean ;
|
|
variable MultiLineComment : boolean := FALSE ;
|
|
begin
|
|
|
|
ReadLoop : loop
|
|
-- ReadLine to RangeItems NumLines, skip blank and comment lines, fails when file empty
|
|
exit when AlertIf(AlertLogIDVar, EndFile(CovDbFile), GetNamePlus(prefix => "in ", suffix => ", ") &
|
|
"CoveragePkg.ReadCovDb: Coverage DB File Incomplete", FAILURE) ;
|
|
ReadLine(CovDbFile, buf) ;
|
|
EmptyOrCommentLine(buf, Empty, MultiLineComment) ;
|
|
next when Empty ;
|
|
|
|
read(buf, NumRangeItems, ReadValid) ;
|
|
exit when AlertIfNot(AlertLogIDVar, ReadValid, GetNamePlus(prefix => "in ", suffix => ", ") &
|
|
"CoveragePkg.ReadCovDb: Failed while reading NumRangeItems", FAILURE) ;
|
|
read(buf, NumLines, ReadValid) ;
|
|
exit when AlertIfNot(AlertLogIDVar, ReadValid, GetNamePlus(prefix => "in ", suffix => ", ") &
|
|
"CoveragePkg.ReadCovDb: Failed while reading NumLines", FAILURE) ;
|
|
exit ;
|
|
end loop ReadLoop ;
|
|
Good := ReadValid ;
|
|
end procedure ReadCovDbInfo ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
-- pt local
|
|
procedure ReadCovDbDataBase (
|
|
------------------------------------------------------------
|
|
File CovDbFile : text ;
|
|
constant NumRangeItems : in integer ;
|
|
constant NumLines : in integer ;
|
|
constant Merge : in boolean ;
|
|
variable Good : out boolean
|
|
) is
|
|
variable buf : line ;
|
|
variable Empty : boolean ;
|
|
variable MultiLineComment : boolean := FALSE ;
|
|
variable ReadValid : boolean ;
|
|
-- Format: Action Count min1 max1 min2 max2 ....
|
|
variable Action : integer ;
|
|
variable Count : integer ;
|
|
variable BinVal : RangeArrayType(1 to NumRangeItems) ;
|
|
variable index : integer ;
|
|
variable AtLeast : integer ;
|
|
variable Weight : integer ;
|
|
variable PercentCov : real ;
|
|
variable NameLength : integer ;
|
|
variable SkipBlank : character ;
|
|
variable NamePtr : line ;
|
|
begin
|
|
GrowBins(NumLines) ;
|
|
ReadLoop : for i in 1 to NumLines loop
|
|
|
|
GetValidLineLoop: loop
|
|
exit ReadLoop when AlertIf(AlertLogIDVar, EndFile(CovDbFile), GetNamePlus(prefix => "in ", suffix => ", ") &
|
|
"CoveragePkg.ReadCovDb: Did not read specified number of lines", FAILURE) ;
|
|
ReadLine(CovDbFile, buf) ;
|
|
EmptyOrCommentLine(buf, Empty, MultiLineComment) ;
|
|
next GetValidLineLoop when Empty ; -- replace with EmptyLine(buf)
|
|
exit GetValidLineLoop ;
|
|
end loop ;
|
|
|
|
read(buf, Action, ReadValid) ;
|
|
exit ReadLoop when AlertIfNot(AlertLogIDVar, ReadValid, GetNamePlus(prefix => "in ", suffix => ", ") &
|
|
"CoveragePkg.ReadCovDb: Failed while reading Action", FAILURE) ;
|
|
read(buf, Count, ReadValid) ;
|
|
exit ReadLoop when AlertIfNot(AlertLogIDVar, ReadValid, GetNamePlus(prefix => "in ", suffix => ", ") &
|
|
"CoveragePkg.ReadCovDb: Failed while reading Count", FAILURE) ;
|
|
read(buf, AtLeast, ReadValid) ;
|
|
exit ReadLoop when AlertIfNot(AlertLogIDVar, ReadValid, GetNamePlus(prefix => "in ", suffix => ", ") &
|
|
"CoveragePkg.ReadCovDb: Failed while reading AtLeast", FAILURE) ;
|
|
read(buf, Weight, ReadValid) ;
|
|
exit ReadLoop when AlertIfNot(AlertLogIDVar, ReadValid, GetNamePlus(prefix => "in ", suffix => ", ") &
|
|
"CoveragePkg.ReadCovDb: Failed while reading Weight", FAILURE) ;
|
|
read(buf, PercentCov, ReadValid) ;
|
|
exit ReadLoop when AlertIfNot(AlertLogIDVar, ReadValid, GetNamePlus(prefix => "in ", suffix => ", ") &
|
|
"CoveragePkg.ReadCovDb: Failed while reading PercentCov", FAILURE) ;
|
|
read(buf, BinVal, ReadValid) ;
|
|
exit ReadLoop when AlertIfNot(AlertLogIDVar, ReadValid, GetNamePlus(prefix => "in ", suffix => ", ") &
|
|
"CoveragePkg.ReadCovDb: Failed while reading BinVal", FAILURE) ;
|
|
read(buf, NameLength, ReadValid) ;
|
|
exit ReadLoop when AlertIfNot(AlertLogIDVar, ReadValid, GetNamePlus(prefix => "in ", suffix => ", ") &
|
|
"CoveragePkg.ReadCovDb: Failed while reading Bin Name Length", FAILURE) ;
|
|
read(buf, SkipBlank, ReadValid) ;
|
|
exit ReadLoop when AlertIfNot(AlertLogIDVar, ReadValid, GetNamePlus(prefix => "in ", suffix => ", ") &
|
|
"CoveragePkg.ReadCovDb: Failed while reading Bin Name Length", FAILURE) ;
|
|
read(buf, NamePtr, NameLength, ReadValid) ;
|
|
exit ReadLoop when AlertIfNot(AlertLogIDVar, ReadValid, GetNamePlus(prefix => "in ", suffix => ", ") &
|
|
"CoveragePkg.ReadCovDb: Failed while reading Bin Name", FAILURE) ;
|
|
index := FindExactBin(Merge, BinVal, Action, AtLeast, Weight, NamePtr.all) ;
|
|
if index > 0 then
|
|
-- Bin is an exact match so only merge the count values
|
|
CovBinPtr(index).Count := CovBinPtr(index).Count + Count ;
|
|
CovBinPtr(index).PercentCov := real(CovBinPtr(index).Count)*100.0/maximum(real(CovBinPtr(index).AtLeast), 1.0) ;
|
|
else
|
|
InsertNewBin(BinVal, Action, Count, AtLeast, Weight, NamePtr.all, PercentCov) ;
|
|
end if ;
|
|
deallocate(NamePtr) ;
|
|
end loop ReadLoop ;
|
|
Good := ReadValid ;
|
|
end ReadCovDbDataBase ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
-- pt local
|
|
procedure ReadCovDb (File CovDbFile : text; Merge : boolean := FALSE) is
|
|
------------------------------------------------------------
|
|
-- Format: Action Count min1 max1 min2 max2
|
|
-- file CovDbFile : text open READ_MODE is FileName ;
|
|
variable NumRangeItems : integer ;
|
|
variable NumLines : integer ;
|
|
variable ReadValid : boolean ;
|
|
begin
|
|
if not Merge then
|
|
Deallocate ; -- remove any old bins
|
|
end if ;
|
|
|
|
ReadLoop : loop
|
|
-- Read coverage private variables to the file
|
|
ReadCovVars(CovDbFile, ReadValid) ;
|
|
exit when not ReadValid ;
|
|
|
|
-- Get Coverage dimensions and number of items in file.
|
|
ReadCovDbInfo(CovDbFile, NumRangeItems, NumLines, ReadValid) ;
|
|
exit when not ReadValid ;
|
|
|
|
-- Read the file
|
|
ReadCovDbDataBase(CovDbFile, NumRangeItems, NumLines, Merge, ReadValid) ;
|
|
exit ;
|
|
end loop ReadLoop ;
|
|
end ReadCovDb ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
procedure ReadCovDb (FileName : string; Merge : boolean := FALSE) is
|
|
------------------------------------------------------------
|
|
-- Format: Action Count min1 max1 min2 max2
|
|
file CovDbFile : text open READ_MODE is FileName ;
|
|
begin
|
|
ReadCovDb(CovDbFile, Merge) ;
|
|
end procedure ReadCovDb ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
-- pt local
|
|
procedure WriteCovDbVars (file CovDbFile : text ) is
|
|
------------------------------------------------------------
|
|
variable buf : line ;
|
|
begin
|
|
-- write coverage private variables to the file
|
|
swrite(buf, CovNameVar.Get("Coverage_Model_Not_Named")) ;
|
|
writeline(CovDbFile, buf) ;
|
|
|
|
write(buf, RV.GetSeed ) ;
|
|
write(buf, ' ') ;
|
|
write(buf, CovThreshold, RIGHT, 0, 5) ;
|
|
write(buf, ' ') ;
|
|
write(buf, IllegalModeType'pos(IllegalMode)) ;
|
|
write(buf, ' ') ;
|
|
write(buf, WeightModeType'pos(WeightMode)) ;
|
|
write(buf, ' ') ;
|
|
write(buf, WeightScale, RIGHT, 0, 6) ;
|
|
write(buf, ' ') ;
|
|
write(buf, CountModeType'pos(CountMode)) ;
|
|
write(buf, ' ') ;
|
|
write(buf, ThresholdingEnable) ; -- boolean
|
|
write(buf, ' ') ;
|
|
write(buf, CovTarget, RIGHT, 0, 6) ; -- Real
|
|
write(buf, ' ') ;
|
|
write(buf, MergingEnable) ; -- boolean
|
|
write(buf, ' ') ;
|
|
writeline(CovDbFile, buf) ;
|
|
write(buf, CovMessageVar.GetCount ) ;
|
|
writeline(CovDbFile, buf) ;
|
|
WriteMessage(CovDbFile, CovMessageVar) ;
|
|
end procedure WriteCovDbVars ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
-- pt local
|
|
procedure WriteCovDb (file CovDbFile : text ) is
|
|
------------------------------------------------------------
|
|
-- Format: Action Count min1 max1 min2 max2
|
|
variable buf : line ;
|
|
begin
|
|
-- write Cover variables to the file
|
|
WriteCovDbVars( CovDbFile ) ;
|
|
|
|
-- write NumRangeItems, NumLines
|
|
write(buf, CovBinPtr(1).BinVal'length) ;
|
|
write(buf, ' ') ;
|
|
write(buf, NumBins) ;
|
|
write(buf, ' ') ;
|
|
writeline(CovDbFile, buf) ;
|
|
-- write coverage to a file
|
|
writeloop : for LineCount in 1 to NumBins loop
|
|
write(buf, CovBinPtr(LineCount).Action) ;
|
|
write(buf, ' ') ;
|
|
write(buf, CovBinPtr(LineCount).Count) ;
|
|
write(buf, ' ') ;
|
|
write(buf, CovBinPtr(LineCount).AtLeast) ;
|
|
write(buf, ' ') ;
|
|
write(buf, CovBinPtr(LineCount).Weight) ;
|
|
write(buf, ' ') ;
|
|
write(buf, CovBinPtr(LineCount).PercentCov, RIGHT, 0, 4) ;
|
|
write(buf, ' ') ;
|
|
WriteBinVal(buf, CovBinPtr(LineCount).BinVal.all) ;
|
|
write(buf, ' ') ;
|
|
write(buf, CovBinPtr(LineCount).Name'length) ;
|
|
write(buf, ' ') ;
|
|
write(buf, CovBinPtr(LineCount).Name.all) ;
|
|
writeline(CovDbFile, buf) ;
|
|
end loop WriteLoop ;
|
|
end procedure WriteCovDb ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
procedure WriteCovDb (FileName : string; OpenKind : File_Open_Kind := WRITE_MODE ) is
|
|
------------------------------------------------------------
|
|
-- Format: Action Count min1 max1 min2 max2
|
|
file CovDbFile : text open OpenKind is FileName ;
|
|
begin
|
|
if NumBins >= 1 then
|
|
WriteCovDb(CovDbFile) ;
|
|
else
|
|
Alert(AlertLogIDVar, GetNamePlus(prefix => "in ", suffix => ", ") &
|
|
"CoveragePkg.WriteCovDb: no bins defined ", FAILURE) ;
|
|
end if ;
|
|
end procedure WriteCovDb ;
|
|
|
|
|
|
-- ------------------------------------------------------------
|
|
-- procedure WriteCovDb is
|
|
-- ------------------------------------------------------------
|
|
-- begin
|
|
-- if WriteCovDbFileInit then
|
|
-- WriteCovDb(WriteCovDbFile) ;
|
|
-- else
|
|
-- report "CoveragePkg: WriteCovDb file not specified" severity failure ;
|
|
-- end if ;
|
|
-- end procedure WriteCovDb ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
impure function GetErrorCount return integer is
|
|
------------------------------------------------------------
|
|
variable ErrorCnt : integer := 0 ;
|
|
begin
|
|
if NumBins < 1 then
|
|
return 1 ; -- return error if model empty
|
|
else
|
|
for i in 1 to NumBins loop
|
|
if CovBinPtr(i).count < 0 then -- illegal CovBin
|
|
ErrorCnt := ErrorCnt + CovBinPtr(i).count ;
|
|
end if ;
|
|
end loop ;
|
|
return - ErrorCnt ;
|
|
end if ;
|
|
end function GetErrorCount ;
|
|
|
|
------------------------------------------------------------
|
|
-- These support usage of cross coverage constants
|
|
-- Also support the older AddBins(GenCross(...)) methodology
|
|
-- which has been replaced by AddCross
|
|
------------------------------------------------------------
|
|
procedure AddCross (CovBin : CovMatrix2Type ; Name : String := "") is
|
|
------------------------------------------------------------
|
|
begin
|
|
CheckBinValLength(2, "AddCross") ;
|
|
GrowBins(CovBin'length) ;
|
|
for i in CovBin'range loop
|
|
InsertBin(
|
|
CovBin(i).BinVal, CovBin(i).Action, CovBin(i).Count,
|
|
CovBin(i).AtLeast, CovBin(i).Weight, Name
|
|
) ;
|
|
end loop ;
|
|
end procedure AddCross ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
procedure AddCross (CovBin : CovMatrix3Type ; Name : String := "") is
|
|
------------------------------------------------------------
|
|
begin
|
|
CheckBinValLength(3, "AddCross") ;
|
|
GrowBins(CovBin'length) ;
|
|
for i in CovBin'range loop
|
|
InsertBin(
|
|
CovBin(i).BinVal, CovBin(i).Action, CovBin(i).Count,
|
|
CovBin(i).AtLeast, CovBin(i).Weight, Name
|
|
) ;
|
|
end loop ;
|
|
end procedure AddCross ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
procedure AddCross (CovBin : CovMatrix4Type ; Name : String := "") is
|
|
------------------------------------------------------------
|
|
begin
|
|
CheckBinValLength(4, "AddCross") ;
|
|
GrowBins(CovBin'length) ;
|
|
for i in CovBin'range loop
|
|
InsertBin(
|
|
CovBin(i).BinVal, CovBin(i).Action, CovBin(i).Count,
|
|
CovBin(i).AtLeast, CovBin(i).Weight, Name
|
|
) ;
|
|
end loop ;
|
|
end procedure AddCross ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
procedure AddCross (CovBin : CovMatrix5Type ; Name : String := "") is
|
|
------------------------------------------------------------
|
|
begin
|
|
CheckBinValLength(5, "AddCross") ;
|
|
GrowBins(CovBin'length) ;
|
|
for i in CovBin'range loop
|
|
InsertBin(
|
|
CovBin(i).BinVal, CovBin(i).Action, CovBin(i).Count,
|
|
CovBin(i).AtLeast, CovBin(i).Weight, Name
|
|
) ;
|
|
end loop ;
|
|
end procedure AddCross ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
procedure AddCross (CovBin : CovMatrix6Type ; Name : String := "") is
|
|
------------------------------------------------------------
|
|
begin
|
|
CheckBinValLength(6, "AddCross") ;
|
|
GrowBins(CovBin'length) ;
|
|
for i in CovBin'range loop
|
|
InsertBin(
|
|
CovBin(i).BinVal, CovBin(i).Action, CovBin(i).Count,
|
|
CovBin(i).AtLeast, CovBin(i).Weight, Name
|
|
) ;
|
|
end loop ;
|
|
end procedure AddCross ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
procedure AddCross (CovBin : CovMatrix7Type ; Name : String := "") is
|
|
------------------------------------------------------------
|
|
begin
|
|
CheckBinValLength(7, "AddCross") ;
|
|
GrowBins(CovBin'length) ;
|
|
for i in CovBin'range loop
|
|
InsertBin(
|
|
CovBin(i).BinVal, CovBin(i).Action, CovBin(i).Count,
|
|
CovBin(i).AtLeast, CovBin(i).Weight, Name
|
|
) ;
|
|
end loop ;
|
|
end procedure AddCross ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
procedure AddCross (CovBin : CovMatrix8Type ; Name : String := "") is
|
|
------------------------------------------------------------
|
|
begin
|
|
CheckBinValLength(8, "AddCross") ;
|
|
GrowBins(CovBin'length) ;
|
|
for i in CovBin'range loop
|
|
InsertBin(
|
|
CovBin(i).BinVal, CovBin(i).Action, CovBin(i).Count,
|
|
CovBin(i).AtLeast, CovBin(i).Weight, Name
|
|
) ;
|
|
end loop ;
|
|
end procedure AddCross ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
procedure AddCross (CovBin : CovMatrix9Type ; Name : String := "") is
|
|
------------------------------------------------------------
|
|
begin
|
|
CheckBinValLength(9, "AddCross") ;
|
|
GrowBins(CovBin'length) ;
|
|
for i in CovBin'range loop
|
|
InsertBin(
|
|
CovBin(i).BinVal, CovBin(i).Action, CovBin(i).Count,
|
|
CovBin(i).AtLeast, CovBin(i).Weight, Name
|
|
) ;
|
|
end loop ;
|
|
end procedure AddCross ;
|
|
|
|
-- ------------------------------------------------------------
|
|
-- ------------------------------------------------------------
|
|
-- Deprecated. Due to name changes to promote greater consistency
|
|
-- Maintained for backward compatibility.
|
|
-- ------------------------------------------------------------
|
|
|
|
------------------------------------------------------------
|
|
impure function CovBinErrCnt return integer is
|
|
-- Deprecated. Name changed to ErrorCount for package to package consistency
|
|
------------------------------------------------------------
|
|
begin
|
|
return GetErrorCount ;
|
|
end function CovBinErrCnt ;
|
|
|
|
------------------------------------------------------------
|
|
-- Deprecated. Same as RandCovBinVal
|
|
impure function RandCovHole ( PercentCov : real ) return RangeArrayType is
|
|
------------------------------------------------------------
|
|
begin
|
|
return RandCovBinVal(PercentCov) ;
|
|
end function RandCovHole ;
|
|
|
|
------------------------------------------------------------
|
|
-- Deprecated. Same as RandCovBinVal
|
|
impure function RandCovHole return RangeArrayType is
|
|
------------------------------------------------------------
|
|
begin
|
|
return RandCovBinVal ;
|
|
end function RandCovHole ;
|
|
|
|
-- GetCovHole replaced by GetHoleBinVal
|
|
------------------------------------------------------------
|
|
-- Deprecated. Same as GetHoleBinVal
|
|
impure function GetCovHole ( ReqHoleNum : integer ; PercentCov : real ) return RangeArrayType is
|
|
------------------------------------------------------------
|
|
begin
|
|
return GetHoleBinVal(ReqHoleNum, PercentCov) ;
|
|
end function GetCovHole ;
|
|
|
|
------------------------------------------------------------
|
|
-- Deprecated. Same as GetHoleBinVal
|
|
impure function GetCovHole ( PercentCov : real ) return RangeArrayType is
|
|
------------------------------------------------------------
|
|
begin
|
|
return GetHoleBinVal(PercentCov) ;
|
|
end function GetCovHole ;
|
|
|
|
------------------------------------------------------------
|
|
-- Deprecated. Same as GetHoleBinVal
|
|
impure function GetCovHole ( ReqHoleNum : integer := 1 ) return RangeArrayType is
|
|
------------------------------------------------------------
|
|
begin
|
|
return GetHoleBinVal(ReqHoleNum) ;
|
|
end function GetCovHole ;
|
|
|
|
-- ------------------------------------------------------------
|
|
-- ------------------------------------------------------------
|
|
-- Deprecated / Subsumed by versions with PercentCov Parameter
|
|
-- Maintained for backward compatibility only and
|
|
-- may be removed in the future.
|
|
-- ------------------------------------------------------------
|
|
|
|
------------------------------------------------------------
|
|
-- Deprecated. Replaced by SetMessage with multi-line support
|
|
procedure SetItemName (ItemNameIn : String) is
|
|
------------------------------------------------------------
|
|
begin
|
|
SetMessage(ItemNameIn) ;
|
|
end procedure SetItemName ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
-- Deprecated. Same as GetMinCount
|
|
impure function GetMinCov return integer is
|
|
------------------------------------------------------------
|
|
begin
|
|
return GetMinCount ;
|
|
end function GetMinCov ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
-- Deprecated. Same as GetMaxCount
|
|
impure function GetMaxCov return integer is
|
|
------------------------------------------------------------
|
|
begin
|
|
return GetMaxCount ;
|
|
end function GetMaxCov ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
-- Deprecated. New versions use PercentCov
|
|
impure function CountCovHoles ( AtLeast : integer ) return integer is
|
|
------------------------------------------------------------
|
|
variable HoleCount : integer := 0 ;
|
|
begin
|
|
CovLoop : for i in 1 to NumBins loop
|
|
-- if CovBinPtr(i).action = COV_COUNT and CovBinPtr(i).Count < minimum(AtLeast, CovBinPtr(i).AtLeast) then
|
|
if CovBinPtr(i).action = COV_COUNT and CovBinPtr(i).Count < AtLeast then
|
|
HoleCount := HoleCount + 1 ;
|
|
end if ;
|
|
end loop CovLoop ;
|
|
return HoleCount ;
|
|
end function CountCovHoles ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
-- Deprecated. New versions use PercentCov
|
|
impure function IsCovered ( AtLeast : integer ) return boolean is
|
|
------------------------------------------------------------
|
|
begin
|
|
return CountCovHoles(AtLeast) = 0 ;
|
|
end function IsCovered ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
impure function CalcWeight ( BinIndex : integer ; MaxAtLeast : integer ) return integer is
|
|
-- pt local
|
|
------------------------------------------------------------
|
|
begin
|
|
case WeightMode is
|
|
when AT_LEAST =>
|
|
return CovBinPtr(BinIndex).AtLeast ;
|
|
|
|
when WEIGHT =>
|
|
return CovBinPtr(BinIndex).Weight ;
|
|
|
|
when REMAIN =>
|
|
return MaxAtLeast - CovBinPtr(BinIndex).Count ;
|
|
|
|
when REMAIN_SCALED =>
|
|
-- Experimental may be removed
|
|
return integer( Ceil( WeightScale * real(MaxAtLeast))) -
|
|
CovBinPtr(BinIndex).Count ;
|
|
|
|
when REMAIN_WEIGHT =>
|
|
-- Experimental may be removed
|
|
return CovBinPtr(BinIndex).Weight * (
|
|
integer( Ceil( WeightScale * real(MaxAtLeast))) -
|
|
CovBinPtr(BinIndex).Count ) ;
|
|
|
|
when others =>
|
|
Alert(AlertLogIDVar, GetNamePlus(prefix => "in ", suffix => ", ") & "CoveragePkg.CalcWeight:" &
|
|
" Selected Weight Mode not supported with deprecated RandCovPoint(AtLeast), see RandCovPoint(PercentCov)", FAILURE) ;
|
|
return MaxAtLeast - CovBinPtr(BinIndex).Count ;
|
|
|
|
end case ;
|
|
end function CalcWeight ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
-- Deprecated. New versions use PercentCov
|
|
-- If keep this, need to be able to scale AtLeast Value
|
|
impure function RandHoleIndex ( AtLeast : integer ) return integer is
|
|
-- pt local
|
|
------------------------------------------------------------
|
|
variable WeightVec : integer_vector(0 to NumBins-1) ; -- Prep for change to DistInt
|
|
variable MinCount, AdjAtLeast, MaxAtLeast : integer ;
|
|
begin
|
|
ItemCount := ItemCount + 1 ;
|
|
MinCount := GetMinCov ;
|
|
-- iAtLeast := integer(ceil(CovTarget * real(AtLeast)/100.0)) ;
|
|
if ThresholdingEnable then
|
|
AdjAtLeast := MinCount + integer(CovThreshold) + 1 ;
|
|
if MinCount < AtLeast then
|
|
-- Clip at AtLeast until reach AtLeast
|
|
AdjAtLeast := minimum(AdjAtLeast, AtLeast) ;
|
|
end if ;
|
|
else
|
|
if MinCount < AtLeast then
|
|
AdjAtLeast := AtLeast ; -- Valid
|
|
else
|
|
-- Done, Enable all bins
|
|
-- AdjAtLeast := integer'right ; -- Get All
|
|
AdjAtLeast := GetMaxCov + 1 ; -- Get All
|
|
end if ;
|
|
end if;
|
|
MaxAtLeast := AdjAtLeast ;
|
|
CovLoop : for i in 1 to NumBins loop
|
|
-- if not ThresholdingEnable then
|
|
-- -- When not thresholding, consider bin Bin.AtLeast
|
|
-- -- iBinAtLeast := integer(ceil(CovTarget * real(CovBinPtr(i).AtLeast)/100.0)) ;
|
|
-- MaxAtLeast := maximum(AdjAtLeast, CovBinPtr(i).AtLeast) ;
|
|
-- end if ;
|
|
if CovBinPtr(i).action = COV_COUNT and CovBinPtr(i).Count < MaxAtLeast then
|
|
WeightVec(i-1) := CalcWeight(i, MaxAtLeast ) ; -- CovBinPtr(i).Weight ;
|
|
else
|
|
WeightVec(i-1) := 0 ;
|
|
end if ;
|
|
end loop CovLoop ;
|
|
-- DistInt returns integer range 0 to Numbins-1
|
|
LastIndex := 1 + RV.DistInt( WeightVec ) ; -- return range 1 to NumBins
|
|
return LastIndex ;
|
|
end function RandHoleIndex ;
|
|
|
|
------------------------------------------------------------
|
|
-- Deprecated. New versions use PercentCov
|
|
impure function RandCovBinVal (AtLeast : integer ) return RangeArrayType is
|
|
------------------------------------------------------------
|
|
begin
|
|
return CovBinPtr( RandHoleIndex(AtLeast) ).BinVal.all ; -- GetBinVal
|
|
end function RandCovBinVal ;
|
|
|
|
-- Maintained for backward compatibility. Repeated until aliases work for methods
|
|
------------------------------------------------------------
|
|
-- Deprecated+ New versions use PercentCov. Name change.
|
|
impure function RandCovHole (AtLeast : integer ) return RangeArrayType is
|
|
------------------------------------------------------------
|
|
begin
|
|
return RandCovBinVal(AtLeast) ; -- GetBinVal
|
|
end function RandCovHole ;
|
|
|
|
------------------------------------------------------------
|
|
-- Deprecated. New versions use PercentCov
|
|
impure function RandCovPoint (AtLeast : integer ) return integer is
|
|
------------------------------------------------------------
|
|
variable BinVal : RangeArrayType(1 to 1) ;
|
|
begin
|
|
BinVal := RandCovBinVal(AtLeast) ;
|
|
return RV.RandInt(BinVal(1).min, BinVal(1).max) ;
|
|
end function RandCovPoint ;
|
|
|
|
------------------------------------------------------------
|
|
impure function RandCovPoint (AtLeast : integer ) return integer_vector is
|
|
------------------------------------------------------------
|
|
begin
|
|
return ToRandPoint(RandCovBinVal(AtLeast)) ;
|
|
end function RandCovPoint ;
|
|
|
|
------------------------------------------------------------
|
|
-- Deprecated. New versions use PercentCov
|
|
impure function GetHoleBinVal ( ReqHoleNum : integer ; AtLeast : integer ) return RangeArrayType is
|
|
------------------------------------------------------------
|
|
variable HoleCount : integer := 0 ;
|
|
variable buf : line ;
|
|
begin
|
|
CovLoop : for i in 1 to NumBins loop
|
|
-- if CovBinPtr(i).action = COV_COUNT and CovBinPtr(i).Count < minimum(AtLeast, CovBinPtr(i).AtLeast) then
|
|
if CovBinPtr(i).action = COV_COUNT and CovBinPtr(i).Count < AtLeast then
|
|
HoleCount := HoleCount + 1 ;
|
|
if HoleCount = ReqHoleNum then
|
|
return CovBinPtr(i).BinVal.all ;
|
|
end if ;
|
|
end if ;
|
|
end loop CovLoop ;
|
|
Alert(AlertLogIDVar, GetNamePlus(prefix => "in ", suffix => ", ") & "CoveragePkg.GetHoleBinVal:" &
|
|
" did not find hole. HoleCount = " & integer'image(HoleCount) &
|
|
"ReqHoleNum = " & integer'image(ReqHoleNum), ERROR
|
|
) ;
|
|
return CovBinPtr(NumBins).BinVal.all ;
|
|
end function GetHoleBinVal ;
|
|
|
|
------------------------------------------------------------
|
|
-- Deprecated+. New versions use PercentCov. Name Change.
|
|
impure function GetCovHole ( ReqHoleNum : integer ; AtLeast : integer ) return RangeArrayType is
|
|
------------------------------------------------------------
|
|
begin
|
|
return GetHoleBinVal(ReqHoleNum, AtLeast) ;
|
|
end function GetCovHole ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
-- pt local
|
|
-- Deprecated. New versions use PercentCov.
|
|
procedure WriteCovHoles ( file f : text; AtLeast : integer ) is
|
|
------------------------------------------------------------
|
|
-- variable minAtLeast : integer ;
|
|
variable buf : line ;
|
|
begin
|
|
WriteBinName(f, "WriteCovHoles: ") ;
|
|
if NumBins < 1 then
|
|
if WriteBinFileInit or UsingLocalFile then
|
|
-- Duplicate Alert in specified file
|
|
swrite(buf, "%% Alert FAILURE " & GetNamePlus(prefix => "in ", suffix => ", ") & "CoveragePkg.WriteCovHoles:" &
|
|
" coverage model is empty. Nothing to print.") ;
|
|
writeline(f, buf) ;
|
|
end if ;
|
|
Alert(AlertLogIDVar, GetNamePlus(prefix => "in ", suffix => ", ") & "CoveragePkg.WriteCovHoles:" &
|
|
" coverage model is empty. Nothing to print.", FAILURE) ;
|
|
end if ;
|
|
CovLoop : for i in 1 to NumBins loop
|
|
-- minAtLeast := minimum(AtLeast,CovBinPtr(i).AtLeast) ;
|
|
-- if CovBinPtr(i).action = COV_COUNT and CovBinPtr(i).Count < minAtLeast then
|
|
if CovBinPtr(i).action = COV_COUNT and CovBinPtr(i).Count < AtLeast then
|
|
swrite(buf, "%% Bin:") ;
|
|
write(buf, CovBinPtr(i).BinVal.all) ;
|
|
write(buf, " Count = " & integer'image(CovBinPtr(i).Count)) ;
|
|
write(buf, " AtLeast = " & integer'image(CovBinPtr(i).AtLeast)) ;
|
|
if WeightMode = WEIGHT or WeightMode = REMAIN_WEIGHT then
|
|
-- Print Weight only when it is used
|
|
write(buf, " Weight = " & integer'image(CovBinPtr(i).Weight)) ;
|
|
end if ;
|
|
writeline(f, buf) ;
|
|
end if ;
|
|
end loop CovLoop ;
|
|
swrite(buf, "") ;
|
|
writeline(f, buf) ;
|
|
end procedure WriteCovHoles ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
-- Deprecated. New versions use PercentCov.
|
|
procedure WriteCovHoles ( AtLeast : integer ) is
|
|
------------------------------------------------------------
|
|
begin
|
|
if WriteBinFileInit then
|
|
-- Write to Local WriteBinFile - Deprecated, recommend use TranscriptFile instead
|
|
WriteCovHoles(WriteBinFile, AtLeast) ;
|
|
elsif IsTranscriptEnabled then
|
|
-- Write to TranscriptFile
|
|
WriteCovHoles(TranscriptFile, AtLeast) ;
|
|
if IsTranscriptMirrored then
|
|
-- Mirrored to OUTPUT
|
|
WriteCovHoles(OUTPUT, AtLeast) ;
|
|
end if ;
|
|
else
|
|
-- Default Write to OUTPUT
|
|
WriteCovHoles(OUTPUT, AtLeast) ;
|
|
end if;
|
|
end procedure WriteCovHoles ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
-- Deprecated. New versions use PercentCov.
|
|
procedure WriteCovHoles ( LogLevel : LogType ; AtLeast : integer ) is
|
|
------------------------------------------------------------
|
|
begin
|
|
if IsLogEnabled(AlertLogIDVar, LogLevel) then
|
|
WriteCovHoles(AtLeast) ;
|
|
end if;
|
|
end procedure WriteCovHoles ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
-- Deprecated. New versions use PercentCov.
|
|
procedure WriteCovHoles ( FileName : string; AtLeast : integer ; OpenKind : File_Open_Kind := APPEND_MODE ) is
|
|
------------------------------------------------------------
|
|
file CovHoleFile : text open OpenKind is FileName ;
|
|
begin
|
|
WriteCovHoles(CovHoleFile, AtLeast) ;
|
|
end procedure WriteCovHoles ;
|
|
|
|
------------------------------------------------------------
|
|
-- Deprecated. New versions use PercentCov.
|
|
procedure WriteCovHoles ( LogLevel : LogType ; FileName : string; AtLeast : integer ; OpenKind : File_Open_Kind := APPEND_MODE ) is
|
|
------------------------------------------------------------
|
|
begin
|
|
if IsLogEnabled(AlertLogIDVar, LogLevel) then
|
|
WriteCovHoles(FileName, AtLeast, OpenKind) ;
|
|
end if;
|
|
end procedure WriteCovHoles ;
|
|
|
|
------------------------------------------------------------
|
|
-- Deprecated. Use AddCross Instead.
|
|
procedure AddBins (CovBin : CovMatrix2Type ; Name : String := "") is
|
|
------------------------------------------------------------
|
|
begin
|
|
AddCross(CovBin, Name) ;
|
|
end procedure AddBins ;
|
|
|
|
------------------------------------------------------------
|
|
procedure AddBins (CovBin : CovMatrix3Type ; Name : String := "") is
|
|
------------------------------------------------------------
|
|
begin
|
|
AddCross(CovBin, Name) ;
|
|
end procedure AddBins ;
|
|
|
|
------------------------------------------------------------
|
|
procedure AddBins (CovBin : CovMatrix4Type ; Name : String := "") is
|
|
------------------------------------------------------------
|
|
begin
|
|
AddCross(CovBin, Name) ;
|
|
end procedure AddBins ;
|
|
|
|
------------------------------------------------------------
|
|
procedure AddBins (CovBin : CovMatrix5Type ; Name : String := "") is
|
|
------------------------------------------------------------
|
|
begin
|
|
AddCross(CovBin, Name) ;
|
|
end procedure AddBins ;
|
|
|
|
------------------------------------------------------------
|
|
procedure AddBins (CovBin : CovMatrix6Type ; Name : String := "") is
|
|
------------------------------------------------------------
|
|
begin
|
|
AddCross(CovBin, Name) ;
|
|
end procedure AddBins ;
|
|
|
|
------------------------------------------------------------
|
|
procedure AddBins (CovBin : CovMatrix7Type ; Name : String := "") is
|
|
------------------------------------------------------------
|
|
begin
|
|
AddCross(CovBin, Name) ;
|
|
end procedure AddBins ;
|
|
|
|
------------------------------------------------------------
|
|
procedure AddBins (CovBin : CovMatrix8Type ; Name : String := "") is
|
|
------------------------------------------------------------
|
|
begin
|
|
AddCross(CovBin, Name) ;
|
|
end procedure AddBins ;
|
|
|
|
------------------------------------------------------------
|
|
procedure AddBins (CovBin : CovMatrix9Type ; Name : String := "") is
|
|
------------------------------------------------------------
|
|
begin
|
|
AddCross(CovBin, Name) ;
|
|
end procedure AddBins ;
|
|
|
|
end protected body CovPType ;
|
|
|
|
------------------------------------------------------------------------------------------
|
|
-- XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX CovPType XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
|
|
-- XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX CovPType XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
|
|
------------------------------------------------------------------------------------------
|
|
|
|
------------------------------------------------------------
|
|
-- Experimental. Intended primarily for development.
|
|
procedure CompareBins (
|
|
------------------------------------------------------------
|
|
variable Bin1 : inout CovPType ;
|
|
variable Bin2 : inout CovPType ;
|
|
variable ErrorCount : inout integer
|
|
) is
|
|
variable NumBins1, NumBins2 : integer ;
|
|
variable BinInfo1, BinInfo2 : CovBinBaseType ;
|
|
variable BinVal1, BinVal2 : RangeArrayType(1 to Bin1.GetBinValLength) ;
|
|
variable buf : line ;
|
|
variable iAlertLogID : AlertLogIDType ;
|
|
begin
|
|
iAlertLogID := Bin1.GetAlertLogID ;
|
|
|
|
NumBins1 := Bin1.GetNumBins ;
|
|
NumBins2 := Bin2.GetNumBins ;
|
|
|
|
if (NumBins1 /= NumBins2) then
|
|
ErrorCount := ErrorCount + 1 ;
|
|
print("CoveragePkg.CompareBins: CoverageModels " & Bin1.GetCovModelName & " and " & Bin2.GetCovModelName &
|
|
" have different bin lengths") ;
|
|
return ;
|
|
end if ;
|
|
|
|
for i in 1 to NumBins1 loop
|
|
BinInfo1 := Bin1.GetBinInfo(i) ;
|
|
BinInfo2 := Bin2.GetBinInfo(i) ;
|
|
BinVal1 := Bin1.GetBinVal(i) ;
|
|
BinVal2 := Bin2.GetBinVal(i) ;
|
|
if BinInfo1 /= BinInfo2 or BinVal1 /= BinVal2 then
|
|
write(buf, "%% Bin:" & integer'image(i) & " miscompare." & LF) ;
|
|
-- writeline(OUTPUT, buf) ;
|
|
swrite(buf, "%% Bin1: ") ;
|
|
write(buf, BinVal1) ;
|
|
write(buf, " Action = " & integer'image(BinInfo1.action)) ;
|
|
write(buf, " Count = " & integer'image(BinInfo1.count)) ;
|
|
write(buf, " AtLeast = " & integer'image(BinInfo1.AtLeast)) ;
|
|
write(buf, " Weight = " & integer'image(BinInfo1.Weight) & LF ) ;
|
|
-- writeline(OUTPUT, buf) ;
|
|
swrite(buf, "%% Bin2: ") ;
|
|
write(buf, BinVal2) ;
|
|
write(buf, " Action = " & integer'image(BinInfo2.action)) ;
|
|
write(buf, " Count = " & integer'image(BinInfo2.count)) ;
|
|
write(buf, " AtLeast = " & integer'image(BinInfo2.AtLeast)) ;
|
|
write(buf, " Weight = " & integer'image(BinInfo2.Weight) & LF ) ;
|
|
-- writeline(OUTPUT, buf) ;
|
|
ErrorCount := ErrorCount + 1 ;
|
|
writeline(buf) ;
|
|
-- Alert(iAlertLogID, buf.all, ERROR) ;
|
|
-- deallocate(buf) ;
|
|
end if ;
|
|
end loop ;
|
|
end procedure CompareBins ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
-- Experimental. Intended primarily for development.
|
|
procedure CompareBins (
|
|
------------------------------------------------------------
|
|
variable Bin1 : inout CovPType ;
|
|
variable Bin2 : inout CovPType
|
|
) is
|
|
variable ErrorCount : integer ;
|
|
variable iAlertLogID : AlertLogIDType ;
|
|
begin
|
|
CompareBins(Bin1, Bin2, ErrorCount) ;
|
|
iAlertLogID := Bin1.GetAlertLogID ;
|
|
AlertIf(ErrorCount /= 0, "CoveragePkg.CompareBins: CoverageModels " & Bin1.GetCovModelName & " and " & Bin2.GetCovModelName & " are not the same.") ;
|
|
end procedure CompareBins ;
|
|
|
|
------------------------------------------------------------
|
|
-- package local, Used by GenBin, IllegalBin, and IgnoreBin
|
|
function MakeBin(
|
|
-- Must be pure to allow initializing coverage models passed as generics.
|
|
-- Impure implies the expression is not globally static.
|
|
------------------------------------------------------------
|
|
Min, Max : integer ;
|
|
NumBin : integer ;
|
|
AtLeast : integer ;
|
|
Weight : integer ;
|
|
Action : integer
|
|
) return CovBinType is
|
|
variable iCovBin : CovBinType(1 to NumBin) ;
|
|
variable TotalBins : integer ; -- either real or integer
|
|
variable rMax, rCurMin, rNumItemsInBin, rRemainingBins : real ; -- must be real
|
|
variable iCurMin, iCurMax : integer ;
|
|
begin
|
|
if Min > Max then
|
|
-- Similar to NULL ranges. Only generate report warning.
|
|
report "OSVVM.CoveragePkg.MakeBin (called by GenBin, IllegalBin, or IgnoreBin) MAX > MIN generated NULL_BIN"
|
|
severity WARNING ;
|
|
-- No Alerts. They make this impure.
|
|
-- Alert(OSVVM_ALERTLOG_ID, "CoveragePkg.MakeBin (called by GenBin, IllegalBin, IgnoreBin): Min must be <= Max", WARNING) ;
|
|
return NULL_BIN ;
|
|
|
|
elsif NumBin <= 0 then
|
|
-- Similar to NULL ranges. Only generate report warning.
|
|
report "OSVVM.CoveragePkg.MakeBin (called by GenBin, IllegalBin, or IgnoreBin) NumBin <= 0 generated NULL_BIN"
|
|
severity WARNING ;
|
|
-- Alerts make this impure.
|
|
-- Alert(OSVVM_ALERTLOG_ID, "CoveragePkg.MakeBin (called by GenBin, IllegalBin, IgnoreBin): NumBin must be <= 0", WARNING) ;
|
|
return NULL_BIN ;
|
|
|
|
elsif NumBin = 1 then
|
|
iCovBin(1) := (
|
|
BinVal => (1 => (Min, Max)),
|
|
Action => Action,
|
|
Count => 0,
|
|
Weight => Weight,
|
|
AtLeast => AtLeast
|
|
) ;
|
|
return iCovBin ;
|
|
|
|
else
|
|
-- Using type real to work around issues with integer sizing
|
|
iCurMin := Min ;
|
|
rCurMin := real(iCurMin) ;
|
|
rMax := real(Max) ;
|
|
rRemainingBins := (minimum( real(NumBin), rMax - rCurMin + 1.0 )) ;
|
|
TotalBins := integer(rRemainingBins) ;
|
|
for i in iCovBin'range loop
|
|
rNumItemsInBin := trunc((rMax - rCurMin + 1.0) / rRemainingBins) ; -- Max - Min can be larger than integer range.
|
|
iCurMax := iCurMin - integer(-rNumItemsInBin + 1.0) ; -- Keep: the "minus negative" works around a simulator bounds issue found in 2015.06
|
|
iCovBin(i) := (
|
|
BinVal => (1 => (iCurMin, iCurMax)),
|
|
Action => Action,
|
|
Count => 0,
|
|
Weight => Weight,
|
|
AtLeast => AtLeast
|
|
) ;
|
|
rRemainingBins := rRemainingBins - 1.0 ;
|
|
exit when rRemainingBins = 0.0 ;
|
|
iCurMin := iCurMax + 1 ;
|
|
rCurMin := real(iCurMin) ;
|
|
end loop ;
|
|
return iCovBin(1 to TotalBins) ;
|
|
|
|
end if ;
|
|
end function MakeBin ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
-- package local, Used by GenBin, IllegalBin, and IgnoreBin
|
|
function MakeBin(
|
|
------------------------------------------------------------
|
|
A : integer_vector ;
|
|
AtLeast : integer ;
|
|
Weight : integer ;
|
|
Action : integer
|
|
) return CovBinType is
|
|
alias NewA : integer_vector(1 to A'length) is A ;
|
|
variable iCovBin : CovBinType(1 to A'length) ;
|
|
begin
|
|
|
|
if A'length <= 0 then
|
|
-- Similar to NULL ranges. Only generate report warning.
|
|
report "OSVVM.CoveragePkg.MakeBin (called by GenBin, IllegalBin, or IgnoreBin) integer_vector length <= 0 generated NULL_BIN"
|
|
severity WARNING ;
|
|
-- Alerts make this impure.
|
|
-- Alert(OSVVM_ALERTLOG_ID, "CoveragePkg.MakeBin (GenBin, IllegalBin, IgnoreBin): integer_vector parameter must have values", WARNING) ;
|
|
return NULL_BIN ;
|
|
|
|
else
|
|
for i in NewA'Range loop
|
|
iCovBin(i) := (
|
|
BinVal => (i => (NewA(i), NewA(i)) ),
|
|
Action => Action,
|
|
Count => 0,
|
|
Weight => Weight,
|
|
AtLeast => AtLeast
|
|
) ;
|
|
end loop ;
|
|
return iCovBin ;
|
|
end if ;
|
|
end function MakeBin ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
function GenBin(
|
|
------------------------------------------------------------
|
|
AtLeast : integer ;
|
|
Weight : integer ;
|
|
Min, Max : integer ;
|
|
NumBin : integer
|
|
) return CovBinType is
|
|
begin
|
|
return MakeBin(
|
|
Min => Min,
|
|
Max => Max,
|
|
NumBin => NumBin,
|
|
AtLeast => AtLeast,
|
|
Weight => Weight,
|
|
Action => COV_COUNT
|
|
) ;
|
|
end function GenBin ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
function GenBin( AtLeast : integer ; Min, Max, NumBin : integer ) return CovBinType is
|
|
------------------------------------------------------------
|
|
begin
|
|
return MakeBin(
|
|
Min => Min,
|
|
Max => Max,
|
|
NumBin => NumBin,
|
|
AtLeast => AtLeast,
|
|
Weight => 1,
|
|
Action => COV_COUNT
|
|
) ;
|
|
end function GenBin ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
function GenBin( Min, Max, NumBin : integer ) return CovBinType is
|
|
------------------------------------------------------------
|
|
begin
|
|
return MakeBin(
|
|
Min => Min,
|
|
Max => Max,
|
|
NumBin => NumBin,
|
|
AtLeast => 1,
|
|
Weight => 1,
|
|
Action => COV_COUNT
|
|
) ;
|
|
end function GenBin ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
function GenBin ( Min, Max : integer) return CovBinType is
|
|
------------------------------------------------------------
|
|
begin
|
|
-- create a separate CovBin for each value
|
|
-- AtLeast and Weight = 1 (must use longer version to specify)
|
|
return MakeBin(
|
|
Min => Min,
|
|
Max => Max,
|
|
NumBin => Max - Min + 1,
|
|
AtLeast => 1,
|
|
Weight => 1,
|
|
Action => COV_COUNT
|
|
) ;
|
|
end function GenBin ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
function GenBin ( A : integer ) return CovBinType is
|
|
------------------------------------------------------------
|
|
begin
|
|
-- create a single CovBin for A.
|
|
-- AtLeast and Weight = 1 (must use longer version to specify)
|
|
return MakeBin(
|
|
Min => A,
|
|
Max => A,
|
|
NumBin => 1,
|
|
AtLeast => 1,
|
|
Weight => 1,
|
|
Action => COV_COUNT
|
|
) ;
|
|
end function GenBin ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
function GenBin(
|
|
------------------------------------------------------------
|
|
AtLeast : integer ;
|
|
Weight : integer ;
|
|
A : integer_vector
|
|
) return CovBinType is
|
|
begin
|
|
return MakeBin(
|
|
A => A,
|
|
AtLeast => AtLeast,
|
|
Weight => Weight,
|
|
Action => COV_COUNT
|
|
) ;
|
|
end function GenBin ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
function GenBin ( AtLeast : integer ; A : integer_vector ) return CovBinType is
|
|
------------------------------------------------------------
|
|
begin
|
|
return MakeBin(
|
|
A => A,
|
|
AtLeast => AtLeast,
|
|
Weight => 1,
|
|
Action => COV_COUNT
|
|
) ;
|
|
end function GenBin ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
function GenBin ( A : integer_vector ) return CovBinType is
|
|
------------------------------------------------------------
|
|
begin
|
|
return MakeBin(
|
|
A => A,
|
|
AtLeast => 1,
|
|
Weight => 1,
|
|
Action => COV_COUNT
|
|
) ;
|
|
end function GenBin ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
function IllegalBin ( Min, Max, NumBin : integer ) return CovBinType is
|
|
------------------------------------------------------------
|
|
begin
|
|
return MakeBin(
|
|
Min => Min,
|
|
Max => Max,
|
|
NumBin => NumBin,
|
|
AtLeast => 0,
|
|
Weight => 0,
|
|
Action => COV_ILLEGAL
|
|
) ;
|
|
end function IllegalBin ;
|
|
|
|
------------------------------------------------------------
|
|
function IllegalBin ( Min, Max : integer ) return CovBinType is
|
|
------------------------------------------------------------
|
|
begin
|
|
-- default, generate one CovBin with the entire range of values
|
|
return MakeBin(
|
|
Min => Min,
|
|
Max => Max,
|
|
NumBin => 1,
|
|
AtLeast => 0,
|
|
Weight => 0,
|
|
Action => COV_ILLEGAL
|
|
) ;
|
|
end function IllegalBin ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
function IllegalBin ( A : integer ) return CovBinType is
|
|
------------------------------------------------------------
|
|
begin
|
|
return MakeBin(
|
|
Min => A,
|
|
Max => A,
|
|
NumBin => 1,
|
|
AtLeast => 0,
|
|
Weight => 0,
|
|
Action => COV_ILLEGAL
|
|
) ;
|
|
end function IllegalBin ;
|
|
|
|
|
|
-- IgnoreBin should never have an AtLeast parameter
|
|
------------------------------------------------------------
|
|
function IgnoreBin (Min, Max, NumBin : integer) return CovBinType is
|
|
------------------------------------------------------------
|
|
begin
|
|
return MakeBin(
|
|
Min => Min,
|
|
Max => Max,
|
|
NumBin => NumBin,
|
|
AtLeast => 0,
|
|
Weight => 0,
|
|
Action => COV_IGNORE
|
|
) ;
|
|
end function IgnoreBin ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
function IgnoreBin (Min, Max : integer) return CovBinType is
|
|
------------------------------------------------------------
|
|
begin
|
|
-- default, generate one CovBin with the entire range of values
|
|
return MakeBin(
|
|
Min => Min,
|
|
Max => Max,
|
|
NumBin => 1,
|
|
AtLeast => 0,
|
|
Weight => 0,
|
|
Action => COV_IGNORE
|
|
) ;
|
|
end function IgnoreBin ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
function IgnoreBin (A : integer) return CovBinType is
|
|
------------------------------------------------------------
|
|
begin
|
|
return MakeBin(
|
|
Min => A,
|
|
Max => A,
|
|
NumBin => 1,
|
|
AtLeast => 0,
|
|
Weight => 0,
|
|
Action => COV_IGNORE
|
|
) ;
|
|
end function IgnoreBin ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
function GenCross( -- 2
|
|
-- Cross existing bins
|
|
-- Use AddCross for adding values directly to coverage database
|
|
-- Use GenCross for constants
|
|
------------------------------------------------------------
|
|
AtLeast : integer ;
|
|
Weight : integer ;
|
|
Bin1, Bin2 : CovBinType
|
|
) return CovMatrix2Type is
|
|
constant BIN_LENS : integer_vector := BinLengths(Bin1, Bin2) ;
|
|
constant NUM_NEW_BINS : integer := CalcNumCrossBins(BIN_LENS) ;
|
|
variable BinIndex : integer_vector(1 to BIN_LENS'length) := (others => 1) ;
|
|
variable CrossBins : CovBinType(BinIndex'range) ;
|
|
variable Action : integer ;
|
|
variable iCovMatrix : CovMatrix2Type(1 to NUM_NEW_BINS) ;
|
|
begin
|
|
for MatrixIndex in iCovMatrix'range loop
|
|
CrossBins := ConcatenateBins(BinIndex, Bin1, Bin2) ;
|
|
Action := MergeState(CrossBins) ;
|
|
iCovMatrix(MatrixIndex).action := Action ;
|
|
iCovMatrix(MatrixIndex).count := 0 ;
|
|
iCovMatrix(MatrixIndex).BinVal := MergeBinVal(CrossBins) ;
|
|
iCovMatrix(MatrixIndex).AtLeast := MergeAtLeast( Action, AtLeast, CrossBins) ;
|
|
iCovMatrix(MatrixIndex).Weight := MergeWeight ( Action, Weight, CrossBins) ;
|
|
IncBinIndex( BinIndex, BIN_LENS ) ; -- increment right most one, then if overflow, increment next
|
|
end loop ;
|
|
return iCovMatrix ;
|
|
end function GenCross ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
function GenCross(AtLeast : integer ; Bin1, Bin2 : CovBinType) return CovMatrix2Type is
|
|
-- Cross existing bins -- use AddCross instead
|
|
------------------------------------------------------------
|
|
begin
|
|
return GenCross(AtLeast, 0, Bin1, Bin2) ;
|
|
end function GenCross ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
function GenCross(Bin1, Bin2 : CovBinType) return CovMatrix2Type is
|
|
-- Cross existing bins -- use AddCross instead
|
|
------------------------------------------------------------
|
|
begin
|
|
return GenCross(0, 0, Bin1, Bin2) ;
|
|
end function GenCross ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
function GenCross( -- 3
|
|
------------------------------------------------------------
|
|
AtLeast : integer ;
|
|
Weight : integer ;
|
|
Bin1, Bin2, Bin3 : CovBinType
|
|
) return CovMatrix3Type is
|
|
constant BIN_LENS : integer_vector := BinLengths(Bin1, Bin2, Bin3) ;
|
|
constant NUM_NEW_BINS : integer := CalcNumCrossBins(BIN_LENS) ;
|
|
variable BinIndex : integer_vector(1 to BIN_LENS'length) := (others => 1) ;
|
|
variable CrossBins : CovBinType(BinIndex'range) ;
|
|
variable Action : integer ;
|
|
variable iCovMatrix : CovMatrix3Type(1 to NUM_NEW_BINS) ;
|
|
begin
|
|
for MatrixIndex in iCovMatrix'range loop
|
|
CrossBins := ConcatenateBins(BinIndex, Bin1, Bin2, Bin3) ;
|
|
Action := MergeState(CrossBins) ;
|
|
iCovMatrix(MatrixIndex).action := Action ;
|
|
iCovMatrix(MatrixIndex).count := 0 ;
|
|
iCovMatrix(MatrixIndex).BinVal := MergeBinVal(CrossBins) ;
|
|
iCovMatrix(MatrixIndex).AtLeast := MergeAtLeast( Action, AtLeast, CrossBins) ;
|
|
iCovMatrix(MatrixIndex).Weight := MergeWeight ( Action, Weight, CrossBins) ;
|
|
IncBinIndex( BinIndex, BIN_LENS ) ; -- increment right most one, then if overflow, increment next
|
|
end loop ;
|
|
return iCovMatrix ;
|
|
end function GenCross ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
function GenCross( AtLeast : integer ; Bin1, Bin2, Bin3 : CovBinType ) return CovMatrix3Type is
|
|
------------------------------------------------------------
|
|
begin
|
|
return GenCross(AtLeast, 0, Bin1, Bin2, Bin3) ;
|
|
end function GenCross ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
function GenCross( Bin1, Bin2, Bin3 : CovBinType ) return CovMatrix3Type is
|
|
------------------------------------------------------------
|
|
begin
|
|
return GenCross(0, 0, Bin1, Bin2, Bin3) ;
|
|
end function GenCross ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
function GenCross( -- 4
|
|
------------------------------------------------------------
|
|
AtLeast : integer ;
|
|
Weight : integer ;
|
|
Bin1, Bin2, Bin3, Bin4 : CovBinType
|
|
) return CovMatrix4Type is
|
|
constant BIN_LENS : integer_vector := BinLengths(Bin1, Bin2, Bin3, Bin4) ;
|
|
constant NUM_NEW_BINS : integer := CalcNumCrossBins(BIN_LENS) ;
|
|
variable BinIndex : integer_vector(1 to BIN_LENS'length) := (others => 1) ;
|
|
variable CrossBins : CovBinType(BinIndex'range) ;
|
|
variable Action : integer ;
|
|
variable iCovMatrix : CovMatrix4Type(1 to NUM_NEW_BINS) ;
|
|
begin
|
|
for MatrixIndex in iCovMatrix'range loop
|
|
CrossBins := ConcatenateBins(BinIndex, Bin1, Bin2, Bin3, Bin4) ;
|
|
Action := MergeState(CrossBins) ;
|
|
iCovMatrix(MatrixIndex).action := Action ;
|
|
iCovMatrix(MatrixIndex).count := 0 ;
|
|
iCovMatrix(MatrixIndex).BinVal := MergeBinVal(CrossBins) ;
|
|
iCovMatrix(MatrixIndex).AtLeast := MergeAtLeast( Action, AtLeast, CrossBins) ;
|
|
iCovMatrix(MatrixIndex).Weight := MergeWeight ( Action, Weight, CrossBins) ;
|
|
IncBinIndex( BinIndex, BIN_LENS ) ; -- increment right most one, then if overflow, increment next
|
|
end loop ;
|
|
return iCovMatrix ;
|
|
end function GenCross ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
function GenCross( AtLeast : integer ; Bin1, Bin2, Bin3, Bin4 : CovBinType ) return CovMatrix4Type is
|
|
------------------------------------------------------------
|
|
begin
|
|
return GenCross(AtLeast, 0, Bin1, Bin2, Bin3, Bin4) ;
|
|
end function GenCross ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
function GenCross( Bin1, Bin2, Bin3, Bin4 : CovBinType ) return CovMatrix4Type is
|
|
------------------------------------------------------------
|
|
begin
|
|
return GenCross(0, 0, Bin1, Bin2, Bin3, Bin4) ;
|
|
end function GenCross ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
function GenCross( -- 5
|
|
------------------------------------------------------------
|
|
AtLeast : integer ;
|
|
Weight : integer ;
|
|
Bin1, Bin2, Bin3, Bin4, Bin5 : CovBinType
|
|
) return CovMatrix5Type is
|
|
constant BIN_LENS : integer_vector := BinLengths(Bin1, Bin2, Bin3, Bin4, Bin5) ;
|
|
constant NUM_NEW_BINS : integer := CalcNumCrossBins(BIN_LENS) ;
|
|
variable BinIndex : integer_vector(1 to BIN_LENS'length) := (others => 1) ;
|
|
variable CrossBins : CovBinType(BinIndex'range) ;
|
|
variable Action : integer ;
|
|
variable iCovMatrix : CovMatrix5Type(1 to NUM_NEW_BINS) ;
|
|
begin
|
|
for MatrixIndex in iCovMatrix'range loop
|
|
CrossBins := ConcatenateBins(BinIndex, Bin1, Bin2, Bin3, Bin4, Bin5) ;
|
|
Action := MergeState(CrossBins) ;
|
|
iCovMatrix(MatrixIndex).action := Action ;
|
|
iCovMatrix(MatrixIndex).count := 0 ;
|
|
iCovMatrix(MatrixIndex).BinVal := MergeBinVal(CrossBins) ;
|
|
iCovMatrix(MatrixIndex).AtLeast := MergeAtLeast( Action, AtLeast, CrossBins) ;
|
|
iCovMatrix(MatrixIndex).Weight := MergeWeight ( Action, Weight, CrossBins) ;
|
|
IncBinIndex( BinIndex, BIN_LENS ) ; -- increment right most one, then if overflow, increment next
|
|
end loop ;
|
|
return iCovMatrix ;
|
|
end function GenCross ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
function GenCross( AtLeast : integer ; Bin1, Bin2, Bin3, Bin4, Bin5 : CovBinType ) return CovMatrix5Type is
|
|
------------------------------------------------------------
|
|
begin
|
|
return GenCross(AtLeast, 0, Bin1, Bin2, Bin3, Bin4, Bin5) ;
|
|
end function GenCross ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
function GenCross( Bin1, Bin2, Bin3, Bin4, Bin5 : CovBinType ) return CovMatrix5Type is
|
|
------------------------------------------------------------
|
|
begin
|
|
return GenCross(0, 0, Bin1, Bin2, Bin3, Bin4, Bin5) ;
|
|
end function GenCross ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
function GenCross( -- 6
|
|
------------------------------------------------------------
|
|
AtLeast : integer ;
|
|
Weight : integer ;
|
|
Bin1, Bin2, Bin3, Bin4, Bin5, Bin6 : CovBinType
|
|
) return CovMatrix6Type is
|
|
constant BIN_LENS : integer_vector := BinLengths(Bin1, Bin2, Bin3, Bin4, Bin5, Bin6) ;
|
|
constant NUM_NEW_BINS : integer := CalcNumCrossBins(BIN_LENS) ;
|
|
variable BinIndex : integer_vector(1 to BIN_LENS'length) := (others => 1) ;
|
|
variable CrossBins : CovBinType(BinIndex'range) ;
|
|
variable Action : integer ;
|
|
variable iCovMatrix : CovMatrix6Type(1 to NUM_NEW_BINS) ;
|
|
begin
|
|
for MatrixIndex in iCovMatrix'range loop
|
|
CrossBins := ConcatenateBins(BinIndex, Bin1, Bin2, Bin3, Bin4, Bin5, Bin6) ;
|
|
Action := MergeState(CrossBins) ;
|
|
iCovMatrix(MatrixIndex).action := Action ;
|
|
iCovMatrix(MatrixIndex).count := 0 ;
|
|
iCovMatrix(MatrixIndex).BinVal := MergeBinVal(CrossBins) ;
|
|
iCovMatrix(MatrixIndex).AtLeast := MergeAtLeast( Action, AtLeast, CrossBins) ;
|
|
iCovMatrix(MatrixIndex).Weight := MergeWeight ( Action, Weight, CrossBins) ;
|
|
IncBinIndex( BinIndex, BIN_LENS ) ; -- increment right most one, then if overflow, increment next
|
|
end loop ;
|
|
return iCovMatrix ;
|
|
|
|
end function GenCross ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
function GenCross( AtLeast : integer ; Bin1, Bin2, Bin3, Bin4, Bin5, Bin6 : CovBinType ) return CovMatrix6Type is
|
|
------------------------------------------------------------
|
|
begin
|
|
return GenCross(AtLeast, 0, Bin1, Bin2, Bin3, Bin4, Bin5, Bin6) ;
|
|
end function GenCross ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
function GenCross( Bin1, Bin2, Bin3, Bin4, Bin5, Bin6 : CovBinType ) return CovMatrix6Type is
|
|
------------------------------------------------------------
|
|
begin
|
|
return GenCross(0, 0, Bin1, Bin2, Bin3, Bin4, Bin5, Bin6) ;
|
|
end function GenCross ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
function GenCross( -- 7
|
|
------------------------------------------------------------
|
|
AtLeast : integer ;
|
|
Weight : integer ;
|
|
Bin1, Bin2, Bin3, Bin4, Bin5, Bin6, Bin7 : CovBinType
|
|
) return CovMatrix7Type is
|
|
constant BIN_LENS : integer_vector := BinLengths(Bin1, Bin2, Bin3, Bin4, Bin5, Bin6, Bin7) ;
|
|
constant NUM_NEW_BINS : integer := CalcNumCrossBins(BIN_LENS) ;
|
|
variable BinIndex : integer_vector(1 to BIN_LENS'length) := (others => 1) ;
|
|
variable CrossBins : CovBinType(BinIndex'range) ;
|
|
variable Action : integer ;
|
|
variable iCovMatrix : CovMatrix7Type(1 to NUM_NEW_BINS) ;
|
|
begin
|
|
for MatrixIndex in iCovMatrix'range loop
|
|
CrossBins := ConcatenateBins(BinIndex, Bin1, Bin2, Bin3, Bin4, Bin5, Bin6, Bin7) ;
|
|
Action := MergeState(CrossBins) ;
|
|
iCovMatrix(MatrixIndex).action := Action ;
|
|
iCovMatrix(MatrixIndex).count := 0 ;
|
|
iCovMatrix(MatrixIndex).BinVal := MergeBinVal(CrossBins) ;
|
|
iCovMatrix(MatrixIndex).AtLeast := MergeAtLeast( Action, AtLeast, CrossBins) ;
|
|
iCovMatrix(MatrixIndex).Weight := MergeWeight ( Action, Weight, CrossBins) ;
|
|
IncBinIndex( BinIndex, BIN_LENS ) ; -- increment right most one, then if overflow, increment next
|
|
end loop ;
|
|
return iCovMatrix ;
|
|
end function GenCross ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
function GenCross( AtLeast : integer ; Bin1, Bin2, Bin3, Bin4, Bin5, Bin6, Bin7 : CovBinType ) return CovMatrix7Type is
|
|
------------------------------------------------------------
|
|
begin
|
|
return GenCross(AtLeast, 0, Bin1, Bin2, Bin3, Bin4, Bin5, Bin6, Bin7) ;
|
|
end function GenCross ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
function GenCross( Bin1, Bin2, Bin3, Bin4, Bin5, Bin6, Bin7 : CovBinType ) return CovMatrix7Type is
|
|
------------------------------------------------------------
|
|
begin
|
|
return GenCross(0, 0, Bin1, Bin2, Bin3, Bin4, Bin5, Bin6, Bin7) ;
|
|
end function GenCross ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
function GenCross( -- 8
|
|
------------------------------------------------------------
|
|
AtLeast : integer ;
|
|
Weight : integer ;
|
|
Bin1, Bin2, Bin3, Bin4, Bin5, Bin6, Bin7, Bin8 : CovBinType
|
|
) return CovMatrix8Type is
|
|
constant BIN_LENS : integer_vector := BinLengths(Bin1, Bin2, Bin3, Bin4, Bin5, Bin6, Bin7, Bin8) ;
|
|
constant NUM_NEW_BINS : integer := CalcNumCrossBins(BIN_LENS) ;
|
|
variable BinIndex : integer_vector(1 to BIN_LENS'length) := (others => 1) ;
|
|
variable CrossBins : CovBinType(BinIndex'range) ;
|
|
variable Action : integer ;
|
|
variable iCovMatrix : CovMatrix8Type(1 to NUM_NEW_BINS) ;
|
|
begin
|
|
for MatrixIndex in iCovMatrix'range loop
|
|
CrossBins := ConcatenateBins(BinIndex, Bin1, Bin2, Bin3, Bin4, Bin5, Bin6, Bin7, Bin8) ;
|
|
Action := MergeState(CrossBins) ;
|
|
iCovMatrix(MatrixIndex).action := Action ;
|
|
iCovMatrix(MatrixIndex).count := 0 ;
|
|
iCovMatrix(MatrixIndex).BinVal := MergeBinVal(CrossBins) ;
|
|
iCovMatrix(MatrixIndex).AtLeast := MergeAtLeast( Action, AtLeast, CrossBins) ;
|
|
iCovMatrix(MatrixIndex).Weight := MergeWeight ( Action, Weight, CrossBins) ;
|
|
IncBinIndex( BinIndex, BIN_LENS ) ; -- increment right most one, then if overflow, increment next
|
|
end loop ;
|
|
return iCovMatrix ;
|
|
end function GenCross ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
function GenCross( AtLeast : integer ; Bin1, Bin2, Bin3, Bin4, Bin5, Bin6, Bin7, Bin8 : CovBinType ) return CovMatrix8Type is
|
|
------------------------------------------------------------
|
|
begin
|
|
return GenCross(AtLeast, 0, Bin1, Bin2, Bin3, Bin4, Bin5, Bin6, Bin7, Bin8) ;
|
|
end function GenCross ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
function GenCross( Bin1, Bin2, Bin3, Bin4, Bin5, Bin6, Bin7, Bin8 : CovBinType ) return CovMatrix8Type is
|
|
------------------------------------------------------------
|
|
begin
|
|
return GenCross(0, 0, Bin1, Bin2, Bin3, Bin4, Bin5, Bin6, Bin7, Bin8) ;
|
|
end function GenCross ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
function GenCross( -- 9
|
|
------------------------------------------------------------
|
|
AtLeast : integer ;
|
|
Weight : integer ;
|
|
Bin1, Bin2, Bin3, Bin4, Bin5, Bin6, Bin7, Bin8, Bin9 : CovBinType
|
|
) return CovMatrix9Type is
|
|
constant BIN_LENS : integer_vector := BinLengths(Bin1, Bin2, Bin3, Bin4, Bin5, Bin6, Bin7, Bin8, Bin9) ;
|
|
constant NUM_NEW_BINS : integer := CalcNumCrossBins(BIN_LENS) ;
|
|
variable BinIndex : integer_vector(1 to BIN_LENS'length) := (others => 1) ;
|
|
variable CrossBins : CovBinType(BinIndex'range) ;
|
|
variable Action : integer ;
|
|
variable iCovMatrix : CovMatrix9Type(1 to NUM_NEW_BINS) ;
|
|
begin
|
|
for MatrixIndex in iCovMatrix'range loop
|
|
CrossBins := ConcatenateBins(BinIndex, Bin1, Bin2, Bin3, Bin4, Bin5, Bin6, Bin7, Bin8, Bin9) ;
|
|
Action := MergeState(CrossBins) ;
|
|
iCovMatrix(MatrixIndex).action := Action ;
|
|
iCovMatrix(MatrixIndex).count := 0 ;
|
|
iCovMatrix(MatrixIndex).BinVal := MergeBinVal(CrossBins) ;
|
|
iCovMatrix(MatrixIndex).AtLeast := MergeAtLeast( Action, AtLeast, CrossBins) ;
|
|
iCovMatrix(MatrixIndex).Weight := MergeWeight ( Action, Weight, CrossBins) ;
|
|
IncBinIndex( BinIndex, BIN_LENS ) ; -- increment right most one, then if overflow, increment next
|
|
end loop ;
|
|
return iCovMatrix ;
|
|
end function GenCross ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
function GenCross( AtLeast : integer ; Bin1, Bin2, Bin3, Bin4, Bin5, Bin6, Bin7, Bin8, Bin9 : CovBinType ) return CovMatrix9Type is
|
|
------------------------------------------------------------
|
|
begin
|
|
return GenCross(AtLeast, 0, Bin1, Bin2, Bin3, Bin4, Bin5, Bin6, Bin7, Bin8, Bin9) ;
|
|
end function GenCross ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
function GenCross( Bin1, Bin2, Bin3, Bin4, Bin5, Bin6, Bin7, Bin8, Bin9 : CovBinType ) return CovMatrix9Type is
|
|
------------------------------------------------------------
|
|
begin
|
|
return GenCross(0, 0, Bin1, Bin2, Bin3, Bin4, Bin5, Bin6, Bin7, Bin8, Bin9) ;
|
|
end function GenCross ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
function to_integer ( B : boolean ) return integer is
|
|
------------------------------------------------------------
|
|
begin
|
|
if B then
|
|
return 1 ;
|
|
else
|
|
return 0 ;
|
|
end if ;
|
|
end function to_integer ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
function to_integer ( SL : std_logic ) return integer is
|
|
-------------------------------------------------------------
|
|
begin
|
|
case SL is
|
|
when '1' | 'H' => return 1 ;
|
|
when '0' | 'L' => return 0 ;
|
|
when others => return -1 ;
|
|
end case ;
|
|
end function to_integer ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
function to_integer_vector ( BV : boolean_vector ) return integer_vector is
|
|
------------------------------------------------------------
|
|
variable result : integer_vector(BV'range) ;
|
|
begin
|
|
for i in BV'range loop
|
|
result(i) := to_integer(BV(i)) ;
|
|
end loop ;
|
|
return result ;
|
|
end function to_integer_vector ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
function to_integer_vector ( SLV : std_logic_vector ) return integer_vector is
|
|
-------------------------------------------------------------
|
|
variable result : integer_vector(SLV'range) ;
|
|
begin
|
|
for i in SLV'range loop
|
|
result(i) := to_integer(SLV(i)) ;
|
|
end loop ;
|
|
return result ;
|
|
end function to_integer_vector ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
------------------------------------------------------------
|
|
-- Deprecated: These are not part of the coverage model
|
|
|
|
------------------------------------------------------------
|
|
procedure increment( signal Count : inout integer ) is
|
|
------------------------------------------------------------
|
|
begin
|
|
Count <= Count + 1 ;
|
|
end procedure increment ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
procedure increment( signal Count : inout integer ; enable : boolean ) is
|
|
------------------------------------------------------------
|
|
begin
|
|
if enable then
|
|
Count <= Count + 1 ;
|
|
end if ;
|
|
end procedure increment ;
|
|
|
|
|
|
------------------------------------------------------------
|
|
procedure increment( signal Count : inout integer ; enable : std_ulogic ) is
|
|
------------------------------------------------------------
|
|
begin
|
|
if to_x01(enable) = '1' then
|
|
Count <= Count + 1 ;
|
|
end if ;
|
|
end procedure increment ;
|
|
|
|
|
|
end package body CoveragePkg ;
|