Namespaces
	sc_meta

	sc_object

	sc_phase_callback_registry

	sc_report_handler

	sc_vector_base

Classes
struct	SC_API_VERSION_STRING

class	sc_attr_base

class	sc_attr_cltn

class	sc_attribute

struct	sc_bind_proxy

class	sc_buffer

class	sc_byte_heap

class	sc_clock

class	sc_clock_negedge_callback

class	sc_clock_posedge_callback

class	sc_cor

class	sc_cor_pkg

class	sc_cor_pkg_qt

class	sc_cor_qt

class	sc_cthread_process

struct	sc_curr_proc_info

struct	sc_direct_access

class	sc_event

class	sc_event_and_list

class	sc_event_expr

class	sc_event_finder

class	sc_event_finder_t

class	sc_event_list

class	sc_event_or_list

class	sc_event_queue

class	sc_event_queue_if

class	sc_event_timed

class	sc_export

class	sc_export_base

class	sc_export_registry

class	sc_fifo

class	sc_fifo_blocking_in_if

class	sc_fifo_blocking_out_if

class	sc_fifo_in

class	sc_fifo_in_if

class	sc_fifo_nonblocking_in_if

class	sc_fifo_nonblocking_out_if

class	sc_fifo_out

class	sc_fifo_out_if

class	sc_halt

class	sc_host_mutex

class	sc_host_semaphore

class	sc_in

class	sc_in< bool >

class	sc_in< sc_dt::sc_logic >

class	sc_in_resolved

class	sc_in_rv

class	sc_inout

class	sc_inout< bool >

class	sc_inout< sc_dt::sc_logic >

class	sc_inout_resolved

class	sc_inout_rv

class	sc_interface

class	sc_join

class	sc_kill

class	sc_lv_resolve

class	sc_member_access

class	sc_mempool

class	sc_method_process

class	sc_module

class	sc_module_name

class	sc_module_registry

class	sc_mpobject

struct	sc_msg_def

class	sc_mutex

class	sc_mutex_if

class	sc_name_gen

class	sc_object

class	sc_object_manager

class	sc_out

class	sc_out_resolved

class	sc_out_rv

class	sc_pdhash

class	sc_pdhash_iter

class	sc_phase_callback_registry

class	sc_phash

class	sc_phash_base

class	sc_phash_base_iter

class	sc_phash_iter

class	sc_plist

class	sc_plist_base

class	sc_plist_base_iter

class	sc_plist_iter

class	sc_port

class	sc_port_b

class	sc_port_base

class	sc_port_registry

class	sc_ppq

class	sc_ppq_base

class	sc_prim_channel

class	sc_prim_channel_registry

class	sc_process_b

class	sc_process_handle

class	sc_process_host

class	sc_process_monitor

class	sc_pvector

class	sc_report

class	sc_report_handler

class	sc_reset

class	sc_reset_finder

class	sc_reset_target

class	sc_runnable

class	sc_scoped_lock

class	sc_semaphore

class	sc_semaphore_if

class	sc_sensitive

class	sc_sensitive_neg

class	sc_sensitive_pos

class	sc_signal

class	sc_signal< bool, POL >

class	sc_signal< sc_dt::sc_logic, POL >

class	sc_signal_channel

class	sc_signal_in_if

class	sc_signal_in_if< bool >

class	sc_signal_in_if< sc_dt::sc_logic >

class	sc_signal_inout_if

class	sc_signal_resolved

class	sc_signal_rv

class	sc_signal_t

class	sc_signal_write_if

class	sc_simcontext

class	sc_spawn_object

class	sc_spawn_object_v

class	sc_spawn_options

class	sc_spawn_reset

class	sc_strhash

class	sc_strhash_iter

class	sc_thread_process

class	sc_throw_it

class	sc_throw_it_helper

class	sc_time

struct	sc_time_params

class	sc_time_tuple

class	sc_trace_file

class	sc_trace_file_base

struct	sc_trace_params

class	sc_type_index

class	sc_unwind_exception

class	sc_user

class	sc_vector

class	sc_vector_assembly

class	sc_vector_base

class	sc_vector_iter

class	sc_vpool

struct	sc_writer_policy_check

