Changeset 16779 for trunk/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1/SimSharp-3.1.1/Core/Resources/PreemptiveResource.cs

Timestamp:

04/12/19 13:45:11 (5 years ago)

Author:

abeham

Message:

#2975: Updated Sim# to 3.1.1

Location:

trunk/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1

Files:

• . (moved) (moved from trunk/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11)
• SimSharp-3.1.1 (copied) (copied from trunk/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11)
• SimSharp-3.1.1/Core/Resources/PreemptiveResource.cs (modified) (7 diffs)

trunk/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1/SimSharp-3.1.1/Core/Resources/PreemptiveResource.cs

@@ -1 +1 @@
 #region License Information
 /* SimSharp - A .NET port of SimPy, discrete event simulation framework
-Copyright (C) 2016  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+Copyright (C) 2019  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 
 This program is free software: you can redistribute it and/or modify
@@ -22 +22 @@
 
 namespace SimSharp {
+  /// <summary>
+  /// A PreemptiveResource is similar to a <see cref="PriorityResource"/>. However,
+  /// it may be possible to interrupt a lower-priority user and hand over the resource.
+  /// 
+  /// PreemptiveResource holds a fixed amount of anonymous entities.
+  /// Requests are processed in this order: priority, time, preemption, and finally FIFO.
+  /// Releases are processed in FIFO order (usually no simulation time passes for a Release).
+  /// </summary>
+  /// <remarks>
+  /// Working with PreemptiveResource, a process holding a request must always call
+  /// <see cref="Process.HandleFault"/> after yielding an event and handle a potential
+  /// interruption.
+  /// </remarks>
   public class PreemptiveResource {
 
@@ -30 +43 @@
     public int Remaining { get { return Capacity - InUse; } }
 
-    protected Environment Environment { get; private set; }
-
-    protected SortedList<int, LinkedList<PreemptiveRequest>> RequestQueue { get; private set; }
+    protected Simulation Environment { get; private set; }
+
+    protected SimplePriorityQueue<PreemptiveRequest> RequestQueue { get; private set; }
     protected Queue<Release> ReleaseQueue { get; private set; }
-    protected HashSet<Request> Users { get; private set; }
-
-    public PreemptiveResource(Environment environment, int capacity = 1) {
+    protected HashSet<PreemptiveRequest> Users { get; private set; }
+    protected List<Event> WhenAnyQueue { get; private set; }
+    protected List<Event> WhenFullQueue { get; private set; }
+    protected List<Event> WhenEmptyQueue { get; private set; }
+    protected List<Event> WhenChangeQueue { get; private set; }
+
+    public PreemptiveResource(Simulation environment, int capacity = 1) {
       if (capacity <= 0) throw new ArgumentException("Capacity must be > 0.", "capacity");
       Environment = environment;
       Capacity = capacity;
-      RequestQueue = new SortedList<int, LinkedList<PreemptiveRequest>>();
+      RequestQueue = new SimplePriorityQueue<PreemptiveRequest>();
       ReleaseQueue = new Queue<Release>();
-      Users = new HashSet<Request>();
-    }
-
-    public virtual PreemptiveRequest Request(int priority = 1, bool preempt = false) {
+      Users = new HashSet<PreemptiveRequest>();
+      WhenAnyQueue = new List<Event>();
+      WhenFullQueue = new List<Event>();
+      WhenEmptyQueue = new List<Event>();
+      WhenChangeQueue = new List<Event>();
+    }
+
+    public virtual PreemptiveRequest Request(double priority = 1, bool preempt = false) {
       var request = new PreemptiveRequest(Environment, TriggerRelease, DisposeCallback, priority, preempt);
-      if (!RequestQueue.ContainsKey(request.Priority))
-        RequestQueue.Add(request.Priority, new LinkedList<PreemptiveRequest>());
-      RequestQueue[request.Priority].AddLast(request);
+      RequestQueue.Enqueue(request);
       TriggerRequest();
       return request;
@@ -61 +80 @@
     }
 
+    public virtual Event WhenAny() {
+      var whenAny = new Event(Environment);
+      WhenAnyQueue.Add(whenAny);
+      TriggerWhenAny();
+      return whenAny;
+    }
+
+    public virtual Event WhenFull() {
+      var whenFull = new Event(Environment);
+      WhenFullQueue.Add(whenFull);
+      TriggerWhenFull();
+      return whenFull;
+    }
+
+    public virtual Event WhenEmpty() {
+      var whenEmpty = new Event(Environment);
+      WhenEmptyQueue.Add(whenEmpty);
+      TriggerWhenEmpty();
+      return whenEmpty;
+    }
+
+    public virtual Event WhenChange() {
+      var whenChange = new Event(Environment);
+      WhenChangeQueue.Add(whenChange);
+      return whenChange;
+    }
+
     protected void DisposeCallback(Event @event) {
       var request = @event as PreemptiveRequest;
@@ -69 +115 @@
       if (Users.Count >= Capacity && request.Preempt) {
         // Check if we can preempt another process
-        var oldest = Users.OfType<PreemptiveRequest>().Select((r, i) => new { Request = r, Index = i })
-          .OrderByDescending(x => x.Request.Priority)
-          .ThenByDescending(x => x.Request.Time)
-          .ThenByDescending(x => x.Request.Preempt)
-          .ThenByDescending(x => x.Index)
-          .First().Request;
-        if (oldest.Priority > request.Priority || (oldest.Priority == request.Priority
-            && (!oldest.Preempt && request.Preempt || (oldest.Preempt == request.Preempt
-              && oldest.Time > request.Time)))) {
-          Users.Remove(oldest);
-          oldest.Process.Interrupt(new Preempted(request.Process, oldest.Time));
+        // MaxItems are the least important according to priorty, time, and preemption flag
+        var preempt = Users.MaxItems(x => x).Last();
+        if (preempt.CompareTo(request) > 0) {
+          preempt.IsPreempted = true;
+          Users.Remove(preempt);
+          preempt.Owner?.Interrupt(new Preempted(request.Owner, preempt.Time));
         }
       }
@@ -89 +130 @@
 
     protected virtual void DoRelease(Release release) {
-      if (!Users.Remove(release.Request)) {
-        var preemptRequest = release.Request as PreemptiveRequest;
-        if (preemptRequest != null) {
-          var current = RequestQueue[preemptRequest.Priority].First;
-          while (current != null && current.Value != release.Request)
-            current = current.Next;
-          if (current != null) RequestQueue[preemptRequest.Priority].Remove(current);
-        }
-      }
+      var req = (PreemptiveRequest)release.Request;
+      if (!Users.Remove(req) && !req.IsPreempted)
+        throw new InvalidOperationException("Released request does not have a user.");
       release.Succeed();
     }
 
     protected virtual void TriggerRequest(Event @event = null) {
-      foreach (var entry in RequestQueue) {
-        var requests = entry.Value;
-        var current = requests.First;
-        while (current != null) {
-          var request = current.Value;
-          DoRequest(request);
-          if (request.IsTriggered) {
-            var next = current.Next;
-            requests.Remove(current);
-            current = next;
-          } else current = current.Next;
-        }
+      while (RequestQueue.Count > 0) {
+        var request = RequestQueue.First;
+        DoRequest(request);
+        if (request.IsTriggered) {
+          RequestQueue.Dequeue();
+          TriggerWhenEmpty();
+          TriggerWhenChange();
+        } else break;
       }
     }
@@ -120 +151 @@
       while (ReleaseQueue.Count > 0) {
         var release = ReleaseQueue.Peek();
-        DoRelease(release);
-        if (release.IsTriggered) {
+        if (release.Request.IsAlive) {
+          if (!RequestQueue.TryRemove((PreemptiveRequest)release.Request))
+            throw new InvalidOperationException("Failed to cancel a request.");
+          release.Succeed();
           ReleaseQueue.Dequeue();
-        } else break;
-      }
+        } else {
+          DoRelease(release);
+          if (release.IsTriggered) {
+            ReleaseQueue.Dequeue();
+            TriggerWhenAny();
+            TriggerWhenFull();
+            TriggerWhenChange();
+          } else break;
+        }
+      }
+    }
+
+    protected virtual void TriggerWhenAny() {
+      if (Remaining > 0) {
+        if (WhenAnyQueue.Count == 0) return;
+        foreach (var evt in WhenAnyQueue)
+          evt.Succeed();
+        WhenAnyQueue.Clear();
+      }
+    }
+
+    protected virtual void TriggerWhenFull() {
+      if (InUse == 0) {
+        if (WhenFullQueue.Count == 0) return;
+        foreach (var evt in WhenFullQueue)
+          evt.Succeed();
+        WhenFullQueue.Clear();
+      }
+    }
+
+    protected virtual void TriggerWhenEmpty() {
+      if (Remaining == 0) {
+        if (WhenEmptyQueue.Count == 0) return;
+        foreach (var evt in WhenEmptyQueue)
+          evt.Succeed();
+        WhenEmptyQueue.Clear();
+      }
+    }
+
+    protected virtual void TriggerWhenChange() {
+      if (WhenChangeQueue.Count == 0) return;
+      foreach (var evt in WhenChangeQueue)
+        evt.Succeed();
+      WhenChangeQueue.Clear();
     }
   }