//EventDataCache m_edCache;
/// <summary>
/// Creates a new instance of the <see cref="T:LocalEventQueue"/> class.
/// </summary>
/// <param name="exec">The executive that this LocalEventQueue services.</param>
/// <param name="capacity">The capacity.</param>
/// <param name="eer">The <see cref="Highpoint.Sage.SimCore.ExecEventReceiver"/> that this LocalEventQueue manages callbacks into.</param>
public LocalEventQueue(IExecutive exec, int capacity, ExecEventReceiver eer)
{
m_exec = exec;
m_capacity = capacity;
m_eer = eer;
m_targetName = ((IHasName)m_eer.Target).Name;
m_dequeueHandler = Dequeue;
m_circQueue = new EventData[capacity];
for (int i = 0; i < capacity; i++)
{
m_circQueue[i] = new EventData();
}
//m_edCache = new EventDataCache(capacity);
m_head = 0;
m_tail = 0;
#if USING_CANNED_HEAP
m_heap = new Heap(Heap.HEAP_RULE.MinValue);
#endif
if (m_capacity < 1)
{
throw new ArgumentException("LocalEventQueue created with a negative or zero capacity - it must be positive!");
}
}
public _ExecEvent Take(ExecEventReceiver eer, DateTime when, object userData, long key, bool isDaemon)
{
if (m_head == m_tail)
{
// Queue is empty!
m_tail = m_numExecEvents;
m_head = 0;
m_numExecEvents *= 2;
m_execEventCache = new _ExecEvent[m_numExecEvents];
for (int i = m_head; i < m_tail; i++)
{
m_execEventCache[i] = new _ExecEvent();
}
}
_ExecEvent retval = m_execEventCache[m_head++];
if (m_head == m_numExecEvents)
{
m_head = 0;
}
retval.Eer = eer;
retval.Key = key;
retval.UserData = userData;
retval.When = when.Ticks;
retval.IsDaemon = isDaemon;
return(retval);
}
private void Model_Starting(IModel theModel)
{
ExecEventReceiver eer = new ExecEventReceiver(AdjustPriority);
DateTime when = theModel.Executive.Now + TimeSpan.FromMinutes(15);
theModel.Executive.RequestEvent(eer, when, 0.0, null, ExecEventType.Synchronous);
}
/// <summary>
/// Requests that the executive queue up an event to be serviced at a specific time and
/// priority.
/// </summary>
/// <param name="eer">The ExecEventReceiver callback that is to receive the callback.</param>
/// <param name="when">The date & time at which the callback is to be made.</param>
/// <param name="priority">The priority of the callback. This executive forces all priorities to zero.</param>
/// <param name="userData">Object data to be provided in the callback.</param>
/// <returns>
/// A code that can subsequently be used to identify the request, e.g. for removal.
/// </returns>
public long RequestEvent(ExecEventReceiver eer, DateTime when, double priority, object userData)
{
if (when < m_now)
{
if (!_ignoreCausalityViolations)
{
string who = eer.Target.GetType().FullName;
if (eer.Target is IHasName)
{
who = ((IHasName)eer.Target).Name;
}
string method = eer.Method.Name + "(...)";
string msg = string.Format("Executive was asked to service an event prior to current time. This is a causality violation. The call was made from {0}.{1}.", who, method);
//throw new ApplicationException(msg);
Console.WriteLine(msg);
}
else
{
when = m_now;
}
}
m_key++;
Enqueue(new _ExecEvent(eer, when, userData, m_key, false));
//Enqueue(m_execEventCache.Take(eer,when,userData,m_key));
return(m_key);
}
private void Executive_EventAboutToFire(long key, ExecEventReceiver eer, double priority, DateTime when, object userData, ExecEventType eventType)
{
string method = eer.Method.ToString();
method = method.Replace(",", ":");
m_logFile.WriteLine(when.ToString(CultureInfo.InvariantCulture) + ", " + priority + ", " + eer.Target + ", " + method + ", " +
(userData?.ToString() ?? "<null>") + ", " + eventType);
}
public _ExecEvent()
{
Eer = null;
When = 0L;
UserData = null;
Key = 0L;
IsDaemon = false;
}
public _ExecEvent(ExecEventReceiver eer, DateTime when, object userData, long key, bool isDaemon)
{
Eer = eer;
When = when.Ticks;
UserData = userData;
Key = key;
IsDaemon = isDaemon;
}
private void ScheduleMyResourceAction(IModel theModel)
{
ExecEventReceiver eer = new ExecEventReceiver(DoResourceAction);
DateTime when = theModel.Executive.Now + TimeSpan.FromMinutes(5.0);
double priority = 0.0;
ExecEventType eet = ExecEventType.Detachable;
theModel.Executive.RequestEvent(eer, when, priority, null, eet);
}
public void TestExecutiveUnRequestTarget()
{
IExecutive exec = ExecFactory.Instance.CreateExecutive();
DateTime now = DateTime.Now;
DateTime when;
double priority;
OtherTarget ot = null;
// initialize validation variables
m_error = false;
m_validateUnRequest = new ArrayList();
Debug.WriteLine("");
Debug.WriteLine("Start test TestExecutiveUnRequestTarget");
Debug.WriteLine("");
for (int i = 0; i < NUM_EVENTS; i++)
{
when = new DateTime(now.Ticks + m_random.Next());
priority = m_random.NextDouble();
Debug.WriteLine("Primary requesting event service " + i);
switch (i)
{
case 1:
case 2:
case 3:
case 5:
case 7:
case 11:
m_validateUnRequest.Add(i);
ot = new OtherTarget(m_validateUnRequest, m_error);
ExecEventReceiver eer = new ExecEventReceiver(ot.ExecEventRecieverUnRequestEventReceiver);
exec.RequestEvent(eer, when, priority, i, m_execEventType);
exec.UnRequestEvents(ot);
break;
default:
exec.RequestEvent(new ExecEventReceiver(this.ExecEventRecieverUnRequestEventReceiver), when, priority, i, m_execEventType);
break;
}
;
}
Debug.WriteLine("");
// AEL exec.UnRequestEvents(new OtherTarget(m_validateUnRequest, m_error));
exec.Start();
Debug.WriteLine("");
// test validation variable
Assert.IsTrue(!m_error, "Executive did fire a unrequested event");
Debug.WriteLine("");
}
public Recurrence(IExecutive exec, DateTime baseline, DateTime stopAfter, double priority)
{
NextOccurrence = baseline;
StopAfterDate = stopAfter;
Priority = priority;
Exec = exec;
Exec.ExecutiveStarted += new ExecutiveEvent(ScheduleNext);
UseDaemonEvents = stopAfter.Equals(DateTime.MaxValue);
Eer = new ExecEventReceiver(_Occurrence);
}
public Recurrence(IExecutive exec, DateTime baseline, int numberOfRecurrences, double priority)
{
NextOccurrence = baseline;
NumRecurrences = numberOfRecurrences;
Priority = priority;
Exec = exec;
Exec.ExecutiveStarted += new ExecutiveEvent(ScheduleNext);
UseDaemonEvents = numberOfRecurrences < 0;
Eer = new ExecEventReceiver(_Occurrence);
}
public TupleTester()
{
m_exec = ExecFactory.Instance.CreateExecutive();
m_t = new DateTime(2004, 07, 15, 05, 23, 14);
m_postIt = new ExecEventReceiver(PostTuple);
m_readIt = new ExecEventReceiver(ReadTuple);
m_takeIt = new ExecEventReceiver(TakeTuple);
m_blockingPostIt = new ExecEventReceiver(BlockingPostTuple);
m_blockingReadIt = new ExecEventReceiver(BlockingReadTuple);
m_blockingTakeIt = new ExecEventReceiver(BlockingTakeTuple);
m_blockTilGone = new ExecEventReceiver(BlockTilGoneTuple);
}
/// <summary>
/// Abstract base class constructor for the Metronome_Base class.
/// </summary>
/// <param name="exec">The executive that will be serving the events.</param>
/// <param name="startAt">The start time for the event train.</param>
/// <param name="finishAfter">The end time for the event train.</param>
/// <param name="period">The periodicity of the event train.</param>
protected MetronomeBase(IExecutive exec, DateTime startAt, DateTime finishAfter, TimeSpan period)
{
m_startAt = startAt;
m_finishAfter = finishAfter;
m_period = period;
m_executive = exec;
m_autoFinish = false;
m_autoStart = false;
m_execEvent = OnExecEvent;
TotalTicksExpected = (int)((m_finishAfter.Ticks - m_startAt.Ticks) / m_period.Ticks);
m_executive.ExecutiveStarted += m_executive_ExecutiveStarted;
}
/// <summary>
/// Abstract base class constructor for the Metronome_Base class. Assumes both autostart
/// and autofinish for this metronome.
/// </summary>
/// <param name="exec">The executive that will be serving the events.</param>
/// <param name="period">The periodicity of the event train.</param>
protected MetronomeBase(IExecutive exec, TimeSpan period)
{
m_startAt = DateTime.MinValue;
m_finishAfter = DateTime.MaxValue;
m_period = period;
m_executive = exec;
m_autoFinish = true;
m_autoStart = true;
m_execEvent = OnExecEvent;
m_executive.EventAboutToFire += m_executive_EventAboutToFire;
TotalTicksExpected = int.MaxValue;
}
private void AcqireResource(IModel theModel)
{
Console.WriteLine("Acquiring the resource at " + theModel.Executive.Now);
m_rscReq = new SimpleResourceRequest(1.0, m_smr);
m_smr.Acquire(m_rscReq, false);
ExecEventReceiver eer = new ExecEventReceiver(ReleaseResource);
DateTime when = theModel.Executive.Now + TimeSpan.FromMinutes(10.0);
double priority = 0.0;
ExecEventType eet = ExecEventType.Synchronous;
theModel.Executive.RequestEvent(eer, when, priority, null, eet);
}
/// <summary>
/// Creates a new instance of the <see cref="T:Ticker"/> class.
/// </summary>
/// <param name="model">The model in which this object runs.</param>
/// <param name="periodicity">The periodicity of the ticker.</param>
/// <param name="autoStart">if set to <c>true</c> the ticker will start automatically, immediately on model start, and cycle indefinitely.</param>
/// <param name="nPulses">The number of pulses to be served.</param>
public Ticker(IModel model, IPeriodicity periodicity, bool autoStart, long nPulses)
{
m_periodicity = periodicity;
m_model = model;
m_autoStart = autoStart;
m_nPulses = nPulses;
m_execEventReceiver = new ExecEventReceiver(OnExecEvent);
if (autoStart)
{
m_model.Starting += new ModelEvent(OnModelStarting);
}
m_model.Stopping += new ModelEvent(OnModelStopping);
}
/// <summary>
/// Creates a channel for which the transit rate is fixed, and which can hold a specified
/// capacity of payload.
/// </summary>
/// <param name="model">The model in which this FixedRateChannel exists.</param>
/// <param name="name">The name of this FixedRateChannel.</param>
/// <param name="guid">The GUID of this FixedRateChannel.</param>
/// <param name="exec">The executive that controls this channel.</param>
/// <param name="transitPeriod">How long it takes an object to transit the channel.</param>
/// <param name="capacity">How many objects the channel can hold.</param>
public FixedRateChannel(IModel model, string name, Guid guid, IExecutive exec, TimeSpan transitPeriod, double capacity)
{
m_exec = exec;
m_transitPeriod = transitPeriod;
m_capacity = capacity;
m_entryPeriod = TimeSpan.FromTicks((long)((double)m_transitPeriod.Ticks / m_capacity));
m_queue = new Queue();
m_entry = new SimpleInputPort(model, "Entry", Guid.NewGuid(), this, new DataArrivalHandler(OnEntryAttempted));
m_exit = new SimpleOutputPort(model, "Exit", Guid.NewGuid(), this, new DataProvisionHandler(CantTakeFromChannel), new DataProvisionHandler(CantPeekFromChannel));
//m_ports.AddPort(m_entry); <-- Done in port's ctor.
//m_ports.AddPort(m_exit); <-- Done in port's ctor.
m_dequeueEventHandler = new ExecEventReceiver(DequeueEventHandler);
}
public PulseSource(IModel model, IPeriodicity periodicity, bool initialPulse)
{
m_model = model;
m_periodicity = periodicity;
m_initialPulse = initialPulse;
m_doPulse = new ExecEventReceiver(DoPulse);
if (m_model.Executive.State.Equals(ExecState.Stopped) || m_model.Executive.State.Equals(ExecState.Finished))
{
m_model.Executive.ExecutiveStarted += new ExecutiveEvent(StartPulsing);
}
else
{
StartPulsing(model.Executive);
}
}
private MultiChannelDelayServer(IModel model, string name, Guid guid)
{
InitializeIdentity(model, name, null, guid);
m_entryPort = new SimpleInputPort(model, "Input", Guid.NewGuid(), this, new DataArrivalHandler(OnDataArrived));
m_exitPort = new SimpleOutputPort(model, "Output", Guid.NewGuid(), this, null, null); // No take, no peek.
// AddPort(m_entryPort); <-- Done in port's ctor.
// AddPort(m_exitPort); <-- Done in port's ctor.
m_releaseObject = new ExecEventReceiver(ReleaseObject);
m_inService = new ArrayList();
m_pending = 0;
IMOHelper.RegisterWithModel(this);
}
public bool SelectThisEvent(ExecEventReceiver eer, DateTime when, double priority, object userData,
ExecEventType eet)
{
return(eer.Target != null && eer.Target.GetType() == m_targetType);
}
private void m_executive_EventAboutToFire(long key, ExecEventReceiver eer, double priority, DateTime when, object userData, ExecEventType eventType)
{
m_executive.RequestEvent(m_execEvent, when, priority + double.Epsilon, null);
m_executive.EventAboutToFire -= m_executive_EventAboutToFire;
}
/// <summary>
/// Requests that the executive queue up an event to be serviced at a specific time and
/// priority.
/// </summary>
/// <param name="eer">The ExecEventReceiver callback that is to receive the callback.</param>
/// <param name="when">The date & time at which the callback is to be made.</param>
/// <param name="priority">The priority of the callback. This executive forces all priorities to zero.</param>
/// <param name="userData">Object data to be provided in the callback.</param>
/// <param name="execEventType">The way the event is to be served by the executive.</param>
/// <returns>
/// A code that can subsequently be used to identify the request, e.g. for removal.
/// </returns>
long IExecutive.RequestEvent(ExecEventReceiver eer, DateTime when, double priority, object userData, ExecEventType execEventType)
{
//if ( !execEventType.Equals(ExecEventType.Synchronous) ) throw new ApplicationException("This high performance exec can currently only handler synchronous events.");
return(RequestEvent(eer, when, priority, userData));
}
public void Kickoff(long key, ExecEventReceiver eer, double priority, DateTime when, object userData, ExecEventType eventType)
{
m_exec.EventAboutToFire -= Kickoff;
m_parent.Begin(m_parent.m_executive, m_parent.m_userData);
}
/// <summary>
/// Requests that the executive queue up an event to be serviced at the current executive time and
/// priority.
/// </summary>
/// <param name="eer">The ExecEventReceiver callback that is to receive the callback.</param>
/// <param name="userData">Object data to be provided in the callback.</param>
/// <param name="eet">The EventType that declares how the event is to be served by the executive.</param>
/// <returns>A code that can subsequently be used to identify the request, e.g. for removal.</returns>
public long RequestImmediateEvent(ExecEventReceiver eer, object userData, ExecEventType eet)
{
throw new NotSupportedException("The selected executive type does not support contemporaneous enqueueing.");
}
/// <summary>
/// Requests that the executive queue up an event to be serviced at a specific time. Priority is assumed
/// to be zero.
/// </summary>
/// <param name="eer">The ExecEventReceiver callback that is to receive the callback.</param>
/// <param name="when">The date & time at which the callback is to be made.</param>
/// <param name="userData">Object data to be provided in the callback.</param>
/// <returns>
/// A code that can subsequently be used to identify the request, e.g. for removal.
/// </returns>
public long RequestEvent(ExecEventReceiver eer, DateTime when, object userData)
{
return(RequestEvent(eer, when, 0.0, userData));
}
/// <summary>
/// Requests that the executive queue up an event to be serviced at a specific time. Priority is assumed
/// to be zero, and the userData object is assumed to be null.
/// </summary>
/// <param name="eer">The ExecEventReceiver callback that is to receive the callback.</param>
/// <param name="when">The date & time at which the callback is to be made.</param>
/// <returns>
/// A code that can subsequently be used to identify the request, e.g. for removal.
/// </returns>
public long RequestEvent(ExecEventReceiver eer, DateTime when)
{
return(RequestEvent(eer, when, 0.0, null));
}