-- -- File Name: CoveragePkg.vhd -- Design Unit Name: CoveragePkg -- Revision: STANDARD VERSION, revision 2014.01 -- -- 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 -- -- -- Package Defines -- Functional coverage modeling utilities and data structure -- -- Developed 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: See also 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 Requires VHDL-2008 types integer_vector and boolean_vecctor -- 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 -- Revised RandCovPoint, RandCovBinVal, AddBins, AddCross, GenBin, Added SetWeightMode -- Randomization with weights/weight modes -- Cleaned up parameter naming -- 11/2011: 2.2a Changed constants ALL_RANGE, ZERO_BIN, and ONE_BIN to have a 1 index -- rather than 0 to match the range of BinVal -- 12/2011: 2.2b Fixed minor inconsistencies on interface declarations. -- Package RandomPkg is assumed to be in the same library as CoveragePkg -- 01/2012: 2.3 Added Function GetBin from Jerry K. -- Made write for RangeArrayType visible -- 01/2012: 2.4 -- Revised AddBins and AddCross to handle merging and deletion for overlapping bins -- Note merging is an experimental feature. -- Renamed RandCovHole to RandCovBinVal - maintained old version calls new -- Renamed GetCovHole to GetHoleBinVal - maintained old version calls new -- 04/2013: 2013.04 -- Revised AddBins and AddCross s.t. bin merging is off by default. -- Added SetMerging to enable/disable merging. -- Note: Merging is an experimental feature and still evolving. -- Revised AddBins and AddCross to check for changes in BinVal size (different size bin). -- Added RandCovPoint for integer. -- Added SetThresholding and SetCovThreshold(Percent) to enable/disable(default) thresholding. -- Revised RandCovPoint and RandCovBinVal to use new mechanism. -- Added SetCovTarget to increase/decrease coverage goals for longer/shorter simulation runs. -- Made CovTarget the default percentage goal (via overloading) for methods RandCovPoint, -- RandCovBinVal, IsCovered, CountCovHoles, GetHoleBinVal, and WriteCovHoles -- Revised SetIllegalMode and ICover to support ILLEGAL_FAILURE (severity FAILURE on illegal bin). -- Added manual bin iteration support. -- BinIndex: GetNumBins, GetMinIndex, GetMaxIndex -- BinVal: GetBinVal(BinIndex), GetMinBinVal, GetMaxBinVal -- Point: GetPoint (BinIndex), GetMinPoint, GetMaxPoint -- Added GetCov to return the current percent done of the entire coverage model. -- Added FileOpenWriteBin and FileCloseWriteBin to specify default file for WriteBin, WriteCovHoles, and DumpBin -- Added CompareBins to facilitate comparing two coverage models. -- Revised WriteBin, WriteCovHoles, and WriteCovDb to check for uninitialized model. -- Revised WriteBins and WriteCovHoles to only print weight if the selected WeightMode uses the weight. -- Added IsInitialized to check if a coverage model is initialized. -- Added GetBinInfo and GetBinValLength to get bin information -- Changed WriteCovDb default for File_Open_Kind to WRITE_MODE -- Revised WriteCovDb and ReadCovDb for new internal control/state variables -- Removed IgnoreBin with AtLeast and Weight parameters. These are zero for ignore bins. -- Revised method naming for consistency. The following have changed: -- New Name Old Name Why -- CovBinErrCnt GetErrorCount Consistency between packages -- GetMinCount GetMinCov[return integer] Naming clarity -- GetMaxCount GetMaxCov[return integer] Naming clarity -- SetName SetItemName SetName now does multi-line messages -- Deprecated usage of the AtLeast parameter (integer) with the following methods: -- RandCovPoint, RandCovBinVal, IsCovered, CountCovHoles, -- GetHoleBinVal, and WriteCovHoles. -- 5/2013 2013.05 -- No changes of substance. -- Removed extra variable declaration in functions GetHoleBinval, -- RandCovBinVal, RandCovHole, GetHoleBinVal -- Using work.RandomPkg.NULL_RANGE_TYPE to remove NULL range warnings -- 1/2014 2014.01 -- Revised ReadCovDb to support merging of coverage models -- Revised RandCovPoint and RandCovBinVal to log the bin index in the LastIndex variable -- Revised ICover to look in bin referenced by LastIndex first -- Added GetLastIndex and GetLastBinVal -- Revised AddBins and AddCross bin merging to allow arbitrary CountBin overlap (facilitated by LastIndex) -- Note: Merging is an experimental feature and still evolving. -- Split SetName into SetMessage (headers) and SetName (printing illegal bins) -- Added methods GetItemCount and GetTotalCovGoal -- Revised GetCov to use CovTarget and overloaded to use a PercentCov parameter. -- -- 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 - 2013 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.RandomBasePkg.all ; use work.RandomPkg.all ; use work.MessagePkg.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 ; -- 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 ; ------------------------------------------------------------ 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 FileOpenWriteCovDb (FileName : string; OpenKind : File_Open_Kind ) ; -- procedure FileCloseWriteCovDb ; procedure SetIllegalMode (A : IllegalModeType) ; procedure SetWeightMode (A : WeightModeType; Scale : real := 1.0) ; procedure SetName (NameIn : String) ; procedure SetMessage (MessageIn : 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 ) ; procedure InitSeed (I : integer ) ; procedure SetSeed (RandomSeedIn : RandomSeedType ) ; impure function GetSeed return RandomSeedType ; procedure SetBinSize (NewNumBins : integer) ; ------------------------------------------------------------ procedure AddBins ( AtLeast : integer ; Weight : integer ; CovBin : CovBinType ) ; procedure AddBins (AtLeast : integer ; CovBin : CovBinType) ; procedure AddBins (CovBin : CovBinType) ; ------------------------------------------------------------ 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 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 ; -- procedure WriteBin ( file f : text ) ; procedure WriteBin ; procedure WriteBin ( FileName : string; OpenKind : File_Open_Kind := APPEND_MODE ) ; procedure WriteCovHoles ; procedure WriteCovHoles ( PercentCov : real ) ; procedure WriteCovHoles ( FileName : string; OpenKind : File_Open_Kind := APPEND_MODE ) ; procedure WriteCovHoles ( FileName : string; PercentCov : real ; OpenKind : File_Open_Kind := APPEND_MODE ) ; procedure DumpBin ; -- 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 AddBins (CovBin : CovMatrix2Type) ; procedure AddBins (CovBin : CovMatrix3Type) ; procedure AddBins (CovBin : CovMatrix4Type) ; procedure AddBins (CovBin : CovMatrix5Type) ; procedure AddBins (CovBin : CovMatrix6Type) ; procedure AddBins (CovBin : CovMatrix7Type) ; procedure AddBins (CovBin : CovMatrix8Type) ; procedure AddBins (CovBin : CovMatrix9Type) ; ------------------------------------------------------------ -- 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 ( FileName : string; AtLeast : integer ; OpenKind : File_Open_Kind := APPEND_MODE ) ; 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 ) ; -- -- 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 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 ; ---------------------------------------------------------- -- function IgnoreBin ( ---------------------------------------------------------- -- AtLeast : integer ; -- Weight : integer ; -- Min, Max : integer ; -- NumBin : integer -- ) return CovBinType ; -- function IgnoreBin (AtLeast : integer ; Min, Max, NumBin : integer) return CovBinType ; -- All items in range in a single CovBin ------------------------------------------------------------ function IgnoreBin (Min, Max, NumBin : integer) return CovBinType ; ------------------------------------------------------------ function IgnoreBin (Min, Max : integer) return CovBinType ; function IgnoreBin (A : integer) return CovBinType ; ------------------------------------------------------------ function GenBin ( -- Manual entry format for CovBin within lots of extra parens ------------------------------------------------------------ ManualBin : CovBinManualType ) 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 ; ------------------------------------------------------------ procedure increment( signal Count : inout integer ) ; procedure increment( signal Count : inout integer ; enable : boolean ) ; procedure increment( signal Count : inout integer ; enable : std_ulogic ) ; ------------------------------------------------------------ -- 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 ; end package CoveragePkg ; --- ////////////////////////////////////////////////////////////////////////////////////////////// --- ////////////////////////////////////////////////////////////////////////////////////////////// package body CoveragePkg is ------------------------------------------------------------ function inside ( -- package local ------------------------------------------------------------ CovPoint : integer ; BinVal : RangeType ) return boolean is begin return CovPoint >= BinVal.min and CovPoint <= BinVal.max ; end function inside ; ------------------------------------------------------------ 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 function failed (InValid : boolean ; Message : string := " ") return boolean is -- Move to TextUtilPkg and make visible? ------------------------------------------------------------ begin if InValid then report Message severity failure ; end if ; return InValid ; end function failed ; ------------------------------------------------------------ -- package local procedure EmptyOrCommentLine ( -- Better as Function, but not supported in VHDL functions ------------------------------------------------------------ variable L : InOut line ; variable Empty : out boolean ) is variable Valid : boolean ; variable Char : character ; constant NBSP : CHARACTER := CHARACTER'val(160); -- space character begin Empty := TRUE ; -- if line empty (null or 0 length), Empty = TRUE if L = null or L.all'length = 0 then return ; end if ; -- if line starts with '#', empty = TRUE if L.all(1) = '#' then return ; end if ; -- if line starts with '--', empty = TRUE if L.all'length >= 2 and L.all(1) = '-' and L.all(2) = '-' then return ; end if ; -- Otherwise, remove white space and check for end of line -- Code borrowed from David Bishop, skip_whitespace WhiteSpLoop : while L /= null and L.all'length > 0 loop if (L.all(1) = ' ' or L.all(1) = NBSP or L.all(1) = HT) then read (L, Char, Valid) ; else Empty := FALSE ; exit WhiteSpLoop ; end if ; end loop WhiteSpLoop ; end procedure EmptyOrCommentLine ; ------------------------------------------------------------ -- 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 -- ------------------------------------------------------------ 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 => report "ConcatenateBins: 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 ; ------------------------------------------------------------ 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 ; ------------------------------------------------------------------------------------------ -- XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX CovPType XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX -- XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX CovPType XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX -- XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX CovPType XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX ------------------------------------------------------------------------------------------ type CovPType is protected body -- Name Data Structure variable Message : MessagePType ; -- 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 ; 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 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 ; -- file WriteCovDbFile : text ; -- variable WriteCovDbFileInit : boolean := FALSE ; ------------------------------------------------------------ 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 FileOpenWriteCovDb (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 SetIllegalMode (A : IllegalModeType) is ------------------------------------------------------------ begin IllegalMode := A ; 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 swrite(buf, "%%WARNING: WeightScale > 2.0 and large Counts can cause RandCovPoint to fail due to integer values out of range") ; writeline(OUTPUT, buf) ; end if ; if (WeightScale < 1.0) and (WeightMode = REMAIN_WEIGHT or WeightMode = REMAIN_SCALED) then report "WeightScale must be > 1.0 when WeightMode = REMAIN_WEIGHT or WeightMode = REMAIN_SCALED" severity failure ; WeightScale := 1.0 ; end if; if WeightScale <= 0.0 then report "WeightScale must be > 0.0" severity failure ; WeightScale := 1.0 ; end if; end procedure SetWeightMode ; ------------------------------------------------------------ procedure SetName (NameIn : String) is ------------------------------------------------------------ begin Message.SetName(NameIn) ; if not RvSeedInit then -- Init seed if not initialized RV.InitSeed(NameIn) ; RvSeedInit := TRUE ; end if ; end procedure SetName ; ------------------------------------------------------------ procedure SetMessage (MessageIn : String) is ------------------------------------------------------------ begin Message.SetMessage(MessageIn) ; if not RvSeedInit then -- Init seed if not initialized RV.InitSeed(MessageIn) ; RvSeedInit := TRUE ; end if ; end procedure SetMessage ; ------------------------------------------------------------ -- 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 buf : line ; begin MessageCount := Message.GetMessageCount ; if MessageCount = 0 then if Prefix'length + S'length > 0 then write(buf, Prefix & S) ; writeline(f, buf) ; -- write(f, Prefix & S & LF); end if ; else write(buf, Prefix & S & Message.GetMessage(1)) ; writeline(f, buf) ; for i in 2 to MessageCount loop write(buf, Prefix & Message.GetMessage(i)) ; writeline(f, buf) ; end loop ; end if ; end procedure WriteBinName ; ------------------------------------------------------------ procedure DeallocateMessage is ------------------------------------------------------------ begin Message.DeallocateMessage ; end procedure DeallocateMessage ; ------------------------------------------------------------ procedure DeallocateName is ------------------------------------------------------------ begin Message.DeallocateName ; 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 report "Invalid Threshold Value " & real'image(Percent) severity 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 ; ------------------------------------------------------------ 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 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 assert BinValLength = CurBinValLength report Caller & ": Cross bins with different sizes prohibited" severity 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 ; PercentCov : real := 0.0 ) is begin 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).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 ; PercentCov : real := 0.0 ) is variable Position : integer ; variable FoundInside : boolean ; begin if not MergingEnable then InsertNewBin(BinVal, Action, Count, AtLeast, Weight, 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, 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 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, 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, PercentCov) ; else report "InsertBin (AddBins/AddCross): ignore bin dropped. It is a subset of prior bin" severity 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, PercentCov) ; else report "InsertBin (AddBins/AddCross): illegal bin dropped. It is a subset of prior bin" severity error ; end if; end if ; end if ; -- merging enabled end procedure InsertBin ; ------------------------------------------------------------ procedure AddBins ( ------------------------------------------------------------ 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 ) ; end loop ; 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( -- Cross existing bins ------------------------------------------------------------ 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) ; IncBinIndex( BinIndex, BIN_LENS) ; -- increment right most one, then if overflow, increment next end loop ; end procedure AddCross ; ------------------------------------------------------------ procedure AddCross( -- Cross existing bins ------------------------------------------------------------ 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( -- Cross existing bins ------------------------------------------------------------ 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) ; end loop ; deallocate(CovBinPtr) ; Message.Deallocate ; -- 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 ; -- RvSeedInit := FALSE ; 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 ; 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 and IllegalMode /= ILLEGAL_OFF then write(buf, "%% " & Message.GetName & " Illegal Value: " ) ; if CovPoint = NULL_INTV then swrite(buf, "LastIndex Value") ; else write(buf, CovPoint) ; end if ; write(buf, " is in an illegal Bin. " & "Time: " & time'image(now)) ; writeline(OUTPUT, buf) ; if IllegalMode = ILLEGAL_FAILURE then report Message.GetName & " Illegal Value" severity failure ; 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 ------------------------------------------------------------ variable Found : boolean := FALSE ; begin if CountMode = COUNT_FIRST and inside(CovPoint, CovBinPtr(LastIndex).BinVal.all) then ICoverIndex(LastIndex, CovPoint) ; Found := TRUE ; end if; if not Found then 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 SetCovZero 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 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 -- assert NumBins >= 1 report "IsCovered: Empty Coverage Model" severity failure ; return CountCovHoles(PercentCov) = 0 ; end function IsCovered ; ------------------------------------------------------------ impure function IsCovered return boolean is ------------------------------------------------------------ begin -- assert NumBins >= 1 report "IsCovered: Empty Coverage Model" severity 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 ; write(buf, "%%Error GetHoleBinVal did not find hole. " & "HoleCount = " & integer'image(HoleCount) & "ReqHoleNum = " & integer'image(ReqHoleNum) & LF) ; writeline(OUTPUT, buf) ; 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 ; ------------------------------------------------------------ -- pt local for now -- file formal parameter not allowed with method procedure WriteBin ( file f : text ) is ------------------------------------------------------------ variable buf : line ; begin WriteBinName(f, "WriteBin: ") ; if NumBins < 1 then swrite(buf, "%%FATAL, Coverage Model is empty. Nothing to print.") ; writeline(f, buf) ; report "Coverage model is empty. Nothing to print." severity failure ; end if ; for i in 1 to NumBins loop -- CovBinPtr.all'range if CovBinPtr(i).count < 0 then swrite(buf, "%%Illegal Bin:") ; write(buf, CovBinPtr(i).BinVal.all) ; write(buf, " Count = " & integer'image(-CovBinPtr(i).count)) ; write(buf, "" & LF) ; elsif CovBinPtr(i).action = COV_COUNT 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 ; swrite(buf, "") ; writeline(f, buf) ; end procedure WriteBin ; ------------------------------------------------------------ procedure WriteBin is ------------------------------------------------------------ begin if WriteBinFileInit then WriteBin(WriteBinFile) ; else WriteBin(OUTPUT) ; end if ; end procedure WriteBin ; ------------------------------------------------------------ procedure WriteBin (FileName : string; OpenKind : File_Open_Kind := APPEND_MODE ) is ------------------------------------------------------------ file BinFile : text open OpenKind is FileName ; begin WriteBin(BinFile) ; end procedure WriteBin ; ------------------------------------------------------------ -- 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, "%% 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 is ------------------------------------------------------------ begin if WriteBinFileInit then DumpBin(WriteBinFile) ; else DumpBin(OUTPUT) ; end if ; end procedure DumpBin ; ------------------------------------------------------------ -- pt local procedure WriteCovHoles ( file f : text; PercentCov : real := 100.0 ) is ------------------------------------------------------------ variable buf : line ; begin WriteBinName(f, "WriteCovHoles: ") ; if NumBins < 1 then swrite(buf, "%%FATAL, Coverage Model is empty. Nothing to print.") ; writeline(f, buf) ; report "Coverage model is empty. Nothing to print." severity failure ; end if ; CovLoop : for i in 1 to NumBins loop if CovBinPtr(i).action = COV_COUNT and CovBinPtr(i).PercentCov < PercentCov 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 ; ------------------------------------------------------------ procedure WriteCovHoles is ------------------------------------------------------------ begin if WriteBinFileInit then WriteCovHoles(WriteBinFile, CovTarget) ; else WriteCovHoles(OUTPUT, CovTarget) ; end if; end procedure WriteCovHoles ; ------------------------------------------------------------ procedure WriteCovHoles ( PercentCov : real ) is ------------------------------------------------------------ begin if WriteBinFileInit then WriteCovHoles(WriteBinFile, PercentCov) ; else WriteCovHoles(OUTPUT, 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 WriteCovHoles(CovHoleFile, CovTarget) ; end procedure WriteCovHoles ; ------------------------------------------------------------ procedure WriteCovHoles ( FileName : string; PercentCov : real ; OpenKind : File_Open_Kind := APPEND_MODE ) is ------------------------------------------------------------ file CovHoleFile : text open OpenKind is FileName ; begin WriteCovHoles(CovHoleFile, PercentCov) ; end procedure WriteCovHoles ; ------------------------------------------------------------ -- pt local impure function FindBin ( ------------------------------------------------------------ Merge : boolean ; BinVal : RangeArrayType ; Action : integer ) 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 then return i ; end if; end loop ; end if ; return 0 ; end function FindBin ; ------------------------------------------------------------ -- pt local procedure ReadCovVars (file CovDbFile : text; Good : out boolean ) is ------------------------------------------------------------ variable buf : line ; variable Empty : boolean ; 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 ReadLine(CovDbFile, buf) ; EmptyOrCommentLine(buf, Empty) ; next when Empty ; if buf.all /= "CoveragePkg_Not_Named" then Message.SetName(buf.all) ; end if ; exit ReadLoop0 ; end loop ReadLoop0 ; ReadLoop1 : while not EndFile(CovDbFile) loop ReadLine(CovDbFile, buf) ; EmptyOrCommentLine(buf, Empty) ; next when Empty ; read(buf, iSeed, ReadValid) ; exit ReadLoop1 when failed(not ReadValid, "ReadCovDb: Failed while reading Seed") ; RV.SetSeed( iSeed ) ; RvSeedInit := TRUE ; read(buf, iCovThreshold, ReadValid) ; exit ReadLoop1 when failed(not ReadValid, "ReadCovDb: Failed while reading CovThreshold") ; CovThreshold := iCovThreshold ; read(buf, iIllegalMode, ReadValid) ; exit ReadLoop1 when failed(not ReadValid, "ReadCovDb: Failed while reading IllegalMode") ; IllegalMode := IllegalModeType'val( iIllegalMode ) ; read(buf, iWeightMode, ReadValid) ; exit ReadLoop1 when failed(not ReadValid, "ReadCovDb: Failed while reading WeightMode") ; WeightMode := WeightModeType'val( iWeightMode ) ; read(buf, iWeightScale, ReadValid) ; exit ReadLoop1 when failed(not ReadValid, "ReadCovDb: Failed while reading WeightScale") ; WeightScale := iWeightScale ; read(buf, iCountMode, ReadValid) ; exit ReadLoop1 when failed(not ReadValid, "ReadCovDb: Failed while reading CountMode") ; CountMode := CountModeType'val( iCountMode ) ; read(buf, iThresholdingEnable, ReadValid) ; exit ReadLoop1 when failed(not ReadValid, "ReadCovDb: Failed while reading CountMode") ; ThresholdingEnable := iThresholdingEnable ; read(buf, iCovTarget, ReadValid) ; exit ReadLoop1 when failed(not ReadValid, "ReadCovDb: Failed while reading CountMode") ; CovTarget := iCovTarget ; read(buf, iMergingEnable, ReadValid) ; exit ReadLoop1 when failed(not ReadValid, "ReadCovDb: Failed while reading CountMode") ; MergingEnable := iMergingEnable ; exit ReadLoop1 ; end loop ReadLoop1 ; GoodLoop1 := ReadValid ; ReadLoop2 : while not EndFile(CovDbFile) loop ReadLine(CovDbFile, buf) ; EmptyOrCommentLine(buf, Empty) ; next when Empty ; read(buf, iNumberOfMessages, ReadValid) ; exit ReadLoop2 when failed(not ReadValid, "ReadCovDb: Failed while reading NumberOfMessages") ; for i in 1 to iNumberOfMessages loop exit ReadLoop2 when failed(EndFile(CovDbFile), "ReadCovDb: End of File while reading Messages") ; 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 ; begin ReadLoop : while not EndFile(CovDbFile) loop ReadLine(CovDbFile, buf) ; EmptyOrCommentLine(buf, Empty) ; next when Empty ; read(buf, NumRangeItems, ReadValid) ; exit ReadLoop when failed(not ReadValid, "ReadCovDb: Failed while reading NumRangeItems") ; read(buf, NumLines, ReadValid) ; assert ReadValid report "ReadCovDb: Failed while reading NumLines" severity 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 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 ; begin GrowBins(NumLines) ; ReadLoop : for i in 1 to NumLines loop exit ReadLoop when failed(EndFile(CovDbFile), "ReadCovDb: Did not read specified number of lines") ; ReadLine(CovDbFile, buf) ; EmptyOrCommentLine(buf, Empty) ; next when Empty ; -- replace with EmptyLine(buf) read(buf, Action, ReadValid) ; exit ReadLoop when failed(not ReadValid, "ReadCovDb: Failed while reading Action") ; read(buf, Count, ReadValid) ; exit ReadLoop when failed(not ReadValid, "ReadCovDb: Failed while reading Count") ; read(buf, AtLeast, ReadValid) ; exit ReadLoop when failed(not ReadValid, "ReadCovDb: Failed while reading AtLeast") ; read(buf, Weight, ReadValid) ; exit ReadLoop when failed(not ReadValid, "ReadCovDb: Failed while reading Weight") ; read(buf, PercentCov, ReadValid) ; exit ReadLoop when failed(not ReadValid, "ReadCovDb: Failed while reading PercentCov") ; read(buf, BinVal, ReadValid) ; exit ReadLoop when failed(not ReadValid, "ReadCovDb: Failed while reading BinVal") ; index := FindBin(Merge, BinVal, Action) ; if index > 0 then -- merge it 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, PercentCov) ; end if ; 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 WriteCovVars (file CovDbFile : text ) is ------------------------------------------------------------ variable buf : line ; begin -- write coverage private variables to the file if Message.GetName /= "" then write(buf, Message.GetName) ; else swrite(buf, "CoveragePkg_Not_Named") ; end if ; writeline(CovDbFile, buf) ; write(buf, RV.GetSeed ) ; write(buf, ' ') ; write(buf, CovThreshold) ; write(buf, ' ') ; write(buf, IllegalModeType'pos(IllegalMode)) ; write(buf, ' ') ; write(buf, WeightModeType'pos(WeightMode)) ; write(buf, ' ') ; write(buf, WeightScale) ; write(buf, ' ') ; write(buf, CountModeType'pos(CountMode)) ; write(buf, ' ') ; write(buf, ThresholdingEnable) ; -- boolean write(buf, ' ') ; write(buf, CovTarget) ; -- Real write(buf, ' ') ; write(buf, MergingEnable) ; -- boolean write(buf, ' ') ; writeline(CovDbFile, buf) ; write(buf, Message.GetMessageCount ) ; writeline(CovDbFile, buf) ; WriteBinName(CovDbFile, "", "") ; end procedure WriteCovVars ; ------------------------------------------------------------ -- 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 WriteCovVars( 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) ; write(buf, ' ') ; WriteBinVal(buf, CovBinPtr(LineCount).BinVal.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 WriteCovDb(CovDbFile) ; 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 the older AddBins(GenCross(...)) methodology -- which has been replaced by AddCross ------------------------------------------------------------ procedure AddBins (CovBin : CovMatrix2Type) is ------------------------------------------------------------ begin 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 ) ; end loop ; end procedure AddBins ; ------------------------------------------------------------ procedure AddBins (CovBin : CovMatrix3Type) is ------------------------------------------------------------ begin 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 ) ; end loop ; end procedure AddBins ; ------------------------------------------------------------ procedure AddBins (CovBin : CovMatrix4Type) is ------------------------------------------------------------ begin 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 ) ; end loop ; end procedure AddBins ; ------------------------------------------------------------ procedure AddBins (CovBin : CovMatrix5Type) is ------------------------------------------------------------ begin 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 ) ; end loop ; end procedure AddBins ; ------------------------------------------------------------ procedure AddBins (CovBin : CovMatrix6Type) is ------------------------------------------------------------ begin 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 ) ; end loop ; end procedure AddBins ; ------------------------------------------------------------ procedure AddBins (CovBin : CovMatrix7Type) is ------------------------------------------------------------ begin 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 ) ; end loop ; end procedure AddBins ; ------------------------------------------------------------ procedure AddBins (CovBin : CovMatrix8Type) is ------------------------------------------------------------ begin 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 ) ; end loop ; end procedure AddBins ; ------------------------------------------------------------ procedure AddBins (CovBin : CovMatrix9Type) is ------------------------------------------------------------ begin 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 ) ; end loop ; end procedure AddBins ; -- ------------------------------------------------------------ -- ------------------------------------------------------------ -- 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 => report "Selected Weight Mode not Supported with depricated RandCovPoint(AtLeast), see RandCovPoint(PercentCov)" severity 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 ; write(buf, "%%Error GetHoleBinVal did not find hole. " & "HoleCount = " & integer'image(HoleCount) & "ReqHoleNum = " & integer'image(ReqHoleNum) & LF) ; writeline(OUTPUT, buf) ; 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 swrite(buf, "%%FATAL, Coverage Model is empty. Nothing to print.") ; writeline(f, buf) ; report "Coverage model is empty. Nothing to print." severity 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 WriteCovHoles(WriteBinFile, AtLeast) ; else WriteCovHoles(OUTPUT, 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 ; 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 ; begin NumBins1 := Bin1.GetNumBins ; NumBins2 := Bin2.GetNumBins ; if (NumBins1 /= NumBins2) then write(buf, "Bins have different lengths" & LF) ; writeline(OUTPUT, buf) ; ErrorCount := ErrorCount + 1 ; 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 ErrorCount := ErrorCount + 1 ; 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)) ; 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)) ; writeline(OUTPUT, buf) ; end if ; end loop ; end procedure CompareBins ; ------------------------------------------------------------ -- package local, Used by GenBin, IllegalBin, and IgnoreBin function MakeBin( ------------------------------------------------------------ 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, rNextMin, rNumItemsInBin, rRemainingBins : real ; -- must be real begin if Min > Max then report "MakeBin (GenBin, IllegalBin, IgnoreBin): Min must be <= Max" severity failure ; return NULL_BIN ; elsif NumBin <= 0 then report "MakeBin (GenBin, IllegalBin, IgnoreBin): NumBin must be <= 0" severity failure ; return NULL_BIN ; elsif NumBin = 1 then iCovBin(1) := ( BinVal => (1 => (Min, Max)), Action => Action, Count => 0, Weight => Weight, AtLeast => AtLeast ) ; return iCovBin ; else rCurMin := real(Min) ; rMax := real(Max) ; rRemainingBins := (minimum( real(NumBin), rMax - rCurMin + 1.0 )) ; TotalBins := integer(rRemainingBins) ; for i in iCovBin'range loop exit when rRemainingBins = 0.0 ; rNumItemsInBin := trunc((rMax - rCurMin + 1.0) / rRemainingBins) ; -- can be too large rNextMin := rCurMin + rNumItemsInBin ; -- can be 2**31 iCovBin(i) := ( BinVal => (1 => (integer(rCurMin), integer(rNextMin - 1.0))), Action => Action, Count => 0, Weight => Weight, AtLeast => AtLeast ) ; rCurMin := rNextMin ; rRemainingBins := rRemainingBins - 1.0 ; end loop ; return iCovBin(1 to TotalBins) ; end if ; end function MakeBin ; -- Old version with bug -- ------------------------------------------------------------ -- -- package local, Used by GenBin, IllegalBin, and IgnoreBin -- function MakeBin( -- ------------------------------------------------------------ -- Min, Max : integer ; -- NumBin : integer ; -- AtLeast : integer ; -- Weight : integer ; -- Action : integer -- ) return CovBinType is -- constant CheckParms : boolean := failed(Min > Max, "MakeBin (GenBin, IllegalBin, IgnoreBin): Min must be <= Max") ; -- constant CALC_NUM_BINS : integer := minimum(NumBin, Max-Min+1) ; -- variable iCovBin : CovBinType(0 to CALC_NUM_BINS -1) ; -- variable CurMin, NextMin, RemainingBins, NumItemsInBin : integer ; -- begin -- CurMin := Min ; -- for i in iCovBin'range loop -- RemainingBins := CALC_NUM_BINS - i ; -- NumItemsInBin := (Max - CurMin + 1) / RemainingBins ; -- NextMin := CurMin + NumItemsInBin ; -- iCovBin(i) := ( -- BinVal => (1 => (CurMin, NextMin - 1)), -- Action => Action, -- Count => 0, -- Weight => Weight, -- AtLeast => AtLeast -- ) ; -- CurMin := NextMin ; -- end loop ; -- return iCovBin ; -- 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 -- default, 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 -- default, create a separate CovBin for each value -- 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 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 ; ---------------------------------------------------------- -- function IgnoreBin ( ---------------------------------------------------------- -- 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_IGNORE -- ) ; -- end function IgnoreBin ; ---------------------------------------------------------- -- function IgnoreBin (AtLeast : integer ; Min, Max, NumBin : integer) return CovBinType is ---------------------------------------------------------- -- begin -- return MakeBin( -- Min => Min, -- Max => Max, -- NumBin => NumBin, -- AtLeast => AtLeast, -- Weight => 0, -- Action => COV_IGNORE -- ) ; -- end function IgnoreBin ; ------------------------------------------------------------ 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 GenBin ( -- Manual entry format for CovBin within lots of extra parens ------------------------------------------------------------ ManualBin : CovBinManualType ) return CovBinType is alias imBin : CovBinManualType (1 to ManualBin'length) is ManualBin ; variable iCovBin : CovBinType(imBin'range) ; begin for i in iCovBin'range loop iCovBin(i) := ( (1 => (imBin(i)(0),imBin(i)(1))), imBin(i)(2), 0, 1, 1) ; end loop ; return iCovBin ; end function GenBin ; ------------------------------------------------------------ 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 ; ------------------------------------------------------------ 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 ; ------------------------------------------------------------ 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 ; end package body CoveragePkg ;