speedes

Metrics


toc >>

struct AskStackElement : public StackElement

#include "processTypes.H"

Public Interface

AskStackElement( C_RANDOM* ran , SpObjectHandle* simobj , int procType ) ;
void ScheduleAskReturn( const SIMTIME& currentSimtime , char* askReturn , size_t askReturnSize ) ;
void SetINandLV( ReentryMsg* msg , size_t INsize , void* in , void* out ) ;

Public Data

int futureAsk;
Flag for if the current ASK method was called as a FUTURE_ASK.
size_t outSize;
Size of *OUT.
Reentry_T reentry;
Reentry and reentryLV are stored from the previous event through the ReentryMsg event message to facilitate scheduling an ASK return.
StackElement* reentryLV;
void* voidIn;
IN casted to void (so this class variable can be general).
void* voidOut;
OUT casted to void (so this class variable can be general).

<<toc >>

class BASE_STATE

#include "state_variable.H"

Internal Class: BASE_STATE
Summary: 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 ) ;

<<toc >>

class COMPONENT

#include "Component.H"

Class: COMPONENT Summary: A generic reusable object with associated event handlers for plugging in and plugging out of C_SIMOBJs during compile time and/or runtime. NOTE: ROLLBACK NOT IMPLEMENTED YET. Description: Components allow the decoupling of subobjects in C_SIMOBJs so that such subobjects, if they inherit from COMPONENT, can be plugged into various different C_SIMOBJs and rollbackably removed from those C_SIMOBJs during runtime. When COMPONENTs are added and removed to and from C_SIMOBJs, any event handlers associated with the COMPONENTs are also added and removed. To associate event handlers with COMPONENTS, use the COMPONENT AddEventHandler and RemoveEventHandler methods, which are also rollbackable.

Public Interface

COMPONENT COMPONENT ~COMPONENT
PluggedIn

Public Interface

COMPONENT( ) ;
Constructor Method: COMPONENT.
COMPONENT( C_SIMOBJ* simobj ) ;
Constructor Method: COMPONENT
Summary: Constructors of COMPONENTs require the associated C_SIMOBJ pointer
Description: Use the following syntax for descendents of COMPONENT:
             COMPONENT_CHILD (C_SIMOBJ *simobj): COMPONENT (simobj)
             { ... }
simobj
Pointer to associated C_SIMOBJ.
~COMPONENT( ) ;
int PluggedIn( ) ;
Method: PluggedIn
Summary: Returns whether this component is currently plugged in to
         the C_SIMOBJ
Description: 
Return: Whether this component is currently plugged in to the C_SIMOBJ

<<toc >>

class C_ANTIMESS : public C_SQ_ITEM

#include "antimess.H"

Antimess object.

Public Interface

C_ANTIMESS get_bytes get_etype
get_event get_node get_obid
get_obtype get_rbid set_bytes
set_etype set_event set_node
set_obid set_obtype set_rbid

Public Interface

C_ANTIMESS( ) ;
int get_bytes( ) ;
int get_etype( ) ;
C_EVENT* get_event( ) ;
int get_node( ) ;
int get_obid( ) ;
int get_obtype( ) ;
int get_rbid( ) ;
void set_bytes( int b ) ;
void set_etype( int e ) ;
void set_event( C_EVENT* e ) ;
void set_node( int n ) ;
void set_obid( int oid ) ;
void set_obtype( int ot ) ;
void set_rbid( int r ) ;

<<toc >>

class C_BASE_EVTYPE

#include "base_evtype.H"

Evtype object.

Public Interface

C_BASE_EVTYPE ~C_BASE_EVTYPE define_event
define_event delete_event delete_holder
delete_message dup_message get_messid
get_messname get_ntypes get_sizeof
message_event new_event new_holder
new_message new_message print
set_holders set_ntypes undup_message

Public Interface

C_BASE_EVTYPE( ) ;
~C_BASE_EVTYPE( ) ;
void define_event( char* type , int itype , EVENT_CONSTRUCTOR_FUNCTION , int sz_e , int sz_m , int n ) ;
void define_event( char* type , int itype , TO_BE_DELETED_FUNCTION , int sz_e , int sz_m , int n ) ;
void delete_event( void* event ) ;
void delete_holder( C_HOLDER* holder ) ;
void delete_message( C_HOLDER* holder ) ;
C_HEADER* dup_message( C_HEADER* header ) ;
int get_messid( char* name ) ;
char* get_messname( int i ) ;
int get_ntypes( ) ;
int get_sizeof( int type ) ;
void* message_event( char* message ) ;
void* new_event( int type ) ;
C_HOLDER* new_holder( char* buff , int size , int node ) ;
C_HOLDER* new_message( const SIMTIME& t , int type , int oty , int oid , int nod ) ;
C_HOLDER* new_message( const SIMTIME& t , int type , int oty , int oid , int nod , int size , char*& bf ) ;
void print( ) ;
void set_holders( int n ) ;
void set_ntypes( int n ) ;
void undup_message( C_HEADER* header ) ;

<<toc >>

class C_BASE_OBMAN

#include "base_obman.H"

Base_obman object.

Public Interface

C_BASE_OBMAN RB_SET_FREE define_manager
get_free_list get_ntypes get_obid
get_obname new_manager set_ntypes

Public Interface

C_BASE_OBMAN( ) ;
void RB_SET_FREE( C_FREE_LIST* f ) ;
void define_manager( char* type , int itype , manager_constructor_function f ) ;
C_FREE_LIST* get_free_list( ) ;
int get_ntypes( ) ;
int get_obid( char* name ) ;
char* get_obname( int object_type ) ;
void* new_manager( int type ) ;
void set_ntypes( int n ) ;

<<toc >>

class C_CANCEL_HANDLE : public C_ANTIMESS

#include "antimess.H"


<<toc >>

class C_EM_COMMAND : public C_EM_HEADER

#include "headers.H"

EM_command object.

Public Interface

Public Data

char EM_command [ 40 ];
External Module command.

<<toc >>

class C_EM_HEADER : public C_HEADER

#include "headers.H"

EM_header object.

Public Interface

void print( ) ;
Number of data bytes.

Public Data

NET_INT EM_flag;
Useful flag.
NET_INT EM_interaction;
Interaction type.
NET_INT EM_socket;
Socket of External Module.
NET_INT data_bytes;
Number of data bytes.
 g;
Useful flag.

<<toc >>

class C_EM_MODULE : public C_EM_COMMAND

#include "headers.H"

EM_command object.

Public Interface

Public Data

double EM_done_time;
External Module done time.

<<toc >>

class C_EVENT : public C_SQ_ITEM

#include "event.H"

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 CriticalPathMessages GetCPU_Time
GetCriticalPathTime GetObjectHandle GetProcessingTime
GetRBQ GetTag GetTotalTime
PrintTimeTag SetCPU_Time SetCriticalPathTime
SetProcessingTime SetTotalTime TieBreakGeneratedMessages
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_DATA 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_eventHandlerName
get_event_canceled get_evtptr get_free
get_from_SpComm 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_from_SpComm reset_lazy reset_lazy_proc
reset_processed reset_trace reset_valid
rollback rollback_event schedule
schedule schedule schedule
sendmess set_DATA 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_eventHandlerName
set_event_canceled set_evtype set_free
set_from_SpComm 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( ) ;
void CriticalPathMessages( double earliestStartTime ) ;
double GetCPU_Time( ) ;
double GetCriticalPathTime( ) ;
SpObjectHandle* GetObjectHandle( ) ;
Method: GetObjectHandle
Summary: Returns a reference to the current simobj's object handle
Description: 
Return: A reference to this simobj's object handle
double GetProcessingTime( ) ;
C_RBQ* GetRBQ( ) ;
Internal Method: *GetRBQ 
Summary: Get the rollback queue manager for this node (C_RBQ)
Description: 
Return: The rollback queue manager for this node (C_RBQ)
SpTag* GetTag( ) ;
double GetTotalTime( ) ;
void PrintTimeTag( ) ;
void SetCPU_Time( double cpu_Time ) ;
void SetCriticalPathTime( double criticalPathTime ) ;
void SetProcessingTime( double processingTime ) ;
void SetTotalTime( double totalTime ) ;
void TieBreakGeneratedMessages( ) ;
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: attach_object 
Summary: Attach this event to its associated simulation object (C_SIMOBJ)
Description: 
Return: None
void calculate_tmin( ) ;
Internal Method: calculate_tmin
Summary: Calculate the minimum time of a generated message
Description: 
Return: None
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: cancel_event 
Summary: Cancel this event
Description: 
Return: Current number of rollbacks
int check_canceled( int& n_roll ) ;
Internal Method: check_canceled 
Summary: Check if this event has been cancelled
Description: 
Return: The new number of rollbacks (ie, the same variable as was passed in)
n_roll
Number of rollbacks.
int check_clear( ) ;
Internal Method: check_clear 
Summary: Check if the event is in a state appropriate to be processed. If 
         not, this is a run-time error.
