most-queue 2.6__py3-none-any.whl → 2.7__py3-none-any.whl

most_queue/sim/base.py

@@ -4,13 +4,14 @@ Simulation model of QS GI/G/n/r and GI/G/n
 
 import time
 
-import numpy as np
 from colorama import Fore, Style, init
 from tqdm import tqdm
 
 from most_queue.constants import DEFAULT_NUM_STATES
 from most_queue.random.utils.create import create_distribution
 from most_queue.random.utils.load import calc_qs_load
+from most_queue.sim.base_core import BaseSimulationCore
+from most_queue.sim.utils.events import EventScheduler
 from most_queue.sim.utils.qs_queue import QsQueueDeque, QsQueueList
 from most_queue.sim.utils.servers import Server
 from most_queue.sim.utils.stats_update import refresh_moments_stat
@@ -20,7 +21,7 @@ from most_queue.structs import QueueResults
 init()
 
 
-class QsSim:
+class QsSim(BaseSimulationCore):
     """
     Base class for Queueing System Simulator
     """
@@ -33,22 +34,19 @@ class QsSim:
         :param verbose: bool : whether to print detailed information during simulation
         :param buffer_type: str : type of the buffer, "list" or "deque"
         """
+        super().__init__()
+
         self.n = num_of_channels
         self.buffer = buffer
         self.verbose = verbose
 
-        self.generator = np.random.default_rng()
-
         self.free_channels = self.n
         self.num_of_states = DEFAULT_NUM_STATES
         self.load = 0  # utilization factor
 
         # to track the length of the continuous channel occupancy period:
         self.start_busy = 0
-        self.busy = [0, 0, 0]
-        self.busy_moments = 0
 
-        self.ttek = 0  # current simulation time
         self.total = 0
 
         self.w = [0, 0, 0, 0]  # raw moments of waiting time in the QS
@@ -85,18 +83,14 @@ class QsSim:
         self.is_set_source_params = False
         self.is_set_server_params = False
 
-        self.time_spent = 0
-
         self.zero_wait_arrivals_num = 0
 
-        # Cache for server with minimum time
-        self._min_server_time = 1e16
-        self._min_server_idx = -1
-        self._servers_time_changed = True
-
         # Set of free server indices for O(1) access
         self._free_servers = set(range(self.n))
 
+        # Event scheduler for managing simulation events
+        self.event_scheduler = EventScheduler()
+
     def set_sources(self, params, kendall_notation: str = "M"):
         """
         Specifies the type and parameters of source time distribution.
@@ -139,7 +133,7 @@ class QsSim:
             )
             for _i in range(self.n)
         ]
-        self._servers_time_changed = True
+        self._mark_servers_time_changed()
         self._free_servers = set(range(self.n))
 
     def calc_load(self) -> float:
@@ -180,7 +174,7 @@ class QsSim:
             self.servers[server_idx].start_service(tsk, self.ttek, is_warm_start)
             self._free_servers.remove(server_idx)
             self.free_channels -= 1
-            self._servers_time_changed = True
+            self._mark_servers_time_changed()
 
             # Проверям, не наступил ли ПНЗ:
             if self.free_channels == 0:
@@ -199,6 +193,10 @@ class QsSim:
         if new_tsk is None:
             new_tsk = Task(self.ttek)
             new_tsk.start_waiting_time = self.ttek
+        else:
+            # If task already exists but start_waiting_time is not set, set it now
+            if new_tsk.start_waiting_time < 0:
+                new_tsk.start_waiting_time = self.ttek
 
         if self.buffer is None:  # queue length is not specified, i.e. infinite queue
 
@@ -220,11 +218,8 @@ class QsSim:
         """
 
         self.arrived += 1
-        # Ensure p array is large enough
-        if self.in_sys >= len(self.p):
-            # Extend p array if needed
-            self.p.extend([0.0] * (self.in_sys - len(self.p) + 1))
-        self.p[self.in_sys] += self.arrival_time - self.ttek
+        # Update state probabilities
+        self._update_state_probs(self.ttek, self.arrival_time, self.in_sys)
 
         if moment:
             self.ttek = moment
@@ -258,14 +253,11 @@ class QsSim:
         """
         time_to_end = self.servers[c].time_to_end_service
         end_ts = self.servers[c].end_service()
-        self._servers_time_changed = True
+        self._mark_servers_time_changed()
         self._free_servers.add(c)  # Server is now free
 
