fsm.h File Reference

Contains functions for determining/reporting FSM coverage. More...

#include <stdio.h>
#include "defines.h"

Go to the source code of this file.

Functions
fsm *	fsm_create (expression *from_state, expression *to_state, int line, bool exclude)
	Creates and initializes new FSM structure.
void	fsm_add_arc (fsm *table, expression *from_state, expression *to_state)
	Adds new FSM arc structure to specified FSMs arc list.
void	fsm_create_tables (fsm *table)
	Sets sizes of tables in specified FSM structure.
void	fsm_db_write (fsm *table, FILE *file, bool ids_issued)
	Outputs contents of specified FSM to CDD file.
void	fsm_db_read (char **line, func_unit *funit)
	Reads in contents of specified FSM.
void	fsm_db_merge (fsm *base, char **line)
	Reads and merges two FSMs, placing result into base FSM.
void	fsm_merge (fsm *base, fsm *other)
	Merges two FSMs, placing the result into the base FSM.
void	fsm_table_set (expression *expr, const sim_time *time)
	Sets the bit in set table based on the values of last and curr.
void	fsm_get_stats (fsm_link *table, int *state_hit, int *state_total, int *arc_hit, int *arc_total, int *arc_excluded)
	Gathers statistics about the current FSM.
void	fsm_get_funit_summary (func_unit *funit, int *hit, int *excluded, int *total)
	Retrieves the FSM summary information for the specified functional unit.
void	fsm_get_inst_summary (funit_inst *inst, int *hit, int *excluded, int *total)
	Retrieves the FSM summary information for the specified functional unit.
void	fsm_collect (func_unit *funit, int cov, sig_link **sig_head, sig_link **sig_tail, int **expr_ids, int **excludes)
	Retrieves covered or uncovered FSMs from the specified functional unit.
void	fsm_get_coverage (func_unit *funit, int expr_id, char ***total_fr_states, unsigned int *total_fr_state_num, char ***total_to_states, unsigned int *total_to_state_num, char ***hit_fr_states, unsigned int *hit_fr_state_num, char ***hit_to_states, unsigned int *hit_to_state_num, char ***total_from_arcs, char ***total_to_arcs, int **total_ids, int **excludes, char ***reasons, int *total_arc_num, char ***hit_from_arcs, char ***hit_to_arcs, int *hit_arc_num, char ***input_state, unsigned int *input_size, char ***output_state, unsigned int *output_size)
	Collects all coverage information for the specified FSM.
void	fsm_report (FILE *ofile, bool verbose)
	Generates report output for FSM coverage.
void	fsm_dealloc (fsm *table)
	Deallocates specified FSM structure.

---

Detailed Description

Contains functions for determining/reporting FSM coverage.

Author:

Trevor Williams (phase1geo@gmail.com)

Date:

3/31/2002

---

Function Documentation

void fsm_add_arc	(	fsm *	table,
		expression *	from_state,
		expression *	to_state
	)

Adds new FSM arc structure to specified FSMs arc list.

Parameters:

	table	Pointer to FSM structure to add new arc to
	from_state	Pointer to from_state expression to add
	to_state	Pointer to to_state expression to add

References fsm_s::arc_head, fsm_s::arc_tail, fsm_arc_s::from_state, malloc_safe, fsm_arc_s::next, PROFILE, PROFILE_END, and fsm_arc_s::to_state.

Referenced by fsm_arg_parse_trans().

  { PROFILE(FSM_ADD_ARC);

  fsm_arc* arc;  /* Pointer to newly created FSM arc structure */

  /* Create an initialize specified arc */
  arc             = (fsm_arc*)malloc_safe( sizeof( fsm_arc ) );
  arc->from_state = from_state;
  arc->to_state   = to_state;
  arc->next       = NULL;

  /* Add new arc to specified FSM structure */
  if( table->arc_head == NULL ) {
    table->arc_head = table->arc_tail = arc;
  } else {
    table->arc_tail->next = arc;
    table->arc_tail       = arc;
  }

  PROFILE_END;

}

void fsm_collect	(	func_unit *	funit,
		int	cov,
		sig_link **	sig_head,
		sig_link **	sig_tail,
		int **	expr_ids,
		int **	excludes
	)