Description: 
Return: Flag for whether it is safe to process this event
int check_proc( int flag ) ;
Internal Method: check_proc Summary: Check if the event is in the processed events queue Description: This is used for lazy cancellation Return: Flag for whether the event is in the processed events queue.
virtual void cleanup( ) ;
Virtual Method: cleanup 
Summary: User-written code called in the event destructor
Description: 
Return: None
void clear_data( ) ;
Internal Method: clear_data 
Summary: Clear the data for this event
Description: 
Return: None
void clear_messages( ) ;
Internal Method: clear_messages 
Summary: Clear all of the messages out of this event
Description: 
Return: None
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.
C_HEADER* 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.
C_HEADER* 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.
C_HEADER* create_object( SIMTIME& time , int object_type , int object_node , int mess_size , char*& buf message ) ;
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.
message
C_HEADER* create_object( void* ch , SIMTIME& time , int object_type , int object_node , int mess_size , nt message 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: delete_MESSAGE 
Summary: delete the MESSAGE associated with this event (if it exists)
Description: 
Return: None
C_HEADER* 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.
C_HEADER* 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.
char* get_DATA( ) ;
Method: get_DATA Summary: Get the data used to enact this event Description: This is the variable length data. When this event was scheduled, if the schedule or ScheduleEvent function was passed a char * buffer, then this function will return a pointer to a copy of that buffer, else it returns NULL. Return: the data used to enact this event, or NULL if no such data exists.
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: get_HOST_USER
Summary: Get the host user on this node (C_HOST_USER)
Description: see HOST_USER
Return: the host user
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: get_amque 
Summary: Get this event's queue of outgoing antimessages
Description: 
Return: This event's queue of outgoing antimessages
int get_cancel_id( ) ;
Internal Method: get_cancel_id 
Summary: Get this event's cancel ID
Description: 
Return: This event's cancel ID
C_DBL_ITEM* get_dbl_item( ) ;
Internal Method: get_dbl_item 
Summary: Get this event's processed events list item pointer
Description: 
Return: This event's processed events list item pointer
char* get_eventHandlerName( ) ;
Internal Method: get_eventHandlerName
Summary: Get the lastprocessed event handler event name (used by
         ReScheduleEventHandler())
Description: 
Return: the last-processed event handler event name
int get_event_canceled( ) ;
Internal Method: get_event_canceled 
Summary: Get cancel flag
Description: 
Return: cancel flag (true if cancelled)
C_LPTR* get_evtptr( ) ;
Internal Method: get_evtptr 
Summary: Get this event's optimistic event object (C_LPTR)
Description: 
Return: This event's optimistic event object (C_LPTR)
int get_free( ) ;
Internal Method: get_free 
Summary: Get the free flag (used for event list management)
Description: 
Return: The free flag
int get_from_SpComm( ) ;
Internal Method: get_from_SpComm 
Summary: Get the from_SpComm member which says if this event came from
         SpComm.  It would be false if it came from this same node.
Description: 
Return: from_SpComm
int get_lazy( ) ;
Internal Method: get_lazy 
Summary: Determine whether lazy cancellation is enabled
Description: 
Return: Whether lazy cancellation is enabled (1=yes)
int get_lazy_proc( ) ;
Internal Method: get_lazy_proc Summary: Get the flag for whether this event has been lazy-processed Description: Time management algorithms, when pulling events off of the event queue for processing, must know whether the event has already been processed, rolled back without sending antimessages, and is waiting for a lazy test (meaning they have been lazy-processed). In this case the algorithm must handle the event differently than if the event is simply waiting to be processed (the usual case). This method determines which case the event falls under. Return: Flag for whether this event has been lazy-processed.
void* get_manager( int om = - 2 ) ;
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. Default is this event's simobj's object manager.
C_QUEUE* get_mque( ) ;
Internal Method: get_mque 
Summary: Get this event's queue of outgoing messages
Description: 
Return: This event's queue of outgoing messages
int get_nopt( ) ;
Internal Method: get_nopt 
Summary: Get the length of the queue of optimistically generated events
Description: 
Return: The length of the queue of optimistically generated events
C_OBJECTS* get_objects( ) ;
Internal Method: get_objects 
Summary: Get the C_OBJECTS object on this node
Description: 
Return: None
int get_processed( ) ;
Internal Method: get_processed 
Summary: Get whether this event has been processed
Description: 
Return: Flag for whether this event has been processed
int get_rbid( ) ;
Internal Method: get_rbid 
Summary: Get this event's rollback ID
Description: 
Return: This event's rollback ID
C_QUEUE* get_rbq( ) ;
Internal Method: *get_rbq 
Summary: Get this event's queue of rollbacks
Description: 
Return: This event's queue of rollbacks
SIMTIME& get_tmin( ) ;
Internal Method: get_tmin
Summary: Get the minimum time of a generated message
Description: 
Return: The minimum time of a generated message
int get_valid( ) ;
Internal Method: get_valid 
Summary: Get whether this event is valid
Description: 
Return: Flag as to whether this event is valid
void getmess( C_QUEUE* q1nd ) ;
Internal Method: getmess
Summary: Get messages coming in
Description: 
Return: None
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: init_qroll_backs 
Summary: Place this event's rollback queue into the rollback queue manager
Description: This allows the rollback queue manager (C_RBQ) to perform the
             rollbacks for this event
Return: None
void insert( ) ;
Internal Method: insert
Summary: Attach this event to its simulation object (C_SIMOBJ)
Description: 
Return: None
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: lazy_rollback 
Summary: Late roll back this event from lazy cancellation
Description: This method does the required processing for an event that has
             failed the lazy test. It has already undergone a "shallow"
             rollback (meaning a rollback with no antimessages), so this
             method handles the antimessage part.
Return: Current number of rollbacks
int local_messages( ) ;
Internal Method: local_messages 
Summary: Send out the local messages
Description: 
Return: Current number of rollbacks
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: optimistic_insert 
Summary: Optimistically insert all of this node's events into the event list
Description: 
Return: Current number of rollbacks
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: pop_roll_back 
Summary: Pop this event off the roll back queue
Description: 
Return: None
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: reset_event_canceled 
Summary: Uncancel an event
Description: 
Return: None
void reset_from_SpComm( ) ;
Method: reset_from_SpComm
Summary: Record the fact that this event DID NOT come from SpComm.
Description: 
Return: None
void reset_lazy( ) ;
Method: reset_lazy 
Summary: Disable lazy cancellation
Description: 
Return: None
void reset_lazy_proc( ) ;
Internal Method: reset_lazy_proc 
Summary: Reset the flag for whether this event has been lazy-processed
Description: 
Return: None
void reset_processed( ) ;
Internal Method: reset_processed 
Summary: Tell this event that it has not been processed
Description: 
Return: None
void reset_trace( ) ;
Method: reset_trace 
Summary: Disable tracing this event
Description: 
Return: None
void reset_valid( ) ;
Internal Method: reset_valid 
Summary: Tell this event that it is not valid
Description: 
Return: None
int rollback( ) ;
Internal Method: rollback 
Summary: Roll back each event on this node if necessary
Description: 
Return: Current number of rollbacks
int rollback_event( ) ;
Internal Method: rollback_event 
Summary: Roll back this event
Description: 
Return: Current number of rollbacks
C_HEADER* 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. 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. The buf argument passed in need not be initialized. It is a return by reference argument. After schedule returns, the buf argument will point to a buffer of size mess_size, and you may then write data into it. Write into it AFTER schedule returns! 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.
C_HEADER* 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. 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.
C_HEADER* 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. The buf argument passed in need not be initialized. It is a return by reference argument. After schedule returns, the buf argument will point to a buffer of size mess_size, and you may then write data into it. Write into it AFTER schedule returns! 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.
C_HEADER* 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: sendmess 
Summary: Send messages out to the appropriate nodes
Description: 
Return: None
q1nd
IN: the messages to send out.
void set_DATA( char* c ) ;
Internal Method: set_DATA 
Summary: Set the data used to enact this event
Description: 
Return: None
void set_EVENT_TYPE( int et ) ;
Internal Method: set_EVENT_TYPE 
Summary: Set the ID (or enumerated type) of the type of this event
Description: 
Return: None
void set_GLOBAL_ID( int g ) ;
Internal Method: set_GLOBAL_ID 
Summary: Set 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: None
void set_HOST_USER( C_HOST_USER* h ) ;
Internal Method: set_HOST_USER 
Summary: Set the host user
Description: 
Return: None
void set_LOCAL_ID( int l ) ;
Internal Method: set_LOCAL_ID 
Summary: Set the ID of the simulation object associated with this event
Description: 
Return: None
void set_MESSAGE( C_HEADER* h ) ;
Internal Method: set_MESSAGE 
Summary: Set the message used to enact this event
Description: 
Return: None
void set_NODE( int nd ) ;
Internal Internal Method: set_NODE 
Summary: Set the node (process number on local machine) that this C_SIMOBJ is
         instantialted on.
Description: 
Return: None
void set_N_NODES( int nds ) ;
Internal Internal Method: set_N_NODES 
Summary: Set the total number of nodes (process number on local machine) in
         the entire simulation (including all other machines' process)
Description: 
Return: None
void set_OBJECT_TYPE( int ot ) ;
Internal Method: set_OBJECT_TYPE
Summary: Set the ID (or enumerated type) of the type of the simulation
         object associated with this event
Description: 
Return: None
void set_RANDOM( C_RANDOM* ran ) ;
Internal Method: set_RANDOM 
Summary: Set the random number generator. There is exactly one C_RANDOM
         object per node, set automatically by the framework with this method.
Description: 
Return: None
void set_SIMOBJ( C_SIMOBJ* g ) ;
Internal Internal Method: set_SIMOBJ 
Summary: Set 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.
Return: None
void set_WriteLookahead( ) ;
Method: set_WriteLookahead 
Summary: Enable write lookahead
Description: 
Return: None
void set_cancel_id( int cid ) ;
Internal Method: set_cancel_id 
Summary: Set the cancel event ID
Description: 
Return: None
void set_eventHandlerName( char* name ) ;
Internal Method: set_eventHandlerName
Summary: Set the current event handler event name (set by
         ScheduleEventHandler() to be possibly later used by
         ReScheduleEventHandler())
Description: 
Return: None
name
Current event handler event name.
void set_event_canceled( ) ;
Internal Method: set_event_canceled 
Summary: Set the state of this event to canceled, meaning when the framework
         pulls it off the queue, it will discard it rather than process it
Description: 
Return: None
void set_evtype( C_EVENT_TYPES* et ) ;
Internal Method: set_evtype 
Summary: Set the C_EVENT_TYPES object for this node
Description: 
Return: None
void set_free( ) ;
Internal Method: set_free 
Summary: Set the state of this object to free, meaning it is a freed object 
         in the free list, able to be reused at a later time (see FREELST)
Description: Used only by freelist management
Return: None
void set_from_SpComm( ) ;
Method: set_from_SpComm
Summary: Record the fact that this event came from SpComm.  Therefore
         the proper way to deallocate this event is to use delete [] on
         a char* type.
Description: 
Return: None
void set_lazy( ) ;
Method: set_lazy 
Summary: Enable lazy cancellation
Description: 
Return: None
void set_lazy_proc( ) ;
Internal Method: set_lazy_proc Summary: Set the state of this event to lazy-processed Description: Time management algorithms, when pulling events off of the event queue for processing, must know whether the event has already been processed, rolled back without sending antimessages, and is waiting for a lazy test (meaning they have been lazy-processed). In this case the algorithm must handle the event differently than if the event is simply waiting to be processed (the usual case). Return: None.
void set_objects( C_OBJECTS* obj ) ;
Internal Method: set_objects 
Summary: Set the C_OBJECTS object for this node
Description: 
Return: None
void set_processed( ) ;
Internal Method: set_processed 
Summary: Set the state of this event to processed, meaning it has been
         processed (the user method process() has been called) by the
         framework
Description: 
Return: None
void set_rbid( int r ) ;
Internal Method: set_rbid 
Summary: Set the roll back unique ID
Description: 
Return: None
void set_rbq( C_RBQ* r ) ;
Internal Method: set_rbq 
Summary: Set the rollback queue manager
Description: 
Return: None
void set_trace( ) ;
Method: set_trace 
Summary: Enable tracing this event
Description: 
Return: None
void set_valid( ) ;
Internal Method: set_valid 
Summary: Set the state of the event to valid non-optimistic
Description: 
Return: None
void set_valid_opt( ) ;
Internal Method: set_valid_opt 
Summary: Set the state of the event to valid optimistic
Description: 
Return: None
void spin_loop( double twait ) ;
Internal Method: spin_loop 
Summary: Loop to waste time
Description: Waits until a specific point in time
Return: None
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: void_event 
Summary: Get cancel flag (same as get_event_canceled)
Description: 
Return: cancel flag (true if cancelled)
static void enable_lazy( ) ;
Internal Method: enable_lazy 
Summary: Enable lazy cancellation for the entire node
Description: This is done at the start of the simulation if the speedes.par
             file has lazy enablement specified
Return: None
static void set_one_node_flag( int onf ) ;
Internal Method: void set_one_node_flag 
Summary: Set the one-node flag, ie whether the simulation is on one node (ie
         sequential) or not (ie parallel)
Description: 
Return: None
static void set_qproc( C_DBL_QUEUE* q ) ;
Internal Method: set_qproc 
Summary: Set the queue of processed events
Description: 
Return: None
static void set_twosmess( void* tm ) ;
Internal Method: void set_twosmess 
Summary: Set the C_TWOSMESS object for this node
Description: 
Return: None

<<toc >>

class C_EVENT_HANDLER_EVENT : public C_EVENT

#include "EventHandlerEvent.H"

Public Interface

C_EVENT_HANDLER_EVENT( ) ;
virtual void process( ) ;

<<toc >>

class C_EVENT_TYPES : public C_BASE_EVTYPE

#include "event_types.H"

Event_types object.

Public Interface

C_EVENT_TYPES( ) ;

<<toc >>

class C_GLOBAL_NAME : public C_ITEM

#include "objman.H"

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_HEADER

#include "headers.H"

Header object.

Public Interface

Public Data

NET_DOUBLE EarliestStartTime;
Earliest start time for critical path.
NET_INT ExternalId;
External Id of external module.
NET_INT bytes;
Bytes in data for variable size message.
NET_INT cancel_id;
Cancel event id.
NET_INT evtype;
Event type.
NET_INT ext;
External output flag.
NET_INT objid;
Destination object id.
NET_INT obtype;
Destination object type.
NET_INT rbid;
Roll back id.
SIMTIME time_tag;
Time tag for the message (future event) GEB2.

<<toc >>

class C_LPTR : public C_ITEM

#include "lptr.H"

Lptr object.

Public Interface

C_LPTR( ) ;
void* get_ptr( ) ;
void set_ptr( void* p ) ;

<<toc >>

class C_OBJECTS : public C_SIMOBJ

#include "objects.H"

Objects object.

Public Interface

C_OBJECTS ComputeCriticalPath GetManagerName
GetNmanagers get_N_LOC get_N_TOT
get_allids get_nodid get_obj
get_objman init_events print
term

Public Interface

C_OBJECTS( ) ;
void ComputeCriticalPath( double& CPU_Time , double& criticalPathTime , double& maxSpeedup ) ;
char* GetManagerName( int i ) ;
int GetNmanagers( ) ;
int get_N_LOC( int ty ) ;
int get_N_TOT( int ty ) ;
char* get_allids( int& size ) ;
void get_nodid( int ot , int oi , int& n , int& i ) ;
C_SIMOBJ* get_obj( int type , int i ) ;
C_SIMOBJ* get_objman( int type ) ;
void init_events( ) ;
virtual void print( ) ;
void term( double tend ) ;

<<toc >>

class C_OBJECT_TYPES : public C_BASE_OBMAN

#include "object_types.H"

Object_types object.

Public Interface

C_OBJECT_TYPES( ) ;

<<toc >>

class C_OBJEVT : public C_DBL_ITEM

#include "objevt.H"

Objevt object.

Public Interface

C_OBJEVT get_event get_processed
get_valid reset_processed reset_valid
set_event set_processed set_valid

Public Interface

C_OBJEVT( ) ;
void* get_event( ) ;
int get_processed( ) ;
int get_valid( ) ;
void reset_processed( ) ;
void reset_valid( ) ;
void set_event( void* e ) ;
void set_processed( ) ;
void set_valid( ) ;

<<toc >>

class C_OBJMAN : public C_SIMOBJ

#include "objman.H"

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 () or CardDeal().

Public Interface

C_OBJMAN ComputeCriticalPath GetCombinedCommittedEvents
GetCombinedCommittedTime GetCombinedTotalEvents GetCombinedTotalTime
IncrementCombinedCommittedEvents IncrementCombinedCommittedTime IncrementCombinedTotalEvents
IncrementCombinedTotalTime 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 ComputeCriticalPath( double& CPU_Time , double& criticalPathTime ) ;
Internal Method: CriticalPath
Summary: 
Description: 
Return: None
int GetCombinedCommittedEvents( ) ;
double GetCombinedCommittedTime( ) ;
int GetCombinedTotalEvents( ) ;
double GetCombinedTotalTime( ) ;
void IncrementCombinedCommittedEvents( ) ;
void IncrementCombinedCommittedTime( double CPU_Time ) ;
void IncrementCombinedTotalEvents( ) ;
void IncrementCombinedTotalTime( double CPU_Time ) ;
void add_object( C_SIMOBJ* simobj ) ;
Internal Method: add_object
Summary: Add a C_SIMOBJ dynamically to the simulation
Description: This function is not currently supported
Return: None
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: get_allids
Summary: 
Description: 
Return: 
int get_allids_size( ) ;
Internal Method: get_allids_size
Summary: 
Description: 
Return: 
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 ) ;
OUT: The LOCAL_ID of the C_SIMOBJ of
interest
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: name_hash
Summary: 
Description: 
Return: 
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: remove_object Summary: Remove a C_SIMOBJ dynamically to the simulation Description: This function is not currently supported Return: None.
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: reset_interact
Summary: 
Description: 
Return: None
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: set_interact
Summary: 
Description: 
Return: None
void term( double tend ) ;
Internal Method: term
Summary: 
Description: 
Return: None

<<toc >>

class C_RBQ

#include "rbq.H"

Rbq object.

Public Interface

C_RBQ ~C_RBQ NewAlt
RBSendData RBSendSubscribedData AddGvtBarrier
RB_delete_amess RB_free_delete RB_free_delete
RB_free_generate RB_free_generate RB_free_new
RB_free_new RB_new_amess RBinsert
RBinsert RBinsert RBmemcpy
RBpop RBpop_bot RBpop_top
RBprint RBpush RBpush_bot
RBpush_top RBremove RBremove
RBremove RBremove RBremove
RBxmem cleanup delete_object
exchange exchange exchange
exchange exchange exchange
exchange exchange exchange
exchange exchange exchange
get_free_list get_optimistic get_queue
get_rbq_free get_stack new_object
pop_queue pop_stack print_memory
push_bot_queue push_queue push_stack
reset_optimistic rollback set_free_list
set_optimistic set_queue set_stack

Public Interface

C_RBQ( ) ;
~C_RBQ( ) ;
void* NewAlt( int altType ) ;
void RBSendData( double t , int extId , char* data , int bytes , int globalId , SP_HOST_USER* hu = SpHostUser ) ;
GEB4.
void RBSendSubscribedData( double t , char* name , char* data , int bytes , int globalId , SP_HOST_USER* hu = SpHostUser ) ;
static void AddGvtBarrier( C_QUEUE* qblock , C_ITEM* it ) ;
qblock
it
GEB4.
static void RB_delete_amess( void* ) ;
static void RB_free_delete( void* ) ;
static void RB_free_delete( C_FREE_LIST* f , void* ) ;
static C_ITEM* RB_free_generate( C_FREE_LIST* f , char* buff ) ;
static C_ITEM* RB_free_generate( char* buff ) ;
...... State saving methods.
static C_ITEM* RB_free_new( int i ) ;
static C_ITEM* RB_free_new( C_FREE_LIST* f , int i ) ;
static C_CANCEL_HANDLE* RB_new_amess( ) ;
...... Antimessages.
static void RBinsert( C_XHASH* xh , C_SQ_ITEM* sqit ) ;
static void RBinsert( C_XPRIORITY* xp , C_SQ_ITEM* sqit ) ;
static void RBinsert( C_XQUEUE* xq , C_SQ_ITEM* sqit ) ;
static void RBmemcpy( char* , char* , int ) ;
...... Memory copy methods.
static C_SQ_ITEM* RBpop( C_XQUEUE* xq ) ;
static C_SQ_ITEM* RBpop_bot( C_XQUEUE* xq ) ;
static C_SQ_ITEM* RBpop_top( C_XQUEUE* xq ) ;
static void RBprint( FILE* fp , char* s ) ;
...... Print methods.
static void RBpush( C_XQUEUE* xq , C_SQ_ITEM* sqit ) ;
static void RBpush_bot( C_XQUEUE* xq , C_SQ_ITEM* sqit ) ;
static void RBpush_top( C_XQUEUE* xq , C_SQ_ITEM* sqit ) ;
...... Insert and remove methods for X data structures.
static C_SQ_ITEM* RBremove( C_XPRIORITY* xp ) ;
static C_SQ_ITEM* RBremove( C_XQUEUE* xq ) ;
static C_SQ_ITEM* RBremove( C_XHASH* xh , char* name ) ;
static C_SQ_ITEM* RBremove( C_XHASH* xh , int i ) ;
static C_SQ_ITEM* RBremove( C_XQUEUE* xq , int i ) ;
static void RBxmem( char* , char* , int ) ;
static void cleanup( ) ;
static void delete_object( C_ITEM* it ) ;
static void exchange( double& v1 , double& v2 ) ;
static void exchange( double& v1 , float& v2 ) ;
static void exchange( float& v1 , double& v2 ) ;
static void exchange( float& v1 , float& v2 ) ;
static void exchange( int& v1 , double& v2 ) ;
static void exchange( int& v1 , float& v2 ) ;
static void exchange( double& v1 , int& v2 ) ;
...... Double first.
static void exchange( float& v1 , int& v2 ) ;
...... Float first.
static void exchange( int& v1 , int& v2 ) ;
...... Exchange methods.
static void exchange( unsigned long& v1 , unsigned long& v2 ) ;
...... Unsigned long.
static void exchange( void*& v1 , void*& v2 ) ;
...... Pointers.
static void exchange( char* v1 , char* v2 , int size ) ;
...... Buffers.
static C_FREE_LIST* get_free_list( ) ;
static int get_optimistic( ) ;
static C_QUEUE* get_queue( ) ;
static C_FREE_LIST* get_rbq_free( ) ;
static C_QUEUE* get_stack( ) ;
static C_ITEM* new_object( int id ) ;
static C_ITEM* pop_queue( ) ;
static C_ITEM* pop_stack( ) ;
static void print_memory( ) ;
static void push_bot_queue( C_ITEM* it ) ;
static void push_queue( C_ITEM* it ) ;
static void push_stack( C_ITEM* it ) ;
static void reset_optimistic( ) ;
static int rollback( ) ;
static void set_free_list( C_FREE_LIST* free ) ;
static void set_optimistic( ) ;
static void set_queue( C_QUEUE* q ) ;
static void set_stack( C_QUEUE* s ) ;

<<toc >>

class C_SIMOBJ

#include "simobj.H"

Class: C_SIMOBJ 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 vents 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 ~C_SIMOBJ AddComponent
AddEventHandler AddEventHandlerMethod CheckEventHandler
CheckSubType CheckSubscription EXCHANGE_SEED
GetCommittedEvents GetCommittedTime GetCriticalPathTime
GetEvCounter GetObjectHandle GetProcessingTime
GetTotalEvents GetTotalTime IncrementCommittedEvents
IncrementCommittedTime IncrementCriticalPathTime IncrementProcessingTime
IncrementTotalEvents IncrementTotalTime NamedQuery
ProcessEventHandlers Query RemoveComponent
RemoveEventHandler SetEvCounter 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 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( ) ;
virtual ~C_SIMOBJ( ) ;
void AddComponent( COMPONENT* component ) ;
Method: AddComponent Summary: Adds the component to this C_SIMOBJ Description: When a COMPONENT is added to or removed from this C_SIMOBJ using AddComponent() and RemoveComponent(), the event handlers associated with that COMPONENT will automatically be added to or removed from this C_SIMOBJ as well. This method can be used rollbackably during runtime. Return: None.
component
Component to add.
void AddEventHandler( char* eventName , EVENT_HANDLER* eventHandler ) ;
Method: AddEventHandler Summary: Adds the event handler to the C_SIMOBJ Description: If the hash table has not been created, it automatically creates the hash table with a nominal size.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: None.
eventName
Name of event.
eventHandler
Pointer to the associated event handler.
EVENT_HANDLER* AddEventHandlerMethod( char* eventName , EVENT_HANDLER_METHOD_FNC_PTR method , void* objPtr ) ;
Method: AddEventHandlerMethod Summary: Adds the event handler method to the C_SIMOBJ Description: Pass the name of the method to this method's second argument. If the event handler hash table has not been created, it automatically creates the hash table with a nominal size. 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: Pointer to the event handler created by calling AddEventHandlerMethod(). This is an optional handle if needed to subsequently remove this event handler using RemoveEventHandler().
eventName
Name of event.
method
Method name to be invoked as the associated event handler (implementation-wise, it is a pointer created by the EVENT_HANDLER_METHOD_H macro).
objPtr
Pointer to the method's object (will be the 'this' pointer if the method is contained directly in the C_SIMOBJ.
int CheckEventHandler( char* eventName ) ;
IN: id of external module
    if applicable (-1 means
    event not generated by
    external module)
eventName
String name of event to check.
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.
int GetCommittedEvents( ) ;
double GetCommittedTime( ) ;
double GetCriticalPathTime( ) ;
int GetEvCounter( ) ;
SpObjectHandle* GetObjectHandle( ) ;
Method: GetObjectHandle
Summary: Returns a reference to this simobj's object handle
Description: 
Return: A reference to this simobj's object handle
double GetProcessingTime( ) ;
int GetTotalEvents( ) ;
double GetTotalTime( ) ;
void IncrementCommittedEvents( ) ;
void IncrementCommittedTime( double CPU_Time ) ;
void IncrementCriticalPathTime( double earliestStartTime , double CPU_Time ) ;
void IncrementProcessingTime( double CPU_Time ) ;
void IncrementTotalEvents( ) ;
void IncrementTotalTime( double CPU_Time ) ;
virtual void NamedQuery( double time_tag , for the query NAME_VALUE_LIST& NameValueList , char* queryName ) ;
Virtual Method: NamedQuery 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. This form of the query passes a query name to allow specific types of queries Return: the size, in bytes, of the returned buffer, buff.
time_tag
IN: simulated time for the query.
NameValueList
OUT: query list.
queryName
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: None
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).
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 RemoveComponent( COMPONENT* component to remove ) ;
Method: RemoveComponent Summary: Removes the component from this C_SIMOBJ Description: When a COMPONENT is added to or removed from this C_SIMOBJ using AddComponent() and RemoveComponent(), the event handlers associated with that COMPONENT will automatically be added to or removed from this C_SIMOBJ as well. This method can be used rollbackably during runtime. Return: None.
void RemoveEventHandler( char* eventName , EVENT_HANDLER* eventHandler ) ;
Method: RemoveEventHandler
Summary: Removes 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: None
eventName
Name of event.
eventHandler
Pointer to EVENT_HANDLER.
void SetEvCounter( int evCounter ) ;
void combine_total_objects( ) ;
Internal Method: combine_total_objects
Summary: Recalculate the total number of objects on all nodes
Description: 
Return: None
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
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: get_TIME
Summary: Get the time of this simulation object. This is not necessarily the
         time of the current event.
Description:  
Return: time of this simulaiton object
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: get_blocking
Summary: Get the number of blocking times on this node
Description: 
Return: the number of blocking times on this node
C_XQUEUE* get_cancel_queue( ) ;
Internal Method: get_cancel_queue
Summary: Get the queue of cancelled events for this simulation object
Description: 
Return: the queue of cancelled events for this simulation object
C_DBL_QUEUE* get_evtq( ) ;
Internal Method: get_evtq
Summary: Get the event queue on this node
Description: 
Return: the event queue on this node
int get_last_etype( ) ;
Internal Method: get_last_etype
Summary: Get the previous event type to act on this simulation object
Description: 
Return: the previous event type to act on this simulation object
C_RQUEUE* get_local_rqueue( ) ;
Internal Method: get_local_rqueue
Summary: Retrieve this simulation object's queue of unprocessed events
Description: 
Return: this simulation object's queue of unprocessed events
void* get_manager( int om = - 2 ) ;
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 Default is this simobj's 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: get_ncancel
Summary: Get the number of cancelled events for this object
Description: 
Return: the number of cancelled events for this object
C_OBJECT_TYPES* get_obman( ) ;
Internal Method: get_obman
Summary: Get this simulation object's object manager constructor
Description: 
Return: this simulation object's object manager constructor
char* get_obname( int i ) ;
Internal Method: get_obname (FOR BACKWARD COMPATIBILITY) Summary: Get the NAME of this simulation object Description: Return: the NAME of this simulation object.
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: get_rq_holder
Summary: Get the rollback queue holder for this simulation object (see
         C_RQ_HOLDER)
Description: 
Return: the rollback queue holder for this simulation object
SIMTIME& get_tblock( ) ;
Internal Method: get_tblock
Summary: Get the simulated time tag of the earliest blocking event
Description: 
Return: None
int get_uid_seed( ) ;
Internal Method: get_uid_seed
Summary: Get the seed to calculate GLOBAL_ID
Description: 
Return: seed for calculating GLOBAL_ID
void init_objs( ) ;
Internal Method: init_objs
Summary: Initialization routine for simulation objects
Description: 
Return: None
void insert_event( C_SQ_ITEM* event ) ;
Internal Method: insert_event
Summary: Insert an event into this simulation object's list of pending events
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
c
IN: NAME of a 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: print_event_memory
Summary: print out free list event memory statistics
Description: 
Return: None
virtual void query( double time_tag , NAME_VALUE_LIST& NameValueList ) ;
void remove_block( C_ITEM* it ) ;
Internal Method: remove_block
Summary: Remove a time from this node's list of blocking times
Description: 
Return: None
it
IN: a C_ITEM with whose TIME_TAG is a blocking time to remove from this node's list of blocking times.
void reset_nlobjs( ) ;
Internal Method: reset_nlobjs
Summary: Set the number of local objects to zero
Description: 
Return: None
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 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.
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: set_LOCAL_ID
Summary: Set 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: None
virtual void set_NAME( char* n ) ;
Internal Method: set_NAME
Summary: Set the name of this object (for referring to this C_SIMOBJ by name)
Description: 
Return: None
void set_NODE( int nd ) ;
Internal Method: set_NODE
Summary: Set the node (process number on local machine) that this C_SIMOBJ
         shall be instantialted on.
