sys_tasks.c File Reference

#include <limits.h>
#include <stdlib.h>
#include "defines.h"
#include "link.h"
#include "profiler.h"
#include "vector.h"

Defines
#define	UNIFORM_MAX   LONG_MAX
#define	UNIFORM_MIN   LONG_MIN
Functions
static double	sys_task_uniform (long *seed, long start, long end)
long	sys_task_dist_uniform (long *seed, long start, long end)
void	sys_task_srandom (long seed)
	Performs $srandom system task call.
long	sys_task_random (long *seed)
	Performs $random system task call.
unsigned long	sys_task_urandom (long *seed)
	Performs $urandom system task call.
unsigned long	sys_task_urandom_range (unsigned long max, unsigned long min)
	Performs $urandom_range system task call.
uint64	sys_task_realtobits (double real)
	Converts a 64-bit real value to a 64-bit unsigned value.
double	sys_task_bitstoreal (uint64 u64)
	Converts a 64-bit value to a 64-bit real.
uint32	sys_task_shortrealtobits (float real)
	Converts a 32-bit real value to a 32-bit unsigned value.
float	sys_task_bitstoshortreal (uint32 u32)
	Converts a 32-bit value to a 32-bit real.
double	sys_task_itor (int ival)
	Returns a real representation of the specified integer value.
int	sys_task_rtoi (double real)
	Returns an integer representation of the specified real value (value is truncated).
void	sys_task_store_plusarg (const char *arg)
	Scans command-line for plusargs.
ulong	sys_task_test_plusargs (const char *arg)
	Returns 1 if the specified plusarg was found; otherwise, returns 0.
ulong	sys_task_value_plusargs (const char *arg, vector *vec)
	Parses command-line for value plusargs, assigns the specified vector the found value and returns 1 (if found).
void	sys_task_dealloc ()
	Deallocates any memory allocated within this file.
Variables
static long	random_seed = 0
static str_link *	sim_plusargs_head = NULL
static str_link *	sim_plusargs_tail = NULL

---

Detailed Description

Author:

Trevor Williams (phase1geo@gmail.com)

Date:

10/2/2008

Note:

The contents of this file came from Icarus Verilog source code and should be attributed to this group. Only the format of this code has been modified.

---

Define Documentation

#define UNIFORM_MAX   LONG_MAX

Referenced by sys_task_dist_uniform().

#define UNIFORM_MIN   LONG_MIN

Referenced by sys_task_dist_uniform().

---

Function Documentation

double sys_task_bitstoreal

(

uint64

u64

)

Converts a 64-bit value to a 64-bit real.

Returns:

Returns a 64-bit real representation of the specified 64-bit value.

Converts a 64-bit value to a 64-bit real.

Parameters:

u64

64-bit value to convert to a real

References PROFILE, and PROFILE_END.

Referenced by expression_op_func__bitstoreal(), and reentrant_restore_data_bits().

  { PROFILE(SYS_TASK_BITSTOREAL);

  union {
    double real;
    uint64 u64;
  } conversion;

  conversion.u64 = u64;

  PROFILE_END;

  return( conversion.real );

}

float sys_task_bitstoshortreal

(

uint32

u32

)

Converts a 32-bit value to a 32-bit real.

Returns:

Returns a 32-bit real representation of the specified 32-bit value.

Converts a 32-bit value to a 32-bit real.

Parameters:

u32

32-bit value to convert to a real

References PROFILE, and PROFILE_END.

Referenced by expression_op_func__bitstoshortreal().

  { PROFILE(SYS_TASK_BITSTOSHORTREAL);

  union {
    float  real;
    uint32 u32;
  } conversion;

  conversion.u32 = u32;

  PROFILE_END;

  return( conversion.real );

}

void sys_task_dealloc

(

)

Deallocates any memory allocated within this file.

Deallocates all memory allocated by any of the above functions.

References PROFILE, PROFILE_END, and str_link_delete_list().

Referenced by command_score(), and covered_end_of_sim().

                        { PROFILE(SYS_TASK_DEALLOC);

  /* Delete simulation plusarg list */
  str_link_delete_list( sim_plusargs_head );

  PROFILE_END;

}