Retrieves covered or uncovered FSMs from the specified functional unit.

Gathers the covered or uncovered FSM information, storing their expressions in the sig_head/sig_tail signal list. Used by the GUI for verbose FSM output.

Parameters:

	funit	Pointer to functional unit
	cov	Specifies if we are attempting to get uncovered (0) or covered (1) FSMs
	sig_head	Pointer to the head of the signal list of covered FSM output states
	sig_tail	Pointer to the tail of the signal list of covered FSM output states
	expr_ids	Pointer to array of expression IDs for each uncovered signal
	excludes	Pointer to array of exclude values for each uncovered signal

References arc_are_any_excluded(), arc_get_stats(), fsm_gather_signals(), func_unit_s::fsm_head, expression_s::id, fsm_link_s::next, PROFILE, PROFILE_END, realloc_safe, fsm_s::table, fsm_link_s::table, and fsm_s::to_state.

  { PROFILE(FSM_COLLECT);

  fsm_link* curr_fsm;  /* Pointer to current FSM link being evaluated */
  int       size = 0;  /* Number of expressions IDs stored in expr_ids array */

  /* Initialize list pointers */
  *sig_tail = *sig_head = NULL;
  *expr_ids = *excludes = NULL;

  curr_fsm = funit->fsm_head;
  while( curr_fsm != NULL ) {

    /* Get the state and arc statistics */
    int state_hit    = 0;
    int state_total  = 0;
    int arc_hit      = 0;
    int arc_total    = 0;
    int arc_excluded = 0;
    arc_get_stats( curr_fsm->table->table, &state_hit, &state_total, &arc_hit, &arc_total, &arc_excluded );

    /* Allocate some more memory for the excluded array */
    *excludes = (int*)realloc_safe( *excludes, (sizeof( int ) * size), (sizeof( int ) * (size + 1)) );

    /* If the total number of arcs is not known, consider this FSM as uncovered */
    if( (cov == 0) && ((arc_total == -1) || (arc_total != arc_hit)) ) {
      (*excludes)[size] = 0;
      fsm_gather_signals( curr_fsm->table->to_state, sig_head, sig_tail, curr_fsm->table->to_state->id, expr_ids, &size );
    } else {
      if( (cov == 0) && arc_are_any_excluded( curr_fsm->table->table ) ) {
        fsm_gather_signals( curr_fsm->table->to_state, sig_head, sig_tail, curr_fsm->table->to_state->id, expr_ids, &size );
        (*excludes)[size] = 1;
      } else if( cov == 1 ) {
        fsm_gather_signals( curr_fsm->table->to_state, sig_head, sig_tail, -1, expr_ids, &size );
      }
    }

    curr_fsm = curr_fsm->next;

  }

  PROFILE_END;

}

fsm* fsm_create	(	expression *	from_state,
		expression *	to_state,
		int	line,
		bool	exclude
	)

Creates and initializes new FSM structure.

Returns:

Returns a pointer to the newly allocated FSM structure.

Allocates and initializes an FSM structure.

Parameters:

	from_state	Pointer to expression that is input state variable for this FSM
	to_state	Pointer to expression that is output state variable for this FSM
	line	First line of FSM attribute
	exclude	Value to set the exclude bit to

References fsm_s::arc_head, fsm_s::arc_tail, fsm_s::exclude, fsm_s::from_state, fsm_s::line, malloc_safe, fsm_s::name, PROFILE, fsm_s::table, and fsm_s::to_state.

Referenced by fsm_db_read(), fsm_var_add(), and fsm_var_bind_stmt().

  { PROFILE(FSM_CREATE);

  fsm* table;  /* Pointer to newly created FSM */

  table             = (fsm*)malloc_safe( sizeof( fsm ) );
  table->name       = NULL;
  table->line       = line;
  table->from_state = from_state;
  table->to_state   = to_state;
  table->arc_head   = NULL;
  table->arc_tail   = NULL;
  table->table      = NULL;
  table->exclude    = exclude;

  return( table );

}

void fsm_create_tables

(

fsm *

table

)

Sets sizes of tables in specified FSM structure.