Description:
Return: None
void set_N_NODES( int nds ) ;
Internal Method: set_N_NODES
Summary: Set the total number of nodes (process number on local machine) in
         the entire simulation (including all other machines' process)
Description: 
Return: None
void set_N_OBJECT_TYPES( int nt ) ;
Internal Method: set_N_OBJECT_TYPES
Summary: Set the total number of OBJECT_TYPEs (see above) in the current
         simulation
Description: 
Return: None
void set_OBJECT_TYPE( int obtyp ) ;
Internal Method: set_OBJECT_TYPE Summary: Set 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: None.
void set_RANDOM( C_RANDOM* r ) ;
Internal Method: set_RANDOM
Summary: Set the random number generator. There is exactly one C_RANDOM
         object per node, set automatically by the framework.  User should
         only use get.
Description: see C_RANDOM
Return: None
void set_SEED( int sd ) ;
Internal Method: set_SEED
Summary: Set the seed for the random number generator. Must be saved and
         recalled for repeatability due to rollbacks.
Description: 
Return: None
void set_TIME( SIMTIME& tt ) ;
Internal Method: set_TIME
Summary: Set the time of this simulation object. This is not necessarily the
         time of the current event.
Description:  
Return: None
void set_TOTAL_OBJECTS( int to ) ;
Internal Method: set_TOTAL_OBJECTS
Summary: Set the total number of objects in the simulation. That is, the sum
         of each object of each object type on each node.
Description: 
Return: None
void set_evtype( void* e ) ;
Internal Method: set_evtype
Summary: Set the event manager object for this node (type C_EVENT_TYPES)
Description: 
Return: None
void set_init_event_queue( C_QUEUE* qi ) ;
Internal Method: set_init_event_queue 
Summary: Set the event queue for this node to its initial queue
Description: 
Return: None
void set_last_etype( int e ) ;
Internal Method: set_last_etype
Summary: Set the previous event type to act on this simulation object
Description: 
Return: None
void set_obman( C_OBJECT_TYPES* ob ) ;
Internal Method: set_obman
Summary: Set this simulation object's object manager constructor
Description: 
Return: None
void set_rbq( C_RBQ* r ) ;
Internal Method: set_rbq
Summary: Set the rollback queue for this object
Description: 
Return: None
void set_rq_holder( C_RQ_HOLDER* rqh ) ;
Internal Method: set_rq_holder
Summary: Set the rollback queue holder for this simulation object (see
         C_RQ_HOLDER)
Description: 
Return: None
void set_rqueue( C_RQUEUE* rq ) ;
Internal Method: set_rqueue
Summary: Attach this node's event queue to this simulation object
Description: 
Return: None
void set_uid_seed( int sd ) ;
Internal Method: set_uid_seed
Summary: Set the seed to calculate GLOBAL_ID
Description: 
Return: None
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: unblock
Summary: unblock a socket
Description: 
Return: None
soc
IN: the socket ID to unblock.
void update_block( ) ;
Internal Method: update_block
Summary: update the blocking and unblocking event lists for this node
Description: 
Return: None
static void add_block( C_ITEM* it ) ;
Internal Method: add_block
Summary: Add a blocking time
Description: 
Return: None
it
IN: a C_ITEM whose TIMETAG is a blocking time.
static void add_unblock( C_ITEM* it ) ;
Internal Method: add_unblock
Summary: Insert the current event as an unblocking event after a specified
         event in this node's list of unblocking events
Description: 
Return: None
it
IN: the event after which the current event is to be inserted.
static C_QUEUE* get_qblock( ) ;
Internal Method: get_qblock
Summary: Get the queue of blocking times for this node
Description: 
Return: the queue of blocking times for this node

<<toc >>

class DUMMY_OBJ

#include "rbq.H"


<<toc >>

class EVENT_HANDLER

#include "EventHandler.H"

Public Interface

EVENT_HANDLER ~EVENT_HANDLER Process
SetComponent SetGlobalId SetLocalId
SetNode SetObjectType SetSimObj

Public Interface

EVENT_HANDLER( ) ;
virtual ~EVENT_HANDLER( ) ;
virtual void Process( char* eventName , SIMTIME& timeTag , char* data , int dataBytes , int externalId ) ;
void SetComponent( COMPONENT* comp ) ;
void SetGlobalId( int globalId ) ;
void SetLocalId( int localId ) ;
void SetNode( int node ) ;
void SetObjectType( int objectType ) ;
void SetSimObj( C_SIMOBJ* simObj ) ;

<<toc >>

class EVENT_HANDLER_EVENT_MESS : public C_HEADER

#include "EventHandlerEventMess.H"

Event handler event message.

Public Interface

Public Data

int DataBytes;

<<toc >>

class EVENT_HANDLER_HOLDER : public C_SQ_ITEM

#include "EventHandlerHolder.H"

Public Interface

EVENT_HANDLER_HOLDER EVENT_HANDLER_HOLDER ~EVENT_HANDLER_HOLDER
AddEventHandler AddEventHandlerMethod GetEventHandler
GetName ProcessEventHandlers RemoveEventHandler
SetEventName SetGlobalId SetLocalId
SetNode SetObjectType SetSimObj

Public Interface

EVENT_HANDLER_HOLDER( ) ;
EVENT_HANDLER_HOLDER( int numberOfHandlers ) ;
~EVENT_HANDLER_HOLDER( ) ;
int AddEventHandler( EVENT_HANDLER* eventHandler ) ;
EVENT_HANDLER* AddEventHandlerMethod( void* object , EVENT_HANDLER_METHOD_FNC_PTR method ) ;
EVENT_HANDLER* GetEventHandler( int i ) ;
virtual char* GetName( ) ;
void ProcessEventHandlers( SIMTIME& TimeTag , char* data , int dataBytes , int externalId ) ;
int RemoveEventHandler( EVENT_HANDLER* eventHandler ) ;
void SetEventName( char* eventName ) ;
void SetGlobalId( int globalId ) ;
void SetLocalId( int localId ) ;
void SetNode( int node ) ;
void SetObjectType( int objectType ) ;
void SetSimObj( C_SIMOBJ* simObj ) ;

<<toc >>

class EVENT_HANDLER_METHOD : public EVENT_HANDLER

#include "EventHandlerMethod.H"

Internal Class: EVENT_HANDLER_METHOD
Summary: Event handler that calls an object method when invoked by a
         named event
Description: 

Public Interface

EVENT_HANDLER_METHOD( void* objPtr , EVENT_HANDLER_METHOD_FNC_PTR met ) ;
void Process( char* eventName , SIMTIME& timeTag , char* data , int dataBytes , int externalId ) ;

<<toc >>

struct EventContainer

#include "Speedes.H"

Public Interface

Public Data

EventConstructFunc conFunc;
int eSize;
int mSize;
char* name;
int numFree;

<<toc >>

struct EventHandlerElement

#include "Component.H"

Internal Struct: EventHandlerElement Summary: elements for the EventHandlerList XLIST Description:

Public Interface

EventHandlerElement( char* name , EVENT_HANDLER* handler ) ;
~EventHandlerElement( ) ;

Public Data

EVENT_HANDLER* eventHandler;
char* eventName;

<<toc >>

class FloatSemaphore : public ResourceSemaphore

#include "Semaphore.H"

Public Interface

FloatSemaphore FloatSemaphore operator double&
operator+= AddResource RemoveBlockingProcess
RequestResource

Public Interface

FloatSemaphore( ) ;
FloatSemaphore( double a ) ;
operator double&( ) ;
double operator+=( double d ) ;
double AddResource( double val ) ;
virtual void RemoveBlockingProcess( StackElement* LVptr ) ;
int RequestResource( double requestAmount , int eventType , StackElement* LVptr , int timeOut = 0 ) ;

<<toc >>

struct FloatWaitingItem : public SemaphoreWaitingItem

#include "Semaphore.H"

Public Interface

FloatWaitingItem( double ra , int et , StackElement* lv , int tof ) ;

Public Data

double requestAmount;

<<toc >>

struct Future

#include "processTypes.H"

Public Interface

Future( ) ;

Public Data

STATE_INT blocking;
STATE_INT set;

<<toc >>

class GO_TO_TIME : public C_ITEM

#include "GoToTime.H"

Public Interface

double GetGoToTime( ) ;
void SetGoToTime( double t ) ;

<<toc >>

class IntegerSemaphore : public ResourceSemaphore

#include "Semaphore.H"

Public Interface

IntegerSemaphore IntegerSemaphore operator int&
operator+= AddResource RemoveBlockingProcess
RequestResource

Public Interface

IntegerSemaphore( ) ;
IntegerSemaphore( int a ) ;
operator int&( ) ;
int operator+=( int d ) ;
int AddResource( int val ) ;
virtual void RemoveBlockingProcess( StackElement* LVptr ) ;
int RequestResource( int requestAmount , int eventType , StackElement* LVptr , int timeOut = 0 ) ;

<<toc >>

struct IntegerWaitingItem : public SemaphoreWaitingItem

#include "Semaphore.H"

Public Interface

IntegerWaitingItem( int ra , int et , StackElement* lv , int tof ) ;

Public Data

int requestAmount;

<<toc >>

class LogicalSemaphore : public Semaphore

#include "Semaphore.H"

Public Interface

LogicalSemaphore LogicalSemaphore operator=
operator int& operator++ operator++
operator+= operator-- operator--
operator-= GetState PrintState
RemoveBlockingProcess Toggle WaitForLogical

Public Interface

LogicalSemaphore( ) ;
LogicalSemaphore( int a ) ;
int operator=( int d ) ;
operator int&( ) ;
int operator++( ) ;
int operator++( int ) ;
int operator+=( int amount ) ;
int operator--( ) ;
int operator--( int ) ;
int operator-=( int amount ) ;
int GetState( ) ;
void PrintState( ) ;
virtual void RemoveBlockingProcess( StackElement* LVptr ) ;
int Toggle( int newState = 1 ) ;
int WaitForLogical( int eventType , StackElement* LVptr , int timeOut = 0 ) ;

<<toc >>

class ObjectManagerContainer

#include "Speedes.H"

Public Interface

ObjectManagerContainer GetConFunc GetName
SetConFunc SetName

Public Interface

ObjectManagerContainer( char* n = ( ( void* ) 0 ) , ObjManConstructFunc omcf = ( ( void* ) 0 ) ) ;
ObjManConstructFunc GetConFunc( ) ;
char* GetName( ) ;
ObjectManagerContainer* SetConFunc( ObjManConstructFunc omcf ) ;
ObjectManagerContainer* SetName( char* n ) ;

Public Data

ObjManConstructFunc conFunc;
char* name;

<<toc >>

class RB_ASSERT_OBJ : public BASE_STATE

#include "rbAssertObj.H"

GEB4: Rollbackable assert.

Public Interface

RB_ASSERT_OBJ RB_ASSERT_OBJ makeErrorStr
rbAssert setAssertStream setAssertStream

Public Interface

RB_ASSERT_OBJ( char* fname ) ;
RB_ASSERT_OBJ( ostream* targetOutStream = & cerr ) ;
char* makeErrorStr( char* test , char* msg , char* file , int lineNum ) ;
int rbAssert( int cond , char* test , char* msg , char* file , int lineNum , int status = 1 ) ;
void setAssertStream( char* fname ) ;
void setAssertStream( ostream* targetOutStream ) ;

<<toc >>

class RB_BINARY_TREE : public BINARY_TREE

#include "RB_BinaryTree.H"

Public Interface

Insert Insert Remove
Remove RemoveFirstElement RemoveFirstElement

Public Interface

void Insert( void* element , char* keyName ) ;
void Insert( void* element , double key ) ;
void* Remove( char* keyName ) ;
void* Remove( double key ) ;
void* RemoveFirstElement( ) ;
void* RemoveFirstElement( double& key ) ;

<<toc >>

class RB_DYN_PTR_ARRAY

#include "RB_DynArray.H"

Public Interface

RB_DYN_PTR_ARRAY ~RB_DYN_PTR_ARRAY operator[]
GetArraySize

Public Interface

RB_DYN_PTR_ARRAY( int sizeOfArray = 2 ) ;
~RB_DYN_PTR_ARRAY( ) ;
RB_pointer& operator[]( int index ) ;
Dynamic array operators.
int GetArraySize( ) ;

<<toc >>

class RB_HASH_TREE

#include "RB_HashTree.H"

Public Interface

RB_HASH_TREE RB_HASH_TREE operator++
operator++ operator+= operator--
operator-- operator-= CheckIntegrity
Find Find GetArraySize
GetBinaryTree GetBinaryTree GetCurrentElement
GetFirstElement GetHashId GetLastElement
GetNextElement GetNumElements GetPreviousElement
Insert Insert IsBalancedTreeMode
IsNormalTreeMode IsSplayTreeMode Remove
Remove SetArraySize SetBalancedTreeMode
SetNormalTreeMode SetSplayTreeMode

Public Interface

RB_HASH_TREE( ) ;
RB_HASH_TREE( int arraySize ) ;
void* operator++( ) ;
void* operator++( int ) ;
void operator+=( void* ptr ) ;
void* operator--( ) ;
void* operator--( int ) ;
void* operator-=( void* ptr ) ;
int CheckIntegrity( ) ;
void* Find( char* keyName ) ;
void* Find( int key ) ;
int GetArraySize( ) ;
RB_BINARY_TREE* GetBinaryTree( ) ;
RB_BINARY_TREE* GetBinaryTree( int arrayIndex ) ;
void* GetCurrentElement( ) ;
void* GetFirstElement( ) ;
int GetHashId( char* keyName ) ;
void* GetLastElement( ) ;
void* GetNextElement( ) ;
int GetNumElements( ) ;
void* GetPreviousElement( ) ;
void Insert( void* element , char* keyName ) ;
void Insert( void* element , int key ) ;
int IsBalancedTreeMode( ) ;
int IsNormalTreeMode( ) ;
int IsSplayTreeMode( ) ;
void* Remove( char* keyName ) ;
void* Remove( int key ) ;
void SetArraySize( int arraySize ) ;
void SetBalancedTreeMode( ) ;
void SetNormalTreeMode( ) ;
void SetSplayTreeMode( ) ;

<<toc >>

class RB_LIST : public LIST

#include "RB_List.H"

RB_LIST - doubly linked list data structure.

Public Interface

RB_LIST operator+= operator-=
RB_Insert RB_Remove RB_add
RB_remove set_rbq

Public Interface

RB_LIST( ) ;
Constructor: RB_LIST
Summary: Constructs the RB_LIST (no arguments required)
Description:
Return:
void* operator+=( void* v ) ;
Operator: +=
Summary: Rollbackly inserts an element to the bottom of the list
Description:
Return: The list item container
void operator-=( void* v ) ;
Operator: -=
Summary: Rollbackly removes an element from the list
Description:
Return:
void* RB_Insert( void* v , int TopBotFlag = BOT_FLAG ) ;
Method: RB_Insert
Summary: Rollbackly inserts an element to the top or bottom of the list
         Note, the default is to insert the element to the bottom
Description:
Return: The list item container
void RB_Remove( void* v ) ;
Method: RB_Remove
Summary: Rollbackly removes an element from the list
Description:
Return:
void* RB_add( void* v , int TopBotFlag = BOT_FLAG ) ;
Backward compatibility.
void RB_remove( void* v ) ;
Backward compatibility.
void set_rbq( void* r ) ;
Method: set_rbq
Summary: Called by SPEEDES to initialize the rollback queue
Description:
Return:

<<toc >>

class RB_PRIORITY_TREE

#include "RB_PriorityTree.H"

Public Interface

RB_PRIORITY_TREE CheckIntegrity Find
GetCurrentPriority GetNumElements Insert
IsBalancedTreeMode IsNormalTreeMode IsSplayTreeMode
Remove Remove Retract
SetBalancedTreeMode SetNormalTreeMode SetSplayTreeMode

Public Interface

RB_PRIORITY_TREE( ) ;
int CheckIntegrity( ) ;
void* Find( double priority ) ;
double GetCurrentPriority( ) ;
int GetNumElements( ) ;
void* Insert( void* element , double priority ) ;
int IsBalancedTreeMode( ) ;
int IsNormalTreeMode( ) ;
int IsSplayTreeMode( ) ;
void* Remove( ) ;
void* Remove( double& priority ) ;
int Retract( void* retractionHandle ) ;
void SetBalancedTreeMode( ) ;
void SetNormalTreeMode( ) ;
void SetSplayTreeMode( ) ;

<<toc >>

class RB_ostream : public BASE_STATE

#include "state_variable.H"

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<< operator<< initAltStream

Public Interface

RB_ostream( RB_ostream::ostream* targetOutStream = & cout ) ;
RB_ostream( char* fname ) ;
alt_ostream& operator<<( IO_Manipulator f ) ;
alt_ostream& operator<<( SIMTIME time ) ;
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( ) ;

<<toc >>

struct ReentryMsg : public C_HEADER

#include "ReentryMsg.H"

Public Interface

Public Data

Reentry_T reentry;
For ASK or FUTURE_ASK returns, else not filled in.
StackElement* reentryLV;
For all reentries, to recover local variables.
int type;
Enum for type of process model message (see processTypes.H).

<<toc >>

struct Reentry_T

#include "processTypes.H"

Public Interface

Public Data

int eventType;
void* futurePtr;
Pointer to future value for future fulfillments, (ie, returning from a FUTURE_ASK) else, NULL.
double lookahead;
SpObjectHandle obj;

<<toc >>

class ResourceSemaphore : public Semaphore

#include "Semaphore.H"

Abstract base class.

Public Interface

double operator=( double d ) ;

<<toc >>

class SPEEDES

#include "Speedes.H"

Public Interface

SPEEDES Execute GetEventConFunc
GetEventName GetEventSize GetMessageSize
GetNumEventTypes GetNumFree GetNumObjManTypes
GetObjManConFunc GetObjManName PlugInEvent
PlugInObjMan Print

Public Interface

SPEEDES( ) ;
int Execute( int argc = 0 , char** argv = ( ( void* ) 0 ) ) ;
EventConstructFunc GetEventConFunc( int id ) ;
char* GetEventName( int id ) ;
int GetEventSize( int id ) ;
int GetMessageSize( int id ) ;
int GetNumEventTypes( ) ;
int GetNumFree( int id ) ;
int GetNumObjManTypes( ) ;
ObjManConstructFunc GetObjManConFunc( int id ) ;
char* GetObjManName( int id ) ;
int PlugInEvent( char* name , EventConstructFunc conFunc , int eSize , int mSize , int numFree ) ;
int PlugInObjMan( char* name , ObjManConstructFunc conFunc ) ;
void Print( ostream& out = cout ) ;

<<toc >>

class SP_HOST_USER

#include "SpHostUser.H"

Class: SP_HOST_USER.

Summary: The SP_HOST_USER class is the internal SPEEDES interface to the Host Router which allows communication with the world outside of SPEEDES.

Description: From external modules, the only way to get information from inside of SPEEDES is to use the EM_HOST_USER class which simply gets its information from the HostRouter (Contained within the SpeedesServer executable). The way this information is sent to the Host Router from SPEEDES is through the use of the SP_HOST_USER interface. This interface allows one to get information out of SPEEDES as well as get information into SPEEDES.

This interface includes several generic GetMessage calls to get messages from the outside world as well as generic methods for sending data, query replies, subscribed data, time synchronization calls and other.

Examples: There are several examples of how to use some of these calls in the demo BmdSim which communicates with the STATE_MANAGER (the OPSM which uses the EM_HOST_USER to get data from SPEEDES). There is an example of how to reply to a query message within the default Query event in src/speedes/query.C.

One overiding rule that you should always try to follow when sending data to the outside world is to only do this only in commit(). You may notice that the default query event in query.C sends its data in process(). This is because we can guarantee that query events will only be processed at GVT which means that they cannot be rolled back. Please understand that this is an exception to the rule and that you should, in general, only send data to the outside world in commit().

Even following this rule may lead to unexpected results. The reason is that when you process() your event, the object may have one state but when you call commit(), that state may have changed. The reason is that other events may "sneak" in between your process and commit() (commit() is called at GVT updates) and change the state of the object. If you need to ensure this does not happen, you need to create data that is only modifiable by your event and use this data in commit() when you send your message out.

Public Interface

SP_HOST_USER SP_HOST_USER SP_HOST_USER
SP_HOST_USER ~SP_HOST_USER CancelReply
CommandReply ConnectionStatus FindScheduledGoToTimeGrant
Flush GetMessage GetMessage
GetNumGoToTimeGrants GetScheduledGoToTimeGrant GetScheduledTimeAdvanceGrant
GrantGoToTime QueryReply ReadMessages
ScheduleEventReply ScheduleGoToTimeGrant ScheduleTimeAdvanceGrant
SendData SendSubscribedData SpeedesConnection
TimeAdvanceGrant TimeReply UnScheduleGoToTimeGrant
UnScheduleTimeAdvanceGrant

Public Interface

SP_HOST_USER( ) ;
Method: SP_HOST_USER() Summary: default constructor for a SP_HOST_USER Description: The default constructor searches the current directory for the file speedes.par. It then goes to the section on the SpeedesServer and finds the appropriate machine name, port and group for the HostRouter and attempts to connect to that HostRouter. If it cannot connect, it simply returns a NULL for that SP_HOST_USER. Return: A new SP_HOST_USER.
SP_HOST_USER( DATA_PARSER* Parser ) ;
Method: SP_HOST_USER(DATA_PARSER *)
Summary: Constructor of a SP_HOST_USER from an already opened par file
Description: If you have already opened the par file from which you
             want to read the port, machine, and group number for
             your SPEEDES process, this is the constructor you want
             to use.
Return: A new SP_HOST_USER
Parser
In: parser that contains the machine name, port and group number for the host router and this simulation.
SP_HOST_USER( char* FileName ) ;
Method: SP_HOST_USER(char *)
Summary: Construcs a SP_HOST_USER using the data from a pre-recorded
         simulation.
Description: One can record all messages from the outside world and
             then pipe them back into a simulation using this call.
             This can be very useful for debugging your
             applications
Return: A new SP_HOST_USER
FileName
In: File name of the pre-recorded simulation.
SP_HOST_USER( char* MachineName , int Port , int Group ) ;
Method: SP_HOST_USER(char *, int, int)
Summary: Constructor of a SP_HOST_USER for a specific machine, port,
         and group
Description: If, for some reason, you want to specify exactly what
             machine, port and group you want to use for this
             simulation, feel free to do so.  But this is NOT THE
             BEST WAY TO DO THINGS!!!.  The prefered method is to
             use the default constructor and just read this data
             from the file speedes.par
Return: A new SP_HOST_USER
MachineName
In: Machine name where the HostRouter (SpeedesServer) resides.
Port
In: Port of the Host Router.
Group
In: Group ID for your simulation.
~SP_HOST_USER( ) ;
Method: ~SP_HOST_USER() Summary: destructor of a SP_HOST_USER Description: This is an internal call and should not be used by end usersdestroys a SP_HOST_USER and disconnects from the HOST_ROUTER. Users should never make this call. Presently, the destruction of a SP_HOST_USER does not remove any barriers that external modules raised. This could lead to locking SPEEDES since nothing would then ever remove those barrers. Return:
void CancelReply( int externalId , int returnCode ) ;
void CommandReply( double Time , int ExternalId , int CommandStatus ) ;
Method: CommandReply(double, int, int) Summary: returns the time and status to an external user making a command Description: This is an internal SPEEDES call. SPEEDES automatically calls this method in response to any command that was received from an external module. It replies to let it know what time the command was processed as well as a status of the command. This status is, essentially, whether or not SPEEDES was able to find a matching command or not. Return: void.
Time
In: Time at which command was processed.
ExternalId
In: ID of module that scheduled command.
CommandStatus
In: Status of the command.
int ConnectionStatus( ) ;
int FindScheduledGoToTimeGrant( double& BlockTime , double& LagTime , int& ExternalId ) ;
BlockTime
LagTime
ExternalId
InOut.
void Flush( ) ;
Method: Flush() Summary: Sends a flush message to the Host Router Description: When one want to make sure that the Host Router has received any previously sent data, one can issue a Flush() call which acts similar to a ping. It sends a message to the Host Router and then waits for the return. This assumes that TCP/IP (or a similar transport mechanism) is being using that guarantees in order delivery of messages. Return: void.
GENERIC_MSG_HEADER* GetMessage( ) ;
Method: GetMessage() Summary: returns a message from the host router if there is one, otherwise NULL. Description: This method first checks to see if any messages have been queued up from a prior ReadMessages() call. If so, it just grabs the first one it can find and returns it. If it does not have any queued messages, it attempts to read one from the Host Router and return it. If it still cannot find any messages, it returns null Return: a char * message or NULL if none are available.
GENERIC_MSG_HEADER* GetMessage( int Type ) ;
Method: GetMessage(int) Summary: Attempts to return a message of a certain type. NULL otherwise Description: If you are waiting for a message of a certain type, this call can be used to try and receive that message. It will first look to see if a message of type Type has been previously received by a ReadMessages call and return that message if possible. If not, it will try to receive and queue messages until it gets one of the appropriate type. If it cannot find one, then it returns NULL Return:
Type
In: the type of message you wish to return.
int GetNumGoToTimeGrants( ) ;
int GetScheduledGoToTimeGrant( double& BlockTime , double& LagTime , int& ExternalId ) ;
int GetScheduledTimeAdvanceGrant( double& TimeLag , int& ExternalId ) ;
Method: GetScheduledTimeAdvanceGrant(int&, int&) Summary: gets value of timelag and external ID for the next time advance grant. Description: This is another internal method call used to iterate through all scheduled time advance requests so that we can send out all the time advance's that have been requested. Return: Status of the operation. 1 if we had anything scheduled and 0 otherwise.
TimeLag
Out: Time lag of module requesting time advance.
ExternalId
Out: ID of the module requesting time advance.
void GrantGoToTime( double Time , int ExternalId ) ;
Method: GoToTimeGrant(double, int) Summary: Returns GVT to an external module while setting a barrier Description: Another internal SPEEDES method call for the Host Router If an external module makes a TimeAdvanceRequest, it makes this request with a given timelag. SPEEDES then creates a barrier at GVT+timelag, returns GVT in this message and, upon reaching the barrier, blocks until or unless another TimeAdvanceRequest message was received or the external module has disconnected. Return: void.
Time
In: GVT of the simulation.
ExternalId
In: ID of module requesting GVT.
void QueryReply( NAME_VALUE_LIST* NameValueList , int ExternalId ) ;
Method: QueryReply(NAME_VALUE_LIST*, int) Summary: Sends the NAME_VALUE_LIST in response to a query message Description: Upon receiving a query, one can either use the built in query response (found in src/speedes/query.C) or one can write his/her own query response. This response can contain anything you wish in the NameValueList. An example of how to fill out the NameValueList can be found in src/speedes/simobj.C. Take a look at C_SIMOBJ::query() to see how one can filll out this list. Return: void.
NameValueList
In: The information to be sent in response to a query event.
ExternalId
In: ID of the external module that scheduled query.
void ReadMessages( ) ;
Method: ReadMessages()
Summary: Attempts to read all messages from the HostRouter and queue them
Description: 
Return: void
void ScheduleEventReply( int errorCode , double time , int ExternalId , int handle ) ;
void ScheduleGoToTimeGrant( double BlockTime , double LagTime , int ExternalId ) ;
void ScheduleTimeAdvanceGrant( double TimeLag , int ExternalId ) ;
Method: ScheduleTimeAdvanceGrant(double, int) Summary: Schedules a time advance request. Description: This is an internal method used for handing time advance requests from external modules. Return: void.
TimeLag
In: Timelag for module requesting time advance.
ExternalId
In: ID of the module requesting time advance.
void SendData( double Time , int ExternalId , char* Data , int Bytes , int GlobalId ) ;
Method: SendData(double, int, char*, int, int) Summary: Sends data to an external module Description: This method sends data to an external module. The external module can then process it in any way it desires. You should be certain that you only make these calls when you are committing the event because, otherwise, the event could be rolled back and this would lead to multiple sendings of possibly conflicting information. We hope to create a roll backabe SP_HOST_USER that will allow you to send the data in process() (similar to how you can do a RB_COUT instead of cout) but this is not available yet.

Warning, don't use this with the OPSM (STATE_MANAGER). Only useSendSubscribedData to send data back to the OSPM Also note that your object state data may change between process() and commit(). Other events can change the state of the object which could lead to different data being sent out to the outside world than you anticipated unless the Data is constructed during process. Return:

Time
In: Time at which data was created.
ExternalId
In: ID of module to receive this data.
Data
In: Actual data as a char array.
Bytes
In: Size of data in bytes.
GlobalId
In: Global ID of object creating the data.
void SendSubscribedData( double Time , char* Name , char* Data , int Bytes , int GlobalId ) ;
Method: SendSubscribedData(double, char*, char*, int, int) Summary: Sends data with a special subscription name to an external module Description: This is the proper way to send data back to an OPSM. The OPSM should subscribe to nameed data with the name Name for this object. As with any other communication with the outside world, this call should only be made during commit. Also note that your object state data may change between process() and commit(). Other events can change the state of the object which could lead to different data being sent out to the outside world than you anticipated unless the Data is constructed during process. Return: void.
Time
In: Time at which data was created.
Name
In: Name of the subcription.
Data
In: Actual data as a char array.
Bytes
In: Size of data in bytes.
GlobalId
In: Global ID of object creating the data.
void SpeedesConnection( int Nnodes , int Node , C_QUEUE* NameList ) ;
Method: SpeedesConnection(int, int, C_QUEUE*) Summary: Sets up various Name list and Node information within the Host Router. Description: This call is used by SPEEDES internally. It should never be made by users. This method is called by each node after all the objects have been created to tell the HostRouter what objects are on this node and what their names are. Return:
Nnodes
In: Total number of nodes.
Node
In: Node number of this box.
NameList
In: A list of all the objects on this node and their names.
void TimeAdvanceGrant( double Time , int ExternalId ) ;
Method: TimeAdvanceGrant(double, int) Summary: Returns GVT to an external module while setting a barrier Description: Another internal SPEEDES method call for the Host Router If an external module makes a TimeAdvanceRequest, it makes this request with a given timelag. SPEEDES then creates a barrier at GVT+timelag, returns GVT in this message and, upon reaching the barrier, blocks until or unless another TimeAdvanceRequest message was received or the external module has disconnected. Return: void.
Time
In: GVT of the simulation.
ExternalId
In: ID of module requesting GVT.
void TimeReply( double Time , int ExternalId ) ;
Method: TimeReply(double, int) Summary: Sends the time to an external module. Description: This is another internal SPEEDES method call. Whenever SPEEDES receives a request for its time, it does a GVT update and then sends this message out with the correct simulation time. Return: void.
Time
In: GVT of the Simulation.
ExternalId
In: ID of module requesting GVT.
void UnScheduleGoToTimeGrant( int ExternalId ) ;
void UnScheduleTimeAdvanceGrant( int ExternalId ) ;
Method: UnScheduleTimeAdvanceGrant(int)
Summary: Unschedule a time advance grant for an external module
Description: This is an internal method used for removing a
             scheduled time advance grant when an external module
             removes barriers or exits.
Return: 
ExternalId
In: ID of the module requesting time advance.

<<toc >>

class STATE_DOUBLE : public BASE_STATE

#include "state_variable.H"

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/=
SetDelta SetMultiplier 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 SetDelta( double del ) ;
double SetMultiplier( double m , int mode ) ;
double assign( double d ) ;
void print( char* s ) ;
void print( ) ;
...... Other methods.

Public Data

double state_variable;

<<toc >>

class STATE_FLOAT : public BASE_STATE

#include "state_variable.H"

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/=
SetDelta SetMultiplier 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 ) ;
float SetDelta( float del ) ;
float SetMultiplier( float m , int mode ) ;
double assign( float d ) ;
void print( char* s ) ;
void print( ) ;
...... Other methods.

