/* Copyright (c) 1995-2003 Pragmatic C Software Corp. */
/*
* test of set delays vpi_ tasks - read and sets (puts) same delay value
* for primitives and paths only
*/
#include <stdio.h>
#include <string.h>
#include "vpi_user.h"
#include "cv_vpi_user.h"
#define TRUE 1
#define FALSE 0
int (*iproc_rtn)();
/* local function prototypes */
static void process_inst(vpiHandle);
static char *get_tchknam(char *, int);
/* global function prototypes */
extern int process_all_insts(struct t_cb_data *);
extern int prt_inst_delays(vpiHandle);
extern int my_error_handler(struct t_cb_data *);
extern void register_scan_cb(void);
/*
* routine to get and zero all delays in design
*/
int process_all_insts(struct t_cb_data *cbp)
{
int isiz;
vpiHandle topiter, topiref;
/* build the iterator for each module */
topiter = vpi_iterate(vpiModule, NULL);
isiz = vpi_get(vpiSize, topiter);
vpi_printf(" There are %d top level modules.\n", isiz);
for (;;)
{
if ((topiref = vpi_scan(topiter)) == NULL) break;
process_inst(topiref);
}
vpi_printf(" All instances processed.\n");
/* notice Verilog model is not run, just data for PLI */
vpi_sim_control(vpiFinish, 0);
return(0);
}
/*
* process one instance and recursively process all under instances
* processing is top down depth first
*/
static void process_inst(vpiHandle up_ihref)
{
int isiz;
vpiHandle iter, ihref;
iproc_rtn(up_ihref);
if ((iter = vpi_iterate(vpiModule, up_ihref)) == NULL) return;
isiz = vpi_get(vpiSize, iter);
vpi_printf(" There are %d instances in %s.\n", isiz,
vpi_get_str(vpiFullName, up_ihref));
for (;;)
{
if ((ihref = vpi_scan(iter)) == NULL) break;
process_inst(ihref);
}
}
/*
* simplest processing routine - just print delays
*/
int prt_inst_delays(vpiHandle ihref)
{
register int di;
int tctyp;
vpiHandle iter, href;
s_vpi_delay idrec, odrec;
s_vpi_time idelarr[12], odelarr[12];
char s1[1024], s2[1024];
idrec.da = &(idelarr[0]);
idrec.time_type = vpiSimTime;
/* idrec.time_type = vpiScaledRealTime; */
idrec.mtm_flag = FALSE;
idrec.append_flag = FALSE;
idrec.pulsere_flag = FALSE;
/* gates - use scan returns nil, nil iterator pattern */
idrec.no_of_delays = 3;
odrec.da = &(odelarr[0]);
odrec.time_type = idrec.time_type;
odrec.mtm_flag = FALSE;
odrec.append_flag = TRUE;
odrec.pulsere_flag = FALSE;
/* gates - use scan returns nil, nil iterator pattern */
odrec.no_of_delays = 3;
iter = vpi_iterate(vpiPrimitive, ihref);
for (;;)
{
if ((href = vpi_scan(iter)) == NULL) break;
if (vpi_iterate(vpiDelay, href) == NULL) continue;
vpi_get_delays(href, &idrec);
for (di = 0; di < idrec.no_of_delays; di++) odrec.da[di] = idrec.da[di];
vpi_put_delays(href, &odrec);
vpi_get_delays(href, &idrec);
/* expect delays to always fit in 31 bits */
if (vpi_get(vpiType, href) == vpiUdp) strcpy(s1, "udp");
else strcpy(s1, "gate");
strcpy(s2, vpi_get_str(vpiDefName, href));
/* -- */
vpi_printf(" %s %s %s has delay #(%d, %d, %d).\n",
s2, s1, vpi_get_str(vpiFullName, href), idrec.da[0].low, idrec.da[1].low,
idrec.da[2].low);
/* --- */
/* ---
vpi_printf(" %s %s %s has delay #(%d, %d).\n",
s2, s1, vpi_get_str(vpiFullName, href), idrec.da[0].low, idrec.da[1].low);
--- */
/* ---
vpi_printf(" %s %s %s has delay #(%5.2f, %5.2f).\n",
s2, s1, vpi_get_str(vpiFullName, href), idrec.da[0].real,
idrec.da[1].real);
--- */
}
/* contas */
iter = vpi_iterate(vpiContAssign, ihref);
for (;;)
{
if ((href = vpi_scan(iter)) == NULL) break;
if (vpi_iterate(vpiDelay, href) == NULL) continue;
vpi_get_delays(href, &idrec);
/* expect delays to always fit in 31 bits */
vpi_printf(" continuous assign at **%s(%d) has delay #(%d, %d, %d).\n",
vpi_get_str(vpiFile, href), vpi_get(vpiLineNo, href),
idrec.da[0].low, idrec.da[1].low, idrec.da[2].low);
}
/* paths */
idrec.no_of_delays = 6;
idrec.time_type = vpiScaledRealTime;
iter = vpi_iterate(vpiModPath, ihref);
for (;;)
{
if ((href = vpi_scan(iter)) == NULL) break;
vpi_get_delays(href, &idrec);
for (di = 0; di < idrec.no_of_delays; di++) odrec.da[di] = idrec.da[di];
vpi_put_delays(href, &odrec);
vpi_get_delays(href, &idrec);
/* expect delays to always fit in 31 bits */
/* --- */
vpi_printf(" path at **%s(%d) has delay #(%g, %g, %g, %g, %g, %g).\n",
vpi_get_str(vpiFile, href), vpi_get(vpiLineNo, href),
idrec.da[0].real, idrec.da[1].real, idrec.da[2].real, idrec.da[3].real,
idrec.da[4].real, idrec.da[5].real);
/* --- */
/* ---
vpi_printf(" path at **%s(%d) has delay #(%d, %d, %d, %d, %d, %d).\n",
vpi_get_str(vpiFile, href), vpi_get(vpiLineNo, href),
idrec.da[0].low, idrec.da[1].low, idrec.da[2].low, idrec.da[3].low,
idrec.da[4].low, idrec.da[5].low);
--- */
/* ---
vpi_printf(
" path at **%s(%d) has delay #(%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d).\n",
vpi_get_str(vpiFile, href), vpi_get(vpiLineNo, href),
idrec.da[0].low, idrec.da[1].low, idrec.da[2].low, idrec.da[3].low,
idrec.da[4].low, idrec.da[5].low, idrec.da[6].low, idrec.da[7].low,
idrec.da[8].low, idrec.da[9].low, idrec.da[10].low, idrec.da[11].low);
--- */
/* ---
vpi_printf(" path at **%s(%d) has delay #(%d, %d).\n",
vpi_get_str(vpiFile, href), vpi_get(vpiLineNo, href),
idrec.da[0].low, idrec.da[1].low, idrec.da[2].low);
--- */
}
/* timing checks */
/* paths */
/* drec.no_of_delays = 2; */
idrec.time_type = vpiSimTime;
/* drec.time_type = vpiScaledRealTime; */
idrec.time_type = vpiScaledRealTime;
iter = vpi_iterate(vpiTchk, ihref);
for (;;)
{
if ((href = vpi_scan(iter)) == NULL) break;
tctyp = vpi_get(vpiTchkType, href);
if (tctyp == vpiWidth || tctyp == vpiSetupHold) idrec.no_of_delays = 2;
else idrec.no_of_delays = 1;
vpi_get_delays(href, &idrec);
get_tchknam(s1, tctyp);
vpi_printf(" %s timing check at **%s(%d) limit %g.\n",
s1, vpi_get_str(vpiFile, href), vpi_get(vpiLineNo, href), idrec.da[0].real);
/* ---
vpi_printf(" %s timing check at **%s(%d) 1st limit %d, 2nd limit %d.\n",
s1, vpi_get_str(vpiFile, href), vpi_get(vpiLineNo, href),
idrec.da[0].low, idrec.da[1].low);
--- */
}
return(0);
}
/*
* notice need user routine - no str property
*/
char *get_tchknam(char *s, int ttyp)
{
switch (ttyp) {
case vpiSetup: strcpy(s, "$setup"); break;
case vpiHold: strcpy(s, "$hold"); break;
case vpiPeriod: strcpy(s, "$period"); break;
case vpiWidth: strcpy(s, "$width"); break;
case vpiSkew: strcpy(s, "$skew"); break;
case vpiRecovery: strcpy(s, "$recovery"); break;
case vpiNoChange: strcpy(s, "$nochange"); break;
case vpiSetupHold: strcpy(s, "$setuphold"); break;
default: strcpy(s, "**out of range**"); break;
}
return(s);
}
/*
* routine to build an error indication string
*/
int my_error_handler(struct t_cb_data *cbp)
{
struct t_vpi_error_info einfotab;
struct t_vpi_error_info *einfop;
char s1[128];
einfop = &einfotab;
vpi_chk_error(einfop);
if (einfop->state == vpiCompile) strcpy(s1, "vpiCompile");
else if (einfop->state == vpiPLI) strcpy(s1, "vpiPLI");
else if (einfop->state == vpiRun) strcpy(s1, "vpiRun");
else strcpy(s1, "**unknown**");
vpi_printf("**ERR(%s) %s (level %d) at **%s(%d):\n %s\n",
einfop->code, s1, einfop->level, einfop->file, einfop->line,
einfop->message);
/* if serious error give up */
if (einfop->level == vpiError || einfop->level == vpiSystem
|| einfop->level == vpiInternal)
{
vpi_printf("**FATAL: encountered error - giving up\n");
vpi_sim_control(vpiFinish, 0);
}
return(0);
}
/* Template functin table for added user systf tasks and functions.
See file vpi_user.h for structure definition
Note only vpi_register_systf and vpi_ or tf_ utility routines that
do not access the simulation data base may be called from these routines
*/
/* all routines are called to register cbs */
/* called just after all PLI 1.0 tf_ veriusertfs table routines are set up */
/* before source is read */
void (*vlog_startup_routines[]) () =
{
register_scan_cb,
0
};
/* routine to do the systf registering - probably should go in other file */
/* usually only vpi_ PLI 2.0 systf or cb registering is done here */
/*
* register the start of sim scan call back and set up error handling
*
* notice making version of Cver that prints some stuff to start but
* is a normal Cver
*
* since handle not save (passed back?), no way to find out cb info
*/
void register_scan_cb(void)
{
vpiHandle href, href2;
struct t_cb_data *ecbp, *cbp;
struct t_cb_data cbrec;
/* notice cb records must be in global storage */
ecbp = &cbrec;
ecbp->reason = cbPLIError;
ecbp->cb_rtn = my_error_handler;
ecbp->obj = NULL;
ecbp->time = NULL;
ecbp->value = NULL;
ecbp->user_data = NULL;
/* probably should check for error here */
if ((href = vpi_register_cb(ecbp)) == NULL)
vpi_printf("**ERR: PLI 2.0 can not register error handler callback.\n");
cbp = &cbrec;
cbp->reason = cbStartOfSimulation;
cbp->cb_rtn = process_all_insts;
cbp->obj = NULL;
cbp->time = NULL;
cbp->value = NULL;
cbp->user_data = NULL;
/* probably should check for error here */
if ((href2 = vpi_register_cb(cbp)) == NULL)
vpi_printf(
"**ERR: PLI 2.0 can not register start of sim setup callback.\n");
/* if not registered will be no call backs */
/* set the processing routine */
iproc_rtn = prt_inst_delays;
}
/* dummy +loadvpi= boostrap routine - mimics old style exec all routines */
/* in standard PLI vlog_startup_routines table */
void vpi_compat_bootstrap(void)
{
int i;
for (i = 0;; i++)
{
if (vlog_startup_routines[i] == NULL) break;
vlog_startup_routines[i]();
}
}
