Merge pull request #9 from NiceOneFox/T8_SimulateProgram

Close T8 simulate program

Author: NiceOneFox

backend/ServiceSimulation/Bll.Domain/Entities/Device.cs

@@ -5,4 +5,6 @@ public class Device
     public int DeviceId { get; set; }
     public bool IsWorking { get; set; }
     public Request? Request { get; set; }
+    public double Lambda { get; set; } = 5;
+    public double TimeOfDeviceWillBeFree { get; set; } = 0;
 }

backend/ServiceSimulation/Bll.Domain/Entities/DeviceManager.cs

@@ -10,9 +10,6 @@ public class DeviceManager : IDeviceManager
 
     private static readonly Random _random = new();
 
-    public double Lambda { get; set; }
-    public double TimeOfDeviceWillBeFree { get; set; }
-
     public DeviceManager(ITimeProvider time, IResults resultChannel)
     {
         _time = time;
@@ -26,22 +23,23 @@ public void TakeRequest(Request request, Device device)
             return;
         }
         device.Request = request;
+        device.IsWorking = true;
 
-        TimeOfDeviceWillBeFree = _time.Now +(-1.0 / Lambda) * Math.Log(_random.NextDouble());
-        //TODO COUNT TIME OF WORKING ON THAT REQUEST
+        device.TimeOfDeviceWillBeFree = _time.Now + (-1.0 / device.Lambda) * Math.Log(_random.NextDouble());
     }
 
     public bool FreeDevice(Device device)
     {
-        if (TimeOfDeviceWillBeFree <= _time.Now)
-        {
-            device.Request.EndTime = _time.Now;
+        device.Request.EndTime = _time.Now;
 
-            device.Request = null;
-            device.IsWorking = false;
+        _time.Now = device.Request.EndTime;
+
+        _resultChannel.Processed.Add(device.Request);
+
+
+        device.Request = null;
+        device.IsWorking = false;
 
-            // TODO COUNT THAT REQUEST WHICH IS END WORKING.
-        }
         return true;
     }
 }

backend/ServiceSimulation/Bll.Domain/Entities/Results.cs

@@ -7,4 +7,10 @@ public class Results : IResults
     public List<Request> Cancelled { get; set; } = new();
     public List<Request> Processed { get; set; } = new();
     public double ModelingTime { get; set; }
+    public int AmountOfGeneratedRequests { get; set; }
+    public int AmountOfServedRequest
+    {
+        get => Cancelled.Count + Processed.Count;
+        set { }
+    }
 }

backend/ServiceSimulation/Bll.Domain/Entities/Source.cs

@@ -5,4 +5,6 @@ public class Source
     public int SourceId { get; set; }
     public int Priority { get; set; }
     public int SerialNumber { get; set; }
+    public double TimeOfNextRequest { get; set; }
+    public double Lambda { get; set; } = 5;
 }

backend/ServiceSimulation/Bll.Domain/Entities/SourceManager.cs