struct	sc_writer_policy_check< SC_MANY_WRITERS >

struct	sc_writer_policy_check< SC_ONE_WRITER >

struct	sc_writer_policy_check< SC_UNCHECKED_WRITERS >

struct	sc_writer_policy_check_delta

struct	sc_writer_policy_check_port

struct	sc_writer_policy_check_write

struct	sc_writer_policy_nocheck_port

struct	sc_writer_policy_nocheck_write

class	sc_zstring_view

struct	scoped_flag

class	vcd_T_trace

class	vcd_trace_file

class	wif_T_trace

class	wif_trace_file

Typedefs
typedef sc_in< bool >	sc_in_clk

typedef sc_inout< bool >	sc_inout_clk

typedef sc_out< bool >	sc_out_clk

typedef sc_port< sc_event_queue_if, 1, SC_ONE_OR_MORE_BOUND >	sc_event_queue_port

typedef std::vector< sc_trace_params *>	sc_trace_params_vec

typedef void()	sc_cor_fn(void *)

typedef sc_cor_pkg_qt	sc_cor_pkg_t

typedef sc_event_expr< sc_event_and_list >	sc_event_and_expr

typedef sc_event_expr< sc_event_or_list >	sc_event_or_expr

typedef sc_module	sc_channel

typedef sc_module	sc_behavior

typedef class sc_cthread_process *	sc_cthread_handle

typedef class sc_method_process *	sc_method_handle

typedef class sc_thread_process *	sc_thread_handle

typedef void(sc_process_host::*	SC_ENTRY_FUNC) ()

typedef sc_process_b	sc_process_b

typedef sc_plist< sc_process_b * >	sc_process_list

typedef const sc_curr_proc_info *	sc_curr_proc_handle

typedef void(*	sc_plist_map_fn) (void data, void arg)

typedef int(*	CFT) (const void , const void )

typedef unsigned	sc_actions

typedef std::exception	sc_exception

typedef void(*	sc_report_handler_proc) (const sc_report &, const sc_actions &)

typedef SC_STRING_VIEW_NS_::string_view	sc_string_view

Enumerations
enum	sc_port_policy

enum	sc_writer_policy

enum	sc_curr_proc_kind

enum	sc_descendant_inclusion_info

enum	sc_stop_mode

enum	sc_starvation_policy

enum	sc_status

enum	sc_time_unit

enum	sc_severity

enum	sc_verbosity

Functions
inline ::std::ostream &	operator<< (::std::ostream &os, const sc_fifo< T > &a)

SC_API void	sc_warn_port_constructor ()

inline ::std::ostream &	operator<< (::std::ostream &os, const sc_signal_channel &a)

SC_API void	sc_deprecated_add_trace ()

::std::ostream &	operator<< (::std::ostream &os, const sc_in< T > &a)

::std::ostream &	operator<< (::std::ostream &os, const sc_inout< T > &a)

void	sc_trace (sc_trace_file *tf, const sc_in< T > &port, const std::string &name)

void	sc_trace (sc_trace_file *tf, const sc_inout< T > &port, const std::string &name)

SC_API void	sc_signal_invalid_writer (sc_object target, sc_object first_writer, sc_object *second_writer, bool check_delta)

void SC_API	halt (sc_simcontext *)

void SC_API	wait (int, sc_simcontext *)

SC_API int	sc_notify_time_compare (const void , const void )

void	notify (sc_event &e)

void	notify (const sc_time &t, sc_event &e)

void	notify (double v, sc_time_unit tu, sc_event &e)

sc_event_or_expr	operator\| (sc_event_or_expr expr, sc_event const &e)

sc_event_or_expr	operator\| (sc_event_or_expr expr, sc_event_or_list const &el)

sc_event_and_expr	operator & (sc_event_and_expr expr, sc_event const &e)

sc_event_and_expr	operator & (sc_event_and_expr expr, sc_event_and_list const &el)

void	sc_thread_cor_fn (void *arg)

SC_API sc_report *	sc_handle_exception ()

int	sc_elab_and_sim (int argc, char *argv[])

int	sc_argc ()

const char const	sc_argv ()

void	sc_method_cor_fn (void *)

