definition of state and RqsGeneratorRuntime

Author: GioeleB00

src/app/config/constants.py

@@ -164,7 +164,8 @@ class SystemNodes(StrEnum):
     Each member represents a *macro-component* that may have its own SimPy
     resources (CPU cores, DB pool, etc.).
     """
-
+    
+    GENERATOR     = "generator"
     SERVER        = "server"
     CLIENT        = "client"
     LOAD_BALANCER = "load_balancer"

src/app/config/rqs_state.py

@@ -0,0 +1,44 @@
+"""
+defining a state in a one to one correspondence
+with the requests generated that will go through
+all the node necessary to accomplish the user request
+"""
+
+from __future__ import annotations
+from dataclasses import dataclass, field
+
+
+@dataclass
+class RequestState:
+    """
+    State object carried by each request through the simulation.
+
+    Attributes:
+        id: Unique identifier of the request.
+        t0: Timestamp (simulated env.now) when the request was generated.
+        history: List of hop records, each noting a node/edge visit.
+    """
+    id: int                                # Unique request identifier
+    initial_time: float                    # Generation timestamp (env.now)
+    finish_time: float | None = None       # a requests might be dropped
+    history: list[str] = field(default_factory=list)  # Trace of hops
+
+    def record_hop(self, node_name: str) -> None:
+        """
+        Append a record of visiting a node or edge.
+
+        Args:
+            node_name: Name of the node or edge being recorded.
+        """
+        # Record hop as "NodeName@Timestamp"
+        self.history.append(f"{node_name}@{self.t0:.3f}")
+    
+    @property
+    def latency(self) -> float | None:
+        """
+        Return the total time in the system (finish_time - initial_time),
+        or None if the request hasn’t completed yet.
+        """
+        if self.finish_time is None:
+            return None
+        return self.finish_time - self.initial_time

src/app/core/event_samplers/gaussian_poisson.py

@@ -24,7 +24,7 @@ def gaussian_poisson_sampling(
     input_data: RqsGeneratorInput,
     sim_settings: SimulationSettings,
     *,
-    rng: np.random.Generator | None = None,
+    rng: np.random.Generator,
 ) -> Generator[float, None, None]:
     """
     Yield inter-arrival gaps (seconds) for the compound Gaussian-Poisson process.
@@ -39,7 +39,6 @@ def gaussian_poisson_sampling(
          Δt ~ Exponential(Λ)   using inverse-CDF.
     4. Stop once the virtual clock exceeds *total_simulation_time*.
     """
-    rng = rng or np.random.default_rng()
 
     simulation_time = sim_settings.total_simulation_time
     user_sampling_window = input_data.user_sampling_window

src/app/core/event_samplers/poisson_poisson.py

@@ -21,7 +21,7 @@ def poisson_poisson_sampling(
     input_data: RqsGeneratorInput,
     sim_settings: SimulationSettings,
     *,
-    rng: np.random.Generator | None = None,
+    rng: np.random.Generator,
 ) ->  Generator[float, None, None]:
     """
     Yield inter-arrival gaps (seconds) for the compound Poisson-Poisson process.
@@ -36,8 +36,7 @@ def poisson_poisson_sampling(
          Δt ~ Exponential(Λ)   using inverse-CDF.
     4. Stop once the virtual clock exceeds *total_simulation_time*.
     """
-    rng = rng or np.random.default_rng()
-
+    
     simulation_time = sim_settings.total_simulation_time
     user_sampling_window = input_data.user_sampling_window
 

src/app/core/helpers.py …c/app/core/helpers/dictionary_metrics.pysrc/app/core/helpers.py renamed to src/app/core/helpers/dictionary_metrics.py src/app/core/helpers.py renamed to src/app/core/helpers/dictionary_metrics.py

@@ -0,0 +1,87 @@
+"""
+definition of the class representing the rqs generator
+that will be passed as a process in the simpy simulation
+"""
+
+from __future__ import annotations
+
+from typing import Generator, TYPE_CHECKING
+
+import simpy
+
+from app.config.constants import Distribution
+from app.config.rqs_state import RequestState
+from app.core.event_samplers.gaussian_poisson import gaussian_poisson_sampling
+from app.core.event_samplers.poisson_poisson import poisson_poisson_sampling
+
+if TYPE_CHECKING:
+    from collections.abc import Generator
+
+    import numpy as np
+
+    from app.schemas.requests_generator_input import RqsGeneratorInput
+    from app.schemas.simulation_settings_input import SimulationSettings
+
+
+class RqsGeneratorRuntime():
+    """
+    A “node” that produces request contexts at stochastic inter‐arrival times
+    and immediately pushes them down the pipeline via an EdgeRuntime.
+    """
+    def __init__(
+        self,
+        env: simpy.Environment,
+        state: RequestState,
+        rqs_generator_data: RqsGeneratorInput,
+        sim_settings: SimulationSettings,
+        *,
+        rng: np.random.Generator | None = None
+        ):
+        
+        self.rqs_generator_data = rqs_generator_data
+        self.sim_settings = sim_settings
+        self.rng =  rng or np.random.default_rng()
+        self.state = state
+        self.env = env
+
+        
+    def _requests_generator(self) -> Generator[float, None, None]:
+        """
+        Return an iterator of inter-arrival gaps (seconds) according to the model
+        chosen in *input_data*.
+
+        Notes
+        -----
+        * If ``avg_active_users.distribution`` is ``"gaussian"`` or ``"normal"``,
+        the Gaussian-Poisson sampler is used.
+        * Otherwise the default Poisson-Poisson sampler is returned.
+
+        """
+        dist = self.rqs_generator_data.avg_active_users.distribution.lower()
+
+        if dist == Distribution.NORMAL:
+            #Gaussian-Poisson model
+            return gaussian_poisson_sampling(
+                input_data=self.rqs_generator_data,
+                sim_settings=self.sim_settings,
+                rng=self.rng,
+
+            )
+
+        # Poisson + Poisson
+        return poisson_poisson_sampling(
+            input_data=self.rqs_generator_data,
+            sim_settings=self.sim_settings,
+            rng=self.rng,
+        )
+        
+    def _event_arrival(self) -> Generator[simpy.Event, None, None]:
+        """simulating the process of event generation"""
+        time_gaps = self._requests_generator()
+        
+        for gap in time_gaps:
+            yield self.env.timeout(gap)
+            
+    def run(self) -> simpy.Process:
+        """passing the structure as a simpy process"""
+        return self.env.process(self._event_arrival())