sim.h File Reference

Contains functions for simulation engine. More...

#include "defines.h"

Go to the source code of this file.

Functions
void	sim_display_thread (const thread *thr, bool show_queue, bool endl)
	Displays the given thread to standard output (for debug purposes only).
void	sim_display_active_queue ()
	Displays the current state of the active queue (for debug purposes only).
void	sim_display_delay_queue ()
	Displays the current state of the delay queue (for debug purposes only).
void	sim_display_all_list ()
	Displays the state of all threads.
thread *	sim_current_thread ()
	Returns a pointer to the current thread at the head of the active queue.
void	sim_thread_insert_into_delay_queue (thread *thr, const sim_time *time)
	Inserts the given thread into the delay queue at the given time slot.
void	sim_expr_changed (expression *expr, const sim_time *time)
	Adds specified expression's statement to pre-simulation statement queue.
thread *	sim_add_thread (thread *parent, statement *stmt, func_unit *funit, const sim_time *time)
	Creates a thread for the given statement and adds it to the thread simulation queue.
void	sim_kill_thread_with_funit (func_unit *funit)
	Deallocates thread and removes it from parent and thread queue lists for specified functional unit.
void	sim_thread_push (thread *thr, const sim_time *time)
	Pushes given thread onto the active queue.
bool	sim_expression (expression *expr, thread *thr, const sim_time *time, bool lhs)
	Simulates a given expression tree, only performing needed operations as it traverses the tree.
void	sim_thread (thread *thr, const sim_time *time)
	Simulates one thread until it has either completed or enters a context switch.
bool	sim_simulate (const sim_time *time)
	Simulates current timestep.
void	sim_initialize ()
	Initializes the simulator.
void	sim_stop ()
	Causes the simulation to stop and enter into CLI mode.
void	sim_finish ()
	Causes simulator to finish gracefully.
void	sim_add_nonblock_assign (nonblock_assign *nba, int lhs_lsb, int lhs_msb, int rhs_lsb, int rhs_msb)
	Updates the given non-blocking assign structure and adds it to the non-blocking assignment queue.
void	sim_perform_nba (const sim_time *time)
	Performs non-blocking assignment for currently queued assignment items for the current timestep.
void	sim_dealloc ()
	Deallocates all memory for simulator.

---

Detailed Description

Contains functions for simulation engine.

Author:

Trevor Williams (phase1geo@gmail.com)

Date:

6/20/2002

---

Function Documentation

void sim_add_nonblock_assign	(	nonblock_assign *	nba,
		int	lhs_lsb,
		int	lhs_msb,
		int	rhs_lsb,
		int	rhs_msb
	)

Updates the given non-blocking assign structure and adds it to the non-blocking assignment queue.

Updates and adds the given non-blocking assignment structure to the simulation queue.

Parameters:

	nba	Pointer to non-blocking assignment to updated and add
	lhs_lsb	LSB of left-hand-side vector to assign
	lhs_msb	MSB of left-hand-side vector to assign
	rhs_lsb	LSB of right-hand-side vector to assign from
	rhs_msb	MSB of right-hand-side vector to assign from

References nonblock_assign_s::added, nonblock_assign_s::lhs_lsb, nonblock_assign_s::lhs_msb, nba_queue_curr_size, PROFILE, PROFILE_END, nonblock_assign_s::rhs_lsb, nonblock_assign_s::rhs_msb, and nonblock_assign_s::suppl.

Referenced by expression_assign().

  { PROFILE(SIM_ADD_NONBLOCK_ASSIGN);

  /* Update the non-blocking assignment structure */
  nba->lhs_lsb = lhs_lsb;
  nba->lhs_msb = lhs_msb;
  nba->rhs_lsb = rhs_lsb;
  nba->rhs_msb = rhs_msb;

  /* Add it to the simulation queue (if it has not been already) */
  if( nba->suppl.added == 0 ) {
    nba_queue[nba_queue_curr_size++] = nba;
    nba->suppl.added = 1;
  }

  PROFILE_END;

}

thread* sim_add_thread	(	thread *	parent,
		statement *	stmt,
		func_unit *	funit,
		const sim_time *	time
	)

Creates a thread for the given statement and adds it to the thread simulation queue.

Returns:

Returns the pointer to the thread that was added to the active queue (if one was added).

Creates a new thread with the given information and adds the thread to the active queue to run. Returns a pointer to the newly created thread for joining/running purposes.

Parameters:

	parent	Pointer to parent thread of the new thread to create (set to NULL if there is no parent thread)
	stmt	Pointer to head statement to have new thread point to
	funit	Pointer to functional unit that is creating this thread
	time	Pointer to current simulation time

References thread_s::active_children, thread_s::all, thread_s::curr, thread_s::curr_time, debug_mode, esuppl_u::eval_t, statement_s::exp, EXP_OP_ALWAYS_COMB, EXP_OP_ALWAYS_LATCH, FALSE, sim_time_s::final, flag_use_command_line_debug, sim_time_s::full, sim_time_s::hi, sim_time_s::lo, expression_s::op, thread_s::parent, esuppl_u::part, thread_s::part, statement_s::part, PROFILE, PROFILE_END, thread_s::queue_next, thread_s::queue_prev, expression_s::right, sim_create_thread(), sim_display_active_queue(), sim_display_all_list(), sim_display_thread(), sim_thread_insert_into_delay_queue(), expression_s::suppl, thread_s::suppl, statement_s::suppl, THR_ST_ACTIVE, and TRUE.