void	sc_cmethod_cor_fn (void *)

SC_API void	sc_set_stack_size (sc_method_handle, std::size_t)

SC_API void	next_trigger (sc_simcontext *)

SC_API void	next_trigger (const sc_event &, sc_simcontext *)

SC_API void	next_trigger (const sc_event_or_list &, sc_simcontext *)

SC_API void	next_trigger (const sc_event_and_list &, sc_simcontext *)

SC_API void	next_trigger (const sc_time &, sc_simcontext *)

SC_API void	next_trigger (const sc_time &, const sc_event &, sc_simcontext *)

SC_API void	next_trigger (const sc_time &, const sc_event_or_list &, sc_simcontext *)

SC_API void	next_trigger (const sc_time &, const sc_event_and_list &, sc_simcontext *)

SC_API sc_module *	sc_module_dynalloc (sc_module *)

sc_object *	sc_get_parent (const sc_object *obj_p)

SC_API const char *	sc_gen_unique_name (const char *, bool preserve_first)

SC_API sc_process_handle	sc_get_current_process_handle ()

SC_API bool	timed_out (sc_simcontext *)

SC_API void	sc_set_stack_size (sc_thread_handle, std::size_t)

bool	operator== (const sc_process_handle &left, const sc_process_handle &right)

bool	operator!= (const sc_process_handle &left, const sc_process_handle &right)

bool	operator< (const sc_process_handle &left, const sc_process_handle &right)

sc_process_handle	sc_get_last_created_process_handle ()

std::ostream &	operator<< (std::ostream &os, const sc_reset_target &target)

SC_API void	sc_set_stop_mode (sc_stop_mode mode)

SC_API sc_stop_mode	sc_get_stop_mode ()

SC_API void	sc_start ()

SC_API void	sc_start (const sc_time &duration, sc_starvation_policy p=SC_RUN_TO_TIME)

void	sc_start (int duration, sc_time_unit unit, sc_starvation_policy p=SC_RUN_TO_TIME)

void	sc_start (double duration, sc_time_unit unit, sc_starvation_policy p=SC_RUN_TO_TIME)

SC_API void	sc_stop ()

SC_API sc_dt::uint64	sc_delta_count ()

SC_API sc_dt::uint64	sc_delta_count_at_current_time ()

SC_API const std::vector< sc_event *> &	sc_get_top_level_events (const sc_simcontext *simc_p)

SC_API const std::vector< sc_object *> &	sc_get_top_level_objects (const sc_simcontext *simc_p)

SC_API bool	sc_is_running (const sc_simcontext *simc_p)

SC_API void	sc_pause ()

SC_API bool	sc_end_of_simulation_invoked ()

SC_API bool	sc_start_of_simulation_invoked ()

SC_API void	sc_set_time_resolution (double, sc_time_unit)

SC_API sc_time	sc_get_time_resolution ()

SC_API void	sc_set_default_time_unit (double, sc_time_unit)

SC_API sc_time	sc_get_default_time_unit ()

SC_API bool	sc_pending_activity_at_current_time (const sc_simcontext *)

SC_API bool	sc_pending_activity_at_future_time (const sc_simcontext *)

SC_API sc_time	sc_time_to_pending_activity (const sc_simcontext *)

sc_simcontext *	sc_get_curr_simcontext ()

sc_status	sc_get_status ()

sc_object *	sc_get_current_object ()

sc_process_b *	sc_get_current_process_b ()

SC_API sc_process_b *	sc_get_curr_process_handle ()

sc_curr_proc_kind	sc_get_curr_process_kind ()

int	sc_get_simulator_status ()

SC_API void	sc_set_random_seed (unsigned int seed_)

SC_API void	sc_initialize ()

SC_API const sc_time &	sc_max_time ()

SC_API const sc_time &	sc_time_stamp ()

SC_API double	sc_simulation_time ()

SC_API sc_event *	sc_find_event (const char *name)

SC_API sc_object *	sc_find_object (const char *name)

SC_API bool	sc_is_unwinding ()

bool	sc_pending_activity (const sc_simcontext *simc_p=sc_get_curr_simcontext())

bool	sc_hierarchical_name_exists (const char *name)

