#include "simInt.h"#include <sys/time.h>
Include dependency graph for simUtil.c:
Go to the source code of this file.
Functions | |
| st_table * | Sim_NetworkBuildNodeToMvfTable (Ntk_Network_t *network, array_t *nodesArray, int internalPartitionHead, int nextStateHead) |
| int | SimNodeReadValueCode (Ntk_Node_t *node, char *value) |
| boolean | SimTestPartInTermsOfCI (Sim_Sim_t *sim) |
| char * | SimInteger2ASCII (int number) |
| void | SimStringPrint (FILE *fp, char *string, int len) |
| array_t * | SimSimInitDataFormat (Sim_Sim_t *sim) |
| void | SimSimVectorFillCurrentState (Sim_Sim_t *sim, int n) |
| int | SimNodeComputeRandomValue (Ntk_Node_t *node, Sim_PseudoSrc pseudoInputSource) |
| mdd_t * | SimSimVectorBuildMdd (Sim_Sim_t *sim, array_t *vector, array_t *partitionVector) |
| void | SimAppendErrorMsg (char *str1, char *str2, char *str3) |
| int | SimComputeRandomInteger (void) |
| void | SimNodesArrayBuildRootsAndLeaves (Ntk_Network_t *network, array_t *nodesArray, int internalPartitionHead, int nextStateHead, array_t **roots, array_t **leaves) |
| st_table * | SimNodesArrayBuildNodeToMvfTable (array_t *nodesArray, int internalPartitionHead, array_t *mvfArray) |
Variables | |
| static char rcsid[] | UNUSED = "$Id: simUtil.c,v 1.8 2005/04/26 19:10:09 jinh Exp $" |
Function Documentation
| st_table* Sim_NetworkBuildNodeToMvfTable | ( | Ntk_Network_t * | network, |
| array_t * | nodesArray, | ||
| int | internalPartitionHead, | ||
| int | nextStateHead | ||
| ) |
AutomaticStart AutomaticEnd Function********************************************************************
Synopsis [Builds a table mapping a node to a Mvf_Function.]
Description [Builds a table mapping a node to a Mvf_Function. nodesArray should contain every nodes for which a Mvf_Function is requested. Returns an empty table if nodesArray doesn't contain any node.]
SideEffects []
Definition at line 63 of file simUtil.c.
{
array_t *rootsName;
array_t *leavesMddId;
array_t *mvfArray;
st_table *nodeToMvfTable;
SimNodesArrayBuildRootsAndLeaves(network, nodesArray, internalPartitionHead, nextStateHead, &rootsName, &leavesMddId);
mvfArray = Part_PartitionBuildFunctions(Part_NetworkReadPartition(network),
rootsName, leavesMddId, NIL(mdd_t));
array_free(leavesMddId);
array_free(rootsName);
nodeToMvfTable = SimNodesArrayBuildNodeToMvfTable(nodesArray, internalPartitionHead, mvfArray);
array_free(mvfArray);
return(nodeToMvfTable);
}
Here is the call graph for this function:
Here is the caller graph for this function:
| void SimAppendErrorMsg | ( | char * | str1, |
| char * | str2, | ||
| char * | str3 | ||
| ) |
Function********************************************************************
Synopsis [Write an error message to error_string.]
Description [Write an error message to error_string. The message will be written as ("%s%s%s", str1, str2, str3).]
SideEffects []
Definition at line 449 of file simUtil.c.
{
error_append(str1);
error_append(str2);
error_append(str3);
}
Here is the caller graph for this function:
| int SimComputeRandomInteger | ( | void | ) |
Function********************************************************************
Synopsis [Returns a random value.]
Description [Returns a random value. Uses gettimeofday system function.]
SideEffects []
Definition at line 469 of file simUtil.c.
{
struct timeval tp;
struct timezone tzp;
if ((int) gettimeofday(&tp,&tzp) == -1) {
fprintf (vis_stderr, "sim : Error while calling gettimeofday.\n");
exit(-1);
}
return((int) (tp.tv_sec));
}
Here is the caller graph for this function:
| char* SimInteger2ASCII | ( | int | number | ) |
Function********************************************************************
Synopsis [Converts integer to string of ASCII characters.]
Description [Converts integer to string of ASCII characters. It is the responsibility of the user to free the returned string.]
SideEffects []
Definition at line 185 of file simUtil.c.
{
char * str = ALLOC(char, 21);
(void) sprintf(str, "%d", number);
return(str);
}
Here is the caller graph for this function:
| int SimNodeComputeRandomValue | ( | Ntk_Node_t * | node, |
| Sim_PseudoSrc | pseudoInputSource | ||
| ) |
Function********************************************************************
Synopsis [Returns a random value for a multi-valued variable.]
Description [Returns a random value for a multi-valued variable. If the node is of type pseudo-input, then 1) if pseudoInputSource is Sim_First_c, then the first value of the first row is used, else 2) a random row of the table is chosen, and within this row, a random value in the output entry is chosen (this is not exactly random, because a value could appear in more than one row). If the node in not a pseudo-input, then a random value from the domain of the node's variable is chosen. The encoded value is returned.]
SideEffects []
Definition at line 315 of file simUtil.c.
{
int value = 0; /* initialize so that lint doesn't complain */
if (Ntk_NodeTestIsPseudoInput(node)) {
Tbl_Entry_t *entry;
int rowNum;
int colNum;
int rowChoice;
Tbl_Table_t *table = Ntk_NodeReadTable(node);
int outIndex = Ntk_NodeReadOutputIndex(node);
/* Decide which row to take value from. */
if (pseudoInputSource == Sim_First_c) {
rowChoice = 0;
}
else {
int numRows = Tbl_TableReadNumRows(table);
rowChoice = ((int) util_random()) % numRows;
}
Tbl_TableForEachOutputEntry(table, rowNum, colNum, entry) {
if ((colNum == outIndex) && (rowNum == rowChoice)) {
Tbl_Range_t *range;
lsGen lsGen;
int tempValue;
int entryChoice;
int i = 0;
/* We are now in rowChoice. Decide which value of entry to take. */
if (pseudoInputSource == Sim_First_c) {
entryChoice = 0;
}
else {
int numValues = Tbl_EntryReadNumValues(entry);
entryChoice = ((int) util_random()) % numValues;
}
Tbl_EntryForEachValue(entry, tempValue, lsGen, range) {
if(entryChoice == i) {
value = tempValue;
/*
* We could break out of the two FOR loops to avoid unnecessary
* work. However, the inner loop has an lsGen that must be freed
* if the loop is broken early, and I couldn't get lsFinish to be
* called correctly. Also, the table shouldn't be big to worry
* about it.
*/
}
i++;
}
}
}
}
else {
Var_Variable_t *var = Ntk_NodeReadVariable(node);
value = ((int) util_random()) % Var_VariableReadNumValues(var);
}
return value;
}
Here is the call graph for this function:
Here is the caller graph for this function:
| int SimNodeReadValueCode | ( | Ntk_Node_t * | node, |
| char * | value | ||
| ) |
Function********************************************************************
Synopsis [Returns the integer code of the value of a variable associated to a node.]
Description [Returns the integer code of the value of a variable associated to a node. If the value does not belong to the domain of the variable, then -1 is returned. It is an error to call this function with a NULL node.]
SideEffects []
Definition at line 102 of file simUtil.c.
{
int index;
Var_Variable_t *var = Ntk_NodeReadVariable(node);
if (Var_VariableTestIsSymbolic(var)) {
return(Var_VariableReadIndexFromSymbolicValue(var, value));
}
/* Enumerative or binary variable */
else {
index = atoi(value);
if (index >= Var_VariableReadNumValues(var) || index < 0) {
return(-1);
}
else {
return(index);
}
}
}
Here is the call graph for this function:
Here is the caller graph for this function:
| st_table* SimNodesArrayBuildNodeToMvfTable | ( | array_t * | nodesArray, |
| int | internalPartitionHead, | ||
| array_t * | mvfArray | ||
| ) |
Function********************************************************************
Synopsis [Builds a table mapping a node to its Mvf_Function.]
Description [Builds a table mapping a node to its Mvf_Function. mvfArray is an array of Mvf_Function.]
SideEffects []
Definition at line 533 of file simUtil.c.
{
int i;
Ntk_Node_t *node;
array_t *mvf;
st_table *nodeToMvfTable = st_init_table(st_ptrcmp, st_ptrhash);
for(i = internalPartitionHead; i < array_n(nodesArray); i++) {
node = array_fetch(Ntk_Node_t *, nodesArray, i);
mvf = array_fetch(Mvf_Function_t *, mvfArray, i - internalPartitionHead);
st_insert(nodeToMvfTable, (char *) node, (char *) mvf);
}
return(nodeToMvfTable);
}
Here is the caller graph for this function:
| void SimNodesArrayBuildRootsAndLeaves | ( | Ntk_Network_t * | network, |
| array_t * | nodesArray, | ||
| int | internalPartitionHead, | ||
| int | nextStateHead, | ||
| array_t ** | roots, | ||
| array_t ** | leaves | ||
| ) |
Function********************************************************************
Synopsis [Builds an array of MddId of primary inputs, pseudo inputs, and current states, and an array of name of next states and outputs.]
Description [Builds an array of MddId of leaves of a network : primary inputs, pseudo inputs, and current states, and an array of name of roots: next states and outputs. These arrays are returned through the parameteres leaves and roots. We suppose that every primary inputs, pseudo inputs, and current states has an MDD Id.]
SideEffects []
Definition at line 496 of file simUtil.c.
{
int i;
Ntk_Node_t *node;
*roots = array_alloc(char *, 0);
*leaves = array_alloc(int, 0);
for(i = 0; i < nextStateHead; i++) {
node = array_fetch(Ntk_Node_t *, nodesArray, i);
array_insert_last(int, *leaves, Ntk_NodeReadMddId(node));
}
for(i = internalPartitionHead; i < array_n(nodesArray); i++) {
node = array_fetch(Ntk_Node_t *, nodesArray, i);
array_insert_last(char *, *roots, Ntk_NodeReadName(node));
}
}
Here is the call graph for this function:
Here is the caller graph for this function:
| array_t* SimSimInitDataFormat | ( | Sim_Sim_t * | sim | ) |
Function********************************************************************
Synopsis [Returns an integer array that will contain the size of the largest value of a node in the nodesArray.]
Description [Returns an integer array that will contain the size of the largest value of a node in the nodesArray. It is the responsibility of the user to free the returned array.]
SideEffects []
Definition at line 234 of file simUtil.c.
{
int i, j;
int size;
int maxSize;
int numValue;
boolean symbolic;
Ntk_Node_t *node;
Var_Variable_t *var;
array_t *formatArray = array_alloc(int, 0);
for (j = 0; j < array_n(sim->nodesArray); j++) {
node = array_fetch(Ntk_Node_t *, sim->nodesArray, j);
var = Ntk_NodeReadVariable(node);
symbolic = Var_VariableTestIsSymbolic(var);
numValue = Var_VariableReadNumValues(var);
maxSize = 0;
if (symbolic) {
for (i = 0; i < numValue; i++) {
size = strlen(Var_VariableReadSymbolicValueFromIndex(var, i));
if (size > maxSize) {
maxSize = size;
}
}
}
else { /* Binary or enumertive type */
while(numValue != 0) {
maxSize++;
numValue = numValue/10;
}
}
array_insert_last(int, formatArray, maxSize);
}
return(formatArray);
}
Here is the call graph for this function:
Here is the caller graph for this function:
| mdd_t* SimSimVectorBuildMdd | ( | Sim_Sim_t * | sim, |
| array_t * | vector, | ||
| array_t * | partitionVector | ||
| ) |
Function********************************************************************
Synopsis [Builds the mdd of a simulation vector.]
Description [Builds the mdd of a simulation vector from an array of integers. The length of this array should be equal to the number of combinational inputs in the sim structure. The ith integer of this array gives the value of the ith node in the sim structure's nodesArray.]
SideEffects []
Definition at line 394 of file simUtil.c.
{
int i;
int value;
mdd_t *mddMinterm;
Ntk_Node_t *node;
mdd_t *literalMdd;
mdd_t *tmpMdd;
Ntk_Network_t *network = sim->network;
mdd_manager *mddManager = Ntk_NetworkReadMddManager(network);
mddMinterm = mdd_one(mddManager);
for(i = 0; i < sim->internalPartitionHead; i++) { /* For every combinational input */
node = array_fetch(Ntk_Node_t *, sim->nodesArray, i);
value = array_fetch(int, vector, i);
/* LiteralMdd will represent the mdd of "Node-variable = value" */
literalMdd = mdd_eq_c(mddManager, Ntk_NodeReadMddId(node), value);
tmpMdd = mdd_and(literalMdd, mddMinterm, 1, 1);
mdd_free(mddMinterm);
mdd_free(literalMdd);
mddMinterm = tmpMdd;
}
for(i = 0; i < array_n(partitionVector); i++) { /* For every internal Partition node */
node = array_fetch(Ntk_Node_t *, sim->nodesArray, i + sim->internalPartitionHead);
value = array_fetch(int, partitionVector, i);
/* LiteralMdd will represent the mdd of "Node-variable = value" */
literalMdd = mdd_eq_c(mddManager, Ntk_NodeReadMddId(node), value);
tmpMdd = mdd_and(literalMdd, mddMinterm, 1, 1);
mdd_free(mddMinterm);
mdd_free(literalMdd);
mddMinterm = tmpMdd;
}
return(mddMinterm);
}
Here is the call graph for this function:
Here is the caller graph for this function:
| void SimSimVectorFillCurrentState | ( | Sim_Sim_t * | sim, |
| int | n | ||
| ) |
Function********************************************************************
Synopsis [Does a copy of the nextState values to the currentState of the next simulation vector.]
Description [Does a copy of the nextState values to the currentState of the next simulation vector. The current vector must contain the nextState values. The next vector must not contain already a currentState value.]
SideEffects []
Definition at line 284 of file simUtil.c.
{
int i;
array_t *currentVector = array_fetch(array_t *, sim->vectorArray, n-1);
array_t *nextVector = array_fetch(array_t *, sim->vectorArray, n);
for (i = sim->nextStateHead; i < sim->outputHead; i++) {
/* We assume nextVector contains only the inputs : insert_last is convenient */
int value = array_fetch(int, currentVector, i);
array_insert_last(int, nextVector, value);
}
}
Here is the caller graph for this function:
| void SimStringPrint | ( | FILE * | fp, |
| char * | string, | ||
| int | len | ||
| ) |
Function********************************************************************
Synopsis [Print a string according to a given format.]
Description [Print a string according to a given format. The output file must be valid. The string is formated according to len. If len > strlen(string), then blanks are added]
SideEffects []
Definition at line 207 of file simUtil.c.
{
int i;
fprintf(fp, "%s", string);
for(i = strlen(string); i < len; i++) {
fprintf(fp, " ");
}
fprintf(fp, " ");
}
Here is the caller graph for this function:
| boolean SimTestPartInTermsOfCI | ( | Sim_Sim_t * | sim | ) |
Function********************************************************************
Synopsis [Tests if the partition is in terms of CIs alone, in case internal partition nodes are present.]
Description [ Returns 1 if internal nodes are present and the partition is in terms of only combinational inputs (and constants)]
SideEffects []
Definition at line 137 of file simUtil.c.
{
int j, k, value, mddId;
Ntk_Node_t *node, *supportNode;
Mvf_Function_t *mvFunction;
array_t *mddIdArray;
/* if there are no internal nodes, return FALSE. This allows
simulation to proceed when partition method inout is used.
*/
if(sim->internalPartitionHead == sim->nextStateHead){
return FALSE;
}
for (j = sim->nextStateHead; j < array_n(sim->nodesArray); j++) {
node = array_fetch(Ntk_Node_t *, sim->nodesArray, j);
(void) st_lookup(sim->nodeToMvfTable, (char *) node, &mvFunction);
mddIdArray = Mvf_FunctionComputeSupport(mvFunction,
Ntk_NetworkReadMddManager(sim->network), &value);
if(mddIdArray != NIL(array_t)){
for(k = 0; k < array_n(mddIdArray); k++){
mddId = array_fetch(int, mddIdArray, k);
supportNode = Ntk_NetworkFindNodeByMddId(sim->network, mddId);
if(!Ntk_NodeTestIsCombInput(supportNode)){
array_free(mddIdArray);
return FALSE;
}
}
array_free(mddIdArray);
}/* if array not nil */
}/* for all nodes */
return TRUE;
}
Here is the call graph for this function:
Here is the caller graph for this function:
Variable Documentation
char rcsid [] UNUSED = "$Id: simUtil.c,v 1.8 2005/04/26 19:10:09 jinh Exp $" [static] |
CFile***********************************************************************
FileName [simUtil.c]
PackageName [sim]
Synopsis [Basic useful functions for the sim package.]
Author [Shaker Sarwary and Tom Shiple]
Copyright [Copyright (c) 1994-1996 The Regents of the Univ. of California. All rights reserved.
Permission is hereby granted, without written agreement and without license or royalty fees, to use, copy, modify, and distribute this software and its documentation for any purpose, provided that the above copyright notice and the following two paragraphs appear in all copies of this software.
IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE UNIVERSITY OF CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND THE UNIVERSITY OF CALIFORNIA HAS NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.]