-        # Ensure p array is large enough
-        if self.in_sys >= len(self.p):
-            # Extend p array if needed
-            self.p.extend([0.0] * (self.in_sys - len(self.p) + 1))
-        self.p[self.in_sys] += time_to_end - self.ttek
+        # Update state probabilities
+        self._update_state_probs(self.ttek, time_to_end, self.in_sys)
 
         self.ttek = time_to_end
         self.served += 1
@@ -326,23 +318,154 @@ class QsSim:
             self._servers_time_changed = False
         return self._min_server_idx, self._min_server_time
 
-    def run_one_step(self) -> None:
+    def _update_state_probs(self, old_time: float, new_time: float, state: int):
         """
-        Execute one step of the simulation (either an arrival or service completion event).
+        Update state probabilities array.
+
+        Args:
+            old_time: Previous time
+            new_time: New time
+            state: Current system state
         """
+        # Ensure p array is large enough
+        while state >= len(self.p):
+            # Extend p array in chunks to avoid frequent reallocations
+            self.p.extend([0.0] * min(1000, max(1, len(self.p) // 10)))
+        self.p[state] += new_time - old_time
 
-        num_of_server_earlier, serv_earl = self._get_min_server_time()
+    # Hook methods for customization
+    def _before_arrival(self, moment: float = None, ts=None):
+        """
+        Hook called before arrival event is processed.
+        Override this to add custom logic before arrival.
 
-        # Global warm-up is set. Need to track
-        # including the moment of warm-up end
-        times = [serv_earl, self.arrival_time]
-        min_time_num = np.argmin(times)
-        if min_time_num == 0:
-            # Serving
-            self.serving(num_of_server_earlier)
-        else:
-            # Arrival
+        Args:
+            moment: Optional specific arrival moment
+            ts: Optional task object
+        """
+        # Override in subclasses if needed
+
+    def _after_arrival(self, moment: float = None, ts=None):
+        """
+        Hook called after arrival event is processed.
+        Override this to add custom logic after arrival.
+
+        Args:
+            moment: Optional specific arrival moment
+            ts: Optional task object
+        """
+        # Override in subclasses if needed
+
+    def _before_serving(self, channel: int, is_network: bool = False):
+        """
+        Hook called before serving event is processed.
+        Override this to add custom logic before serving.
+
+        Args:
+            channel: Channel number that completed service
+            is_network: Whether this is part of a network simulation
+        """
+        # Override in subclasses if needed
+
+    def _after_serving(self, channel: int, task=None, is_network: bool = False):
+        """
+        Hook called after serving event is processed.
+        Override this to add custom logic after serving.
+
+        Args:
+            channel: Channel number that completed service
+            task: Task that completed service
+            is_network: Whether this is part of a network simulation
+        """
+        # Override in subclasses if needed
+
+    def _get_custom_events(self):
+        """
+        Get custom events for this simulator.
+        Override this method to register custom event types.
+
+        Returns:
+            dict: Dictionary mapping event_type -> event_time
+        """
+        return {}
+
+    def _handle_custom_event(self, event_type: str):
+        """
+        Handle a custom event.
+        Override this method to process custom events.
+
+        Args:
+            event_type: Type of the custom event
+        """
+        raise NotImplementedError(f"Custom event '{event_type}' not handled")
+
+    def _get_available_events(self):
+        """
+        Collect all available events (arrival, serving, custom).
+        Returns dictionary of event_type -> event_time.
+        """
+        events = {}
+
+        # Standard arrival event
+        if hasattr(self, "arrival_time") and self.arrival_time < float("inf"):
+            events["arrival"] = self.arrival_time
+
+        # Standard serving event (next service completion)
+        server_idx, serv_time = self._get_min_server_time()
+        if server_idx >= 0 and serv_time < float("inf"):
+            events["serving"] = serv_time
+
+        # Custom events from subclass
+        custom_events = self._get_custom_events()
+        events.update(custom_events)
+
+        return events
+
+    def _select_next_event(self):
+        """
+        Select the next event to process based on minimum time.
+
+        Returns:
+            tuple: (event_type, event_time) or (None, None) if no events
+        """
+        events = self._get_available_events()
+        if not events:
+            return None, None
+
+        event_type = min(events.keys(), key=lambda k: events[k])
+        return event_type, events[event_type]
+
+    def _execute_event(self, event_type: str):
+        """
+        Execute the specified event.
+
+        Args:
+            event_type: Type of event to execute
+        """
+        if event_type == "arrival":
+            self._before_arrival()
             self.arrival()
+            self._after_arrival()
+        elif event_type == "serving":
+            server_idx, _ = self._get_min_server_time()
+            self._before_serving(server_idx)
+            task = self.serving(server_idx)
+            self._after_serving(server_idx, task)
+        else:
+            # Custom event
+            self._handle_custom_event(event_type)
+
+    def run_one_step(self) -> None:
+        """
+        Execute one step of the simulation using event-based approach.
+        Automatically handles arrival, serving, and custom events.
+        """
+        event_type, _event_time = self._select_next_event()
+
+        if event_type is None:
+            raise RuntimeError("No events available to process")
+
+        self._execute_event(event_type)
 
     def run(self, total_served: int) -> QueueResults:
         """
@@ -386,32 +509,41 @@ class QsSim:
 
         return QueueResults(v=v, w=w, p=p, duration=self.time_spent, utilization=self.calc_load())
 
-    def refresh_busy_stat(self, new_a: float) -> None:
+    def refresh_busy_stat(self, new_a: float, count: int = None) -> None:
         """
         Update statistics of the busy period.
 
         Args:
             new_a: New busy period duration to include in statistics.
+            count: Number of busy periods (if None, uses self.busy_moments)
         """
-        self.busy = refresh_moments_stat(self.busy, new_a, self.busy_moments)
+        if count is None:
+            count = self.busy_moments
+        super().refresh_busy_stat(new_a, count)
 
-    def refresh_v_stat(self, new_a: float) -> None:
+    def refresh_v_stat(self, new_a: float, count: int = None) -> None:
         """
         Update statistics of sojourn times.
 
         Args:
             new_a: New sojourn time value to include in statistics.
+            count: Number of served tasks (if None, uses self.served)
         """
-        self.v = refresh_moments_stat(self.v, new_a, self.served)
+        if count is None:
+            count = self.served
+        self.v = refresh_moments_stat(self.v, new_a, count)
 
-    def refresh_w_stat(self, new_a: float) -> None:
+    def refresh_w_stat(self, new_a: float, count: int = None) -> None:
         """
         Update statistics of wait times.
 
         Args:
             new_a: New waiting time value to include in statistics.
+            count: Number of taken tasks (if None, uses self.taked)
         """
-        self.w = refresh_moments_stat(self.w, new_a, self.taked)
+        if count is None:
+            count = self.taked
+        self.w = refresh_moments_stat(self.w, new_a, count)
 
     def get_p(self) -> list[float]:
         """

most_queue/sim/base_core.py

@@ -0,0 +1,89 @@
+"""
+Base simulation core with common functionality for all simulators
+"""
+
+import numpy as np
+
+from most_queue.sim.utils.stats_update import refresh_moments_stat
+
+
+class BaseSimulationCore:
+    """
+    Base class for queueing system simulators.
+    Contains common attributes and methods shared across different simulator types.
+    """
+
+    def __init__(self):
+        """Initialize the base simulation core."""
+        self.ttek = 0  # current simulation time
+        self.generator = np.random.default_rng()
+        self.time_spent = 0
+
+        # Statistics for busy periods
+        self.busy = [0, 0, 0]
+        self.busy_moments = 0
+
+        # Cache for server with minimum time
+        self._min_server_time = 1e16
+        self._min_server_idx = -1
+        self._servers_time_changed = True
+
+    def refresh_busy_stat(self, new_a: float, count: int = None) -> None:
+        """
+        Update statistics of the busy period.
+
+        Args:
+            new_a: New busy period duration to include in statistics.
+            count: Number of busy periods (if None, uses self.busy_moments)
+        """
+        if count is None:
+            count = self.busy_moments
+        self.busy = refresh_moments_stat(self.busy, new_a, count)
+
+    def refresh_v_stat(self, new_a: float, count: int = None) -> None:
+        """
+        Update statistics of sojourn times.
+
+        Args:
+            new_a: New sojourn time value to include in statistics.
+            count: Number of served tasks (if None, should be overridden by subclass)
+        """
+        # This is a placeholder - subclasses should override with proper count
+        # Initialize v if not exists
+        if not hasattr(self, "v"):
+            self.v = [0, 0, 0, 0]
+        if count is not None:
+            self.v = refresh_moments_stat(self.v, new_a, count)
+
+    def refresh_w_stat(self, new_a: float, count: int = None) -> None:
+        """
+        Update statistics of wait times.
+
+        Args:
+            new_a: New waiting time value to include in statistics.
+            count: Number of taken tasks (if None, should be overridden by subclass)
+        """
+        # This is a placeholder - subclasses should override with proper count
+        # Initialize w if not exists
+        if not hasattr(self, "w"):
+            self.w = [0, 0, 0, 0]
+        if count is not None:
+            self.w = refresh_moments_stat(self.w, new_a, count)
+
+    def _get_min_server_time(self):
+        """
+        Get server with minimum time to end service.
+        Uses caching to avoid O(n) search on every call.
+
+        This is a base implementation that should be overridden
+        if the simulator uses a different server structure.
+
+        Returns:
+            tuple: (server_index, min_time) or (-1, float('inf')) if no servers
+        """
+        # Base implementation - subclasses should override
+        return -1, float("inf")
+
+    def _mark_servers_time_changed(self):
+        """Mark that server times have changed and cache needs refresh."""
+        self._servers_time_changed = True

most_queue/sim/batch.py

@@ -61,7 +61,7 @@ class QueueingSystemBatchSim(QsSim):
             self.servers[server_idx].start_service(Task(ttek), ttek, False)
             self._free_servers.remove(server_idx)
             self.free_channels -= 1
-            self._servers_time_changed = True
+            self._mark_servers_time_changed()
 
             # Check if busy period has started:
             if self.free_channels == 0:
@@ -85,12 +85,8 @@ class QueueingSystemBatchSim(QsSim):
 
         for _tsk in range(batch_size):
             self.arrived += 1
-            # Ensure p array is large enough before accessing
-            # We need space for current in_sys and potentially more
-            while self.in_sys >= len(self.p):
-                # Extend p array in chunks to avoid frequent reallocations
-                self.p.extend([0.0] * min(1000, max(1, len(self.p) // 10)))
-            self.p[self.in_sys] += self.arrival_time - self.ttek
+            # Update state probabilities
+            self._update_state_probs(self.ttek, self.arrival_time, self.in_sys)
             self.in_sys += 1
 
             if self.free_channels == 0:

most_queue/sim/finite_source.py

@@ -73,7 +73,8 @@ class QueueingFiniteSourceSim(QsSim):
         """
 
         self.arrived += 1
-        self.p[self.in_sys] += self.arrival_times[self.arrived_num] - self.ttek
+        # Update state probabilities
+        self._update_state_probs(self.ttek, self.arrival_times[self.arrived_num], self.in_sys)
         self.sources_left -= 1
         self.in_sys += 1
         self.ttek = self.arrival_times[self.arrived_num]

most_queue/sim/fork_join.py

@@ -85,11 +85,8 @@ class ForkJoinSim(QsSim):
         """
 
         self.arrived += 1
-        # Ensure p array is large enough
-        while self.in_sys >= len(self.p):
-            # Extend p array in chunks to avoid frequent reallocations
-            self.p.extend([0.0] * min(1000, max(1, len(self.p) // 10)))
-        self.p[self.in_sys] += self.arrival_time - self.ttek
+        # Update state probabilities
+        self._update_state_probs(self.ttek, self.arrival_time, self.in_sys)
         self.ttek = self.arrival_time
         self.arrival_time = self.ttek + self.source.generate()
 
@@ -122,7 +119,7 @@ class ForkJoinSim(QsSim):
                             self.servers[i].start_service(t.subtasks[i], self.ttek)
                             self._free_servers.discard(i)
                             self.free_channels -= 1
-                            self._servers_time_changed = True
+                            self._mark_servers_time_changed()
                         else:
                             self.queues[i].append(t.subtasks[i])
 
@@ -189,14 +186,11 @@ class ForkJoinSim(QsSim):
         :param c: int : number of channel where service is completed.
         """
         time_to_end = self.servers[c].time_to_end_service
-        # Ensure p array is large enough
-        while self.in_sys >= len(self.p):
-            # Extend p array in chunks to avoid frequent reallocations
-            self.p.extend([0.0] * min(1000, max(1, len(self.p) // 10)))
-        self.p[self.in_sys] += time_to_end - self.ttek
+        # Update state probabilities
+        self._update_state_probs(self.ttek, time_to_end, self.in_sys)
         end_ts = self.servers[c].end_service()
         self._free_servers.add(c)  # Server is now free
-        self._servers_time_changed = True
+        self._mark_servers_time_changed()
         self.ttek = time_to_end
         self.served_subtask_in_task[end_ts.task_id] += 1
         self.total += 1

most_queue/sim/fork_join_delta.py

@@ -17,6 +17,13 @@ class ForkJoinSimDelta(ForkJoinSim):
     Simulation of ForkJoin queue with delta.
     """
 
+    def _handle_custom_event(self, event_type):
+        """
+        Handle custom events (none needed for this simulator).
+        """
+        # This simulator doesn't use custom events
+        raise NotImplementedError(f"Custom event '{event_type}' not supported by ForkJoinSimDelta")
+
     def __init__(
         self,
         num_of_channels,

most_queue/sim/impatient.py

@@ -52,17 +52,46 @@ class ImpatientQueueSim(QsSim):
 
         self.impatience = create_distribution(params, kendall_notation, self.generator)
 
+    def _get_custom_events(self):
+        """
+        Get custom events (impatient task drops).
+        """
+        events = {}
+        if self.queue.size() > 0:
+            min_leave_time = float("inf")
+            for tsk in self.queue.queue:
+                if tsk.moment_to_leave < min_leave_time:
+                    min_leave_time = tsk.moment_to_leave
+            if min_leave_time < float("inf"):
+                events["task_drop"] = min_leave_time
+        return events
+
+    def _handle_custom_event(self, event_type: str):
+        """
+        Handle custom events (impatient task drops).
+        """
+        if event_type == "task_drop":
+            # Find the task with minimum leave time
+            num_of_task_earlier = -1
+            moment_to_leave_earlier = float("inf")
+            for i, tsk in enumerate(self.queue.queue):
+                if tsk.moment_to_leave < moment_to_leave_earlier:
+                    moment_to_leave_earlier = tsk.moment_to_leave
+                    num_of_task_earlier = i
+
+            if num_of_task_earlier >= 0:
+                self.drop_task(num_of_task_earlier, moment_to_leave_earlier)
+        else:
+            super()._handle_custom_event(event_type)
+
     def arrival(self, moment=None, ts=None):
         """
         Actions on arrival of a task.
         """
 
         self.arrived += 1
-        # Ensure p array is large enough
-        while self.in_sys >= len(self.p):
-            # Extend p array in chunks to avoid frequent reallocations
-            self.p.extend([0.0] * min(1000, max(1, len(self.p) // 10)))
-        self.p[self.in_sys] += self.arrival_time - self.ttek
+        # Update state probabilities
+        self._update_state_probs(self.ttek, self.arrival_time, self.in_sys)
 
         self.in_sys += 1
         self.ttek = self.arrival_time
@@ -92,7 +121,7 @@ class ImpatientQueueSim(QsSim):
                 self.servers[server_idx].start_service(ImpatientTask(self.ttek, moment_to_leave), self.ttek, False)
                 self._free_servers.remove(server_idx)
                 self.free_channels -= 1
-                self._servers_time_changed = True
+                self._mark_servers_time_changed()
 
                 # Проверям, не наступил ли ПНЗ:
                 if self.free_channels == 0:
@@ -103,11 +132,8 @@ class ImpatientQueueSim(QsSim):
         """
         Drop a task from the queue and update statistics.
         """
-        # Ensure p array is large enough
-        while self.in_sys >= len(self.p):
-            # Extend p array in chunks to avoid frequent reallocations
-            self.p.extend([0.0] * min(1000, max(1, len(self.p) // 10)))
-        self.p[self.in_sys] += moment_to_leave_earlier - self.ttek
+        # Update state probabilities
+        self._update_state_probs(self.ttek, moment_to_leave_earlier, self.in_sys)
         self.ttek = moment_to_leave_earlier
 
         # Remove task from queue - need to handle deque properly
@@ -132,37 +158,8 @@ class ImpatientQueueSim(QsSim):
             end_ts.wait_time = self.ttek - end_ts.arr_time
             self.refresh_w_stat(end_ts.wait_time)
 
-    def run_one_step(self):
-        """
-        Run one step of the simulation.
-        """
-        # Use optimized method from base class
-        num_of_server_earlier, serv_earl = self._get_min_server_time()
-
-        num_of_task_earlier = -1
-        moment_to_leave_earlier = 1e10
-        if self.queue.size() > 0:
-            for i, tsk in enumerate(self.queue.queue):
-                if tsk.moment_to_leave < moment_to_leave_earlier:
-                    moment_to_leave_earlier = tsk.moment_to_leave
-                    num_of_task_earlier = i
-
-        # Key moment:
-
-        if self.arrival_time < serv_earl:
-            if self.arrival_time < moment_to_leave_earlier:
-                self.arrival()
-            elif num_of_task_earlier >= 0:
-                self.drop_task(num_of_task_earlier, moment_to_leave_earlier)
-            else:
-                self.arrival()
-        else:
-            if serv_earl < moment_to_leave_earlier and num_of_task_earlier >= 0:
-                self.serving(num_of_server_earlier)
-            elif num_of_task_earlier >= 0:
-                self.drop_task(num_of_task_earlier, moment_to_leave_earlier)
-            else:
-                self.serving(num_of_server_earlier)
+    # run_one_step is now inherited from base class and uses event-based approach
+    # Custom events (task drops) are handled via _get_custom_events() and _handle_custom_event()
 
     def __str__(self, is_short=False):
         """