bool	sc_hierarchical_name_exists (const sc_object parent, const char name)

const char *	sc_get_hierarchical_name (const char *name)

const char *	sc_get_hierarchical_name (const sc_object parent, const char name)

bool	sc_register_hierarchical_name (const char *name)

bool	sc_register_hierarchical_name (const sc_object parent, const char name)

bool	sc_unregister_hierarchical_name (const char *name)

bool	sc_unregister_hierarchical_name (const sc_object parent, const char name)

const char *	sc_get_current_process_name (const char *if_empty=NULL)

SC_API void	sc_defunct_process_function (sc_module *)

sc_process_handle	sc_spawn (T object, const char name_p=0, const sc_spawn_options opt_p=0)

sc_process_handle	sc_spawn (typename T::result_type r_p, T object, const char name_p=0, const sc_spawn_options *opt_p=0)

SC_API std::ostream &	operator<< (std::ostream &, sc_status)

sc_cor *	get_cor_pointer (sc_process_b *process_p)

SC_API void	wait (sc_simcontext *)

SC_API void	wait (const sc_event &, sc_simcontext *)

SC_API void	wait (const sc_event_or_list &, sc_simcontext *)

SC_API void	wait (const sc_event_and_list &, sc_simcontext *)

SC_API void	wait (const sc_time &, sc_simcontext *)

SC_API void	wait (const sc_time &, const sc_event &, sc_simcontext *)

SC_API void	wait (const sc_time &, const sc_event_or_list &, sc_simcontext *)

SC_API void	wait (const sc_time &, const sc_event_and_list &, sc_simcontext *)

const sc_time	operator+ (const sc_time &, const sc_time &)

const sc_time	operator- (const sc_time &, const sc_time &)

const sc_time	operator* (const sc_time &, double)

const sc_time	operator* (double, const sc_time &)

const sc_time	operator/ (const sc_time &, double)

double	operator/ (const sc_time &, const sc_time &)

inline ::std::ostream &	operator<< (::std::ostream &, const sc_time &)

const sc_time	operator% (const sc_time &t1, const sc_time &t2)

SC_API const char *	sc_copyright ()

SC_API const char *	sc_release ()

SC_API const char *	sc_version ()

SC_API void	wait (double v, sc_time_unit tu, sc_simcontext *simc=sc_get_curr_simcontext())

SC_API void	wait (double v, sc_time_unit tu, const sc_event &e, sc_simcontext *simc=sc_get_curr_simcontext())

SC_API void	wait (double v, sc_time_unit tu, const sc_event_or_list &el, sc_simcontext *simc=sc_get_curr_simcontext())

SC_API void	wait (double v, sc_time_unit tu, const sc_event_and_list &el, sc_simcontext *simc=sc_get_curr_simcontext())

SC_API void	next_trigger (double v, sc_time_unit tu, sc_simcontext *simc=sc_get_curr_simcontext())

SC_API void	next_trigger (double v, sc_time_unit tu, const sc_event &e, sc_simcontext *simc=sc_get_curr_simcontext())

SC_API void	next_trigger (double v, sc_time_unit tu, const sc_event_or_list &el, sc_simcontext *simc=sc_get_curr_simcontext())

void	next_trigger (double v, sc_time_unit tu, const sc_event_and_list &el, sc_simcontext *simc=sc_get_curr_simcontext())

SC_API void	sc_set_location (const char , int, sc_simcontext =sc_get_curr_simcontext())

void	at_posedge (const sc_signal_in_if< bool > &, sc_simcontext *=sc_get_curr_simcontext())

void	at_posedge (const sc_signal_in_if< sc_dt::sc_logic > &, sc_simcontext *=sc_get_curr_simcontext())

void	at_negedge (const sc_signal_in_if< bool > &, sc_simcontext *=sc_get_curr_simcontext())

void	at_negedge (const sc_signal_in_if< sc_dt::sc_logic > &, sc_simcontext *=sc_get_curr_simcontext())

void	sc_trace (sc_trace_file *tf, const sc_signal_in_if< T > &object, const std::string &name)

void	sc_trace (sc_trace_file tf, const sc_signal_in_if< T > &object, const char name)

