Changeset 17053 for stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1/SimSharp-3.1.1/Core/Resources/PriorityResource.cs

Timestamp:

07/04/19 12:55:52 (5 years ago)

Author:

abeham

Message:

#2975: merged to stable

Location:

stable

Files:

• . (modified) (1 prop)
• HeuristicLab.ExtLibs (modified) (1 prop)
• HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1 (moved) (moved from stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11)
• HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1/SimSharp-3.1.1 (copied) (copied from stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11)
• HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1/SimSharp-3.1.1/Core/Resources/PriorityResource.cs (modified) (6 diffs)

stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1/SimSharp-3.1.1/Core/Resources/PriorityResource.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
@@ -21 +21 @@
 
 namespace SimSharp {
+  /// <summary>
+  /// A PriorityResource is similar to a <see cref="Resource"/>.
+  /// However, it enables prioritizing requests.
+  /// 
+  /// PriorityResource holds a fixed number of anonymous entities.
+  /// Requests are processed in order priority first, FIFO second.
+  /// Releases are processed in FIFO order (usually no simulation time passes for a Release).
+  /// </summary>
   public class PriorityResource {
 
@@ -29 +37 @@
     public int Remaining { get { return Capacity - InUse; } }
 
-    protected Environment Environment { get; private set; }
+    protected Simulation Environment { get; private set; }
 
-    protected SortedList<int, LinkedList<PriorityRequest>> RequestQueue { get; private set; }
+    protected SimplePriorityQueue<Request, double> RequestQueue { get; private set; }
     protected Queue<Release> ReleaseQueue { get; private set; }
     protected HashSet<Request> 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 PriorityResource(Environment environment, int capacity = 1) {
+    public PriorityResource(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<PriorityRequest>>();
+      RequestQueue = new SimplePriorityQueue<Request, double>();
       ReleaseQueue = new Queue<Release>();
       Users = new HashSet<Request>();
+      WhenAnyQueue = new List<Event>();
+      WhenFullQueue = new List<Event>();
+      WhenEmptyQueue = new List<Event>();
+      WhenChangeQueue = new List<Event>();
     }
 
-    public virtual PriorityRequest Request(int priority = 1) {
-      var request = new PriorityRequest(Environment, TriggerRelease, DisposeCallback, priority);
-      if (!RequestQueue.ContainsKey(priority))
-        RequestQueue.Add(priority, new LinkedList<PriorityRequest>());
-      RequestQueue[priority].AddLast(request);
+    public virtual Request Request(double priority = 1) {
+      var request = new Request(Environment, TriggerRelease, DisposeCallback);
+      RequestQueue.Enqueue(request, priority);
       TriggerRequest();
       return request;
     }
 
-    public virtual Release Release(PriorityRequest request) {
+    public virtual Release Release(Request request) {
       var release = new Release(Environment, request, TriggerRequest);
       ReleaseQueue.Enqueue(release);
@@ -60 +74 @@
     }
 
+    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 PriorityRequest;
+      var request = @event as Request;
       if (request != null) Release(request);
     }
@@ -73 +114 @@
 
     protected virtual void DoRelease(Release release) {
-      if (!Users.Remove(release.Request)) {
-        var prioRequest = release.Request as PriorityRequest;
-        if (prioRequest != null) {
-          var current = RequestQueue[prioRequest.Priority].First;
-          while (current != null && current.Value != release.Request)
-            current = current.Next;
-          if (current != null) RequestQueue[prioRequest.Priority].Remove(current);
-        }
-      }
+      if (!Users.Remove(release.Request))
+        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 cascade = false;
-        var requests = entry.Value;
-        while (requests.Count > 0) {
-          var req = requests.First.Value;
-          DoRequest(req);
-          if (req.IsTriggered) {
-            requests.RemoveFirst();
-          } else {
-            cascade = true;
-            break;
-          }
-        }
-        if (cascade) break;
+      while (RequestQueue.Count > 0) {
+        var request = RequestQueue.First;
+        DoRequest(request);
+        if (request.IsTriggered) {
+          RequestQueue.Dequeue();
+          TriggerWhenEmpty();
+          TriggerWhenChange();
+        } else break;
       }
     }
@@ -106 +134 @@
       while (ReleaseQueue.Count > 0) {
         var release = ReleaseQueue.Peek();
+        if (release.Request.IsAlive) {
+          if (!RequestQueue.TryRemove(release.Request))
+            throw new InvalidOperationException("Failed to cancel a request.");
+          release.Succeed();
+          ReleaseQueue.Dequeue();
+        }
         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();
+    }
   }
 }