|
|
- --
- -- 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 ;
|