SC_API void	sc_trace (sc_trace_file *tf, const sc_signal_in_if< char > &object, const std::string &name, int width)

SC_API void	sc_trace (sc_trace_file *tf, const sc_signal_in_if< short > &object, const std::string &name, int width)

SC_API void	sc_trace (sc_trace_file *tf, const sc_signal_in_if< int > &object, const std::string &name, int width)

SC_API void	sc_trace (sc_trace_file *tf, const sc_signal_in_if< long > &object, const std::string &name, int width)

SC_API void	sc_trace (sc_trace_file tf, const unsigned int &object, const std::string &name, const char *enum_literals)

SC_API void	sc_trace (sc_trace_file tf, const void object, const std::string &name)

SC_API void	sc_trace_delta_cycles (sc_trace_file *tf, bool on=true)

SC_API void	sc_write_comment (sc_trace_file *tf, const std::string &comment)

SC_API void	tprintf (sc_trace_file tf, const char format,...)

SC_API sc_trace_file *	sc_create_vcd_trace_file (const char *name)

SC_API void	sc_close_vcd_trace_file (sc_trace_file *tf)

SC_API sc_trace_file *	sc_create_wif_trace_file (const char *name)

SC_API void	sc_close_wif_trace_file (sc_trace_file *tf)

SC_API std::string	localtime_string ()

SC_API unsigned	default_int_hash_fn (const void *)

SC_API unsigned	default_ptr_hash_fn (const void *)

SC_API unsigned	default_str_hash_fn (const void *)

SC_API int	sc_strhash_cmp (const void , const void )

SC_API void	sc_strhash_kfree (void *)

SC_API void *	sc_strhash_kdup (const void *)

SC_API const std::string	sc_report_compose_message (const sc_report &)

SC_NORETURN_ SC_API void	sc_abort ()

SC_NORETURN_ SC_API void	sc_assertion_failed (const char msg, const char file, int line)

SC_API bool	sc_report_close_default_log ()

SC_API void	sc_interrupt_here (const char *id, sc_severity severity)

SC_API void	sc_stop_here (const char *id, sc_severity severity)

Container::iterator	sc_vector_do_bind (Container &cont, ArgumentIterator first, ArgumentIterator last, typename Container::iterator from)

Container::iterator	sc_vector_do_operator_paren (Container &cont, ArgumentIterator first, ArgumentIterator last, typename Container::iterator from)

sc_vector_assembly< T, MT >	sc_assemble_vector (sc_vector< T > &vec, MT(T::*ptr))

Variables
	SC_ONE_OR_MORE_BOUND

	SC_ZERO_OR_MORE_BOUND

	SC_ALL_BOUND

	SC_ONE_WRITER

	SC_MANY_WRITERS

	SC_UNCHECKED_WRITERS

	SC_NO_PROC_

	SC_METHOD_PROC_

	SC_THREAD_PROC_

	SC_CTHREAD_PROC_

	SC_NO_DESCENDANTS

	SC_INCLUDE_DESCENDANTS

	SC_INVALID_DESCENDANTS

	SC_STOP_FINISH_DELTA

	SC_STOP_IMMEDIATE

	SC_EXIT_ON_STARVATION

	SC_RUN_TO_TIME

	SC_UNITIALIZED

	SC_ELABORATION

	SC_BEFORE_END_OF_ELABORATION

	SC_END_OF_ELABORATION

	SC_START_OF_SIMULATION

	SC_RUNNING

	SC_PAUSED

	SC_STOPPED

	SC_END_OF_SIMULATION

	SC_END_OF_INITIALIZATION

	SC_END_OF_UPDATE

	SC_BEFORE_TIMESTEP

	SC_STATUS_LAST

	SC_STATUS_ANY

	SC_FS

	SC_PS

	SC_NS

	SC_US

	SC_MS

	SC_SEC

	SC_INFO

	SC_WARNING

	SC_ERROR

	SC_FATAL

	SC_MAX_SEVERITY

	SC_NONE

	SC_LOW

	SC_MEDIUM

	SC_HIGH

	SC_FULL

	SC_DEBUG

	SC_UNSPECIFIED

	SC_DO_NOTHING

	SC_THROW

	SC_LOG

	SC_DISPLAY

	SC_CACHE_REPORT

	SC_INTERRUPT

	SC_STOP

	SC_ABORT

	SC_DEFAULT_INFO_ACTIONS

	SC_DEFAULT_WARNING_ACTIONS

	SC_DEFAULT_ERROR_ACTIONS

	SC_DEFAULT_FATAL_ACTIONS

	SC_DEFAULT_CATCH_ACTIONS