After the FSM signals are sized, this function is called to size an FSM structure (allocate memory for its tables) and the associated FSM arc list is parsed, setting the appropriate bit in the valid table.

Parameters:

table

Pointer to FSM structure to set table sizes to

References arc_add(), arc_create(), fsm_s::arc_head, fsm_s::exclude, expression_operate(), FALSE, sim_time_s::final, fsm_arc_s::from_state, sim_time_s::full, sim_time_s::hi, sim_time_s::lo, fsm_arc_s::next, PROFILE, PROFILE_END, fsm_s::table, fsm_arc_s::to_state, fsm_s::to_state, TRUE, expression_s::value, and vector_s::width.

Referenced by funit_size_elements().

  { PROFILE(FSM_CREATE_TABLES);

  fsm_arc* curr_arc;    /* Pointer to current FSM arc structure */
  bool     set = TRUE;  /* Specifies if specified bit was set */
  sim_time time;        /* Current simulation time */

  /* Create the FSM arc transition table */
  assert( table != NULL );
  assert( table->to_state != NULL );
  assert( table->to_state->value != NULL );
  assert( table->table == NULL );
  table->table = arc_create( table->to_state->value->width );

  /* Initialize the current time */
  time.lo    = 0;
  time.hi    = 0;
  time.full  = 0;
  time.final = FALSE;

  /* Set valid table */
  curr_arc = table->arc_head;
  while( (curr_arc != NULL) && set ) {

    /* Evaluate from and to state expressions */
    (void)expression_operate( curr_arc->from_state, NULL, &time );
    (void)expression_operate( curr_arc->to_state, NULL, &time );

    /* Set table entry in table, if possible */
    arc_add( table->table, curr_arc->from_state->value, curr_arc->to_state->value, 0, table->exclude );

    curr_arc = curr_arc->next;

  } 

  PROFILE_END;

}

void fsm_db_merge	(	fsm *	base,
		char **	line
	)

Reads and merges two FSMs, placing result into base FSM.

Parameters:

	base	Pointer to FSM structure to merge data into.
	line	Pointer to read in line from CDD file to merge.

Exceptions:

anonymous

arc_db_merge Throw

Parses specified line for FSM information and performs merge of the base and in FSMs, placing the resulting merged FSM into the base signal. If the FSMs are found to be unalike (names are different), an error message is displayed to the user. If both FSMs are the same, perform the merge on the FSM's tables.

References arc_db_merge(), FATAL, fsm_s::from_state, print_output(), PROFILE, PROFILE_END, fsm_s::table, Throw, and fsm_s::to_state.

Referenced by funit_db_inst_merge(), and funit_db_mod_merge().

  { PROFILE(FSM_DB_MERGE);

  int fline;       /* First line number of FSM */
  int iid;         /* Input state variable expression ID */
  int oid;         /* Output state variable expression ID */
  int chars_read;  /* Number of characters read from line */
  int is_table;    /* Holds value of is_table signifier */

  assert( base != NULL );
  assert( base->from_state != NULL );
  assert( base->to_state != NULL );

  if( sscanf( *line, "%d %d %d %d%n", &fline, &iid, &oid, &is_table, &chars_read ) == 4 ) {

    *line = *line + chars_read + 1;

    if( is_table == 1 ) {

      arc_db_merge( base->table, line );
          
    }

  } else {

    print_output( "Database being merged is not compatible with the original database.", FATAL, __FILE__, __LINE__ );
    Throw 0;

  }

  PROFILE_END;

}

void fsm_db_read	(	char **	line,
		func_unit *	funit
	)

Reads in contents of specified FSM.

Parameters:

	line	Pointer to current line being read from the CDD file.
	funit	Pointer to current functional unit.

Exceptions:

anonymous

expression_create Throw Throw Throw Throw arc_db_read

Reads in contents of FSM line from CDD file and stores newly created FSM into the specified functional unit.

References arc_db_read(), bind_append_fsm_expr(), Catch_anonymous, exp_link_s::exp, func_unit_s::exp_head, exp_link_find(), EXP_OP_STATIC, expression_create(), FALSE, FATAL, fsm_s::from_state, fsm_create(), fsm_dealloc(), func_unit_s::fsm_head, fsm_link_add(), func_unit_s::fsm_tail, print_output(), PROFILE, PROFILE_END, fsm_s::table, expression_s::table, Throw, fsm_s::to_state, Try, user_msg, USER_MSG_LENGTH, expression_s::value, and vector_dealloc().