Referenced by expression_op_func__fork(), expression_op_func__func_call(), expression_op_func__nb_call(), expression_op_func__task_call(), and statement_db_read().

  { PROFILE(SIM_ADD_THREAD);

  thread* thr = NULL;  /* Pointer to added thread */

  /* Only add expression if it is the head statement of its statement block */
  if( stmt->suppl.part.head == 1 ) {

    /* Create thread, if needed */
    thr = sim_create_thread( parent, stmt, funit );

    /* Initialize thread runtime components */
    thr->suppl.all       = 0;
    thr->active_children = 0;
    thr->queue_prev      = NULL;
    thr->queue_next      = NULL;

    /*
     If the parent thread is specified, update our current time, increment the number of active children in the parent
     and add ourselves between the parent thread and its next pointer.
    */
    if( thr->parent != NULL ) {

      thr->curr_time = thr->parent->curr_time;
      thr->parent->active_children++;

      /* Place ourselves between the parent and its queue_next pointer */
      thr->queue_next = thr->parent->queue_next;
      thr->parent->queue_next = thr;
      if( thr->queue_next == NULL ) {
        active_tail = thr;
      } else {
        thr->queue_next->queue_prev = thr;
      }
      thr->queue_prev = thr->parent;
      thr->suppl.part.state = THR_ST_ACTIVE;    /* We will place the thread immediately into the active queue */

    } else {

      thr->curr_time = *time;

      /*
       If this statement is an always_comb or always_latch, add it to the delay list and change its right
       expression so that it will be executed at time 0 after all initial and always blocks have completed
      */
      if( (thr->curr->exp->op == EXP_OP_ALWAYS_COMB) || (thr->curr->exp->op == EXP_OP_ALWAYS_LATCH) ) {

        sim_time tmp_time;

        /* Add this thread into the delay queue at time 0 */
        tmp_time.lo    = 0;
        tmp_time.hi    = 0;
        tmp_time.full  = 0LL;
        tmp_time.final = FALSE;
        sim_thread_insert_into_delay_queue( thr, &tmp_time );

        /* Specify that this block should be evaluated */
        thr->curr->exp->right->suppl.part.eval_t = 1;

      } else {

        /* If the statement block is specified as a final block, add it to the end of the delay queue */
        if( thr->curr->suppl.part.final == 1 ) {

          sim_time tmp_time;

          tmp_time.lo    = 0xffffffff;
          tmp_time.hi    = 0xffffffff;
          tmp_time.full  = UINT64(0xffffffffffffffff);
          tmp_time.final = TRUE;
          sim_thread_insert_into_delay_queue( thr, &tmp_time );

        /* Otherwise, add it to the active thread list */
        } else {

          if( active_head == NULL ) {
            active_head = active_tail = thr;
          } else {
            thr->queue_prev         = active_tail;
            active_tail->queue_next = thr;
            active_tail             = thr;
          }
          thr->suppl.part.state = THR_ST_ACTIVE;

        }

      }
 
    }

#ifdef DEBUG_MODE
    if( debug_mode && !flag_use_command_line_debug ) {
      printf( "Adding thread: " );
      sim_display_thread( thr, FALSE, TRUE );
      printf( "After thread is added to active queue...\n" );
      sim_display_active_queue();
      sim_display_all_list();
    }
#endif

  }

  PROFILE_END;

  return( thr );

}

thread* sim_current_thread

(

)

Returns a pointer to the current thread at the head of the active queue.

Returns:

Returns a pointer to the current head of the active thread queue.

References PROFILE.

                             { PROFILE(SIM_CURRENT_THREAD);

  return( active_head );

}

void sim_dealloc

(

)

Deallocates all memory for simulator.

Deallocates all allocated memory for simulation code.

References thread_s::all_next, cli_debug_mode, exp_link_delete_list(), FALSE, free_safe, nba_queue_size, PROFILE, and PROFILE_END.

Referenced by covered_end_of_sim(), parse_and_score_dumpfile(), and parse_design().

                   { PROFILE(SIM_DEALLOC);

  thread* tmp;  /* Temporary thread pointer */

  /* Deallocate each thread in the all_threads array */
  while( all_head != NULL ) {
    tmp = all_head;
    all_head = all_head->all_next;
    free_safe( tmp, sizeof( thread ) );
  }

  all_head     = all_tail     = all_next = NULL;
  active_head  = active_tail  = NULL;
  delayed_head = delayed_tail = NULL;

  /* Deallocate all static expressions, if there are any */
  exp_link_delete_list( static_expr_head, FALSE );

  /* Deallocate the non-blocking assignment queue */
  free_safe( nba_queue, (sizeof( nonblock_assign ) * nba_queue_size) );

#ifdef DEBUG_MODE
#ifndef VPI_ONLY
  /* Clear CLI debug mode */
  cli_debug_mode = FALSE;
#endif
#endif

  PROFILE_END;

}

