vlcSim 0.6.2__tar.gz → 0.7.0__tar.gz

{vlcsim-0.6.2 → vlcsim-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vlcSim
-Version: 0.6.2
+Version: 0.7.0
 Summary: Python Package of Event-Oriented Simulation for visible light communication
 License: MIT
 License-File: LICENSE.md
@@ -318,6 +318,36 @@ sim.print_initial_info()  # Display scenario configuration
 - `get_Allocated_Connections()`: Connections assigned to an AP
 - `get_Waiting_Connections()`: Connections currently waiting for retry
 - `get_Blocked_Connections()`: Connections rejected with `NOT_ALLOCATED`
+- `get_Response_Time()`: Per-connection time from arrival to first service
+- `get_Average_Response_Time()`: Mean response time for completed connections
+- `get_Turnaround_Time()`: Per-connection time from arrival to completion
+- `get_Average_Turnaround_Time()`: Mean turnaround time for completed connections
+- `get_Waiting_Time()`: Per-connection total waiting time, including TDM gaps between slots
+- `get_Average_Waiting_Time()`: Mean total waiting time for completed connections
+
+**Time Metrics:**
+
+VLCSim reports time metrics for completed connections only:
+
+```python
+response_time = first_service_time - arrival_time
+turnaround_time = finish_time - arrival_time
+waiting_time = turnaround_time - active_service_time
+```
+
+`first_service_time` is the first `RESUME` event for a connection.
+`active_service_time` is the effective transmission time accumulated by the receiver.
+In TDM simulations, waiting time includes the initial delay before first service
+and the idle gaps between assigned slots or frames, so it can be larger than
+response time.
+
+```python
+sim.run()
+
+avg_response_time = sim.get_Average_Response_Time()
+avg_turnaround_time = sim.get_Average_Turnaround_Time()
+avg_waiting_time = sim.get_Average_Waiting_Time()
+```
 
 ### Scenario Class
 

{vlcsim-0.6.2 → vlcsim-0.7.0}/README.md

@@ -294,6 +294,36 @@ sim.print_initial_info()  # Display scenario configuration
 - `get_Allocated_Connections()`: Connections assigned to an AP
 - `get_Waiting_Connections()`: Connections currently waiting for retry
 - `get_Blocked_Connections()`: Connections rejected with `NOT_ALLOCATED`
+- `get_Response_Time()`: Per-connection time from arrival to first service
+- `get_Average_Response_Time()`: Mean response time for completed connections
+- `get_Turnaround_Time()`: Per-connection time from arrival to completion
+- `get_Average_Turnaround_Time()`: Mean turnaround time for completed connections
+- `get_Waiting_Time()`: Per-connection total waiting time, including TDM gaps between slots
+- `get_Average_Waiting_Time()`: Mean total waiting time for completed connections
+
+**Time Metrics:**
+
+VLCSim reports time metrics for completed connections only:
+
+```python
+response_time = first_service_time - arrival_time
+turnaround_time = finish_time - arrival_time
+waiting_time = turnaround_time - active_service_time
+```
+
+`first_service_time` is the first `RESUME` event for a connection.
+`active_service_time` is the effective transmission time accumulated by the receiver.
+In TDM simulations, waiting time includes the initial delay before first service
+and the idle gaps between assigned slots or frames, so it can be larger than
+response time.
+
+```python
+sim.run()
+
+avg_response_time = sim.get_Average_Response_Time()
+avg_turnaround_time = sim.get_Average_Turnaround_Time()
+avg_waiting_time = sim.get_Average_Waiting_Time()
+```
 
 ### Scenario Class
 

{vlcsim-0.6.2 → vlcsim-0.7.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "vlcSim"
-version = "0.6.2"  # Placeholder, will be replaced by dynamic versioning
+version = "0.7.0"  # Placeholder, will be replaced by dynamic versioning
 description = "Python Package of Event-Oriented Simulation for visible light communication"
 authors = ["Danilo Bórquez-Paredes <danilo.borquez.p@uai.cl>"]
 license = "MIT"

{vlcsim-0.6.2 → vlcsim-0.7.0}/vlcsim/__init__.py

@@ -30,7 +30,7 @@ See Also:
     For detailed documentation, visit the project repository or build the Sphinx docs.
 """
 
-__version__ = "0.6.2"  # placeholder for poetry-dynamic-versioning
+__version__ = "0.7.0"  # placeholder for poetry-dynamic-versioning
 
 from .scene import *
 from .controller import *

{vlcsim-0.6.2 → vlcsim-0.7.0}/vlcsim/controller/controller.py

@@ -360,7 +360,7 @@ class Controller:
             raise ValueError(
                 "Receiver must have goalTime set before resuming connection."
             )
-        if receiver.goalTime < receiver.timeActive + connection.AP.sliceTime:
+        if receiver.goalTime <= receiver.timeActive + connection.AP.sliceTime:
             return (
                 Controller.nextStatus.FINISH,
                 time + receiver.goalTime - receiver.timeActive,

{vlcsim-0.6.2 → vlcsim-0.7.0}/vlcsim/simulator.py

@@ -253,6 +253,10 @@ class Simulator:
         self.__allocatedConnectionIds: set[int] = set()
         self.__blockedConnectionIds: set[int] = set()
         self.__waitingConnectionIds: set[int] = set()
+        self.__firstServiceTimes: dict[int, float] = {}
+        self.__responseTimes: List[float] = []
+        self.__turnaroundTimes: List[float] = []
+        self.__waitingTimes: List[float] = []
         # time
         self.__clock: float = 0.0
         self.__time_duration: Optional[float] = None
@@ -900,9 +904,6 @@ class Simulator:
                 next_status == Controller.nextStatus.RESUME
                 or next_status == Controller.nextStatus.PAUSE
             ):
-                connection.receiver.goalTime = self.__departure_variable.exponential(
-                    self.__mu
-                )
                 connection.allocated = True
                 if next_status == Controller.nextStatus.RESUME:
                     for pos in range(len(self.__events) - 1, -1, -1):
@@ -953,6 +954,7 @@ class Simulator:
         elif self.__current_event.type == Event.event.RESUME:
             if not self.__current_event.connection:
                 return
+            self.__record_first_service_time(self.__current_event.connection)
             next_status, time, connection = self.__controller.resumeConnection(
                 self.__current_event.connection, self.__clock
             )
@@ -977,9 +979,11 @@ class Simulator:
         elif self.__current_event.type == Event.event.DEPARTURE:
             if not self.__current_event.connection:
                 return
+            completed_connection = self.__current_event.connection
             next_status, time, connection = self.__controller.unassignConnection(
-                self.__current_event.connection, self.__clock
+                completed_connection, self.__clock
             )
+            self.__record_completed_connection_time_metrics(completed_connection)
             # if next_status == Controller.nextStatus.RESUME:
             #     for pos in range(len(self.__events) - 1, -1, -1):
             #         if self.__events[pos].time <= time:
@@ -1017,6 +1021,33 @@ class Simulator:
         if connection_id not in self.__allocatedConnectionIds:
             self.__blockedConnectionIds.add(connection_id)
 
+    def __record_first_service_time(self, connection: Connection) -> None:
+        connection_id = connection.id
+        if connection_id not in self.__firstServiceTimes:
+            self.__firstServiceTimes[connection_id] = self.__clock
+
+    def __record_completed_connection_time_metrics(
+        self, connection: Connection
+    ) -> None:
+        first_service_time = self.__firstServiceTimes.get(connection.id)
+        finish_time = connection.receiver.timeFinished
+        if first_service_time is None or finish_time is None:
+            return
+
+        response_time = first_service_time - connection.time
+        turnaround_time = finish_time - connection.time
+        waiting_time = max(0.0, turnaround_time - connection.receiver.timeActive)
+
+        self.__responseTimes.append(response_time)
+        self.__turnaroundTimes.append(turnaround_time)
+        self.__waitingTimes.append(waiting_time)
+
+    @staticmethod
+    def __average(values: List[float]) -> float:
+        if len(values) == 0:
+            return 0.0
+        return sum(values) / len(values)
+
     def init(self):
         """Initialize the simulation engine and prepare for execution.
 
@@ -1055,6 +1086,10 @@ class Simulator:
         self.__allocatedConnectionIds = set()
         self.__blockedConnectionIds = set()
         self.__waitingConnectionIds = set()
+        self.__firstServiceTimes = {}
+        self.__responseTimes = []
+        self.__turnaroundTimes = []
+        self.__waitingTimes = []
         self.__users_by_vlc = []
         self.__users_by_rf = []
         self.__current_event = None
@@ -1185,6 +1220,64 @@ class Simulator:
         """
         return len(self.__blockedConnectionIds)
 
+    def get_Response_Time(self) -> List[float]:
+        """Get response times for completed connections.
+
+        Response time is the elapsed simulation time from connection arrival to
+        the first RESUME event, when the connection first receives service.
+
+        Returns:
+            list[float]: Response time for each completed connection in seconds
+        """
+        return list(self.__responseTimes)
+
+    def get_Average_Response_Time(self) -> float:
+        """Get the average response time for completed connections.
+
+        Returns:
+            float: Mean response time in seconds, or 0.0 if no connection finished
+        """
+        return self.__average(self.__responseTimes)
+
+    def get_Turnaround_Time(self) -> List[float]:
+        """Get turnaround times for completed connections.
+
+        Turnaround time is the elapsed simulation time from connection arrival
+        to departure.
+
+        Returns:
+            list[float]: Turnaround time for each completed connection in seconds
+        """
+        return list(self.__turnaroundTimes)
+
+    def get_Average_Turnaround_Time(self) -> float:
+        """Get the average turnaround time for completed connections.
+
+        Returns:
+            float: Mean turnaround time in seconds, or 0.0 if no connection finished
+        """
+        return self.__average(self.__turnaroundTimes)
+
+    def get_Waiting_Time(self) -> List[float]:
+        """Get total waiting times for completed connections.
+
+        Waiting time is turnaround time minus active service time. In TDM
+        simulations, this includes the initial delay before first service and
+        the idle gaps between assigned slots or frames.
+
+        Returns:
+            list[float]: Waiting time for each completed connection in seconds
+        """
+        return list(self.__waitingTimes)
+
+    def get_Average_Waiting_Time(self) -> float:
+        """Get the average total waiting time for completed connections.
+
+        Returns:
+            float: Mean waiting time in seconds, or 0.0 if no connection finished
+        """
+        return self.__average(self.__waitingTimes)
+
     def get_Waiting_Probability(self) -> float:
         """Calculate the fraction of attempted connections currently waiting.