@@ -4,22 +4,28 @@ namespace Bll.Domain.Entities;
 
 public class SourceManager : ISourceManager
 {
-    public ITimeProvider Time { get; set; }
-    public double TimeOfNextRequest { get; set; }
-    public double Lambda { get; set; }
+    private readonly ITimeProvider _time;
+
+    private readonly IResults _results;
 
     private static Random _random = new();
-    public SourceManager(ITimeProvider time)
+
+    public SourceManager(ITimeProvider time, IResults results)
     {
-        Time = time;
+        _time = time;
+        _results = results;
     }
 
     public Request GetNewRequest(Source source)
     {
-        TimeOfNextRequest += -(1.0 / Lambda) * Math.Log(_random.NextDouble());
-
-        var generatedRequest = new Request(source.SourceId, source.SerialNumber, TimeOfNextRequest, -1);
+        var generatedRequest = new Request(source.SourceId, source.SerialNumber, source.TimeOfNextRequest, -1);
+        
+        source.TimeOfNextRequest += -(1.0 / source.Lambda) * Math.Log(_random.NextDouble());
         source.SerialNumber++;
+        generatedRequest.SerialNumberOfSource = source.SerialNumber; // TODO REFACTOR? 
+
+        _time.Now = source.TimeOfNextRequest;
+        _results.AmountOfGeneratedRequests++;
 
         return generatedRequest;
     }

backend/ServiceSimulation/Bll.Domain/Entities/StandardBufferManager.cs

@@ -20,7 +20,6 @@ public StandardBufferManager(IResults resultChannel, ITimeProvider time)
 
     public void Add(Request request)
     {
-        _time.Now = 0.6;
         if (_requests.Count >= Capacity)
         {
             var removedRequest = _requests.Last();
@@ -33,17 +32,15 @@ public void Add(Request request)
         _requests.AddFirst(request);
     }
 
-    public Request? Get()
+    public Request Get()
     {
-        if (_requests.Count == 0)
-        {
-            return null; // TODO THROW EXCEPTION?
-        }
+        if (IsFree()) throw new ArgumentNullException("Buffer was empty"); // TODO template string for Ex
 
         var requestFromBuffer = _requests.Last();
         _requests.RemoveLast();
 
         return requestFromBuffer;
     }
 
+    public bool IsFree() => _requests.Count == 0;
 }

backend/ServiceSimulation/Bll.Domain/Interfaces/IBufferManager.cs

@@ -5,5 +5,6 @@ namespace Bll.Domain.Interfaces;
 public interface IBufferManager
 {
     void Add(Request request);
-    Request? Get();
+    Request Get();
+    bool IsFree();
 }

backend/ServiceSimulation/Bll.Domain/Interfaces/IChannel.cs

@@ -4,7 +4,9 @@ namespace Bll.Domain.Interfaces;
 
 public interface IResults
 {
-    public List<Request> Cancelled { get; set; }
-    public List<Request> Processed { get; set; }
+    List<Request> Cancelled { get; set; }
+    List<Request> Processed { get; set; }
     double ModelingTime { get; set; }
+    int AmountOfGeneratedRequests { get; set; }
+    int AmountOfServedRequest { get; set; }
 }

backend/ServiceSimulation/Bll.Domain/Interfaces/IResults.cs

@@ -10,30 +10,128 @@ public class SimulationService : ISimulationService
     private readonly ISourceManager _sourceManager;
     private readonly IDeviceManager _deviceManager;
     private readonly IBufferManagerFactory _bufferManagerFactory;
+    private readonly IResults _results;
 
-    public SimulationService(ISourceManager sourceManager, IDeviceManager deviceManager, IBufferManagerFactory bufferManagerFactory)
+    public SimulationService(ISourceManager sourceManager, IDeviceManager deviceManager, IBufferManagerFactory bufferManagerFactory, IResults results)
     {
         _sourceManager = sourceManager;
         _deviceManager = deviceManager;
         _bufferManagerFactory = bufferManagerFactory;
+        _results = results;
     }
 
     public void StartSimulation(InputParameters parameters)
     {
-        // TODO ALGORITHM OF CHOOSING REQUEST FROM SOURCE AND PUT IT ON DEVICE
-        var source = new Source();
-        var device = new Device();
+        List<Source> sources = new List<Source>(parameters.NumberOfSources);
+        List<Device> devices = new List<Device>(parameters.NumberOfDevices);
+
+        for (int i = 0; i < parameters.NumberOfSources; i++)
+        {
+            sources.Add(new Source()
+            {
+                SourceId = i,
+                SerialNumber = 0,
+                Lambda = parameters.Lambda,
+                Priority = 1,
+                TimeOfNextRequest = 0,
+            });
+        }
+
+        for (int i = 0; i < parameters.NumberOfDevices; i++)
+        {
+            devices.Add(new Device()
+            {
+                DeviceId = i,
+                IsWorking = false,
+                Lambda = parameters.Lambda,
+                Request = null,
+                TimeOfDeviceWillBeFree = 0,
+            });
+        }
 
         var bufferManager = _bufferManagerFactory.CreateBufferManager(parameters.SimulationType);
 
-        var request =_sourceManager.GetNewRequest(source);
+        foreach (var source in sources) // Generate first requests that generated by sources.
+        {
+            _sourceManager.GetNewRequest(source);
+        }
+
+        while (true)
+        {
+            if (_results.AmountOfGeneratedRequests >= parameters.AmountOfRequests &&
+                bufferManager.IsFree() &&
+                IsAllDevicesFree(devices))
+            {
+                break;
+            }
+            FindNextSpecialEvent(devices, sources, bufferManager, parameters);
+        }
+    }
+
+    private void FindNextSpecialEvent(List<Device> devices, List<Source> sources, IBufferManager bufferManager, InputParameters parameters)
+    {
+        double timeOfClosestRequestCome = double.MaxValue;
+        double timeOfClosestDeviceFree = double.MaxValue;
 
-        bufferManager.Add(request);
+        int indexOfRequestWithClosestTimeCome = -1;
+        for (int i = 0; i < sources.Count; i++)
+        {
+            if (_results.AmountOfGeneratedRequests >= parameters.AmountOfRequests) break;
+            if (sources[i].TimeOfNextRequest < timeOfClosestRequestCome)
+            {
+                timeOfClosestRequestCome = sources[i].TimeOfNextRequest;
+                indexOfRequestWithClosestTimeCome = i;
+            }
+        }
 
-        var requestFromBuffer = bufferManager.Get();
+        int indexOfDeviceWithClosestTimeFree = -1;
+        for (int i = 0; i < devices.Count; i++)
+        {
+            if (devices[i].IsWorking && devices[i].TimeOfDeviceWillBeFree < timeOfClosestDeviceFree)
+            {
+                timeOfClosestDeviceFree = devices[i].TimeOfDeviceWillBeFree;
+                indexOfDeviceWithClosestTimeFree = i;
+            }
+        }
 
-        if (requestFromBuffer == null) return;
+        if (timeOfClosestDeviceFree < timeOfClosestRequestCome)
+        {
+            _deviceManager.FreeDevice(devices[indexOfDeviceWithClosestTimeFree]);
+
+            // Take from buffer and put on device.
+            if (!bufferManager.IsFree())
+            {
+                _deviceManager.TakeRequest(bufferManager.Get(), devices[indexOfDeviceWithClosestTimeFree]);
+            }
+        }
+        else
+        {
+            // Take request on work or add to buffer.
+            if (_results.AmountOfGeneratedRequests >= parameters.AmountOfRequests) return;
+
+            var newRequestInSystem = _sourceManager.GetNewRequest(sources[indexOfRequestWithClosestTimeCome]);
+            // find out free device
+            bool wasFreeDevice = false;
+            foreach (var device in devices)
+            {
+                if (!device.IsWorking)
+                {
+                    _deviceManager.TakeRequest(newRequestInSystem, device);
+                    wasFreeDevice = true;
+                    break;
+                }
+            }
+
+            if (!wasFreeDevice)
+            {
+                // Add request to buffer if no free devices were found
+                bufferManager.Add(newRequestInSystem);
+            }
+        }
 
-        _deviceManager.TakeRequest(requestFromBuffer, device);
     }
+
+    public bool IsAllDevicesFree(List<Device> devices) =>
+        devices.Any(d => d.IsWorking);
+
 }