void sim_display_active_queue

(

)

Displays the current state of the active queue (for debug purposes only).

References sim_display_queue().

Referenced by sim_add_thread(), sim_kill_thread(), sim_thread_pop_head(), and sim_thread_push().

                                {

  sim_display_queue( active_head, active_tail );

}

void sim_display_all_list

(

)

Displays the state of all threads.

Displays the current state of the all_threads list (for debug purposes only).

References thread_s::all_next, FALSE, and sim_display_thread().

Referenced by sim_add_thread(), sim_kill_thread(), sim_thread_insert_into_delay_queue(), and sim_thread_push().

                            {

  thread* thr;  /* Pointer to current thread */

  printf( "ALL THREADS:\n" );

  thr = all_head;
  while( thr != NULL ) {
    sim_display_thread( thr, FALSE, FALSE );
    if( thr == all_head ) {
      printf( "H" );
    }
    if( thr == all_tail ) {
      printf( "T" );
    }
    if( thr == all_next ) {
      printf( "N" );
    }
    printf( "\n" );
    thr = thr->all_next;
  }

}

void sim_display_delay_queue

(

)

Displays the current state of the delay queue (for debug purposes only).

References sim_display_queue().

Referenced by sim_simulate(), and sim_thread_insert_into_delay_queue().

                               {

  sim_display_queue( delayed_head, delayed_tail );

}

void sim_display_thread	(	const thread *	thr,
		bool	show_queue,
		bool	endl
	)

Displays the given thread to standard output (for debug purposes only).

Displays the contents of the given thread to standard output.

Parameters:

	thr	Pointer to thread to display to standard output
	show_queue	If set to TRUE, displays queue_prev/queue_next; otherwise, displays all_prev/all_next
	endl	If set to TRUE, prints a newline character

References thread_s::all_next, thread_s::all_prev, thread_s::curr, thread_s::curr_time, statement_s::exp, expression_string_op(), sim_time_s::full, expression_s::id, expression_s::line, expression_s::op, thread_s::parent, thread_s::part, thread_s::queue_next, thread_s::queue_prev, thread_s::suppl, and thread_state_str.

Referenced by sim_add_thread(), sim_display_all_list(), and sim_display_queue().

  {

  if( !endl ) {
    printf( "    " );
  }

  /*@-duplicatequals -formatcode -formattype@*/
  printf( "time %" FMT64 "u, ", thr->curr_time.full );
  /*@=duplicatequals =formatcode =formattype@*/

  if( thr->curr == NULL ) {
    printf( "stmt NONE, " );
  } else {
    printf( "stmt %d, ", thr->curr->exp->id );
    printf( "%s, ", expression_string_op( thr->curr->exp->op ) );
    printf( "line %d, ", thr->curr->exp->line );
  }

  printf( "state %s ", thread_state_str[thr->suppl.part.state] );
  printf( "(%p, ", thr );
  printf( "parent=%p, ", thr->parent );
  printf( "prev=%p, ", (show_queue ? thr->queue_prev : thr->all_prev) );
  printf( "next=%p)  ", (show_queue ? thr->queue_next : thr->all_next) );

  if( endl ) {
    printf( "\n" );
  }

}

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

Adds specified expression's statement to pre-simulation statement queue.

Traverses up expression tree pointed to by leaf node expr, setting the CHANGED bits as it reaches the root expression. When the root expression is found, the statement pointed to by the root's parent pointer is added to the pre-simulation statement queue for simulation at the end of the timestep. If, upon traversing the tree, an expression is found to already be have a CHANGED bit set, we know that the statement has already been added, so stop here and do not add the statement again.

Parameters:

	expr	Pointer to expression that contains a changed signal value
	time	Specifies current simulation time for the thread to push

References DEBUG, debug_mode, ESUPPL_IS_LEFT_CHANGED, ESUPPL_IS_RIGHT_CHANGED, ESUPPL_IS_ROOT, EXP_OP_COND, expr_stmt_u::expr, expression_string_op(), sim_time_s::full, statement_s::funit, funit_push_threads(), expression_s::id, expression_s::left, esuppl_u::left_changed, expression_s::line, expression_s::op, expression_s::parent, esuppl_u::part, print_output(), PROFILE, PROFILE_END, esuppl_u::right_changed, expr_stmt_u::stmt, expression_s::suppl, user_msg, and USER_MSG_LENGTH.