long sys_task_dist_uniform	(	long *	seed,
		long	start,
		long	end
	)

Returns:

Returns a randomly generated integer value that is uniformly distributed.

Note:

Copied from IEEE1364-2001, with slight modifications for 64bit machines. This code is taken from Icarus Verilog.

Parameters:

	seed	Pointer to seed value to use and store new seed value to
	start	Starting range of random value
	end	Ending range of random value

References PROFILE, PROFILE_END, sys_task_uniform(), UNIFORM_MAX, and UNIFORM_MIN.

Referenced by sys_task_random(), sys_task_urandom(), and sys_task_urandom_range().

  { PROFILE(SYS_TASK_RTL_DIST_UNIFORM);

  double r;
  long   i;

  if( start >= end ) {

    i = start;

  } else {

    /*
     NOTE: The cast of r to i can overflow and generate strange
     values, so cast to unsigned long first. This eliminates
     the underflow and gets the twos complement value. That in
     turn can be cast to the long value that is expected.
    */

    if( end != UNIFORM_MAX ) {

      end++;
      r = sys_task_uniform( seed, start, end );
      if( r >= 0 ) {
        i = (unsigned long) r;
      } else {
        i = - ( (unsigned long) (-(r - 1)) );
      }
      if( i < start ) i = start;
      if( i >= end ) i = end - 1;

    } else if( start != UNIFORM_MIN ) {

      start--;
      r = sys_task_uniform( seed, start, end ) + 1.0;
      if( r >= 0 ) {
        i = (unsigned long) r;
      } else {
        i = - ( (unsigned long) (-(r - 1)) );
      }
      if( i <= start ) i = start + 1;
      if( i > end ) i = end;

    } else {

      r = (sys_task_uniform( seed, start, end ) + 2147483648.0) / 4294967295.0;
      r = r * 4294967296.0 - 2147483648.0;

      if( r >= 0 ) {
        i = (unsigned long) r;
      } else {
        /*
         At least some compilers will notice that (r-1)
         is <0 when castling to unsigned long and
         replace the result with a zero. This causes
         much wrongness, so do the casting to the
         positive version and invert it back.
        */
        i = - ( (unsigned long) (-(r - 1)) );
      }

    }

  }

  PROFILE_END;

  return( i );

}

double sys_task_itor

(

int

ival

)

Returns a real representation of the specified integer value.

Returns:

Returns a real representation of the specified integer value.

Parameters:

ival

Integer value to convert to real value

References PROFILE, and PROFILE_END.

Referenced by expression_op_func__itor().

  { PROFILE(SYS_TASK_ITOR);

  double real = (double)ival;

  PROFILE_END;

  return( real );

}

long sys_task_random

(

long *

seed

)

Performs $random system task call.

Returns:

Returns a randomly generated signed value

Parameters:

seed

Pointer to seed value to use and store new information to

References PROFILE, PROFILE_END, random_seed, and sys_task_dist_uniform().

Referenced by expression_op_func__random().

  { PROFILE(SYS_TASK_RANDOM);

  long result;
  
  if( seed != NULL ) {
    random_seed = *seed;
  }

  result = sys_task_dist_uniform( &random_seed, INT_MIN, INT_MAX );

  if( seed != NULL ) {
    *seed = random_seed;
  }

  PROFILE_END;

  return( result );

}

uint64 sys_task_realtobits

(

double

real

)

Converts a 64-bit real value to a 64-bit unsigned value.

Returns:

Returns a 64-bit bit representation of the specified double value.

Converts a 64-bit real value to a 64-bit unsigned value.

Parameters:

real

Real value to convert to bits

References PROFILE, and PROFILE_END.

Referenced by expression_op_func__realtobits(), and reentrant_store_data_bits().

  { PROFILE(SYS_TASK_REALTOBITS);

  union {
    double real;
    uint64 u64;
  } conversion;

  conversion.real = real;

  PROFILE_END;

  return( conversion.u64 );

}

int sys_task_rtoi

(

double

real

)

Returns an integer representation of the specified real value (value is truncated).

Returns:

Returns an integer representation of the specified real value (value is truncated).

Parameters:

real

Real value to convert to integer

