| /****************************************************************************** |
| * (C) Copyright 2015 AMIQ Consulting |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| * NAME: svaunit_vpi_interface.sv |
| * PROJECT: svaunit |
| * Description: It contains communication API with VPI |
| *******************************************************************************/ |
| |
| `ifndef SVAUNIT_VPI_INTERFACE_SV |
| `define SVAUNIT_VPI_INTERFACE_SV |
| |
| // It contains communication API with VPI |
| interface svaunit_vpi_interface(); |
| import svaunit_pkg::*; |
| import uvm_pkg::*; |
| `include "uvm_macros.svh" |
| `include "svaunit_defines.svh" |
| `include "svaunit_version_defines.svh" |
| |
| // DPI-C API used to find SVAs using VPI API |
| import "DPI-C" context function void register_assertions_dpi(input int print_flag); |
| |
| /* Control assertion using vpi_control function |
| * @param a_sva_name : the assertion used to apply control action on |
| * @param a_control_type : the control action |
| * @param a_sys_time : attempt time |
| */ |
| import "DPI-C" context function void control_assertion_dpi(input string a_sva_name, input int a_control_type, |
| input int a_sys_time); |
| |
| /* DPI-C API used to get SVA cover statistics - how many times this cover was triggered and how many times it failed |
| * @param a_cover_name : cover name to retrieve information about |
| * @param a_nof_attempts_covered : number of attempts this cover was triggered and it failed |
| * @param a_nof_attempts_succeeded_covered : number of attempts this cover was triggered and it succeeded |
| */ |
| import "DPI-C" context function void get_cover_statistics_dpi(input string a_cover_name, |
| output int unsigned a_nof_attempts_covered, output int unsigned a_nof_attempts_succeeded_covered); |
| |
| /* DPI-C API to retrieve information about all callbacks |
| * @param a_test_name : the test name from which this function is called |
| */ |
| import "DPI-C" context function void call_callback_dpi(input string a_test_name); |
| |
| /* Set the current test name |
| * @param a_test_name : current test name to be updated |
| */ |
| import "DPI-C" context function void set_test_name_to_vpi_dpi(input string a_test_name); |
| |
| // Check that the current clock cycle has finished |
| import "DPI-C" function int dpi_check_flag(); |
| |
| /* VPI API to update a given SVA |
| * @param a_test_name : test name from where this function is called |
| * @param a_sva_name : SVA name to be updated |
| * @param a_sva_type : the type of the SVA to be updated |
| * @param a_reason : callback reason |
| * @param a_start_time : the start attempt for this SVA |
| * @param a_callback_time : the callback time for this SVA attempt |
| */ |
| export "DPI-C" function pass_info_to_sv_dpi; |
| |
| /* Create SVA with a name and a type given |
| * @param a_sva_name : SVA name to be created |
| * @param a_sva_type : SVA type to be created |
| */ |
| export "DPI-C" function create_assertion_dpi; |
| |
| // Stores the test name to be simulated |
| string test_name; |
| |
| // "End of time slot" flag (1 - reached; 0 - not reached); |
| bit eots_flag = 0; |
| |
| // Will store the info for all assertions from an interface |
| svaunit_concurrent_assertion_info sva_info[]; |
| |
| // Will store the info for all cover assertions from an interface |
| svaunit_concurrent_assertion_info cover_info[]; |
| |
| // Will store the info for all property assertions from an interface |
| svaunit_concurrent_assertion_info property_info[]; |
| |
| initial begin |
| automatic string svaunit_header = "\n----------------------------------------------------------------"; |
| svaunit_header = $sformatf("%s\n\t\t%s\n", svaunit_header, `SVAUNIT_VERSION_STRING); |
| svaunit_header = $sformatf("%s----------------------------------------------------------------\n", |
| svaunit_header); |
| |
| `uvm_info("SVAUNIT", $sformatf("%s", svaunit_header), UVM_NONE) |
| // Register the assertions from the interface |
| |
| if(uvm_top.get_report_verbosity_level() >= UVM_MEDIUM) |
| register_assertions_dpi(1); |
| else |
| register_assertions_dpi(0); |
| end |
| |
| /* Set test name in VPI interface |
| * @param a_test_name : the test name to be added inside VPI interface |
| */ |
| function void set_test_name(string a_test_name); |
| test_name = a_test_name; |
| |
| set_test_name_to_vpi_dpi(test_name); |
| endfunction |
| |
| /* Retrieve info about SVAs |
| * @param a_test_name : test name from where this function is called |
| */ |
| function void get_info_from_c(string a_test_name); |
| call_callback_dpi(a_test_name); |
| endfunction |
| |
| /* Verify if an SVA assertion exists into SVA list |
| * @param a_sva_name : the SVA to be found into list |
| * @param a_sva_path : the path to the SVA which needs to be found into list |
| * @param a_lof_sva : the list of SVAs |
| * @return 1 if given SVA exists into list and 0 otherwise |
| */ |
| function bit sva_exists(string a_sva_name, string a_sva_path, svaunit_concurrent_assertion_info a_lof_sva[]); |
| int index[$]; |
| |
| index = a_lof_sva.find_index() with ((item.get_sva_name() == a_sva_name) && (item.get_sva_path() == a_sva_path)); |
| |
| if(index.size() > 0) begin |
| return 1; |
| end else begin |
| return 0; |
| end |
| endfunction |
| |
| /* Get the state for an SVA according to a callback a_reason |
| * @param a_reason : the integer to be transformed to a callback reason |
| * @return a state of an SVA transformed from a callback reason |
| */ |
| function svaunit_concurrent_assertion_state_type get_state_from_reason(int a_reason); |
| if (a_reason inside {`SVAUNIT_VPI_CB_ASSERTION_START, `SVAUNIT_VPI_CB_ASSERTION_SUCCESS, |
| `SVAUNIT_VPI_CB_ASSERTION_FAILURE, `SVAUNIT_VPI_CB_ASSERTION_STEP_SUCCESS, |
| `SVAUNIT_VPI_CB_ASSERTION_STEP_FAILURE, `SVAUNIT_VPI_CB_ASSERTION_DISABLE, |
| `SVAUNIT_VPI_CB_ASSERTION_ENABLE, `SVAUNIT_VPI_CB_ASSERTION_RESET, |
| `SVAUNIT_VPI_CB_ASSERTION_KILL}) begin |
| if(a_reason == `SVAUNIT_VPI_CB_ASSERTION_START) begin |
| return SVAUNIT_START; |
| end |
| else if(a_reason == `SVAUNIT_VPI_CB_ASSERTION_SUCCESS) begin |
| return SVAUNIT_SUCCESS; |
| end |
| else if(a_reason == `SVAUNIT_VPI_CB_ASSERTION_FAILURE) begin |
| return SVAUNIT_FAILURE; |
| end |
| if(a_reason == `SVAUNIT_VPI_CB_ASSERTION_STEP_SUCCESS) begin |
| return SVAUNIT_STEP_SUCCESS; |
| end |
| else if(a_reason == `SVAUNIT_VPI_CB_ASSERTION_STEP_FAILURE) begin |
| return SVAUNIT_STEP_FAILURE; |
| end |
| else if(a_reason == `SVAUNIT_VPI_CB_ASSERTION_DISABLE) begin |
| return SVAUNIT_DISABLE; |
| end |
| if(a_reason == `SVAUNIT_VPI_CB_ASSERTION_ENABLE) begin |
| return SVAUNIT_ENABLE; |
| end |
| else if(a_reason == `SVAUNIT_VPI_CB_ASSERTION_RESET) begin |
| return SVAUNIT_RESET; |
| end |
| else if(a_reason == `SVAUNIT_VPI_CB_ASSERTION_KILL) begin |
| return SVAUNIT_KILL; |
| end |
| end else begin |
| return SVAUNIT_IDLE; |
| end |
| endfunction |
| |
| /* Update SVA info according to a reason |
| * @param a_test_name : test name from where this function is called |
| * @param a_sva_name : SVA name to be updated |
| * @param a_sva_path : the path to the SVA which need to be updated |
| * @param a_sva_type : the type of the SVA to be updated |
| * @param a_reason : callback reason |
| * @param a_callback_time : the callback time for this SVA attempt |
| * @param a_lof_sva : the list of SVAs which contains the SVA to be updated |
| */ |
| function void update_sva_from_c(string a_test_name, string a_sva_name, string a_sva_path, string a_sva_type, |
| int a_reason, int a_callback_time, svaunit_concurrent_assertion_info a_lof_sva[]); |
| |
| foreach(a_lof_sva[index]) begin |
| if((a_lof_sva[index].get_sva_name() == a_sva_name) && (a_lof_sva[index].get_sva_type() == a_sva_type) && |
| (a_lof_sva[index].get_sva_path() == a_sva_path)) begin |
| |
| static svaunit_concurrent_assertion_state_type crt_state = get_state_from_reason(a_reason); |
| |
| crt_state = svaunit_concurrent_assertion_state_type'(a_reason); |
| |
| if(crt_state inside {SVAUNIT_SUCCESS, SVAUNIT_FAILURE, SVAUNIT_DISABLE, SVAUNIT_ENABLE, SVAUNIT_RESET, SVAUNIT_KILL}) begin |
| a_lof_sva[index].add_new_detail_sva(a_test_name, crt_state, a_callback_time); |
| end |
| end |
| end |
| endfunction |
| |
| /* Create SVA with a name and a type given |
| * @param a_sva_name : SVA name to be created |
| * @param a_sva_path : the path to the SVA which needs to be created |
| * @param a_sva_type : SVA type to be created |
| */ |
| function void create_assertion_dpi(string a_sva_name, string a_sva_path, string a_sva_type); |
| if(a_sva_type == "vpiCover") begin |
| if(!(sva_exists(a_sva_name, a_sva_path, cover_info))) begin |
| // Create and add an assertion info to assertion_info array |
| cover_info = new[cover_info.size() + 1] (cover_info); |
| cover_info[cover_info.size() - 1] = |
| svaunit_concurrent_assertion_info::type_id::create($sformatf("sva_%s", a_sva_name), null); |
| cover_info[cover_info.size() - 1].create_new_sva(a_sva_name, a_sva_path, a_sva_type); |
| end |
| end else if(a_sva_type == "vpiAssert") begin |
| if(!(sva_exists(a_sva_name, a_sva_path, sva_info))) begin |
| // Create and add an assertion info to assertion_info array |
| sva_info = new[sva_info.size() + 1] (sva_info); |
| sva_info[sva_info.size() - 1] = svaunit_concurrent_assertion_info::type_id::create($sformatf("sva_%s", |
| a_sva_name), null); |
| sva_info[sva_info.size() - 1].create_new_sva(a_sva_name, a_sva_path, a_sva_type); |
| end |
| end else if((a_sva_type == "vpiPropertyInst") || (a_sva_type == "vpiPropertyDecl")) begin |
| if(!(sva_exists(a_sva_name, a_sva_path, property_info))) begin |
| // Create and add an assertion info to assertion_info array |
| property_info = new[property_info.size() + 1] (property_info); |
| property_info[property_info.size() - 1] = svaunit_concurrent_assertion_info::type_id:: |
| create($sformatf("property_%s", a_sva_name), null); |
| property_info[property_info.size() - 1].create_new_sva(a_sva_name, a_sva_path, a_sva_type); |
| end |
| end |
| endfunction |
| |
| /* VPI API to update a given SVA |
| * @param a_test_name : test name from where this function is called |
| * @param a_sva_name : SVA name to be updated |
| * @param a_sva_path : path to the SVA |
| * @param a_sva_type : the type of the SVA to be updated |
| * @param a_reason : callback reason |
| * @param a_callback_time : the callback time for this SVA attempt |
| * @param a_start_time : the start attempt for this SVA |
| */ |
| function void pass_info_to_sv_dpi(string a_test_name, string a_sva_name, string a_sva_path, string a_sva_type, |
| int a_reason, int a_callback_time, int a_start_time); |
| |
| if(a_sva_type == "vpiCover") begin |
| update_sva_from_c(a_test_name, a_sva_name, a_sva_path, a_sva_type, a_reason, a_callback_time, |
| cover_info); |
| end else if(a_sva_type == "vpiAssert") begin |
| update_sva_from_c(a_test_name, a_sva_name, a_sva_path, a_sva_type, a_reason, a_callback_time, |
| sva_info); |
| end else if((a_sva_type == "vpiPropertyInst") || (a_sva_type == "vpiPropertyDecl")) begin |
| update_sva_from_c(a_test_name, a_sva_name, a_sva_path, a_sva_type, a_reason, a_callback_time, |
| property_info); |
| end |
| endfunction |
| |
| /* Get the SVA with the given path |
| * @param a_sva_path : SVA path to be found |
| * @return the SVA with the given path |
| */ |
| function svaunit_concurrent_assertion_info get_assertion_from_path(string a_sva_path); |
| foreach(sva_info[index]) begin |
| if(sva_info[index].get_sva_path() == a_sva_path) begin |
| return sva_info[index]; |
| end |
| end |
| |
| return null; |
| endfunction |
| |
| /* Get the SVA with the given name |
| * @param a_sva_name : SVA name to be found |
| * @return the SVA with the given name |
| */ |
| function svaunit_concurrent_assertion_info get_assertion_by_name(string a_sva_name); |
| foreach(sva_info[index]) begin |
| if(sva_info[index].get_sva_name() == a_sva_name) begin |
| return sva_info[index]; |
| end |
| end |
| |
| return null; |
| endfunction |
| |
| |
| // {{{ Functions used to control SVA |
| //------------------------------- RESET -------------------------------- |
| /* Will discard all current attempts in progress for an SVA with a given name |
| * and resets the SVA to its initial state |
| * @param a_test_name : the test name from which SVA were enabled and tested |
| * @param a_sva : assertion which needs to be reseted |
| */ |
| function void reset_assertion(string a_test_name, svaunit_concurrent_assertion_info a_sva); |
| automatic bit enable_sva = 1; |
| |
| a_sva.set_enable(a_test_name, enable_sva); |
| control_assertion_dpi(a_sva.get_sva_path(), `SVAUNIT_VPI_CONTROL_RESET_ASSERTION, $time()); |
| endfunction |
| |
| /* Will discard all current attempts in progress for all SVAs and resets the SVAs to initial state |
| * @param a_test_name : the test name from which SVA were enabled and tested |
| */ |
| function void reset_all_assertions(string a_test_name); |
| foreach(sva_info[index]) begin |
| reset_assertion(a_test_name, sva_info[index]); |
| end |
| endfunction |
| |
| //------------------------------- DISABLE -------------------------------- |
| /* Will disable the starting of any new attempt for a given SVA |
| * (this will have no effect on any existing attempts or if SVA was already disable; |
| * on default all SVAs are enable) |
| * @param a_test_name : the test name from which SVA were enabled and tested |
| * @param a_sva : assertion which needs to be disabled |
| */ |
| function void disable_assertion(string a_test_name, svaunit_concurrent_assertion_info a_sva); |
| |
| automatic bit disable_sva = 0; |
| |
| a_sva.set_enable(a_test_name, disable_sva); |
| control_assertion_dpi(a_sva.get_sva_path(), `SVAUNIT_VPI_CONTROL_DISABLE_ASSERTION, $time()); |
| endfunction |
| |
| /* Will disable the starting of any new attempt for all SVAs |
| * (this will have no effect on any existing attempts or if SVA was already disable; |
| * on default all SVAs are enable) |
| * @param a_test_name : the test name from which SVA were enabled and tested |
| */ |
| function void disable_all_assertions(string a_test_name); |
| foreach(sva_info[index]) begin |
| disable_assertion(a_test_name, sva_info[index]); |
| end |
| endfunction |
| |
| //------------------------------- ENABLE -------------------------------- |
| /* Will enable starting any new attempts for a given SVA |
| * (this will have no effect id SVA was already enable or on any current attempt) |
| * @param a_test_name : the test name from which SVA were enabled and tested |
| * @param a_sva : assertion which needs to be enabled |
| */ |
| function void enable_assertion(string a_test_name, svaunit_concurrent_assertion_info a_sva); |
| automatic bit enable_sva = 1; |
| |
| a_sva.set_enable(a_test_name, enable_sva); |
| control_assertion_dpi(a_sva.get_sva_path(), `SVAUNIT_VPI_CONTROL_ENABLE_ASSERTION, $time()); |
| endfunction |
| |
| /* Will enable starting any new attempts for all SVAs |
| * (this will have no effect id SVA was already enable or on any current attempt) |
| * @param a_test_name : the test name from which SVA were enabled and tested |
| */ |
| function void enable_all_assertions(string a_test_name); |
| foreach(sva_info[index]) begin |
| enable_assertion(a_test_name, sva_info[index]); |
| end |
| endfunction |
| |
| //------------------------------- KILL -------------------------------- |
| /* Will discard any attempts of a given SVA |
| * (the SVA will remain enabled and does not reset any state used by this SVA) |
| * @param a_test_name : the test name from which SVA were enabled and tested |
| * @param a_sva : assertion which needs to be killed |
| * @param a_sim_time : the time from which any attempt of a given SVA will be discarded |
| */ |
| function void kill_assertion(string a_test_name, svaunit_concurrent_assertion_info a_sva, time a_sim_time); |
| |
| automatic bit enable_sva = 1; |
| |
| a_sva.set_enable(a_test_name, enable_sva); |
| control_assertion_dpi(a_sva.get_sva_path(), `SVAUNIT_VPI_CONTROL_KILL_ASSERTION, a_sim_time); |
| endfunction |
| |
| /* Will discard any attempts of all SVAs |
| * (the SVA will remain enabled and does not reset any state used by any SVA) |
| * @param a_test_name : the test name from which SVA were enabled and tested |
| * @param a_sim_time : the time from which any attempt of a given SVA will be discarded |
| */ |
| function void kill_all_assertions(string a_test_name, time a_sim_time); |
| foreach(sva_info[index]) begin |
| kill_assertion(a_test_name, sva_info[index], a_sim_time); |
| end |
| endfunction |
| |
| //------------------------------- DISABLE STEP -------------------------------- |
| /* Will disable step callback for a given SVA |
| * (this will have no effect if step callback is not enabled or it was already disabled) |
| * @param a_test_name : the test name from which SVA were enabled and tested |
| * @param a_sva : assertion which needs to disable stepping for |
| */ |
| function void disable_step_assertion(string a_test_name, svaunit_concurrent_assertion_info a_sva); |
| |
| automatic bit enable_sva = 1; |
| |
| a_sva.set_enable(a_test_name, enable_sva); |
| control_assertion_dpi(a_sva.get_sva_path(), `SVAUNIT_VPI_CONTROL_DISABLE_STEP_ASSERTION, $time()); |
| endfunction |
| |
| /* Will disable step callback for all SVAs |
| * (this will have no effect if step callback is not enabled or it was already disabled) |
| * @param a_test_name : the test name from which SVA were enabled and tested |
| */ |
| function void disable_step_all_assertions(string a_test_name); |
| foreach(sva_info[index]) begin |
| disable_step_assertion(a_test_name, sva_info[index]); |
| end |
| endfunction |
| |
| //------------------------------- ENABLE STEP -------------------------------- |
| |
| /* Will enable step callback for a given SVA |
| * (by default, stepping is disabled; this will have no effect if stepping was already enabled; |
| * the stepping mode cannot be modified after the assertion attempt has started) |
| * @param a_test_name : the test name from which SVA were enabled and tested |
| * @param a_sva : assertion which needs to enable stepping for |
| */ |
| function void enable_step_assertion(string a_test_name, svaunit_concurrent_assertion_info a_sva); |
| |
| automatic bit enable_sva = 1; |
| |
| a_sva.set_enable(a_test_name, enable_sva); |
| control_assertion_dpi(a_sva.get_sva_path(), `SVAUNIT_VPI_CONTROL_ENABLE_STEP_ASSERTION, $time()); |
| endfunction |
| |
| /* Will enable step callback for all SVAs |
| * (by default, stepping is disabled; this will have no effect if stepping was already enabled; |
| * the stepping mode cannot be modified after the assertion attempt has started) |
| * @param a_test_name : the test name from which SVA were enabled and tested |
| */ |
| function void enable_step_all_assertions(string a_test_name); |
| foreach(sva_info[index]) begin |
| enable_step_assertion(a_test_name, sva_info[index]); |
| end |
| endfunction |
| |
| //------------------------------- SYSTEM RESET -------------------------------- |
| /* Will discard all attempts in progress for all SVAs and restore the entire assertion system to its initial state. |
| * (The vpiAssertionStepSuccess and vpiAssertionStepFailure callbacks will be removed) |
| */ |
| function void system_reset_all_assertions(); |
| control_assertion_dpi("", `SVAUNIT_VPI_CONTROL_SYSTEM_RESET_ASSERTION, $time()); |
| endfunction |
| |
| |
| //------------------------------- SYSTEM ON -------------------------------- |
| /* Will restart the SVAs after it was stopped |
| * @param a_test_name : the test name from which SVA were enabled and tested |
| */ |
| function void system_on_all_assertions(string a_test_name); |
| control_assertion_dpi("", `SVAUNIT_VPI_CONTROL_SYSTEM_ON_ASSERTION, $time()); |
| |
| foreach(sva_info[index]) begin |
| automatic bit enable_sva = 1; |
| |
| sva_info[index].set_enable(a_test_name, enable_sva); |
| end |
| endfunction |
| |
| |
| //------------------------------- SYSTEM OFF -------------------------------- |
| /* Will disable any SVA to being started and all current attempts will be considered as unterminated |
| * @param a_test_name : the test name from which SVA were enabled and tested |
| */ |
| function void system_off_all_assertions(string a_test_name); |
| control_assertion_dpi("", `SVAUNIT_VPI_CONTROL_SYSTEM_OFF_ASSERTION, $time()); |
| |
| foreach(sva_info[index]) begin |
| automatic bit disable_sva = 0; |
| |
| sva_info[index].set_enable(a_test_name, disable_sva); |
| end |
| endfunction |
| |
| |
| //------------------------------- SYSTEM END -------------------------------- |
| /* Will discard any attempt in progress and disable any SVA to be started |
| * (all callbacks will be removed) |
| * @param a_test_name : the test name from which SVA were enabled and tested |
| */ |
| function void system_end_all_assertions(string a_test_name); |
| control_assertion_dpi("", `SVAUNIT_VPI_CONTROL_SYSTEM_END_ASSERTION, $time()); |
| |
| foreach(sva_info[index]) begin |
| automatic bit disable_sva = 0; |
| |
| sva_info[index].set_enable(a_test_name, disable_sva); |
| end |
| endfunction |
| // }}} |
| |
| /* Update SVA cover |
| * @param a_test_name : the test name from which SVA were enabled and tested |
| */ |
| function void update_coverage(string a_test_name); |
| automatic int nof_attempts_failed_covered; |
| automatic int nof_attempts_successful_covered; |
| |
| foreach(cover_info[index]) begin |
| if(cover_info[index].sva_enabled(a_test_name)) begin |
| get_cover_statistics_dpi(cover_info[index].get_sva_name(), nof_attempts_failed_covered, |
| nof_attempts_successful_covered); |
| cover_info[index].set_nof_attempts_failed_covered(nof_attempts_failed_covered); |
| cover_info[index].set_nof_attempts_successfull_covered(nof_attempts_successful_covered); |
| end |
| end |
| endfunction |
| |
| /* Computes how many SVAs are enabled during simulation |
| * @param a_test_name : the test name from which SVA were enabled and tested |
| * @return number of SVA which are enabled during simulation |
| */ |
| function int unsigned get_nof_enabled_sva(string a_test_name); |
| // It stores the number of SVA enabled during simulation |
| automatic int unsigned nof_sva_enabled = 0; |
| |
| //For each SVA verify if it is enabled and increase the counter |
| foreach(sva_info[index]) begin |
| if(sva_info[index].was_enable(a_test_name)) begin |
| nof_sva_enabled = nof_sva_enabled + 1; |
| end |
| end |
| |
| return nof_sva_enabled; |
| endfunction |
| |
| /* Computes how many SVAs were tested during simulation |
| * @param a_test_name : the test name from which SVA were enabled and tested |
| * @return number of SVA which were tested during simulation |
| */ |
| function int unsigned get_nof_tested_sva(string a_test_name); |
| // It stores the number of SVA tested during simulation |
| automatic int unsigned nof_sva_tested = 0; |
| |
| //For each SVA verify if it was tested and increase the counter |
| foreach(sva_info[index]) begin |
| if(sva_info[index].was_tested(a_test_name)) begin |
| nof_sva_tested = nof_sva_tested + 1; |
| end |
| end |
| |
| return nof_sva_tested; |
| endfunction |
| |
| /* Get the total number of SVAs |
| * @return total number of SVAs |
| */ |
| function int unsigned get_nof_sva(); |
| return sva_info.size(); |
| endfunction |
| |
| /* Form the report status of SVA |
| * @param a_test_name : the test name from which SVA were enabled and tested |
| * @return the report status for all SVAs |
| */ |
| function string report_for_sva(string a_test_name, string test_type); |
| // Stores the report |
| static string report = ""; |
| |
| // Stores extra report |
| static string extra = ""; |
| |
| // Stores how many SVAs were enabled during simulation |
| int unsigned nof_enabled_sva; |
| |
| // Stores how many SVAs were tested during simulation |
| int unsigned nof_tested_sva; |
| |
| // Initialize counters |
| nof_enabled_sva = get_nof_enabled_sva(a_test_name); |
| nof_tested_sva = get_nof_tested_sva(a_test_name); |
| |
| // Header for SVAs |
| report = $sformatf("\n\n-------------------- %s::%s : SVAs run statistics --------------------\n\n", |
| a_test_name, test_type); |
| |
| // Print how many enabled SVA are from a total number of SVA |
| report = $sformatf("%s\t%0d/%0d SVA were enabled: \n", report, nof_enabled_sva, get_nof_sva()); |
| |
| // Form the SVAs enabled |
| foreach(sva_info[index]) begin |
| if(sva_info[index].was_enable(a_test_name)) begin |
| report = $sformatf("%s\t\t%s\n", report, sva_info[index].get_sva_name()); |
| end |
| end |
| |
| // Print how many tested SVA are from a total number of enabled SVA |
| report = $sformatf("%s\n\n\t%0d/%0d SVA were exercised: \n\n", report, nof_tested_sva, sva_info.size()); |
| |
| // Form the SVAs tested |
| foreach(sva_info[index]) begin |
| if(sva_info[index].was_tested(a_test_name)) begin |
| report = $sformatf("%s\t\t%s\n", report, sva_info[index].get_sva_name()); |
| end |
| end |
| |
| // Print how many not tested SVA are from a total number of enabled SVA |
| report = $sformatf("%s\n\n\t%0d/%0d SVA were not exercised: \n\n", |
| report, sva_info.size() - nof_tested_sva, sva_info.size()); |
| |
| // Form the SVAs not tested |
| foreach(sva_info[index]) begin |
| if(!sva_info[index].was_tested(a_test_name)) begin |
| report = $sformatf("%s\t\t%s\n", report, sva_info[index].get_sva_name()); |
| end |
| end |
| |
| // Header for cover SVAs |
| report = $sformatf("%s\n\n-------------------- %s::%s: Cover statistics --------------------\n\n", report, |
| a_test_name, test_type); |
| |
| // Form the cover SVA |
| foreach(cover_info[index]) begin |
| if(cover_info[index].sva_enabled(a_test_name)) begin |
| extra = $sformatf("%0d SUCCEEDED, %0d FAILED", cover_info[index] |
| .get_nof_attempts_successful_covered(), cover_info[index].get_nof_attempts_failed_covered()); |
| |
| report = $sformatf("%s\t%s %s\n", report, cover_info[index].get_sva_name(), extra); |
| end |
| end |
| |
| return report; |
| endfunction |
| |
| // Polls the until the "End of time slot" is set (i.e. time slot ended) |
| task wait_for_eots(); |
| do begin |
| eots_flag = dpi_check_flag(); |
| // We need a wait here. Beware #0 goes into an infinite loop. As specified in LRM, #0 sends you to NB region. |
| #1; |
| end while (eots_flag == 0); |
| |
| // Clear the flag for next time slot |
| eots_flag = 0; |
| endtask |
| endinterface |
| |
| `endif |