Public Data

float state_variable;

<<toc >>

class STATE_INT : public BASE_STATE

#include "state_variable.H"

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 STATE_INT operator=
operator delete operator int operator new
operator%= operator&= operator*=
operator++ operator++ operator+=
operator-- operator-- operator-=
operator/= operator<<= operator>>=
operator^= operator|= Exchange
SetDelta SetMultiplier assign
print print

Public Interface

STATE_INT( ) ;
STATE_INT( STATE_INT& s ) ;
The sizeof(BASE_STATE) is 1 (even though BASE_STATE has no non-static members, the C++ language standard still requires it to have non-zero size). This STATE_INT class adds on 4 bytes to make a total of 5 bytes but 5 is not a multiple of the number of bytes in the int which is 4. Therefore the compiler pads this class with 3 more bytes. The padding is copied by the default copy constructor supplied by the CenterLine compiler, and gets a UMR (uninitialized memory read). Therefore I supplied an explicit copy constructor here which does not have a UMR. If this works, then someday we may need to do a similar thing for the other descendants of BASE_STATE.
int operator=( int i ) ;
void operator delete( void* p ) ;
operator int( ) const;
...... 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 ) ;
int operator+=( int i ) ;
int operator--( ) ;
int operator--( int ) ;
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 SetDelta( int del ) ;
int SetMultiplier( int m , int mode ) ;
int assign( int i ) ;
void print( char* s ) ;
void print( ) ;
...... Other methods.

Public Data

int state_variable;

<<toc >>

class STATE_POINTER : public BASE_STATE

#include "state_variable.H"

State_pointer object.

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