Referenced by db_read(), and funit_db_mod_merge().

  { PROFILE(FSM_DB_READ);

  int        fline;       /* First line of FSM attribute */
  int        iexp_id;     /* Input expression ID */
  int        oexp_id;     /* Output expression ID */
  exp_link*  iexpl;       /* Pointer to found state variable */
  exp_link*  oexpl;       /* Pointer to found state variable */
  int        chars_read;  /* Number of characters read from sscanf */
  fsm*       table;       /* Pointer to newly created FSM structure from CDD */
  int        is_table;    /* Holds value of is_table entry of FSM output */
 
  if( sscanf( *line, "%d %d %d %d%n", &fline, &iexp_id, &oexp_id, &is_table, &chars_read ) == 4 ) {

    *line = *line + chars_read + 1;

    if( funit == NULL ) {

      print_output( "Internal error:  FSM in database written before its functional unit", FATAL, __FILE__, __LINE__ );
      Throw 0;

    } else {

      /* Find specified signal */
      if( ((iexpl = exp_link_find( iexp_id, funit->exp_head )) != NULL) &&
          ((oexpl = exp_link_find( oexp_id, funit->exp_head )) != NULL) ) {

        /* Create new FSM */
        table = fsm_create( iexpl->exp, oexpl->exp, fline, FALSE );

        /*
         If the input state variable is the same as the output state variable, create the new expression now.
        */
        if( iexp_id == oexp_id ) {
          Try {
            table->from_state = expression_create( NULL, NULL, EXP_OP_STATIC, FALSE, iexp_id, 0, 0, 0, FALSE );
          } Catch_anonymous {
            fsm_dealloc( table );
            Throw 0;
          }
          vector_dealloc( table->from_state->value );
          bind_append_fsm_expr( table->from_state, iexpl->exp, funit );
        } else {
          table->from_state = iexpl->exp;
        }

        /* Set input/output expression tables to point to this FSM */
        table->from_state->table = table;
        table->to_state->table   = table;
  
        /* Now read in set table */
        if( is_table == 1 ) {

          Try {
            arc_db_read( &(table->table), line );
          } Catch_anonymous {
            fsm_dealloc( table );
            Throw 0;
          }

        }

        /* Add fsm to current functional unit */
        fsm_link_add( table, &(funit->fsm_head), &(funit->fsm_tail) );
 
      } else {

        unsigned int rv = snprintf( user_msg, USER_MSG_LENGTH, "Unable to find state variable expressions (%d, %d) for current FSM", iexp_id, oexp_id );
        assert( rv < USER_MSG_LENGTH );
        print_output( user_msg, FATAL, __FILE__, __LINE__ );
        Throw 0;

      }

    }

  } else {

    print_output( "Unable to parse FSM line in database file.  Unable to read.", FATAL, __FILE__, __LINE__ );
    Throw 0;

  }

  PROFILE_END;

}

void fsm_db_write	(	fsm *	table,
		FILE *	file,
		bool	ids_issued
	)

Outputs contents of specified FSM to CDD file.

Outputs the contents of the specified FSM to the specified CDD file.

Parameters:

	table	Pointer to FSM structure to output
	file	Pointer to file output stream to write to
	ids_issued	Set to TRUE if expression IDs were just issued

References arc_db_write(), arc_dealloc(), DB_TYPE_FSM, expression_get_id(), fsm_s::from_state, fsm_s::line, PROFILE, PROFILE_END, fsm_s::table, and fsm_s::to_state.

Referenced by funit_db_write().

  { PROFILE(FSM_DB_WRITE);

  fprintf( file, "%d %d %d %d ",
    DB_TYPE_FSM,
    table->line,
    expression_get_id( table->from_state, ids_issued ),
    expression_get_id( table->to_state, ids_issued )
  );

  /* Print set table */
  if( table->table != NULL ) {
    fprintf( file, "1 " );
    arc_db_write( table->table, file );

    /* Deallocate the given table after writing it */
    if( table->table != NULL ) {
      arc_dealloc( table->table );
      table->table = NULL;
    }
  } else {
    fprintf( file, "0" );
  }

  fprintf( file, "\n" );

  PROFILE_END;

} 

