SPEEDES 0.4

• SPEEDES 0.4
  • SPEEDES Fundamentals
    • EVENTS--------------------------------------------------------------------------+
    • C_EVENT
    • CancelEvent
    • ReScheduleEvent
    • ScheduleEvent
    • ScheduleEventHandler
    • OBJECTS------------------------------------------------------------------------+
    • C_GLOBAL_NAME
    • C_OBJMAN
    • C_SIMOBJ
    • ROLLBACKABLE OPERATIONS------------------------------------+
    • BASE_STATE
    • RB_ostream
    • STATE_DOUBLE
    • STATE_FLOAT
    • STATE_INT
    • STATE_POINTER
    • STATE_STRING
    • SIMULATED TIME---------------------------------------------------------+
    • SIMTIME
    • operator!=
    • operator<
    • operator<<
    • operator<=
    • operator==
    • operator>
    • operator>=
  • Utilities
    • MISCELLANEOUS----------------------------------------------------------+
    • C_FREE_LIST
    • C_HOLDER
    • C_RANDOM
    • DATA_PARSER
    • STOPWATCH
    • NON-ROLLBACKABLE CONTAINERS---------------------------+
    • C_DBL_ITEM
    • C_DBL_QUEUE
    • C_DUMMY_V
    • C_HASH
    • C_ITEM
    • C_QUEUE
    • RB_DELETE_SINGLE_C_ITEM
    • RB_NEW_C_ITEM
    • delete_single_C_ITEM
    • ROLLBACKABLE CONTAINERS------------------------------------+
    • C_SQ_ITEM
    • C_XHASH
    • C_XQUEUE
    • RB_DELETE_ARRAY_C_SQ_ITEM
    • RB_DELETE_SINGLE_C_SQ_ITEM
    • RB_DELETE_SINGLE_C_XQUEUE
    • RB_NEW_C_SQ_ITEM
    • RB_NEW_C_SQ_ITEM
    • RB_NEW_C_XQUEUE
    • delete_C_SQ_ITEM_array
    • delete_single_C_SQ_ITEM
    • delete_single_C_XQUEUE

toc

SPEEDES 0.4

toc

SPEEDES Fundamentals

toc

EVENTS--------------------------------------------------------------------------+

toc

class C_EVENT : public C_SQ_ITEM

Class: C_EVENT
Summary: A generic simulation event
Description: This is the fundamental active building block in SPEEDES
             applications that acts on C_SIMOBJs. It is also the way SPEEDES
             passes simulated time. C_EVENTs are discrete events are designed
             to act on a single class (type) of simulation object, ie, a
             particular descendent of C_SIMOBJ. Events are generally also
             responsible for scheduling other events. To achieve maximum
             reuse, C_EVENTs should provide all of the actions and
             associations between C_SIMOBJs.

Public Interface

C_EVENT	GetRBQ	WriteLookaheadfile
attach_object	calculate_tmin	cancel
cancel_event	check_canceled	check_clear
check_proc	cleanup	clear_data
clear_messages	commit	create_object
create_object	create_object	create_object
delete_MESSAGE	destroy_object	destroy_object
event_type	exchange	get_CANCEL
get_CREATE	get_DESTROY	get_EVENT_HANDLER_EVENT
get_EVENT_TYPE	get_GLOBAL_ID	get_HOST_USER
get_LOCAL_ID	get_MESSAGE	get_NODE
get_N_NODES	get_OBJECT_TYPE	get_RANDOM
get_SIMOBJ	get_amque	get_cancel_id
get_dbl_item	get_event_canceled	get_evtptr
get_free	get_lazy	get_lazy_proc
get_manager	get_mque	get_nopt
get_objects	get_processed	get_rbid
get_rbq	get_tmin	get_valid
getmess	init	init_qroll_backs
insert	lazy	lazy_rollback
local_messages	memory_print	object_type
open_Lookaheadfile	open_tracefile	optimistic_insert
perm_process	pop_roll_back	print_event_memory
process	reset_WriteLookahead	reset_event_canceled
reset_lazy	reset_lazy_proc	reset_processed
reset_trace	reset_valid	rollback
rollback_event	schedule	schedule
schedule	schedule	sendmess
set_CANCEL	set_CREATE	set_DESTROY
set_EVENT_HANDLER_EVENT	set_EVENT_TYPE	set_GLOBAL_ID
set_HOST_USER	set_LOCAL_ID	set_MESSAGE
set_NODE	set_N_NODES	set_OBJECT_TYPE
set_RANDOM	set_SIMOBJ	set_WriteLookahead
set_cancel_id	set_event_canceled	set_evtype
set_free	set_lazy	set_lazy_proc
set_objects	set_processed	set_rbid
set_rbq	set_trace	set_valid
set_valid_opt	spin_loop	temp_process
trace	void_event	enable_lazy
set_one_node_flag	set_qproc	set_twosmess

Public Interface

C_EVENT

() ;

C_RBQ* GetRBQ

() ;

INTERNAL METHOD

void WriteLookaheadfile

( const SIMTIME& t2 , int ty2 , int ot2 , int id2 , int nd ) ;

Method: WriteLookaheadfile 
Summary: Write to the lookahead file, if enabled
Description: 
Return: None

t2

Lookahead time.

ty2

Second object EVENT_TYPE.

ot2

Second object OBJECT_TYPE.

id2

Second object LOCAL_ID.

nd

Second object NODE.

void attach_object

() ;

INTERNAL METHOD

void calculate_tmin

() ;

INTERNAL METHOD

void cancel

( void* ch ) ;

Method: cancel 
Summary: Cancel the event specified by a C_CANCEL_HANDLE
Description: The event to be cancelled must have been scheduled with the
             cancel handle used here (C_CANCEL_HANDLE), and the event to
             cancel must be in the simulated time future.
Return: None.

ch

IN: the cancel handle (C_CANCEL_HANDLE) of the event to cancel, which was the first argument in that event's schedule () call.

int cancel_event

() ;

INTERNAL METHOD

int check_canceled

( int& n_roll ) ;

INTERNAL METHOD

n_roll

Number of rollbacks.

int check_clear

() ;

INTERNAL METHOD

int check_proc

( int flag ) ;

INTERNAL METHOD

virtual void cleanup

() ;

Virtual Method: cleanup 
Summary: User-written code called in the event destructor
Description: 
Return: None

void clear_data

() ;

INTERNAL METHOD

void clear_messages

() ;

INTERNAL METHOD

virtual void commit

() ;

Virtual Method: commit 
Summary: The part of the user process code that is run after the event is
         committed (same as perm_process())