static SC_API_VERSION_STRING< &SC_DISABLE_VIRTUAL_BIND_CHECK_ >	api_version_check (SC_DEFAULT_WRITER_POLICY)

SC_API const char	SC_ID_REGISTER_ID_FAILED_ []

SC_API_TEMPLATE_DECL_	sc_ppq< sc_time *>

SC_API_TEMPLATE_DECL_	sc_port< sc_event_queue_if, 1, SC_ONE_OR_MORE_BOUND >

class SC_API	sc_event

class SC_API	sc_port_base

class SC_API	sc_reset

SC_API_TEMPLATE_DECL_	sc_signal_t< bool, SC_ONE_WRITER >

SC_API_TEMPLATE_DECL_	sc_signal_t< bool, SC_MANY_WRITERS >

SC_API_TEMPLATE_DECL_	sc_signal_t< bool, SC_UNCHECKED_WRITERS >

SC_API_TEMPLATE_DECL_	sc_port< sc_signal_in_if< bool >, 1, SC_ONE_OR_MORE_BOUND >

SC_API_TEMPLATE_DECL_	sc_port< sc_signal_inout_if< bool >, 1, SC_ONE_OR_MORE_BOUND >

SC_API const sc_dt::sc_logic_value_t	sc_logic_resolution_tbl [4][4]

sc_byte_heap SC_API	sc_temp_heap

const int	SC_DEFAULT_STACK_SIZE

SC_API const sc_bind_proxy	SC_BIND_PROXY_NIL

class SC_API	sc_module

class SC_API	sc_simcontext

class SC_API	sc_trace_file

class SC_API	sc_trace_file_base

const char	SC_HIERARCHY_CHAR

bool	sc_enable_name_checking

SC_API bool	sc_allow_process_control_corners

SC_API sc_simcontext *	sc_curr_simcontext

SC_API sc_simcontext *	sc_default_global_context

const int	SC_SIM_OK

const int	SC_SIM_ERROR

const int	SC_SIM_USER_STOP

class SC_API	sc_time_tuple

SC_API const sc_time	SC_ZERO_TIME

SC_API const unsigned int	sc_version_major

SC_API const unsigned int	sc_version_minor

SC_API const unsigned int	sc_version_patch

SC_API const std::string	sc_version_originator

SC_API const std::string	sc_version_release_date

SC_API const std::string	sc_version_prerelease

SC_API const bool	sc_is_prerelease

SC_API const std::string	sc_version_string

SC_API const std::string	sc_copyright_string

const int	SC_DISABLE_VIRTUAL_BIND_CHECK_

SC_TPLEXTERN_ template struct SC_API	SC_API_VERSION_STRING< &SC_DISABLE_VIRTUAL_BIND_CHECK_ >

const int	PHASH_DEFAULT_MAX_DENSITY

const int	PHASH_DEFAULT_INIT_TABLE_SIZE

SC_API const double	PHASH_DEFAULT_GROW_FACTOR

const bool	PHASH_DEFAULT_REORDER_FLAG

SC_API const char	SC_ID_UNKNOWN_ERROR_ []

SC_API const char	SC_ID_WITHOUT_MESSAGE_ []

SC_API const char	SC_ID_NOT_IMPLEMENTED_ []

SC_API const char	SC_ID_INTERNAL_ERROR_ []

SC_API const char	SC_ID_ASSERTION_FAILED_ []

SC_API const char	SC_ID_OUT_OF_BOUNDS_ []

SC_API const char	SC_ID_ABORT_ []

class SC_API	sc_object

Variable Documentation

◆ sc_object

class SC_API sc_core::sc_object

Definition at line 24 of file convenience_socket_bases.h.

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Variable Documentation

◆ sc_object