void fsm_dealloc

(

fsm *

table

)

Deallocates specified FSM structure.

Deallocates all allocated memory for the specified FSM structure.

Parameters:

table

Pointer to FSM structure to deallocate

References arc_dealloc(), fsm_s::arc_head, expression_dealloc(), FALSE, free_safe, fsm_s::from_state, fsm_arc_s::from_state, expression_s::id, fsm_s::name, fsm_arc_s::next, PROFILE, PROFILE_END, fsm_s::table, fsm_s::to_state, and fsm_arc_s::to_state.

Referenced by fsm_db_read(), and fsm_link_delete_list().

  { PROFILE(FSM_DEALLOC);

  fsm_arc* tmp;  /* Temporary pointer to current FSM arc structure to deallocate */

  if( table != NULL ) {

    /* Free name if one was specified */
    if( table->name != NULL ) {
      free_safe( table->name, (strlen( table->name ) + 1) );
    }

    /* Deallocate tables */
    arc_dealloc( table->table );

    /* Deallocate FSM arc structure */
    while( table->arc_head != NULL ) {
      tmp = table->arc_head;
      table->arc_head = table->arc_head->next;
      expression_dealloc( tmp->to_state, FALSE );
      expression_dealloc( tmp->from_state, FALSE );
      free_safe( tmp, sizeof( fsm_arc ) );
    }

    /*
     Deallocate from_state if it is the same expression ID as the to_state expression and is
     not the same expression structure
    */
    if( (table->from_state != NULL)             &&
        (table->to_state != NULL)               &&
        (table->from_state != table->to_state ) &&
        (table->from_state->id == table->to_state->id) ) {
      expression_dealloc( table->from_state, FALSE );
    }

    /* Deallocate this structure */
    free_safe( table, sizeof( fsm ) );
      
  }

  PROFILE_END;

}

void fsm_get_coverage	(	func_unit *	funit,
		int	expr_id,
		char ***	total_fr_states,
		unsigned int *	total_fr_state_num,
		char ***	total_to_states,
		unsigned int *	total_to_state_num,
		char ***	hit_fr_states,
		unsigned int *	hit_fr_state_num,
		char ***	hit_to_states,
		unsigned int *	hit_to_state_num,
		char ***	total_from_arcs,
		char ***	total_to_arcs,
		int **	total_ids,
		int **	excludes,
		char ***	reasons,
		int *	total_arc_num,
		char ***	hit_from_arcs,
		char ***	hit_to_arcs,
		int *	hit_arc_num,
		char ***	input_state,
		unsigned int *	input_size,
		char ***	output_state,
		unsigned int *	output_size
	)

Collects all coverage information for the specified FSM.

Gets the FSM coverage information for the specified FSM in the specified functional unit. Used by the GUI for creating the contents of the verbose FSM viewer.

Parameters:

	funit	Pointer to functional unit
	expr_id	Expression ID of output state expression to find
	total_fr_states	Pointer to a string array containing all possible from states in this FSM
	total_fr_state_num	Pointer to the number of elements in the total_fr_states array
	total_to_states	Pointer to a string array containing all possible to states in this FSM
	total_to_state_num	Pointer to the number of elements in the total_to_states array
	hit_fr_states	Pointer to a string array containing the hit fr_states in this FSM
	hit_fr_state_num	Pointer to the number of elements in the hit_fr_states array
	hit_to_states	Pointer to a string array containing the hit to_states in this FSM
	hit_to_state_num	Pointer to the number of elements in the hit_to_states array
	total_from_arcs	Pointer to a string array containing all possible state transition from states
	total_to_arcs	Pointer to a string array containing all possible state transition to states
	total_ids	Pointer to an integer array containing the arc transition IDs for each transition
	excludes	Pointer to an integer array containing the exclude values for each state transition
	reasons	Pointer to a string array containing exclusion reasons
	total_arc_num	Pointer to the number of elements in both the total_from_arcs, total_to_arcs and excludes arrays
	hit_from_arcs	Pointer to a string array containing the hit state transition from states
	hit_to_arcs	Pointer to a string array containing the hit state transition to states
	hit_arc_num	Pointer to the number of elements in both the hit_from_arcs and hit_to_arcs arrays
	input_state	Pointer to a string array containing the code for the input state expression
	input_size	Pointer to the number of elements stored in the input state array
	output_state	Pointer to a string array containing the code for the output state expression
	output_size	Pointer to the number of elements stored in the output state array