Referenced by fsm_table_set(), sim_add_statics(), and vsignal_propagate().

  { PROFILE(SIM_EXPR_CHANGED);

  assert( expr != NULL );

  /* Set my left_changed bit to indicate to sim_expression that it should evaluate me */
  expr->suppl.part.left_changed = 1;

  while( ESUPPL_IS_ROOT( expr->suppl ) == 0 ) {

    expression* parent = expr->parent->expr;

#ifdef DEBUG_MODE
    if( debug_mode ) {
      unsigned int rv = snprintf( user_msg, USER_MSG_LENGTH, "In sim_expr_changed, expr %d, op %s, line %d, left_changed: %d, right_changed: %d, time: %" FMT64 "u",
                                  expr->id, expression_string_op( expr->op ), expr->line,
                                  ESUPPL_IS_LEFT_CHANGED( expr->suppl ),
                                  ESUPPL_IS_RIGHT_CHANGED( expr->suppl ),
                                  time->full );
      assert( rv < USER_MSG_LENGTH );
      print_output( user_msg, DEBUG, __FILE__, __LINE__ );
    }
#endif

    /* If our expression is on the left of the parent, set the left_changed as needed */
    if( (parent->left != NULL) && (parent->left->id == expr->id) ) {
      
      /* If the bit we need to set is already set, stop iterating up tree */
      if( ESUPPL_IS_LEFT_CHANGED( parent->suppl ) == 1 ) {
        break;
      } else {
        parent->suppl.part.left_changed = 1;
        if( parent->op == EXP_OP_COND ) {
          parent->suppl.part.right_changed = 1;
        }
      }

    /* Otherwise, we assume that we match the right side */
    } else {

      /* If the bit we need to set is already set, stop iterating up tree */
      if( ESUPPL_IS_RIGHT_CHANGED( parent->suppl ) == 1 ) {
        break;
      } else {
        parent->suppl.part.right_changed = 1;
      }

    }

    expr = parent;

  }

  /* If we reached the root expression, push our thread onto the active queue */
  if( (ESUPPL_IS_ROOT( expr->suppl ) == 1) && (expr->parent->stmt != NULL) ) {

#ifdef DEBUG_MODE
    if( debug_mode ) {
      unsigned int rv = snprintf( user_msg, USER_MSG_LENGTH, "In sim_expr_changed, expr %d, op %s, line %d, left_changed: %d, right_changed: %d, time: %" FMT64 "u",
                                  expr->id, expression_string_op( expr->op ), expr->line,
                                  ESUPPL_IS_LEFT_CHANGED( expr->suppl ),
                                  ESUPPL_IS_RIGHT_CHANGED( expr->suppl ),
                                  time->full );
      assert( rv < USER_MSG_LENGTH );
      print_output( user_msg, DEBUG, __FILE__, __LINE__ );
    }
#endif

    funit_push_threads( expr->parent->stmt->funit, expr->parent->stmt, time );

  }

  PROFILE_END;

}

bool sim_expression	(	expression *	expr,
		thread *	thr,
		const sim_time *	time,
		bool	lhs
	)

Simulates a given expression tree, only performing needed operations as it traverses the tree.

Returns:

Returns TRUE if this expression has changed value from previous sim; otherwise, returns FALSE.

Recursively traverses specified expression tree, following the ESUPPL_IS_LEFT_CHANGED and ESUPPL_IS_RIGHT_CHANGED bits in the supplemental field. Once an expression is found that has neither bit set, perform the expression operation and move back up the tree. Once both left and right children have calculated values, perform the expression operation for the current expression, clear both changed bits and return.

Parameters:

	expr	Pointer to expression to simulate
	thr	Pointer to current thread that is being simulated
	time	Pointer to current simulation time
	lhs	Specifies if we should only traverse LHS expressions or RHS expressions

References esuppl_u::clear_changed, DEBUG, debug_mode, ESUPPL_IS_LEFT_CHANGED, ESUPPL_IS_LHS, ESUPPL_IS_RIGHT_CHANGED, ESUPPL_IS_ROOT, EXP_OP_CASE, EXP_OP_CASEX, EXP_OP_CASEZ, EXP_OP_DELAY, EXP_OP_DLY_OP, expression_operate(), FALSE, expression_s::id, expression_s::left, esuppl_u::left_changed, expression_s::op, expression_s::parent, statement_s::part, thread_s::part, esuppl_u::part, print_output(), PROFILE, PROFILE_END, expression_s::right, esuppl_u::right_changed, sim_expression(), expr_stmt_u::stmt, statement_s::suppl, thread_s::suppl, expression_s::suppl, expression_s::table, TRUE, user_msg, and USER_MSG_LENGTH.

