luke
/
iverilog
mirror of https://github.com/steveicarus/iverilog.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
iverilog/vpi/sys_queue.c

1468 lines
43 KiB
C
Raw Blame History

/*
* Copyright (C) 2011-2014 Cary R. (cygcary@yahoo.com)
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include "sys_priv.h"
#include <assert.h>
#include <inttypes.h>
#include <stdlib.h>
#include "ivl_alloc.h"
/*
* The two queue types.
*/
#define IVL_QUEUE_FIFO 1
#define IVL_QUEUE_LIFO 2
/*
* The statistical codes that can be passed to $q_exam().
*/
#define IVL_QUEUE_LENGTH 1
#define IVL_QUEUE_MEAN 2
#define IVL_QUEUE_MAX_LENGTH 3
#define IVL_QUEUE_SHORTEST 4
#define IVL_QUEUE_LONGEST 5
#define IVL_QUEUE_AVERAGE 6
/*
* All the values that can be returned by the queue tasks/function.
*/
#define IVL_QUEUE_OK 0
#define IVL_QUEUE_FULL 1
#define IVL_QUEUE_UNDEFINED_ID 2
#define IVL_QUEUE_EMPTY 3
#define IVL_QUEUE_UNSUPPORTED_TYPE 4
#define IVL_QUEUE_INVALID_LENGTH 5
#define IVL_QUEUE_DUPLICATE_ID 6
#define IVL_QUEUE_OUT_OF_MEMORY 7
/* Icarus specific status codes. */
#define IVL_QUEUE_UNDEFINED_STAT_CODE 8
#define IVL_QUEUE_VALUE_OVERFLOWED 9
#define IVL_QUEUE_NO_STATISTICS 10
/*
* Routine to add the given time to the the total time (high/low).
*/
static void add_to_wait_time(uint64_t *high, uint64_t *low, uint64_t c_time)
{
uint64_t carry = 0U;
if ((UINT64_MAX - *low) < c_time) carry = 1U;
*low += c_time;
assert((carry == 0U) || (*high < UINT64_MAX));
*high += carry;
}
/*
* Routine to divide the given total time (high/low) by the number of
* items to get the average.
*/
static uint64_t calc_average_wait_time(uint64_t high, uint64_t low, uint64_t total)
{
int bit = 64;
uint64_t result = 0U;
assert(total != 0U);
if (high == 0U) return (low/total);
/* This is true by design, but since we can only return 64 bits
* make sure nothing went wrong. */
assert(high < total);
/* It's a big value so calculate the average the long way. */
do {
unsigned carry = 0U;
/* Copy bits from low to high until we have a bit to place
* in the result or there are no bits left. */
while ((bit >= 0) && (high < total) && !carry) {
/* If the MSB is set then we will have a carry. */
if (high > (UINT64_MAX >> 1)) carry = 1U;
high <<= 1;
high |= (low & 0x8000000000000000) != 0;
low <<= 1;
bit -= 1;
}
/* If this is a valid bit, set the appropriate bit in the
* result and subtract the total from the current value. */
if (bit >= 0) {
result |= UINT64_C(1) << bit;
high = high - total;
}
/* Loop until there are no bits left. */
} while (bit > 0);
return result;
}
/*
* The data structure used for an individual queue element. It hold four
* state result for the jobs and inform fields along with the time that
* the element was added in base time units.
*/
typedef struct t_ivl_queue_elem {
uint64_t time;
s_vpi_vecval job;
s_vpi_vecval inform;
} s_ivl_queue_elem, *p_ivl_queue_elem;
/*
* This structure is used to represent a specific queue. The time
* information is in base simulation units.
*/
typedef struct t_ivl_queue_base {
uint64_t shortest_wait_time;
uint64_t first_add_time;
uint64_t latest_add_time;
uint64_t wait_time_high;
uint64_t wait_time_low;
uint64_t number_of_adds;
p_ivl_queue_elem queue;
PLI_INT32 id;
PLI_INT32 length;
PLI_INT32 type;
PLI_INT32 head;
PLI_INT32 elems;
PLI_INT32 max_len;
PLI_INT32 have_shortest_statistic;
} s_ivl_queue_base, *p_ivl_queue_base;
/*
* For now we keep the queues in a vector since there are likely not too many
* of them. We may need something more efficient later.
*/
static p_ivl_queue_base base = NULL;
static int64_t base_len = 0;
/*
* This routine is called at the end of simulation to free the queue memory.
*/
static PLI_INT32 cleanup_queue(p_cb_data cause)
{
PLI_INT32 idx;
(void) cause; /* Unused argument. */
for (idx = 0; idx < base_len; idx += 1) free(base[idx].queue);
free(base);
base = NULL;
base_len = 0;
return 0;
}
/*
* Add a new queue to the list, return 1 if there is not enough memory,
* otherwise return 0.
*/
static unsigned create_queue(PLI_INT32 id, PLI_INT32 type, PLI_INT32 length)
{
p_ivl_queue_base new_base;
p_ivl_queue_elem queue;
/* Allocate space for the new queue base. */
base_len += 1;
new_base = (p_ivl_queue_base) realloc(base,
base_len*sizeof(s_ivl_queue_base));
/* If we ran out of memory then fix the length and return a fail. */
if (new_base == NULL) {
base_len -= 1;
return 1;
}
base = new_base;
/* Allocate space for the queue elements. */
queue = (p_ivl_queue_elem) malloc(length*sizeof(s_ivl_queue_elem));
/* If we ran out of memory then fix the length and return a fail. */
if (queue == NULL) {
base_len -= 1;
return 1;
}
/* The memory was allocated so configure it. */
base[base_len-1].queue = queue;
base[base_len-1].id = id;
base[base_len-1].length = length;
base[base_len-1].type = type;
base[base_len-1].head = 0;
base[base_len-1].elems = 0;
base[base_len-1].max_len = 0;
base[base_len-1].shortest_wait_time = UINT64_MAX;
base[base_len-1].first_add_time = 0U;
base[base_len-1].latest_add_time = 0U;
base[base_len-1].wait_time_high = 0U;
base[base_len-1].wait_time_low = 0U;
base[base_len-1].number_of_adds = 0U;
base[base_len-1].have_shortest_statistic = 0;
return 0;
}
/*
* Check to see if the given queue is full.
*/
static unsigned is_queue_full(int64_t idx)
{
if (base[idx].elems >= base[idx].length) return 1;
return 0;
}
/*
* Add the job and inform to the queue. Return 1 if the queue is full,
* otherwise return 0.
*/
static unsigned add_to_queue(int64_t idx, p_vpi_vecval job,
p_vpi_vecval inform)
{
PLI_INT32 length = base[idx].length;
PLI_INT32 type = base[idx].type;
PLI_INT32 head = base[idx].head;
PLI_INT32 elems = base[idx].elems;
PLI_INT32 loc;
s_vpi_time cur_time;
uint64_t c_time;
assert(elems <= length);
/* If the queue is full we can't add anything. */
if (elems == length) return 1;
/* Increment the number of element since one will be added.*/
base[idx].elems += 1;
/* Save the job and inform to the queue. */
if (type == IVL_QUEUE_LIFO) {
assert(head == 0); /* For a LIFO head must always be zero. */
loc = elems;
} else {
assert(type == IVL_QUEUE_FIFO);
loc = head + elems;
if (loc >= length) loc -= length;
}
base[idx].queue[loc].job.aval = job->aval;
base[idx].queue[loc].job.bval = job->bval;
base[idx].queue[loc].inform.aval = inform->aval;
base[idx].queue[loc].inform.bval = inform->bval;
/* Save the current time with this entry for the statistics. */
cur_time.type = vpiSimTime;
vpi_get_time(NULL, &cur_time);
c_time = cur_time.high;
c_time <<= 32;
c_time |= cur_time.low;
base[idx].queue[loc].time = c_time;
/* Increment the maximum length if needed. */
if (base[idx].max_len == elems) base[idx].max_len += 1;
/* Update the inter-arrival statistics. */
assert(base[idx].number_of_adds < UINT64_MAX);
base[idx].number_of_adds += 1;
if (base[idx].number_of_adds == 1) base[idx].first_add_time = c_time;
base[idx].latest_add_time = c_time;
return 0;
}
/*
* Get the job and inform values from the queue. Return 1 if the queue is
* empty, otherwise return 0.
*/
static unsigned remove_from_queue(int64_t idx, p_vpi_vecval job,
p_vpi_vecval inform)
{
PLI_INT32 type = base[idx].type;
PLI_INT32 head = base[idx].head;
PLI_INT32 elems = base[idx].elems - 1;
PLI_INT32 loc;
s_vpi_time cur_time;
uint64_t c_time;
assert(elems >= -1);
/* If the queue is empty we can't remove anything. */
if (elems < 0) return 1;
/* Decrement the number of element in the queue structure since one
* will be removed.*/
base[idx].elems -= 1;
/* Remove the job and inform from the queue. */
if (type == IVL_QUEUE_LIFO) {
assert(head == 0); /* For a LIFO head must always be zero. */
loc = elems;
} else {
assert(type == IVL_QUEUE_FIFO);
loc = head;
if (head + 1 == base[idx].length) base[idx].head = 0;
else base[idx].head += 1;
}
job->aval = base[idx].queue[loc].job.aval;
job->bval = base[idx].queue[loc].job.bval;
inform->aval = base[idx].queue[loc].inform.aval;
inform->bval = base[idx].queue[loc].inform.bval;
/* Get the current simulation time. */
cur_time.type = vpiSimTime;
vpi_get_time(NULL, &cur_time);
c_time = cur_time.high;
c_time <<= 32;
c_time |= cur_time.low;
/* Set the shortest wait time if needed. */
assert(c_time >= base[idx].queue[loc].time);
c_time -= base[idx].queue[loc].time;
if (c_time < base[idx].shortest_wait_time) {
base[idx].shortest_wait_time = c_time;
}
base[idx].have_shortest_statistic = 1;
/* Add the current element wait time to the total wait time. */
add_to_wait_time(&(base[idx].wait_time_high), &(base[idx].wait_time_low),
c_time);
return 0;
}
/*
* Return the current queue length.
*/
static PLI_INT32 get_current_queue_length(int64_t idx)
{
return base[idx].elems;
}
/*
* Return the maximum queue length.
*/
static PLI_INT32 get_maximum_queue_length(int64_t idx)
{
return base[idx].max_len;
}
/*
* Return the longest wait time in the queue in base simulation units.
* Make sure to check that there are elements in the queue before calling
* this routine. The caller will need to scale the time as appropriate.
*/
static uint64_t get_longest_queue_time(int64_t idx)
{
s_vpi_time cur_time;
uint64_t c_time;
/* Get the current simulation time. */
cur_time.type = vpiSimTime;
vpi_get_time(NULL, &cur_time);
c_time = cur_time.high;
c_time <<= 32;
c_time |= cur_time.low;
/* Subtract the element with the longest time (the head) from the
* current time. */
assert(c_time >= base[idx].queue[base[idx].head].time);
c_time -= base[idx].queue[base[idx].head].time;
return c_time;
}
/*
* Check to see if there are inter-arrival time statistics.
*/
static unsigned have_interarrival_statistic(int64_t idx)
{
return (base[idx].number_of_adds >= 2U);
}
/*
* Return the mean inter-arrival time for the queue. This is just the
* latest add time minus the first add time divided be the number of time
* deltas (the number of adds - 1).
*/
static uint64_t get_mean_interarrival_time(int64_t idx)
{
return ((base[idx].latest_add_time - base[idx].first_add_time) /
(base[idx].number_of_adds - 1U));
}
/*
* Check to see if there are shortest wait time statistics.
*/
static unsigned have_shortest_wait_statistic(int64_t idx)
{
return (base[idx].have_shortest_statistic != 0);
}
/*
* Return the shortest amount of time an element has waited in the queue.
*/
static uint64_t get_shortest_wait_time(int64_t idx)
{
return base[idx].shortest_wait_time;
}
/*
* Check to see if we have an average wait time statistics.
*/
static unsigned have_average_wait_statistic(int64_t idx)
{
return (base[idx].number_of_adds >= 1U);
}
/*
* Return the average wait time in the queue.
*/
static uint64_t get_average_wait_time(int64_t idx)
{
PLI_INT32 length = base[idx].length;
PLI_INT32 loc = base[idx].head;
PLI_INT32 elems = base[idx].elems;
PLI_INT32 count;
/* Initialize the high and low time with the current total time. */
uint64_t high = base[idx].wait_time_high;
uint64_t low = base[idx].wait_time_low;
s_vpi_time cur_time;
uint64_t c_time;
/* Get the current simulation time. */
cur_time.type = vpiSimTime;
vpi_get_time(NULL, &cur_time);
c_time = cur_time.high;
c_time <<= 32;
c_time |= cur_time.low;
/* For each element still in the queue, add its wait time to the
* total wait time. */
for (count = 0; count < elems; count += 1) {
uint64_t add_time = base[idx].queue[loc].time;
assert(c_time >= add_time);
add_to_wait_time(&high, &low, c_time-add_time);
/* Move to the next element. */
loc += 1;
if (loc == length) loc = 0;
}
/* Return the average wait time. */
return calc_average_wait_time(high, low, base[idx].number_of_adds);
}
/*
* Check to see if the given id already exists. Return the index for the
* queue if it exists, otherwise return -1.
*/
static int64_t get_id_index(PLI_INT32 id)
{
int64_t idx;
for (idx = 0; idx < base_len; idx += 1) {
if (id == base[idx].id) return idx;
}
return -1;
}
/*
* Check to see if the given value is bit based and has 32 or fewer bits.
*/
static unsigned is_32_or_smaller_obj(vpiHandle obj)
{
PLI_INT32 const_type;
unsigned rtn = 0;
assert(obj);
switch(vpi_get(vpiType, obj)) {
case vpiConstant:
case vpiParameter:
const_type = vpi_get(vpiConstType, obj);
if ((const_type != vpiRealConst) &&
(const_type != vpiStringConst)) rtn = 1;
break;
/* These can have valid 32 bit or smaller numeric values. */
case vpiIntegerVar:
case vpiBitVar:
case vpiByteVar:
case vpiShortIntVar:
case vpiIntVar:
case vpiMemoryWord:
case vpiNet:
case vpiPartSelect:
case vpiReg:
rtn = 1;
break;
}
/* The object must be 32 bits or smaller. */
if (vpi_get(vpiSize, obj) > 32) rtn = 0;
return rtn;
}
/*
* Check to see if the argument is a variable that is exactly 32 bits in size.
*/
static void check_var_arg_32(vpiHandle arg, vpiHandle callh,
const char *name, const char *desc)
{
assert(arg);
switch (vpi_get(vpiType, arg)) {
case vpiMemoryWord:
case vpiPartSelect:
case vpiBitVar:
case vpiReg: // Check that we have exactly 32 bits.
if (vpi_get(vpiSize, arg) != 32) {
vpi_printf("ERROR: %s:%d: ", vpi_get_str(vpiFile, callh),
(int)vpi_get(vpiLineNo, callh));
vpi_printf("%s's %s (variable) argument must be 32 bits.\n",
name, desc);
vpi_control(vpiFinish, 1);
}
case vpiIntegerVar:
case vpiIntVar:
break;
default:
vpi_printf("ERROR: %s:%d: ", vpi_get_str(vpiFile, callh),
(int)vpi_get(vpiLineNo, callh));
vpi_printf("%s's %s argument must be a 32 bit variable.\n",
name, desc);
vpi_control(vpiFinish, 1);
}
}
/*
* Check to see if the argument is a variable of at least 32 bits.
*/
static void check_var_arg_large(vpiHandle arg, vpiHandle callh,
const char *name, const char *desc)
{
assert(arg);
switch (vpi_get(vpiType, arg)) {
case vpiMemoryWord:
case vpiPartSelect:
case vpiBitVar:
case vpiReg: // Check that we have at least 32 bits.
if (vpi_get(vpiSize, arg) < 32) {
vpi_printf("ERROR: %s:%d: ", vpi_get_str(vpiFile, callh),
(int)vpi_get(vpiLineNo, callh));
vpi_printf("%s's %s (variable) argument must have at least "
"32 bits.\n", name, desc);
vpi_control(vpiFinish, 1);
}
case vpiIntegerVar:
case vpiIntVar:
case vpiLongIntVar:
case vpiTimeVar:
break;
default:
vpi_printf("ERROR: %s:%d: ", vpi_get_str(vpiFile, callh),
(int)vpi_get(vpiLineNo, callh));
vpi_printf("%s's %s argument must be a variable.\n", name, desc);
vpi_control(vpiFinish, 1);
}
}
/*
* Check that the given number of arguments are numeric.
*/
static unsigned check_numeric_args(vpiHandle argv, unsigned count,
vpiHandle callh, const char *name)
{
unsigned idx;
/* Check that the first count arguments are numeric. Currently
* only three are needed/supported. */
for (idx = 0; idx < count; idx += 1) {
const char *loc = NULL;
vpiHandle arg = vpi_scan(argv);
/* Get the name for this argument. */
switch (idx) {
case 0: loc = "first"; break;
case 1: loc = "second"; break;
case 2: loc = "third"; break;
default: assert(0);
}
/* Check that there actually is an argument. */
if (! arg) {
vpi_printf("ERROR: %s:%d: ", vpi_get_str(vpiFile, callh),
(int)vpi_get(vpiLineNo, callh));
vpi_printf("%s requires a %s (<= 32 bit numeric) argument.\n",
name, loc);
vpi_control(vpiFinish, 1);
return 1;
}
/* Check that it is no more than 32 bits. */
if (! is_32_or_smaller_obj(arg)) {
vpi_printf("ERROR: %s:%d: ", vpi_get_str(vpiFile, callh),
(int)vpi_get(vpiLineNo, callh));
vpi_printf("%s's %s argument must be numeric (<= 32 bits).\n",
name, loc);
vpi_control(vpiFinish, 1);
}
}
return 0;
}
/*
* Check to see if the given argument is valid (does not have any X/Z bits).
* Return zero if it is valid and a positive value if it is invalid.
*/
static unsigned get_valid_32(vpiHandle arg, PLI_INT32 *value)
{
PLI_INT32 size, mask;
s_vpi_value val;
size = vpi_get(vpiSize, arg);
/* The compiletf routine should have already verified that this is
* <= 32 bits. */
assert((size <= 32) && (size > 0));
/* Create a mask so that we only check the appropriate bits. */
mask = UINT32_MAX >> (32 - size);
/* Get the value and return the possible integer value in the value
* variable. Return the b-value bits to indicate if the value is
* undefined (has X/Z bit). */
val.format = vpiVectorVal;
vpi_get_value(arg, &val);
*value = val.value.vector->aval & mask;
/* If the argument is signed and less than 32 bit we need to sign
* extend the value. */
if (vpi_get(vpiSigned, arg) && (size < 32)) {
if ((*value) & (1 << (size - 1))) *value |= ~mask;
}
return (val.value.vector->bval & mask);
}
static void get_four_state(vpiHandle arg, p_vpi_vecval vec)
{
PLI_INT32 size, mask;
s_vpi_value val;
size = vpi_get(vpiSize, arg);
/* The compiletf routine should have already verified that this is
* <= 32 bits. */
assert((size <= 32) && (size > 0));
/* Create a mask so that we only use the appropriate bits. */
mask = UINT32_MAX >> (32 - size);
/* Get the bits for the argument and save them in the return value. */
val.format = vpiVectorVal;
vpi_get_value(arg, &val);
vec->aval = val.value.vector->aval & mask;
vec->bval = val.value.vector->bval & mask;
/* If the argument is signed and less than 32 bit we need to sign
* extend the value. */
if (vpi_get(vpiSigned, arg) && (size < 32)) {
if (vec->aval & (1 << (size - 1))) vec->aval |= ~mask;
if (vec->bval & (1 << (size - 1))) vec->bval |= ~mask;
}
}
/*
* Fill the passed variable with x.
*/
static void fill_variable_with_x(vpiHandle var)
{
s_vpi_value val;
PLI_INT32 words = ((vpi_get(vpiSize, var) - 1) / 32) + 1;
PLI_INT32 idx;
p_vpi_vecval val_ptr = (p_vpi_vecval) malloc(words*sizeof(s_vpi_vecval));
assert(val_ptr);
/* Fill the vector with X. */
for (idx = 0; idx < words; idx += 1) {
val_ptr[idx].aval = 0xffffffff;
val_ptr[idx].bval = 0xffffffff;
}
/* Put the vector to the variable. */
val.format = vpiVectorVal;
val.value.vector = val_ptr;
vpi_put_value(var, &val, 0, vpiNoDelay);
free(val_ptr);
}
/*
* Fill the passed variable with the passed value if it fits. If it doesn't
* fit then set all bits to one and return that the value is too big instead
* of the normal OK. The value is a time and needs to be scaled to the
* calling module's timescale.
*/
static PLI_INT32 fill_variable_with_scaled_time(vpiHandle var, uint64_t c_time)
{
s_vpi_value val;
PLI_INT32 size = vpi_get(vpiSize, var);
PLI_INT32 is_signed = vpi_get(vpiSigned, var);
PLI_INT32 words = ((size - 1) / 32) + 1;
uint64_t max_val = 0;
uint64_t scale = 1;
uint64_t frac;
PLI_INT32 rtn, units, prec;
p_vpi_vecval val_ptr = (p_vpi_vecval) malloc(words*sizeof(s_vpi_vecval));
assert(val_ptr);
assert(size >= 32);
assert(words > 0);
/* Scale the variable to match the calling module's timescale. */
prec = vpi_get(vpiTimePrecision, 0);
units = vpi_get(vpiTimeUnit, vpi_handle(vpiModule, var));
assert(units >= prec);
while (units > prec) {
scale *= 10;
units -= 1;
}
frac = c_time % scale;
c_time /= scale;
if ((scale > 1) && (frac >= scale/2)) c_time += 1;
/* Find the maximum value + 1 that can be put into the variable. */
if (size < 64) {
max_val = 1;
max_val <<= (size - is_signed);
}
/* If the time is too big to fit then return the maximum positive
* value and that the value overflowed. Otherwise, return the time
* and OK. */
if (max_val && (c_time >= max_val)) {
/* For a single word only the MSB is cleared if signed. */
if (words == 1) {
if (is_signed) {
val_ptr[0].aval = 0x7fffffff;
} else {
val_ptr[0].aval = 0xffffffff;
}
val_ptr[0].bval = 0x00000000;
/* For two words the lower word is filled with 1 and the top
* word has a size dependent fill if signed. */
} else {
assert(words == 2);
val_ptr[0].aval = 0xffffffff;
val_ptr[0].bval = 0x00000000;
if (is_signed) {
val_ptr[1].aval = ~(UINT32_MAX >> (size - 32));
} else {
val_ptr[1].aval = 0xffffffff;
}
val_ptr[1].bval = 0x00000000;
}
rtn = IVL_QUEUE_VALUE_OVERFLOWED;
} else {
/* Fill the vector with 0. */
for (PLI_INT32 idx = 0; idx < words; idx += 1) {
val_ptr[idx].aval = 0x00000000;
val_ptr[idx].bval = 0x00000000;
}
/* Add the time to the vector. */
switch (words) {
default:
val_ptr[1].aval = (c_time >> 32) & 0xffffffff;
case 1:
val_ptr[0].aval = c_time & 0xffffffff;
}
rtn = IVL_QUEUE_OK;
}
/* Put the vector to the variable. */
val.format = vpiVectorVal;
val.value.vector = val_ptr;
vpi_put_value(var, &val, 0, vpiNoDelay);
free(val_ptr);
return rtn;
}
/*
* Check that the given $q_initialize() call has valid arguments.
*/
static PLI_INT32 sys_q_initialize_compiletf(ICARUS_VPI_CONST PLI_BYTE8 *name)
{
vpiHandle callh = vpi_handle(vpiSysTfCall, 0);
vpiHandle argv = vpi_iterate(vpiArgument, callh);
vpiHandle arg;
/* Check that there are arguments. */
if (argv == 0) {
vpi_printf("ERROR: %s:%d: ", vpi_get_str(vpiFile, callh),
(int)vpi_get(vpiLineNo, callh));
vpi_printf("%s requires four arguments.\n", name);
vpi_control(vpiFinish, 1);
return 0;
}
/* Check that the first three arguments (the id, type and maximum
* length) are numeric. */
if (check_numeric_args(argv, 3, callh, name)) return 0;
/* The fourth argument (the status) must be a variable. */
arg = vpi_scan(argv);
if (! arg) {
vpi_printf("ERROR: %s:%d: ", vpi_get_str(vpiFile, callh),
(int)vpi_get(vpiLineNo, callh));
vpi_printf("%s requires a fourth (variable) argument.\n", name);
vpi_control(vpiFinish, 1);
return 0;
}
/* Check that the status argument is a 32 bit variable. */
check_var_arg_32(arg, callh, name, "fourth");
/* Make sure there are no extra arguments. */
check_for_extra_args(argv, callh, name, "four arguments", 0);
return 0;
}
/*
* The runtime code for $q_initialize().
*/
static PLI_INT32 sys_q_initialize_calltf(ICARUS_VPI_CONST PLI_BYTE8 *name)
{
vpiHandle callh = vpi_handle(vpiSysTfCall, 0);
vpiHandle argv = vpi_iterate(vpiArgument, callh);
vpiHandle status;
PLI_INT32 id, type, length;
s_vpi_value val;
unsigned invalid_id, invalid_type, invalid_length;
(void)name; /* Parameter is not used. */
/* Get the id. */
invalid_id = get_valid_32(vpi_scan(argv), &id);
/* Get the queue type. */
invalid_type = get_valid_32(vpi_scan(argv), &type);
/* Get the queue maximum length. */
invalid_length = get_valid_32(vpi_scan(argv), &length);
/* Get the status variable. */
status = vpi_scan(argv);
/* We are done with the argument iterator so free it. */
vpi_free_object(argv);
/* If the id is invalid then return. */
if (invalid_id) {
val.format = vpiIntVal;
val.value.integer = IVL_QUEUE_UNDEFINED_ID;
vpi_put_value(status, &val, 0, vpiNoDelay);
return 0;
}
/* Verify that the type is valid. */
if (invalid_type || ((type != IVL_QUEUE_FIFO) &&
(type != IVL_QUEUE_LIFO))) {
val.format = vpiIntVal;
val.value.integer = IVL_QUEUE_UNSUPPORTED_TYPE;
vpi_put_value(status, &val, 0, vpiNoDelay);
return 0;
}
/* Verify that the queue length is greater than zero. */
if (invalid_length || (length <= 0)) {
val.format = vpiIntVal;
val.value.integer = IVL_QUEUE_INVALID_LENGTH;
vpi_put_value(status, &val, 0, vpiNoDelay);
return 0;
}
/* Check that this is not a duplicate queue id. */
if (get_id_index(id) >= 0) {
val.format = vpiIntVal;
val.value.integer = IVL_QUEUE_DUPLICATE_ID;
vpi_put_value(status, &val, 0, vpiNoDelay);
return 0;
}
/* Create the queue and fail if we do not have enough memory. */
if (create_queue(id, type, length)) {
val.format = vpiIntVal;
val.value.integer = IVL_QUEUE_OUT_OF_MEMORY;
vpi_put_value(status, &val, 0, vpiNoDelay);
return 0;
}
/* The queue was initialized correctly so return OK. */
val.format = vpiIntVal;
val.value.integer = IVL_QUEUE_OK;
vpi_put_value(status, &val, 0, vpiNoDelay);
return 0;
}
/*
* Check that the given $q_add() call has valid arguments.
*/
static PLI_INT32 sys_q_add_compiletf(ICARUS_VPI_CONST PLI_BYTE8 *name)
{
vpiHandle callh = vpi_handle(vpiSysTfCall, 0);
vpiHandle argv = vpi_iterate(vpiArgument, callh);
vpiHandle arg;
/* Check that there are arguments. */
if (argv == 0) {
vpi_printf("ERROR: %s:%d: ", vpi_get_str(vpiFile, callh),
(int)vpi_get(vpiLineNo, callh));
vpi_printf("%s requires four arguments.\n", name);
vpi_control(vpiFinish, 1);
return 0;
}
/* Check that the first three arguments (the id, job and information)
* are numeric. */
if (check_numeric_args(argv, 3, callh, name)) return 0;
/* The fourth argument (the status) must be a variable. */
arg = vpi_scan(argv);
if (! arg) {
vpi_printf("ERROR: %s:%d: ", vpi_get_str(vpiFile, callh),
(int)vpi_get(vpiLineNo, callh));
vpi_printf("%s requires a fourth (variable) argument.\n", name);
vpi_control(vpiFinish, 1);
return 0;
}
/* Check that the status argument is a 32 bit variable. */
check_var_arg_32(arg, callh, name, "fourth");
/* Make sure there are no extra arguments. */
check_for_extra_args(argv, callh, name, "four arguments", 0);
return 0;
}
/*
* The runtime code for $q_add().
*/
static PLI_INT32 sys_q_add_calltf(ICARUS_VPI_CONST PLI_BYTE8 *name)
{
vpiHandle callh = vpi_handle(vpiSysTfCall, 0);
vpiHandle argv = vpi_iterate(vpiArgument, callh);
vpiHandle status;
PLI_INT32 id;
int64_t idx;
s_vpi_vecval job, inform;
s_vpi_value val;
unsigned invalid_id;
(void)name; /* Parameter is not used. */
/* Get the id. */
invalid_id = get_valid_32(vpi_scan(argv), &id);
/* Get the job. */
get_four_state(vpi_scan(argv), &job);
/* Get the value. */
get_four_state(vpi_scan(argv), &inform);
/* Get the status variable. */
status = vpi_scan(argv);
/* We are done with the argument iterator so free it. */
vpi_free_object(argv);
/* Verify that the id is valid. */
idx = get_id_index(id);
if (invalid_id || (idx < 0)) {
val.format = vpiIntVal;
val.value.integer = IVL_QUEUE_UNDEFINED_ID;
vpi_put_value(status, &val, 0, vpiNoDelay);
return 0;
}
/* Add the data to the queue if it is not already full. */
if (add_to_queue(idx, &job, &inform)) {
val.format = vpiIntVal;
val.value.integer = IVL_QUEUE_FULL;
vpi_put_value(status, &val, 0, vpiNoDelay);
return 0;
}
/* The data was added to the queue so return OK. */
val.format = vpiIntVal;
val.value.integer = IVL_QUEUE_OK;
vpi_put_value(status, &val, 0, vpiNoDelay);
return 0;
}
/*
* Check that the given $q_remove() call has valid arguments.
*/
static PLI_INT32 sys_q_remove_compiletf(ICARUS_VPI_CONST PLI_BYTE8 *name)
{
vpiHandle callh = vpi_handle(vpiSysTfCall, 0);
vpiHandle argv = vpi_iterate(vpiArgument, callh);
vpiHandle arg;
/* Check that there are arguments. */
if (argv == 0) {
vpi_printf("ERROR: %s:%d: ", vpi_get_str(vpiFile, callh),
(int)vpi_get(vpiLineNo, callh));
vpi_printf("%s requires four arguments.\n", name);
vpi_control(vpiFinish, 1);
return 0;
}
/* The first argument (the id) must be numeric. */
if (! is_32_or_smaller_obj(vpi_scan(argv))) {
vpi_printf("ERROR: %s:%d: ", vpi_get_str(vpiFile, callh),
(int)vpi_get(vpiLineNo, callh));
vpi_printf("%s's first argument must be numeric (<= 32 bits).\n",
name);
vpi_control(vpiFinish, 1);
}
/* The second argument (the job id) must be a variable. */
arg = vpi_scan(argv);
if (! arg) {
vpi_printf("ERROR: %s:%d: ", vpi_get_str(vpiFile, callh),
(int)vpi_get(vpiLineNo, callh));
vpi_printf("%s requires a second (variable) argument.\n", name);
vpi_control(vpiFinish, 1);
return 0;
}
/* Check that the job id argument is a 32 bit variable. */
check_var_arg_32(arg, callh, name, "second");
/* The third argument (the information id) must be a variable. */
arg = vpi_scan(argv);
if (! arg) {
vpi_printf("ERROR: %s:%d: ", vpi_get_str(vpiFile, callh),
(int)vpi_get(vpiLineNo, callh));
vpi_printf("%s requires a third (variable) argument.\n", name);
vpi_control(vpiFinish, 1);
return 0;
}
/* Check that the information id argument is a 32 bit variable. */
check_var_arg_32(arg, callh, name, "third");
/* The fourth argument (the status) must be a variable. */
arg = vpi_scan(argv);
if (! arg) {
vpi_printf("ERROR: %s:%d: ", vpi_get_str(vpiFile, callh),
(int)vpi_get(vpiLineNo, callh));
vpi_printf("%s requires a fourth (variable) argument.\n", name);
vpi_control(vpiFinish, 1);
return 0;
}
/* Check that the status argument is a 32 bit variable. */
check_var_arg_32(arg, callh, name, "fourth");
/* Make sure there are no extra arguments. */
check_for_extra_args(argv, callh, name, "four arguments", 0);
return 0;
}
/*
* The runtime code for $q_remove().
*/
static PLI_INT32 sys_q_remove_calltf(ICARUS_VPI_CONST PLI_BYTE8 *name)
{
vpiHandle callh = vpi_handle(vpiSysTfCall, 0);
vpiHandle argv = vpi_iterate(vpiArgument, callh);
vpiHandle job, inform, status;
PLI_INT32 id, idx;
s_vpi_vecval job_val, inform_val;
s_vpi_value val;
unsigned invalid_id;
(void)name; /* Parameter is not used. */
/* Get the id. */
invalid_id = get_valid_32(vpi_scan(argv), &id);
/* Get the job variable. */
job = vpi_scan(argv);
/* Get the inform variable. */
inform = vpi_scan(argv);
/* Get the status variable. */
status = vpi_scan(argv);
/* We are done with the argument iterator so free it. */
vpi_free_object(argv);
/* Verify that the id is valid. */
idx = get_id_index(id);
if (invalid_id || (idx < 0)) {
fill_variable_with_x(job);
fill_variable_with_x(inform);
val.format = vpiIntVal;
val.value.integer = IVL_QUEUE_UNDEFINED_ID;
vpi_put_value(status, &val, 0, vpiNoDelay);
return 0;
}
/* Remove the data from the queue if it is not already empty. */
if (remove_from_queue(idx, &job_val, &inform_val)) {
fill_variable_with_x(job);
fill_variable_with_x(inform);
val.format = vpiIntVal;
val.value.integer = IVL_QUEUE_EMPTY;
vpi_put_value(status, &val, 0, vpiNoDelay);
return 0;
}
val.format = vpiVectorVal;
val.value.vector = &job_val;
vpi_put_value(job, &val, 0, vpiNoDelay);
val.format = vpiVectorVal;
val.value.vector = &inform_val;
vpi_put_value(inform, &val, 0, vpiNoDelay);
/* The data was added to the queue so return OK. */
val.format = vpiIntVal;
val.value.integer = IVL_QUEUE_OK;
vpi_put_value(status, &val, 0, vpiNoDelay);
return 0;
}
/*
* Check that the given $q_full() call has valid arguments.
*/
static PLI_INT32 sys_q_full_compiletf(ICARUS_VPI_CONST PLI_BYTE8 *name)
{
vpiHandle callh = vpi_handle(vpiSysTfCall, 0);
vpiHandle argv = vpi_iterate(vpiArgument, callh);
vpiHandle arg;
/* Check that there are arguments. */
if (argv == 0) {
vpi_printf("ERROR: %s:%d: ", vpi_get_str(vpiFile, callh),
(int)vpi_get(vpiLineNo, callh));
vpi_printf("%s requires two arguments.\n", name);
vpi_control(vpiFinish, 1);
return 0;
}
/* The first argument (the id) must be numeric. */
if (! is_32_or_smaller_obj(vpi_scan(argv))) {
vpi_printf("ERROR: %s:%d: ", vpi_get_str(vpiFile, callh),
(int)vpi_get(vpiLineNo, callh));
vpi_printf("%s's first argument must be numeric (<= 32 bits).\n",
name);
vpi_control(vpiFinish, 1);
}
/* The second argument (the status) must be a variable. */
arg = vpi_scan(argv);
if (! arg) {
vpi_printf("ERROR: %s:%d: ", vpi_get_str(vpiFile, callh),
(int)vpi_get(vpiLineNo, callh));
vpi_printf("%s requires a second (variable) argument.\n", name);
vpi_control(vpiFinish, 1);
return 0;
}
/* Check that the status argument is a 32 bit variable. */
check_var_arg_32(arg, callh, name, "second");
/* Make sure there are no extra arguments. */
check_for_extra_args(argv, callh, name, "two arguments", 0);
return 0;
}
/*
* The runtime code for $q_full().
*/
static PLI_INT32 sys_q_full_calltf(ICARUS_VPI_CONST PLI_BYTE8 *name)
{
vpiHandle callh = vpi_handle(vpiSysTfCall, 0);
vpiHandle argv = vpi_iterate(vpiArgument, callh);
vpiHandle status;
PLI_INT32 id, idx;
s_vpi_value val;
unsigned invalid_id;
(void)name; /* Parameter is not used. */
/* Get the id. */
invalid_id = get_valid_32(vpi_scan(argv), &id);
/* Get the status variable. */
status = vpi_scan(argv);
/* We are done with the argument iterator so free it. */
vpi_free_object(argv);
/* Verify that the id is valid. */
idx = get_id_index(id);
if (invalid_id || (idx < 0)) {
val.format = vpiIntVal;
val.value.integer = IVL_QUEUE_UNDEFINED_ID;
vpi_put_value(status, &val, 0, vpiNoDelay);
fill_variable_with_x(callh);
return 0;
}
/* Get the queue state and return it. */
val.format = vpiIntVal;
if (is_queue_full(idx)) val.value.integer = 1;
else val.value.integer = 0;
vpi_put_value(callh, &val, 0, vpiNoDelay);
/* The queue state was passed back so return OK. */
val.format = vpiIntVal;
val.value.integer = IVL_QUEUE_OK;
vpi_put_value(status, &val, 0, vpiNoDelay);
return 0;
}
/*
* Check that the given $q_exam() call has valid arguments.
*/
static PLI_INT32 sys_q_exam_compiletf(ICARUS_VPI_CONST PLI_BYTE8 *name)
{
vpiHandle callh = vpi_handle(vpiSysTfCall, 0);
vpiHandle argv = vpi_iterate(vpiArgument, callh);
vpiHandle arg;
/* Check that there are arguments. */
if (argv == 0) {
vpi_printf("ERROR: %s:%d: ", vpi_get_str(vpiFile, callh),
(int)vpi_get(vpiLineNo, callh));
vpi_printf("%s requires four arguments.\n", name);
vpi_control(vpiFinish, 1);
return 0;
}
/* Check that the first two arguments (the id and code) are numeric. */
if (check_numeric_args(argv, 2, callh, name)) return 0;
/* The third argument (the value) must be a variable. */
arg = vpi_scan(argv);
if (! arg) {
vpi_printf("ERROR: %s:%d: ", vpi_get_str(vpiFile, callh),
(int)vpi_get(vpiLineNo, callh));
vpi_printf("%s requires a third (variable) argument.\n", name);
vpi_control(vpiFinish, 1);
return 0;
}
/* Check that the value argument is a variable with at least
* 32 bits. */
check_var_arg_large(arg, callh, name, "third");
/* The fourth argument (the status) must be a variable. */
arg = vpi_scan(argv);
if (! arg) {
vpi_printf("ERROR: %s:%d: ", vpi_get_str(vpiFile, callh),
(int)vpi_get(vpiLineNo, callh));
vpi_printf("%s requires a fourth (variable) argument.\n", name);
vpi_control(vpiFinish, 1);
return 0;
}
/* Check that the status argument is a 32 bit variable. */
check_var_arg_32(arg, callh, name, "fourth");
/* Make sure there are no extra arguments. */
check_for_extra_args(argv, callh, name, "two arguments", 0);
return 0;
}
/*
* The runtime code for $q_exam().
*/
static PLI_INT32 sys_q_exam_calltf(ICARUS_VPI_CONST PLI_BYTE8 *name)
{
vpiHandle callh = vpi_handle(vpiSysTfCall, 0);
vpiHandle argv = vpi_iterate(vpiArgument, callh);
vpiHandle value, status;
PLI_INT32 id, code, idx, rtn;
s_vpi_value val;
unsigned invalid_id, invalid_code;
(void)name; /* Parameter is not used. */
/* Get the id. */
invalid_id = get_valid_32(vpi_scan(argv), &id);
/* Get the code. */
invalid_code = get_valid_32(vpi_scan(argv), &code);
/* Get the value variable. */
value = vpi_scan(argv);
/* Get the status variable. */
status = vpi_scan(argv);
/* We are done with the argument iterator so free it. */
vpi_free_object(argv);
/* Verify that the id is valid. */
idx = get_id_index(id);
if (invalid_id || (idx < 0)) {
fill_variable_with_x(value);
val.format = vpiIntVal;
val.value.integer = IVL_QUEUE_UNDEFINED_ID;
vpi_put_value(status, &val, 0, vpiNoDelay);
return 0;
}
/* Verify that the code is valid. */
if (invalid_code || (code <= 0) || (code > 6)) {
fill_variable_with_x(value);
val.format = vpiIntVal;
val.value.integer = IVL_QUEUE_UNDEFINED_STAT_CODE;
vpi_put_value(status, &val, 0, vpiNoDelay);
return 0;
}
rtn = IVL_QUEUE_OK;
/* Calculate the requested queue information. */
switch (code) {
/* The current queue length. */
case IVL_QUEUE_LENGTH:
val.format = vpiIntVal;
val.value.integer = get_current_queue_length(idx);
vpi_put_value(value, &val, 0, vpiNoDelay);
break;
/* The mean inter-arrival time. */
case IVL_QUEUE_MEAN:
if (have_interarrival_statistic(idx) == 0) {
fill_variable_with_x(value);
rtn = IVL_QUEUE_NO_STATISTICS;
} else {
uint64_t ia_time = get_mean_interarrival_time(idx);
rtn = fill_variable_with_scaled_time(value, ia_time);
}
break;
/* The maximum queue length. */
case IVL_QUEUE_MAX_LENGTH:
val.format = vpiIntVal;
val.value.integer = get_maximum_queue_length(idx);
vpi_put_value(value, &val, 0, vpiNoDelay);
break;
/* The shortest queue wait time ever. */
case IVL_QUEUE_SHORTEST:
if (have_shortest_wait_statistic(idx) == 0) {
fill_variable_with_x(value);
rtn = IVL_QUEUE_NO_STATISTICS;
} else {
uint64_t sw_time = get_shortest_wait_time(idx);
rtn = fill_variable_with_scaled_time(value, sw_time);
}
break;
/* The longest wait time for elements still in the queue. */
case IVL_QUEUE_LONGEST:
if (get_current_queue_length(idx) == 0) {
fill_variable_with_x(value);
rtn = IVL_QUEUE_NO_STATISTICS;
} else {
uint64_t lq_time = get_longest_queue_time(idx);
rtn = fill_variable_with_scaled_time(value, lq_time);
}
break;
/* The average queue wait time. */
case IVL_QUEUE_AVERAGE:
if (have_average_wait_statistic(idx) == 0) {
fill_variable_with_x(value);
rtn = IVL_QUEUE_NO_STATISTICS;
} else {
uint64_t aw_time = get_average_wait_time(idx);
rtn = fill_variable_with_scaled_time(value, aw_time);
}
break;
default:
assert(0);
}
/* The queue information was passed back so now return the status. */
val.format = vpiIntVal;
val.value.integer = rtn;
vpi_put_value(status, &val, 0, vpiNoDelay);
return 0;
}
/*
* Routine to register the system tasks/functions provided in this file.
*/
void sys_queue_register(void)
{
s_vpi_systf_data tf_data;
s_cb_data cb;
vpiHandle res;
tf_data.type = vpiSysTask;
tf_data.tfname = "$q_initialize";
tf_data.calltf = sys_q_initialize_calltf;
tf_data.compiletf = sys_q_initialize_compiletf;
tf_data.sizetf = 0;
tf_data.user_data = "$q_initialize";
res = vpi_register_systf(&tf_data);
vpip_make_systf_system_defined(res);
tf_data.type = vpiSysTask;
tf_data.tfname = "$q_add";
tf_data.calltf = sys_q_add_calltf;
tf_data.compiletf = sys_q_add_compiletf;
tf_data.sizetf = 0;
tf_data.user_data = "$q_add";
res = vpi_register_systf(&tf_data);
vpip_make_systf_system_defined(res);
tf_data.type = vpiSysTask;
tf_data.tfname = "$q_remove";
tf_data.calltf = sys_q_remove_calltf;
tf_data.compiletf = sys_q_remove_compiletf;
tf_data.sizetf = 0;
tf_data.user_data = "$q_remove";
res = vpi_register_systf(&tf_data);
vpip_make_systf_system_defined(res);
tf_data.type = vpiSysFunc;
tf_data.sysfunctype = vpiSysFuncInt;
tf_data.tfname = "$q_full";
tf_data.calltf = sys_q_full_calltf;
tf_data.compiletf = sys_q_full_compiletf;
tf_data.sizetf = 0; /* Not needed for a vpiSysFuncInt. */
tf_data.user_data = "$q_full";
res = vpi_register_systf(&tf_data);
vpip_make_systf_system_defined(res);
tf_data.type = vpiSysTask;
tf_data.tfname = "$q_exam";
tf_data.calltf = sys_q_exam_calltf;
tf_data.compiletf = sys_q_exam_compiletf;
tf_data.sizetf = 0;
tf_data.user_data = "$q_exam";
res = vpi_register_systf(&tf_data);
vpip_make_systf_system_defined(res);
/* Create a callback to clear all the queue memory when the
* simulator finishes. */
cb.time = NULL;
cb.reason = cbEndOfSimulation;
cb.cb_rtn = cleanup_queue;
cb.user_data = 0x0;
cb.obj = 0x0;
vpi_register_cb(&cb);
}
Reference in New Issue View Git Blame Copy Permalink