Class: STATE_POINTER (typedef'd to RB_pointer) Summary: Rollbackable pointer Description: Use this just as you would a normal void or character pointer on the right-hand side of equations when that pointer is part of the state of a C_SIMOBJ or non-C_SIMOBJ object (ie, when it needs to be rollbackable). In addition to regular use on the right-hand side of equations as a void or character pointer, this object can be rollbackably set equal to another void pointer using the = operator. The = operator is the only left-hand side of equations operator supported.

Public Interface

STATE_POINTER operator= operator char*
operator void* assign

Public Interface

STATE_POINTER( ) ;
void* operator=( void* v ) ;
operator char*( ) ;
operator void*( ) ;
...... Conversion method allows this object to be used as a void* or char.
void* assign( void* p ) ;

Public Data

void* state_variable;

<<toc >>

class STATE_STRING : public BASE_STATE

#include "state_variable.H"

State_string object.

Class: STATE_STRING (typedef'd to RB_string) Summary: Rollbackable character pointer Description: Use this just as you would a normal character pointer on the right-hand side of equations when that character pointer is part of the state of a C_SIMOBJ or non-C_SIMOBJ object (ie, when it needs to be rollbackable). In addition to regular use on the right-hand side of equations as a character pointer, this object can be set equal to another character pointer using the = operator, and the string that the other character pointer points to will be rollbackably copied to this character pointer. Memory management is handled automatically. The = operator is the only left-hand side of equations operator supported.

Public Interface

STATE_STRING ~STATE_STRING operator=
operator char* EraseString SetNoRollback
assign print print

Public Interface

STATE_STRING( ) ;
~STATE_STRING( ) ;
char* operator=( char* v ) ;
operator char*( ) ;
...... Conversion method allows this object to be used as a char.
void EraseString( ) ;
void SetNoRollback( char* s ) ;
char* assign( char* s ) ;
void print( char* s ) ;
void print( ) ;
...... Other methods.

Public Data

char* state_variable;

<<toc >>

class SUB_TYPE : public C_SQ_ITEM

#include "SubType.H"

Public Interface

SUB_TYPE SUB_TYPE ~SUB_TYPE
Compare Compare GetExternalId
GetName GetType SetExternalId
SetType

Public Interface

SUB_TYPE( ) ;
SUB_TYPE( char* type , int externalId ) ;
~SUB_TYPE( ) ;
int Compare( char* type ) ;
int Compare( char* type , int externalId ) ;
int GetExternalId( ) ;
virtual char* GetName( ) ;
char* GetType( ) ;
void SetExternalId( int externalId ) ;
void SetType( char* type ) ;

<<toc >>

class Semaphore : public C_SQ_ITEM

#include "Semaphore.H"

Abstract base class.

Public Interface

operator*= operator+= operator-=
operator/= RemoveBlockingProcess ScheduleSuccessfulSemReturnEvent

Public Interface

double operator*=( double d ) ;
double operator+=( double d ) ;
double operator-=( double d ) ;
double operator/=( double d ) ;
virtual void RemoveBlockingProcess( StackElement* LVptr ) = 0;
Semaphore() {}.
void ScheduleSuccessfulSemReturnEvent( StackElement* LVptr , int eventType ) ;

<<toc >>

struct SemaphoreWaitingItem

#include "Semaphore.H"

Semaphore support structures:

Public Interface

SemaphoreWaitingItem( int et , StackElement* lv , int tof ) ;

Public Data

StackElement* LVptr;
int eventType;
int timeOut;

<<toc >>

class SharedSemaphore : public C_SQ_ITEM

#include "Semaphore.H"

Public Interface

SharedSemaphore Add GetAmount
GetName Request

Public Interface

SharedSemaphore( char* n , double a ) ;
void Add( double addAmount ) ;
double GetAmount( ) ;
virtual char* GetName( ) ;
void Request( double requestAmount , SpObjectHandle obj , int eventType , double reentryLA , StackElement* LVptr ) ;

<<toc >>

struct SharedSemaphoreWaitingItem : public FloatWaitingItem, public C_SQ_ITEM

#include "Semaphore.H"

Public Interface

SharedSemaphoreWaitingItem( double ra , int et , StackElement* lv , int tof , SpObjectHandle oh , double rl ) ;

Public Data

SpObjectHandle obj;
double reentryLookahead;

<<toc >>

struct Stack : public C_SQ_ITEM

#include "processTypes.H"

Public Interface

Public Data

C_XQUEUE* sePtr;
List of StackElement's.

<<toc >>

struct StackElement : public C_SQ_ITEM

#include "processTypes.H"

Public Interface

StackElement AbortProc CleanupProc
EndSetUp EstablishNewStack GetAskRetArgs
HandleSemReturn InitProc LoadContext
SaveContext ScheduleAddSharedSem ScheduleAsk
ScheduleRequestSharedSem ScheduleTimeOut ScheduleWaitReturn

Public Interface

StackElement( C_RANDOM* ran , SpObjectHandle* simobj , int procType ) ;
void AbortProc( char* name ) ;
void CleanupProc( ) ;
int EndSetUp( ReentryMsg* msg ) ;
void EstablishNewStack( ) ;
void GetAskRetArgs( ReentryMsg* msg , char* askReturn , size_t askReturnSize ) ;
void HandleSemReturn( ReentryMsg* msg , int& successFlag ) ;
void InitProc( ) ;
void LoadContext( ) ;
void SaveContext( int reentryLabel ) ;
void ScheduleAddSharedSem( SpObjectHandle resourceObj , char* resourceName , double addAmount , double addLookahead ) ;
void ScheduleAsk( int isFutureAsk , int askObjNodeId , int askObjObjManId , int askObjSimObjId , int askType , char* askMethod , char* askIn , const SIMTIME& scheduleTime , double reentryLookahead , size_t inSize ) ;
void ScheduleRequestSharedSem( SpObjectHandle resourceObj , char* resourceName , double requestAmount , double requestLookahead , double reentryLookahead ) ;
void ScheduleTimeOut( const SIMTIME& currentTime , double timeOut ) ;
void ScheduleWaitReturn( const SIMTIME& currentTime , double lookahead ) ;

Public Data

C_EVENT* Event;
The this pointer of the process of this stack.
int ProcessType;
The enum of the event (event id) for this process.
C_RANDOM* Random;
The simobj's random number generator class.
ime out Semaphore* SemaphorePtr;
Save the semaphore for semaphore timeouts.
SpObjectHandle* Simobj;
The simobj with which this process is associated.
RB_pointer TimeOutCancelHandle;
Cancel handle for semaphore timeouts.
RB_int finiteTimeOut;
The following are used for the present event, the first for of which are set by the constructor since they never change whether a semaphore block has a time out.
RB_int reentryLabel;
Stored when blocking and retrieved when reentered.
RB_int seed;
For RANDOM number generator.
Stack* stackPtr;
The stack on which is this StackElement.

<<toc >>

class Thread : public C_SIMOBJ

#include "Thread.H"

S_Thread class definition.

Public Interface

Thread ~Thread CreateSharedSemaphore
GetSharedSemaphoreAmount init terminate

Public Interface

Thread( ) ;
<BEGIN: Define constructors>.
~Thread( ) ;
void CreateSharedSemaphore( char* name , double initimount ) ;
List of SharedSemaphores.
name
String name of shared semaphore.
initimount
Intial amount of the SharedSemaphore.
double GetSharedSemaphoreAmount( char* name ) ;
Method: GetSharedSemaphoreAmount
Summary: returns the current amount from named SharedSemaphore
Description:
Return: the 'amount' field from named SharedSemaphore
name
String name of shared semaphore.
void init( DATA_PARSER* Parser ) ;
<END: Define constructors>.
virtual void terminate( double tend ) ;
<END: Define public methods>.

Public Data

C_XQUEUE* sharedSemaphoreList;
List of SharedSemaphores.
C_XQUEUE* threadList;
List of Stacks.

<<toc >>

struct _SpObjectHandle

#include "ObjectHandle.H"

Public Interface

int GetNode( ) const;

Public Data

int NodeId;
int ObjManId;
int SimObjId;

<<toc >>

class alt : public C_ITEM

#include "rbq_items.H"

Public Interface

cleanup print rollback
store store store
store store_error set_alt_free_list

Public Interface

virtual void cleanup( ) ;
virtual void print( ) ;
virtual void rollback( ) = 0;
virtual void store( double ) ;
virtual void store( float ) ;
virtual void store( int ) ;
virtual void store( void* ) ;
void store_error( ) ;
static void set_alt_free_list( C_FREE_LIST* a ) ;

<<toc >>

class alt_RB_List : public alt

#include "rbq_items.H"

Public Interface

virtual void print( ) ;
virtual void rollback( ) ;
void set( RB_LIST* xla , void* ptra , int top_flaga , int flaga ) ;

<<toc >>

class alt_SEND_DATA : public alt

#include "rbq_items.H"

Public Interface

virtual void cleanup( ) ;
virtual void rollback( ) ;
void set( SP_HOST_USER* hostUser , double t , int externalId , char* data , int nBytes , int globalId ) ;

<<toc >>

class alt_SEND_SUBSCRIBED_DATA : public alt

#include "rbq_items.H"

Public Interface

virtual void cleanup( ) ;
virtual void rollback( ) ;
void set( SP_HOST_USER* hostUser , double t , char* name , char* data , int nBytes , int globalId ) ;

<<toc >>

class alt_amess : public alt

#include "rbq_items.H"

Public Interface

virtual void cleanup( ) ;
virtual void print( ) ;
virtual void rollback( ) ;

<<toc >>

class alt_binary_tree : public alt

#include "rbq_items.H"

Public Interface

SetInsert SetRemove print
rollback

Public Interface

void SetInsert( RB_BINARY_TREE* binaryTree , void* element , double key , char* keyName , int tieBreaker ) ;
void SetRemove( RB_BINARY_TREE* binaryTree , void* element , double key , char* keyName , int tieBreaker ) ;
virtual void print( ) ;
virtual void rollback( ) ;

<<toc >>

class alt_block : public alt

#include "rbq_items.H"

GEB1: obj for rolling back qblocks.

Public Interface

cleanup print rollback
setSlots

Public Interface

virtual void cleanup( ) ;
virtual void print( ) ;
virtual void rollback( ) ;
void setSlots( C_QUEUE* qBlk , C_ITEM* blockItem ) ;

<<toc >>

class alt_buff : public alt

#include "rbq_items.H"

Public Interface

cleanup print rollback
set

Public Interface

virtual void cleanup( ) ;
virtual void print( ) ;
virtual void rollback( ) ;
void set( void* va , void (* delete_with_correct_typea ) ( void* ) , int flaga ) ;

<<toc >>

class alt_delta_double : public alt

#include "rbq_items.H"

Public Interface

virtual void rollback( ) ;
void set( double* d , double delta ) ;

<<toc >>

class alt_delta_float : public alt

#include "rbq_items.H"

Public Interface

virtual void rollback( ) ;
void set( float* d , float delta ) ;

<<toc >>

class alt_delta_int : public alt

#include "rbq_items.H"

Public Interface

virtual void rollback( ) ;
void set( int* d , int delta ) ;

<<toc >>

class alt_double : public alt

#include "rbq_items.H"

Public Interface

print rollback set
store store store
store

Public Interface

virtual void print( ) ;
virtual void rollback( ) ;
void set( double* d ) ;
virtual void store( double v ) ;
virtual void store( float v ) ;
virtual void store( int v ) ;
virtual void store( void* ) ;

<<toc >>

class alt_exit : public alt

#include "rbq_items.H"

GEB4: rollbackable exit() call.

Public Interface

cleanup print rollback
set

Public Interface

virtual void cleanup( ) ;
virtual void print( ) ;
virtual void rollback( ) ;
void set( char* msga , ostream* outStreama , int exitStatusa ) ;

<<toc >>

class alt_float : public alt

#include "rbq_items.H"

Public Interface

print rollback set
store store store
store

Public Interface

virtual void print( ) ;
virtual void rollback( ) ;
void set( float* f ) ;
virtual void store( double v ) ;
virtual void store( float v ) ;
virtual void store( int v ) ;
virtual void store( void* ) ;

<<toc >>

class alt_int : public alt

#include "rbq_items.H"

Public Interface

print rollback set
store store store
store

Public Interface

virtual void print( ) ;
virtual void rollback( ) ;
void set( int* i ) ;
virtual void store( double v ) ;
virtual void store( float v ) ;
virtual void store( int v ) ;
virtual void store( void* ) ;

<<toc >>

class alt_mem : public alt

#include "rbq_items.H"

Public Interface

cleanup print rollback
set

Public Interface

virtual void cleanup( ) ;
virtual void print( ) ;
virtual void rollback( ) ;
void set( char* p , int sizea ) ;

<<toc >>

class alt_multiple_double : public alt

#include "rbq_items.H"

Public Interface

virtual void rollback( ) ;
void set( double* d , double multiple , int mult = SP_TIMES_EQUALS ) ;

<<toc >>

class alt_multiple_float : public alt

#include "rbq_items.H"

Public Interface

virtual void rollback( ) ;
void set( float* d , float multiple , int mult = SP_TIMES_EQUALS ) ;

<<toc >>

class alt_multiple_int : public alt

#include "rbq_items.H"

Public Interface

virtual void rollback( ) ;
void set( int* d , int multiple , int mult = SP_TIMES_EQUALS ) ;

<<toc >>

class alt_obj : public alt

#include "rbq_items.H"

Public Interface

cleanup print rollback
set

Public Interface

virtual void cleanup( ) ;
virtual void print( ) ;
virtual void rollback( ) ;
void set( void* p , int flaga , C_FREE_LIST* fl ) ;

<<toc >>

class alt_ostream : public alt

#include "rbq_items.H"

GEB0: obj for rolling back stream output:

Public Interface

alt_ostream operator<< operator<<
operator<< operator<< operator<<
operator<< operator<< operator<<
operator<< operator<< operator<<
operator<< cleanup deleteQ
initialize printQueue rollback
setOptimistic setStream

Public Interface

alt_ostream( ) ;
alt_ostream& operator<<( IO_Manipulator f ) ;
alt_ostream& operator<<( SIMTIME 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 ) ;
virtual void cleanup( ) ;
void deleteQ( ) ;
void initialize( ) ;
GEB10.20: initialize alt item from free list:
void printQueue( ) ;
virtual void rollback( ) ;
void setOptimistic( int opt_p ) ;
void setStream( ostream* str ) ;

<<toc >>

struct alt_ostream::outputItem

#include "rbq_items.H"

Use following to queue-up items in expression of form: stateStream << A << B << C << D ... Each item will be sprintf-ed to a string and stored in outString, except for IO_Manipulators which cannot be stringified.

Public Interface

Public Data

IO_Manipulator manip;
outputItem* next;
char* outString;

<<toc >>

class alt_print : public alt

#include "rbq_items.H"

Public Interface

cleanup print rollback
set

Public Interface

virtual void cleanup( ) ;
virtual void print( ) ;
virtual void rollback( ) ;
void set( FILE* fpa , char* sa ) ;

<<toc >>

class alt_ptr : public alt

#include "rbq_items.H"

Public Interface

print rollback set
store store store
store

Public Interface

virtual void print( ) ;
virtual void rollback( ) ;
void set( void** v ) ;
virtual void store( double ) ;
virtual void store( float ) ;
virtual void store( int ) ;
virtual void store( void* v ) ;

<<toc >>

class alt_string : public alt

#include "rbq_items.H"

Public Interface

cleanup print rollback
set

Public Interface

virtual void cleanup( ) ;
virtual void print( ) ;
virtual void rollback( ) ;
void set( char** c ) ;

<<toc >>

class alt_xhash : public alt

#include "rbq_items.H"

Public Interface

virtual void print( ) ;
virtual void rollback( ) ;
void set( C_XHASH* xha , C_SQ_ITEM* sqita , int flaga ) ;

<<toc >>

class alt_xmem : public alt

#include "rbq_items.H"

Public Interface

virtual void print( ) ;
virtual void rollback( ) ;
void set( char* p1 , char* p2 , int sizea ) ;

<<toc >>

class alt_xpriority : public alt

#include "rbq_items.H"

Public Interface

virtual void print( ) ;
virtual void rollback( ) ;
void set( C_XPRIORITY* xpa , C_SQ_ITEM* sqita , int flaga ) ;

<<toc >>

class alt_xqueue : public alt

#include "rbq_items.H"

Public Interface

virtual void print( ) ;
virtual void rollback( ) ;
void set( C_XQUEUE* xqa , C_SQ_ITEM* sqita , int flaga , int top_flaga ) ;

<<toc >>

struct mstrct

#include "speedes_comm.H"

Public Interface

Public Data

int blen;
int* buf;
int dest;
int dummy_byte_align;
int mlen;
int source;
int type;

<<toc

struct scubenv

#include "speedes_comm.H"

Structure declaration used by scparam().

Public Interface

Public Data

int bmask;
Sub-hyercube braodcast mask.
int corner;
Corner node with in sub-hypercube.
in hypercube* / int cpmask;
Mask to CP.
int cubemask;
Only used on CP.
int doc;
Dim of hypercube.
int dosc;
Dim of sub-hypercube.
int nproc;
Number of processors in hypercube.
int nsproc;
Number of processors in sub-hypercube.
int procnum;
Processor number.

CancelEvent #include "ScheduleEvent.H"
void CancelEvent(C_CANCEL_HANDLE* cancelHandle ) ;
Function: CancelEvent
Summary: Cancels an event (or event handler or process) 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
cancelHandle
IN: Cancel handle.
toc >>

EVENT_HANDLER_EVENT_esize #include "EventHandlerEvent.H"
int EVENT_HANDLER_EVENT_esize() ;
<<toc >>

EVENT_HANDLER_EVENT_msize #include "EventHandlerEvent.H"
int EVENT_HANDLER_EVENT_msize() ;
<<toc >>

EVENT_HANDLER_EVENT_nfree #include "EventHandlerEvent.H"
int EVENT_HANDLER_EVENT_nfree() ;
<<toc >>

EXCHANGE #include "def_rbq.H"
void EXCHANGE(double& v1 , double& v2 ) ;
<<toc >>

EXCHANGE #include "def_rbq.H"
void EXCHANGE(double& v1 , float& v2 ) ;
<<toc >>

EXCHANGE #include "def_rbq.H"
void EXCHANGE(double& v1 , int& v2 ) ;
<<toc >>

EXCHANGE #include "def_rbq.H"
void EXCHANGE(float& v1 , double& v2 ) ;
<<toc >>

EXCHANGE #include "def_rbq.H"
void EXCHANGE(float& v1 , float& v2 ) ;
<<toc >>

EXCHANGE #include "def_rbq.H"
void EXCHANGE(float& v1 , int& v2 ) ;
<<toc >>

EXCHANGE #include "def_rbq.H"
void EXCHANGE(int& v1 , double& v2 ) ;
<<toc >>

EXCHANGE #include "def_rbq.H"
void EXCHANGE(int& v1 , float& v2 ) ;
<<toc >>

EXCHANGE #include "def_rbq.H"
void EXCHANGE(unsigned long& v1 , unsigned long& v2 ) ;
<<toc >>

EXCHANGE #include "def_rbq.H"
void EXCHANGE(void*& v1 , void*& v2 ) ;
<<toc >>

EXCHANGE #include "def_rbq.H"
void EXCHANGE(char* v1 , char* v2 , int size ) ;
<<toc >>

EXCHANGE #include "def_rbq.H"
void EXCHANGE(int& v1 , int& v2 ) ;
Inline: EXCHANGE Summary: Exchanges two arguments Description: Takes two arguments of any combination of (int), (float), or (double), using type demotion and promotion as necessary, and exchanges them. Or, takes two pointer (void*) arguments and exchanges them. Or, takes two unsigned long arguments and exchanges them. Or, takes three arguments consisting of two (char*) buffers and a size (int or size_t) in bytes and exchanges size bytes of the character buffers pointed to by the (char*) arguments. Rather than a rollbackable operation, this macro is normally used in the exchange () virtual method in C_EVENTs to support fast rollbacks for ints, floats, doubles, pointers, and buffers (faster than using RB versions of ints, floats, doubles, and pointers for instance). To use this rollback paradigm, always save the version of a variable (old version) at the beginning of the process () virtual method in a C_EVENT, and call this EXCHANGE macro with the old version and the current version of the variable in the exchange () virtual function of the C_EVENT. This creates the fastest type of rollbackable functionality available in SPEEDES. Return: None.
<<toc >>

ExecuteSpeedes #include "Speedes.H"
int ExecuteSpeedes(int argc = 0 , char** argv = ( ( void* ) 0 ) ) ;
<<toc >>

RB_DEFINE_FREE #include "def_rbq.H"
void RB_DEFINE_FREE(C_FREE_LIST* free ) ;
Inline: RB_DEFINE_FREE 
Summary: Rollbackably define the rollback manager default free list
Description: Takes one argument representing a free list manager
             (C_FREE_LIST*) to be used as the roll back queue manager's
             default free list manager
Return: None
<<toc >>

RB_DELETE_ARRAY_EVENT_HANDLER #include "EventHandler.H"
void RB_DELETE_ARRAY_EVENT_HANDLER(EVENT_HANDLER* obj ) ;
<<toc >>

RB_DELETE_ARRAY_EVENT_HANDLER_HOLDER #include "EventHandlerHolder.H"
void RB_DELETE_ARRAY_EVENT_HANDLER_HOLDER(EVENT_HANDLER_HOLDER* obj ) ;
<<toc >>

RB_DELETE_ARRAY_EVENT_HANDLER_HOLDER_PTR #include "EventHandlerHolder.H"
void RB_DELETE_ARRAY_EVENT_HANDLER_HOLDER_PTR(EVENT_HANDLER_HOLDER** obj ) ;
<<toc >>

RB_DELETE_ARRAY_EVENT_HANDLER_PTR #include "EventHandler.H"
void RB_DELETE_ARRAY_EVENT_HANDLER_PTR(EVENT_HANDLER** obj ) ;
<<toc >>

RB_DELETE_ARRAY_FloatSemaphore #include "Semaphore.H"
void RB_DELETE_ARRAY_FloatSemaphore(FloatSemaphore* obj ) ;
<<toc >>

RB_DELETE_ARRAY_FloatSemaphore_PTR #include "Semaphore.H"
void RB_DELETE_ARRAY_FloatSemaphore_PTR(FloatSemaphore** obj ) ;
<<toc >>

RB_DELETE_ARRAY_IntegerSemaphore #include "Semaphore.H"
void RB_DELETE_ARRAY_IntegerSemaphore(IntegerSemaphore* obj ) ;
<<toc >>

RB_DELETE_ARRAY_IntegerSemaphore_PTR #include "Semaphore.H"
void RB_DELETE_ARRAY_IntegerSemaphore_PTR(IntegerSemaphore** obj ) ;
<<toc >>

RB_DELETE_ARRAY_LogicalSemaphore #include "Semaphore.H"
void RB_DELETE_ARRAY_LogicalSemaphore(LogicalSemaphore* obj ) ;
<<toc >>

RB_DELETE_ARRAY_LogicalSemaphore_PTR #include "Semaphore.H"
void RB_DELETE_ARRAY_LogicalSemaphore_PTR(LogicalSemaphore** obj ) ;
<<toc >>

RB_DELETE_ARRAY_RB_BINARY_TREE #include "RB_BinaryTree.H"
void RB_DELETE_ARRAY_RB_BINARY_TREE(RB_BINARY_TREE* obj ) ;
<<toc >>

RB_DELETE_ARRAY_RB_BINARY_TREE_PTR #include "RB_BinaryTree.H"
void RB_DELETE_ARRAY_RB_BINARY_TREE_PTR(RB_BINARY_TREE** obj ) ;
<<toc >>

RB_DELETE_ARRAY_RB_double #include "state_variable.H"
void RB_DELETE_ARRAY_RB_double(RB_double* obj ) ;
<<toc >>

RB_DELETE_ARRAY_RB_double_PTR #include "state_variable.H"
void RB_DELETE_ARRAY_RB_double_PTR(RB_double** obj ) ;
<<toc >>

RB_DELETE_ARRAY_RB_float #include "state_variable.H"
void RB_DELETE_ARRAY_RB_float(RB_float* obj ) ;
<<toc >>

RB_DELETE_ARRAY_RB_float_PTR #include "state_variable.H"
void RB_DELETE_ARRAY_RB_float_PTR(RB_float** obj ) ;
<<toc >>

RB_DELETE_ARRAY_RB_int #include "state_variable.H"
void RB_DELETE_ARRAY_RB_int(RB_int* obj ) ;
<<toc >>

RB_DELETE_ARRAY_RB_int_PTR #include "state_variable.H"
void RB_DELETE_ARRAY_RB_int_PTR(RB_int** obj ) ;
<<toc >>

RB_DELETE_ARRAY_RB_pointer #include "state_variable.H"
void RB_DELETE_ARRAY_RB_pointer(RB_pointer* obj ) ;
<<toc >>

RB_DELETE_ARRAY_RB_pointer_PTR #include "state_variable.H"
void RB_DELETE_ARRAY_RB_pointer_PTR(RB_pointer** obj ) ;
<<toc >>

RB_DELETE_ARRAY_RB_string #include "state_variable.H"
void RB_DELETE_ARRAY_RB_string(RB_string* obj ) ;
<<toc >>

RB_DELETE_ARRAY_RB_string_PTR #include "state_variable.H"
void RB_DELETE_ARRAY_RB_string_PTR(RB_string** obj ) ;
<<toc >>

RB_DELETE_ARRAY_Stack #include "processTypes.H"
void RB_DELETE_ARRAY_Stack(Stack* obj ) ;
<<toc >>

RB_DELETE_ARRAY_Stack_PTR #include "processTypes.H"
void RB_DELETE_ARRAY_Stack_PTR(Stack** obj ) ;
<<toc >>

RB_DELETE_ARRAY_char #include "def_rbq.H"
void RB_DELETE_ARRAY_char(char* obj ) ;
<<toc >>

RB_DELETE_ARRAY_char_PTR #include "def_rbq.H"
void RB_DELETE_ARRAY_char_PTR(char** obj ) ;
<<toc >>

RB_DELETE_ARRAY_double #include "def_rbq.H"
void RB_DELETE_ARRAY_double(double* obj ) ;
<<toc >>

RB_DELETE_ARRAY_double_PTR #include "def_rbq.H"
void RB_DELETE_ARRAY_double_PTR(double** obj ) ;
<<toc >>

RB_DELETE_ARRAY_float #include "def_rbq.H"
void RB_DELETE_ARRAY_float(float* obj ) ;
<<toc >>

RB_DELETE_ARRAY_float_PTR #include "def_rbq.H"
void RB_DELETE_ARRAY_float_PTR(float** obj ) ;
<<toc >>

RB_DELETE_ARRAY_int #include "def_rbq.H"
void RB_DELETE_ARRAY_int(int* obj ) ;
<<toc >>

RB_DELETE_ARRAY_int_PTR #include "def_rbq.H"
void RB_DELETE_ARRAY_int_PTR(int** obj ) ;
<<toc >>

RB_DELETE_CANCEL_HANDLE #include "def_rbq.H"
void RB_DELETE_CANCEL_HANDLE(C_CANCEL_HANDLE* obj ) ;
Inline: RB_DELETE_CANCEL_HANDLE 
Summary: Rollbackably deletes a pointer to a C_CANCEL_HANDLE, which is
         typedef-equivalent to a C_ANTIMESS, that was previously returned
         from RB_NEW_CANCEL_HANDLE
Description: Takes one argument representing a C_CANCEL_HANDLE pointer
Return: None
<<toc >>

RB_DELETE_EVENT_HANDLER #include "EventHandler.H"
void RB_DELETE_EVENT_HANDLER(EVENT_HANDLER* obj ) ;
<<toc >>

RB_DELETE_EVENT_HANDLER_HOLDER #include "EventHandlerHolder.H"
void RB_DELETE_EVENT_HANDLER_HOLDER(EVENT_HANDLER_HOLDER* obj ) ;
<<toc >>

RB_DELETE_EVENT_HANDLER_HOLDER_PTR #include "EventHandlerHolder.H"
void RB_DELETE_EVENT_HANDLER_HOLDER_PTR(EVENT_HANDLER_HOLDER** obj ) ;
<<toc >>

RB_DELETE_EVENT_HANDLER_METHOD #include "EventHandlerMethod.H"
void RB_DELETE_EVENT_HANDLER_METHOD(EVENT_HANDLER_METHOD* obj ) ;
<<toc >>

RB_DELETE_EVENT_HANDLER_METHOD_PTR #include "EventHandlerMethod.H"
void RB_DELETE_EVENT_HANDLER_METHOD_PTR(EVENT_HANDLER_METHOD** obj ) ;
<<toc >>

RB_DELETE_EVENT_HANDLER_PTR #include "EventHandler.H"
void RB_DELETE_EVENT_HANDLER_PTR(EVENT_HANDLER** obj ) ;
<<toc >>

RB_DELETE_EventHandlerElement #include "Component.H"
void RB_DELETE_EventHandlerElement(EventHandlerElement* obj ) ;
<<toc >>

RB_DELETE_EventHandlerElement_PTR #include "Component.H"
void RB_DELETE_EventHandlerElement_PTR(EventHandlerElement** obj ) ;
<<toc >>

RB_DELETE_FloatSemaphore #include "Semaphore.H"
void RB_DELETE_FloatSemaphore(FloatSemaphore* obj ) ;
<<toc >>

RB_DELETE_FloatSemaphore_PTR #include "Semaphore.H"
void RB_DELETE_FloatSemaphore_PTR(FloatSemaphore** obj ) ;
<<toc >>

RB_DELETE_FloatWaitingItem #include "Semaphore.H"
void RB_DELETE_FloatWaitingItem(FloatWaitingItem* obj ) ;
<<toc >>

RB_DELETE_FloatWaitingItem_PTR #include "Semaphore.H"
void RB_DELETE_FloatWaitingItem_PTR(FloatWaitingItem** obj ) ;
<<toc >>

RB_DELETE_HELPER #include "RB_DefineClass.H"
void RB_DELETE_HELPER(void* obj , void (* delete_with_correct_typea ) ( void* ) ) ;
<<toc >>

RB_DELETE_IntegerSemaphore #include "Semaphore.H"
void RB_DELETE_IntegerSemaphore(IntegerSemaphore* obj ) ;
<<toc >>

RB_DELETE_IntegerSemaphore_PTR #include "Semaphore.H"
void RB_DELETE_IntegerSemaphore_PTR(IntegerSemaphore** obj ) ;
<<toc >>

RB_DELETE_IntegerWaitingItem #include "Semaphore.H"
void RB_DELETE_IntegerWaitingItem(IntegerWaitingItem* obj ) ;
<<toc >>

RB_DELETE_IntegerWaitingItem_PTR #include "Semaphore.H"
void RB_DELETE_IntegerWaitingItem_PTR(IntegerWaitingItem** obj ) ;
<<toc >>

RB_DELETE_LogicalSemaphore #include "Semaphore.H"
void RB_DELETE_LogicalSemaphore(LogicalSemaphore* obj ) ;
<<toc >>

RB_DELETE_LogicalSemaphore_PTR #include "Semaphore.H"
void RB_DELETE_LogicalSemaphore_PTR(LogicalSemaphore** obj ) ;
<<toc >>

RB_DELETE_RB_BINARY_TREE #include "RB_BinaryTree.H"
void RB_DELETE_RB_BINARY_TREE(RB_BINARY_TREE* obj ) ;
<<toc >>

RB_DELETE_RB_BINARY_TREE_PTR #include "RB_BinaryTree.H"
void RB_DELETE_RB_BINARY_TREE_PTR(RB_BINARY_TREE** obj ) ;
<<toc >>

RB_DELETE_RB_double #include "state_variable.H"
void RB_DELETE_RB_double(RB_double* obj ) ;
<<toc >>

RB_DELETE_RB_double_PTR #include "state_variable.H"
void RB_DELETE_RB_double_PTR(RB_double** obj ) ;
<<toc >>

RB_DELETE_RB_float #include "state_variable.H"
void RB_DELETE_RB_float(RB_float* obj ) ;
<<toc >>

RB_DELETE_RB_float_PTR #include "state_variable.H"
void RB_DELETE_RB_float_PTR(RB_float** obj ) ;
<<toc >>

RB_DELETE_RB_int #include "state_variable.H"
void RB_DELETE_RB_int(RB_int* obj ) ;
<<toc >>

RB_DELETE_RB_int_PTR #include "state_variable.H"
void RB_DELETE_RB_int_PTR(RB_int** obj ) ;
<<toc >>

RB_DELETE_RB_pointer #include "state_variable.H"
void RB_DELETE_RB_pointer(RB_pointer* obj ) ;
<<toc >>

RB_DELETE_RB_pointer_PTR #include "state_variable.H"
void RB_DELETE_RB_pointer_PTR(RB_pointer** obj ) ;
<<toc >>

RB_DELETE_RB_string #include "state_variable.H"
void RB_DELETE_RB_string(RB_string* obj ) ;
<<toc >>

RB_DELETE_RB_string_PTR #include "state_variable.H"
void RB_DELETE_RB_string_PTR(RB_string** obj ) ;
<<toc >>

RB_DELETE_SemaphoreWaitingItem #include "Semaphore.H"
void RB_DELETE_SemaphoreWaitingItem(SemaphoreWaitingItem* obj ) ;
<<toc >>

RB_DELETE_SemaphoreWaitingItem_PTR #include "Semaphore.H"
void RB_DELETE_SemaphoreWaitingItem_PTR(SemaphoreWaitingItem** obj ) ;
<<toc >>

RB_DELETE_SharedSemaphore #include "Semaphore.H"
void RB_DELETE_SharedSemaphore(SharedSemaphore* obj ) ;
<<toc >>

RB_DELETE_SharedSemaphoreWaitingItem #include "Semaphore.H"
void RB_DELETE_SharedSemaphoreWaitingItem(SharedSemaphoreWaitingItem* obj ) ;
<<toc >>

RB_DELETE_SharedSemaphoreWaitingItem_PTR #include "Semaphore.H"
void RB_DELETE_SharedSemaphoreWaitingItem_PTR(SharedSemaphoreWaitingItem** obj ) ;
<<toc >>

RB_DELETE_SharedSemaphore_PTR #include "Semaphore.H"
void RB_DELETE_SharedSemaphore_PTR(SharedSemaphore** obj ) ;
<<toc >>

RB_DELETE_Stack #include "processTypes.H"
void RB_DELETE_Stack(Stack* obj ) ;
<<toc >>

RB_DELETE_Stack_PTR #include "processTypes.H"
void RB_DELETE_Stack_PTR(Stack** obj ) ;
<<toc >>

RB_DELETE_char #include "def_rbq.H"
void RB_DELETE_char(char* obj ) ;
<<toc >>

RB_DELETE_char_PTR #include "def_rbq.H"
void RB_DELETE_char_PTR(char** obj ) ;
<<toc >>

RB_DELETE_double #include "def_rbq.H"
void RB_DELETE_double(double* obj ) ;
<<toc >>

RB_DELETE_double_PTR #include "def_rbq.H"
void RB_DELETE_double_PTR(double** obj ) ;
<<toc >>

RB_DELETE_float #include "def_rbq.H"
void RB_DELETE_float(float* obj ) ;
<<toc >>

RB_DELETE_float_PTR #include "def_rbq.H"
void RB_DELETE_float_PTR(float** obj ) ;
<<toc >>

RB_DELETE_int #include "def_rbq.H"
void RB_DELETE_int(int* obj ) ;
<<toc >>

RB_DELETE_int_PTR #include "def_rbq.H"
void RB_DELETE_int_PTR(int** obj ) ;
<<toc >>

RB_FREE_DELETE #include "def_rbq.H"
void RB_FREE_DELETE(C_FREE_LIST* f , void* obj ) ;
<<toc >>

RB_FREE_DELETE #include "def_rbq.H"
void RB_FREE_DELETE(void* obj ) ;
Inline: RB_FREE_DELETE Summary: Rollbackably puts a freelist object into a freelist of currently unused objects Description: Takes one argument representing a free list object casted to (*void) and stores that object onto the free list of currently unused objects of its type (using the default C_RBQ free list manager). Optionally takes two arguments, the first being a pointer to the free list object manager to use (C_FREE_LIST*) and the second being the free list object to store casted to (*void). Return: None.
<<toc >>

RB_FREE_GENERATE #include "def_rbq.H"
C_ITEM* RB_FREE_GENERATE(char* buff ) ;
<<toc >>

RB_FREE_GENERATE #include "def_rbq.H"
C_ITEM* RB_FREE_GENERATE(C_FREE_LIST* f , char* buff ) ;
Inline: RB_FREE_GENERATE Summary: Rollbackably generates an object from a buffer Description: Takes one argument representing a pointer to a character buffer (char*) that represents the memory buffer for an object that inherited from C_ITEM, and memcopies the buffer over the proper free list object type (using the default C_RBQ free list manager) and returns it. The buffer is normally from an event message. C_ITEMs inherit from C_DUMMY_V, which is a dummy class that puts the V table at the top of C_ITEM objects. This way, objects that have virtual functions can still be constructed with this function. Optionally takes two arguments, the first being a pointer to the C_FREE_LIST free list object manager to use and the second being the pointer to the character buffer. Return: Pointer to an object of unknown type casted to (C_ITEM *).
<<toc >>

RB_FREE_NEW #include "def_rbq.H"
void* RB_FREE_NEW(C_FREE_LIST* f , int i ) ;
<<toc >>

RB_FREE_NEW #include "def_rbq.H"
void* RB_FREE_NEW(int i ) ;
Inline: RB_FREE_NEW Summary: Rollbackably creates a new or returns a currently unused freelist object Description: Takes one argument representing free list object type ID (int) and generates a new free list object (using the default C_RBQ free list manager) of the specified type. Optionally takes two arguments, the first being a pointer to the free list object manager to use (C_FREE_LIST*) and the second being a free list object type ID for the object type to create. Return: Pointer to a free list object.
<<toc >>

RB_INSERT #include "def_rbq.H"
void RB_INSERT(C_XHASH* xh , C_SQ_ITEM* sqit ) ;
<<toc >>

RB_INSERT #include "def_rbq.H"
void RB_INSERT(C_XPRIORITY* xh , C_SQ_ITEM* sqit ) ;
<<toc >>

RB_INSERT #include "def_rbq.H"
void RB_INSERT(C_XQUEUE* xh , C_SQ_ITEM* sqit ) ;
Inline: RB_INSERT Summary: Rollbackably inserts a C_SQ_ITEM into either a C_XQUEUE, a C_XHASH, or a C_XPRIORITY Description: Takes two arguments representing 1. The rollbackable queue or hash (C_XQUEUE*, C_XHASH*, or C_XPRIORITY*) into which to insert the item, 2. The item (C_SQ_ITEM*) to insert. For C_XQUEUEs, items are pushed onto the bottom of the queue. Return: None.
<<toc >>

RB_MEMCPY #include "def_rbq.H"
void RB_MEMCPY(char* p1 , char* p2 , int size ) ;
Inline: RB_MEMCPY or RB_memcpy
Summary: Rollbackably copies memory
Description: Takes three arguments representing 1. pointer to a character
             buffer (char*) to which to copy, 2. pointer to a character
             buffer (char*) from which to copy, 3. the size of the buffer
             (int or size_t) from which to copy, in bytes.
Return: None
<<toc >>

RB_NEW_ARRAY_EVENT_HANDLER #include "EventHandler.H"
EVENT_HANDLER* RB_NEW_ARRAY_EVENT_HANDLER(size_t num_EVENT_HANDLER ) ;
<<toc >>

RB_NEW_ARRAY_EVENT_HANDLER_HOLDER #include "EventHandlerHolder.H"
EVENT_HANDLER_HOLDER* RB_NEW_ARRAY_EVENT_HANDLER_HOLDER(size_t num_EVENT_HANDLER_HOLDER ) ;
<<toc >>

RB_NEW_ARRAY_EVENT_HANDLER_HOLDER_PTR #include "EventHandlerHolder.H"
EVENT_HANDLER_HOLDER** RB_NEW_ARRAY_EVENT_HANDLER_HOLDER_PTR(size_t num_EVENT_HANDLER_HOLDER ) ;
<<toc >>

RB_NEW_ARRAY_EVENT_HANDLER_PTR #include "EventHandler.H"
EVENT_HANDLER** RB_NEW_ARRAY_EVENT_HANDLER_PTR(size_t num_EVENT_HANDLER ) ;
<<toc >>

RB_NEW_ARRAY_FloatSemaphore #include "Semaphore.H"
FloatSemaphore* RB_NEW_ARRAY_FloatSemaphore(size_t num_FloatSemaphore ) ;
<<toc >>

RB_NEW_ARRAY_FloatSemaphore_PTR #include "Semaphore.H"
FloatSemaphore** RB_NEW_ARRAY_FloatSemaphore_PTR(size_t num_FloatSemaphore ) ;
<<toc >>

RB_NEW_ARRAY_IntegerSemaphore #include "Semaphore.H"
IntegerSemaphore* RB_NEW_ARRAY_IntegerSemaphore(size_t num_IntegerSemaphore ) ;
<<toc >>

RB_NEW_ARRAY_IntegerSemaphore_PTR #include "Semaphore.H"
IntegerSemaphore** RB_NEW_ARRAY_IntegerSemaphore_PTR(size_t num_IntegerSemaphore ) ;
<<toc >>

RB_NEW_ARRAY_LogicalSemaphore #include "Semaphore.H"
LogicalSemaphore* RB_NEW_ARRAY_LogicalSemaphore(size_t num_LogicalSemaphore ) ;
<<toc >>

RB_NEW_ARRAY_LogicalSemaphore_PTR #include "Semaphore.H"
LogicalSemaphore** RB_NEW_ARRAY_LogicalSemaphore_PTR(size_t num_LogicalSemaphore ) ;
<<toc >>

RB_NEW_ARRAY_RB_BINARY_TREE #include "RB_BinaryTree.H"
RB_BINARY_TREE* RB_NEW_ARRAY_RB_BINARY_TREE(size_t num_RB_BINARY_TREE ) ;
<<toc >>

RB_NEW_ARRAY_RB_BINARY_TREE_PTR #include "RB_BinaryTree.H"
RB_BINARY_TREE** RB_NEW_ARRAY_RB_BINARY_TREE_PTR(size_t num_RB_BINARY_TREE ) ;
<<toc >>

RB_NEW_ARRAY_RB_double #include "state_variable.H"
RB_double* RB_NEW_ARRAY_RB_double(size_t num_RB_double ) ;
<<toc >>

RB_NEW_ARRAY_RB_double_PTR #include "state_variable.H"
RB_double** RB_NEW_ARRAY_RB_double_PTR(size_t num_RB_double ) ;
<<toc >>

RB_NEW_ARRAY_RB_float #include "state_variable.H"
RB_float* RB_NEW_ARRAY_RB_float(size_t num_RB_float ) ;
<<toc >>

RB_NEW_ARRAY_RB_float_PTR #include "state_variable.H"
RB_float** RB_NEW_ARRAY_RB_float_PTR(size_t num_RB_float ) ;
<<toc >>

RB_NEW_ARRAY_RB_int #include "state_variable.H"
RB_int* RB_NEW_ARRAY_RB_int(size_t num_RB_int ) ;
<<toc >>

RB_NEW_ARRAY_RB_int_PTR #include "state_variable.H"
RB_int** RB_NEW_ARRAY_RB_int_PTR(size_t num_RB_int ) ;
<<toc >>

RB_NEW_ARRAY_RB_pointer #include "state_variable.H"
RB_pointer* RB_NEW_ARRAY_RB_pointer(size_t num_RB_pointer ) ;
<<toc >>

RB_NEW_ARRAY_RB_pointer_PTR #include "state_variable.H"
RB_pointer** RB_NEW_ARRAY_RB_pointer_PTR(size_t num_RB_pointer ) ;
<<toc >>

RB_NEW_ARRAY_RB_string #include "state_variable.H"
RB_string* RB_NEW_ARRAY_RB_string(size_t num_RB_string ) ;
<<toc >>

RB_NEW_ARRAY_RB_string_PTR #include "state_variable.H"
RB_string** RB_NEW_ARRAY_RB_string_PTR(size_t num_RB_string ) ;
<<toc >>

RB_NEW_ARRAY_Stack #include "processTypes.H"
Stack* RB_NEW_ARRAY_Stack(size_t num_Stack ) ;
<<toc >>

RB_NEW_ARRAY_Stack_PTR #include "processTypes.H"
Stack** RB_NEW_ARRAY_Stack_PTR(size_t num_Stack ) ;
<<toc >>

RB_NEW_ARRAY_char #include "def_rbq.H"
char* RB_NEW_ARRAY_char(size_t num_char ) ;
<<toc >>

RB_NEW_ARRAY_char_PTR #include "def_rbq.H"
char** RB_NEW_ARRAY_char_PTR(size_t num_char ) ;
<<toc >>

RB_NEW_ARRAY_double #include "def_rbq.H"
double* RB_NEW_ARRAY_double(size_t num_double ) ;
<<toc >>

RB_NEW_ARRAY_double_PTR #include "def_rbq.H"
double** RB_NEW_ARRAY_double_PTR(size_t num_double ) ;
<<toc >>

RB_NEW_ARRAY_float #include "def_rbq.H"
float* RB_NEW_ARRAY_float(size_t num_float ) ;
<<toc >>

RB_NEW_ARRAY_float_PTR #include "def_rbq.H"
float** RB_NEW_ARRAY_float_PTR(size_t num_float ) ;
<<toc >>

RB_NEW_ARRAY_int #include "def_rbq.H"
int* RB_NEW_ARRAY_int(size_t num_int ) ;
<<toc >>

RB_NEW_ARRAY_int_PTR #include "def_rbq.H"
int** RB_NEW_ARRAY_int_PTR(size_t num_int ) ;
<<toc >>

RB_NEW_CANCEL_HANDLE #include "def_rbq.H"
C_CANCEL_HANDLE* RB_NEW_CANCEL_HANDLE() ;
Inline: RB_NEW_CANCEL_HANDLE 
Summary: Rollbackably creates a new or returns a currently unused freelist
         cancel handle (C_CANCEL_HANDLE, which is typedef-equivalent to a
         C_ANTIMESS)
Description: Takes no arguments
Return: Pointer to a free list C_CANCEL_HANDLE (or, typedef-equivalently, a
        C_ANTIMESS)
<<toc >>

RB_NEW_EVENT_HANDLER #include "EventHandler.H"
EVENT_HANDLER* RB_NEW_EVENT_HANDLER() ;
<<toc >>

RB_NEW_EVENT_HANDLER #include "EventHandler.H"
EVENT_HANDLER* RB_NEW_EVENT_HANDLER(EVENT_HANDLER* obj ) ;
<<toc >>

RB_NEW_EVENT_HANDLER_HOLDER #include "EventHandlerHolder.H"
EVENT_HANDLER_HOLDER* RB_NEW_EVENT_HANDLER_HOLDER() ;
<<toc >>

RB_NEW_EVENT_HANDLER_HOLDER #include "EventHandlerHolder.H"
EVENT_HANDLER_HOLDER* RB_NEW_EVENT_HANDLER_HOLDER(EVENT_HANDLER_HOLDER* obj ) ;
<<toc >>

RB_NEW_EVENT_HANDLER_HOLDER_PTR #include "EventHandlerHolder.H"
EVENT_HANDLER_HOLDER** RB_NEW_EVENT_HANDLER_HOLDER_PTR() ;
<<toc >>

RB_NEW_EVENT_HANDLER_METHOD #include "EventHandlerMethod.H"
EVENT_HANDLER_METHOD* RB_NEW_EVENT_HANDLER_METHOD(EVENT_HANDLER_METHOD* obj ) ;
<<toc >>

RB_NEW_EVENT_HANDLER_METHOD_PTR #include "EventHandlerMethod.H"
EVENT_HANDLER_METHOD** RB_NEW_EVENT_HANDLER_METHOD_PTR() ;
<<toc >>

RB_NEW_EVENT_HANDLER_PTR #include "EventHandler.H"
EVENT_HANDLER** RB_NEW_EVENT_HANDLER_PTR() ;
<<toc >>

RB_NEW_EventHandlerElement #include "Component.H"
EventHandlerElement* RB_NEW_EventHandlerElement(EventHandlerElement* obj ) ;
<<toc >>

RB_NEW_EventHandlerElement_PTR #include "Component.H"
EventHandlerElement** RB_NEW_EventHandlerElement_PTR() ;
<<toc >>

RB_NEW_FloatSemaphore #include "Semaphore.H"
FloatSemaphore* RB_NEW_FloatSemaphore() ;
<<toc >>

RB_NEW_FloatSemaphore #include "Semaphore.H"
FloatSemaphore* RB_NEW_FloatSemaphore(FloatSemaphore* obj ) ;
<<toc >>

RB_NEW_FloatSemaphore_PTR #include "Semaphore.H"
FloatSemaphore** RB_NEW_FloatSemaphore_PTR() ;
<<toc >>

RB_NEW_FloatWaitingItem #include "Semaphore.H"
FloatWaitingItem* RB_NEW_FloatWaitingItem(FloatWaitingItem* obj ) ;
<<toc >>

RB_NEW_FloatWaitingItem_PTR #include "Semaphore.H"
FloatWaitingItem** RB_NEW_FloatWaitingItem_PTR() ;
<<toc >>

RB_NEW_HELPER #include "RB_DefineClass.H"
void RB_NEW_HELPER(void* obj , void (* delete_with_correct_typea ) ( void* ) ) ;
Do not write any additional calls to these functions:
<<toc >>

RB_NEW_IntegerSemaphore #include "Semaphore.H"
IntegerSemaphore* RB_NEW_IntegerSemaphore() ;
<<toc >>

RB_NEW_IntegerSemaphore #include "Semaphore.H"
IntegerSemaphore* RB_NEW_IntegerSemaphore(IntegerSemaphore* obj ) ;
<<toc >>

RB_NEW_IntegerSemaphore_PTR #include "Semaphore.H"
IntegerSemaphore** RB_NEW_IntegerSemaphore_PTR() ;
<<toc >>

RB_NEW_IntegerWaitingItem #include "Semaphore.H"
IntegerWaitingItem* RB_NEW_IntegerWaitingItem(IntegerWaitingItem* obj ) ;
<<toc >>

RB_NEW_IntegerWaitingItem_PTR #include "Semaphore.H"
IntegerWaitingItem** RB_NEW_IntegerWaitingItem_PTR() ;
<<toc >>

RB_NEW_LogicalSemaphore #include "Semaphore.H"
LogicalSemaphore* RB_NEW_LogicalSemaphore() ;
<<toc >>

RB_NEW_LogicalSemaphore #include "Semaphore.H"
LogicalSemaphore* RB_NEW_LogicalSemaphore(LogicalSemaphore* obj ) ;
<<toc >>

RB_NEW_LogicalSemaphore_PTR #include "Semaphore.H"
LogicalSemaphore** RB_NEW_LogicalSemaphore_PTR() ;
<<toc >>

RB_NEW_RB_BINARY_TREE #include "RB_BinaryTree.H"
RB_BINARY_TREE* RB_NEW_RB_BINARY_TREE() ;
<<toc >>

RB_NEW_RB_BINARY_TREE #include "RB_BinaryTree.H"
RB_BINARY_TREE* RB_NEW_RB_BINARY_TREE(RB_BINARY_TREE* obj ) ;
<<toc >>

RB_NEW_RB_BINARY_TREE_PTR #include "RB_BinaryTree.H"
RB_BINARY_TREE** RB_NEW_RB_BINARY_TREE_PTR() ;
<<toc >>

RB_NEW_RB_double #include "state_variable.H"
RB_double* RB_NEW_RB_double() ;
<<toc >>

RB_NEW_RB_double #include "state_variable.H"
RB_double* RB_NEW_RB_double(RB_double* obj ) ;
<<toc >>

RB_NEW_RB_double_PTR #include "state_variable.H"
RB_double** RB_NEW_RB_double_PTR() ;
<<toc >>

RB_NEW_RB_float #include "state_variable.H"
RB_float* RB_NEW_RB_float() ;
<<toc >>

RB_NEW_RB_float #include "state_variable.H"
RB_float* RB_NEW_RB_float(RB_float* obj ) ;
<<toc >>

RB_NEW_RB_float_PTR #include "state_variable.H"
RB_float** RB_NEW_RB_float_PTR() ;
<<toc >>

RB_NEW_RB_int #include "state_variable.H"
RB_int* RB_NEW_RB_int() ;
<<toc >>

RB_NEW_RB_int #include "state_variable.H"
RB_int* RB_NEW_RB_int(RB_int* obj ) ;
<<toc >>

RB_NEW_RB_int_PTR #include "state_variable.H"
RB_int** RB_NEW_RB_int_PTR() ;
<<toc >>

RB_NEW_RB_pointer #include "state_variable.H"
RB_pointer* RB_NEW_RB_pointer() ;
<<toc >>

RB_NEW_RB_pointer #include "state_variable.H"
RB_pointer* RB_NEW_RB_pointer(RB_pointer* obj ) ;
<<toc >>

RB_NEW_RB_pointer_PTR #include "state_variable.H"
RB_pointer** RB_NEW_RB_pointer_PTR() ;
<<toc >>

RB_NEW_RB_string #include "state_variable.H"
RB_string* RB_NEW_RB_string() ;
<<toc >>

RB_NEW_RB_string #include "state_variable.H"
RB_string* RB_NEW_RB_string(RB_string* obj ) ;
<<toc >>

RB_NEW_RB_string_PTR #include "state_variable.H"
RB_string** RB_NEW_RB_string_PTR() ;
<<toc >>

RB_NEW_SemaphoreWaitingItem #include "Semaphore.H"
SemaphoreWaitingItem* RB_NEW_SemaphoreWaitingItem(SemaphoreWaitingItem* obj ) ;
<<toc >>

RB_NEW_SemaphoreWaitingItem_PTR #include "Semaphore.H"
SemaphoreWaitingItem** RB_NEW_SemaphoreWaitingItem_PTR() ;
<<toc >>

RB_NEW_SharedSemaphore #include "Semaphore.H"
SharedSemaphore* RB_NEW_SharedSemaphore(SharedSemaphore* obj ) ;
<<toc >>

RB_NEW_SharedSemaphoreWaitingItem #include "Semaphore.H"
SharedSemaphoreWaitingItem* RB_NEW_SharedSemaphoreWaitingItem(SharedSemaphoreWaitingItem* obj ) ;
<<toc >>

RB_NEW_SharedSemaphoreWaitingItem_PTR #include "Semaphore.H"
SharedSemaphoreWaitingItem** RB_NEW_SharedSemaphoreWaitingItem_PTR() ;
<<toc >>

RB_NEW_SharedSemaphore_PTR #include "Semaphore.H"
SharedSemaphore** RB_NEW_SharedSemaphore_PTR() ;
<<toc >>

RB_NEW_Stack #include "processTypes.H"
Stack* RB_NEW_Stack() ;
<<toc >>

RB_NEW_Stack #include "processTypes.H"
Stack* RB_NEW_Stack(Stack* obj ) ;
<<toc >>

RB_NEW_Stack_PTR #include "processTypes.H"
Stack** RB_NEW_Stack_PTR() ;
<<toc >>

RB_NEW_char #include "def_rbq.H"
char* RB_NEW_char() ;
<<toc >>

RB_NEW_char #include "def_rbq.H"
char* RB_NEW_char(char* obj ) ;
<<toc >>

RB_NEW_char_PTR #include "def_rbq.H"
char** RB_NEW_char_PTR() ;
<<toc >>

RB_NEW_double #include "def_rbq.H"
double* RB_NEW_double() ;
<<toc >>

RB_NEW_double #include "def_rbq.H"
double* RB_NEW_double(double* obj ) ;
<<toc >>

RB_NEW_double_PTR #include "def_rbq.H"
double** RB_NEW_double_PTR() ;
<<toc >>

RB_NEW_float #include "def_rbq.H"
float* RB_NEW_float() ;
<<toc >>

RB_NEW_float #include "def_rbq.H"
float* RB_NEW_float(float* obj ) ;
<<toc >>

RB_NEW_float_PTR #include "def_rbq.H"
float** RB_NEW_float_PTR() ;
<<toc >>

RB_NEW_int #include "def_rbq.H"
int* RB_NEW_int() ;
<<toc >>

RB_NEW_int #include "def_rbq.H"
int* RB_NEW_int(int* obj ) ;
<<toc >>

RB_NEW_int_PTR #include "def_rbq.H"
int** RB_NEW_int_PTR() ;
<<toc >>

RB_POP #include "def_rbq.H"
C_SQ_ITEM* RB_POP(C_XQUEUE* xq ) ;
Inline: RB_POP (same as RB_POP_TOP and RB_REMOVE (C_XQUEUE *xq) Summary: Rollbackably pops (removes) a C_SQ_ITEM from the top of the specified C_XQUEUE Description: Takes one argument representing the queue (C_XQUEUE*) from the top of which to remove a C_SQ_ITEM Return: Pointer to the removed item (C_SQ_ITEM*).
<<toc >>

RB_POP_BOT #include "def_rbq.H"
C_SQ_ITEM* RB_POP_BOT(C_XQUEUE* xq ) ;
Inline: RB_POP_BOT
Summary: Rollbackably pops (removes) a C_SQ_ITEM from the bottom of the
         specified C_XQUEUE
Description: Takes one argument representing the queue (C_XQUEUE*) from the
             bottom of which to remove a C_SQ_ITEM
Return: Pointer to the removed item (C_SQ_ITEM*)
<<toc >>

RB_POP_TOP #include "def_rbq.H"
C_SQ_ITEM* RB_POP_TOP(C_XQUEUE* xq ) ;
Inline: RB_POP_TOP (same as RB_POP and RB_REMOVE (C_XQUEUE *xq) Summary: Rollbackably pops (removes) a C_SQ_ITEM from the top of the specified C_XQUEUE Description: Takes one argument representing the queue (C_XQUEUE*) from the top of which to remove a C_SQ_ITEM Return: Pointer to the removed item (C_SQ_ITEM*).
<<toc >>

RB_PRINT #include "def_rbq.H"
void RB_PRINT(FILE* fp , char* s ) ;
Inline: RB_PRINT Summary: Rollbackably prints a string to stdout, strerr, or a file Description: Takes two arguments representing 1. FILE pointer (FILE*) to which to print (can be stdout or strerr) and 2. Pointer to the character buffer (char*) to print. This macro withholds actually printing the buffer until the event that calls this macro is committed. Thus the buffer is guaranteed to be printed exactly once, even when rolled back. Return: None.
<<toc >>

RB_PUSH #include "def_rbq.H"
void RB_PUSH(C_XQUEUE* xq , C_SQ_ITEM* sqit ) ;
Inline: RB_PUSH (same as RB_PUSH_BOT and RB_INSERT (C_XQUEUE *xq,
       C_SQ_ITEM *sqit))
Summary: Rollbackably pushes (inserts) a C_SQ_ITEM onto the bottom of an
         C_XQUEUE
Description: Takes two arguments representing 1. (C_XQUEUE*) onto which to
             insert the item, 2. the item (C_SQ_ITEM*) to insert.
Return: None
<<toc >>

RB_PUSH_BOT #include "def_rbq.H"
void RB_PUSH_BOT(C_XQUEUE* xq , C_SQ_ITEM* sqit ) ;
Inline: RB_PUSH_BOT (same as RB_PUSH and RB_INSERT (C_XQUEUE *xq, C_SQ_ITEM
        sqit))
Summary: Rollbackably pushes (inserts) a C_SQ_ITEM onto the bottom of a
         C_XQUEUE
Description: Takes two arguments representing 1. (C_XQUEUE*) onto which to
             insert the item, 2. the item (C_SQ_ITEM*) to insert.
Return: None
<<toc >>

RB_PUSH_TOP #include "def_rbq.H"
void RB_PUSH_TOP(C_XQUEUE* xq , C_SQ_ITEM* sqit ) ;
Inline: RB_PUSH_TOP 
Summary: Rollbackably pushes (inserts) a C_SQ_ITEM onto the top of an
         C_XQUEUE
Description: Takes two arguments representing 1. (C_XQUEUE*) onto which to
             insert the item, 2. the item (C_SQ_ITEM*) to insert.
Return: None
<<toc >>

RB_REMOVE #include "def_rbq.H"
C_SQ_ITEM* RB_REMOVE(C_XPRIORITY* xp ) ;
<<toc >>

RB_REMOVE #include "def_rbq.H"
C_SQ_ITEM* RB_REMOVE(C_XQUEUE* xq ) ;
<<toc >>

RB_REMOVE #include "def_rbq.H"
void RB_REMOVE(C_XHASH* xh , char* name ) ;
<<toc >>

RB_REMOVE #include "def_rbq.H"
C_SQ_ITEM* RB_REMOVE(C_XHASH* xh , int i ) ;
<<toc >>

RB_REMOVE #include "def_rbq.H"
C_SQ_ITEM* RB_REMOVE(C_XQUEUE* xq , int i ) ;
Inline: RB_REMOVE Summary: Rollbackably removes and returns a C_SQ_ITEM from either a C_XQUEUE, a C_XHASH, or a C_XPRIORITY Description: Takes one (for C_XQUEUEs and C_XPRIORITYs only) or two (for C_XQUEUEs and C_XHASHs only) arguments. When using one argument (C_XQUEUE* or C_XPRIORITY*), this method pops a C_SQ_ITEM off of the top of the C_XQUEUE or C_XPRIORITY and returns it. When using two arguments, the first argument represents the container (C_XQUEUE* or C_XHASH*) and the second argument represents the ID (int) of the item to remove and return. Return: Pointer to the removed item (C_SQ_ITEM*).
<<toc >>

RB_STRDUP #include "def_rbq.H"
char* RB_STRDUP(char* s ) ;
Inline: RB_STRDUP or RB_strdup Summary: Rollbackable version of strdup, with new instead of malloc Description: Takes one argument, a string to be duplicated in newly allocated memory. You may deallocate it with delete [] or RB_DELETE_ARRAY_char. Even though free can be passed the return value of strdup, DO NOT pass the return value of RB_STRDUP to free. Return: Pointer to new string.
<<toc >>

RB_XMEM #include "def_rbq.H"
void RB_XMEM(char* p1 , char* p2 , int size ) ;
Inline: RB_XMEM 
Summary: Rollbackably exchanges two character buffers
Description: Takes three arguments representing 1. pointer to the first
             character buffer (char*), 2. pointer to the second character
             buffer (char*), 3. the number of bytes to exchange between these
             two buffers (int or size_t)
Return: None
<<toc >>

RB_memcpy #include "def_rbq.H"
void RB_memcpy(char* p1 , char* p2 , int size ) ;
<<toc >>

RB_strdup #include "def_rbq.H"
char* RB_strdup(char* s ) ;
<<toc >>

ReScheduleEvent #include "ScheduleEvent.H"
C_CANCEL_HANDLE ReScheduleEvent(const SIMTIME& time , const C_HEADER& header , const char* data = ( ( void* ) 0 ) , int dataBytes = 0 ) ;
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.
time
IN: Logical time.
header
IN: Optional message for scheduling the event.
data
IN: Variable length data that gets passed with the event (optional).
dataBytes
IN: Number of bytes for variable length data.
<<toc >>

ReScheduleEvent #include "ScheduleEvent.H"
C_CANCEL_HANDLE ReScheduleEvent(const SIMTIME& time , const C_HEADER* header = ( ( void* ) 0 ) , const char* data = ( ( void* ) 0 ) , int dataBytes = 0 ) ;
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.
time
IN: Logical time.
header
IN: Optional message for scheduling the event.
data
IN: Variable length data that gets passed with the event (optional).
dataBytes
IN: Number of bytes for variable length data.
<<toc >>

ReScheduleEventHandler #include "ScheduleEvent.H"
C_CANCEL_HANDLE ReScheduleEventHandler(const SIMTIME& time , const char* data = ( ( void* ) 0 ) , int dataBytes = 0 ) ;
Overloaded Function: ReScheduleEventHandler Summary: Re-schedules the same event handler to be processed for the same simobj at a future time. 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. 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.
time
IN: Simulated time.
data
IN: Variable length data that is passed to the event handler(s).
dataBytes
IN: Number of bytes in the data.
<<toc >>

ReScheduleProcess #include "ScheduleEvent.H"
C_CANCEL_HANDLE ReScheduleProcess(const SIMTIME& time , ReentryMsg* message = ( ( void* ) 0 ) , const char* data = ( ( void* ) 0 ) , int dataBytes = 0 ) ;
Function: ReScheduleProcess
Summary: Re-schedules the same process to be started for the same simobj at
         a future time.
Description: This function can be called from anywhere within SPEEDES to
             reschedule the same proces for the same simobj for starting
             at a later time.
Return: A cancel handle for the process which can be later used to retract
        the process before it is started. Applications are not required to
        use this returned value.
time
IN: Logical time.
message
IN: Optional message for scheduling the process.
data
IN: Variable length data that gets passed with the process (optional).
dataBytes
IN: Number of bytes for variable length data.
<<toc >>

ScheduleEvent #include "ScheduleEvent.H"
C_CANCEL_HANDLE ScheduleEvent(const SIMTIME& time , int eventType , const SpObjectHandle& simobj , const C_HEADER& header , const char* data = ( ( void* ) 0 ) , int dataBytes = 0 ) ;
time
IN: Logical time.
eventType
IN: Event type Id.
simobj
IN: Simulation object handle.
header
IN: Optional message for scheduling the event.
data
IN: Variable length data that gets passed with the event (optional).
dataBytes
IN: Number of bytes for variable length data.
<<toc >>

ScheduleEvent #include "ScheduleEvent.H"
C_CANCEL_HANDLE ScheduleEvent(const SIMTIME& time , int eventType , const SpObjectHandle& simobj , const C_HEADER* header = ( ( void* ) 0 ) , const char* data = ( ( void* ) 0 ) , int dataBytes = 0 ) ;
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. Here, users pass in an object handler reference. 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 in the descendent class of C_HEADER (note that descendents MUST NOT have multiple inheritance) 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. SPEEDES will not delete header or data. 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.
time
IN: Logical time.
eventType
IN: Event type Id.
simobj
IN: Simulation object handle.
header
IN: Optional message for scheduling the event.
data
IN: Variable length data that gets passed with the event (optional).
dataBytes
IN: Number of bytes for variable length data.
<<toc >>

ScheduleEvent #include "ScheduleEvent.H"
C_CANCEL_HANDLE ScheduleEvent(const SIMTIME& time , int eventType , int simobjType , int simobjLocalId , int simobjNode , const C_HEADER& header , const char* data = ( ( void* ) 0 ) , int dataBytes = 0 ) ;
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. Here, users pass in a reference to the message header. 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 in the descendent class of C_HEADER (note that descendents MUST NOT have multiple inheritance) 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. SPEEDES will not delete header or data. 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.
time
IN: Logical time.
eventType
IN: Event type Id.
simobjType
IN: Simulation object type.
simobjLocalId
IN: Simulation object local Id.
simobjNode
IN: Node that the simulation object is on.
header
IN: message for scheduling the event.
data
IN: Variable length data that gets passed with the event (optional).
dataBytes
IN: Number of bytes for variable length data.
<<toc >>

ScheduleEvent #include "ScheduleEvent.H"
C_CANCEL_HANDLE ScheduleEvent(const SIMTIME& time , int eventType , int simobjType , int simobjLocalId , int simobjNode , is on const C_HEADER* header = ( ( void* ) 0 ) , const char* data = ( ( void* ) 0 ) , int dataBytes = 0 ) ;
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 in the descendent class of C_HEADER (note that descendents MUST NOT have multiple inheritance) 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. SPEEDES will not delete header or data. 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.
time
IN: Logical time.
eventType
IN: Event type Id.
simobjType
IN: Simulation object type.
simobjLocalId
IN: Simulation object local Id.
simobjNode
IN: Node that the simulation object is on.
header
IN: Optional message for scheduling the event.
data
IN: Variable length data that gets passed with the event (optional).
dataBytes
IN: Number of bytes for variable length data.
<<toc >>

ScheduleEventHandler #include "ScheduleEvent.H"
C_CANCEL_HANDLE ScheduleEventHandler(const SIMTIME& time , const char* eventName , int simobjType , int simobjLocalId , int simobjNode , const char* data = ( ( void* ) 0 ) , int dataBytes = 0 ) ;
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.
time
IN: Simulated time.
eventName
IN: String name of the event handler.
simobjType
IN: Simulation object type.
simobjLocalId
IN: LOCAL_ID of the simulation object.
simobjNode
IN: NODE that the simulation object is on.
data
IN: Variable length data that is passed to the event handler(s).
dataBytes
IN: Number of bytes in the data.
<<toc >>

ScheduleProcess #include "ScheduleEvent.H"
C_CANCEL_HANDLE ScheduleProcess(const SIMTIME& time , int eventType , const SpObjectHandle& simobj , ReentryMsg* message = ( ( void* ) 0 ) , const char* data = ( ( void* ) 0 ) , int dataBytes = 0 ) ;
Function: ScheduleProcess Summary: Schedules a process to be started for a simobj at a specified time. Processes must never be scheduled in the past of the current event or process. Description: This function can be called from anywhere within SPEEDES to schedule a process. An proces must have a time tag, event type simulation object type, simulation object local Id, and node number to uniquely identify the process 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.
time
IN: Logical time.
eventType
IN: Event type Id.
simobj
IN: simobj Object Handle.
message
IN: Optional message for scheduling the event.
data
IN: Variable length data that gets passed with the event (optional).
dataBytes
IN: Number of bytes for variable length data.
<<toc >>

ScheduleProcess #include "ScheduleEvent.H"
C_CANCEL_HANDLE ScheduleProcess(const SIMTIME& time , int eventType , int simobjType , int simobjLocalId , int simobjNode , ReentryMsg* message = ( ( void* ) 0 ) , const char* data = ( ( void* ) 0 ) , int dataBytes = 0 ) ;
Function: ScheduleProcess Summary: Schedules a process to be started for a simobj at a specified time. Processes must never be scheduled in the past of the current event or process. Description: This function can be called from anywhere within SPEEDES to schedule a process. An proces must have a time tag, event type simulation object type, simulation object local Id, and node number to uniquely identify the process 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.
time
IN: Logical time.
eventType
IN: Event type Id.
simobjType
IN: Simulation object type.
simobjLocalId
IN: Simulation object local Id.
simobjNode
IN: Node that the simulation object is on.
message
IN: Optional message for scheduling the event.
data
IN: Variable length data that gets passed with the event (optional).
dataBytes
IN: Number of bytes for variable length data.
<<toc >>

SpComm_BarrierSync #include "SpeedesComm.H"
void SpComm_BarrierSync() ;
Barrier synchronizations. The BarrierSync function blocks until all of the nodes have made this call. The EnterFuzzyBarrier function works together with the ExitFuzzyBarrier function. Nodes call the non-blocking EnterFuzzyBarrier function and then continue their processing. The ExitFuzzyBarrier function is then polled to determine when all of the nodes have entered the fuzzy barrier.
<<toc >>

SpComm_CleanupOther #include "SpeedesComm.H"
void SpComm_CleanupOther() ;
Clean up things other than shared memory.
<<toc >>

SpComm_CleanupShm #include "SpeedesComm.H"
void SpComm_CleanupShm() ;
Clean up shared memory.
<<toc >>

SpComm_CoordinatedReceive #include "SpeedesComm.H"
char* SpComm_CoordinatedReceive(int& nbytes ) ;
<<toc >>

SpComm_CoordinatedSend #include "SpeedesComm.H"
void SpComm_CoordinatedSend(int nbytes , void* buff ) ;
<<toc >>

SpComm_CoordinatedSend #include "SpeedesComm.H"
void SpComm_CoordinatedSend(DESTINATION* dest , int nbytes , void* buff ) ;
<<toc >>

SpComm_CoordinatedSend #include "SpeedesComm.H"
void SpComm_CoordinatedSend(int destination , int nbytes , void* buff ) ;
Coordinated message sending. These routines are used differently by an application from the asynchronous services. It is assumed that each node has a number of messages that it wants to send to different nodes. Again, there are three ways for defining the destination (1) node-to-node, (2) node-to-multiple-nodes, and (3) node-to-every-other-node-but-self.

Each node first makes calls to the coordinated send routine for each message that it wants to send. After all of the outgoing messages have been passed to the coordinated send routines, the application is expected to make calls to the coordinated receive routine to receive messages from other nodes. The coordinated receive routine returns a NULL pointer when there are no further messages to be received by that node. The coordinated message passing services guarantee that all coordinated messages are received before the NULL pointer is returned. Note that this call may block if it has no messages to return and all messages have not yet been received.

It should be noted that it is a logic error to mix these calls with any of the reductions. That is, once one has sent a coordinated message, one should not make a call to any synchronization until the coordinated receive has returned NULL.

<<toc >>

SpComm_EnterFuzzyBarrier #include "SpeedesComm.H"
void SpComm_EnterFuzzyBarrier() ;
Returns when all nodes make this call.
<<toc >>

SpComm_ExitFuzzyBarrier #include "SpeedesComm.H"
int SpComm_ExitFuzzyBarrier() ;
Returns right away (non-blocking).
<<toc >>

SpComm_GetNodeId #include "SpeedesComm.H"
int SpComm_GetNodeId() ;
Returns the number of nodes.
<<toc >>

SpComm_GetNumNodes #include "SpeedesComm.H"
int SpComm_GetNumNodes() ;
Returns the number of nodes and the local node id.
<<toc >>

SpComm_GetPendingMessage #include "SpeedesComm.H"
char* SpComm_GetPendingMessage(int type , int& nbytes ) ;
<<toc >>

SpComm_GlobalMax #include "SpeedesComm.H"
SIMTIME& SpComm_GlobalMax(SIMTIME& SimTime ) ;
Max of everyone's value.
<<toc >>

SpComm_GlobalMax #include "SpeedesComm.H"
double SpComm_GlobalMax(double value ) ;
Max of everyone's value.
value
Max of everyone's value.
<<toc >>

SpComm_GlobalMax #include "SpeedesComm.H"
int SpComm_GlobalMax(int value ) ;
Min of everyone's SimTime.
value
Max of everyone's value.
<<toc >>

SpComm_GlobalMin #include "SpeedesComm.H"
SIMTIME& SpComm_GlobalMin(SIMTIME& SimTime ) ;
Min of everyone's value.
SimTime
Min of everyone's SimTime.
<<toc >>

SpComm_GlobalMin #include "SpeedesComm.H"
double SpComm_GlobalMin(double value ) ;
Min of everyone's value.
value
Min of everyone's value.
<<toc >>

SpComm_GlobalMin #include "SpeedesComm.H"
int SpComm_GlobalMin(int value ) ;
Sum of everyone's value.
value
Min of everyone's value.
<<toc >>

SpComm_GlobalSum #include "SpeedesComm.H"
double SpComm_GlobalSum(double value ) ;
Sum of everyone's value.
value
Sum of everyone's value.
<<toc >>

SpComm_GlobalSum #include "SpeedesComm.H"
int SpComm_GlobalSum(int value ) ;
Global Reductions combine values from each node. The operations include global sums, global minimums, and global maximums.The result is returned.
value
Sum of everyone's value.
<<toc >>

SpComm_Receive #include "SpeedesComm.H"
void SpComm_Receive() ;
<<toc >>

SpComm_Receive #include "SpeedesComm.H"
char* SpComm_Receive(int type , int& nbytes ) ;
<<toc >>

SpComm_Send #include "SpeedesComm.H"
void SpComm_Send(int type , int nbytes , void* buff ) ;
<<toc >>

SpComm_Send #include "SpeedesComm.H"
void SpComm_Send(DESTINATION* dest , int type , int nbytes , void* buff ) ;
<<toc >>

SpComm_Send #include "SpeedesComm.H"
void SpComm_Send(int destination , int type , int nbytes , void* buff ) ;
<<toc >>

SpComm_StartUp #include "SpeedesComm.H"
int SpComm_StartUp(int nNodes , int nLoc , int group , char* MiscInfo ) ;
<<toc >>

Start_Merc #include "speedes_comm.H"
void Start_Merc(int , int ) ;
<<toc >>

b_sync #include "speedes_comm.H"
void b_sync() ;
<<toc >>

combine #include "speedes_comm.H"
int combine(int* buf , int type , int size , int num ) ;
<<toc >>

comm_cleanup #include "speedes_comm.H"
void comm_cleanup() ;
<<toc >>

delete_C_HOLDER #include "defunc.H"
void delete_C_HOLDER(C_HOLDER* ) ;
<<toc >>

delete_EVENT_HANDLER_HOLDER_array #include "EventHandlerHolder.H"
void delete_EVENT_HANDLER_HOLDER_array(void* v ) ;
<<toc >>

delete_EVENT_HANDLER_HOLDER_array_PTR #include "EventHandlerHolder.H"
void delete_EVENT_HANDLER_HOLDER_array_PTR(void* v ) ;
<<toc >>

delete_EVENT_HANDLER_array #include "EventHandler.H"
void delete_EVENT_HANDLER_array(void* v ) ;
<<toc >>

delete_EVENT_HANDLER_array_PTR #include "EventHandler.H"
void delete_EVENT_HANDLER_array_PTR(void* v ) ;
<<toc >>

delete_FloatSemaphore_array #include "Semaphore.H"
void delete_FloatSemaphore_array(void* v ) ;
<<toc >>

delete_FloatSemaphore_array_PTR #include "Semaphore.H"
void delete_FloatSemaphore_array_PTR(void* v ) ;
<<toc >>

delete_IntegerSemaphore_array #include "Semaphore.H"
void delete_IntegerSemaphore_array(void* v ) ;
<<toc >>

delete_IntegerSemaphore_array_PTR #include "Semaphore.H"
void delete_IntegerSemaphore_array_PTR(void* v ) ;
<<toc >>

delete_LogicalSemaphore_array #include "Semaphore.H"
void delete_LogicalSemaphore_array(void* v ) ;
<<toc >>

delete_LogicalSemaphore_array_PTR #include "Semaphore.H"
void delete_LogicalSemaphore_array_PTR(void* v ) ;
<<toc >>

delete_RB_BINARY_TREE_array #include "RB_BinaryTree.H"
void delete_RB_BINARY_TREE_array(void* v ) ;
<<toc >>

delete_RB_BINARY_TREE_array_PTR #include "RB_BinaryTree.H"
void delete_RB_BINARY_TREE_array_PTR(void* v ) ;
<<toc >>

delete_RB_double_array #include "state_variable.H"
void delete_RB_double_array(void* v ) ;
<<toc >>

delete_RB_double_array_PTR #include "state_variable.H"
void delete_RB_double_array_PTR(void* v ) ;
<<toc >>

delete_RB_float_array #include "state_variable.H"
void delete_RB_float_array(void* v ) ;
<<toc >>

delete_RB_float_array_PTR #include "state_variable.H"
void delete_RB_float_array_PTR(void* v ) ;
<<toc >>

delete_RB_int_array #include "state_variable.H"
void delete_RB_int_array(void* v ) ;
<<toc >>

delete_RB_int_array_PTR #include "state_variable.H"
void delete_RB_int_array_PTR(void* v ) ;
<<toc >>

delete_RB_pointer_array #include "state_variable.H"
void delete_RB_pointer_array(void* v ) ;
<<toc >>

delete_RB_pointer_array_PTR #include "state_variable.H"
void delete_RB_pointer_array_PTR(void* v ) ;
<<toc >>

delete_RB_string_array #include "state_variable.H"
void delete_RB_string_array(void* v ) ;
<<toc >>

delete_RB_string_array_PTR #include "state_variable.H"
void delete_RB_string_array_PTR(void* v ) ;
<<toc >>

delete_Stack_array #include "processTypes.H"
void delete_Stack_array(void* v ) ;
<<toc >>

delete_Stack_array_PTR #include "processTypes.H"
void delete_Stack_array_PTR(void* v ) ;
<<toc >>

delete_char_array #include "def_rbq.H"
void delete_char_array(void* v ) ;
<<toc >>

delete_char_array_PTR #include "def_rbq.H"
void delete_char_array_PTR(void* v ) ;
<<toc >>

delete_double_array #include "def_rbq.H"
void delete_double_array(void* v ) ;
<<toc >>

delete_double_array_PTR #include "def_rbq.H"
void delete_double_array_PTR(void* v ) ;
<<toc >>

delete_float_array #include "def_rbq.H"
void delete_float_array(void* v ) ;
<<toc >>

delete_float_array_PTR #include "def_rbq.H"
void delete_float_array_PTR(void* v ) ;
<<toc >>

delete_int_array #include "def_rbq.H"
void delete_int_array(void* v ) ;
<<toc >>

delete_int_array_PTR #include "def_rbq.H"
void delete_int_array_PTR(void* v ) ;
<<toc >>

delete_single_EVENT_HANDLER #include "EventHandler.H"
void delete_single_EVENT_HANDLER(void* v ) ;
<<toc >>

delete_single_EVENT_HANDLER_HOLDER #include "EventHandlerHolder.H"
void delete_single_EVENT_HANDLER_HOLDER(void* v ) ;
<<toc >>

delete_single_EVENT_HANDLER_HOLDER_PTR #include "EventHandlerHolder.H"
void delete_single_EVENT_HANDLER_HOLDER_PTR(void* v ) ;
<<toc >>

delete_single_EVENT_HANDLER_METHOD #include "EventHandlerMethod.H"
void delete_single_EVENT_HANDLER_METHOD(void* v ) ;
<<toc >>

delete_single_EVENT_HANDLER_METHOD_PTR #include "EventHandlerMethod.H"
void delete_single_EVENT_HANDLER_METHOD_PTR(void* v ) ;
<<toc >>

delete_single_EVENT_HANDLER_PTR #include "EventHandler.H"
void delete_single_EVENT_HANDLER_PTR(void* v ) ;
<<toc >>

delete_single_EventHandlerElement #include "Component.H"
void delete_single_EventHandlerElement(void* v ) ;
<<toc >>

delete_single_EventHandlerElement_PTR #include "Component.H"
void delete_single_EventHandlerElement_PTR(void* v ) ;
<<toc >>

delete_single_FloatSemaphore #include "Semaphore.H"
void delete_single_FloatSemaphore(void* v ) ;
<<toc >>

delete_single_FloatSemaphore_PTR #include "Semaphore.H"
void delete_single_FloatSemaphore_PTR(void* v ) ;
<<toc >>

delete_single_FloatWaitingItem #include "Semaphore.H"
void delete_single_FloatWaitingItem(void* v ) ;
<<toc >>

delete_single_FloatWaitingItem_PTR #include "Semaphore.H"
void delete_single_FloatWaitingItem_PTR(void* v ) ;
<<toc >>

delete_single_IntegerSemaphore #include "Semaphore.H"
void delete_single_IntegerSemaphore(void* v ) ;
<<toc >>

delete_single_IntegerSemaphore_PTR #include "Semaphore.H"
void delete_single_IntegerSemaphore_PTR(void* v ) ;
<<toc >>

delete_single_IntegerWaitingItem #include "Semaphore.H"
void delete_single_IntegerWaitingItem(void* v ) ;
<<toc >>

delete_single_IntegerWaitingItem_PTR #include "Semaphore.H"
void delete_single_IntegerWaitingItem_PTR(void* v ) ;
<<toc >>

delete_single_LogicalSemaphore #include "Semaphore.H"
void delete_single_LogicalSemaphore(void* v ) ;
<<toc >>

delete_single_LogicalSemaphore_PTR #include "Semaphore.H"
void delete_single_LogicalSemaphore_PTR(void* v ) ;
<<toc >>

delete_single_RB_BINARY_TREE #include "RB_BinaryTree.H"
void delete_single_RB_BINARY_TREE(void* v ) ;
<<toc >>

delete_single_RB_BINARY_TREE_PTR #include "RB_BinaryTree.H"
void delete_single_RB_BINARY_TREE_PTR(void* v ) ;
<<toc >>

delete_single_RB_double #include "state_variable.H"
void delete_single_RB_double(void* v ) ;
<<toc >>

delete_single_RB_double_PTR #include "state_variable.H"
void delete_single_RB_double_PTR(void* v ) ;
<<toc >>

delete_single_RB_float #include "state_variable.H"
void delete_single_RB_float(void* v ) ;
<<toc >>

delete_single_RB_float_PTR #include "state_variable.H"
void delete_single_RB_float_PTR(void* v ) ;
<<toc >>

delete_single_RB_int #include "state_variable.H"
void delete_single_RB_int(void* v ) ;
<<toc >>

delete_single_RB_int_PTR #include "state_variable.H"
void delete_single_RB_int_PTR(void* v ) ;
<<toc >>

delete_single_RB_pointer #include "state_variable.H"
void delete_single_RB_pointer(void* v ) ;
<<toc >>

delete_single_RB_pointer_PTR #include "state_variable.H"
void delete_single_RB_pointer_PTR(void* v ) ;
<<toc >>

delete_single_RB_string #include "state_variable.H"
void delete_single_RB_string(void* v ) ;
<<toc >>

delete_single_RB_string_PTR #include "state_variable.H"
void delete_single_RB_string_PTR(void* v ) ;
<<toc >>

delete_single_SemaphoreWaitingItem #include "Semaphore.H"
void delete_single_SemaphoreWaitingItem(void* v ) ;
Rollback items.
<<toc >>

delete_single_SemaphoreWaitingItem_PTR #include "Semaphore.H"
void delete_single_SemaphoreWaitingItem_PTR(void* v ) ;
<<toc >>

delete_single_SharedSemaphore #include "Semaphore.H"
void delete_single_SharedSemaphore(void* v ) ;
<<toc >>

delete_single_SharedSemaphoreWaitingItem #include "Semaphore.H"
void delete_single_SharedSemaphoreWaitingItem(void* v ) ;
<<toc >>

delete_single_SharedSemaphoreWaitingItem_PTR #include "Semaphore.H"
void delete_single_SharedSemaphoreWaitingItem_PTR(void* v ) ;
<<toc >>

delete_single_SharedSemaphore_PTR #include "Semaphore.H"
void delete_single_SharedSemaphore_PTR(void* v ) ;
<<toc >>

delete_single_Stack #include "processTypes.H"
void delete_single_Stack(void* v ) ;
<<toc >>

delete_single_Stack_PTR #include "processTypes.H"
void delete_single_Stack_PTR(void* v ) ;
<<toc >>

delete_single_char #include "def_rbq.H"
void delete_single_char(void* v ) ;
Inline: void RB_DELETE_ARRAY_T(T *t) Summary: Rollbackably deletes an array of objects of type T Description: T may be char or int or float or double, or anything else passed to macro RB_DEFINE_CLASS Example: During the processing of an event, the code "C_SQ_ITEM cancel_item = new C_SQ_ITEM[3]; ...; RB_DELETE_ARRAY_C_SQ_ITEM(cancel_item);" tells SPEEDES that cancel_item should be deleted with brackets, but SPEEDES will not delete it immediately. Rather, SPEEDES will wait until the event is committed to actually do the delete. This way if the event gets rolled back, then SPEEDES will decide NOT to delete the memory. That code is similar to "delete [] cancel_item;", except that if the event is rolled back, the memory will NOT have actually been deleted. Do NOT pass this function a single non-array object (an example of a single non-array object is something returned by RB_NEW_T to by new T(...)); Return: void.
<<toc >>

delete_single_char_PTR #include "def_rbq.H"
void delete_single_char_PTR(void* v ) ;
<<toc >>

delete_single_double #include "def_rbq.H"
void delete_single_double(void* v ) ;
<<toc >>

delete_single_double_PTR #include "def_rbq.H"
void delete_single_double_PTR(void* v ) ;
<<toc >>

delete_single_float #include "def_rbq.H"
void delete_single_float(void* v ) ;
<<toc >>

delete_single_float_PTR #include "def_rbq.H"
void delete_single_float_PTR(void* v ) ;
<<toc >>

delete_single_int #include "def_rbq.H"
void delete_single_int(void* v ) ;
<<toc >>

delete_single_int_PTR #include "def_rbq.H"
void delete_single_int_PTR(void* v ) ;
<<toc >>

exit_all_other_nodes #include "speedes_comm.H"
void exit_all_other_nodes() ;
<<toc >>

f_subcube #include "speedes_comm.H"
void f_subcube(FILE* , int ) ;
<<toc >>

get_msg #include "speedes_comm.H"
int get_msg(MSG_STRUCT* msg ) ;
<<toc >>

get_n_nodes #include "speedes_comm.H"
int get_n_nodes() ;
<<toc >>

get_node #include "speedes_comm.H"
int get_node() ;
<<toc >>

give_buf #include "speedes_comm.H"
int give_buf(MSG_STRUCT* msg ) ;
<<toc >>

nb_check #include "speedes_comm.H"
int nb_check() ;
<<toc >>

nb_sync #include "speedes_comm.H"
void nb_sync() ;
<<toc >>

new_C_HOLDER #include "defunc.H"
C_HOLDER* new_C_HOLDER(char* , int , int ) ;
...... SPEEDES utilities.
<<toc >>

new_EVENT_HANDLER_EVENT #include "EventHandlerEvent.H"
void* new_EVENT_HANDLER_EVENT(int n ) ;
<<toc >>

scombine #include "speedes_comm.H"
int scombine(int* buf , int type , int size , int num ) ;
<<toc >>

scparam #include "speedes_comm.H"
void scparam(scubenv* ) ;
<<toc >>

send_msg #include "speedes_comm.H"
int send_msg(MSG_STRUCT* msg , int& status ) ;
<<toc >>

send_msg_w #include "speedes_comm.H"
int send_msg_w(MSG_STRUCT* msg ) ;
<<toc >>

startup #include "speedes_comm.H"
void startup() ;
<<toc