Referenced by expression_assign(), expression_op_func__add_a(), expression_op_func__and_a(), expression_op_func__arshift_a(), expression_op_func__divide_a(), expression_op_func__lshift_a(), expression_op_func__mod_a(), expression_op_func__multiply_a(), expression_op_func__or_a(), expression_op_func__rshift_a(), expression_op_func__sub_a(), expression_op_func__xor_a(), sim_expression(), and sim_thread().

  { PROFILE(SIM_EXPRESSION);

  bool retval        = FALSE;  /* Return value for this function */
  bool left_changed  = FALSE;  /* Signifies if left expression tree has changed value */
  bool right_changed = FALSE;  /* Signifies if right expression tree has changed value */

  assert( expr != NULL );

  /* If our LHS mode matches the needed LHS mode, continue */
  if( ESUPPL_IS_LHS( expr->suppl ) == lhs ) {

#ifdef DEBUG_MODE
    if( debug_mode ) {
      unsigned int rv = snprintf( user_msg, USER_MSG_LENGTH, "    In sim_expression %d, left_changed %d, right_changed %d, thread %p",
                                  expr->id, ESUPPL_IS_LEFT_CHANGED( expr->suppl ), ESUPPL_IS_RIGHT_CHANGED( expr->suppl ), thr );
      assert( rv < USER_MSG_LENGTH );
      print_output( user_msg, DEBUG, __FILE__, __LINE__ );
    }
#endif

    /* Traverse left child expression if it has changed */
    if( ((ESUPPL_IS_LEFT_CHANGED( expr->suppl ) == 1) ||
         (expr->op == EXP_OP_CASE)                    ||
         (expr->op == EXP_OP_CASEX)                   ||
         (expr->op == EXP_OP_CASEZ)) &&
        ((expr->op != EXP_OP_DLY_OP) || (expr->left == NULL) || (expr->left->op != EXP_OP_DELAY)) ) {

      /* Simulate the left expression if it has changed */
      if( expr->left != NULL ) {
        expr->suppl.part.left_changed = expr->suppl.part.clear_changed;
        left_changed = sim_expression( expr->left, thr, time, lhs );
      } else {
        expr->suppl.part.left_changed = 0;
        left_changed                  = TRUE;
      }

    }

    /* Traverse right child expression if it has changed */
    if( (ESUPPL_IS_RIGHT_CHANGED( expr->suppl ) == 1) &&
        ((expr->op != EXP_OP_DLY_OP) || !thr->suppl.part.exec_first) ) {
  
      /* Simulate the right expression if it has changed */
      if( expr->right != NULL ) {
        expr->suppl.part.right_changed = expr->suppl.part.clear_changed;
        right_changed = sim_expression( expr->right, thr, time, lhs );
      } else {
        expr->suppl.part.right_changed = 0;
        right_changed                  = TRUE;
      }

    }

    /*
     Now perform expression operation for this expression if left or right
     expressions trees have changed.
    */
    if( (ESUPPL_IS_ROOT( expr->suppl ) == 0) || (expr->parent->stmt == NULL) || (expr->parent->stmt->suppl.part.cont == 0) || left_changed || right_changed || (expr->table != NULL) ) {
      retval = expression_operate( expr, thr, time );
    }

  }

  PROFILE_END;

  return( retval );

}

void sim_finish

(

)

Causes simulator to finish gracefully.

Causes the simulator to finish gracefully.

References FALSE, PROFILE, PROFILE_END, and simulate.

Referenced by expression_op_func__finish().

                  { PROFILE(SIM_FINISH);

  simulate = FALSE;

  PROFILE_END;

}

void sim_initialize

(

)

Initializes the simulator.

Allocates thread arrays for simulation and initializes the contents of the active_threads array.

References cli_ctrl_c(), cli_debug_mode, debug_mode, flag_use_command_line_debug, malloc_safe, nba_queue_curr_size, nba_queue_size, PROFILE, PROFILE_END, and sim_add_statics().

Referenced by covered_sim_calltf(), and parse_and_score_dumpfile().

                      { PROFILE(SIM_INITIALIZE);

  /* Create non-blocking assignment queue */
  if( nba_queue_size > 0 ) {
    nba_queue           = (nonblock_assign**)malloc_safe( sizeof( nonblock_assign ) * nba_queue_size );
    nba_queue_curr_size = 0;
  }

  /* Add static values */
  sim_add_statics();

#ifdef DEBUG_MODE
#ifndef VPI_ONLY
  /* Set the CLI debug mode to the value of the general debug mode */
  cli_debug_mode = debug_mode;

  /* Add a signal handler for Ctrl-C if we are running in CLI mode */
  if( flag_use_command_line_debug ) {
    signal( SIGINT, cli_ctrl_c );
  }
#endif
#endif

  PROFILE_END;

}

void sim_kill_thread_with_funit

(

func_unit *

funit

)

Deallocates thread and removes it from parent and thread queue lists for specified functional unit.

Searches the current state of the active queue for the thread containing the specified head statement. If a thread was found to match, kill it. This function is called whenever the DISABLE statement is run.

Parameters:

funit

Pointer to functional unit of thread to kill

References thread_s::all_next, thread_s::funit, funit_is_child_of(), thread_s::part, PROFILE, PROFILE_END, and thread_s::suppl.

Referenced by expression_op_func__disable().

  { PROFILE(SIM_KILL_THREAD_WITH_FUNIT);

  thread* thr;  /* Pointer to current thread */

  assert( funit != NULL );

  /* Kill any threads that match the given functional unit or are children of it */
  thr = all_head;
  while( thr != NULL ) {
    if( (thr->funit == funit) || (funit_is_child_of( funit, thr->funit )) ) {
      thr->suppl.part.kill = 1;
    }
    thr = thr->all_next;
  }

  PROFILE_END;

}

void sim_perform_nba

(

const sim_time *

time

)

Performs non-blocking assignment for currently queued assignment items for the current timestep.

