#include "processTypes.H"
|
|
|
|
|
|
int futureAsk;
size_t outSize;
Reentry_T reentry;
StackElement* reentryLV;
void* voidIn;
void* voidOut;
#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:
#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.
COMPONENT | COMPONENT | ~COMPONENT |
PluggedIn |
|
) ; |
|
|
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) { ... }
|
) ; |
|
) ; |
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
#include "antimess.H"
Antimess object.
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 |
|
) ; |
|
) ; |
|
) ; |
|
) ; |
|
) ; |
|
) ; |
|
) ; |
|
) ; |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#include "base_evtype.H"
Evtype object.
|
) ; |
|
) ; |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
) ; |
|
|
|
|
|
|
|
|
|
|
|
|
|
) ; |
|
|
|
|
|
|
#include "base_obman.H"
Base_obman object.
C_BASE_OBMAN | RB_SET_FREE | define_manager |
get_free_list | get_ntypes | get_obid |
get_obname | new_manager | set_ntypes |
|
) ; |
|
|
|
|
|
) ; |
|
) ; |
|
|
|
|
|
|
|
|
#include "antimess.H"
#include "headers.H"
EM_command object.
char EM_command [ 40 ];
#include "headers.H"
EM_header object.
|
) ; |
NET_INT EM_flag;
NET_INT EM_interaction;
NET_INT EM_socket;
NET_INT data_bytes;
g;
#include "headers.H"
EM_command object.
double EM_done_time;
#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.
|
) ; |
|
|
|
) ; |
|
) ; |
|
) ; |
Method: GetObjectHandle Summary: Returns a reference to the current simobj's object handle Description: Return: A reference to this simobj's object handle
|
) ; |
|
) ; |
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)
|
) ; |
|
) ; |
|
) ; |
|
|
|
|
|
|
|
|
|
) ; |
|
|
Method: WriteLookaheadfile Summary: Write to the lookahead file, if enabled Description: Return: None
|
) ; |
Internal Method: attach_object Summary: Attach this event to its associated simulation object (C_SIMOBJ) Description: Return: None
|
) ; |
Internal Method: calculate_tmin Summary: Calculate the minimum time of a generated message Description: Return: None
|
|
|
) ; |
Internal Method: cancel_event Summary: Cancel this event Description: Return: Current number of rollbacks
|
|
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)
|
) ; |
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
|
|
|
) ; |
Virtual Method: cleanup Summary: User-written code called in the event destructor Description: Return: None
|
) ; |
Internal Method: clear_data Summary: Clear the data for this event Description: Return: None
|
) ; |
Internal Method: clear_messages Summary: Clear all of the messages out of this event Description: Return: None
|
) ; |
|
|
|
|
|
|
|
|
|
) ; |
Internal Method: delete_MESSAGE Summary: delete the MESSAGE associated with this event (if it exists) Description: Return: None
|
|
|
|
|
|
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
|
) ; |
|
) ; |
|
) ; |
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
|
) ; |
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
|
) ; |
Internal Method: get_HOST_USER Summary: Get the host user on this node (C_HOST_USER) Description: see HOST_USER Return: the host user
|
) ; |
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
|
) ; |
|
) ; |
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.
|
) ; |
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
|
) ; |
|
) ; |
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
|
) ; |
|
) ; |
Internal Method: get_amque Summary: Get this event's queue of outgoing antimessages Description: Return: This event's queue of outgoing antimessages
|
) ; |
Internal Method: get_cancel_id Summary: Get this event's cancel ID Description: Return: This event's cancel ID
|
) ; |
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
|
) ; |
Internal Method: get_eventHandlerName Summary: Get the lastprocessed event handler event name (used by ReScheduleEventHandler()) Description: Return: the last-processed event handler event name
|
) ; |
Internal Method: get_event_canceled Summary: Get cancel flag Description: Return: cancel flag (true if cancelled)
|
) ; |
Internal Method: get_evtptr Summary: Get this event's optimistic event object (C_LPTR) Description: Return: This event's optimistic event object (C_LPTR)
|
) ; |
Internal Method: get_free Summary: Get the free flag (used for event list management) Description: Return: The free flag
|
) ; |
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
|
) ; |
Internal Method: get_lazy Summary: Determine whether lazy cancellation is enabled Description: Return: Whether lazy cancellation is enabled (1=yes)
|
) ; |
|
|
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 *)
|
) ; |
Internal Method: get_mque Summary: Get this event's queue of outgoing messages Description: Return: This event's queue of outgoing messages
|
) ; |
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
|
) ; |
Internal Method: get_objects Summary: Get the C_OBJECTS object on this node Description: Return: None
|
) ; |
Internal Method: get_processed Summary: Get whether this event has been processed Description: Return: Flag for whether this event has been processed
|
) ; |
Internal Method: get_rbid Summary: Get this event's rollback ID Description: Return: This event's rollback ID
|
) ; |
Internal Method: *get_rbq Summary: Get this event's queue of rollbacks Description: Return: This event's queue of rollbacks
|
) ; |
Internal Method: get_tmin Summary: Get the minimum time of a generated message Description: Return: The minimum time of a generated message
|
) ; |
Internal Method: get_valid Summary: Get whether this event is valid Description: Return: Flag as to whether this event is valid
|
|
Internal Method: getmess Summary: Get messages coming in Description: Return: None
|
|
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
|
) ; |
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
|
) ; |
Internal Method: insert Summary: Attach this event to its simulation object (C_SIMOBJ) Description: Return: None
|
) ; |
|
) ; |
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
|
) ; |
Internal Method: local_messages Summary: Send out the local messages Description: Return: Current number of rollbacks
|
) ; |
Method: memory_print Summary: print out event free list memory statistics Description: Return: None
|
|
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
|
|
Method: open_Lookaheadfile Summary: Open a file into which to output lookahead information Description: Return: None
|
|
Method: open_tracefile Summary: Open a file into which to output trace information (see trace()) Description: Return: None
|
) ; |
Internal Method: optimistic_insert Summary: Optimistically insert all of this node's events into the event list Description: Return: Current number of rollbacks
|
) ; |
|
) ; |
Internal Method: pop_roll_back Summary: Pop this event off the roll back queue Description: Return: None
|
) ; |
Method: print_event_memory Summary: print out event free list memory statistics Description: Return: None
|
) ; |
|
) ; |
Method: reset_WriteLookahead Summary: Disable write lookahead Description: Return: None
|
) ; |
Internal Method: reset_event_canceled Summary: Uncancel an event Description: Return: None
|
) ; |
Method: reset_from_SpComm Summary: Record the fact that this event DID NOT come from SpComm. Description: Return: None
|
) ; |
Method: reset_lazy Summary: Disable lazy cancellation Description: Return: None
|
) ; |
Internal Method: reset_lazy_proc Summary: Reset the flag for whether this event has been lazy-processed Description: Return: None
|
) ; |
Internal Method: reset_processed Summary: Tell this event that it has not been processed Description: Return: None
|
) ; |
Method: reset_trace Summary: Disable tracing this event Description: Return: None
|
) ; |
Internal Method: reset_valid Summary: Tell this event that it is not valid Description: Return: None
|
) ; |
Internal Method: rollback Summary: Roll back each event on this node if necessary Description: Return: Current number of rollbacks
|
) ; |
Internal Method: rollback_event Summary: Roll back this event Description: Return: Current number of rollbacks
|
|
|
|
|
|
|
|
|
|
Internal Method: sendmess Summary: Send messages out to the appropriate nodes Description: Return: None
|
|
Internal Method: set_DATA Summary: Set the data used to enact this event Description: Return: None
|
|
Internal Method: set_EVENT_TYPE Summary: Set the ID (or enumerated type) of the type of this event Description: Return: None
|
|
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
|
|
Internal Method: set_HOST_USER Summary: Set the host user Description: Return: None
|
|
Internal Method: set_LOCAL_ID Summary: Set the ID of the simulation object associated with this event Description: Return: None
|
|
Internal Method: set_MESSAGE Summary: Set the message used to enact this event Description: Return: None
|
|
Internal Internal Method: set_NODE Summary: Set the node (process number on local machine) that this C_SIMOBJ is instantialted on. Description: Return: None
|
|
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
|
|
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
|
|
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
|
|
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
|
) ; |
Method: set_WriteLookahead Summary: Enable write lookahead Description: Return: None
|
|
Internal Method: set_cancel_id Summary: Set the cancel event ID Description: Return: None
|
|
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
|
) ; |
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
|
|
Internal Method: set_evtype Summary: Set the C_EVENT_TYPES object for this node Description: Return: None
|
) ; |
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
|
) ; |
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
|
) ; |
Method: set_lazy Summary: Enable lazy cancellation Description: Return: None
|
) ; |
|
|
Internal Method: set_objects Summary: Set the C_OBJECTS object for this node Description: Return: None
|
) ; |
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
|
|
Internal Method: set_rbid Summary: Set the roll back unique ID Description: Return: None
|
|
Internal Method: set_rbq Summary: Set the rollback queue manager Description: Return: None
|
) ; |
Method: set_trace Summary: Enable tracing this event Description: Return: None
|
) ; |
Internal Method: set_valid Summary: Set the state of the event to valid non-optimistic Description: Return: None
|
) ; |
Internal Method: set_valid_opt Summary: Set the state of the event to valid optimistic Description: Return: None
|
|
Internal Method: spin_loop Summary: Loop to waste time Description: Waits until a specific point in time Return: None
|
) ; |
|
) ; |
Method: trace Summary: Trace this event Description: Provide statistics about this event to a trace file during run time Return: None
|
) ; |
Internal Method: void_event Summary: Get cancel flag (same as get_event_canceled) Description: Return: cancel flag (true if cancelled)
|
) ; |
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
|
|
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
|
|
Internal Method: set_qproc Summary: Set the queue of processed events Description: Return: None
|
|
Internal Method: void set_twosmess Summary: Set the C_TWOSMESS object for this node Description: Return: None
#include "EventHandlerEvent.H"
|
) ; |
|
) ; |
#include "event_types.H"
Event_types object.
|
) ; |
#include "objman.H"
Class: C_GLOBAL_NAME Summary: Structure for a hash table of global names Description: Used only by C_OBJMAN
int lid;
char name [ MAX_NAME_LENGTH ];
int node;
#include "headers.H"
Header object.
NET_DOUBLE EarliestStartTime;
NET_INT ExternalId;
NET_INT bytes;
NET_INT cancel_id;
NET_INT evtype;
NET_INT ext;
NET_INT objid;
NET_INT obtype;
NET_INT rbid;
SIMTIME time_tag;
#include "lptr.H"
Lptr object.
#include "objects.H"
Objects object.
C_OBJECTS | ComputeCriticalPath | GetManagerName |
GetNmanagers | get_N_LOC | get_N_TOT |
get_allids | get_nodid | get_obj |
get_objman | init_events | |
term |
|
) ; |
|
|
|
|
|
) ; |
|
|
|
|
|
|
|
|
|
|
|
|
|
) ; |
|
) ; |
|
|
#include "object_types.H"
Object_types object.
|
) ; |
#include "objevt.H"
Objevt object.
C_OBJEVT | get_event | get_processed |
get_valid | reset_processed | reset_valid |
set_event | set_processed | set_valid |
|
) ; |
|
) ; |
|
) ; |
|
) ; |
|
) ; |
|
) ; |
|
|
|
) ; |
|
) ; |
#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().
|
) ; |
|
|
Internal Method: CriticalPath Summary: Description: Return: None
|
) ; |
|
) ; |
|
) ; |
|
) ; |
|
) ; |
|
|
|
) ; |
|
|
|
|
Internal Method: add_object Summary: Add a C_SIMOBJ dynamically to the simulation Description: This function is not currently supported Return: None
|
) ; |
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 Method: define_object Summary: Put a C_SIMOBJ into the array of C_SIMOBJs managed by this C_OBJMAN Description: Return: None
|
|
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
|
) ; |
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
|
) ; |
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
|
) ; |
Internal Method: get_allids Summary: Description: Return:
|
) ; |
Internal Method: get_allids_size Summary: Description: Return:
|
|
Overloaded Method: get_nodid Summary: Get the NODE and LOCAL_ID of the C_SIMOBJ specified by its NAME Description: Return: None
|
|
OUT: The LOCAL_ID of the C_SIMOBJ of interest
|
|
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
|
|
Virtual Method: get_oid Summary: Get the GLOBAL_ID of the C_SIMOBJ specified by NODE and LOCAL_ID Description: Return: None
|
) ; |
|
|
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
|
|
Internal Method: name_hash Summary: Description: Return:
|
) ; |
Method: print_global_names Summary: Print the global name database to cout (see set_global_names()) Description: Return: None
|
|
|
|
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
|
) ; |
Internal Method: reset_interact Summary: Description: Return: None
|
) ; |
|
|
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
|
|
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
|
) ; |
|
) ; |
Internal Method: set_interact Summary: Description: Return: None
|
|
Internal Method: term Summary: Description: Return: None
#include "rbq.H"
Rbq object.
|
) ; |
|
) ; |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
) ; |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
) ; |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
) ; |
|
) ; |
|
) ; |
|
) ; |
|
) ; |
|
|
|
) ; |
|
) ; |
|
) ; |
|
|
|
|
|
|
|
) ; |
|
) ; |
|
|
|
) ; |
|
|
|
|
#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.
|
) ; |
|
) ; |
|
|
|
|
|
|
|
|
IN: id of external module if applicable (-1 means event not generated by external module)
|
|
|
|
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.
|
|
Method: EXCHANGE_SEED Summary: Exchange the SEED of this C_SIMOBJ for rollback purposes Description: Return: None
|
) ; |
|
) ; |
|
) ; |
|
) ; |
|
) ; |
Method: GetObjectHandle Summary: Returns a reference to this simobj's object handle Description: Return: A reference to this simobj's object handle
|
) ; |
|
) ; |
|
) ; |
|
) ; |
|
|
|
|
|
|
|
) ; |
|
|
|
|
|
|
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
|
|
|
|
|
|
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
|
|
|
) ; |
Internal Method: combine_total_objects Summary: Recalculate the total number of objects on all nodes Description: Return: None
|
|
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
|
) ; |
|
) ; |
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
|
) ; |
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
|
) ; |
Method: get_NAME Summary: Get the name of this object (for referring to this C_SIMOBJ by name) Description: Return: name of this object
|
) 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.
|
) ; |
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
|
) ; |
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
|
) ; |
|
) ; |
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
|
) ; |
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
|
) ; |
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
|
) ; |
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
|
) ; |
Internal Method: get_blocking Summary: Get the number of blocking times on this node Description: Return: the number of blocking times on this node
|
) ; |
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
|
) ; |
Internal Method: get_evtq Summary: Get the event queue on this node Description: Return: the event queue on this node
|
) ; |
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
|
) ; |
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
|
|
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 *)
|
) ; |
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
|
) ; |
Internal Method: get_ncancel Summary: Get the number of cancelled events for this object Description: Return: the number of cancelled events for this object
|
) ; |
Internal Method: get_obman Summary: Get this simulation object's object manager constructor Description: Return: this simulation object's object manager constructor
|
|
|
) ; |
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
|
) ; |
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
|
) ; |
Internal Method: get_tblock Summary: Get the simulated time tag of the earliest blocking event Description: Return: None
|
) ; |
Internal Method: get_uid_seed Summary: Get the seed to calculate GLOBAL_ID Description: Return: seed for calculating GLOBAL_ID
|
) ; |
Internal Method: init_objs Summary: Initialization routine for simulation objects Description: Return: None
|
|
Internal Method: insert_event Summary: Insert an event into this simulation object's list of pending events Description: Return: None
|
|
Method: object_type Summary: Retrieves a simulation object's OBJECT_TYPE (see set_OBJECT_TYPE) based on its string NAME Description: Return: the object type of this simulation object
|
) ; |
Virtual Method: print Summary: User-overridable function to print something about this simulation object during run-time Description: Return: None
|
) ; |
Internal Method: print_event_memory Summary: print out free list event memory statistics Description: Return: None
|
|
|
|
Internal Method: remove_block Summary: Remove a time from this node's list of blocking times Description: Return: None
|
) ; |
Internal Method: reset_nlobjs Summary: Set the number of local objects to zero Description: Return: None
|
|
|
|
|
|
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
|
|
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
|
|
Internal Method: set_NAME Summary: Set the name of this object (for referring to this C_SIMOBJ by name) Description: Return: None
|
|
Internal Method: set_NODE Summary: Set the node (process number on local machine) that this C_SIMOBJ shall be instantialted on. Description: Return: None
|
|
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
|
|
Internal Method: set_N_OBJECT_TYPES Summary: Set the total number of OBJECT_TYPEs (see above) in the current simulation Description: Return: None
|
|
|
|
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
|
|
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
|
|
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
|
|
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
|
|
Internal Method: set_evtype Summary: Set the event manager object for this node (type C_EVENT_TYPES) Description: Return: None
|
|
Internal Method: set_init_event_queue Summary: Set the event queue for this node to its initial queue Description: Return: None
|
|
Internal Method: set_last_etype Summary: Set the previous event type to act on this simulation object Description: Return: None
|
|
Internal Method: set_obman Summary: Set this simulation object's object manager constructor Description: Return: None
|
|
Internal Method: set_rbq Summary: Set the rollback queue for this object Description: Return: None
|
|
Internal Method: set_rq_holder Summary: Set the rollback queue holder for this simulation object (see C_RQ_HOLDER) Description: Return: None
|
|
Internal Method: set_rqueue Summary: Attach this node's event queue to this simulation object Description: Return: None
|
|
Internal Method: set_uid_seed Summary: Set the seed to calculate GLOBAL_ID Description: Return: None
|
|
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
|
|
Internal Method: unblock Summary: unblock a socket Description: Return: None
|
) ; |
Internal Method: update_block Summary: update the blocking and unblocking event lists for this node Description: Return: None
|
|
Internal Method: add_block Summary: Add a blocking time Description: Return: None
|
|
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
|
) ; |
Internal Method: get_qblock Summary: Get the queue of blocking times for this node Description: Return: the queue of blocking times for this node
#include "rbq.H"
#include "EventHandler.H"
EVENT_HANDLER | ~EVENT_HANDLER | Process |
SetComponent | SetGlobalId | SetLocalId |
SetNode | SetObjectType | SetSimObj |
|
) ; |
|
) ; |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#include "EventHandlerEventMess.H"
Event handler event message.
int DataBytes;
#include "EventHandlerHolder.H"
|
) ; |
|
|
|
) ; |
|
|
|
|
|
|
|
) ; |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#include "EventHandlerMethod.H"
Internal Class: EVENT_HANDLER_METHOD Summary: Event handler that calls an object method when invoked by a named event Description:
|
|
|
|
#include "Speedes.H"
EventConstructFunc conFunc;
int eSize;
int mSize;
char* name;
int numFree;
#include "Component.H"
Internal Struct: EventHandlerElement Summary: elements for the EventHandlerList XLIST Description:
|
|
|
) ; |
EVENT_HANDLER* eventHandler;
char* eventName;
#include "Semaphore.H"
FloatSemaphore | FloatSemaphore | operator double& |
operator+= | AddResource | RemoveBlockingProcess |
RequestResource |
|
) ; |
|
|
|
) ; |
|
|
|
|
|
|
|
|
#include "Semaphore.H"
|
|
double requestAmount;
#include "processTypes.H"
|
) ; |
STATE_INT blocking;
STATE_INT set;
#include "GoToTime.H"
|
) ; |
|
|
#include "Semaphore.H"
IntegerSemaphore | IntegerSemaphore | operator int& |
operator+= | AddResource | RemoveBlockingProcess |
RequestResource |
|
) ; |
|
|
|
) ; |
|
|
|
|
|
|
|
|
#include "Semaphore.H"
|
|
int requestAmount;
#include "Semaphore.H"
|
) ; |
|
|
|
|
|
) ; |
|
) ; |
|
|
|
|
|
) ; |
|
|
|
|
|
) ; |
|
) ; |
|
|
|
|
|
|
#include "Speedes.H"
ObjectManagerContainer | GetConFunc | GetName |
SetConFunc | SetName |
|
|
|
) ; |
|
) ; |
|
|
|
|
ObjManConstructFunc conFunc;
char* name;
#include "rbAssertObj.H"
GEB4: Rollbackable assert.
RB_ASSERT_OBJ | RB_ASSERT_OBJ | makeErrorStr |
rbAssert | setAssertStream | setAssertStream |
|
|
|
|
|
|
|
|
|
|
|
|
#include "RB_BinaryTree.H"
Insert | Insert | Remove |
Remove | RemoveFirstElement | RemoveFirstElement |
|
|
|
|
|
|
|
|
|
) ; |
|
|
#include "RB_DynArray.H"
RB_DYN_PTR_ARRAY | ~RB_DYN_PTR_ARRAY | operator[] |
GetArraySize |
|
|
|
) ; |
|
|
|
) ; |
#include "RB_HashTree.H"
|
) ; |
|
|
|
) ; |
|
|
|
|
|
) ; |
|
|
|
|
|
) ; |
|
|
|
|
|
) ; |
|
) ; |
|
|
|
) ; |
|
) ; |
|
|
|
) ; |
|
) ; |
|
) ; |
|
) ; |
|
|
|
|
|
) ; |
|
) ; |
|
) ; |
|
|
|
|
|
|
|
) ; |
|
) ; |
|
) ; |
#include "RB_List.H"
RB_LIST - doubly linked list data structure.
RB_LIST | operator+= | operator-= |
RB_Insert | RB_Remove | RB_add |
RB_remove | set_rbq |
|
) ; |
Constructor: RB_LIST Summary: Constructs the RB_LIST (no arguments required) Description: Return:
|
|
Operator: += Summary: Rollbackly inserts an element to the bottom of the list Description: Return: The list item container
|
|
Operator: -= Summary: Rollbackly removes an element from the list Description: Return:
|
|
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
|
|
Method: RB_Remove Summary: Rollbackly removes an element from the list Description: Return:
|
|
|
|
|
|
Method: set_rbq Summary: Called by SPEEDES to initialize the rollback queue Description: Return:
#include "RB_PriorityTree.H"
|
) ; |
|
) ; |
|
|
|
) ; |
|
) ; |
|
|
|
) ; |
|
) ; |
|
) ; |
|
) ; |
|
|
|
|
|
) ; |
|
) ; |
|
) ; |
#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)
RB_ostream | RB_ostream | operator<< |
operator<< | operator<< | operator<< |
operator<< | operator<< | operator<< |
operator<< | operator<< | operator<< |
operator<< | operator<< | initAltStream |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
) ; |
#include "ReentryMsg.H"
Reentry_T reentry;
StackElement* reentryLV;
int type;
#include "processTypes.H"
int eventType;
void* futurePtr;
double lookahead;
SpObjectHandle obj;
#include "Semaphore.H"
Abstract base class.
|
|
#include "Speedes.H"
SPEEDES | Execute | GetEventConFunc |
GetEventName | GetEventSize | GetMessageSize |
GetNumEventTypes | GetNumFree | GetNumObjManTypes |
GetObjManConFunc | GetObjManName | PlugInEvent |
PlugInObjMan |
|
) ; |
|
|
|
|
|
|
|
|
|
|
|
) ; |
|
|
|
) ; |
|
|
|
|
|
|
|
|
|
|
#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.
|
) ; |
|
|
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
|
|
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
|
|
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
|
) ; |
|
|
|
|
|
) ; |
|
|
|
) ; |
|
) ; |
|
|
|
) ; |
|
|
|
|
|
|
|
|
|
) ; |
Method: ReadMessages() Summary: Attempts to read all messages from the HostRouter and queue them Description: Return: void
|
|
|
|
|
|
|
|
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:
|
|
|
|
|
|
|
|
|
|
|
|
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:
#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)
STATE_DOUBLE | operator= | operator double |
operator*= | operator++ | operator+= |
operator-- | operator-= | operator/= |
SetDelta | SetMultiplier | assign |
|
) ; |
|
|
|
) ; |
|
|
|
) ; |
|
|
|
) ; |
|
|
|
|
|
|
|
|
|
|
|
|
|
) ; |
double state_variable;
#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)
STATE_FLOAT | operator= | operator float |
operator*= | operator++ | operator+= |
operator-- | operator-= | operator/= |
SetDelta | SetMultiplier | assign |
|
) ; |
|
|
|
) ; |
|
|
|
) ; |
|
|
|
) ; |
|
|
|
|
|
|
|
|
|
|
|
|
|
) ; |
float state_variable;
#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)
|
) ; |
|
|
|
|
|
|
|
) const; |
|
|
|
|
|
|
|
|
|
) ; |
|
|
|
|
|
) ; |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
) ; |
int state_variable;
#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.
STATE_POINTER | operator= | operator char* |
operator void* | assign |
|
) ; |
|
|
|
) ; |
|
) ; |
|
|
void* state_variable;
#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.
STATE_STRING | ~STATE_STRING | operator= |
operator char* | EraseString | SetNoRollback |
assign | ||
|
) ; |
|
) ; |
|
|
|
) ; |
|
) ; |
|
|
|
|
|
|
|
) ; |
char* state_variable;
#include "SubType.H"
SUB_TYPE | SUB_TYPE | ~SUB_TYPE |
Compare | Compare | GetExternalId |
GetName | GetType | SetExternalId |
SetType |
|
) ; |
|
|
|
) ; |
|
|
|
|
|
) ; |
|
) ; |
|
) ; |
|
|
|
|
#include "Semaphore.H"
Abstract base class.
operator*= | operator+= | operator-= |
operator/= | RemoveBlockingProcess | ScheduleSuccessfulSemReturnEvent |
|
|
|
|
|
|
|
|
|
|
|
|
#include "Semaphore.H"
Semaphore support structures:
|
|
StackElement* LVptr;
int eventType;
int timeOut;
#include "Semaphore.H"
SharedSemaphore | Add | GetAmount |
GetName | Request |
|
|
|
|
|
) ; |
|
) ; |
|
|
#include "Semaphore.H"
|
|
SpObjectHandle obj;
double reentryLookahead;
#include "processTypes.H"
C_XQUEUE* sePtr;
#include "processTypes.H"
|
|
|
|
|
) ; |
|
|
|
) ; |
|
|
|
|
|
) ; |
|
) ; |
|
|
|
|
|
|
|
|
|
|
|
|
C_EVENT* Event;
int ProcessType;
C_RANDOM* Random;
ime out Semaphore* SemaphorePtr;
SpObjectHandle* Simobj;
RB_pointer TimeOutCancelHandle;
RB_int finiteTimeOut;
RB_int reentryLabel;
RB_int seed;
Stack* stackPtr;
#include "Thread.H"
S_Thread class definition.
Thread | ~Thread | CreateSharedSemaphore |
GetSharedSemaphoreAmount | init | terminate |
|
) ; |
|
) ; |
|
|
|
|
Method: GetSharedSemaphoreAmount Summary: returns the current amount from named SharedSemaphore Description: Return: the 'amount' field from named SharedSemaphore
|
|
|
|
C_XQUEUE* sharedSemaphoreList;
C_XQUEUE* threadList;
#include "ObjectHandle.H"
|
) const; |
int NodeId;
int ObjManId;
int SimObjId;
#include "rbq_items.H"
cleanup | rollback | |
store | store | store |
store | store_error | set_alt_free_list |
|
) ; |
|
) ; |
|
) = 0; |
|
|
|
|
|
|
|
|
|
) ; |
|
|
#include "rbq_items.H"
|
) ; |
|
) ; |
|
|
#include "rbq_items.H"
|
) ; |
|
) ; |
|
|
#include "rbq_items.H"
|
) ; |
|
) ; |
|
|
#include "rbq_items.H"
#include "rbq_items.H"
SetInsert | SetRemove | |
rollback |
|
|
|
|
|
) ; |
|
) ; |
#include "rbq_items.H"
GEB1: obj for rolling back qblocks.
cleanup | rollback | |
setSlots |
|
) ; |
|
) ; |
|
) ; |
|
|
#include "rbq_items.H"
cleanup | rollback | |
set |
|
) ; |
|
) ; |
|
) ; |
|
|
#include "rbq_items.H"
#include "rbq_items.H"
#include "rbq_items.H"
#include "rbq_items.H"
rollback | set | |
store | store | store |
store |
|
) ; |
|
) ; |
|
|
|
|
|
|
|
|
|
|
#include "rbq_items.H"
GEB4: rollbackable exit() call.
cleanup | rollback | |
set |
|
) ; |
|
) ; |
|
) ; |
|
|
#include "rbq_items.H"
rollback | set | |
store | store | store |
store |
|
) ; |
|
) ; |
|
|
|
|
|
|
|
|
|
|
#include "rbq_items.H"
rollback | set | |
store | store | store |
store |
|
) ; |
|
) ; |
|
|
|
|
|
|
|
|
|
|
#include "rbq_items.H"
cleanup | rollback | |
set |
|
) ; |
|
) ; |
|
) ; |
|
|
#include "rbq_items.H"
#include "rbq_items.H"
#include "rbq_items.H"
#include "rbq_items.H"
cleanup | rollback | |
set |
|
) ; |
|
) ; |
|
) ; |
|
|
#include "rbq_items.H"
GEB0: obj for rolling back stream output:
|
) ; |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
) ; |
|
) ; |
|
) ; |
|
) ; |
|
) ; |
|
|
|
|
#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.
IO_Manipulator manip;
outputItem* next;
char* outString;
#include "rbq_items.H"
cleanup | rollback | |
set |
|
) ; |
|
) ; |
|
) ; |
|
|
#include "rbq_items.H"
rollback | set | |
store | store | store |
store |
|
) ; |
|
) ; |
|
|
|
|
|
|
|
|
|
|
#include "rbq_items.H"
cleanup | rollback | |
set |
#include "rbq_items.H"
|
) ; |
|
) ; |
|
|
#include "rbq_items.H"
#include "rbq_items.H"
|
) ; |
|
) ; |
|
|
#include "rbq_items.H"
|
) ; |
|
) ; |
|
|
#include "speedes_comm.H"
int blen;
int* buf;
int dest;
int dummy_byte_align;
int mlen;
int source;
int type;
#include "speedes_comm.H"
Structure declaration used by scparam().
int bmask;
int corner;
in hypercube* / int cpmask;
int cubemask;
int doc;
int dosc;
int nproc;
int nsproc;
int procnum;
CancelEvent | #include "ScheduleEvent.H" |
void CancelEvent( |
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 |
|
EVENT_HANDLER_EVENT_esize | #include "EventHandlerEvent.H" |
int EVENT_HANDLER_EVENT_esize() ; |
EVENT_HANDLER_EVENT_msize | #include "EventHandlerEvent.H" |
int EVENT_HANDLER_EVENT_msize() ; |
EVENT_HANDLER_EVENT_nfree | #include "EventHandlerEvent.H" |
int EVENT_HANDLER_EVENT_nfree() ; |
EXCHANGE | #include "def_rbq.H" |
void EXCHANGE( |
EXCHANGE | #include "def_rbq.H" |
void EXCHANGE( |
EXCHANGE | #include "def_rbq.H" |
void EXCHANGE( |
EXCHANGE | #include "def_rbq.H" |
void EXCHANGE( |
EXCHANGE | #include "def_rbq.H" |
void EXCHANGE( |
EXCHANGE | #include "def_rbq.H" |
void EXCHANGE( |
EXCHANGE | #include "def_rbq.H" |
void EXCHANGE( |
EXCHANGE | #include "def_rbq.H" |
void EXCHANGE( |
EXCHANGE | #include "def_rbq.H" |
void EXCHANGE( |
EXCHANGE | #include "def_rbq.H" |
void EXCHANGE( |
EXCHANGE | #include "def_rbq.H" |
void EXCHANGE( |
EXCHANGE | #include "def_rbq.H" |
void EXCHANGE( |
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. |
ExecuteSpeedes | #include "Speedes.H" |
int ExecuteSpeedes( |
RB_DEFINE_FREE | #include "def_rbq.H" |
void RB_DEFINE_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 |
RB_DELETE_ARRAY_EVENT_HANDLER | #include "EventHandler.H" |
void RB_DELETE_ARRAY_EVENT_HANDLER( |
RB_DELETE_ARRAY_EVENT_HANDLER_HOLDER | #include "EventHandlerHolder.H" |
void RB_DELETE_ARRAY_EVENT_HANDLER_HOLDER( |
RB_DELETE_ARRAY_EVENT_HANDLER_HOLDER_PTR | #include "EventHandlerHolder.H" |
void RB_DELETE_ARRAY_EVENT_HANDLER_HOLDER_PTR( |
RB_DELETE_ARRAY_EVENT_HANDLER_PTR | #include "EventHandler.H" |
void RB_DELETE_ARRAY_EVENT_HANDLER_PTR( |
RB_DELETE_ARRAY_FloatSemaphore | #include "Semaphore.H" |
void RB_DELETE_ARRAY_FloatSemaphore( |
RB_DELETE_ARRAY_FloatSemaphore_PTR | #include "Semaphore.H" |
void RB_DELETE_ARRAY_FloatSemaphore_PTR( |
RB_DELETE_ARRAY_IntegerSemaphore | #include "Semaphore.H" |
void RB_DELETE_ARRAY_IntegerSemaphore( |
RB_DELETE_ARRAY_IntegerSemaphore_PTR | #include "Semaphore.H" |
void RB_DELETE_ARRAY_IntegerSemaphore_PTR( |
RB_DELETE_ARRAY_LogicalSemaphore | #include "Semaphore.H" |
void RB_DELETE_ARRAY_LogicalSemaphore( |
RB_DELETE_ARRAY_LogicalSemaphore_PTR | #include "Semaphore.H" |
void RB_DELETE_ARRAY_LogicalSemaphore_PTR( |
RB_DELETE_ARRAY_RB_BINARY_TREE | #include "RB_BinaryTree.H" |
void RB_DELETE_ARRAY_RB_BINARY_TREE( |
RB_DELETE_ARRAY_RB_BINARY_TREE_PTR | #include "RB_BinaryTree.H" |
void RB_DELETE_ARRAY_RB_BINARY_TREE_PTR( |
RB_DELETE_ARRAY_RB_double | #include "state_variable.H" |
void RB_DELETE_ARRAY_RB_double( |
RB_DELETE_ARRAY_RB_double_PTR | #include "state_variable.H" |
void RB_DELETE_ARRAY_RB_double_PTR( |
RB_DELETE_ARRAY_RB_float | #include "state_variable.H" |
void RB_DELETE_ARRAY_RB_float( |
RB_DELETE_ARRAY_RB_float_PTR | #include "state_variable.H" |
void RB_DELETE_ARRAY_RB_float_PTR( |
RB_DELETE_ARRAY_RB_int | #include "state_variable.H" |
void RB_DELETE_ARRAY_RB_int( |
RB_DELETE_ARRAY_RB_int_PTR | #include "state_variable.H" |
void RB_DELETE_ARRAY_RB_int_PTR( |
RB_DELETE_ARRAY_RB_pointer | #include "state_variable.H" |
void RB_DELETE_ARRAY_RB_pointer( |
RB_DELETE_ARRAY_RB_pointer_PTR | #include "state_variable.H" |
void RB_DELETE_ARRAY_RB_pointer_PTR( |
RB_DELETE_ARRAY_RB_string | #include "state_variable.H" |
void RB_DELETE_ARRAY_RB_string( |
RB_DELETE_ARRAY_RB_string_PTR | #include "state_variable.H" |
void RB_DELETE_ARRAY_RB_string_PTR( |
RB_DELETE_ARRAY_Stack | #include "processTypes.H" |
void RB_DELETE_ARRAY_Stack( |
RB_DELETE_ARRAY_Stack_PTR | #include "processTypes.H" |
void RB_DELETE_ARRAY_Stack_PTR( |
RB_DELETE_ARRAY_char | #include "def_rbq.H" |
void RB_DELETE_ARRAY_char( |
RB_DELETE_ARRAY_char_PTR | #include "def_rbq.H" |
void RB_DELETE_ARRAY_char_PTR( |
RB_DELETE_ARRAY_double | #include "def_rbq.H" |
void RB_DELETE_ARRAY_double( |
RB_DELETE_ARRAY_double_PTR | #include "def_rbq.H" |
void RB_DELETE_ARRAY_double_PTR( |
RB_DELETE_ARRAY_float | #include "def_rbq.H" |
void RB_DELETE_ARRAY_float( |
RB_DELETE_ARRAY_float_PTR | #include "def_rbq.H" |
void RB_DELETE_ARRAY_float_PTR( |
RB_DELETE_ARRAY_int | #include "def_rbq.H" |
void RB_DELETE_ARRAY_int( |
RB_DELETE_ARRAY_int_PTR | #include "def_rbq.H" |
void RB_DELETE_ARRAY_int_PTR( |
RB_DELETE_CANCEL_HANDLE | #include "def_rbq.H" |
void RB_DELETE_CANCEL_HANDLE( |
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 |
RB_DELETE_EVENT_HANDLER | #include "EventHandler.H" |
void RB_DELETE_EVENT_HANDLER( |
RB_DELETE_EVENT_HANDLER_HOLDER | #include "EventHandlerHolder.H" |
void RB_DELETE_EVENT_HANDLER_HOLDER( |
RB_DELETE_EVENT_HANDLER_HOLDER_PTR | #include "EventHandlerHolder.H" |
void RB_DELETE_EVENT_HANDLER_HOLDER_PTR( |
RB_DELETE_EVENT_HANDLER_METHOD | #include "EventHandlerMethod.H" |
void RB_DELETE_EVENT_HANDLER_METHOD( |
RB_DELETE_EVENT_HANDLER_METHOD_PTR | #include "EventHandlerMethod.H" |
void RB_DELETE_EVENT_HANDLER_METHOD_PTR( |
RB_DELETE_EVENT_HANDLER_PTR | #include "EventHandler.H" |
void RB_DELETE_EVENT_HANDLER_PTR( |
RB_DELETE_EventHandlerElement | #include "Component.H" |
void RB_DELETE_EventHandlerElement( |
RB_DELETE_EventHandlerElement_PTR | #include "Component.H" |
void RB_DELETE_EventHandlerElement_PTR( |
RB_DELETE_FloatSemaphore | #include "Semaphore.H" |
void RB_DELETE_FloatSemaphore( |
RB_DELETE_FloatSemaphore_PTR | #include "Semaphore.H" |
void RB_DELETE_FloatSemaphore_PTR( |
RB_DELETE_FloatWaitingItem | #include "Semaphore.H" |
void RB_DELETE_FloatWaitingItem( |
RB_DELETE_FloatWaitingItem_PTR | #include "Semaphore.H" |
void RB_DELETE_FloatWaitingItem_PTR( |
RB_DELETE_HELPER | #include "RB_DefineClass.H" |
void RB_DELETE_HELPER( |
RB_DELETE_IntegerSemaphore | #include "Semaphore.H" |
void RB_DELETE_IntegerSemaphore( |
RB_DELETE_IntegerSemaphore_PTR | #include "Semaphore.H" |
void RB_DELETE_IntegerSemaphore_PTR( |
RB_DELETE_IntegerWaitingItem | #include "Semaphore.H" |
void RB_DELETE_IntegerWaitingItem( |
RB_DELETE_IntegerWaitingItem_PTR | #include "Semaphore.H" |
void RB_DELETE_IntegerWaitingItem_PTR( |
RB_DELETE_LogicalSemaphore | #include "Semaphore.H" |
void RB_DELETE_LogicalSemaphore( |
RB_DELETE_LogicalSemaphore_PTR | #include "Semaphore.H" |
void RB_DELETE_LogicalSemaphore_PTR( |
RB_DELETE_RB_BINARY_TREE | #include "RB_BinaryTree.H" |
void RB_DELETE_RB_BINARY_TREE( |
RB_DELETE_RB_BINARY_TREE_PTR | #include "RB_BinaryTree.H" |
void RB_DELETE_RB_BINARY_TREE_PTR( |
RB_DELETE_RB_double | #include "state_variable.H" |
void RB_DELETE_RB_double( |
RB_DELETE_RB_double_PTR | #include "state_variable.H" |
void RB_DELETE_RB_double_PTR( |
RB_DELETE_RB_float | #include "state_variable.H" |
void RB_DELETE_RB_float( |
RB_DELETE_RB_float_PTR | #include "state_variable.H" |
void RB_DELETE_RB_float_PTR( |
RB_DELETE_RB_int | #include "state_variable.H" |
void RB_DELETE_RB_int( |
RB_DELETE_RB_int_PTR | #include "state_variable.H" |
void RB_DELETE_RB_int_PTR( |
RB_DELETE_RB_pointer | #include "state_variable.H" |
void RB_DELETE_RB_pointer( |
RB_DELETE_RB_pointer_PTR | #include "state_variable.H" |
void RB_DELETE_RB_pointer_PTR( |
RB_DELETE_RB_string | #include "state_variable.H" |
void RB_DELETE_RB_string( |
RB_DELETE_RB_string_PTR | #include "state_variable.H" |
void RB_DELETE_RB_string_PTR( |
RB_DELETE_SemaphoreWaitingItem | #include "Semaphore.H" |
void RB_DELETE_SemaphoreWaitingItem( |
RB_DELETE_SemaphoreWaitingItem_PTR | #include "Semaphore.H" |
void RB_DELETE_SemaphoreWaitingItem_PTR( |
RB_DELETE_SharedSemaphore | #include "Semaphore.H" |
void RB_DELETE_SharedSemaphore( |
RB_DELETE_SharedSemaphoreWaitingItem | #include "Semaphore.H" |
void RB_DELETE_SharedSemaphoreWaitingItem( |
RB_DELETE_SharedSemaphoreWaitingItem_PTR | #include "Semaphore.H" |
void RB_DELETE_SharedSemaphoreWaitingItem_PTR( |
RB_DELETE_SharedSemaphore_PTR | #include "Semaphore.H" |
void RB_DELETE_SharedSemaphore_PTR( |
RB_DELETE_Stack | #include "processTypes.H" |
void RB_DELETE_Stack( |
RB_DELETE_Stack_PTR | #include "processTypes.H" |
void RB_DELETE_Stack_PTR( |
RB_DELETE_char | #include "def_rbq.H" |
void RB_DELETE_char( |
RB_DELETE_char_PTR | #include "def_rbq.H" |
void RB_DELETE_char_PTR( |
RB_DELETE_double | #include "def_rbq.H" |
void RB_DELETE_double( |
RB_DELETE_double_PTR | #include "def_rbq.H" |
void RB_DELETE_double_PTR( |
RB_DELETE_float | #include "def_rbq.H" |
void RB_DELETE_float( |
RB_DELETE_float_PTR | #include "def_rbq.H" |
void RB_DELETE_float_PTR( |
RB_DELETE_int | #include "def_rbq.H" |
void RB_DELETE_int( |
RB_DELETE_int_PTR | #include "def_rbq.H" |
void RB_DELETE_int_PTR( |
RB_FREE_DELETE | #include "def_rbq.H" |
void RB_FREE_DELETE( |
RB_FREE_DELETE | #include "def_rbq.H" |
void RB_FREE_DELETE( |
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. |
RB_FREE_GENERATE | #include "def_rbq.H" |
C_ITEM* RB_FREE_GENERATE( |
RB_FREE_GENERATE | #include "def_rbq.H" |
C_ITEM* RB_FREE_GENERATE( |
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 *). |
RB_FREE_NEW | #include "def_rbq.H" |
void* RB_FREE_NEW( |
RB_FREE_NEW | #include "def_rbq.H" |
void* RB_FREE_NEW( |
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. |
RB_INSERT | #include "def_rbq.H" |
void RB_INSERT( |
RB_INSERT | #include "def_rbq.H" |
void RB_INSERT( |
RB_INSERT | #include "def_rbq.H" |
void RB_INSERT( |
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. |
RB_MEMCPY | #include "def_rbq.H" |
void RB_MEMCPY( |
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 |
RB_NEW_ARRAY_EVENT_HANDLER | #include "EventHandler.H" |
EVENT_HANDLER* RB_NEW_ARRAY_EVENT_HANDLER( |
RB_NEW_ARRAY_EVENT_HANDLER_HOLDER | #include "EventHandlerHolder.H" |
EVENT_HANDLER_HOLDER* RB_NEW_ARRAY_EVENT_HANDLER_HOLDER( |
RB_NEW_ARRAY_EVENT_HANDLER_HOLDER_PTR | #include "EventHandlerHolder.H" |
EVENT_HANDLER_HOLDER** RB_NEW_ARRAY_EVENT_HANDLER_HOLDER_PTR( |
RB_NEW_ARRAY_EVENT_HANDLER_PTR | #include "EventHandler.H" |
EVENT_HANDLER** RB_NEW_ARRAY_EVENT_HANDLER_PTR( |
RB_NEW_ARRAY_FloatSemaphore | #include "Semaphore.H" |
FloatSemaphore* RB_NEW_ARRAY_FloatSemaphore( |
RB_NEW_ARRAY_FloatSemaphore_PTR | #include "Semaphore.H" |
FloatSemaphore** RB_NEW_ARRAY_FloatSemaphore_PTR( |
RB_NEW_ARRAY_IntegerSemaphore | #include "Semaphore.H" |
IntegerSemaphore* RB_NEW_ARRAY_IntegerSemaphore( |
RB_NEW_ARRAY_IntegerSemaphore_PTR | #include "Semaphore.H" |
IntegerSemaphore** RB_NEW_ARRAY_IntegerSemaphore_PTR( |
RB_NEW_ARRAY_LogicalSemaphore | #include "Semaphore.H" |
LogicalSemaphore* RB_NEW_ARRAY_LogicalSemaphore( |
RB_NEW_ARRAY_LogicalSemaphore_PTR | #include "Semaphore.H" |
LogicalSemaphore** RB_NEW_ARRAY_LogicalSemaphore_PTR( |
RB_NEW_ARRAY_RB_BINARY_TREE | #include "RB_BinaryTree.H" |
RB_BINARY_TREE* RB_NEW_ARRAY_RB_BINARY_TREE( |
RB_NEW_ARRAY_RB_BINARY_TREE_PTR | #include "RB_BinaryTree.H" |
RB_BINARY_TREE** RB_NEW_ARRAY_RB_BINARY_TREE_PTR( |
RB_NEW_ARRAY_RB_double | #include "state_variable.H" |
RB_double* RB_NEW_ARRAY_RB_double( |
RB_NEW_ARRAY_RB_double_PTR | #include "state_variable.H" |
RB_double** RB_NEW_ARRAY_RB_double_PTR( |
RB_NEW_ARRAY_RB_float | #include "state_variable.H" |
RB_float* RB_NEW_ARRAY_RB_float( |
RB_NEW_ARRAY_RB_float_PTR | #include "state_variable.H" |
RB_float** RB_NEW_ARRAY_RB_float_PTR( |
RB_NEW_ARRAY_RB_int | #include "state_variable.H" |
RB_int* RB_NEW_ARRAY_RB_int( |
RB_NEW_ARRAY_RB_int_PTR | #include "state_variable.H" |
RB_int** RB_NEW_ARRAY_RB_int_PTR( |
RB_NEW_ARRAY_RB_pointer | #include "state_variable.H" |
RB_pointer* RB_NEW_ARRAY_RB_pointer( |
RB_NEW_ARRAY_RB_pointer_PTR | #include "state_variable.H" |
RB_pointer** RB_NEW_ARRAY_RB_pointer_PTR( |
RB_NEW_ARRAY_RB_string | #include "state_variable.H" |
RB_string* RB_NEW_ARRAY_RB_string( |
RB_NEW_ARRAY_RB_string_PTR | #include "state_variable.H" |
RB_string** RB_NEW_ARRAY_RB_string_PTR( |
RB_NEW_ARRAY_Stack | #include "processTypes.H" |
Stack* RB_NEW_ARRAY_Stack( |
RB_NEW_ARRAY_Stack_PTR | #include "processTypes.H" |
Stack** RB_NEW_ARRAY_Stack_PTR( |
RB_NEW_ARRAY_char | #include "def_rbq.H" |
char* RB_NEW_ARRAY_char( |
RB_NEW_ARRAY_char_PTR | #include "def_rbq.H" |
char** RB_NEW_ARRAY_char_PTR( |
RB_NEW_ARRAY_double | #include "def_rbq.H" |
double* RB_NEW_ARRAY_double( |
RB_NEW_ARRAY_double_PTR | #include "def_rbq.H" |
double** RB_NEW_ARRAY_double_PTR( |
RB_NEW_ARRAY_float | #include "def_rbq.H" |
float* RB_NEW_ARRAY_float( |
RB_NEW_ARRAY_float_PTR | #include "def_rbq.H" |
float** RB_NEW_ARRAY_float_PTR( |
RB_NEW_ARRAY_int | #include "def_rbq.H" |
int* RB_NEW_ARRAY_int( |
RB_NEW_ARRAY_int_PTR | #include "def_rbq.H" |
int** RB_NEW_ARRAY_int_PTR( |
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) |
RB_NEW_EVENT_HANDLER | #include "EventHandler.H" |
EVENT_HANDLER* RB_NEW_EVENT_HANDLER() ; |
RB_NEW_EVENT_HANDLER | #include "EventHandler.H" |
EVENT_HANDLER* RB_NEW_EVENT_HANDLER( |
RB_NEW_EVENT_HANDLER_HOLDER | #include "EventHandlerHolder.H" |
EVENT_HANDLER_HOLDER* RB_NEW_EVENT_HANDLER_HOLDER() ; |
RB_NEW_EVENT_HANDLER_HOLDER | #include "EventHandlerHolder.H" |
EVENT_HANDLER_HOLDER* RB_NEW_EVENT_HANDLER_HOLDER( |
RB_NEW_EVENT_HANDLER_HOLDER_PTR | #include "EventHandlerHolder.H" |
EVENT_HANDLER_HOLDER** RB_NEW_EVENT_HANDLER_HOLDER_PTR() ; |
RB_NEW_EVENT_HANDLER_METHOD | #include "EventHandlerMethod.H" |
EVENT_HANDLER_METHOD* RB_NEW_EVENT_HANDLER_METHOD( |
RB_NEW_EVENT_HANDLER_METHOD_PTR | #include "EventHandlerMethod.H" |
EVENT_HANDLER_METHOD** RB_NEW_EVENT_HANDLER_METHOD_PTR() ; |
RB_NEW_EVENT_HANDLER_PTR | #include "EventHandler.H" |
EVENT_HANDLER** RB_NEW_EVENT_HANDLER_PTR() ; |
RB_NEW_EventHandlerElement | #include "Component.H" |
EventHandlerElement* RB_NEW_EventHandlerElement( |
RB_NEW_EventHandlerElement_PTR | #include "Component.H" |
EventHandlerElement** RB_NEW_EventHandlerElement_PTR() ; |
RB_NEW_FloatSemaphore | #include "Semaphore.H" |
FloatSemaphore* RB_NEW_FloatSemaphore() ; |
RB_NEW_FloatSemaphore | #include "Semaphore.H" |
FloatSemaphore* RB_NEW_FloatSemaphore( |
RB_NEW_FloatSemaphore_PTR | #include "Semaphore.H" |
FloatSemaphore** RB_NEW_FloatSemaphore_PTR() ; |
RB_NEW_FloatWaitingItem | #include "Semaphore.H" |
FloatWaitingItem* RB_NEW_FloatWaitingItem( |
RB_NEW_FloatWaitingItem_PTR | #include "Semaphore.H" |
FloatWaitingItem** RB_NEW_FloatWaitingItem_PTR() ; |
RB_NEW_HELPER | #include "RB_DefineClass.H" |
void RB_NEW_HELPER( |
Do not write any additional calls to these functions: |
RB_NEW_IntegerSemaphore | #include "Semaphore.H" |
IntegerSemaphore* RB_NEW_IntegerSemaphore() ; |
RB_NEW_IntegerSemaphore | #include "Semaphore.H" |
IntegerSemaphore* RB_NEW_IntegerSemaphore( |
RB_NEW_IntegerSemaphore_PTR | #include "Semaphore.H" |
IntegerSemaphore** RB_NEW_IntegerSemaphore_PTR() ; |
RB_NEW_IntegerWaitingItem | #include "Semaphore.H" |
IntegerWaitingItem* RB_NEW_IntegerWaitingItem( |
RB_NEW_IntegerWaitingItem_PTR | #include "Semaphore.H" |
IntegerWaitingItem** RB_NEW_IntegerWaitingItem_PTR() ; |
RB_NEW_LogicalSemaphore | #include "Semaphore.H" |
LogicalSemaphore* RB_NEW_LogicalSemaphore() ; |
RB_NEW_LogicalSemaphore | #include "Semaphore.H" |
LogicalSemaphore* RB_NEW_LogicalSemaphore( |
RB_NEW_LogicalSemaphore_PTR | #include "Semaphore.H" |
LogicalSemaphore** RB_NEW_LogicalSemaphore_PTR() ; |
RB_NEW_RB_BINARY_TREE | #include "RB_BinaryTree.H" |
RB_BINARY_TREE* RB_NEW_RB_BINARY_TREE() ; |
RB_NEW_RB_BINARY_TREE | #include "RB_BinaryTree.H" |
RB_BINARY_TREE* RB_NEW_RB_BINARY_TREE( |
RB_NEW_RB_BINARY_TREE_PTR | #include "RB_BinaryTree.H" |
RB_BINARY_TREE** RB_NEW_RB_BINARY_TREE_PTR() ; |
RB_NEW_RB_double | #include "state_variable.H" |
RB_double* RB_NEW_RB_double() ; |
RB_NEW_RB_double | #include "state_variable.H" |
RB_double* RB_NEW_RB_double( |
RB_NEW_RB_double_PTR | #include "state_variable.H" |
RB_double** RB_NEW_RB_double_PTR() ; |
RB_NEW_RB_float | #include "state_variable.H" |
RB_float* RB_NEW_RB_float() ; |
RB_NEW_RB_float | #include "state_variable.H" |
RB_float* RB_NEW_RB_float( |
RB_NEW_RB_float_PTR | #include "state_variable.H" |
RB_float** RB_NEW_RB_float_PTR() ; |
RB_NEW_RB_int | #include "state_variable.H" |
RB_int* RB_NEW_RB_int() ; |
RB_NEW_RB_int | #include "state_variable.H" |
RB_int* RB_NEW_RB_int( |
RB_NEW_RB_int_PTR | #include "state_variable.H" |
RB_int** RB_NEW_RB_int_PTR() ; |
RB_NEW_RB_pointer | #include "state_variable.H" |
RB_pointer* RB_NEW_RB_pointer() ; |
RB_NEW_RB_pointer | #include "state_variable.H" |
RB_pointer* RB_NEW_RB_pointer( |
RB_NEW_RB_pointer_PTR | #include "state_variable.H" |
RB_pointer** RB_NEW_RB_pointer_PTR() ; |
RB_NEW_RB_string | #include "state_variable.H" |
RB_string* RB_NEW_RB_string() ; |
RB_NEW_RB_string | #include "state_variable.H" |
RB_string* RB_NEW_RB_string( |
RB_NEW_RB_string_PTR | #include "state_variable.H" |
RB_string** RB_NEW_RB_string_PTR() ; |
RB_NEW_SemaphoreWaitingItem | #include "Semaphore.H" |
SemaphoreWaitingItem* RB_NEW_SemaphoreWaitingItem( |
RB_NEW_SemaphoreWaitingItem_PTR | #include "Semaphore.H" |
SemaphoreWaitingItem** RB_NEW_SemaphoreWaitingItem_PTR() ; |
RB_NEW_SharedSemaphore | #include "Semaphore.H" |
SharedSemaphore* RB_NEW_SharedSemaphore( |
RB_NEW_SharedSemaphoreWaitingItem | #include "Semaphore.H" |
SharedSemaphoreWaitingItem* RB_NEW_SharedSemaphoreWaitingItem( |
RB_NEW_SharedSemaphoreWaitingItem_PTR | #include "Semaphore.H" |
SharedSemaphoreWaitingItem** RB_NEW_SharedSemaphoreWaitingItem_PTR() ; |
RB_NEW_SharedSemaphore_PTR | #include "Semaphore.H" |
SharedSemaphore** RB_NEW_SharedSemaphore_PTR() ; |
RB_NEW_Stack | #include "processTypes.H" |
Stack* RB_NEW_Stack() ; |
RB_NEW_Stack | #include "processTypes.H" |
Stack* RB_NEW_Stack( |
RB_NEW_Stack_PTR | #include "processTypes.H" |
Stack** RB_NEW_Stack_PTR() ; |
RB_NEW_char | #include "def_rbq.H" |
char* RB_NEW_char() ; |
RB_NEW_char | #include "def_rbq.H" |
char* RB_NEW_char( |
RB_NEW_char_PTR | #include "def_rbq.H" |
char** RB_NEW_char_PTR() ; |
RB_NEW_double | #include "def_rbq.H" |
double* RB_NEW_double() ; |
RB_NEW_double | #include "def_rbq.H" |
double* RB_NEW_double( |
RB_NEW_double_PTR | #include "def_rbq.H" |
double** RB_NEW_double_PTR() ; |
RB_NEW_float | #include "def_rbq.H" |
float* RB_NEW_float() ; |
RB_NEW_float | #include "def_rbq.H" |
float* RB_NEW_float( |
RB_NEW_float_PTR | #include "def_rbq.H" |
float** RB_NEW_float_PTR() ; |
RB_NEW_int | #include "def_rbq.H" |
int* RB_NEW_int() ; |
RB_NEW_int | #include "def_rbq.H" |
int* RB_NEW_int( |
RB_NEW_int_PTR | #include "def_rbq.H" |
int** RB_NEW_int_PTR() ; |
RB_POP | #include "def_rbq.H" |
C_SQ_ITEM* RB_POP( |
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*). |
RB_POP_BOT | #include "def_rbq.H" |
C_SQ_ITEM* RB_POP_BOT( |
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*) |
RB_POP_TOP | #include "def_rbq.H" |
C_SQ_ITEM* RB_POP_TOP( |
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*). |
RB_PRINT | #include "def_rbq.H" |
void RB_PRINT( |
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. |
RB_PUSH | #include "def_rbq.H" |
void RB_PUSH( |
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 |
RB_PUSH_BOT | #include "def_rbq.H" |
void RB_PUSH_BOT( |
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 |
RB_PUSH_TOP | #include "def_rbq.H" |
void RB_PUSH_TOP( |
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 |
RB_REMOVE | #include "def_rbq.H" |
C_SQ_ITEM* RB_REMOVE( |
RB_REMOVE | #include "def_rbq.H" |
C_SQ_ITEM* RB_REMOVE( |
RB_REMOVE | #include "def_rbq.H" |
void RB_REMOVE( |
RB_REMOVE | #include "def_rbq.H" |
C_SQ_ITEM* RB_REMOVE( |
RB_REMOVE | #include "def_rbq.H" |
C_SQ_ITEM* RB_REMOVE( |
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*). |
RB_STRDUP | #include "def_rbq.H" |
char* RB_STRDUP( |
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. |
RB_XMEM | #include "def_rbq.H" |
void RB_XMEM( |
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 |
RB_memcpy | #include "def_rbq.H" |
void RB_memcpy( |
RB_strdup | #include "def_rbq.H" |
char* RB_strdup( |
ReScheduleEvent | #include "ScheduleEvent.H" |
C_CANCEL_HANDLE ReScheduleEvent( |
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. |
|
ReScheduleEvent | #include "ScheduleEvent.H" |
C_CANCEL_HANDLE ReScheduleEvent( |
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. |
|
ReScheduleEventHandler | #include "ScheduleEvent.H" |
C_CANCEL_HANDLE ReScheduleEventHandler( |
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. |
|
ReScheduleProcess | #include "ScheduleEvent.H" |
C_CANCEL_HANDLE ReScheduleProcess( |
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. |
|
ScheduleEvent | #include "ScheduleEvent.H" |
C_CANCEL_HANDLE ScheduleEvent( |
|
ScheduleEvent | #include "ScheduleEvent.H" |
C_CANCEL_HANDLE ScheduleEvent( |
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. |
|
ScheduleEvent | #include "ScheduleEvent.H" |
C_CANCEL_HANDLE ScheduleEvent( |
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. |
|
ScheduleEvent | #include "ScheduleEvent.H" |
C_CANCEL_HANDLE ScheduleEvent( |
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. |
|
ScheduleEventHandler | #include "ScheduleEvent.H" |
C_CANCEL_HANDLE ScheduleEventHandler( |
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. |
|
ScheduleProcess | #include "ScheduleEvent.H" |
C_CANCEL_HANDLE ScheduleProcess( |
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. |
|
ScheduleProcess | #include "ScheduleEvent.H" |
C_CANCEL_HANDLE ScheduleProcess( |
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. |
|
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. |
SpComm_CleanupOther | #include "SpeedesComm.H" |
void SpComm_CleanupOther() ; |
Clean up things other than shared memory. |
SpComm_CleanupShm | #include "SpeedesComm.H" |
void SpComm_CleanupShm() ; |
Clean up shared memory. |
SpComm_CoordinatedReceive | #include "SpeedesComm.H" |
char* SpComm_CoordinatedReceive( |
SpComm_CoordinatedSend | #include "SpeedesComm.H" |
void SpComm_CoordinatedSend( |
SpComm_CoordinatedSend | #include "SpeedesComm.H" |
void SpComm_CoordinatedSend( |
SpComm_CoordinatedSend | #include "SpeedesComm.H" |
void SpComm_CoordinatedSend( |
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. |
SpComm_EnterFuzzyBarrier | #include "SpeedesComm.H" |
void SpComm_EnterFuzzyBarrier() ; |
Returns when all nodes make this call. |
SpComm_ExitFuzzyBarrier | #include "SpeedesComm.H" |
int SpComm_ExitFuzzyBarrier() ; |
Returns right away (non-blocking). |
SpComm_GetNodeId | #include "SpeedesComm.H" |
int SpComm_GetNodeId() ; |
Returns the number of nodes. |
SpComm_GetNumNodes | #include "SpeedesComm.H" |
int SpComm_GetNumNodes() ; |
Returns the number of nodes and the local node id. |
SpComm_GetPendingMessage | #include "SpeedesComm.H" |
char* SpComm_GetPendingMessage( |
SpComm_GlobalMax | #include "SpeedesComm.H" |
SIMTIME& SpComm_GlobalMax( |
Max of everyone's value. |
SpComm_GlobalMax | #include "SpeedesComm.H" |
double SpComm_GlobalMax( |
Max of everyone's value. |
|
SpComm_GlobalMax | #include "SpeedesComm.H" |
int SpComm_GlobalMax( |
Min of everyone's SimTime. |
|
SpComm_GlobalMin | #include "SpeedesComm.H" |
SIMTIME& SpComm_GlobalMin( |
Min of everyone's value. |
|
SpComm_GlobalMin | #include "SpeedesComm.H" |
double SpComm_GlobalMin( |
Min of everyone's value. |
|
SpComm_GlobalMin | #include "SpeedesComm.H" |
int SpComm_GlobalMin( |
Sum of everyone's value. |
|
SpComm_GlobalSum | #include "SpeedesComm.H" |
double SpComm_GlobalSum( |
Sum of everyone's value. |
|
SpComm_GlobalSum | #include "SpeedesComm.H" |
int SpComm_GlobalSum( |
Global Reductions combine values from each node. The operations include global sums, global minimums, and global maximums.The result is returned. |
|
SpComm_Receive | #include "SpeedesComm.H" |
void SpComm_Receive() ; |
SpComm_Receive | #include "SpeedesComm.H" |
char* SpComm_Receive( |
SpComm_Send | #include "SpeedesComm.H" |
void SpComm_Send( |
SpComm_Send | #include "SpeedesComm.H" |
void SpComm_Send( |
SpComm_Send | #include "SpeedesComm.H" |
void SpComm_Send( |
SpComm_StartUp | #include "SpeedesComm.H" |
int SpComm_StartUp( |
Start_Merc | #include "speedes_comm.H" |
void Start_Merc( |
b_sync | #include "speedes_comm.H" |
void b_sync() ; |
combine | #include "speedes_comm.H" |
int combine( |
comm_cleanup | #include "speedes_comm.H" |
void comm_cleanup() ; |
delete_C_HOLDER | #include "defunc.H" |
void delete_C_HOLDER( |
delete_EVENT_HANDLER_HOLDER_array | #include "EventHandlerHolder.H" |
void delete_EVENT_HANDLER_HOLDER_array( |
delete_EVENT_HANDLER_HOLDER_array_PTR | #include "EventHandlerHolder.H" |
void delete_EVENT_HANDLER_HOLDER_array_PTR( |
delete_EVENT_HANDLER_array | #include "EventHandler.H" |
void delete_EVENT_HANDLER_array( |
delete_EVENT_HANDLER_array_PTR | #include "EventHandler.H" |
void delete_EVENT_HANDLER_array_PTR( |
delete_FloatSemaphore_array | #include "Semaphore.H" |
void delete_FloatSemaphore_array( |
delete_FloatSemaphore_array_PTR | #include "Semaphore.H" |
void delete_FloatSemaphore_array_PTR( |
delete_IntegerSemaphore_array | #include "Semaphore.H" |
void delete_IntegerSemaphore_array( |
delete_IntegerSemaphore_array_PTR | #include "Semaphore.H" |
void delete_IntegerSemaphore_array_PTR( |
delete_LogicalSemaphore_array | #include "Semaphore.H" |
void delete_LogicalSemaphore_array( |
delete_LogicalSemaphore_array_PTR | #include "Semaphore.H" |
void delete_LogicalSemaphore_array_PTR( |
delete_RB_BINARY_TREE_array | #include "RB_BinaryTree.H" |
void delete_RB_BINARY_TREE_array( |
delete_RB_BINARY_TREE_array_PTR | #include "RB_BinaryTree.H" |
void delete_RB_BINARY_TREE_array_PTR( |
delete_RB_double_array | #include "state_variable.H" |
void delete_RB_double_array( |
delete_RB_double_array_PTR | #include "state_variable.H" |
void delete_RB_double_array_PTR( |
delete_RB_float_array | #include "state_variable.H" |
void delete_RB_float_array( |
delete_RB_float_array_PTR | #include "state_variable.H" |
void delete_RB_float_array_PTR( |
delete_RB_int_array | #include "state_variable.H" |
void delete_RB_int_array( |
delete_RB_int_array_PTR | #include "state_variable.H" |
void delete_RB_int_array_PTR( |
delete_RB_pointer_array | #include "state_variable.H" |
void delete_RB_pointer_array( |
delete_RB_pointer_array_PTR | #include "state_variable.H" |
void delete_RB_pointer_array_PTR( |
delete_RB_string_array | #include "state_variable.H" |
void delete_RB_string_array( |
delete_RB_string_array_PTR | #include "state_variable.H" |
void delete_RB_string_array_PTR( |
delete_Stack_array | #include "processTypes.H" |
void delete_Stack_array( |
delete_Stack_array_PTR | #include "processTypes.H" |
void delete_Stack_array_PTR( |
delete_char_array | #include "def_rbq.H" |
void delete_char_array( |
delete_char_array_PTR | #include "def_rbq.H" |
void delete_char_array_PTR( |
delete_double_array | #include "def_rbq.H" |
void delete_double_array( |
delete_double_array_PTR | #include "def_rbq.H" |
void delete_double_array_PTR( |
delete_float_array | #include "def_rbq.H" |
void delete_float_array( |
delete_float_array_PTR | #include "def_rbq.H" |
void delete_float_array_PTR( |
delete_int_array | #include "def_rbq.H" |
void delete_int_array( |
delete_int_array_PTR | #include "def_rbq.H" |
void delete_int_array_PTR( |
delete_single_EVENT_HANDLER | #include "EventHandler.H" |
void delete_single_EVENT_HANDLER( |
delete_single_EVENT_HANDLER_HOLDER | #include "EventHandlerHolder.H" |
void delete_single_EVENT_HANDLER_HOLDER( |
delete_single_EVENT_HANDLER_HOLDER_PTR | #include "EventHandlerHolder.H" |
void delete_single_EVENT_HANDLER_HOLDER_PTR( |
delete_single_EVENT_HANDLER_METHOD | #include "EventHandlerMethod.H" |
void delete_single_EVENT_HANDLER_METHOD( |
delete_single_EVENT_HANDLER_METHOD_PTR | #include "EventHandlerMethod.H" |
void delete_single_EVENT_HANDLER_METHOD_PTR( |
delete_single_EVENT_HANDLER_PTR | #include "EventHandler.H" |
void delete_single_EVENT_HANDLER_PTR( |
delete_single_EventHandlerElement | #include "Component.H" |
void delete_single_EventHandlerElement( |
delete_single_EventHandlerElement_PTR | #include "Component.H" |
void delete_single_EventHandlerElement_PTR( |
delete_single_FloatSemaphore | #include "Semaphore.H" |
void delete_single_FloatSemaphore( |
delete_single_FloatSemaphore_PTR | #include "Semaphore.H" |
void delete_single_FloatSemaphore_PTR( |
delete_single_FloatWaitingItem | #include "Semaphore.H" |
void delete_single_FloatWaitingItem( |
delete_single_FloatWaitingItem_PTR | #include "Semaphore.H" |
void delete_single_FloatWaitingItem_PTR( |
delete_single_IntegerSemaphore | #include "Semaphore.H" |
void delete_single_IntegerSemaphore( |
delete_single_IntegerSemaphore_PTR | #include "Semaphore.H" |
void delete_single_IntegerSemaphore_PTR( |
delete_single_IntegerWaitingItem | #include "Semaphore.H" |
void delete_single_IntegerWaitingItem( |
delete_single_IntegerWaitingItem_PTR | #include "Semaphore.H" |
void delete_single_IntegerWaitingItem_PTR( |
delete_single_LogicalSemaphore | #include "Semaphore.H" |
void delete_single_LogicalSemaphore( |
delete_single_LogicalSemaphore_PTR | #include "Semaphore.H" |
void delete_single_LogicalSemaphore_PTR( |
delete_single_RB_BINARY_TREE | #include "RB_BinaryTree.H" |
void delete_single_RB_BINARY_TREE( |
delete_single_RB_BINARY_TREE_PTR | #include "RB_BinaryTree.H" |
void delete_single_RB_BINARY_TREE_PTR( |
delete_single_RB_double | #include "state_variable.H" |
void delete_single_RB_double( |
delete_single_RB_double_PTR | #include "state_variable.H" |
void delete_single_RB_double_PTR( |
delete_single_RB_float | #include "state_variable.H" |
void delete_single_RB_float( |
delete_single_RB_float_PTR | #include "state_variable.H" |
void delete_single_RB_float_PTR( |
delete_single_RB_int | #include "state_variable.H" |
void delete_single_RB_int( |
delete_single_RB_int_PTR | #include "state_variable.H" |
void delete_single_RB_int_PTR( |
delete_single_RB_pointer | #include "state_variable.H" |
void delete_single_RB_pointer( |
delete_single_RB_pointer_PTR | #include "state_variable.H" |
void delete_single_RB_pointer_PTR( |
delete_single_RB_string | #include "state_variable.H" |
void delete_single_RB_string( |
delete_single_RB_string_PTR | #include "state_variable.H" |
void delete_single_RB_string_PTR( |
delete_single_SemaphoreWaitingItem | #include "Semaphore.H" |
void delete_single_SemaphoreWaitingItem( |
Rollback items. |
delete_single_SemaphoreWaitingItem_PTR | #include "Semaphore.H" |
void delete_single_SemaphoreWaitingItem_PTR( |
delete_single_SharedSemaphore | #include "Semaphore.H" |
void delete_single_SharedSemaphore( |
delete_single_SharedSemaphoreWaitingItem | #include "Semaphore.H" |
void delete_single_SharedSemaphoreWaitingItem( |
delete_single_SharedSemaphoreWaitingItem_PTR | #include "Semaphore.H" |
void delete_single_SharedSemaphoreWaitingItem_PTR( |
delete_single_SharedSemaphore_PTR | #include "Semaphore.H" |
void delete_single_SharedSemaphore_PTR( |
delete_single_Stack | #include "processTypes.H" |
void delete_single_Stack( |
delete_single_Stack_PTR | #include "processTypes.H" |
void delete_single_Stack_PTR( |
delete_single_char | #include "def_rbq.H" |
void delete_single_char( |
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. |
delete_single_char_PTR | #include "def_rbq.H" |
void delete_single_char_PTR( |
delete_single_double | #include "def_rbq.H" |
void delete_single_double( |
delete_single_double_PTR | #include "def_rbq.H" |
void delete_single_double_PTR( |
delete_single_float | #include "def_rbq.H" |
void delete_single_float( |
delete_single_float_PTR | #include "def_rbq.H" |
void delete_single_float_PTR( |
delete_single_int | #include "def_rbq.H" |
void delete_single_int( |
delete_single_int_PTR | #include "def_rbq.H" |
void delete_single_int_PTR( |
exit_all_other_nodes | #include "speedes_comm.H" |
void exit_all_other_nodes() ; |
f_subcube | #include "speedes_comm.H" |
void f_subcube( |
get_msg | #include "speedes_comm.H" |
int get_msg( |
get_n_nodes | #include "speedes_comm.H" |
int get_n_nodes() ; |
get_node | #include "speedes_comm.H" |
int get_node() ; |
give_buf | #include "speedes_comm.H" |
int give_buf( |
nb_check | #include "speedes_comm.H" |
int nb_check() ; |
nb_sync | #include "speedes_comm.H" |
void nb_sync() ; |
new_C_HOLDER | #include "defunc.H" |
C_HOLDER* new_C_HOLDER( |
...... SPEEDES utilities. |
new_EVENT_HANDLER_EVENT | #include "EventHandlerEvent.H" |
void* new_EVENT_HANDLER_EVENT( |
scombine | #include "speedes_comm.H" |
int scombine( |
scparam | #include "speedes_comm.H" |
void scparam( |
send_msg | #include "speedes_comm.H" |
int send_msg( |
send_msg_w | #include "speedes_comm.H" |
int send_msg_w( |
startup | #include "speedes_comm.H" |
void startup() ; |