void do_and( void * param )
{
inst_rec * ip = (inst_rec *)param;
mtiInt32T val1, val2;
mtiInt32T result;
val1 = mti_GetSignalValue( ip->in1 );
val2 = mti_GetSignalValue( ip->in2 );
result = val1 & val2;
mti_ScheduleDriver( ip->out1, result, 0, MTI_INERTIAL );
}
const char* FliLogicObjHdl::get_signal_value_binstr(void)
{
switch (m_fli_type) {
case MTI_TYPE_ENUM:
if (m_is_var) {
m_val_buff[0] = m_value_enum[mti_GetVarValue(get_handle<mtiVariableIdT>())][1];
} else {
m_val_buff[0] = m_value_enum[mti_GetSignalValue(get_handle<mtiSignalIdT>())][1];
}
break;
case MTI_TYPE_ARRAY: {
if (m_is_var) {
mti_GetArrayVarValue(get_handle<mtiVariableIdT>(), m_mti_buff);
} else {
mti_GetArraySignalValue(get_handle<mtiSignalIdT>(), m_mti_buff);
}
for (int i = 0; i < m_num_elems; i++ ) {
m_val_buff[i] = m_value_enum[(int)m_mti_buff[i]][1];
}
}
break;
default:
LOG_CRITICAL("Object type is not 'logic' for %s (%d)", m_name.c_str(), m_fli_type);
return NULL;
}
LOG_DEBUG("Retrieved \"%s\" for value object %s", m_val_buff, m_name.c_str());
return m_val_buff;
}
/**
* convert_logic_vector_to_int() - Convert a multibit signal into the
* corresponding numerical value
*
* @vec: std_logic_vector signal to convert
*
* Return: 32-bit integer equivalent to the input signal
*/
int convert_logic_vector_to_int(mtiSignalIdT vec)
{
mtiSignalIdT *elems_list;
mtiTypeIdT sig_type;
mtiInt32T num_elems;
int data;
int i;
/* Get an handle to the type of the given signal */
sig_type = mti_GetSignalType(vec);
/* Get the number of elements that compose the vector */
num_elems = mti_TickLength(sig_type);
assert(num_elems <= 25);
/* Extract the list of individual elements */
elems_list = mti_GetSignalSubelements(vec, 0);
data = 0;
for (i = 0; i < num_elems; ++i) {
/* If a 1 is received, increment the corresponding bit of the
result */
if (mti_GetSignalValue(elems_list[i]) == STD_LOGIC_1) {
data += 1 << (num_elems - i - 1);
}
}
mti_VsimFree(elems_list);
return data;
}
long FliEnumObjHdl::get_signal_value_long(void)
{
if (m_is_var) {
return (long)mti_GetVarValue(get_handle<mtiVariableIdT>());
} else {
return (long)mti_GetSignalValue(get_handle<mtiSignalIdT>());
}
}
const char* FliEnumObjHdl::get_signal_value_str(void)
{
if (m_is_var) {
return m_value_enum[mti_GetVarValue(get_handle<mtiVariableIdT>())];
} else {
return m_value_enum[mti_GetSignalValue(get_handle<mtiSignalIdT>())];
}
}
long FliIntObjHdl::get_signal_value_long(void)
{
mtiInt32T value;
if (m_is_var) {
value = mti_GetVarValue(get_handle<mtiVariableIdT>());
} else {
value = mti_GetSignalValue(get_handle<mtiSignalIdT>());
}
return (long)value;
}
const char* FliSignalObjHdl::get_signal_value_binstr(void)
{
switch (m_fli_type) {
case MTI_TYPE_ENUM:
m_val_buff[0] = value_enum[mti_GetSignalValue(m_fli_hdl)];
break;
case MTI_TYPE_SCALAR:
case MTI_TYPE_PHYSICAL: {
std::bitset<32> value((unsigned long)mti_GetSignalValue(m_fli_hdl));
std::string bin_str = value.to_string<char,std::string::traits_type, std::string::allocator_type>();
snprintf(m_val_buff, m_val_len+1, "%s", bin_str.c_str());
}
break;
case MTI_TYPE_ARRAY: {
mti_GetArraySignalValue(m_fli_hdl, m_mti_buff);
if (m_val_len <= 256) {
char *iter = (char*)m_mti_buff;
for (int i = 0; i < m_val_len; i++ ) {
m_val_buff[i] = value_enum[(int)iter[i]];
}
} else {
for (int i = 0; i < m_val_len; i++ ) {
m_val_buff[i] = value_enum[m_mti_buff[i]];
}
}
}
break;
default:
LOG_CRITICAL("Signal %s type %d not currently supported",
m_name.c_str(), m_fli_type);
break;
}
LOG_DEBUG("Retrieved \"%s\" for signal %s", m_val_buff, m_name.c_str());
return m_val_buff;
}
const char* FliIntObjHdl::get_signal_value_binstr(void)
{
mtiInt32T val;
if (m_is_var) {
val = mti_GetVarValue(get_handle<mtiVariableIdT>());
} else {
val = mti_GetSignalValue(get_handle<mtiSignalIdT>());
}
std::bitset<32> value((unsigned long)val);
std::string bin_str = value.to_string<char,std::string::traits_type, std::string::allocator_type>();
snprintf(m_val_buff, 33, "%s", bin_str.c_str());
return m_val_buff;
}
/*
* This procedure is called by the simulator as a result of an
* mti_ScheduleWakeup() call. Its purpose is to process all drive/test
* data specified for the current timestep. It schedules drivers for
* drive points by calling mti_ScheduleDriver(). For test points, it
* reads the port values by calling either mti_GetSignalValue() or
* mti_GetArraySignalValue(). It then compares the current values with the
* expected values and prints an error message if they don't match.
*/
static void test_value_proc( void * param )
{
inst_rec_ptr ip = (inst_rec_ptr)param;
char actual_val[MAX_PORT_WIDTH];
char buf[100];
char expected_val[MAX_PORT_WIDTH];
char *sig_array_val;
int portnum, i, width, is_array;
long now;
long sigval;
testpoint *cur_testpoint;
now = mti_Now();
for ( cur_testpoint=testpoints; cur_testpoint;
cur_testpoint=cur_testpoint->nxt) {
portnum = cur_testpoint->portnum;
width = tester_ports[portnum].width;
is_array = tester_ports[portnum].is_array_type;
if ( cur_testpoint->type == DRIVE ) {
if ( ! is_array ) {
if ( ip->verbose ) {
sprintf(buf,"TIME %ld: drive signal %s with value %c\n",
now, tester_ports[portnum].name,
convert_enum_to_mvl9_char(*cur_testpoint->test_val));
mti_PrintMessage(buf);
}
mti_ScheduleDriver( ip->drivers[portnum],
(mtiLongT) *cur_testpoint->test_val,
0, MTI_INERTIAL );
} else {
char tmpstring[MAX_PORT_WIDTH];
convert_enums_to_mvl9_string( cur_testpoint->test_val,
tmpstring, width );
if ( ip->verbose ) {
sprintf(buf,"TIME %ld: drive signal array %s with value %s\n",
now, tester_ports[portnum].name, tmpstring);
mti_PrintMessage(buf);
}
mti_ScheduleDriver( ip->drivers[portnum],
(mtiLongT)(cur_testpoint->test_val),
0, MTI_INERTIAL );
}
} else {
if ( ! is_array ) {
char exp, act;
sigval = mti_GetSignalValue(ip->ports[portnum]);
exp = convert_enum_to_mvl9_char(*cur_testpoint->test_val);
act = convert_enum_to_mvl9_char(sigval);
if ( ip->verbose ) {
sprintf(buf,"TIME %ld: test signal %s for value %c\n",
now, tester_ports[portnum].name, exp);
mti_PrintMessage(buf);
}
if ( sigval != (long) *cur_testpoint->test_val ) {
sprintf( buf,
"Miscompare at time %ld, signal %s. "
"Expected \'%c\', Actual \'%c\'\n",
now, tester_ports[portnum].name, exp, act);
mti_PrintMessage(buf);
}
} else {
sig_array_val = mti_GetArraySignalValue(ip->ports[portnum],
NULL);
convert_enums_to_mvl9_string(cur_testpoint->test_val,
expected_val, width);
convert_enums_to_mvl9_string(sig_array_val, actual_val, width);
if ( ip->verbose ) {
sprintf(buf,"TIME %ld: test signal %s for value %s\n",
now, tester_ports[portnum].name, expected_val);
mti_PrintMessage(buf);
}
for ( i = 0; i < width; i++ ) {
if ( sig_array_val[i] != cur_testpoint->test_val[i] ) {
sprintf( buf,
"Miscompare at time %ld, signal %s. "
"Expected \"%s\", Actual \"%s\"\n",
now, tester_ports[portnum].name,
expected_val, actual_val);
mti_PrintMessage( buf );
break;
}
}
}
}
}
delete_testpoints();
read_next_statement(ip);
}
static void testbench( void *param )
{
_Bool clk, cmp;
_Bool rst = false;
_Bool set = false;
mtiInt32T load = 0;
mtiInt32T result, read_data;
static unsigned long long clk_cnt = 0;
static _Bool inc = false;
static _Bool dec = false;
testbench_t * ip = (testbench_t *) param;
clk = mti_GetSignalValue ( ip->clk );
cmp = mti_GetSignalValue ( ip->cmp );
result = mti_GetSignalValue (ip->result );
read_data = mti_GetSignalValue (ip->read_data );
if( clk )
{
clk_cnt++;
}
if( clk_cnt >=3 && clk_cnt <= 7 )
{
rst = true;
}
if( clk_cnt == 9 )
{
set = true;
load = 27;
}
if( clk_cnt == 12 )
{
inc = true;
}
if( result > 19 || result < 1 )
{
/* in case a force is used and the inc or dec are still active the value can go out of our "visible" test range */
set = true;
load = 27;
}
else if( result > 18 )
{
inc = false;
dec = true;
}
else if( result < 2 )
{
inc = true;
dec = false;
}
mti_ScheduleDriver( ip->rst, rst, 2, MTI_INERTIAL );
mti_ScheduleDriver( ip->set, set, 1, MTI_INERTIAL );
mti_ScheduleDriver( ip->inc, inc, 1, MTI_INERTIAL );
mti_ScheduleDriver( ip->dec, dec, 1, MTI_INERTIAL );
mti_ScheduleDriver( ip->load, load, 2, MTI_INERTIAL );
#ifdef NONO
printf( "testbech clk_cnt %llu clk %u, rst %u, set %u, inc %u, dec %u, load %d, result %d, cmp %u\n",
clk_cnt, clk, rst, set, inc, dec, load, result, cmp );
fflush(stdout);
#endif
}
