Additional methods defined in TimeWarp

• void rollback(VTime) : this method is called by the object itself from the method recvEvent when the input queue reports that event being received is in the past. This method restores the appropriate state and sends out antimessages based on the recvTime of the event.
• void inputGcollect(VTime) : this function performs garbage collection on the input queue only. Garbage collection on the input queue only removes references to events from the queue -- it doesn't actually call delete on the enqueued events (as discussed in the section describing the inputQueue class).
• void stateGcollect(VTime) : same as void inputGcollect, but for the stateQ.
• void outputGcollect(VTime) : same as void inputGcollect, but for the outputQ.
• void recvEvent(BasicEvent *) : this is the method that other objects call if they want this object to receive an event. This method gets called by local simulation objects, and the CommManager on the object's LP.
• void setTimeWindow(VTime) : this method can be called from the LogicalProcess to set size of the ``bounded time window.'' Bounded time windows may be desirable for objects which produce many events in a short amount of time in order to avoid swamping the message system -- this is especially true during startup.
• bool withinTimeWindow() : this method is called by the LogicalProcess associated with this simulation object to see if the object is within the time window established for it.
• VTime calculateMin() : this method is called by the GVTManager to get this simulation object's estimate for GVT calculation.
• void coastForward(VTime timeRestored) : this method is used for state reconstruction after a rollback when using periodic state savings or adaptive state savings.
• virtual bool suppressMessageTest(BasicEvent* ) : this method is used to determine whether to send an event message or not. This method is invoked when there is a rollback, when lazy cancelation or any form of periodic state savings is being used.
• cancelMessagesAggressively(const VTime rollbackTime) : used during aggressive cancelation to dispatch negative messages for all positive messages with sendTimes greater than rollbackTime.
• fillEventInfo(BasicEvent* ) : used during lazy cancelation to fill in information needed to compare event messages, for determining lazy hits and misses.
• void sendEventUnconditionally(BasicEvent* eventToSend) : this method is used for sending out events to others/itself and is used for both positive and negative events. The event is dispatched without performing any checks such as lazy hits or misses.
• bool lazyCancel(BasicEvent* ) : this method is used during lazy cancelation to determine if a the same event message is generated after a rollback or not.
• bool suppressLazyMessages(BasicEvent* toSend) : this method is used during lazy cancelation to determine whether a regenerated event has to be sent or not.
• void moveMessagesToLazyCancelQueue(VTime) : this method is used to move all messages with send times greater than the VTime to the lazyQueue so that they can be used for doing the comparisons with the regenerated messages.

Here is the interface of the TimeWarp class :

template < class State > 
class TimeWarp : public BasicTimeWarp {
public:
  TimeWarp();
  virtual ~TimeWarp();

  void executeSimulation();
  void simulate();
  void saveState();  // Save our current state.
  int inputGcollect(VTime);
  virtual VTime stateGcollect(VTime);
  void outputGcollect(VTime);
  BasicEvent *getEvent();       // gets an event from the input queue

  void sendEvent(BasicEvent *); // put an event on the output queue
  void recvEvent(BasicEvent *); // how to handle incoming messages

  // this calls the application to execute its code for one simulation cycle
  void executeProcess() = 0;

  // the application overrides these two functions, if desired, to
  // contain code to be executed before and after simulation starts
  // and ends.
  void initialize() {};
  void finalize() {};

  // this method is for the LP to query whether or not we are within
  // our time window...
  bool withinTimeWindow();

  // this method allows our time window to be set.
  void setTimeWindow( VTime newWindow ){
    timeWindow = newWindow;
  };

  // this method returns the time of the earliest unexecuted event.
  VTime calculateMin(); 

  // returns this object's current simulation time
  VTime getLVT() const { return state.current->lVT; };

  // data structures for file access
  int numOutFiles;
  int numInFiles;
  FileQueue *outFileQ;
  FileQueue *inFileQ;

  STATE_MANAGER<State> state;

  enum MSGSUPPRESSION { NONE = 0,          // No Message Supression in effect.
		        LAZYCANCEL = 01,    // Lazy Cancellation Suppression.
		        COASTFORWARD = 02,  // Infrequent State Saving
			 	            // Suppression
		        LAZYAGGRCANCEL = 04 // For dynamic cancellation
  };

protected:
  // rollback to the time specified
  virtual void rollback(VTime);

  // Flag to determine when to suppress a message
  int suppressMessage; 

  // Method to determine whether to suppress the message or not 
  virtual bool suppressMessageTest(BasicEvent*);

  virtual bool suppressLazyMessages(BasicEvent*);

  // Queue used for lazy cancellation.
  OutputQueue lazyCancelQ;

  // Should we dispatch a message during lazy cancellation or not? 
  // basically was the comparision a "hit" or a "miss"
  bool lazyCancel(BasicEvent*);
  // Used to terminate the simulation on error - can pass in a string
  // describing the error

private:
  // this defines how far this object can execute into the future.
  VTime timeWindow;

  // increments each time we send an event to produce a unique id for 
  // events (the id, eventID tuple is unique)
  long long eventCounter;

  // handle to this object's LP, to access terminateSimulation
  LogicalProcess *lpHandle;

  // for statistical use only
  int rollbackCount;

  bool timingsNeeded;
  void coastForward(VTime );

  // Invoked during aggressive cancellation
  void cancelMessagesAggressively(const VTime );

  // Invoked during lazy cancellation
  void moveMessagesToLazyQueue(const VTime );

  // Used only during lazy cancellation
  void fillEventInfo(BasicEvent* );

  // Same as sendEvent() but here the event is sent out without performing
  // any checks.
  void sendEventUnconditionally(BasicEvent* );
};

// Since this is a template class,  we need the actual code everywhere we
// have the definitions...
#include "TimeWarp.cc"