References PROFILE, and PROFILE_END.

Referenced by expression_op_func__rtoi().

  { PROFILE(SYS_TASK_RTOI);

  int ival = (int)real;

  PROFILE_END;

  return( ival );

}

uint32 sys_task_shortrealtobits

(

float

real

)

Converts a 32-bit real value to a 32-bit unsigned value.

Returns:

Returns a 32-bit bit representation of the specified double value.

Converts a 32-bit real value to a 32-bit unsigned value.

Parameters:

real

Real value to convert to bits

References PROFILE, and PROFILE_END.

Referenced by expression_op_func__shortrealtobits().

  { PROFILE(SYS_TASK_SHORTREALTOBITS);

  union {
    float  real;
    uint32 u32;
  } conversion;

  conversion.real = real;

  PROFILE_END;

  return( conversion.u32 );

}

void sys_task_srandom

(

long

seed

)

Performs $srandom system task call.

Sets the global seed value to the specified value.

Parameters:

seed

User-specified seed to set global seed value to

References PROFILE, PROFILE_END, and random_seed.

Referenced by expression_op_func__srandom().

  { PROFILE(SYS_TASK_SRANDOM);

  random_seed = seed;

  PROFILE_END;

}

void sys_task_store_plusarg

(

const char *

arg

)

Scans command-line for plusargs.

This function is called by the score command argument parser or the VPI command-line parser and performs the task of adding plusarg options from the score command or VPI for later usage during simulation.

Parameters:

arg

Plusarg from the score command or VPI code minus the initial '+' character

References PROFILE, PROFILE_END, str_link_add(), and strdup_safe.

Referenced by covered_sim_calltf(), and score_parse_args().

  { PROFILE(SYS_TASK_STORE_PLUSARGS);

  str_link_add( strdup_safe( arg ), &sim_plusargs_head, &sim_plusargs_tail );

  PROFILE_END;

}

ulong sys_task_test_plusargs

(

const char *

arg

)

Returns 1 if the specified plusarg was found; otherwise, returns 0.

Returns:

Returns 1 if the specified plusarg was found; otherwise, returns 0.

Parameters:

arg

Plusarg to find

References PROFILE, PROFILE_END, and str_link_find().

Referenced by expression_op_func__test_plusargs().

  { PROFILE(SYS_TASK_TEST_PLUSARG);

  /* Scan the simulation argument list for matching values */
  ulong retval = (str_link_find( arg, sim_plusargs_head ) != NULL) ? 1 : 0;

  PROFILE_END;

  return( retval );

}

static double sys_task_uniform	(	long *	seed,
		long	start,
		long	end
	)			[static]

Returns:

Returns a randomly generated number that is uniformly distributed.

Parameters:

	seed	Pointer to seed value to use and store new seed in
	start	Beginning range
	end	Ending range

References PROFILE, and PROFILE_END.

Referenced by sys_task_dist_uniform().

  { PROFILE(SYS_TASK_UNIFORM);

  double        d = 0.00000011920928955078125;
  double        a, b, c;
  unsigned long oldseed, newseed;

  oldseed = *seed;

  if( oldseed == 0 )
    oldseed = 259341593;

  if( start >= end ) {
    a = 0.0;
    b = 2147483647.0;
  } else {
    a = (double)start;
    b = (double)end;
  }

  /* Original routine used signed arithmetic, and the (frequent)
   * overflows trigger "Undefined Behavior" according to the
   * C standard (both c89 and c99).  Using unsigned arithmetic
   * forces a conforming C implementation to get the result
   * that the IEEE-1364-2001 committee wants.
   */
  newseed = 69069 * oldseed + 1;

  /* Emulate a 32-bit unsigned long, even if the native machine
   * uses wider words.
   */
#if ULONG_MAX > 4294967295UL
  newseed = newseed & 4294967295UL;
#endif
  *seed = newseed;

  /* Equivalent conversion without assuming IEEE 32-bit float */
  /* constant is 2^(-23) */
  c = 1.0 + (newseed >> 9) * 0.00000011920928955078125;
  c = c + (c*d);
  c = ((b - a) * (c - 1.0)) + a;

  PROFILE_END;

  return( c );

}