References arc_get_states(), arc_get_transitions(), codegen_gen_expr(), FALSE, free_safe, fsm_s::from_state, func_unit_s::fsm_head, expression_s::id, fsm_link_s::next, expression_s::op, PROFILE, PROFILE_END, fsm_s::table, fsm_link_s::table, fsm_s::to_state, TRUE, expression_s::value, and vector_s::width.

  { PROFILE(FSM_GET_COVERAGE);

  fsm_link*    curr_fsm;
  int*         tmp_ids;
  int*         tmp;
  char**       tmp_reasons;
  unsigned int fr_width;
  unsigned int to_width;

  curr_fsm = funit->fsm_head;
  while( (curr_fsm != NULL) && (curr_fsm->table->to_state->id != expr_id) ) {
    curr_fsm = curr_fsm->next; 
  }

  assert( curr_fsm != NULL );

  fr_width = curr_fsm->table->from_state->value->width;
  to_width = curr_fsm->table->to_state->value->width;

  /* Get state information */
  arc_get_states( total_fr_states, total_fr_state_num, total_to_states, total_to_state_num, curr_fsm->table->table, TRUE, TRUE,  fr_width, to_width ); 
  arc_get_states( hit_fr_states,   hit_fr_state_num,   hit_to_states,   hit_to_state_num,   curr_fsm->table->table, TRUE, FALSE, fr_width, to_width );

  /* Get state transition information */
  arc_get_transitions( total_from_arcs, total_to_arcs, total_ids, excludes, reasons,      total_arc_num, curr_fsm->table->table, funit, TRUE, TRUE,  fr_width, to_width );
  arc_get_transitions( hit_from_arcs,   hit_to_arcs,   &tmp_ids,  &tmp,     &tmp_reasons, hit_arc_num,   curr_fsm->table->table, funit, TRUE, FALSE, fr_width, to_width );

  /* Get input state code */
  codegen_gen_expr( curr_fsm->table->from_state, curr_fsm->table->from_state->op, input_state, input_size, NULL );

  /* Get output state code */
  codegen_gen_expr( curr_fsm->table->to_state, curr_fsm->table->to_state->op, output_state, output_size, NULL );

  /* Deallocate unused state information */
  if( *hit_arc_num > 0 ) {
    unsigned int i;
    free_safe( tmp_ids, (sizeof( int ) * (*hit_arc_num)) );
    free_safe( tmp,     (sizeof( int ) * (*hit_arc_num)) );
    for( i=0; i<(*hit_arc_num); i++ ) {
      free_safe( tmp_reasons[i], (strlen( tmp_reasons[i] ) + 1) );
    }
    free_safe( tmp_reasons, (sizeof( char* ) * (*hit_arc_num)) );
  }

  PROFILE_END;

}

void fsm_get_funit_summary	(	func_unit *	funit,
		int *	hit,
		int *	excluded,
		int *	total
	)

Retrieves the FSM summary information for the specified functional unit.

Parameters:

	funit	Pointer to functional unit
	hit	Pointer to location to store the number of hit state transitions for the specified functional unit
	excluded	Pointer to number of excluded arcs
	total	Pointer to location to store the total number of state transitions for the specified functional unit

References statistic_s::arc_excluded, statistic_s::arc_hit, statistic_s::arc_total, PROFILE, PROFILE_END, and func_unit_s::stat.

  { PROFILE(FSM_GET_FUNIT_SUMMARY);

  *hit      = funit->stat->arc_hit;
  *excluded = funit->stat->arc_excluded;
  *total    = funit->stat->arc_total;

  PROFILE_END;

}