Performs non-blocking assignment for the nba elements in the current nba simulation queue.

Parameters:

time

Current simulation time

References nonblock_assign_s::added, cli_debug_mode, debug_mode, flag_use_command_line_debug, nonblock_assign_s::is_signed, nonblock_assign_s::lhs_lsb, nonblock_assign_s::lhs_msb, nonblock_assign_s::lhs_sig, nba_queue_curr_size, vsuppl_u::part, PROFILE, PROFILE_END, nonblock_assign_s::rhs_lsb, nonblock_assign_s::rhs_msb, nonblock_assign_s::rhs_vec, vsuppl_u::set, vector_s::suppl, nonblock_assign_s::suppl, vsignal_s::value, vector_part_select_push(), vsignal_display(), and vsignal_propagate().

Referenced by db_do_timestep().

  { PROFILE(SIM_PERFORM_NBA);

  int              i;
  bool             changed;
  nonblock_assign* nba;

  for( i=0; i<nba_queue_curr_size; i++ ) {
    nba     = nba_queue[i];
    changed = vector_part_select_push( nba->lhs_sig->value, nba->lhs_lsb, nba->lhs_msb, nba->rhs_vec, nba->rhs_lsb, nba->rhs_msb, nba->suppl.is_signed );
    nba->lhs_sig->value->suppl.part.set = 1;
#ifdef DEBUG_MODE
#ifndef VPI_ONLY
    if( debug_mode && (!flag_use_command_line_debug || cli_debug_mode) ) {
      if( i == 0 ) {
        printf( "Non-blocking assignments:\n" );
      }
      printf( "    " );  vsignal_display( nba->lhs_sig );
    }
#endif
#endif
    if( changed ) { 
      vsignal_propagate( nba->lhs_sig, time );
    }
    nba->suppl.added = 0;
  }

  /* Clear the nba queue */
  nba_queue_curr_size = 0;

  PROFILE_END;

}

bool sim_simulate

(

const sim_time *

time

)

Simulates current timestep.

Returns:

Returns TRUE if simulation should continue; otherwise, returns FALSE to indicate that simulation should no longer continue.

This function is the heart of the simulation engine. It is called by the db_do_timestep() function in db.c and moves the statements and expressions into the appropriate simulation functions. See above explanation on this procedure.

Parameters:

time

Current simulation time from dumpfile or simulator

References thread_s::curr_time, debug_mode, flag_use_command_line_debug, thread_s::part, PROFILE, PROFILE_END, thread_s::queue_next, thread_s::queue_prev, sim_display_delay_queue(), sim_thread(), simulate, thread_s::suppl, THR_ST_ACTIVE, and TIME_CMP_LE.

Referenced by db_do_timestep().

  { PROFILE(SIM_SIMULATE);

  /* Simulate all threads in the active queue */
  while( active_head != NULL ) {
    sim_thread( active_head, time );
  }

  while( (delayed_head != NULL) && TIME_CMP_LE(delayed_head->curr_time, *time) ) {

    active_head  = active_tail = delayed_head;
    delayed_head = delayed_head->queue_next;
    active_head->queue_prev = active_head->queue_next = NULL;
    if( delayed_head != NULL ) {
      delayed_head->queue_prev = NULL;
    } else {
      delayed_tail = NULL;
    }
    active_head->suppl.part.state = THR_ST_ACTIVE;

    while( active_head != NULL ) {
      sim_thread( active_head, time );
    }

  }

#ifdef DEBUG_MODE
  if( debug_mode && !flag_use_command_line_debug ) {
    printf( "After delay simulation...\n" );
    sim_display_delay_queue();
  }
#endif

  PROFILE_END;

  return( simulate );

}

void sim_stop

(

)

Causes the simulation to stop and enter into CLI mode.

Stops the simulation and gets the user to a CLI prompt, if possible.

References FALSE, force_stop, PROFILE, PROFILE_END, simulate, and TRUE.

Referenced by expression_op_func__stop().

                { PROFILE(SIM_STOP);

#ifdef DEBUG_MODE
#ifndef VPI_ONLY
  force_stop = TRUE;
#else
  simulate = FALSE;
#endif
#else
  simulate = FALSE;
#endif

  PROFILE_END;

}

void sim_thread	(	thread *	thr,
		const sim_time *	time
	)

Simulates one thread until it has either completed or enters a context switch.

Performs statement simulation as described above. Calls expression simulator if the associated root expression is specified that signals have changed value within it. Continues to run for current statement tree until statement tree hits a wait-for-event condition (or we reach the end of a simulation tree).

Parameters:

	thr	Pointer to current thread to simulate
	time	Current simulation time to simulate

References cli_execute(), thread_s::curr, DEBUG, debug_mode, ESUPPL_IS_TRUE, statement_s::exp, EXP_OP_CASE, EXP_OP_CASEX, EXP_OP_CASEZ, EXP_OP_DEFAULT, EXP_OP_DELAY, EXP_OP_DLY_ASSIGN, EXPR_IS_CONTEXT_SWITCH, FALSE, sim_time_s::final, force_stop, thread_s::funit, expression_s::id, expression_s::left, statement_s::next_false, statement_s::next_true, expression_s::op, statement_s::part, thread_s::part, print_output(), PROFILE, PROFILE_END, reentrant_dealloc(), thread_s::ren, expression_s::right, sim_expression(), sim_kill_thread(), sim_thread_pop_head(), simulate, expression_s::suppl, statement_s::suppl, thread_s::suppl, user_msg, and USER_MSG_LENGTH.

