/// <summary> /// Creates a synchronization between two or more vertices, where the vertices /// are, once all are able to fire, fired in the order specified in the 'vertices' /// array. /// </summary> /// <param name="exec">The executive in whose simulation this VS is currently running.</param> /// <param name="vertices">An array of vertices to be synchronized.</param> /// <param name="vertexFiringType">The type of ExecEvent that successor edges to this vertex /// should be called with.</param> public VertexSynchronizer(IExecutive exec, Vertex[] vertices, ExecEventType vertexFiringType) { m_vertices = vertices; m_exec = exec; m_eventType = vertexFiringType; //Trace.Write("CREATING SYNCHRONIZER WITH TASKS ( " ); foreach (Vertex vertex in m_vertices) { if (vertex.PrincipalEdge is Tasks.Task) { ((Tasks.Task)vertex.PrincipalEdge).SelfValidState = false; } } foreach (Vertex vertex in m_vertices) { //Trace.Write(vertex.Name + ", "); if (vertex.Role.Equals(Vertex.WhichVertex.Post)) { throw new ApplicationException("Cannot synchronize postVertices at this time."); } else { vertex.SetSynchronizer(this); } } //_Debug.WriteLine(" )"); }
public void TestEventJoinDetachable() { IExecutive exec1 = ExecFactory.Instance.CreateExecutive("Highpoint.Sage.SimCore.Executive", Guid.NewGuid()); DateTime setupTime = new DateTime(2008, 11, 24, 12, 15, 44); ExecEventType eet = ExecEventType.Detachable; // Don't change this one. Join must be done on a detachable event. exec1.RequestEvent(new ExecEventReceiver(JoinDetachableSetup), setupTime, 0.0, null, eet); exec1.Start(); }
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 virtual void DeserializeFrom(XmlSerializationContext xmlsc) { m_model = (Model)xmlsc.ContextEntities["Model"]; m_eet = (ExecEventType)xmlsc.LoadObject("ExecEventType"); m_guid = (Guid)xmlsc.LoadObject("Guid"); m_keepGraphContexts = (bool)xmlsc.LoadObject("KeepGCs"); m_masterTask = (Task)xmlsc.LoadObject("MasterTask"); m_name = (string)xmlsc.LoadObject("Name"); m_startConditionsSpecified = (bool)xmlsc.LoadObject("StartCondSpec"); m_when = (DateTime)xmlsc.LoadObject("When"); }
public TaskProcessor(IModel model, string name, Guid guid, Task task) { InitializeIdentity(model, name, null, guid); m_masterTask = task; m_priority = 0.0; m_when = DateTime.MinValue; m_eet = ExecEventType.Synchronous; Model.GetService <ITaskManagementService>().AddTaskProcessor(this); IMOHelper.RegisterWithModel(this); }
public virtual void DeserializeFrom(XmlSerializationContext xmlsc) { // TODO: Add Vertex.DeserializeFrom implementation m_exec = ((Model)xmlsc.ContextEntities["Model"]).Executive; m_eventType = (ExecEventType)xmlsc.LoadObject("EventType"); int vertexCount = (int)xmlsc.LoadObject("VertexCount"); m_vertices = new Vertex[vertexCount]; //for ( int i = 0 ; i < vertexCount ; i++ ) { throw new NotImplementedException("Vertex deserialization not yet implemented in VertexSynchronizers."); //} }
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); }
private void FireTheVertex(IDictionary graphContext) { if (m_model.Executive.Now < m_earliest) { TimeSpan ts = (m_earliest - m_model.Executive.Now); // _Debug.WriteLine(m_model.Executive.Now + " : " + "Will fire vertex " + m_vertex.Name + " after a delay of " + string.Format("{0:d2}:{1:d2}:{2:d2}",ts.Hours,ts.Minutes,ts.Seconds)); ExecEventType eet = m_model.Executive.CurrentEventType; m_model.Executive.RequestEvent(new ExecEventReceiver(_FireTheVertex), m_earliest, 0, graphContext, eet); } else { // _Debug.WriteLine(m_model.Executive.Now + " : " + "Firing vertex " + m_vertex.Name); m_vertexTrigger(graphContext); } }
private void JoinDetachableSetup(IExecutive exec, object userData) { DateTime[] whens = new DateTime[3]; whens[0] = new DateTime(2008, 11, 25, 12, 15, 44); whens[1] = new DateTime(2008, 11, 26, 12, 15, 44); whens[2] = new DateTime(2008, 11, 27, 12, 15, 44); List <long> eventKeys = new List <long>(); ExecEventType eet = ExecEventType.Synchronous; for (int i = 0; i < 3; i++) { if (eet == ExecEventType.Synchronous) { eventKeys.Add(exec.RequestEvent(new ExecEventReceiver(DoItWithoutSuspension), whens[i], 0.0, null, eet)); } else if (eet == ExecEventType.Detachable) { eventKeys.Add(exec.RequestEvent(new ExecEventReceiver(DoItWithSuspension), whens[i], 0.0, null, eet)); } } Console.WriteLine(exec.Now + " : Waiting to join."); exec.Join(eventKeys.ToArray()); Console.WriteLine(exec.Now + " : Done waiting to join."); }
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; }
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); }
/// <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)); }
/// <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."); }
public void SetStartEventType(ExecEventType eet) { m_eet = eet; }
public void SetConfigData(DateTime when, ExecEventType eet, double priority) { SetStartTime(when); SetStartEventType(eet); SetStartEventPriority(priority); }
public bool SelectThisEvent(ExecEventReceiver eer, DateTime when, double priority, object userData, ExecEventType eet) { return(eer.Target != null && eer.Target.GetType() == m_targetType); }
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); }