unsigned long sys_task_urandom

(

long *

seed

)

Performs $urandom system task call.

Returns:

Returns a randomly generated unsigned value within a given range

Note:

From System Verilog 3.1a. This code is from the Icarus Verilog project.

Parameters:

seed

Pointer to seed value to use and store new information to

References PROFILE, random_seed, and sys_task_dist_uniform().

Referenced by expression_op_func__urandom().

  { PROFILE(SYS_TASK_URANDOM);

  unsigned long result;

  if( seed != NULL ) {
    random_seed = *seed;
  }

  result = sys_task_dist_uniform( &random_seed, INT_MIN, INT_MAX ) - INT_MIN;

  if( seed != NULL ) {
    *seed = random_seed;
  }

  return( result );

}

unsigned long sys_task_urandom_range	(	unsigned long	max,
		unsigned long	min
	)

Performs $urandom_range system task call.

Returns:

Returns a randomly generated unsigned value within a given range

Note:

From System Verilog 3.1a. This code is from the Icarus Verilog project.

Parameters:

	max	Maximum range value
	min	Minimum range value

References PROFILE, random_seed, and sys_task_dist_uniform().

Referenced by expression_op_func__urandom_range().

  { PROFILE(SYS_TASK_URANDOM_RANGE);

  unsigned long result;
  long          max_i, min_i;

  /* If the max value is less than the min value, swap the two values */
  if( max < min ) {
    unsigned long tmp;
    tmp = max;
    max = min;
    min = tmp;
  }

  max_i = max + INT_MIN;
  min_i = min + INT_MIN;

  result = sys_task_dist_uniform( &random_seed, min_i, max_i ) - INT_MIN;

  return( result );

}

ulong sys_task_value_plusargs	(	const char *	arg,
		vector *	vec
	)

Parses command-line for value plusargs, assigns the specified vector the found value and returns 1 (if found).

Parameters:

	arg	Plusarg to find
	vec	Pointer to vector to populate with found value

References str_link_s::next, PROFILE, PROFILE_END, str_link_s::str, vector_from_real64(), vector_from_string_fixed(), and vector_from_uint64().

Referenced by expression_op_func__value_plusargs().

  { PROFILE(SYS_TASK_VALUE_PLUSARGS);

  ulong     retval = 0;
  str_link* strl;
  char*     ptr;

  /* Find the percent character in the argument string */
  ptr = strchr( arg, '%' );
  assert( ptr != NULL );

  /* See if the plusarg even exists on the command-line */
  strl = sim_plusargs_head;
  while( (strl != NULL) && (strncmp( arg, strl->str, (ptr - arg) ) != 0) ) {
    strl = strl->next;
  }

  /* If the argument exists on the command-line, continue */
  if( strl != NULL ) {

    switch( *(ptr + 1) ) {
      case 'b' :  vector_from_uint64( vec, strtoull( (strl->str + (ptr - arg)), 0, 2 ) );  break;
      case 'o' :  vector_from_uint64( vec, strtoull( (strl->str + (ptr - arg)), 0, 8 ) );  break;
      case 'd' :  vector_from_uint64( vec, strtoull( (strl->str + (ptr - arg)), 0, 10 ) );  break;
      case 'h' :  vector_from_uint64( vec, strtoull( (strl->str + (ptr - arg)), 0, 16 ) );  break;
      case 'e' :
      case 'f' :
      case 'g' :  vector_from_real64( vec, strtod( (strl->str + (ptr - arg)), 0 ) );  break;
      case 's' :  vector_from_string_fixed( vec, (strl->str + (ptr - arg)) );  break;
      default  :  assert( 0 );  break;
    }

    /* Specify that we have found and converted the value */
    retval = 1;

  }

  PROFILE_END;

  return( retval );

}

---

Variable Documentation

long random_seed = 0 [static]

Random seed value.

Referenced by sys_task_random(), sys_task_srandom(), sys_task_urandom(), and sys_task_urandom_range().

str_link* sim_plusargs_head = NULL [static]

Pointer to the head of the list of simulation plusargs.

str_link* sim_plusargs_tail = NULL [static]

Pointer to the tail of the list of simulation plusargs.