Referenced by expression_op_func__func_call(), expression_op_func__nb_call(), and sim_simulate().

  { PROFILE(SIM_THREAD);

  statement* stmt;                  /* Pointer to current statement to evaluate */
  bool       expr_changed = FALSE;  /* Specifies if expression tree was modified in any way */

  /* If the thread has a reentrant structure assigned to it, pop it */
  if( thr->ren != NULL ) {
    reentrant_dealloc( thr->ren, thr->funit, FALSE );
    thr->ren = NULL;
  }

  /* Set the value of stmt with the head_stmt */
  stmt = thr->curr;


  while( (stmt != NULL) && !thr->suppl.part.kill && simulate ) {

#ifdef DEBUG_MODE
#ifndef VPI_ONLY
    cli_execute( time, force_stop, stmt );
    force_stop = FALSE;
#endif
#endif

    /* Place expression in expression simulator and run */
    expr_changed = sim_expression( stmt->exp, thr, time, FALSE );

#ifdef DEBUG_MODE
    if( debug_mode ) {
      unsigned int rv = snprintf( user_msg, USER_MSG_LENGTH, "  Executed statement %d, expr changed %d, thread %p", stmt->exp->id, expr_changed, thr );
      assert( rv < USER_MSG_LENGTH );
      print_output( user_msg, DEBUG, __FILE__, __LINE__ );
    }
#endif
      
    thr->curr = stmt;

    /* Set exec_first to FALSE */
    thr->suppl.part.exec_first = 0;

    if( stmt->suppl.part.cont == 1 ) {
       /* If this is a continuous assignment, don't traverse next pointers. */
       stmt = NULL;
    } else {
      if( ESUPPL_IS_TRUE( stmt->exp->suppl ) == 1 ) {
        stmt = stmt->next_true;
      } else {
        stmt = stmt->next_false;
      }
    }

  }

  /* If this is the last statement in the tree with no loopback, kill the current thread */
  if( (expr_changed && 
      (((thr->curr->next_true == NULL) && (thr->curr->next_false == NULL)) ||
       (!EXPR_IS_CONTEXT_SWITCH( thr->curr->exp ) && !thr->curr->suppl.part.cont))) ||
      (thr->curr == NULL) ||
      (!expr_changed && (stmt == NULL) &&
       ((thr->curr->exp->op == EXP_OP_CASE)  ||
        (thr->curr->exp->op == EXP_OP_CASEX) ||
        (thr->curr->exp->op == EXP_OP_CASEZ) ||
        (thr->curr->exp->op == EXP_OP_DEFAULT))) ||
      thr->suppl.part.kill ||
      !simulate ) {

#ifdef DEBUG_MODE
    if( debug_mode ) {
      unsigned int rv = snprintf( user_msg, USER_MSG_LENGTH, "Completed thread %p, killing...\n", thr );
      assert( rv < USER_MSG_LENGTH );
      print_output( user_msg, DEBUG, __FILE__, __LINE__ );
    }
#endif
 
    /* Destroy the thread */
    sim_kill_thread( thr );

  /* Otherwise, we are switching contexts */
  } else {

#ifdef DEBUG_MODE
    if( debug_mode ) {
      unsigned int rv = snprintf( user_msg, USER_MSG_LENGTH, "Switching context of thread %p...\n", thr );
      assert( rv < USER_MSG_LENGTH );
      print_output( user_msg, DEBUG, __FILE__, __LINE__ );
    }
#endif

    /* Pop this packet out of the active queue */
    if( ((thr->curr->exp->op != EXP_OP_DELAY) && 
         ((thr->curr->exp->op != EXP_OP_DLY_ASSIGN) || (thr->curr->exp->right->left->op != EXP_OP_DELAY))) ||
        time->final ) {
      sim_thread_pop_head();
    } else {
      thr->suppl.part.exec_first = 1;
    }

  }

  PROFILE_END;

}

void sim_thread_insert_into_delay_queue	(	thread *	thr,
		const sim_time *	time
	)

Inserts the given thread into the delay queue at the given time slot.

This function is called by the expression_op_func__delay() function.

Parameters:

	thr	Pointer to the thread to add to the delay queue
	time	Pointer to time to insert the given thread

References thread_s::curr_time, debug_mode, flag_use_command_line_debug, sim_time_s::full, thread_s::part, PROFILE, PROFILE_END, thread_s::queue_next, thread_s::queue_prev, sim_display_all_list(), sim_display_delay_queue(), thread_s::suppl, THR_ST_ACTIVE, THR_ST_DELAYED, and TIME_CMP_GT.