Description: The user should override this method whenever they want code to
             be guaranteed not to rollback. This is achieved by the SPEEDES
             framework by calling this method after the event has been
             committed (ie, after it has passed global virtual time and thus
             won't ever again rollback). This method is overridden whenever
             the user needs to call code outside of the SPEEDES framework and
             calling it more than once is undesired (such as calling screen
             graphics). An alternative to using commit() is to extend the
             SPEEDES framework with rollbackable items that can thus be used
             within the process() method.
Return: None

void* create_object

( SIMTIME& time , int object_type , int object_node ) ;

Overloaded Method: create_object
Summary: Schedule for dynamically creating a simulation object (C_SIMOBJ)
Description: This is simply a schedule call for a CREATE event. Like all
             schedule calls, it returns the associated message.
Return: the message for dynamically created simulation object (C_SIMOBJ)

time

IN: simulated time to create the object.

object_type

IN: type of object to create.

object_node

IN: node on which to create the object.

void* create_object

( void* ch , SIMTIME& time , int object_type , int object_node ) ;

Overloaded Method: create_object
Summary: Schedule for dynamically creating a simulation object (C_SIMOBJ)
Description: This is simply a schedule call for a CREATE event. Like all
             schedule calls, it returns the associated message.
Return: the message for dynamically created simulation object (C_SIMOBJ)

ch

Cancel handle (see schedule method).

time

IN: simulated time to create the object.

object_type

IN: type of object to create.

object_node

IN: node on which to create the object.

void* create_object

( SIMTIME& time , int object_type , int object_node , int mess_size , char*& buf ) ;

Overloaded Method: create_object
Summary: Schedule for dynamically creating a simulation object (C_SIMOBJ)
Description: This is simply a schedule call for a CREATE event. Like all
             schedule calls, it returns the associated message.
Return: the message for dynamically created simulation object (C_SIMOBJ)

time

IN: simulated time to create the object.

object_type

IN: type of object to create.

object_node

IN: node on which to create the object.

mess_size

IN: (OPTIONAL) number of bytes of the variable-length part of the event message.

buf

IN: (USED IF AND ONLY IF "mess_size" IS USED) the variable-length part of the event message.

void* create_object

( void* ch , SIMTIME& time , int object_type , int object_node , int mess_size , char*& buf ) ;

Overloaded Method: create_object
Summary: Schedule for dynamically creating a simulation object (C_SIMOBJ)
Description: This is simply a schedule call for a CREATE event. Like all
             schedule calls, it returns the associated message.
Return: the message for dynamically created simulation object (C_SIMOBJ)

ch

Cancel handle (see schedule method).

time

IN: simulated time to create the object.

object_type

IN: type of object to create.

object_node

IN: node on which to create the object.

mess_size

IN: (OPTIONAL) number of bytes of the variable-length part of the event message.

buf

IN: (USED IF AND ONLY IF "mess_size" IS USED) the variable-length part of the event message.

void delete_MESSAGE

() ;

INTERNAL METHOD

void* destroy_object

( SIMTIME& time , int object_type , int object_id , int object_node ) ;

Overloaded Method: destroy_object 
Summary: Schedule for dynamically destroying (deleting) a simulation object
         (C_SIMOBJ)
Description: This is simply a schedule call for a DESTROY event. Like all
             schedule calls, it returns the associated message.
Return: the message for dynamically destroyed simulation object (C_SIMOBJ)

time

IN: simulated time to destroy the object.

object_type

IN: type of object to destroy.

object_id

IN: the LOCAL_ID of the object to destroy.

object_node

IN: node on which to destroy the object.

void* destroy_object

( void* ch , SIMTIME& time , int object_type , int object_id , int object_node ) ;

Overloaded Method: destroy object
Summary: Schedule for dynamically destroying (deleting) a simulation object
         (C_SIMOBJ)
Description: This is simply a schedule call for a DESTROY event. Like all
             schedule calls, it returns the associated message.
Return: the message for dynamically destroyed simulation object (C_SIMOBJ)

ch

Cancel handle (see schedule method).

time

IN: simulated time to destroy the object.

object_type

IN: type of object to destroy.

object_id

IN: the LOCAL_ID of the object to destroy.

object_node

IN: node on which to destroy the object.

int event_type

( char* c ) ;

Method: event_type
Summary: Get the enumerated ID for an event type, specified by the event
         type's string name
Description: 
Return: the enumerated ID for an event type

virtual void exchange

() ;

Virtual Method: exchange 
Summary: This is for the user to write exchange code for fast rollbacks.
Description: This is usually not required, since rollbackable items in the
             process virtual method essentially undergo exchanges
             automatically. But if rollbackable items are not available for
             certain state data, this method allows the user to write
             low-level code to exchange a value with a saved previous
             value. The SPEEDES framework calls this method whenever
             performing a rollback.
Return: None 

int get_CANCEL

() ;

Method: get_CANCEL 
Summary: Get the ID (ie, the enumerated type) of the CANCEL event
Description: This is used for scheduling CANCEL events, which are events that
             cancel other non-committed events on the event queue
Return: the ID (ie, the enumerated type) of the CANCEL event

int get_CREATE

() ;

Method: get_CREATE 
Summary: Get the ID (ie, the enumerated type) of the CREATE event
Description: This is used for scheduling CREATE events, which are events that
             dynamically create simulation objects (C_SIMOBJs)
Return: the ID (ie, the enumerated type) of the CREATE event

int get_DESTROY

() ;

Method: get_DESTROY 
Summary: Get the ID (ie, the enumerated type) of the DESTROY event
Description: This is used for scheduling DESTROY events, which are events that
             dynamically destroy (delete) simulation objects (C_SIMOBJs)
Return: the ID (ie, the enumerated type) of the DESTROY event

int get_EVENT_HANDLER_EVENT

() ;

Method: get_EVENT_HANDLER_EVENT
Summary: Get the ID (ie, the enumerated type) of the EVENT_HANDLER_EVENT
         event
Description: This is used internally by SPEEDES to get the id of the event
             handler event
Return: the ID (ie, the enumerated type) of the DESTROY event

int get_EVENT_TYPE

() ;

Method: get_EVENT_TYPE 
Summary: Get the ID (or enumerated type) of the type of this event
Description: A unique EVENT_TYPE is required for each C_EVENT class, and is
             found in event_types.C
Return: the OBJECT_TYPE, ie, the ID of the type of this simulation type

int get_GLOBAL_ID

() ;

Method: get_GLOBAL_ID 
Summary: Get the unique ID, simulaiton-wide, of the object associated with
         this event. GLOBAL_ID generated automatically, but can be overridden
         by the user.
Description: 
Return: the unique ID of this simulation object

C_HOST_USER* get_HOST_USER

() ;

INTERNAL METHOD

int get_LOCAL_ID

() ;

Method: get_LOCAL_ID 
Summary: Get the ID of the simulation object associated with this event
Description: Each object manager has its own set of C_SIMOBJs, each with
             their own LOCAL_ID. Thus LOCAL_ID only needs to be unique for a
             given object manager (C_OBJMAN), not unique to a given node or
             to a given simulation
Return: the ID of this simulation object

C_HEADER* get_MESSAGE

() ;

Method: get_MESSAGE 
Summary: Get the message used to enact this event
Description: This is a fundamental method for C_EVENT, since events are
             enacted by a message, and that message often contains
             information intended to be extracted by its effected event. Use
             this method get and then read the contents of the message.
Return: the message used to enact this event

int get_NODE

() ;

Method: get_NODE 
Summary: Get the node (process number on local machine) that this C_SIMOBJ is
         instantialted on. 
Description: 
Return: the node (process number on local machine) that this C_SIMOBJ
        is instantialted on.

int get_N_NODES

() ;

Method: get_N_NODES
Summary: Get the total number of nodes (process number on local machine) in
         the entire simulation (including all other machines' process)
Description: 
Return: total number of nodes

int get_OBJECT_TYPE

() ;

Method: get_OBJECT_TYPE 
Summary: Get the ID (or enumerated type) of the type of the simulation
         object associated with this event
Description: A unique OBJECT_TYPE is required for each C_SIMOBJ class.  Each
             C_SIMOBJ class is managed by one instantiation of
             C_OBJMAN. Thus, the OBJECT_TYPE also uniquely defines the type
             of C_SIMOBJ that each instantiation of C_OBJMAN manages. Each
             node has a single instantiation of C_OBJECTS, which in turn
             manages a list of C_OBJMANs. C_OBJECTS refers to each C_OBJMAN
             by the OBJECT_TYPE it manages.
Return: the OBJECT_TYPE, ie, the ID of the type of this simulation type

C_RANDOM* get_RANDOM

() ;

Method: get_RANDOM 
Summary: Get the random number generator. There is exactly one C_RANDOM
         object per node, set automatically by the framework.
Description: see C_RANDOM
Return: the random number generator

C_SIMOBJ* get_SIMOBJ

() ;

Method: get_SIMOBJ
Summary: Get the simulation object (C_SIMOBJ) associated with this event
Description: This is a fundamental method for C_EVENT, since events are
             designed to act upon one type of simulation object, ie one class
             that inherits from C_SIMOBJ. Use this method to read and write
             to the simulation object on which the event is acting.
Return: the simulation object associated with this event

C_QUEUE* get_amque

() ;

INTERNAL METHOD

int get_cancel_id

() ;

INTERNAL METHOD

C_DBL_ITEM* get_dbl_item

() ;

INTERNAL METHOD

int get_event_canceled

() ;

INTERNAL METHOD

C_LPTR* get_evtptr

() ;

INTERNAL METHOD

int get_free

() ;

INTERNAL METHOD

int get_lazy

() ;

INTERNAL METHOD

int get_lazy_proc

() ;

INTERNAL METHOD

void* get_manager

( int om ) ;

Method: get_manager 
Summary: Get the object manager for another simulation object, specified by
         its OBJECT_TYPE
Description: 
Return: an object manager, casted to (void *)

om

IN: OBJECT_TYPE of the desired object manager.

C_QUEUE* get_mque

() ;

INTERNAL METHOD

int get_nopt

() ;

INTERNAL METHOD

C_OBJECTS* get_objects

() ;

INTERNAL METHOD

int get_processed

() ;

INTERNAL METHOD

int get_rbid

() ;

INTERNAL METHOD

C_QUEUE* get_rbq

() ;

INTERNAL METHOD

double get_tmin

() ;

INTERNAL METHOD

int get_valid

() ;

INTERNAL METHOD

void getmess

( C_QUEUE* q1nd ) ;

INTERNAL METHOD

q1nd

OUT: the messages coming in.

virtual void init

( C_HEADER* ) ;

Virtual Method: init 
Summary: Initialize this event
Description: This is for the user to write code that gets executed in this
             event's constructor. That is, code in this method will not occur
             in the process virtual method phase, and thus will not get
             rolled back.
Return: None

The framework passes in the message for the event here, and its use is optional.

void init_qroll_backs

() ;

INTERNAL METHOD

void insert

() ;

INTERNAL METHOD

virtual int lazy

() ;

Virtual Method: lazy 
Summary: User code written to determine, each time this event rolls back,
         whether to roll forward (and thus avoid the overhead of sending
         antimessages and reprocessing) or to undergo the normal rollback
         operations.
Description: Often when an event gets rolled back and reproccessed, the
             results of the simulation are the same (or nearly the same) as
             if the framework didn't roll it back at all even though it was
             processed out of simulated time order. This is user code to
             determine whether this event should send out antimessages when
             it gets rolled back (like a regular rollback) or whether, after
             rolling back, tests show that nothing critical would change by
             sending out antimessages and thus it can simply roll forward
             back to where it was before it got rolled back.
Return: flag for whether the lazy test passed (non-zero = pass). If it
        passes, and if lazy cancellation is enabled, this event is rolled
        forward without sending out antimessages. If it fails, it is treated
        just like any other rollback.

int lazy_rollback

() ;

INTERNAL METHOD

int local_messages

() ;

INTERNAL METHOD

void memory_print

() ;

Method: memory_print 
Summary: print out event free list memory statistics
Description: 
Return: None

int object_type

( char* c ) ;

Method: object_type
Summary: Retrieves a simulation object's OBJECT_TYPE (see set_OBJECT_TYPE)
         based on its string NAME
Description: 
Return: the object type of this simulation object

void open_Lookaheadfile

( char* filename ) ;

Method: open_Lookaheadfile 
Summary: Open a file into which to output lookahead information
Description: 
Return: None

void open_tracefile

( char* filename ) ;

Method: open_tracefile 
Summary: Open a file into which to output trace information (see trace())
Description: 
Return: None

filename

Filename for trace output.

int optimistic_insert

() ;

INTERNAL METHOD

virtual void perm_process

() ;

Virtual Method: perm_process
Summary: The part of the user process code that is run after the event is
         committed (same as commit())
Description: The user should override this method whenever they want code to
             be guaranteed not to rollback. This is achieved by the SPEEDES
             framework by calling this method after the event has been
             committed (ie, after it has passed global virtual time and thus
             won't ever again rollback). This method is overridden whenever
             the user needs to call code outside of the SPEEDES framework and
             calling it more than once is undesired (such as calling screen
             graphics). An alternative to using commit() is to extend the
             SPEEDES framework with rollbackable items that can thus be used
             within the process() method.
Return: None

void pop_roll_back

() ;

INTERNAL METHOD

void print_event_memory

() ;

Method: print_event_memory 
Summary: print out event free list memory statistics
Description: 
Return: None

virtual void process

() ;

Virtual Method: process 
Summary: The main process user code block (same as temp_process())
Description: The user overrides this method for essentially every C_EVENT.
             That is because it is the place where the body of user code is
             written for the event. It is the only virtual method wherein
             rollbackable operations (such as using STATE variables, etc.)
             are permitted. State information that is not rollbackable should
             not be used in this method, since this method is run more than
             once whenever it is rolled back and reprocessed. Also, calls to
             outside of the SPEEDES framework should not go here for the same
             reason, and should instead occur in the commit virtual function.
Return: None

void reset_WriteLookahead

() ;

Method: reset_WriteLookahead 
Summary: Disable write lookahead
Description: 
Return: None

void reset_event_canceled

() ;

INTERNAL METHOD

void reset_lazy

() ;

Method: reset_lazy 
Summary: Disable lazy cancellation
Description: 
Return: None

void reset_lazy_proc

() ;

INTERNAL METHOD

void reset_processed

() ;

INTERNAL METHOD

void reset_trace

() ;

Method: reset_trace 
Summary: Disable tracing this event
Description: 
Return: None

void reset_valid

() ;

INTERNAL METHOD

int rollback

() ;

INTERNAL METHOD

int rollback_event

() ;

INTERNAL METHOD

void* schedule

( const SIMTIME& time , int event_type , int object_type , int object_id , int object_node ) ;

Overloaded Method: schedule
Summary: Schedule an event at the present or a future simulated time for any
         simulation object (C_SIMOBJ) in the simulation
Description: This is a fundamental method for C_EVENT, since events are
             generally responsible for scheduling future events. The message
             for this event schedule is returned (*C_HEADER), and should be
             subsequently filled in. This is OK, since the message isn't sent
             until after the event user code (the process() virtual method)
             completes.
Return: the message for this scheduled event (*C_HEADER)

time

IN: simulated time.

event_type

IN: enumerated or integer type of event to schedule.

object_type

IN: enumerated or integer type of object for which to schedule the event (must be the one type of object required for the event_type).

object_id

IN: the LOCAL_ID of the object for which to schedule the event.

object_node

IN: the NODE of the object for which to schedule the event.

void* schedule

( void* ch , const SIMTIME& time , int event_type , int object_type , int object_id , int object_node ) ;

Overloaded Method: schedule
Summary: Schedule a cancelable event at the present or a future simulated
         time for any simulation object (C_SIMOBJ) in the simulation
Description: This is a fundamental method for C_EVENT, since events are
             generally responsible for scheduling future events. The message
             for this event schedule is returned (inherited from C_HEADER),
             and should be subsequently filled in. This is OK, since the
             message isn't sent until after the event user code (the
             process() virtual method) completes. The cancel handle (first
             argument) simply must be an uninitialized object (ie, the user
             need only create it, not fill it in) of type C_CANCEL_HANDLE (or
             equivalently, C_ANTIMESS, which is what it is typedef'd
             with). This function returns the handle filled-in with all of
             the information to use this handle later in the cancel () call,
             to later cancel the event now being scheduled. The cancel ()
             call, if later called by the user, will cancel the event now
             being scheduled by scheduling a CANCEL event. When calling
             cancel (), the event to cancel must be in the simulated time
             future.
Return: The message for this scheduled event (inherited from C_HEADER)

ch

INOUT: cancel handle.

time

IN: simulated time.

event_type

IN: enumerated or integer type of event to schedule.

object_type

IN: enumerated or integer type of object for which to schedule the event (must be the one type of object required for the event_type).

object_id

IN: the LOCAL_ID of the object for which to schedule the event.

object_node

IN: the NODE of the object for which to schedule the event.

void* schedule

( const SIMTIME& time , int event_type , int object_type , int object_id , int object_node , int mess_size , char*& buf ) ;

Overloaded Method: schedule
Summary: Schedule an event at the present or a future simulated time for any
         simulation object (C_SIMOBJ) in the simulation. This version of
         schedule () allows the event's message to contain a variable-length
         character buffer as well as the variables contained in the inherited
         C_HEADER.
Description: This is a fundamental method for C_EVENT, since events are
             generally responsible for scheduling future events. The message
             for this event schedule is returned (*C_HEADER), and should be
             subsequently filled in. This is OK, since the message isn't sent
             until after the event user code (the process() virtual method)
             completes.
Return: the message for this scheduled event (*C_HEADER)

time

IN: simulated time.

event_type

IN: enumerated or integer type of event to schedule.

object_type

IN: enumerated or integer type of object for which to schedule the event (must be the one type of object required for the event_type).

object_id

IN: the LOCAL_ID of the object for which to schedule the event.

object_node

IN: the NODE of the object for which to schedule the event.

mess_size

IN: (OPTIONAL) number of bytes of the variable-length part of the event message.

buf

IN: (USED IF AND ONLY IF "size" IS USED) the variable-length part of the event message.

void* schedule

( void* ch , const SIMTIME& time , int event_type , int object_type , int object_id , int object_node , int mess_size , char*& buf ) ;

Overloaded Method: schedule
Summary: Schedule a cancelable event at the present or a future simulated
         time for any simulation object (C_SIMOBJ) in the simulation. This
         version of schedule () allows the event's message to contain a
         variable-length character buffer as well as the variables contained
         in the inherited C_HEADER.
Description: This is a fundamental method for C_EVENT, since events are
             generally responsible for scheduling future events. The message
             for this event schedule is returned (inherited from C_HEADER),
             and should be subsequently filled in. This is OK, since the
             message isn't sent until after the event user code (the
             process() virtual method) completes. The cancel handle (first
             argument) simply must be an uninitialized object (ie, the user
             need only create it, not fill it in) of type C_CANCEL_HANDLE (or
             equivalently, C_ANTIMESS, which is what it is typedef'd
             with). This function returns the handle filled-in with all of
             the information to use this handle later in the cancel () call,
             to later cancel the event now being scheduled. The cancel ()
             call, if later called by the user, will cancel the event now
             being scheduled by scheduling a CANCEL event. When calling
             cancel (), the event to cancel must be in the simulated time
             future.
Return: The message for this scheduled event (inherited from C_HEADER)

ch

IN: cancel handle.

time

IN: simulated time.

event_type

IN: enumerated or integer type of event to schedule.

object_type

IN: enumerated or integer type of object for which to schedule the event (must be the one type of object required for the event_type).

object_id

IN: the LOCAL_ID of the object for which to schedule the event.

object_node

IN: the NODE of the object for which to schedule the event.

mess_size

IN: (OPTIONAL) number of bytes of the variable-length part of the event message.

buf

IN: (USED IF AND ONLY IF "size" IS USED) the variable-length part of the event message.

void sendmess

( C_QUEUE* q1nd ) ;

INTERNAL METHOD

q1nd

IN: the messages to send out.

void set_CANCEL

( int c ) ;

INTERNAL METHOD

void set_CREATE

( int c ) ;

INTERNAL METHOD

void set_DESTROY

( int d ) ;

INTERNAL METHOD

void set_EVENT_HANDLER_EVENT

( int e ) ;

INTERNAL METHOD

void set_EVENT_TYPE

( int et ) ;

INTERNAL METHOD

void set_GLOBAL_ID

( int g ) ;

INTERNAL METHOD

void set_HOST_USER

( C_HOST_USER* h ) ;

INTERNAL METHOD

void set_LOCAL_ID

( int l ) ;

INTERNAL METHOD

void set_MESSAGE

( C_HEADER* h ) ;

INTERNAL METHOD

void set_NODE

( int nd ) ;

INTERNAL METHOD

void set_N_NODES

( int nds ) ;

INTERNAL METHOD

void set_OBJECT_TYPE

( int ot ) ;

INTERNAL METHOD

void set_RANDOM

( C_RANDOM* ran ) ;

INTERNAL METHOD

void set_SIMOBJ

( C_SIMOBJ* g ) ;

INTERNAL METHOD

void set_WriteLookahead

() ;

Method: set_WriteLookahead 
Summary: Enable write lookahead
Description: 
Return: None

void set_cancel_id

( int cid ) ;

INTERNAL METHOD

void set_event_canceled

() ;

INTERNAL METHOD

void set_evtype

( C_EVENT_TYPES* et ) ;

INTERNAL METHOD

void set_free

() ;

INTERNAL METHOD

void set_lazy

() ;

Method: set_lazy 
Summary: Enable lazy cancellation
Description: 
Return: None

void set_lazy_proc

() ;

INTERNAL METHOD

void set_objects

( C_OBJECTS* obj ) ;

INTERNAL METHOD

void set_processed

() ;

INTERNAL METHOD

void set_rbid

( int r ) ;

INTERNAL METHOD

void set_rbq

( C_RBQ* r ) ;

INTERNAL METHOD

void set_trace

() ;

Method: set_trace 
Summary: Enable tracing this event
Description: 
Return: None

void set_valid

() ;

INTERNAL METHOD

void set_valid_opt

() ;

INTERNAL METHOD

void spin_loop

( double twait ) ;

INTERNAL METHOD

twait

Amount of time to add to the desired point in time to wait.

virtual void temp_process

() ;

Virtual Method: temp_process 
Summary: The main process user code block (same as process())
Description: This method is essentially always overridden for every C_EVENT.
             That is because it is the place where the body of user code is
             written for the event. It is the only virtual method wherein
             rollbackable operations (such as using STATE variables, etc.)
             are permitted. State information that is not rollbackable should
             not be used in this method, since this method is run more than
             once whenever it is rolled back and reprocessed. Also, calls to
             outside of the SPEEDES framework should not go here for the same
             reason, and should instead occur in the commit virtual function.
Return: None

void trace

() ;

Method: trace 
Summary: Trace this event
Description: Provide statistics about this event to a trace file during run
             time
Return: None

virtual int void_event

() ;

INTERNAL METHOD

static void enable_lazy

() ;

INTERNAL METHOD

static void set_one_node_flag

( int onf ) ;

INTERNAL METHOD

static void set_qproc

( C_DBL_QUEUE* q ) ;

INTERNAL METHOD

static void set_twosmess

( void* tm ) ;

INTERNAL METHOD

Protected Interface

Protected Data

static int CANCEL;

Cancel event type id.

static int CREATE;

Create object event type id.

static int DESTROY;

Destroy object event type id.

static int EVENT_HANDLER_EVENT;

Event handler event type id.

int EVENT_TYPE;

Event type.

int GLOBAL_ID;

Global id for simobj.

static C_HOST_USER* HOST_USER;

Host user object.

C_HEADER* MESSAGE;

Pointer to event message.

static int NODE;

Node.

static int N_NODES;

Number of nodes.

int OBJECT_TYPE;

Object type.

static C_RANDOM* RANDOM;

Random number generator.

C_SIMOBJ* SIMOBJ;

Generic object for all objects.

static C_RBQ* rbq;

Roll back queue manager.

Private Interface

Private Data

static int EnableLazy;

Lazy cancellation enabled flag.

static FILE* LookaheadFP;

File pointer for lookahead file.

static char* Lookaheadfile;

Name of lookahead file.

static int WriteLookahead;

Write lookahead file (1=on, 0=off).

int cancel_id;

Cancel event id.

C_DBL_ITEM dbl_item;

Processed event item.

static C_DBL_QUEUE* dbl_qproc;

Queue of processed events.

int event_canceled;

Event has canceled flag.

C_LPTR evtptr;

Optimistic event object.

static C_EVENT_TYPES* evtype;

Event and message memory manager.

static int first_cancel;

Flag for first canceled event.

int free_flag;

Flag set only by free list management.

static int gencid;

Generated cancel id.

int lazy_flag;

Flag for lazy cancellation.

int lazy_proc;

Flag for lazy processed.

static C_OBJECTS* objects;

Object manager.

C_OBJEVT objevt;

Object event status and link.

static int one_node_flag;

One node flag.

C_QUEUE optevts;

Queue of optimistically generated events.

C_QUEUE qanti;

Queue of outgoing antimessages.

C_QUEUE qmessout;

Queue of outgoing messages.

C_QUEUE qroll_backs;

Queue of roll backs.

int rbid;

Roll back unique id.

static double spin_clock;

Clocked spin time.

static double spin_time;

Desired spin time.

double tmin;

Minimum time of a generated message.

static FILE* traceFP;

File pointer for trace file.

static char* tracefile;

Name of trace file.

static int traceflag;

Trace flag (1 means on, 0 means off).

int valid;

Valid event flag.

Function: CancelEvent
Summary: Cancels an event (or event handler) that was previously scheduled.
Description: This function may be called from anywhere in a SPEEDES
             application to retract an event that was previously scheduled.
Return: void

Function: ReScheduleEvent
Summary: Re-schedules the same event to be processed for the same simobj at
         a future time.
Description: This function can be called from anywhere within SPEEDES to
             reschedule the same event for the same simobj for processing
             at a later time.
Return: A cancel handle for the event which can be later used to retract
        the event before it is processed. Applications are not required to
        use this returned value.

Function: ScheduleEvent
Summary: Schedules an event to be processed for a simobj at a specified.
         time. Events must never be scheduled in the past of the current
         event.
Description: This function can be called from anywhere within SPEEDES to
             schedule an event. An event must have a time tag, event type
             simulation object type, simulation object local Id, and node
             number to uniquely identify the event and the simobj that it
             acts on. Optional arguments are the message header (users must
             set specified data members before making the schedule call), and
             a variable data buffer followed by the number of bytes. If the
             variable data buffer is not provided, the SPEEDES internal
             free list mechanisms are used to reduce overheads.
Return: A cancel handle for the event which can be later used to retract
        the event before it is processed. Applications are not required to
        use this returned value.

Overloaded Function: ScheduleEventHandler
Summary: Schedule an event handler for the present or future time for any
         simulation object (C_SIMOBJ) in the simulation. The data that
         is passed in gets delivered to the event handler when it is
         processed. The cancel handle is returned to the application and can
         later be used to retract the event.
Description: This method may be called from anywhere in a SPEEDES
             application and schedules an event handler for any simulation
             object. The eventName is the name of the event handler(s) that
             get invoked when the event is processed. The data passed in
             is what is delivered to the event handler. The cancel
             handle is returned to the user. This allows the event to later
             be retracted using the Cancel() method.
Return: void

toc

OBJECTS------------------------------------------------------------------------+

toc • >>

class C_GLOBAL_NAME : public C_ITEM

Class: C_GLOBAL_NAME
Summary: Structure for a hash table of global names
Description: Used only by C_OBJMAN

Public Interface

Public Data

int lid;

char name [ MAX_NAME_LENGTH ];

int node;

<< • toc • >>

class C_OBJMAN : public C_SIMOBJ

Class: C_OBJMAN
Summary: Manages (creates and distributes) the C_SIMOBJs of a given type on
         this node. Also, since this class inherits from C_SIMOBJ itself, it
         can handle events scheduled for itself (LOCAL_ID = -1).
Description: Descendants of this class should set the variables
             C_OBJMAN::N_LOC and C_OBJMAN::N_TOT, call reserve_n_objects ()
             and define_object (), and increment TOTAL_OBJECTS. To card deal
             this object type, use deal_me ().

Public Interface

C_OBJMAN	add_object	create_object
define_object	destroy_object	get_N_LOC
get_N_TOT	get_allids	get_allids_size
get_nodid	get_nodid	get_obj
get_oid	init_events	init_object
name_hash	print_global_names	remove_object
reserve_n_objects	reset_interact	set_N_LOC
set_N_LOC	set_N_TOT	set_global_names
set_interact	term

Public Interface

C_OBJMAN

() ;

void add_object

( C_SIMOBJ* simobj ) ;

INTERNAL METHOD

simobj

Dynamically created C_SIMOBJ to add to the simulation.

virtual C_SIMOBJ* create_object

() ;

Virtual Method: create_object
Summary: Dynamically (and rollbackably) create a C_SIMOBJ of this C_OBJMAN's
         OBJECT_TYPE
Description: Defaults to returning NULL (must be overridden)
Return: pointer to a dynamically-created C_SIMOBJ of this C_OBJMAN's
        OBJECT_TYPE

virtual void define_object

( C_SIMOBJ* gen ) ;

Virtual Method: define_object
Summary: Put a C_SIMOBJ into the array of C_SIMOBJs managed by this C_OBJMAN
Description: 
Return: None

gen

C_SIMOBJ to define.

virtual void destroy_object

( C_SIMOBJ* ) ;

Virtual Method: destroy_object
Summary: Dynamically (and rollbackably) destroy a C_SIMOBJ of this C_OBJMAN's
         OBJECT_TYPE
Description: Defaults to a pass-through method (must be overridden)
Return: None

C_SIMOBJ to destroy.

int get_N_LOC

() ;

Method: get_N_LOC
Summary: Get N_LOC, which is the total number of this C_OBJMAN's type of
         C_SIMOBJ on this node
Description: 
Return: N_LOC

int get_N_TOT

() ;

Method: get_N_TOT
Summary: Get N_TOT, which is the total number of this C_OBJMAN's type of
         C_SIMOBJ in the simulation
Description: 
Return: N_TOT

char* get_allids

() ;

INTERNAL METHOD

int get_allids_size

() ;

INTERNAL METHOD

void get_nodid

( char* name , int& nd , int& lid ) ;

Overloaded Method: get_nodid
Summary: Get the NODE and LOCAL_ID of the C_SIMOBJ specified by its NAME
Description: 
Return: None

name

IN: name of C_SIMOBJ of interest.

nd

OUT: The NODE of the C_SIMOBJ of interest.

lid

OUT: The LOCAL_ID of the C_SIMOBJ of interest.

virtual void get_nodid

( int oi , int& n , int& i ) ;

Overloaded Method: get_nodid
Summary: Get the NODE and LOCAL_ID of the C_SIMOBJ specified by its GLOBAL_ID
Description: 
Return: None

oi

IN: The GLOBAL_ID of the C_SIMOBJ of interest.

n

OUT: The NODE of the C_SIMOBJ of interest.

i

OUT: The LOCAL_ID of the C_SIMOBJ of interest.

virtual C_SIMOBJ* get_obj

( int oid ) ;

Virtual Method: get_obj
Summary: Get the C_SIMOBJ from this C_OBJMAN (ie, of this C_OBJMAN's
         OBJECT_TYPE) specified by LOCAL_ID
Description: 
Return: The C_SIMOBJ from this C_OBJMAN (ie, of this C_OBJMAN's OBJECT_TYPE)
        specified by LOCAL_ID

oid

Object ID (LOCAL_ID of output C_SIMOBJ).

virtual void get_oid

( int& oi , int n , int i ) ;

Virtual Method: get_oid
Summary: Get the GLOBAL_ID of the C_SIMOBJ specified by NODE and LOCAL_ID
Description: 
Return: None

oi

OUT: GLOBAL_ID of C_SIMOBJ of interest.

n

IN: NODE of C_SIMOBJ of interest.

i

IN: LOCAL_ID of C_SIMOBJ of interest.

virtual void init_events

() ;

Virtual Method: init_events
Summary: Method in which to schedule initial events.
Description: This method is called just before the beginning of the
             simulation.  (I.e., just prior to simulated time = zero). This
             is done so users can schedule evetns for simulated time =
             zero. Users schedule initial events in each C_OBJMAN on each
             node by overriding this method.
Return: None

virtual void init_object

( C_SIMOBJ* , void* ) ;

Virtual Method: init_object
Summary: Initialize a particular C_SIMOBJ managed by this C_OBJMAN 
Description: Defaults to a pass-through method (must be overridden)
Return: None

Intended as C_SIMOBJ to initialize.

Intended as initialization data.

int name_hash

( char* name ) ;

INTERNAL METHOD

void print_global_names

() ;

Method: print_global_names
Summary: Print the global name database to cout (see set_global_names())
Description: 
Return: None

void remove_object

( C_SIMOBJ* simobj ) ;

INTERNAL METHOD

simobj

C_SIMOBJ to remove from the simulation.

virtual void reserve_n_objects

( int n ) ;

Virtual Method: reserve_n_objects
Summary: Allocate memory for an array of n pointers to the C_SIMOBJs to be
         created by this C_OBJMAN
Description: By default,
Return: None

n

Number of objects to reserve.

void reset_interact

() ;

INTERNAL METHOD

void set_N_LOC

() ;

Method: set_N_LOC
Summary: Set N_LOC, which is the total number of this C_OBJMAN's type of
         C_SIMOBJ on this node
Description: Users are responsible to set this variable in this C_OBJMAN's
             constructor. This version of this overloaded method uses N_TOT
             (which must be set previously by the user) and N_NODES to
             determine N_LOC, using the deal_me () algorithm.
Return: None

void set_N_LOC

( int n ) ;

Overloaded Method: set_N_LOC
Summary: Set N_LOC, which is the total number of this C_OBJMAN's type of
         C_SIMOBJ on this node
Description: Users are responsible to set this variable in this C_OBJMAN's
             constructor
Return: None

n

N_LOC.

void set_N_TOT

( int n ) ;

Method: set_N_TOT
Summary: Set N_TOT, which is the total number of this C_OBJMAN's type of
         C_SIMOBJ in the simulation
Description: Users are responsible to set this variable in this C_OBJMAN's
             constructor
Return: None

n

N_TOT.

void set_global_names

() ;

Method: set_global_names
Summary: Creates a hash table of the NAMEs of all of the C_SIMOBJs in the
         simulation for easy lookups using get_nodid (char *name, int &nd,
         int &lid)
Description: The purpose of this method is to ease the burden on the user
             when scheduling events. This method uses global reduction
             techniques to create a local data base of each C_SIMOBJ in the
             simulation that has the NAME attribute defined (regardless of
             what node they reside on). We recommend calling this method in
             this C_OBJMAN's constructor. Then, get_nodid (char *name, int
             &nd, int &lid) and print_global_names() can be called any time
             during the simulation and access the database created at that
             point. However, the database is not updated as C_SIMOBJs are
             created and destroyed.
Return: None

void set_interact

() ;

INTERNAL METHOD

void term

( double tend ) ;

INTERNAL METHOD

Protected Interface

int deal_me

( int nobjs ) ;

Local number of objects of my type.

nobjs

IN: total number of objects of this type to be managed collectively by all C_OBJMANs of this type on all nodes (normally N_TOT).

int deal_me

( int nobjs , int& offset ) ;

Method: deal_me
Summary: card deal objects of this simulation object type for this node
Description: This function is called by this simulation type's object manager
             constructor when the distribution strategy for this class of
             simulation objects is to "card deal" all the simulation objects
             of this type to all of the nodes in the simulation. nobjs is the
             total number of objects of this type to be managed collectively
             by all C_OBJMANs of this type on all nodes (normally N_TOT is
             passed as the argument for this parameter). This function
             returns the number of those objects that this node should manage
             (the other nodes will manage the other objects).  This C_OBJMAN
             manages objects with ids in the calling manager of offset +
             N_NODES * j, where j is a whole number. Or, another way to state
             this is that offset is used to determine which C_SIMOBJs this
             C_OBJMAN should manage. Namely, this C_OBJMAN manages all
             C_SIMOJs of LOCAL_ID == i where ((i-offset+N_NODES)%N_NODES) ==
             0 and (0 <= i < N_TOT).
Return: N_LOC

nobjs

IN: total number of objects of this type to be managed collectively by all C_OBJMANs of this type on all nodes (normally N_TOT).

offset

OUT: node offset.

Protected Data

int N_LOC;

Local number of objects of my type.

int N_TOT;

Total number of objects of my type.

Private Interface

Private Data

static int done;

Pointer to the objects.

C_GLOBAL_NAME* global_name;

Array of global names.

C_SIMOBJ** gobj;

Pointer to the objects.

int interact;

Interaction flag.

C_QUEUE* name_queue;

Array of queues of global names.

ion flag int ndef;

Number of local object defined so far.

static int ntobj;

Number of total objects.

static int seed_update;

Seed update.

<< • toc

class C_SIMOBJ : public C_SQ_ITEM

Class: C_SIMOJ
Summary: A generic SPEEDES simulation object
Description: This is the fundamental modeling unit in SPEEDES applications on
             which C_EVENTs act. C_SIMOBJs must be designed independent of
             other C_SIMOBJs so as to permit each C_SIMOBJ to temporarily
             exist at different logical (simulated) times as controlled by
             the operative time management algorithm. C_SIMOBJs are permitted
             to schedule events for other C_SIMOBJs, but this is generally
             discouraged in favor of maximizing C_SIMOBJ reuse. To achieve
             greater reuse, C_SIMOBJs should use events attached to
             themselves for scheduling events for other C_SIMOBJs.

Public Interface

C_SIMOBJ	AddEventHandler	CheckEventHandler
CheckSubType	CheckSubscription	EXCHANGE_SEED
ProcessEventHandlers	RemoveEventHandler	SetEventHandlerHashSize
combine_total_objects	event_type	get_EXTSUBS
get_GLOBAL_ID	get_LOCAL_ID	get_NAME
get_NODE	get_N_NODES	get_N_OBJECT_TYPES
get_OBJECT_TYPE	get_RANDOM	get_SEED
get_TIME	get_TOTAL_OBJECTS	get_blocking
get_cancel_queue	get_evtq	get_last_etype
get_local_rqueue	get_manager	get_monitor
get_ncancel	get_obman	get_obname
get_qmon	get_rq_holder	get_tblock
get_uid_seed	init_objs	insert_event
object_type	print	print_event_memory
query	remove_block	reset_nlobjs
schedule	schedule	schedule
set_GLOBAL_ID	set_LOCAL_ID	set_NAME
set_NODE	set_N_NODES	set_N_OBJECT_TYPES
set_OBJECT_TYPE	set_RANDOM	set_SEED
set_TIME	set_TOTAL_OBJECTS	set_evtype
set_init_event_queue	set_last_etype	set_obman
set_rbq	set_rq_holder	set_rqueue
set_uid_seed	terminate	unblock
update_block	add_block	add_unblock
get_qblock

Public Interface

C_SIMOBJ

() ;

void AddEventHandler

( char* eventName , EVENT_HANDLER* eventHandler ) ;

Method: AddEventHandler
Summary: Adds the event handler to the simobj. If the hash table has not
         been created, it automatically creates the hash table with a
         nominal size.
Description: adds the event handler to the simobj's set of event handlers.
             Note that it is possible to add more than one event handler for
             a specified eventName. Each eventName is managed in an item
             that is stored in the EventHandlerHash table as a group.
Return: void.

int CheckEventHandler

( char* eventName ) ;

IN: id of external module
    if applicable (-1 means
    event not generated by
    external module)

int CheckSubType

( char* Type , int externalId ) ;

Method: CheckSubType
Summary: Checks if an external module (specified by the externalId input)
         has subscribed to a specified type (represented as the string Type)
Description: Searches through the EXTSUBS list for the pair <Type and
             externalId> and returns 1 if found (otherwise, returns 0).
Return: Returns 1 if the subscription type for that externalId is in
        the EXTSUBS list. Otherwise, returns 0.

int CheckSubscription

( char* Name ) ;

Method: CheckSubscription
Summary: Checks if a subscription type specified by the input argument Name
         is in the EXTSUBS list.
Description: Searches through the EXTSUBS list for the named subscription.
Return: Returns 1 if the subscription name is in the EXTSUBS list.
        Otherwise, returns 0.

void EXCHANGE_SEED

( int& seed ) ;

Method: EXCHANGE_SEED
Summary: Exchange the SEED of this C_SIMOBJ for rollback purposes
Description: 
Return: None

seed

INOUT: SEED to exchange with this C_SIMOBJ's SEED.

void ProcessEventHandlers

( char* eventName , SIMTIME& timeTag , char* data , int dataBytes , int externalId ) ;

Method: ProcessEventHandlers
Summary: Processes all of the event handlers with a specified name..
Description: Removes the event handler from the simobj's set of event
             handlers.
Return: void.

eventName

IN: name of the event type.

timeTag

IN: simulation time.

data

IN: data passed to the IN: event handler.

dataBytes

IN: number of bytes for data.

externalId

IN: id of external module if applicable (-1 means event not generated by external module).

void RemoveEventHandler

( char* eventName , EVENT_HANDLER* eventHandler ) ;

Method: RemoveEventHandler
Summary: Removbes the event handler from the simobj. Note that the event
         name item that is in the EventHandlerHash table is never deleted.
Description: Removes the event handler from the simobj's set of event
             handlers.
Return: void.

void SetEventHandlerHashSize

( int hashSize ) ;

Method: SetEventHandlerHashSize
Summary: Sets the size of the hash table for storing event handlers.
Description: Creates the hash table for event handlers and uses the input
             argument to define the size of the hash table. Reasonable sizes
             for the hash table would be the number of different kinds of
             event names.
Return: void.

void combine_total_objects

() ;

INTERNAL METHOD

int event_type

( char* c ) ;

Method: event_type 
Summary: Get the enumerated ID for an event type, specified by the event
         type's string name
Description: 
Return: the enumerated ID for an event type

c

IN: NAME of an event.

C_XQUEUE* get_EXTSUBS

() ;

Method: get_EXTSUBS
Summary: Gets the list of external subscriptions
Description: Returns the EXTSUBS C_XQUEUE
Return: Returns the pointer to the EXTSUBS object (of type C_XQUEUE)

int get_GLOBAL_ID

() ;

Method: get_GLOBAL_ID
Summary: Get the unique ID, simulaiton-wide, of this object. GLOBAL_ID
         generated automatically, but can be overridden by the user.
Description: 
Return: the unique ID of this simulation object

int get_LOCAL_ID

() ;

Method: get_LOCAL_ID
Summary: Get the ID of this simulation object
Description: Each object manager has its own set of C_SIMOBJs, each with
             their own LOCAL_ID. Thus LOCAL_ID only needs to be unique for a
             given object manager (C_OBJMAN), not unique to a given node or
             to a given simulation
Return: the ID of this simulation object

char* get_NAME

() ;

Method: get_NAME
Summary: Get the name of this object (for referring to this C_SIMOBJ by name)
Description: 
Return: name of this object

int get_NODE

() const;

Method: get_NODE
Summary: Get the node (process number on local machine) that this C_SIMOBJ is
         instantialted on.
Description:
Return: the node (process number on local machine) that this C_SIMOBJ
        is instantialted on.

int get_N_NODES

() ;

Method: get_N_NODES
Summary: Get the total number of nodes (process number on local machine) in
         the entire simulation (including all other machines' process)
Description: 
Return: total number of nodes

int get_N_OBJECT_TYPES

() ;

Method: get_N_OBJECT_TYPES
Summary: Get the total number of OBJECT_TYPEs (see above) in the current
         simulation
Description: 
Return: the total number of OBJECT_TYPEs (see above) in the current
        simulation

int get_OBJECT_TYPE

() ;

Method: get_OBJECT_TYPE
Summary: Get the ID (or enumerated type) of the type of this simulation
         object
Description: A unique OBJECT_TYPE is required for each C_SIMOBJ class.  Each
             C_SIMOBJ class is managed by one instantiation of
             C_OBJMAN. Thus, the OBJECT_TYPE also uniquely defines the type
             of C_SIMOBJ that each instantiation of C_OBJMAN manages. Each
             node has a single instantiation of C_OBJECTS, which in turn
             manages a list of C_OBJMANs. C_OBJECTS refers to each C_OBJMAN
             by the OBJECT_TYPE it manages.
Return: the OBJECT_TYPE, ie, the ID of the type of this simulation type

C_RANDOM* get_RANDOM

() ;

Method: get_RANDOM
Summary: Get the random number generator. There is exactly one C_RANDOM
         object per node, set automatically by the framework.
Description: see C_RANDOM
Return: the random number generator

STATE_INT get_SEED

() ;

Method: get_SEED
Summary: Get the seed for the random number generator. Must be saved and
         recalled for repeatability due to rollbacks.
Description: 
Return: the random number generator seed

SIMTIME& get_TIME

() ;

INTERNAL METHOD

int get_TOTAL_OBJECTS

() ;

Method: get_TOTAL_OBJECTS
Summary: Get the total number of objects in the simulation. That is, the sum
         of each object of each object type on each node.
Description: 
Return: the total number of objects in the simulation

int get_blocking

() ;

INTERNAL METHOD

C_XQUEUE* get_cancel_queue

() ;

INTERNAL METHOD

C_DBL_QUEUE* get_evtq

() ;

INTERNAL METHOD

int get_last_etype

() ;

INTERNAL METHOD

C_RQUEUE* get_local_rqueue

() ;

INTERNAL METHOD

void* get_manager

( int om ) ;

Method: get_manager
Summary: Get the object manager for another simulation object, specified by
         its OBJECT_TYPE
Description: 
Return: an object manager, casted to (void *)

om

IN: OBJECT_TYPE of the desired object manager.

int get_monitor

() ;

Method: get_monitor
Summary: Get the number of external monitors connected to this simulation
         object
Description: 
Return: the number of external monitors connected to this simulation
        object

int get_ncancel

() ;

INTERNAL METHOD

C_OBJECT_TYPES* get_obman

() ;

INTERNAL METHOD

char* get_obname

( int i ) ;

INTERNAL METHOD

C_QUEUE* get_qmon

() ;

Method: get_qmon
Summary: Get the list of external monitors connected to this simulation
         object
Description: 
Return: the list of external monitors connected to this simulation object

C_RQ_HOLDER* get_rq_holder

() ;

INTERNAL METHOD

SIMTIME& get_tblock

() ;

INTERNAL METHOD

int get_uid_seed

() ;

INTERNAL METHOD

void init_objs

() ;

INTERNAL METHOD

void insert_event

( C_SQ_ITEM* event ) ;

INTERNAL METHOD

int object_type

( char* c ation object ) ;

Method: object_type
Summary: Retrieves a simulation object's OBJECT_TYPE (see set_OBJECT_TYPE)
         based on its string NAME
Description: 
Return: the object type of this simulation object

virtual void print

() ;

Virtual Method: print
Summary: User-overridable function to print something about this simulation
         object during run-time
Description:
Return: None

void print_event_memory

() ;

INTERNAL METHOD

virtual void query

( double time_tag , NAME_VALUE_LIST& NameValueList ) ;

Virtual Method: query
Summary: Query this simulation object for a name-value list of information
Description: Simulation objects can be queried during run-time for real-time
             updates of their state. The state information queried is defined
             by the simulation object at compile time by overridding this
             virtual function.
Return: the size, in bytes, of the returned buffer, buff

time_tag

IN: simulated time for the query.

NameValueList

OUT: query list.

void remove_block

( C_ITEM* it ) ;

INTERNAL METHOD

it

IN: the event to remove from this node's list of blocking events.

void reset_nlobjs

() ;

INTERNAL METHOD

void* schedule

( const SIMTIME& time , int event_type , int object_type , int object_id , int object_node ) ;

Overloaded Method: schedule
Summary: Schedule an event at the present or a future simulated time for any
         simulation object (C_SIMOBJ) in the simulation
Description: For reusability, prefer scheduling events in the process user
             code of events (C_EVENTs). See the schedule methods in C_EVENT.
Return: the message for this scheduled event

time

IN: simulated time.

event_type

IN: enumerated or integer type of event to schedule.

object_type

IN: enumerated or integer type of object for which to schedule the event (must be the one type of object required for the event_type).

object_id

IN: the LOCAL_ID of the object for which to schedule the event.

object_node

IN: the NODE of the object for which to schedule the event.

void* schedule

( double time , int event_type , int object_type , int object_id , int object_node ) ;

Overloaded Method: schedule
Summary: Schedule an event at the present or a future simulated time for any
         simulation object (C_SIMOBJ) in the simulation
Description: For reusability, prefer scheduling events in the process user
             code of events (C_EVENTs). See the schedule methods in C_EVENT.
Return: the message for this scheduled event

time

IN: simulated time as a double (ie, no priority fields).

event_type

IN: enumerated or integer type of event to schedule.

object_type

IN: enumerated or integer type of object for which to schedule the event (must be the one type of object required for the event_type).

object_id

IN: the LOCAL_ID of the object for which to schedule the event.

object_node

IN: the NODE of the object for which to schedule the event.

void* schedule

( const SIMTIME& time , int event_type , int object_type , int object_id , int object_node , int size , char*& buf ) ;

Overloaded Method: schedule
Summary: Schedule an event at the present or a future simulated time for any
         simulation object (C_SIMOBJ) in the simulation
Description: For reusability, prefer scheduling events in the process user
             code of events (C_EVENTs). See the schedule methods in C_EVENT.
Return: the message for this event

time

IN: simulated time.

event_type

IN: enumerated or integer type of event to schedule.

object_type

IN: enumerated or integer type of object for which to schedule the event (must be the one type of object required for the event_type).

object_id

IN: the LOCAL_ID of the object for which to schedule the event.

object_node

IN: the NODE of the object for which to schedule the event.

size

IN: (OPTIONAL) number of bytes of the variable-length part of the event message.

buf

IN: (USED IF AND ONLY IF "size" IS USED) the variable-length part of the event message.

void set_GLOBAL_ID

( int i ) ;

Method: set_GLOBAL_ID
Summary: Set the unique ID, simulaiton-wide, of this object. GLOBAL_ID
         generated automatically, but can be overridden by the user with this
         method.
Description: 
Return: None

void set_LOCAL_ID

( int i ) ;

INTERNAL METHOD

void set_NAME

( char* n ) ;

INTERNAL METHOD

void set_NODE

( int nd ) ;

INTERNAL METHOD

void set_N_NODES

( int nds ) ;

INTERNAL METHOD

void set_N_OBJECT_TYPES

( int nt ) ;

INTERNAL METHOD

void set_OBJECT_TYPE

( int obtyp ) ;

INTERNAL METHOD

void set_RANDOM

( C_RANDOM* r ) ;

INTERNAL METHOD

void set_SEED

( int sd ) ;

INTERNAL METHOD

void set_TIME

( SIMTIME& tt ) ;

INTERNAL METHOD

void set_TOTAL_OBJECTS

( int to ) ;

INTERNAL METHOD

void set_evtype

( void* e ) ;

INTERNAL METHOD

void set_init_event_queue

( C_QUEUE* qi ) ;

INTERNAL METHOD

void set_last_etype

( int e ) ;

INTERNAL METHOD

void set_obman

( C_OBJECT_TYPES* ob ) ;

INTERNAL METHOD

void set_rbq

( C_RBQ* r ) ;

INTERNAL METHOD

void set_rq_holder

( C_RQ_HOLDER* rqh ) ;

INTERNAL METHOD

void set_rqueue

( C_RQUEUE* rq ) ;

INTERNAL METHOD

void set_uid_seed

( int sd ) ;

INTERNAL METHOD

virtual void terminate

( double ) ;

Virtual Method: terminate
Summary: User-overridable function for operations (such as printing
         statistics) associated with this simulation object to be performed
         when the simulation completes
Description: 
Return: None

The simulation passes the end time of the simulation here (tend). Using this value is of course optional.

void unblock

( int soc ) ;

INTERNAL METHOD

soc

IN: the socket ID to unblock.

void update_block

() ;

INTERNAL METHOD

static void add_block

( C_ITEM* it ) ;

INTERNAL METHOD

it

IN: the event after which the current event is to be inserted.

static void add_unblock

( C_ITEM* it ) ;

INTERNAL METHOD

it

IN: the event after which the current event is to be inserted.

static C_QUEUE* get_qblock

() ;

INTERNAL METHOD

Protected Interface

Protected Data

C_XQUEUE EXTSUBS;

Requested external subscriptions.

int GLOBAL_ID;

Unique id for simulation.

char* NAME;

Name of object.

static int NODE;

Node id.

static int N_NODES;

The total number of nodes.

static int N_OBJECT_TYPES;

Number of object types.

int OBJECT_TYPE;

Object type.

static C_RANDOM* RANDOM;

Shared random number generator.

STATE_INT SEED;

Random number SEED.

SIMTIME TIME;

Time of object GEB3.

static int TOTAL_OBJECTS;

Total number of objects created.

int id;

Local object id.

static C_RBQ* rbq;

Roll back queue object.

Private Interface

Private Data

C_XHASH* EventHandlerHash;

Manages event handlers.

C_XQUEUE cancel_queue;

Queue of canceled events.

static int done;

Done flag (first simobj created).

C_DBL_QUEUE evtq;

Event queue for object.

static void* evtype;

Evtype manages event creation.

static C_QUEUE* init_events;

Initial event queue.

int last_etype;

Last event type of object.

C_RQUEUE local_rqueue;

Speedes queue for this object.

static int nlobjs;

Number of local objects.

static C_OBJECT_TYPES* obman;

Object manager constructor.

static C_QUEUE* qblock;

Queue of blocking events.

C_QUEUE qmon;

Queue of external monitors.

static C_QUEUE* qunblock;

Queue of unblocking events.

C_RQ_HOLDER* rq_holder;

Rqueue holder for the object.

static C_RQUEUE* rqueue;

Speedes queue for local objects.

static int uid_seed;

Unique id for this object.

toc

ROLLBACKABLE OPERATIONS------------------------------------+

toc • >>

class BASE_STATE

INTERNAL METHODSummary: Holds the C_RBQ (rollback queue manager) for all the rollbackable
           classes that inherit from this
  Description: 

Public Interface

void set_rbq

( C_RBQ* r ) ;

Protected Interface

Protected Data

static C_RBQ* rbq;

<< • toc • >>

class RB_ostream : public BASE_STATE

Class: RB_ostream
Summary: Rollbackable ostream
Description: Use this just as you would a normal ostream when that ostream
             is part of the state of a C_SIMOBJ or non-C_SIMOBJ object (ie,
             when it needs to be rollbackable)

Public Interface

RB_ostream	RB_ostream	operator<<
operator<<	operator<<	operator<<
operator<<	operator<<	operator<<
operator<<	operator<<	operator<<
operator<<	initAltStream

Public Interface

RB_ostream

( RB_ostream::ostream* targetOutStream = & cout ) ;

RB_ostream

( char* fname ) ;

alt_ostream& operator<<

( IO_Manipulator f ) ;

alt_ostream& operator<<

( const char* s ) ;

alt_ostream& operator<<

( double x ) ;

alt_ostream& operator<<

( float x ) ;

alt_ostream& operator<<

( int i ) ;

alt_ostream& operator<<

( long i ) ;

alt_ostream& operator<<

( short i ) ;

alt_ostream& operator<<

( unsigned int i ) ;

alt_ostream& operator<<

( unsigned long i ) ;

alt_ostream& operator<<

( unsigned short i ) ;

alt_ostream& operator<<

( void* pt ) ;

alt_ostream& initAltStream

() ;

Private Interface

Private Data

ofstream filestream;

ostream* outstream;

Either a file or cout.

int toFile_p;

Is output going to a file?

<< • toc • >>

class STATE_DOUBLE : public BASE_STATE

State_double object.

Class: STATE_DOUBLE (typedef'd to RB_double)
Summary: Rollbackable double
Description: Use this just as you would a normal double when that double
             is part of the state of a C_SIMOBJ or non-C_SIMOBJ object (ie,
             when it needs to be rollbackable)

Public Interface

STATE_DOUBLE	operator=	operator double
operator*=	operator++	operator+=
operator--	operator-=	operator/=
assign	print	print

Public Interface

STATE_DOUBLE

() ;

double operator=

( double d ) ;

operator double

() ;

...... Conversion method allows this object to be used as a double.

double operator*=

( double d ) ;

double operator++

() ;

double operator+=

( double d ) ;

double operator--

() ;

double operator-=

( double d ) ;

double operator/=

( double d ) ;

double assign

( double d ) ;

void print

( char* s ) ;

void print

() ;

...... Other methods.

Public Data

double state_variable;

<< • toc • >>

class STATE_FLOAT : public BASE_STATE

Class: STATE_FLOAT (typedef'd to RB_float)
Summary: Rollbackable float
Description: Use this just as you would a normal float when that float
             is part of the state of a C_SIMOBJ or non-C_SIMOBJ object (ie,
             when it needs to be rollbackable)

Public Interface

STATE_FLOAT	operator=	operator float
operator*=	operator++	operator+=
operator--	operator-=	operator/=
assign	print	print

Public Interface

STATE_FLOAT

() ;

float operator=

( float d ) ;

operator float

() ;

...... Conversion method allows this object to be used as a double.

float operator*=

( float d ) ;

float operator++

() ;

float operator+=

( float d ) ;

float operator--

() ;

float operator-=

( float d ) ;

float operator/=

( float d ) ;

double assign

( float d ) ;

void print

( char* s ) ;

void print

() ;

...... Other methods.

Public Data

float state_variable;

<< • toc • >>

class STATE_INT : public BASE_STATE

Class: STATE_INT (typedef'd to RB_int)
Summary: Rollbackable integer
Description: Use this just as you would a normal integer when that integer
             is part of the state of a C_SIMOBJ or non-C_SIMOBJ object (ie,
             when it needs to be rollbackable)

Public Interface

STATE_INT	operator=	operator delete
operator int	operator new	operator%=
operator&=	operator*=	operator++
operator+=	operator--	operator-=
operator/=	operator<<=	operator>>=
operator^=	operator|=	Exchange
assign	print	print

Public Interface

STATE_INT

() ;

int operator=

( int i ) ;

void operator delete

( void* p ) ;

operator int

() ;

...... Conversion method allows this object to be used as an int.

void* operator new

( size_t s , int n = 1 ) ;

...... Overloading new and delete operators.

int operator%=

( int i ) ;

int operator&=

( int i ) ;

int operator*=

( int i ) ;

int operator++

() ;

int operator+=

( int i ) ;

int operator--

() ;

int operator-=

( int i ) ;

int operator/=

( int i ) ;

int operator<<=

( int i ) ;

int operator>>=

( int i ) ;

int operator^=

( int i ) ;

int operator|=

( int i ) ;

void Exchange

( int& var ) ;

int assign

( int i ) ;

void print

( char* s ) ;

void print

() ;

...... Other methods.