void fsm_get_inst_summary	(	funit_inst *	inst,
		int *	hit,
		int *	excluded,
		int *	total
	)

Retrieves the FSM summary information for the specified functional unit.

Retrieves the FSM summary information for the specified functional unit instance.

Parameters:

	inst	Pointer to functional unit instance
	hit	Pointer to location to store the number of hit state transitions for the specified functional unit
	excluded	Pointer to number of excluded arcs
	total	Pointer to location to store the total number of state transitions for the specified functional unit

References statistic_s::arc_excluded, statistic_s::arc_hit, statistic_s::arc_total, PROFILE, PROFILE_END, and funit_inst_s::stat.

  { PROFILE(FSM_GET_INST_SUMMARY);

  *hit      = inst->stat->arc_hit;
  *excluded = inst->stat->arc_excluded;
  *total    = inst->stat->arc_total;

  PROFILE_END;

}

void fsm_get_stats	(	fsm_link *	table,
		int *	state_hit,
		int *	state_total,
		int *	arc_hit,
		int *	arc_total,
		int *	arc_excluded
	)

Gathers statistics about the current FSM.

Gathers the FSM state and state transition statistics for the given table and assigns this information to the specified pointers.

Parameters:

	table	Pointer to FSM to get statistics from
	state_hit	Number of states reached in this FSM
	state_total	Total number of states within this FSM
	arc_hit	Number of arcs reached in this FSM
	arc_total	Total number of arcs within this FSM
	arc_excluded	Total number of excluded arcs

References arc_get_stats(), fsm_link_s::next, PROFILE, PROFILE_END, fsm_s::table, and fsm_link_s::table.

Referenced by report_gather_funit_stats(), and report_gather_instance_stats().

  { PROFILE(FSM_GET_STATS);

  fsm_link* curr;   /* Pointer to current FSM in table list */

  curr = table;
  while( curr != NULL ) {
    arc_get_stats( curr->table->table, state_hit, state_total, arc_hit, arc_total, arc_excluded );
    curr = curr->next;
  }

  PROFILE_END;

}

void fsm_merge	(	fsm *	base,
		fsm *	other
	)

Merges two FSMs, placing the result into the base FSM.

Merges two FSMs, placing the resulting FSM into the base. This function is called when merging modules for the GUI.

Parameters:

	base	Base FSM to store merged results
	other	Other FSM that will be merged with the base FSM

References arc_merge(), fsm_s::from_state, PROFILE, PROFILE_END, fsm_s::table, and fsm_s::to_state.

Referenced by funit_merge().

  { PROFILE(FSM_MERGE);

  assert( base != NULL );
  assert( base->from_state != NULL );
  assert( base->to_state != NULL );
  assert( other != NULL );
  assert( other->from_state != NULL );
  assert( other->to_state != NULL );

  if( base->table != NULL ) {
    assert( other->table != NULL );
    arc_merge( base->table, other->table );
  }

  PROFILE_END;

}

void fsm_report	(	FILE *	ofile,
		bool	verbose
	)

Generates report output for FSM coverage.

After the design is read into the functional unit hierarchy, parses the hierarchy by functional unit, reporting the FSM coverage for each functional unit encountered. The parent functional unit will specify its own FSM coverage along with a total FSM coverage including its children.

Parameters:

	ofile	Pointer to file to output results to
	verbose	Specifies whether or not to provide verbose information

References curr_db, FALSE, fsm_display_funit_summary(), fsm_display_instance_summary(), fsm_funit_summary(), fsm_funit_verbose(), fsm_instance_summary(), fsm_instance_verbose(), funit_head, inst_link_s::inst, db_s::inst_head, funit_inst_s::name_diff, inst_link_s::next, PROFILE, PROFILE_END, report_covered, report_exclusions, report_instance, and funit_inst_s::suppl.