Referenced by expression_op_func__delay(), and sim_add_thread().

  { PROFILE(SIM_THREAD_INSERT_INTO_DELAY_QUEUE);

  thread* curr;  /* Pointer to current thread in delayed queue to compare against */

#ifdef DEBUG_MODE
  if( debug_mode && !flag_use_command_line_debug ) {
    printf( "Before delay thread is inserted for time %" FMT64 "u...\n", time->full );
  }
#endif

  if( thr != NULL ) {

    assert( thr->suppl.part.state != THR_ST_DELAYED );

#ifdef DEBUG_MODE
    if( debug_mode && !flag_use_command_line_debug ) {
      sim_display_delay_queue();
    }
#endif

    /* If the thread is currently in the active state, remove it from the active queue now */
    if( thr->suppl.part.state == THR_ST_ACTIVE ) {
 
      /* Move the head pointer */
      active_head = active_head->queue_next;
      if( active_head == NULL ) {
        active_tail = NULL;
      } else {
        active_head->queue_prev = NULL;   /* TBD - Placed here for help in debug */
      }

    }

    /* Specify that the thread is queued and delayed */
    thr->suppl.part.state = THR_ST_DELAYED;

    /* Set the thread simulation time to the given time */
    thr->curr_time = *time;

    /* Add the given thread to the delayed queue in simulation time order */
    if( delayed_head == NULL ) {
      delayed_head = delayed_tail = thr;
      thr->queue_prev = NULL;
      thr->queue_next = NULL;
    } else {
      curr = delayed_tail;
      while( (curr != NULL) && TIME_CMP_GT(curr->curr_time, *time) ) {
        curr = curr->queue_prev;
      }
      if( curr == NULL ) {
        thr->queue_prev          = NULL;
        thr->queue_next          = delayed_head;
        delayed_head->queue_prev = thr;
        delayed_head             = thr;
      } else if( curr == delayed_tail ) {
        thr->queue_prev          = delayed_tail;
        thr->queue_next          = NULL;
        delayed_tail->queue_next = thr;
        delayed_tail             = thr;
      } else {
        thr->queue_prev             = curr;
        thr->queue_next             = curr->queue_next;
        thr->queue_next->queue_prev = thr;
        curr->queue_next            = thr;
      }
    }
    
#ifdef DEBUG_MODE
    if( debug_mode && !flag_use_command_line_debug ) {
      printf( "After delay thread is inserted...\n" );
      sim_display_delay_queue();
      sim_display_all_list();
    }
#endif

  }

  PROFILE_END;

}

void sim_thread_push	(	thread *	thr,
		const sim_time *	time
	)

Pushes given thread onto the active queue.

Adds the specified thread to the end of the current simulation queue. This function gets called whenever a head statement has a signal change or the head statement is a delay operation and

Parameters:

	thr	Pointer to thread to add to the tail of the simulation queue
	time	Current simulation time of thread to push

References thread_s::curr, thread_s::curr_time, debug_mode, statement_s::exp, EXP_OP_AEDGE, EXP_OP_ALWAYS_COMB, EXP_OP_ALWAYS_LATCH, EXP_OP_EOR, EXP_OP_NEDGE, EXP_OP_PEDGE, EXP_OP_SLIST, EXP_OP_WAIT, flag_use_command_line_debug, expression_s::op, thread_s::part, PROFILE, PROFILE_END, thread_s::queue_next, thread_s::queue_prev, sim_display_active_queue(), sim_display_all_list(), thread_s::suppl, and THR_ST_ACTIVE.

Referenced by funit_push_threads().

  { PROFILE(SIM_THREAD_PUSH);

  exp_op_type op;  /* Operation type of current expression in given thread */

#ifdef DEBUG_MODE
  if( debug_mode && !flag_use_command_line_debug ) {
    printf( "Before thread is pushed...\n" );
    sim_display_active_queue();
  }
#endif

  /* Set the state to ACTIVE */
  thr->suppl.part.state = THR_ST_ACTIVE;

  /* Set the current time of the thread to the given value */
  op = thr->curr->exp->op;
  if( (op == EXP_OP_PEDGE)       ||
      (op == EXP_OP_NEDGE)       ||
      (op == EXP_OP_AEDGE)       ||
      (op == EXP_OP_EOR)         ||
      (op == EXP_OP_WAIT)        ||
      (op == EXP_OP_SLIST)       ||
      (op == EXP_OP_ALWAYS_COMB) ||
      (op == EXP_OP_ALWAYS_LATCH) ) {
    thr->curr_time = *time;
  }

  /* Set the active next and prev pointers to NULL */
  thr->queue_prev = thr->queue_next = NULL;

  /* Add the given thread to the end of the active_threads queue */
  if( active_head == NULL ) {
    active_head = active_tail = thr;
  } else {
    thr->queue_prev         = active_tail;
    active_tail->queue_next = thr;
    active_tail             = thr;
  }

#ifdef DEBUG_MODE
  if( debug_mode && !flag_use_command_line_debug ) {
    printf( "After thread is pushed...\n" );
    sim_display_active_queue();
    sim_display_all_list();
  }
#endif

  PROFILE_END;

}