UVM/svaunit/sv/svaunit_vpi_api.cpp - third_party/Surelog - Git at Google

 /******************************************************************************
  * (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.
  *
  * MODULE:       svaunit_vpi_api.cpp
  * PROJECT:      svaunit
  * Description:  VPI APIs and DPI-C API - retrieve informations about SVA using VPI
  *               and transfer the information to/from SystemVerilog
  *******************************************************************************/

 #ifndef __SVAUNIT_VPI_API_CPP
 #define __SVAUNIT_VPI_API_CPP

 #include <string.h>
 #include <stdlib.h>
 #include <assert.h>
 #include <iostream>
 #include <stdio.h>
 #include <vector>

 #include "svdpi.h"
 #include "sv_vpi_user.h"
 #include "vpi_user.h"

 using namespace std;

 // Class used to store callback info
 class cb_assertion_info {
 public:
 	// SVA name
 	string assertion_name;

 	// SVA path
 	string assertion_path;

 	// SVA type
 	string assertion_type;

 	// The reason why this callback was triggered
 	int reason;

 	// The start time of the SVA attempt
 	int start_time;

 	// Callback time
 	int cb_time;
 public:
 	/* Constructor for callback info
 	 * name : SVA name
 	 * type : SVA type
 	 * path : SVA path
 	 * cb_reason : current reason why this callback was triggered
 	 * cb_start_time : current start time of the SVA attempt
 	 * a_cb_time : callback time
 	 */
 	cb_assertion_info(string name, string path, string type, int cb_reason,
 			int cb_start_time, int a_cb_time) {

 		assertion_name = name;
 		assertion_path = path;
 		assertion_type = type;
 		reason = cb_reason;
 		start_time = cb_start_time;
 		cb_time = a_cb_time;
 	}

 	// Destructor for callback info class
 	~cb_assertion_info() {
 	}
 };

 extern "C" {
 // Function prototypes so you can have circular calls (sots calls eots etc.)
 PLI_INT32 sots_callback(p_cb_data cb_data);
 PLI_INT32 eots_callback(p_cb_data cb_data);
 PLI_INT32 register_eots_callback();
 PLI_INT32 register_sots_callback();

 /* VPI API to update a given SVA
  * crt_test_name : test name from where this function is called
  * assertion_name : SVA name to be updated
  * assertion_path : path to the SVA
  * assertion_type : the type of the SVA to be updated
  * reason : callback reason
  * start_time : the start attempt for this SVA
  * callback_time : the callback time for this SVA attempt
  */
 extern void pass_info_to_sv_dpi(char *, char*, char *, char *, int, int, int);

 /* Create SVA with a name and a type given
  * assertion_name : SVA name to be created
  * assertion_type : SVA type to be created
  * assertion_path : path to the SVA
  */
 extern void create_assertion_dpi(char *, char *, char *);

 //the SV scope saved at assertion registration. this is required in order to
 //set a scope once the assertion callbacks are ready to update information in SV
 svScope testSvScope;

 // List of SVAs which where found using VPI API
 std::vector<vpiHandle> lof_assertions;

 // List of callbacks for SVAs - this list will store the callbacks until a DPI-C call came
 std::vector<cb_assertion_info> lof_cbs;

 // Test name
 char * test_name;

 /* Set the current test_name
  * crt_test_name : current test name to be updated
  */
 void set_test_name_to_vpi_dpi(char * crt_test_name) {
 	test_name = crt_test_name;
 }

 /* Convert a string from a given char*
  * a_string : the string to be converted
  * return the converted char*
  */
 char * get_char_from_string(string a_string) {
 	char **a_string_c = new char *[1];

 	a_string_c[0] = new char[a_string.length() + 1];

 	strcpy(a_string_c[0], a_string.c_str());

 	return a_string_c[0];
 }

 /* Control assertion using vpi_control function
  * assertion_name : the assertion used to apply control action on
  * control_type : the control action
  * sys_time : attempt time
  */
 void control_assertion_dpi(char * assertion_name, int control_type,
 		int sys_time) {

 	string assertion_type;
 	s_vpi_time *a_struct;
 	int step_constant;
 	bool running_cadence = 0;

 #ifndef IRUN
 	running_cadence = 0;
 #else
 	running_cadence = 1;
 #endif

 	if (((running_cadence == 0)
 			&& ((control_type == vpiAssertionEnableStep)
 					|| (control_type == vpiAssertionDisableStep)))
 			|| (control_type == vpiAssertionKill)) {
 		a_struct->type = vpiSimTime;
 		a_struct->high = 0;
 		a_struct->low = 0;
 		a_struct->real = 0;
 	}

 	if ((running_cadence == 0)
 			&& ((control_type == vpiAssertionEnableStep)
 					|| (control_type == vpiAssertionDisableStep))) {
 		step_constant = vpiAssertionClockSteps;
 	}

 	if ((control_type == vpiAssertionReset)
 			|| (control_type == vpiAssertionDisable)
 			|| (control_type == vpiAssertionEnable)
 			|| (control_type == vpiAssertionKill)
 			|| ((running_cadence == 0)
 					&& ((control_type == vpiAssertionEnableStep)
 							|| (control_type == vpiAssertionDisableStep)))) {
 		if (lof_assertions.size() > 0) {
 			for (unsigned int sva_index = 0; sva_index < lof_assertions.size();
 					sva_index++) {

 				vpiHandle assertion = lof_assertions[sva_index];
 				string an_assertion_name = vpi_get_str(vpiFullName, assertion);

 				if ((an_assertion_name.compare(assertion_name) == 0)
 						&& ((vpi_get(vpiType, assertion) != vpiPropertyDecl)
 								|| (vpi_get(vpiType, assertion)
 										!= vpiPropertyInst))) {
 					vpi_control(control_type, assertion, &a_struct,
 							step_constant);
 				}
 			}
 		}
 	} else if ((control_type == vpiAssertionSysReset)
 			|| (control_type == vpiAssertionSysOn)
 			|| (control_type == vpiAssertionSysOff)
 			|| (control_type == vpiAssertionSysEnd)) {
 		vpi_control(control_type);
 	}
 }

 /* Assertion callback function
  * reason : callback reason
  * cb_time : callback time
  * assertion : handle to assertion
  * info : attempt related information
  * user_data : user data entered upon registration
  * return the callback reason
  */
 PLI_INT32 assertion_callback(PLI_INT32 reason, p_vpi_time cb_time,
 		vpiHandle assertion, p_vpi_attempt_info info, PLI_BYTE8 *user_data) {

 	string casted_reason = "UNKNOWN";
 	int callback_time;
 	int start_time;
 	string assertion_name = vpi_get_str(vpiName, assertion);
 	string assertion_path = vpi_get_str(vpiFullName, assertion);
 	string assertion_type = vpi_get_str(vpiType, assertion);

 	if (reason == cbAssertionStart) {
 		casted_reason = "START";
 	} else if (reason == cbAssertionSuccess) {
 		casted_reason = "SUCCESS";
 	} else if (reason == cbAssertionFailure) {
 		casted_reason = "FAILURE";
 	} else if (reason == cbAssertionDisable) {
 		casted_reason = "DISABLE";
 	} else if (reason == cbAssertionEnable) {
 		casted_reason = "ENABLE";
 	} else if (reason == cbAssertionReset) {
 		casted_reason = "RESET";
 	} else if (reason == cbAssertionKill) {
 		casted_reason = "KILL";
 	} else {
 		casted_reason = "IDLE";

 		// For Cadence cbAssertionStepSuccess and cbAssertionStepFailure are not supported
 #ifndef IRUN
 		if (reason == cbAssertionStepSuccess) {
 			casted_reason = "STEP_SUCCESS";
 		} else if (reason == cbAssertionStepFailure) {
 			casted_reason = "STEP_FAILURE";
 		}
 #endif
 	}

 	if (cb_time != NULL) {
 		if (cb_time->type == vpiScaledRealTime) {
 			callback_time = (int) (cb_time->real);
 		} else if (cb_time->type == vpiSimTime) {
 			callback_time = (int) (cb_time->low);
 		}
 	} else {
 		callback_time = 0;
 	}

 	if (info != NULL) {
 		if (info->attemptStartTime.type == vpiScaledRealTime) {
 			start_time = (int) (info->attemptStartTime.real);
 		} else if (info->attemptStartTime.type == vpiSimTime) {
 			start_time = (int) (info->attemptStartTime.low);
 		}

 	} else {
 		start_time = callback_time;
 	}

 //	printf(
 //			"Detected assertion callback -> name: %s, reason: %s, time: %d, start_time : %d\n",
 //			assertion_path.c_str(), casted_reason.c_str(), callback_time,
 //			start_time);

 	cb_assertion_info crt_callback_info(assertion_name, assertion_path,
 			assertion_type, reason, callback_time, start_time);

 	lof_cbs.push_back(crt_callback_info);

 	return reason;
 }

 /* DPI-C API to retrieve information about all callbacks
  * crt_test_name : the test name from which this function is called
  */
 void call_callback_dpi(char * crt_test_name) {
 //set the scope as this function is a callback and in SV there is no scope set
 	svSetScope(testSvScope);

 	while (lof_cbs.size() > 0) {
 		pass_info_to_sv_dpi(crt_test_name,
 				get_char_from_string(lof_cbs[0].assertion_name),
 				get_char_from_string(lof_cbs[0].assertion_path),
 				get_char_from_string(lof_cbs[0].assertion_type),
 				lof_cbs[0].reason, lof_cbs[0].start_time, lof_cbs[0].cb_time);

 		lof_cbs.erase(lof_cbs.begin());
 	}
 }

 /* Place callbacks on a given SVA
  * assertion : handle to assertion
  */
 void put_callbacks_on_assertion(vpiHandle assertion, int print_flag) {
 	string assertion_name = vpi_get_str(vpiName, assertion);
 	bool running_cadence = 0;

 // Verify if the current simulator is from Cadence
 #ifdef IRUN
 	running_cadence = 1;
 #else
 	running_cadence = 0;
 #endif

 	if (print_flag == 1)
 		printf("Set callback on assertion: %s \n", assertion_name.c_str());

 	PLI_BYTE8 *user_data = (PLI_BYTE8 *) 0;

 	if (((vpi_get(vpiType, assertion) != vpiPropertyDecl)
 			&& (running_cadence == 1)) || (running_cadence == 0)) {
 		// For Cadence there could not be a callback on vpiPropertyDecl
 		vpi_register_assertion_cb(assertion, cbAssertionStart,
 				assertion_callback, user_data);

 		if (print_flag == 1)
 			printf("Set callback on assertion for start: %s \n",
 					assertion_name.c_str());
 	}

 	if (((vpi_get(vpiType, assertion) != vpiPropertyDecl)
 			&& (running_cadence == 1)) || (running_cadence == 0)) {
 		vpi_register_assertion_cb(assertion, cbAssertionFailure,
 				assertion_callback, user_data);
 		vpi_register_assertion_cb(assertion, cbAssertionSuccess,
 				assertion_callback, user_data);
 		vpi_register_assertion_cb(assertion, cbAssertionDisable,
 				assertion_callback, user_data);
 		vpi_register_assertion_cb(assertion, cbAssertionEnable,
 				assertion_callback, user_data);
 		vpi_register_assertion_cb(assertion, cbAssertionReset,
 				assertion_callback, user_data);
 		vpi_register_assertion_cb(assertion, cbAssertionKill,
 				assertion_callback, user_data);

 //		if (running_cadence == 0) {
 //			// For Cadence cbAssertionStepSuccess and cbAssertionStepFailure are not supported
 //			vpi_register_assertion_cb(assertion, cbAssertionStepSuccess,
 //					assertion_callback, user_data);
 //			vpi_register_assertion_cb(assertion, cbAssertionStepFailure,
 //					assertion_callback, user_data);
 //		}
 	}
 }

 void get_interfaces(std::vector<vpiHandle> &lof_interface_handles,
 		vpiHandle interface_top) {

 	//get an iterator over all assertions
 	vpiHandle itr_module, itr_interface, itr_internal_scope,
 			itr_internal_scope1;

 	//handle for current assertion
 	vpiHandle module, interface, internal_scope, internal_scope1;

 	// If interface_top is an interface push into interface list
 	if ((interface_top != NULL)) {
 		if (vpi_get(vpiType, interface_top) == vpiInterface) {
 			lof_interface_handles.push_back(interface_top);
 		}
 	}

 	// Interrogate over the interface_top - it could contain:
 	// 1. interface
 	if ((itr_interface = vpi_iterate(vpiInterface, interface_top)) != NULL) {
 		while ((interface = vpi_scan(itr_interface)) != NULL) {
 			get_interfaces(lof_interface_handles, interface);
 		}
 	}

 	if (interface_top == NULL) {
 		// 2. module
 		if ((itr_module = vpi_iterate(vpiModule, interface_top)) != NULL) {
 			while ((module = vpi_scan(itr_module)) != NULL) {
 				get_interfaces(lof_interface_handles, module);
 			}
 		}
 	}

 	if (interface_top != NULL) {
 		// 3. scope
 		if ((itr_internal_scope = vpi_iterate(vpiInternalScope, interface_top))
 				!= NULL) {
 			while ((internal_scope = vpi_scan(itr_internal_scope)) != NULL) {
 				if (vpi_get(vpiType, internal_scope) == vpiGenScope) {

 					lof_interface_handles.push_back(internal_scope);
 					get_interfaces(lof_interface_handles, internal_scope);

 					if ((itr_internal_scope1 = vpi_iterate(vpiInternalScope,
 							internal_scope)) != NULL) {
 						while ((internal_scope1 = vpi_scan(itr_internal_scope1))
 								!= NULL) {
 							get_interfaces(lof_interface_handles,
 									internal_scope1);
 						}
 					}
 				}
 			}
 		}

 		if (vpi_get(vpiType, interface_top) != vpiInterface) {
 			// 2. module
 			if ((itr_module = vpi_iterate(vpiModule, interface_top)) != NULL) {
 				while ((module = vpi_scan(itr_module)) != NULL) {
 					get_interfaces(lof_interface_handles, module);
 				}
 			}
 		}
 	}
 }

 // DPI-C API used to find SVAs using VPI API
 void register_assertions_dpi(int print_flag) {
 	testSvScope = svGetScope();

 	svSetScope(testSvScope);

 	register_sots_callback();

 	if (print_flag)
 		printf("Register assertions!\n");

 	// list of units where the interface can be instantiated
 	std::vector < vpiHandle > lof_assertions_units;

 	//get an iterator over all assertions
 	vpiHandle itr_sva, itr_param;

 	//handle for current assertion
 	vpiHandle top_module = NULL, sva, param;

 	//stores the sva name, path and type as a string
 	string assertion_name, assertion_path, assertion_type;

 	// Test runners
 	get_interfaces(lof_assertions_units, top_module);

 	for (int unsigned index = 0; index < lof_assertions_units.size(); index++) {
 		if ((itr_param = vpi_iterate(vpiParameter, lof_assertions_units[index]))
 				!= NULL) {
 			while ((param = vpi_scan(itr_param)) != NULL) {
 				struct t_vpi_value argval;
 				int value;

 				argval.format = vpiIntVal;
 				vpi_get_value(param, &argval);
 				value = argval.value.integer;
 				if (print_flag)
 					printf("VPI routine received %d\n", value);
 			}
 		}

 		if (svGetNameFromScope(testSvScope)
 				!= vpi_get_str(vpiFullName, lof_assertions_units[index])) {

 			if ((itr_sva = vpi_iterate(vpiAssertion,
 					lof_assertions_units[index])) != NULL) {
 				while ((sva = vpi_scan(itr_sva)) != NULL) {
 					bool exists = 0;

 					for (int unsigned sva_index = 0;
 							sva_index < lof_assertions.size(); sva_index++) {
 						string sva_name = vpi_get_str(vpiFullName, sva);
 						string crt_sva = vpi_get_str(vpiFullName,
 								lof_assertions[sva_index]);

 						if (sva_name.compare(crt_sva) == 0) {
 							exists = 1;
 						}
 					}

 					if (exists == 0) {
 						lof_assertions.push_back(sva);

 						assertion_path = vpi_get_str(vpiFullName, sva);
 						assertion_name = vpi_get_str(vpiName, sva);
 						assertion_type = vpi_get_str(vpiType, sva);

 						if (print_flag)
 							printf("Registering assertion: %s with type: %s\n",
 									assertion_path.c_str(),
 									assertion_type.c_str());

 						//send information to SV
 						create_assertion_dpi(
 								get_char_from_string(assertion_name),
 								get_char_from_string(assertion_path),
 								get_char_from_string(assertion_type));

 						put_callbacks_on_assertion(sva, print_flag);
 					}
 				}
 			}
 		}
 	}
 }

 /* DPI-C API used to get SVA cover statistics - how many times this cover was triggered and how many times it failed
  * cover_name : cover name to retrieve information about
  * nof_attempts_failed_covered : number of attempts this cover was triggered and it failed
  * nof_attempts_succeeded_covered : number of attempts this cover was triggered and it succeeded
  */
 void get_cover_statistics_dpi(char * cover_name,
 		int * nof_attempts_failed_covered,
 		int * nof_attempts_succeeded_covered) {

 	for (unsigned int i = 0; i < lof_assertions.size(); i++) {

 		string assertion_name = vpi_get_str(vpiName, lof_assertions[i]);

 		if (assertion_name.compare(cover_name) == 0) {
 			if (vpi_get(vpiType, lof_assertions[i]) == vpiCover) {

 				*nof_attempts_failed_covered = vpi_get(vpiAssertFailureCovered,
 						lof_assertions[i]);
 				*nof_attempts_succeeded_covered = vpi_get(
 						vpiAssertSuccessCovered, lof_assertions[i]);
 			}
 		}
 	}
 }

 // "End of time slot" flag (1 - reached; 0 - not reached);
 int eots_flag = 0;

 // Returns the status of the "End of time slot" flag (1 - reached; 0 - not reached);
 int dpi_check_flag() {
 	return eots_flag;
 }

 // Executed on "Start of time slot" callback from simulator
 PLI_INT32 sots_callback(p_cb_data cb_data) {
 	s_vpi_time crt_time;
 	crt_time.type = vpiSimTime;
 	vpi_get_time(NULL, &crt_time);

 	//printf("Detected cbNextSimTime -> crt_time: %d\n", crt_time.low);

 	register_eots_callback();
 }

 // Executed on "End of time slot" callback from simulator
 PLI_INT32 eots_callback(p_cb_data cb_data) {
 	s_vpi_time crt_time;
 	crt_time.type = vpiSimTime;
 	vpi_get_time(0, &crt_time);

 	//printf("Detected cbReadOnlySynch -> crt_time: %d\n", crt_time.low);

 	register_sots_callback();

 	eots_flag = 1;
 }

 // Register a callback on "Start of time slot"
 PLI_INT32 register_sots_callback() {
 	s_cb_data cb_data_s;
 	s_vpi_time time_s;

 	time_s.type = vpiSimTime;
 	time_s.high = 0;
 	time_s.low = 0;

 	cb_data_s.reason = cbNextSimTime;
 	cb_data_s.user_data = NULL;
 	cb_data_s.cb_rtn = sots_callback;
 	cb_data_s.obj = NULL;
 	cb_data_s.time = &time_s;
 	cb_data_s.value = NULL;
 	vpi_register_cb(&cb_data_s);
 }

 // Register a callback on "End of time slot"
 PLI_INT32 register_eots_callback() {
 	s_cb_data cb_data_s;
 	s_vpi_time time_s;

 	time_s.type = vpiSimTime;
 	time_s.high = 0;
 	time_s.low = 0;

 	cb_data_s.reason = cbReadOnlySynch;
 	cb_data_s.user_data = NULL;
 	cb_data_s.cb_rtn = eots_callback;
 	cb_data_s.obj = NULL;
 	cb_data_s.time = &time_s;
 	cb_data_s.value = NULL;
 	vpi_register_cb(&cb_data_s);
 }

 }

 #endif
	/******************************************************************************
	* (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.
	*
	* MODULE: svaunit_vpi_api.cpp
	* PROJECT: svaunit
	* Description: VPI APIs and DPI-C API - retrieve informations about SVA using VPI
	* and transfer the information to/from SystemVerilog
	*******************************************************************************/

	#ifndef __SVAUNIT_VPI_API_CPP
	#define __SVAUNIT_VPI_API_CPP

	#include <string.h>
	#include <stdlib.h>
	#include <assert.h>
	#include <iostream>
	#include <stdio.h>
	#include <vector>

	#include "svdpi.h"
	#include "sv_vpi_user.h"
	#include "vpi_user.h"

	using namespace std;

	// Class used to store callback info
	class cb_assertion_info {
	public:
	// SVA name
	string assertion_name;

	// SVA path
	string assertion_path;

	// SVA type
	string assertion_type;

	// The reason why this callback was triggered
	int reason;

	// The start time of the SVA attempt
	int start_time;

	// Callback time
	int cb_time;
	public:
	/* Constructor for callback info
	* name : SVA name
	* type : SVA type
	* path : SVA path
	* cb_reason : current reason why this callback was triggered
	* cb_start_time : current start time of the SVA attempt
	* a_cb_time : callback time
	*/
	cb_assertion_info(string name, string path, string type, int cb_reason,
	int cb_start_time, int a_cb_time) {

	assertion_name = name;
	assertion_path = path;
	assertion_type = type;
	reason = cb_reason;
	start_time = cb_start_time;
	cb_time = a_cb_time;
	}

	// Destructor for callback info class
	~cb_assertion_info() {
	}
	};

	extern "C" {
	// Function prototypes so you can have circular calls (sots calls eots etc.)
	PLI_INT32 sots_callback(p_cb_data cb_data);
	PLI_INT32 eots_callback(p_cb_data cb_data);
	PLI_INT32 register_eots_callback();
	PLI_INT32 register_sots_callback();

	/* VPI API to update a given SVA
	* crt_test_name : test name from where this function is called
	* assertion_name : SVA name to be updated
	* assertion_path : path to the SVA
	* assertion_type : the type of the SVA to be updated
	* reason : callback reason
	* start_time : the start attempt for this SVA
	* callback_time : the callback time for this SVA attempt
	*/
	extern void pass_info_to_sv_dpi(char , char, char , char , int, int, int);

	/* Create SVA with a name and a type given
	* assertion_name : SVA name to be created
	* assertion_type : SVA type to be created
	* assertion_path : path to the SVA
	*/
	extern void create_assertion_dpi(char , char , char *);

	//the SV scope saved at assertion registration. this is required in order to
	//set a scope once the assertion callbacks are ready to update information in SV
	svScope testSvScope;

	// List of SVAs which where found using VPI API
	std::vector<vpiHandle> lof_assertions;

	// List of callbacks for SVAs - this list will store the callbacks until a DPI-C call came
	std::vector<cb_assertion_info> lof_cbs;

	// Test name
	char * test_name;

	/* Set the current test_name
	* crt_test_name : current test name to be updated
	*/
	void set_test_name_to_vpi_dpi(char * crt_test_name) {
	test_name = crt_test_name;
	}

	/* Convert a string from a given char*
	* a_string : the string to be converted
	* return the converted char*
	*/
	char * get_char_from_string(string a_string) {
	char *a_string_c = new char [1];

	a_string_c[0] = new char[a_string.length() + 1];

	strcpy(a_string_c[0], a_string.c_str());

	return a_string_c[0];
	}

	/* Control assertion using vpi_control function
	* assertion_name : the assertion used to apply control action on
	* control_type : the control action
	* sys_time : attempt time
	*/
	void control_assertion_dpi(char * assertion_name, int control_type,
	int sys_time) {

	string assertion_type;
	s_vpi_time *a_struct;
	int step_constant;
	bool running_cadence = 0;

	#ifndef IRUN
	running_cadence = 0;
	#else
	running_cadence = 1;
	#endif

	if (((running_cadence == 0)
	&& ((control_type == vpiAssertionEnableStep)
	\|\| (control_type == vpiAssertionDisableStep)))
	\|\| (control_type == vpiAssertionKill)) {
	a_struct->type = vpiSimTime;
	a_struct->high = 0;
	a_struct->low = 0;
	a_struct->real = 0;
	}

	if ((running_cadence == 0)
	&& ((control_type == vpiAssertionEnableStep)
	\|\| (control_type == vpiAssertionDisableStep))) {
	step_constant = vpiAssertionClockSteps;
	}

	if ((control_type == vpiAssertionReset)
	\|\| (control_type == vpiAssertionDisable)
	\|\| (control_type == vpiAssertionEnable)
	\|\| (control_type == vpiAssertionKill)
	\|\| ((running_cadence == 0)
	&& ((control_type == vpiAssertionEnableStep)
	\|\| (control_type == vpiAssertionDisableStep)))) {
	if (lof_assertions.size() > 0) {
	for (unsigned int sva_index = 0; sva_index < lof_assertions.size();
	sva_index++) {

	vpiHandle assertion = lof_assertions[sva_index];
	string an_assertion_name = vpi_get_str(vpiFullName, assertion);

	if ((an_assertion_name.compare(assertion_name) == 0)
	&& ((vpi_get(vpiType, assertion) != vpiPropertyDecl)
	\|\| (vpi_get(vpiType, assertion)
	!= vpiPropertyInst))) {
	vpi_control(control_type, assertion, &a_struct,
	step_constant);
	}
	}
	}
	} else if ((control_type == vpiAssertionSysReset)
	\|\| (control_type == vpiAssertionSysOn)
	\|\| (control_type == vpiAssertionSysOff)
	\|\| (control_type == vpiAssertionSysEnd)) {
	vpi_control(control_type);
	}
	}

	/* Assertion callback function
	* reason : callback reason
	* cb_time : callback time
	* assertion : handle to assertion
	* info : attempt related information
	* user_data : user data entered upon registration
	* return the callback reason
	*/
	PLI_INT32 assertion_callback(PLI_INT32 reason, p_vpi_time cb_time,
	vpiHandle assertion, p_vpi_attempt_info info, PLI_BYTE8 *user_data) {

	string casted_reason = "UNKNOWN";
	int callback_time;
	int start_time;
	string assertion_name = vpi_get_str(vpiName, assertion);
	string assertion_path = vpi_get_str(vpiFullName, assertion);
	string assertion_type = vpi_get_str(vpiType, assertion);

	if (reason == cbAssertionStart) {
	casted_reason = "START";
	} else if (reason == cbAssertionSuccess) {
	casted_reason = "SUCCESS";
	} else if (reason == cbAssertionFailure) {
	casted_reason = "FAILURE";
	} else if (reason == cbAssertionDisable) {
	casted_reason = "DISABLE";
	} else if (reason == cbAssertionEnable) {
	casted_reason = "ENABLE";
	} else if (reason == cbAssertionReset) {
	casted_reason = "RESET";
	} else if (reason == cbAssertionKill) {
	casted_reason = "KILL";
	} else {
	casted_reason = "IDLE";

	// For Cadence cbAssertionStepSuccess and cbAssertionStepFailure are not supported
	#ifndef IRUN
	if (reason == cbAssertionStepSuccess) {
	casted_reason = "STEP_SUCCESS";
	} else if (reason == cbAssertionStepFailure) {
	casted_reason = "STEP_FAILURE";
	}
	#endif
	}

	if (cb_time != NULL) {
	if (cb_time->type == vpiScaledRealTime) {
	callback_time = (int) (cb_time->real);
	} else if (cb_time->type == vpiSimTime) {
	callback_time = (int) (cb_time->low);
	}
	} else {
	callback_time = 0;
	}

	if (info != NULL) {
	if (info->attemptStartTime.type == vpiScaledRealTime) {
	start_time = (int) (info->attemptStartTime.real);
	} else if (info->attemptStartTime.type == vpiSimTime) {
	start_time = (int) (info->attemptStartTime.low);
	}

	} else {
	start_time = callback_time;
	}

	// printf(
	// "Detected assertion callback -> name: %s, reason: %s, time: %d, start_time : %d\n",
	// assertion_path.c_str(), casted_reason.c_str(), callback_time,
	// start_time);

	cb_assertion_info crt_callback_info(assertion_name, assertion_path,
	assertion_type, reason, callback_time, start_time);

	lof_cbs.push_back(crt_callback_info);

	return reason;
	}

	/* DPI-C API to retrieve information about all callbacks
	* crt_test_name : the test name from which this function is called
	*/
	void call_callback_dpi(char * crt_test_name) {
	//set the scope as this function is a callback and in SV there is no scope set
	svSetScope(testSvScope);

	while (lof_cbs.size() > 0) {
	pass_info_to_sv_dpi(crt_test_name,
	get_char_from_string(lof_cbs[0].assertion_name),
	get_char_from_string(lof_cbs[0].assertion_path),
	get_char_from_string(lof_cbs[0].assertion_type),
	lof_cbs[0].reason, lof_cbs[0].start_time, lof_cbs[0].cb_time);

	lof_cbs.erase(lof_cbs.begin());
	}
	}

	/* Place callbacks on a given SVA
	* assertion : handle to assertion
	*/
	void put_callbacks_on_assertion(vpiHandle assertion, int print_flag) {
	string assertion_name = vpi_get_str(vpiName, assertion);
	bool running_cadence = 0;

	// Verify if the current simulator is from Cadence
	#ifdef IRUN
	running_cadence = 1;
	#else
	running_cadence = 0;
	#endif

	if (print_flag == 1)
	printf("Set callback on assertion: %s \n", assertion_name.c_str());

	PLI_BYTE8 user_data = (PLI_BYTE8 ) 0;

	if (((vpi_get(vpiType, assertion) != vpiPropertyDecl)
	&& (running_cadence == 1)) \|\| (running_cadence == 0)) {
	// For Cadence there could not be a callback on vpiPropertyDecl
	vpi_register_assertion_cb(assertion, cbAssertionStart,
	assertion_callback, user_data);

	if (print_flag == 1)
	printf("Set callback on assertion for start: %s \n",
	assertion_name.c_str());
	}

	if (((vpi_get(vpiType, assertion) != vpiPropertyDecl)
	&& (running_cadence == 1)) \|\| (running_cadence == 0)) {
	vpi_register_assertion_cb(assertion, cbAssertionFailure,
	assertion_callback, user_data);
	vpi_register_assertion_cb(assertion, cbAssertionSuccess,
	assertion_callback, user_data);
	vpi_register_assertion_cb(assertion, cbAssertionDisable,
	assertion_callback, user_data);
	vpi_register_assertion_cb(assertion, cbAssertionEnable,
	assertion_callback, user_data);
	vpi_register_assertion_cb(assertion, cbAssertionReset,
	assertion_callback, user_data);
	vpi_register_assertion_cb(assertion, cbAssertionKill,
	assertion_callback, user_data);

	// if (running_cadence == 0) {
	// // For Cadence cbAssertionStepSuccess and cbAssertionStepFailure are not supported
	// vpi_register_assertion_cb(assertion, cbAssertionStepSuccess,
	// assertion_callback, user_data);
	// vpi_register_assertion_cb(assertion, cbAssertionStepFailure,
	// assertion_callback, user_data);
	// }
	}
	}

	void get_interfaces(std::vector<vpiHandle> &lof_interface_handles,
	vpiHandle interface_top) {

	//get an iterator over all assertions
	vpiHandle itr_module, itr_interface, itr_internal_scope,
	itr_internal_scope1;

	//handle for current assertion
	vpiHandle module, interface, internal_scope, internal_scope1;

	// If interface_top is an interface push into interface list
	if ((interface_top != NULL)) {
	if (vpi_get(vpiType, interface_top) == vpiInterface) {
	lof_interface_handles.push_back(interface_top);
	}
	}

	// Interrogate over the interface_top - it could contain:
	// 1. interface
	if ((itr_interface = vpi_iterate(vpiInterface, interface_top)) != NULL) {
	while ((interface = vpi_scan(itr_interface)) != NULL) {
	get_interfaces(lof_interface_handles, interface);
	}
	}

	if (interface_top == NULL) {
	// 2. module
	if ((itr_module = vpi_iterate(vpiModule, interface_top)) != NULL) {
	while ((module = vpi_scan(itr_module)) != NULL) {
	get_interfaces(lof_interface_handles, module);
	}
	}
	}

	if (interface_top != NULL) {
	// 3. scope
	if ((itr_internal_scope = vpi_iterate(vpiInternalScope, interface_top))
	!= NULL) {
	while ((internal_scope = vpi_scan(itr_internal_scope)) != NULL) {
	if (vpi_get(vpiType, internal_scope) == vpiGenScope) {

	lof_interface_handles.push_back(internal_scope);
	get_interfaces(lof_interface_handles, internal_scope);

	if ((itr_internal_scope1 = vpi_iterate(vpiInternalScope,
	internal_scope)) != NULL) {
	while ((internal_scope1 = vpi_scan(itr_internal_scope1))
	!= NULL) {
	get_interfaces(lof_interface_handles,
	internal_scope1);
	}
	}
	}
	}
	}

	if (vpi_get(vpiType, interface_top) != vpiInterface) {
	// 2. module
	if ((itr_module = vpi_iterate(vpiModule, interface_top)) != NULL) {
	while ((module = vpi_scan(itr_module)) != NULL) {
	get_interfaces(lof_interface_handles, module);
	}
	}
	}
	}
	}

	// DPI-C API used to find SVAs using VPI API
	void register_assertions_dpi(int print_flag) {
	testSvScope = svGetScope();

	svSetScope(testSvScope);

	register_sots_callback();

	if (print_flag)
	printf("Register assertions!\n");

	// list of units where the interface can be instantiated
	std::vector < vpiHandle > lof_assertions_units;

	//get an iterator over all assertions
	vpiHandle itr_sva, itr_param;

	//handle for current assertion
	vpiHandle top_module = NULL, sva, param;

	//stores the sva name, path and type as a string
	string assertion_name, assertion_path, assertion_type;

	// Test runners
	get_interfaces(lof_assertions_units, top_module);

	for (int unsigned index = 0; index < lof_assertions_units.size(); index++) {
	if ((itr_param = vpi_iterate(vpiParameter, lof_assertions_units[index]))
	!= NULL) {
	while ((param = vpi_scan(itr_param)) != NULL) {
	struct t_vpi_value argval;
	int value;

	argval.format = vpiIntVal;
	vpi_get_value(param, &argval);
	value = argval.value.integer;
	if (print_flag)
	printf("VPI routine received %d\n", value);
	}
	}

	if (svGetNameFromScope(testSvScope)
	!= vpi_get_str(vpiFullName, lof_assertions_units[index])) {

	if ((itr_sva = vpi_iterate(vpiAssertion,
	lof_assertions_units[index])) != NULL) {
	while ((sva = vpi_scan(itr_sva)) != NULL) {
	bool exists = 0;

	for (int unsigned sva_index = 0;
	sva_index < lof_assertions.size(); sva_index++) {
	string sva_name = vpi_get_str(vpiFullName, sva);
	string crt_sva = vpi_get_str(vpiFullName,
	lof_assertions[sva_index]);

	if (sva_name.compare(crt_sva) == 0) {
	exists = 1;
	}
	}

	if (exists == 0) {
	lof_assertions.push_back(sva);

	assertion_path = vpi_get_str(vpiFullName, sva);
	assertion_name = vpi_get_str(vpiName, sva);
	assertion_type = vpi_get_str(vpiType, sva);

	if (print_flag)
	printf("Registering assertion: %s with type: %s\n",
	assertion_path.c_str(),
	assertion_type.c_str());

	//send information to SV
	create_assertion_dpi(
	get_char_from_string(assertion_name),
	get_char_from_string(assertion_path),
	get_char_from_string(assertion_type));

	put_callbacks_on_assertion(sva, print_flag);
	}
	}
	}
	}
	}
	}

	/* DPI-C API used to get SVA cover statistics - how many times this cover was triggered and how many times it failed
	* cover_name : cover name to retrieve information about
	* nof_attempts_failed_covered : number of attempts this cover was triggered and it failed
	* nof_attempts_succeeded_covered : number of attempts this cover was triggered and it succeeded
	*/
	void get_cover_statistics_dpi(char * cover_name,
	int * nof_attempts_failed_covered,
	int * nof_attempts_succeeded_covered) {

	for (unsigned int i = 0; i < lof_assertions.size(); i++) {

	string assertion_name = vpi_get_str(vpiName, lof_assertions[i]);

	if (assertion_name.compare(cover_name) == 0) {
	if (vpi_get(vpiType, lof_assertions[i]) == vpiCover) {

	*nof_attempts_failed_covered = vpi_get(vpiAssertFailureCovered,
	lof_assertions[i]);
	*nof_attempts_succeeded_covered = vpi_get(
	vpiAssertSuccessCovered, lof_assertions[i]);
	}
	}
	}
	}

	// "End of time slot" flag (1 - reached; 0 - not reached);
	int eots_flag = 0;

	// Returns the status of the "End of time slot" flag (1 - reached; 0 - not reached);
	int dpi_check_flag() {
	return eots_flag;
	}

	// Executed on "Start of time slot" callback from simulator
	PLI_INT32 sots_callback(p_cb_data cb_data) {
	s_vpi_time crt_time;
	crt_time.type = vpiSimTime;
	vpi_get_time(NULL, &crt_time);

	//printf("Detected cbNextSimTime -> crt_time: %d\n", crt_time.low);

	register_eots_callback();
	}

	// Executed on "End of time slot" callback from simulator
	PLI_INT32 eots_callback(p_cb_data cb_data) {
	s_vpi_time crt_time;
	crt_time.type = vpiSimTime;
	vpi_get_time(0, &crt_time);

	//printf("Detected cbReadOnlySynch -> crt_time: %d\n", crt_time.low);

	register_sots_callback();

	eots_flag = 1;
	}

	// Register a callback on "Start of time slot"
	PLI_INT32 register_sots_callback() {
	s_cb_data cb_data_s;
	s_vpi_time time_s;

	time_s.type = vpiSimTime;
	time_s.high = 0;
	time_s.low = 0;

	cb_data_s.reason = cbNextSimTime;
	cb_data_s.user_data = NULL;
	cb_data_s.cb_rtn = sots_callback;
	cb_data_s.obj = NULL;
	cb_data_s.time = &time_s;
	cb_data_s.value = NULL;
	vpi_register_cb(&cb_data_s);
	}

	// Register a callback on "End of time slot"
	PLI_INT32 register_eots_callback() {
	s_cb_data cb_data_s;
	s_vpi_time time_s;

	time_s.type = vpiSimTime;
	time_s.high = 0;
	time_s.low = 0;

	cb_data_s.reason = cbReadOnlySynch;
	cb_data_s.user_data = NULL;
	cb_data_s.cb_rtn = eots_callback;
	cb_data_s.obj = NULL;
	cb_data_s.time = &time_s;
	cb_data_s.value = NULL;
	vpi_register_cb(&cb_data_s);
	}

	}

	#endif