Referenced by report_generate().

  { PROFILE(FSM_REPORT);

  bool       missed_found  = FALSE;  /* If set to TRUE, FSM cases were found to be missed */
  inst_link* instl;                  /* Pointer to current instance link */
  int        acc_st_hits   = 0;      /* Accumulated number of states hit */
  int        acc_st_total  = 0;      /* Accumulated number of states in design */
  int        acc_arc_hits  = 0;      /* Accumulated number of arcs hit */
  int        acc_arc_total = 0;      /* Accumulated number of arcs in design */

  fprintf( ofile, "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n" );
  fprintf( ofile, "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~   FINITE STATE MACHINE COVERAGE RESULTS   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n" );
  fprintf( ofile, "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n" );

  if( report_instance ) {

    fprintf( ofile, "                                                               State                             Arc\n" );
    fprintf( ofile, "Instance                                          Hit/Miss/Total    Percent hit    Hit/Miss/Total    Percent hit\n" );
    fprintf( ofile, "---------------------------------------------------------------------------------------------------------------------\n" );

    instl = db_list[curr_db]->inst_head;
    while( instl != NULL ) {
      missed_found |= fsm_instance_summary( ofile, instl->inst, (instl->inst->suppl.name_diff ? "<NA>" : "*"), &acc_st_hits, &acc_st_total, &acc_arc_hits, &acc_arc_total );
      instl = instl->next;
    }
    fprintf( ofile, "---------------------------------------------------------------------------------------------------------------------\n" );
    (void)fsm_display_instance_summary( ofile, "Accumulated", acc_st_hits, acc_st_total, acc_arc_hits, acc_arc_total );
   
    if( verbose && (missed_found || report_covered || report_exclusions) ) {
      fprintf( ofile, "---------------------------------------------------------------------------------------------------------------------\n" );
      instl = db_list[curr_db]->inst_head;
      while( instl != NULL ) {
        fsm_instance_verbose( ofile, instl->inst, (instl->inst->suppl.name_diff ? "<NA>" : "*") );
        instl = instl->next;
      }
    }

  } else {

    fprintf( ofile, "                                                               State                             Arc\n" );
    fprintf( ofile, "Module/Task/Function      Filename                Hit/Miss/Total    Percent Hit    Hit/Miss/Total    Percent hit\n" );
    fprintf( ofile, "---------------------------------------------------------------------------------------------------------------------\n" );

    missed_found = fsm_funit_summary( ofile, db_list[curr_db]->funit_head, &acc_st_hits, &acc_st_total, &acc_arc_hits, &acc_arc_total );
    fprintf( ofile, "---------------------------------------------------------------------------------------------------------------------\n" );
    (void)fsm_display_funit_summary( ofile, "Accumulated", "", acc_st_hits, acc_st_total, acc_arc_hits, acc_arc_total );

    if( verbose && (missed_found || report_covered || report_exclusions) ) {
      fprintf( ofile, "---------------------------------------------------------------------------------------------------------------------\n" );
      fsm_funit_verbose( ofile, db_list[curr_db]->funit_head );
    }

  }

  fprintf( ofile, "\n\n" );

  PROFILE_END;

}

void fsm_table_set	(	expression *	expr,
		const sim_time *	time
	)

Sets the bit in set table based on the values of last and curr.

Taking the from and to state signal values, a new table entry is added to the specified FSM structure arc array (if an entry does not already exist in the array).

Parameters:

	expr	Pointer to expression that contains FSM table to modify
	time	Pointer to current simulation time

References arc_add(), fsm_s::exclude, fsm_s::from_state, expression_s::id, PROFILE, PROFILE_END, sim_expr_changed(), fsm_s::table, expression_s::table, fsm_s::to_state, expression_s::value, and vector_copy().

Referenced by expression_operate().

  { PROFILE(FSM_TABLE_SET);

  /* If the expression is the input state expression, make sure that the output state expression is simulated this clock period */
  if( (expr->table->from_state->id == expr->id) && (expr->table->from_state->id != expr->table->to_state->id) ) {

    sim_expr_changed( expr->table->to_state, time );

  /* Otherwise, add the state/state transition */
  } else {

    /* Add the states and state transition */
    arc_add( expr->table->table, expr->table->from_state->value, expr->table->to_state->value, 1, expr->table->exclude );

    /* If from_state was not specified, we need to copy the current contents of to_state to from_state */
    if( expr->table->from_state->id == expr->id ) {
      vector_copy( expr->value, expr->table->from_state->value );
    }

  }

  PROFILE_END;

}