diff --git a/asyncflow_queue_limit/asyncflow_mm1_notebook.ipynb b/asyncflow_queue_limit/asyncflow_mm1_notebook.ipynb new file mode 100644 index 0000000..4d02abb --- /dev/null +++ b/asyncflow_queue_limit/asyncflow_mm1_notebook.ipynb @@ -0,0 +1,650 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# AsyncFlow — MM1 Theory vs Simulation (Guided Notebook)\n", + "\n", + "This notebook shows how to:\n", + "\n", + "1. Make imports work inside a notebook (src-layout or package install)\n", + "2. Build a **single-server** scenario compatible with **M/M/1** assumptions\n", + "3. Run the simulation and collect results\n", + "4. Compare theory vs observed KPIs (pretty-printed table)\n", + "5. Plot the standard dashboards (latency, throughput, server time series)\n", + "\n", + "> Tip: run this notebook from your project **root folder**.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "c3a69413", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import importlib, asyncflow, asyncflow.analysis\n", + "importlib.reload(asyncflow)\n", + "importlib.reload(asyncflow.analysis)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "tags": [ + "imports" + ] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Imports OK.\n" + ] + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import simpy\n", + "\n", + "# Public AsyncFlow API\n", + "from asyncflow import AsyncFlow, SimulationRunner, Sweep\n", + "from asyncflow.components import Client, Server, Edge, Endpoint\n", + "from asyncflow.settings import SimulationSettings\n", + "from asyncflow.workload import RqsGenerator\n", + "from asyncflow.analysis import MM1, ResultsAnalyzer, SweepAnalyzer\n", + "\n", + "print(\"Imports OK.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1) Build an M/M/1-friendly scenario\n", + "\n", + "* **Single server with exponential CPU service**\n", + " One server, one endpoint, exactly **one CPU-bound step** with an **Exponential** service-time RV (mean $E[S]$). No RAM/IO steps in the pipeline.\n", + "\n", + "* **No load balancer**\n", + " Topology has **exactly one server** and **no LB** (no fan-out, no parallelism).\n", + "\n", + "* **Deterministic, very small network latency**\n", + " All edges use a **fixed latency** $\\ll 1\\,\\mathrm{ms}$ so queueing is dominated by CPU service (closer to textbook M/M/1).\n", + "\n", + "* **“Poisson arrivals” via the generator (what we actually sample)**\n", + " We use a **two-stage, windowed sampler**: every user-sampling window $\\Delta$ we draw the active users $U$ (Poisson or Normal, per config). **Within that window**, arrivals are a **homogeneous Poisson process** with rate $\\Lambda = U \\cdot \\lambda_r/60$ (where $\\lambda_r$ is requests/min/user). If $U$ changes between windows, the overall process becomes a **piecewise-constant (mixed/Cox) Poisson** rather than one global Poisson.\n", + " *Implications:* with **small $\\Delta$**, **Poisson users**, **long runs**, and **tiny edge latency**, this closely matches M/M/1. Larger $\\Delta$, Normal users, or short horizons can introduce small, expected deviations in $\\lambda, W, L$ (especially during warm-up).\n", + "\n", + "\n", + "```mermaid\n", + "graph LR;\n", + " %% Definiamo i nodi con i loro dettagli\n", + " rqs1[\"RqsGenerator
id: rqs-1\"]\n", + " client1[\"Client
id: client-1\"]\n", + " app1[\"Server
id: app-1
Endpoint: /api\"]\n", + "\n", + " %% Definiamo le connessioni (edge) con latenza\n", + " rqs1 -- \"Edge: gen-client
Latency: 0.0001\" --> client1;\n", + " client1 -- \"Request
Edge: client-app
Latency: 0.0001\" --> app1;\n", + " app1 -- \"Response
Edge: app-client
Latency: 0.0001\" --> client1;" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "tags": [ + "build" + ] + }, + "outputs": [], + "source": [ + "def build_payload():\n", + " generator = RqsGenerator(\n", + " id=\"rqs-1\",\n", + " avg_active_users={\"mean\": 100},\n", + " avg_request_per_minute_per_user={\"mean\": 20},\n", + " user_sampling_window=60,\n", + " )\n", + "\n", + " client = Client(id=\"client-1\")\n", + "\n", + " endpoint = Endpoint(\n", + " endpoint_name=\"/api\",\n", + " probability=1.0,\n", + " steps=[\n", + " {\n", + " \"kind\": \"initial_parsing\", # CPU-bound step\n", + " \"step_operation\": {\n", + " \"cpu_time\": {\"mean\": 0.015, \"distribution\": \"exponential\"},\n", + " },\n", + " },\n", + " ],\n", + " )\n", + "\n", + " server = Server(\n", + " id=\"app-1\",\n", + " server_resources={\"cpu_cores\": 1, \"ram_mb\": 2048},\n", + " endpoints=[endpoint],\n", + " )\n", + "\n", + " e_gen_client = Edge(id=\"gen-client\", source=\"rqs-1\", target=\"client-1\", latency=0.0001, dropout_rate=0.0)\n", + " e_client_app = Edge(id=\"client-app\", source=\"client-1\", target=\"app-1\", latency=0.0001, dropout_rate=0.0)\n", + " e_app_client = Edge(id=\"app-client\", source=\"app-1\", target=\"client-1\", latency=0.0001, dropout_rate=0.0)\n", + "\n", + " settings = SimulationSettings(\n", + " total_simulation_time=900,\n", + " sample_period_s=0.05,\n", + " )\n", + "\n", + " payload = (\n", + " AsyncFlow()\n", + " .add_generator(generator)\n", + " .add_client(client)\n", + " .add_servers(server)\n", + " .add_edges(e_gen_client, e_client_app, e_app_client)\n", + " .add_simulation_settings(settings)\n", + " ).build_payload()\n", + " return payload\n", + "\n", + "payload = build_payload()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2) Run the simulation\n" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "tags": [ + "run" + ] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Done.\n" + ] + } + ], + "source": [ + "env = simpy.Environment()\n", + "runner = SimulationRunner(env=env, simulation_input=payload)\n", + "results: ResultsAnalyzer = runner.run()\n", + "print(\"Done.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3) MM1 theory vs observed comparison \n", + "If the payload violates MM1 assumptions, a readable error is shown instead.\n", + "## Variables (what they represent)\n", + "\n", + "* **λ (lambda)**: mean **arrival rate**, in requests/second.\n", + "* **μ (mu)**: mean **service rate**, in requests/second (= 1 / mean service time).\n", + "* **ρ (rho)**: **utilization** of the server, ρ = λ / μ (unitless).\n", + "* **W**: **mean time in system** (end-to-end latency, queue + service), in seconds.\n", + "* **Wq**: **mean waiting time in queue** (before service), in seconds.\n", + "* **L**: **mean number in system** (in queue + in service), unitless.\n", + "* **Lq**: **mean number in queue**, unitless.\n", + "* **E\\[S]**: **mean service time** at the server (CPU only), in seconds.\n", + "\n", + "\n", + "> In the comparison table you’ll see two columns: **Theory** (closed-form M/M/1 values) and **Observed** (estimates from the run). The run is a single execution; “Theory” is the model prediction, “Observed” is what was measured.\n", + "\n", + "---\n", + "\n", + "## How we compute the **Theory** column (M/M/1)\n", + "\n", + "1. **Predicted arrival rate**\n", + "\n", + "$$\n", + "\\lambda_{\\text{Theory}} \\;=\\; \n", + "\\frac{\\texttt{avg\\_active\\_users.mean}\\times \\texttt{avg\\_request\\_per\\_minute\\_per\\_user.mean}}{60}\n", + "$$\n", + "\n", + "2. **Predicted service rate** (from the **CPU exponential step** with mean $E[S]$)\n", + "\n", + "$$\n", + "\\mu_{\\text{Theory}} \\;=\\; \\frac{1}{E[S]}\n", + "$$\n", + "\n", + "3. **M/M/1 closed forms** (valid when $\\lambda_{\\text{Theory}} < \\mu_{\\text{Theory}}$)\n", + "\n", + "$$\n", + "\\begin{aligned}\n", + "\\rho_{\\text{Theory}} &= \\frac{\\lambda_{\\text{Theory}}}{\\mu_{\\text{Theory}}} \\\\\n", + "W_{\\text{Theory}} &= \\frac{1}{\\mu_{\\text{Theory}} - \\lambda_{\\text{Theory}}} \\\\\n", + "W_{q,\\text{Theory}} &= \\frac{\\rho_{\\text{Theory}}}{\\mu_{\\text{Theory}} - \\lambda_{\\text{Theory}}} \\\\\n", + "L_{\\text{Theory}} &= \\lambda_{\\text{Theory}}\\, W_{\\text{Theory}} \\;=\\; \\frac{\\rho_{\\text{Theory}}}{1-\\rho_{\\text{Theory}}} \\\\\n", + "L_{q,\\text{Theory}} &= \\lambda_{\\text{Theory}}\\, W_{q,\\text{Theory}} \\;=\\; \\frac{\\rho_{\\text{Theory}}^{2}}{1-\\rho_{\\text{Theory}}}\n", + "\\end{aligned}\n", + "$$\n", + "\n", + "If $\\lambda_{\\text{Theory}} \\ge \\mu_{\\text{Theory}}$, the system is **unstable** and $W, W_q, L, L_q$ **diverge** (we display them as $+\\infty$).\n", + "\n", + "---\n", + "\n", + "## How we compute the **Observed** column (from the run)\n", + "\n", + "After the `ResultsAnalyzer` processes metrics:\n", + "\n", + "1. **Observed arrival rate** (mean throughput across time windows)\n", + "\n", + "$$\n", + "\\lambda_{\\text{Observed}} \\;=\\; \\text{mean}\\big(\\text{windowed RPS series}\\big)\n", + "$$\n", + "\n", + "2. **Observed time in system** (client end-to-end latency)\n", + "\n", + "$$\n", + "W_{\\text{Observed}} \\;=\\; \\text{mean}\\big(\\text{client latencies}\\big)\n", + "$$\n", + "\n", + "3. **Observed service rate** (from server service times)\n", + "\n", + "$$\n", + "\\overline{S}=\\text{mean}(\\text{service\\_time}), \n", + "\\qquad\n", + "\\mu_{\\text{Observed}}=\n", + "\\begin{cases}\n", + "1/\\overline{S} & \\overline{S}>0\\\\\n", + "+\\infty & \\overline{S}=0\n", + "\\end{cases}\n", + "$$\n", + "\n", + "4. **Observed waiting time in queue** (from server queue wait times)\n", + "\n", + "$$\n", + "W_{q,\\text{Observed}} \\;=\\; \\text{mean}(\\text{waiting\\_time})\n", + "$$\n", + "\n", + "5. **Little’s law (observed)**\n", + "\n", + "$$\n", + "L_{\\text{Observed}}=\\lambda_{\\text{Observed}}\\, W_{\\text{Observed}},\n", + "\\qquad\n", + "L_{q,\\text{Observed}}=\\lambda_{\\text{Observed}}\\, W_{q,\\text{Observed}}\n", + "$$\n", + "\n", + "6. **Observed utilization**\n", + "\n", + "$$\n", + "\\rho_{\\text{Observed}}=\n", + "\\begin{cases}\n", + "\\lambda_{\\text{Observed}} / \\mu_{\\text{Observed}} & \\mu_{\\text{Observed}} \\not\\in \\{0,+\\infty\\}\\\\\n", + "0 & \\text{otherwise}\n", + "\\end{cases}\n", + "$$\n", + "\n", + "> **Why small deltas appear:** warm-up effects, the user-sampling window (piecewise-constant rate), finite simulation horizon, and a (small) deterministic network latency naturally introduce small Theory vs Observed gaps. Increasing the simulation time and reducing network latency typically shrinks these deltas.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "tags": [ + "mm1" + ] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "====================================================================\n", + "MM1 - Theory vs Observed\n", + "--------------------------------------------------------------------\n", + "sym metric theory observed abs rel%\n", + "--------------------------------------------------------------------\n", + "λ Arrival rate (1/s) 33.333333 33.204444 -0.128889 -0.39\n", + "μ Service rate (1/s) 66.666667 66.638004 -0.028663 -0.04\n", + "rho Utilization 0.500000 0.498281 -0.001719 -0.34\n", + "L Mean items in system 1.000000 1.034536 0.034536 3.45\n", + "Lq Mean items in queue 0.500000 0.526294 0.026294 5.26\n", + "W Mean time in system (s) 0.030000 0.031157 0.001157 3.86\n", + "Wq Mean waiting time (s) 0.015000 0.015850 0.000850 5.67\n", + "====================================================================\n" + ] + } + ], + "source": [ + "mm1 = MM1()\n", + "if mm1.is_compatible(payload):\n", + " mm1.print_comparison(payload, results) # ✅ metodo esistente\n", + "else:\n", + " print(\"Payload is not compatible with M/M/1:\")\n", + " for reason in mm1.explain_incompatibilities(payload):\n", + " print(\" -\", reason)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 4) Plot dashboards\n", + "\n", + "**System-level and per-server charts**\n", + "\n", + "Beyond the two main panels (latency histogram + throughput time series), AsyncFlow records **rich time series and per-request distributions** that make the system behavior easy to read. In your scenario (single server, exponential CPU only, no I/O/RAM), you’ll see:\n", + "\n", + "* **System dashboard**\n", + "\n", + " * **Request Latency Distribution**: end-to-end histogram (client→server→client) with **mean, P50, P95, P99** markers. Here latency is dominated by CPU service + short queue; vertical lines highlight tail behavior.\n", + " * **Throughput (RPS)**: windowed time series with **mean, P95, max**. Great for spotting stability, oscillations, and warm-up.\n", + "\n", + "* **Server time-series dashboard (for `app-1`)**\n", + "\n", + " * **Ready queue length**: CPU queue over time with **mean/min/max**. With ρ≈0.5 the mean queue ≈0.5, consistent with M/M/1.\n", + " * **I/O queue length**: flat at zero (no I/O step in the pipeline).\n", + " * **RAM in use**: flat at zero (no RAM step in the pipeline).\n", + "\n", + "* **Server event-metrics dashboard**\n", + "\n", + " * **Server-side latency**: histogram of (waiting + service) at the server.\n", + " * **CPU service time**: histogram of **service\\_time** (Exp \\~15 ms) with P95/P99.\n", + " * **CPU waiting time**: histogram of queue **waiting\\_time**; shows the heavy tail under bursts.\n", + " * **I/O time**: flat at zero (no I/O).\n", + "\n", + "#### What you “get for free” from the collected data\n", + "\n", + "* **Distributions** (per-request arrays): end-to-end latency, server latency, **service\\_time**, **waiting\\_time**, (optional) **io\\_time** ⇒ percentiles, variance, pre/post comparisons.\n", + "* **Time series** (periodic sampling): **ready\\_queue\\_len**, **event\\_loop\\_io\\_sleep** (if I/O exists), **ram\\_in\\_use**, **edge\\_concurrent\\_connection**, plus **throughput series** to estimate observed λ.\n", + "* **Derived checks**: automatic **Little’s Law** sanity (L≈λW, Lq≈λWq), observed utilization **ρ̂ = λ̂/μ̂**, and the **MM1 theory vs observed** comparison table you printed.\n", + "\n", + "> In this specific setup, I/O and RAM panels are flat by design; add I/O or RAM steps and those plots will populate accordingly.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "tags": [ + "plots" + ] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 4.1 System dashboard: latency + throughput\n", + "fig_sys, axes_sys = plt.subplots(1, 2, figsize=(12, 4.5), dpi=140)\n", + "results.plot_latency_distribution(axes_sys[0])\n", + "results.plot_throughput(axes_sys[1])\n", + "fig_sys.tight_layout()\n", + "plt.show()\n", + "\n", + "# 4.2 Server time-series and event-metric dashboards\n", + "sids = results.list_server_ids()\n", + "if sids:\n", + " sid = sids[0]\n", + " fig_ts, axes_ts = plt.subplots(2, 2, figsize=(12, 8), dpi=140)\n", + " axes_ts[1, 1].axis(\"off\")\n", + " results.plot_server_timeseries_dashboard(\n", + " ax_ready=axes_ts[0, 0],\n", + " ax_io=axes_ts[0, 1],\n", + " ax_ram=axes_ts[1, 0],\n", + " server_id=sid,\n", + " )\n", + " fig_ts.tight_layout()\n", + " plt.show()\n", + "\n", + " fig_ev, axes_ev = plt.subplots(2, 2, figsize=(12, 8), dpi=140)\n", + " results.plot_server_event_metrics_dashboard(\n", + " ax_latency_hist=axes_ev[0, 0],\n", + " ax_service_hist=axes_ev[0, 1],\n", + " ax_io_hist=axes_ev[1, 0],\n", + " ax_wait_hist=axes_ev[1, 1],\n", + " server_id=sid,\n", + " )\n", + " fig_ev.tight_layout()\n", + " plt.show()\n", + "else:\n", + " print(\"No servers present in the topology.\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "8328475f", + "metadata": {}, + "source": [ + "\n", + "## 5) Sweep over mean concurrent users\n", + "We iterate the scenario by changing the *mean concurrent users* from 10 to 200 (step 5).\n", + "For each grid point we run a fresh simulation and keep the ResultsAnalyzer.\n", + "Then we wrap everything in `SweepAnalyzer`, which caches the data for plotting." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "c9063bbe", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sweep points: 41\n", + "Server IDs detected: ['app-1']\n" + ] + } + ], + "source": [ + "payload_base = build_payload()\n", + "\n", + "sweeper = Sweep()\n", + "pairs = sweeper.sweep_on_user(\n", + " payload=payload_base,\n", + " user_lower_bound=50,\n", + " user_upper_bound=250,\n", + " step=5,\n", + ")\n", + "\n", + "# Wrap with the sweep analyzer and pre-collect/caches\n", + "sweep = SweepAnalyzer(pairs)\n", + "sweep.precollect()\n", + "\n", + "print(f\"Sweep points: {len(pairs)}\")\n", + "if pairs:\n", + " print(\"Server IDs detected:\", pairs[0][1].list_server_ids())\n" + ] + }, + { + "cell_type": "markdown", + "id": "dae40bfc", + "metadata": {}, + "source": [ + "## 6) Global plots (system-level)\n", + "We plot: \n", + " - Throughput (mean RPS) vs users\n", + " - Mean latency (W) vs users\n", + " - latency percentiles vs users.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "48716bc8", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig_global = sweep.plot_global_dashboard()\n", + "plt.show()\n", + "\n", + "# 6.2 Latency percentiles vs users (P50, P95, P99)\n", + "fig_pct, ax_pct = plt.subplots(1, 1, figsize=(6.5, 4.0), dpi=130)\n", + "sweep.plot_global_latency_percentiles(ax_pct)\n", + "fig_pct.tight_layout()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "71b7199b", + "metadata": {}, + "source": [ + "\n", + "## 7) Per-server overlays\n", + "We plot per-server curves over users (utilization ρ_i, waiting time Wq_i, service rate μ_i, throughput λ_i).\n", + "If multiple servers exist, overlays show a line per server.\n", + "Below we also show the *single-server* case by explicitly passing the server id.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "9b9f0236", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_127715/23993299.py:28: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n", + " fig.tight_layout()\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 7.1 Single-server overlays (explicit server id), if present\n", + "server_ids = pairs[0][1].list_server_ids() if pairs else []\n", + "if server_ids:\n", + " sid = server_ids[0]\n", + "\n", + " fig = plt.figure(figsize=(12, 10), dpi=130)\n", + " gs = fig.add_gridspec(nrows=3, ncols=2, hspace=0.35, wspace=0.25)\n", + "\n", + " # Row 1 (2 charts)\n", + " ax11 = fig.add_subplot(gs[0, 0])\n", + " ax12 = fig.add_subplot(gs[0, 1])\n", + "\n", + " # Row 2 (2 charts)\n", + " ax21 = fig.add_subplot(gs[1, 0])\n", + " ax22 = fig.add_subplot(gs[1, 1])\n", + "\n", + " # Row 3 (1 chart spanning both columns)\n", + " ax3 = fig.add_subplot(gs[2, :])\n", + "\n", + " # Plots\n", + " sweep.plot_server_utilization_overlay(ax11, server_ids=[sid])\n", + " sweep.plot_server_waiting_time_overlay(ax12, server_ids=[sid])\n", + " sweep.plot_server_service_rate_overlay(ax21, server_ids=[sid])\n", + " sweep.plot_server_throughput_overlay(ax22, server_ids=[sid])\n", + " sweep.plot_server_latency_overlay(ax3, server_ids=[sid]) # full-width\n", + "\n", + " fig.suptitle(f\"Per-server overlays — {sid}\", y=0.98)\n", + " fig.tight_layout()\n", + " plt.show()\n", + "else:\n", + " print(\"No servers present — skipping per-server overlays.\")\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "asyncflow-sim-py3.12 (3.12.3)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/builder_input/event_injection/lb_two_servers.py b/examples/builder_input/event_injection/lb_two_servers.py index 8af411f..fa1e82e 100644 --- a/examples/builder_input/event_injection/lb_two_servers.py +++ b/examples/builder_input/event_injection/lb_two_servers.py @@ -37,8 +37,8 @@ from asyncflow.workload import RqsGenerator # Runner + Analyzer -from asyncflow.metrics.analyzer import ResultsAnalyzer -from asyncflow.runtime.simulation_runner import SimulationRunner +from asyncflow.metrics.simulation_analyzer import ResultsAnalyzer +from asyncflow.runner.simulation import SimulationRunner def build_and_run() -> ResultsAnalyzer: diff --git a/examples/builder_input/event_injection/single_server.py b/examples/builder_input/event_injection/single_server.py index 0c514b2..dadae75 100644 --- a/examples/builder_input/event_injection/single_server.py +++ b/examples/builder_input/event_injection/single_server.py @@ -45,8 +45,8 @@ from asyncflow.workload import RqsGenerator # Runner + Analyzer -from asyncflow.runtime.simulation_runner import SimulationRunner -from asyncflow.metrics.analyzer import ResultsAnalyzer +from asyncflow.runner.simulation import SimulationRunner +from asyncflow.metrics.simulation_analyzer import ResultsAnalyzer def build_and_run() -> ResultsAnalyzer: diff --git a/examples/builder_input/load_balancer/two_servers.py b/examples/builder_input/load_balancer/two_servers.py index a57d090..eebced4 100644 --- a/examples/builder_input/load_balancer/two_servers.py +++ b/examples/builder_input/load_balancer/two_servers.py @@ -51,8 +51,8 @@ from asyncflow.workload import RqsGenerator # Runner + Analyzer -from asyncflow.runtime.simulation_runner import SimulationRunner -from asyncflow.metrics.analyzer import ResultsAnalyzer +from asyncflow.runner.simulation import SimulationRunner +from asyncflow.metrics.simulation_analyzer import ResultsAnalyzer def main() -> None: diff --git a/examples/builder_input/single_server/builder_service_plots.png b/examples/builder_input/single_server/builder_service_plots.png index 31c230e..8a0f270 100644 Binary files a/examples/builder_input/single_server/builder_service_plots.png and b/examples/builder_input/single_server/builder_service_plots.png differ diff --git a/examples/builder_input/single_server/single_server.py b/examples/builder_input/single_server/single_server.py index 7fb7e99..f405748 100644 --- a/examples/builder_input/single_server/single_server.py +++ b/examples/builder_input/single_server/single_server.py @@ -40,8 +40,8 @@ from asyncflow.workload import RqsGenerator # Runner + Analyzer -from asyncflow.runtime.simulation_runner import SimulationRunner -from asyncflow.metrics.analyzer import ResultsAnalyzer +from asyncflow.runner.simulation import SimulationRunner +from asyncflow.metrics.simulation_analyzer import ResultsAnalyzer def build_and_run() -> ResultsAnalyzer: diff --git a/examples/yaml_input/event_injections/heavy_single_server.py b/examples/yaml_input/event_injections/heavy_single_server.py index 72605af..5ac9b16 100644 --- a/examples/yaml_input/event_injections/heavy_single_server.py +++ b/examples/yaml_input/event_injections/heavy_single_server.py @@ -19,8 +19,8 @@ import matplotlib.pyplot as plt import simpy -from asyncflow.metrics.analyzer import ResultsAnalyzer -from asyncflow.runtime.simulation_runner import SimulationRunner +from asyncflow.metrics.simulation_analyzer import ResultsAnalyzer +from asyncflow.runner.simulation import SimulationRunner def main() -> None: diff --git a/examples/yaml_input/event_injections/lb_two_servers.py b/examples/yaml_input/event_injections/lb_two_servers.py index a2b666c..700f42d 100644 --- a/examples/yaml_input/event_injections/lb_two_servers.py +++ b/examples/yaml_input/event_injections/lb_two_servers.py @@ -15,8 +15,8 @@ import matplotlib.pyplot as plt import simpy -from asyncflow.metrics.analyzer import ResultsAnalyzer -from asyncflow.runtime.simulation_runner import SimulationRunner +from asyncflow.metrics.simulation_analyzer import ResultsAnalyzer +from asyncflow.runner.simulation import SimulationRunner def main() -> None: diff --git a/examples/yaml_input/event_injections/single_server.py b/examples/yaml_input/event_injections/single_server.py index 58d1603..3f5b182 100644 --- a/examples/yaml_input/event_injections/single_server.py +++ b/examples/yaml_input/event_injections/single_server.py @@ -19,8 +19,8 @@ import matplotlib.pyplot as plt import simpy -from asyncflow.metrics.analyzer import ResultsAnalyzer -from asyncflow.runtime.simulation_runner import SimulationRunner +from asyncflow.metrics.simulation_analyzer import ResultsAnalyzer +from asyncflow.runner.simulation import SimulationRunner def main() -> None: diff --git a/examples/yaml_input/load_balancer/two_servers.py b/examples/yaml_input/load_balancer/two_servers.py index a6fb125..622d277 100644 --- a/examples/yaml_input/load_balancer/two_servers.py +++ b/examples/yaml_input/load_balancer/two_servers.py @@ -23,8 +23,8 @@ import simpy import matplotlib.pyplot as plt -from asyncflow.runtime.simulation_runner import SimulationRunner -from asyncflow.metrics.analyzer import ResultsAnalyzer +from asyncflow.runner.simulation import SimulationRunner +from asyncflow.metrics.simulation_analyzer import ResultsAnalyzer def main() -> None: diff --git a/examples/yaml_input/single_server/single_server.py b/examples/yaml_input/single_server/single_server.py index 722de75..8e03779 100644 --- a/examples/yaml_input/single_server/single_server.py +++ b/examples/yaml_input/single_server/single_server.py @@ -44,8 +44,8 @@ import matplotlib.pyplot as plt # The only imports a user needs to run a simulation -from asyncflow.metrics.analyzer import ResultsAnalyzer -from asyncflow.runtime.simulation_runner import SimulationRunner +from asyncflow.metrics.simulation_analyzer import ResultsAnalyzer +from asyncflow.runner.simulation import SimulationRunner # --- Basic Logging Setup --- logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s") diff --git a/src/asyncflow/__init__.py b/src/asyncflow/__init__.py index 0f38c83..bcaa60c 100644 --- a/src/asyncflow/__init__.py +++ b/src/asyncflow/__init__.py @@ -2,6 +2,7 @@ from __future__ import annotations from asyncflow.builder.asyncflow_builder import AsyncFlow -from asyncflow.runtime.simulation_runner import SimulationRunner +from asyncflow.runner.simulation import SimulationRunner +from asyncflow.runner.sweep import Sweep -__all__ = ["AsyncFlow", "SimulationRunner"] +__all__ = ["AsyncFlow", "SimulationRunner", "Sweep"] diff --git a/src/asyncflow/analysis/__init__.py b/src/asyncflow/analysis/__init__.py index 825de6e..e7338af 100644 --- a/src/asyncflow/analysis/__init__.py +++ b/src/asyncflow/analysis/__init__.py @@ -1,5 +1,7 @@ """Public module exposing the results analyzer""" -from asyncflow.metrics.analyzer import ResultsAnalyzer +from asyncflow.metrics.simulation_analyzer import ResultsAnalyzer +from asyncflow.metrics.sweep_analyzer import SweepAnalyzer +from asyncflow.queue_theory_analysis.mm1 import MM1 -__all__ = ["ResultsAnalyzer"] +__all__ = ["MM1", "ResultsAnalyzer", "SweepAnalyzer"] diff --git a/src/asyncflow/config/constants.py b/src/asyncflow/config/constants.py index fb23820..a1a8e8b 100644 --- a/src/asyncflow/config/constants.py +++ b/src/asyncflow/config/constants.py @@ -213,7 +213,7 @@ class SamplePeriods(float, Enum): STANDARD_TIME = 0.01 # 10 MILLISECONDS MINIMUM_TIME = 0.001 # 1 MILLISECOND - MAXIMUM_TIME = 0.1 # 100 MILLISECONDS + MAXIMUM_TIME = 0.5 # 500 MILLISECONDS # ====================================================================== # CONSTANTS FOR EVENT METRICS @@ -227,7 +227,13 @@ class EventMetricName(StrEnum): # Mandatory RQS_CLOCK = "rqs_clock" # useful to collect starting and finishing time of rqs - # Not mandatory + RQS_SERVER_CLOCK = "rqs_server_clock" #useful for latency and throughput of the server + SERVICE_TIME = "service_time" + IO_TIME = "io_time" + WAITING_TIME = "waiting_time" + + + # Not mandatory now not implemented LLM_COST = "llm_cost" @@ -240,6 +246,14 @@ class AggregatedMetricName(StrEnum): LATENCY_STATS = "latency_stats" THROUGHPUT = "throughput_rps" + SERVER_THROUGHPUT = "server_throughput" + SERVER_LATENCY_STATS = "server_latency_stats" + SERVICE_TIME_STATS = "service_time_stats" + IO_TIME_STATS = "io_time_stats" + WAITING_TIME_STATS = "waiting_time_stats" + UTILIZATION = "utilization" + + # now not implemented LLM_STATS = "llm_stats" # ====================================================================== diff --git a/src/asyncflow/metrics/client.py b/src/asyncflow/metrics/client.py index 2e49638..c2632d2 100644 --- a/src/asyncflow/metrics/client.py +++ b/src/asyncflow/metrics/client.py @@ -9,7 +9,9 @@ class RqsClock(NamedTuple): """ structure to register time of generation and - time of elaboration for each request + time of elaboration for each request during + all the cycle of elaboration starting and ending + with the client """ start: float diff --git a/src/asyncflow/metrics/server.py b/src/asyncflow/metrics/server.py index 6ebb96e..516680f 100644 --- a/src/asyncflow/metrics/server.py +++ b/src/asyncflow/metrics/server.py @@ -1,9 +1,9 @@ """ initialization of the structure to gather the sampled metrics -for the server of the system +and event metrics for the server of the system """ - from collections.abc import Iterable +from dataclasses import dataclass from asyncflow.config.constants import SampledMetricName @@ -32,3 +32,14 @@ def build_server_metrics( metric: [] for metric in SERVER_METRICS if metric in enabled_sample_metrics } + +# For the client we choosed a named tuple, here we prefer +# a dataclass because we need mutability since start and +# are updated in two different steps +@dataclass +class ServerClock: + """Server-side request timing: start + finish.""" + + start: float + finish: float | None = None + diff --git a/src/asyncflow/metrics/analyzer.py b/src/asyncflow/metrics/simulation_analyzer.py similarity index 66% rename from src/asyncflow/metrics/analyzer.py rename to src/asyncflow/metrics/simulation_analyzer.py index b9a6ea2..9b82dc6 100644 --- a/src/asyncflow/metrics/analyzer.py +++ b/src/asyncflow/metrics/simulation_analyzer.py @@ -3,11 +3,15 @@ from __future__ import annotations from collections import defaultdict -from typing import TYPE_CHECKING +from typing import TYPE_CHECKING, TypedDict import numpy as np -from asyncflow.config.constants import LatencyKey, SampledMetricName +from asyncflow.config.constants import ( + EventMetricName, + LatencyKey, + SampledMetricName, +) from asyncflow.config.plot_constants import ( LATENCY_PLOT, RAM_PLOT, @@ -15,6 +19,7 @@ THROUGHPUT_PLOT, PlotCfg, ) +from asyncflow.metrics.server import ServerClock if TYPE_CHECKING: # Standard library typing imports in type-checking block (TC003). @@ -29,10 +34,22 @@ from asyncflow.schemas.settings.simulation import SimulationSettings -# Short alias to keep signatures within 88 chars (E501). +# Short alias to keep signatures within 88 chars. Series = tuple[list[float], list[float]] +class ServerArrays(TypedDict): + """Object to collect relevant data for each server""" + + latencies: list[float] + service_time: list[float] + io_time: list[float] + waiting_time: list[float] + finish_times: list[float] + +ServerArraysMap = dict[str, ServerArrays] + + class ResultsAnalyzer: """Analyze and visualize the results of a completed simulation. @@ -68,18 +85,122 @@ def __init__( self.throughput_series: Series | None = None # Sampled metrics are stored with string metric keys for simplicity. self.sampled_metrics: dict[str, dict[str, list[float]]] | None = None + # Per-server, per-request arrays (filled lazily by _collect_server_event_arrays) + # Map: server_id -> { + # 'latencies': list[float], # server-side (finish - start) + # 'service_time': list[float], + # 'io_time': list[float], + # 'waiting_time': list[float], + # 'finish_times': list[float], # for per-server throughput + # } + self.server_event_arrays: ServerArraysMap | None = None # ───────────────────────────────────────────── # Core computation # ───────────────────────────────────────────── def process_all_metrics(self) -> None: """Compute all aggregated and sampled metrics if not already done.""" + # Client-side: end-to-end latencies + 1s throughput if self.latency_stats is None and self._client.rqs_clock: self._process_event_metrics() + # Sampled time series from servers/edges (RAM, queues, etc.) if self.sampled_metrics is None: self._extract_sampled_metrics() + # Per-server per-request arrays (service/io/wait/server-latency/finishes) + self.get_server_event_arrays() # single call, handles lazy init + + def _build_server_event_arrays(self) -> ServerArraysMap: + """Pure builder: returns {server_id -> arrays} without mutating self.""" + out: ServerArraysMap = {} + + for srv in self._servers: + sid = srv.server_config.id + latencies: list[float] = [] + service: list[float] = [] + io_w: list[float] = [] + wait: list[float] = [] + finishes: list[float] = [] + + # srv.server_rqs_clock: Mapping[int, MetricBucket] + for bucket in srv.server_rqs_clock.values(): + # Server clock (if present and completed) + clock = bucket.get(EventMetricName.RQS_SERVER_CLOCK) + if isinstance(clock, ServerClock) and clock.finish is not None: + latencies.append(float(clock.finish - clock.start)) + finishes.append(float(clock.finish)) + + # Accumulators are floats in the bucket + st = bucket.get(EventMetricName.SERVICE_TIME, 0.0) + if isinstance(st, float): + service.append(st) + + it = bucket.get(EventMetricName.IO_TIME, 0.0) + if isinstance(it, float): + io_w.append(it) + + wt = bucket.get(EventMetricName.WAITING_TIME, 0.0) + if isinstance(wt, float): + wait.append(wt) + + out[sid] = ServerArrays( + latencies=latencies, + service_time=service, + io_time=io_w, + waiting_time=wait, + finish_times=finishes, + ) + + return out + + def _ensure_server_arrays(self) -> ServerArraysMap: + """Ensure self.server_event_arrays is built exactly once, and return it.""" + if self.server_event_arrays is None: + self.server_event_arrays = self._build_server_event_arrays() + return self.server_event_arrays + + def get_server_event_arrays(self) -> ServerArraysMap: + """Return {server_id -> per-request arrays} (computed lazily).""" + return self._ensure_server_arrays() + + def get_server_throughput_series( + self, server_id: str, *, window_s: float | None = None, + ) -> Series: + """ + Return (timestamps, RPS) for a single server + in fixed windows (default 1s) + """ + if window_s is None: + window_s = ResultsAnalyzer._WINDOW_SIZE_S + + arrays = self.get_server_event_arrays().get(server_id) + if arrays is None: + return ([], []) + + finishes = sorted(arrays["finish_times"]) + if not finishes: + return ([], []) + + end_time = self._settings.total_simulation_time + timestamps: list[float] = [] + rps_values: list[float] = [] + idx = 0 + window = float(window_s) + current_end = window + + while current_end <= end_time: + count = 0 + while idx < len(finishes) and finishes[idx] <= current_end: + count += 1 + idx += 1 + timestamps.append(current_end) + rps_values.append(count / window) + current_end += window + + return (timestamps, rps_values) + + def _process_event_metrics(self) -> None: """Calculate latency stats and throughput time series (1s RPS).""" # 1) Latencies @@ -533,7 +654,6 @@ def plot_single_server_io_queue(self, ax: Axes, server_id: str) -> None: leg.get_frame().set_facecolor("white") - def plot_single_server_ram(self, ax: Axes, server_id: str) -> None: """Plot RAM usage with mean/min/max lines and a single legend box with values. No trend/ewma, no legend entry for the main series. @@ -587,3 +707,187 @@ def plot_single_server_ram(self, ax: Axes, server_id: str) -> None: fontsize=9.5, ) leg.get_frame().set_facecolor("white") + + # ------------------------------------------------- + # SERVER METRICS PLOT + #-------------------------------------------------- + + def _plot_histogram_with_overlays( + self, + ax: Axes, + data: list[float], + *, + title: str, + xlabel: str, + show_p50: bool = False, + ) -> None: + """Render a histogram with mean/(optional)P50/P95/P99 overlays + and a compact legend. + """ + if not data: + ax.text(0.5, 0.5, "No data", ha="center", va="center") + ax.set_title(title) + ax.set_xlabel(xlabel) + ax.set_ylabel("count") + ax.grid(visible=True) + return + + # Colors consistent with the rest of the module + col_mean = "#d62728" # red + col_p50 = "#ff7f0e" # orange + col_p95 = "#2ca02c" # green + col_p99 = "#9467bd" # purple + hist_color = "#1f77b4" # soft blue + + arr = np.asarray(data, dtype=float) + v_mean = float(np.mean(arr)) + v_p95 = float(np.percentile(arr, 95)) + v_p99 = float(np.percentile(arr, 99)) + + # Histogram (subtle to let overlays stand out) + ax.hist( + arr, bins=50, color=hist_color, alpha=0.40, + edgecolor="none", zorder=1, + ) + + # Overlays + ax.axvline( + v_mean, color=col_mean, linestyle=":", linewidth=1.8, + alpha=0.95, zorder=3, + ) + handles: list[Line2D] = [] + + # Legend handles (dummy lines with values) + h_mean = ax.plot( + [], [], color=col_mean, linestyle=":", linewidth=2.4, + label=f"mean = {v_mean:.3f}", + )[0] + handles.append(h_mean) + + if show_p50: + v_p50 = float(np.percentile(arr, 50)) + ax.axvline( + v_p50, color=col_p50, linestyle="-.", linewidth=1.6, + alpha=0.90, zorder=3, + ) + h_p50 = ax.plot( + [], [], color=col_p50, linestyle="-.", linewidth=2.4, + label=f"P50 = {v_p50:.3f}", + )[0] + handles.append(h_p50) + + ax.axvline( + v_p95, color=col_p95, linestyle="--", linewidth=1.6, + alpha=0.90, zorder=3, + ) + ax.axvline( + v_p99, color=col_p99, linestyle="--", linewidth=1.6, + alpha=0.90, zorder=3, + ) + + h_p95 = ax.plot( + [], [], color=col_p95, linestyle="--", linewidth=2.4, + label=f"P95 = {v_p95:.3f}", + )[0] + h_p99 = ax.plot( + [], [], color=col_p99, linestyle="--", linewidth=2.4, + label=f"P99 = {v_p99:.3f}", + )[0] + handles.extend([h_p95, h_p99]) + + # Titles / labels / grid + ax.set_title(title) + ax.set_xlabel(xlabel) + ax.set_ylabel("count") + ax.grid(visible=True) + + # Legend (top-right) with readable background + leg = ax.legend( + handles=handles, + loc="upper right", + bbox_to_anchor=(0.98, 0.98), + borderaxespad=0.0, + framealpha=0.90, + fancybox=True, + handlelength=2.6, + fontsize=9.5, + ) + leg.get_frame().set_facecolor("white") + + + def plot_server_event_metrics_dashboard( + self, + ax_latency_hist: Axes, + ax_service_hist: Axes, + ax_io_hist: Axes, + ax_wait_hist: Axes, + server_id: str, + ) -> None: + """Dashboard of per-request distributions for a single server: + - server-side latency (finish - start) + - accumulated SERVICE_TIME (CPU) + - accumulated IO_TIME + - accumulated WAITING_TIME + """ + arrays = self.get_server_event_arrays().get(server_id, None) + if arrays is None: + # Graceful empty state for all panes + for ax, msg in [ + (ax_latency_hist, "No server-side latencies"), + (ax_service_hist, "No service-time samples"), + (ax_io_hist, "No I/O-time samples"), + (ax_wait_hist, "No waiting-time samples"), + ]: + ax.text(0.5, 0.5, msg, ha="center", va="center") + ax.grid(visible=True) + return + + # 1) Server-side latency histogram (mean/P50/P95/P99) + self._plot_histogram_with_overlays( + ax_latency_hist, + arrays["latencies"], + title=f"Server latency — {server_id}", + xlabel="seconds", + show_p50=True, + ) + + # 2) CPU service time (mean/P95/P99) + self._plot_histogram_with_overlays( + ax_service_hist, + arrays["service_time"], + title=f"CPU service time — {server_id}", + xlabel="seconds", + show_p50=False, + ) + + # 3) I/O wait time (mean/P95/P99) + self._plot_histogram_with_overlays( + ax_io_hist, + arrays["io_time"], + title=f"I/O time — {server_id}", + xlabel="seconds", + show_p50=False, + ) + + # 4) CPU waiting time (mean/P95/P99) + self._plot_histogram_with_overlays( + ax_wait_hist, + arrays["waiting_time"], + title=f"CPU waiting time — {server_id}", + xlabel="seconds", + show_p50=False, + ) + + def plot_server_timeseries_dashboard( + self, + ax_ready: Axes, + ax_io: Axes, + ax_ram: Axes, + server_id: str, + ) -> None: + """Quick dashboard for one server: Ready queue, I/O queue, and RAM series.""" + # Reuse existing single-plot helpers for consistency. + self.plot_single_server_ready_queue(ax_ready, server_id) + self.plot_single_server_io_queue(ax_io, server_id) + self.plot_single_server_ram(ax_ram, server_id) + diff --git a/src/asyncflow/metrics/sweep_analyzer.py b/src/asyncflow/metrics/sweep_analyzer.py new file mode 100644 index 0000000..6d50dd3 --- /dev/null +++ b/src/asyncflow/metrics/sweep_analyzer.py @@ -0,0 +1,455 @@ +""" +SweepAnalyzer — build plots from a sweep over *mean concurrent users*. + +Global +------ +- Throughput (mean RPS) vs. users +- Mean latency (W) vs. users +- (Opzionale) Latency percentiles vs. users + +Per-server (overlay) +-------------------- +- Utilization rho_i vs. users +- Waiting time Wq_i vs. users +- Service rate mu_i vs. users +- Throughput lambda_i vs. users +""" + +from __future__ import annotations + +from dataclasses import dataclass +from typing import TYPE_CHECKING, Literal, cast + +import matplotlib.pyplot as plt + +from asyncflow.config.constants import LatencyKey + +if TYPE_CHECKING: # pragma: no cover + from collections.abc import Iterable + + from matplotlib.axes import Axes + from matplotlib.figure import Figure + + from asyncflow.metrics.simulation_analyzer import ResultsAnalyzer + + +# ────────────────────────────────────────────────────────────────────── +# Data containers +# ────────────────────────────────────────────────────────────────────── + +@dataclass(frozen=True) +class GlobalPoint: + """One sweep point (global/system metrics collected today).""" + + users: int + lambda_rps: float # mean throughput (RPS) + W: float # mean end-to-end latency (s) + p50: float # latency median (s) + p95: float # latency P95 (s) + p99: float # latency P99 (s) + + +@dataclass(frozen=True) +class ServerPoint: + """One sweep point for a single server.""" + + users: int + server_id: str + lambda_rps: float # server throughput (estimated) + mu_rps: float # 1 / mean(service_time) + rho: float # lambda / mu + Wq: float # mean waiting time (s) + service_mean_s: float # mean service time (s) + completions: int # number of completed requests + server_latency_mean_s: float + + +# ────────────────────────────────────────────────────────────────────── +# Analyzer +# ────────────────────────────────────────────────────────────────────── + +class SweepAnalyzer: + """ + Build plots from a sweep over *mean concurrent users*. + + Input + ----- + pairs : Iterable[tuple[int, ResultsAnalyzer]] + Output of Sweep.sweep_on_user(...): (users, analyzer). + + Caching + ------- + Collections are private and executed once. All plotters read from caches. + """ + + def __init__(self, pairs: Iterable[tuple[int, ResultsAnalyzer]]) -> None: + """Initialize with (users, ResultsAnalyzer) pairs and prepare caches.""" + self._pairs: list[tuple[int, ResultsAnalyzer]] = sorted( + (int(u), ra) for (u, ra) in pairs + ) + # Caches + self._global_points: list[GlobalPoint] = [] + self._server_points: dict[str, list[ServerPoint]] = {} + self._collected_global: bool = False + self._collected_servers: bool = False + + # ────────────────────────────────────────────────────────────────── + # Public convenience + # ────────────────────────────────────────────────────────────────── + + def precollect(self) -> None: + """Warm both caches once (optional).""" + self._ensure_global_collected() + self._ensure_servers_collected() + + # ────────────────────────────────────────────────────────────────── + # Private collectors (one-time) + # ────────────────────────────────────────────────────────────────── + + def _ensure_global_collected(self) -> None: + if self._collected_global: + return + self._collect_global() + self._collected_global = True + + def _ensure_servers_collected(self) -> None: + if self._collected_servers: + return + self._collect_servers() + self._collected_servers = True + + def _collect_global(self) -> None: + """Compute global/system metrics (throughput & latency) once.""" + out: list[GlobalPoint] = [] + + for users, ra in self._pairs: + # Ensure metrics are computed + ra.process_all_metrics() + + # λ: mean throughput from the time series + _, rps_series = ra.get_throughput_series() + if rps_series: + lambda_rps = float(sum(rps_series)) / float(len(rps_series)) + else: + lambda_rps = 0.0 + + # Latency stats → W and percentiles + lat = ra.get_latency_stats() + w_mean = float(lat.get(LatencyKey.MEAN, 0.0)) + p50 = float(lat.get(LatencyKey.MEDIAN, 0.0)) + p95 = float(lat.get(LatencyKey.P95, 0.0)) + p99 = float(lat.get(LatencyKey.P99, 0.0)) + + out.append( + GlobalPoint( + users=users, + lambda_rps=lambda_rps, + W=w_mean, + p50=p50, + p95=p95, + p99=p99, + ), + ) + + self._global_points = out + + def _collect_servers(self) -> None: + """ + Compute per-server metrics across the sweep once. + + Server throughput λᵢ is estimated via completions split: + λᵢ ≈ (nᵢ / Σⱼ nⱼ) · λ_tot + """ + points: dict[str, list[ServerPoint]] = {} + + for users, ra in self._pairs: + ra.process_all_metrics() + + # Global lambda for proportional split + _, rps_series = ra.get_throughput_series() + lambda_tot = ( + float(sum(rps_series)) / float(len(rps_series)) + if rps_series + else 0.0 + ) + + arrays_map = cast( + "dict[str, dict[str, list[float]]]", + ra.get_server_event_arrays(), + ) + sids = ra.list_server_ids() + + total_compl = 0 + per_server_compl: dict[str, int] = {} + for sid in sids: + arr_for_count: dict[str, list[float]] = arrays_map.get(sid, {}) + n = len(arr_for_count.get("finish_times", [])) + per_server_compl[sid] = n + total_compl += n + + for sid in sids: + arr: dict[str, list[float]] = arrays_map.get(sid, {}) + + # μᵢ from mean(service_time) + s_vals: list[float] = arr.get("service_time", []) + if s_vals: + s_mean = float(sum(s_vals)) / float(len(s_vals)) + mu = (1.0 / s_mean) if s_mean > 0.0 else float("inf") + else: + s_mean = 0.0 + mu = float("inf") + + # Wqᵢ from mean(waiting_time) + wq_vals: list[float] = arr.get("waiting_time", []) + wq_mean = ( + float(sum(wq_vals)) / float(len(wq_vals)) + if wq_vals + else 0.0 + ) + + # server latency + lat_vals: list[float] = arr.get("latencies", []) + if lat_vals: + server_lat_mean = float(sum(lat_vals)) / float(len(lat_vals)) + else: + server_lat_mean = wq_mean + ( + 1.0 / mu if mu not in (0.0, float("inf")) else s_mean) + + # λᵢ via proportional split of completions + n_i = per_server_compl.get(sid, 0) + if total_compl > 0: + lambda_i = (n_i / float(total_compl)) * lambda_tot + else: + lambda_i = 0.0 + + # ρᵢ = λᵢ / μᵢ + rho = (lambda_i / mu) if mu not in (0.0, float("inf")) else 0.0 + + points.setdefault(sid, []).append( + ServerPoint( + users=users, + server_id=sid, + lambda_rps=lambda_i, + mu_rps=mu, + rho=rho, + Wq=wq_mean, + service_mean_s=s_mean, + completions=n_i, + server_latency_mean_s=server_lat_mean, + ), + ) + + self._server_points = points + + # ────────────────────────────────────────────────────────────────── + # Global plotters (cached) + # ────────────────────────────────────────────────────────────────── + + def plot_global_throughput(self, ax: Axes) -> None: + """Plot mean throughput (RPS) vs. mean concurrent users.""" + self._ensure_global_collected() + pts = self._global_points + xs = [p.users for p in pts] + ys = [p.lambda_rps for p in pts] + ax.plot(xs, ys, marker="o") + ax.set_title("Throughput (mean RPS) vs. concurrent users") + ax.set_xlabel("Mean concurrent users") + ax.set_ylabel("RPS") + ax.grid(visible=True, alpha=0.3) + + def plot_global_latency(self, ax: Axes) -> None: + """Plot mean system time (W) vs. mean concurrent users.""" + self._ensure_global_collected() + pts = self._global_points + xs = [p.users for p in pts] + ys = [p.W for p in pts] + ax.plot(xs, ys, marker="o") + ax.set_title("Mean system time (W) vs. concurrent users") + ax.set_xlabel("Mean concurrent users") + ax.set_ylabel("W (seconds)") + ax.grid(visible=True, alpha=0.3) + + def plot_global_latency_percentiles(self, ax: Axes) -> None: + """Plot P50, P95, P99 latency vs. mean concurrent users.""" + self._ensure_global_collected() + pts = self._global_points + xs = [p.users for p in pts] + ax.plot(xs, [p.p50 for p in pts], marker="o", label="P50") + ax.plot(xs, [p.p95 for p in pts], marker="o", label="P95") + ax.plot(xs, [p.p99 for p in pts], marker="o", label="P99") + ax.set_title("Latency percentiles vs. concurrent users") + ax.set_xlabel("Mean concurrent users") + ax.set_ylabel("Latency (seconds)") + ax.legend() + ax.grid(visible=True, alpha=0.3) + + def plot_global_dashboard(self) -> Figure: + """1x2 dashboard: throughput and mean latency (W).""" + fig, axes = plt.subplots(1, 2, figsize=(12, 4.5), dpi=130) + self.plot_global_throughput(axes[0]) + self.plot_global_latency(axes[1]) + fig.tight_layout() + return fig + + # ────────────────────────────────────────────────────────────────── + # Per-server plotters (overlay; cached) + # ────────────────────────────────────────────────────────────────── + + def _select_top_servers( + self, + by: Literal["rho", "Wq", "mu", "lambda"], + max_servers: int, + ) -> list[str]: + """Pick up to `max_servers` “hottest” servers at max users (from cache).""" + self._ensure_servers_collected() + data = self._server_points + if not data: + return [] + + max_users = max( + (pt.users for pts in data.values() for pt in pts), + default=0, + ) + scores: list[tuple[str, float]] = [] + for sid, pts in data.items(): + at_max = [p for p in pts if p.users == max_users] + if not at_max: + continue + p = at_max[-1] + if by == "rho": + val = p.rho + elif by == "Wq": + val = p.Wq + elif by == "mu": + val = -p.mu_rps if p.mu_rps not in (0.0, float("inf")) else -0.0 + else: # "lambda" + val = p.lambda_rps + scores.append((sid, float(val))) + + scores.sort(key=lambda x: x[1], reverse=True) + return [sid for sid, _ in scores[:max_servers]] + + def plot_server_utilization_overlay( + self, + ax: Axes, + *, + max_servers: int = 5, + server_ids: list[str] | None = None, + ) -> None: + """Overlay of server utilization rho vs. users (auto-picks hottest)""" + self._ensure_servers_collected() + ids = server_ids or self._select_top_servers("rho", max_servers) + for sid in sorted(ids): + pts = self._server_points.get(sid, []) + xs = [p.users for p in pts] + ys = [p.rho for p in pts] + ax.plot(xs, ys, marker="o", label=sid) + ax.set_title("Server utilization (rho) vs. concurrent users") + ax.set_xlabel("Mean concurrent users") + ax.set_ylabel("rho") + if ids: + ax.legend() + ax.grid(visible=True, alpha=0.3) + + def plot_server_waiting_time_overlay( + self, + ax: Axes, + *, + max_servers: int = 5, + server_ids: list[str] | None = None, + ) -> None: + """Overlay of server waiting time Wqᵢ vs. users (auto-picks hottest)""" + self._ensure_servers_collected() + ids = server_ids or self._select_top_servers("Wq", max_servers) + for sid in sorted(ids): + pts = self._server_points.get(sid, []) + xs = [p.users for p in pts] + ys = [p.Wq for p in pts] + ax.plot(xs, ys, marker="o", label=sid) + ax.set_title("Server waiting time (Wq) vs. concurrent users") + ax.set_xlabel("Mean concurrent users") + ax.set_ylabel("Wq (seconds)") + if ids: + ax.legend() + ax.grid(visible=True, alpha=0.3) + + def plot_server_service_rate_overlay( + self, + ax: Axes, + *, + max_servers: int = 5, + server_ids: list[str] | None = None, + ) -> None: + """Overlay of server service rate μ vs. users (auto-picks hottest)""" + self._ensure_servers_collected() + ids = server_ids or self._select_top_servers("mu", max_servers) + for sid in sorted(ids): + pts = self._server_points.get(sid, []) + xs = [p.users for p in pts] + ys = [p.mu_rps for p in pts] + ax.plot(xs, ys, marker="o", label=sid) + ax.set_title("Server service rate (mu) vs. concurrent users") + ax.set_xlabel("Mean concurrent users") + ax.set_ylabel("mu (1/s)") + if ids: + ax.legend() + ax.grid(visible=True, alpha=0.3) + + def plot_server_throughput_overlay( + self, + ax: Axes, + *, + max_servers: int = 5, + server_ids: list[str] | None = None, + ) -> None: + """Overlay of server throughput λ vs. users (auto-picks hottest by default).""" + self._ensure_servers_collected() + ids = server_ids or self._select_top_servers("lambda", max_servers) + for sid in sorted(ids): + pts = self._server_points.get(sid, []) + xs = [p.users for p in pts] + ys = [p.lambda_rps for p in pts] + ax.plot(xs, ys, marker="o", label=sid) + ax.set_title("Server throughput (lambda) vs. concurrent users") + ax.set_xlabel("Mean concurrent users") + ax.set_ylabel("lambda (1/s)") + if ids: + ax.legend() + ax.grid(visible=True, alpha=0.3) + + def plot_server_latency_overlay( + self, ax: Axes, *, max_servers: int = 5, server_ids: list[str] | None = None, + ) -> None: + """Plot of the latency vs concurrent user""" + self._ensure_servers_collected() + ids = server_ids or self._select_top_servers("Wq", max_servers) + for sid in sorted(ids): + pts = self._server_points.get(sid, []) + xs = [p.users for p in pts] + ys = [p.server_latency_mean_s for p in pts] + ax.plot(xs, ys, marker="o", label=sid) + ax.set_title("Server latency (waiting+service) vs. concurrent users") + ax.set_xlabel("Mean concurrent users") + ax.set_ylabel("Server latency (s)") + if ids: + ax.legend() + ax.grid(visible=True, alpha=0.3) + + + def plot_server_dashboard(self) -> Figure: + """2x3 per-server overlay: rho_i, Wq_i, mu_i, lambda_i, server latency.""" + fig, axes = plt.subplots(2, 3, figsize=(16, 8), dpi=130) + + # Row 1 + self.plot_server_utilization_overlay(axes[0, 0]) + self.plot_server_waiting_time_overlay(axes[0, 1]) + self.plot_server_service_rate_overlay(axes[0, 2]) + + # Row 2 + self.plot_server_throughput_overlay(axes[1, 0]) + self.plot_server_latency_overlay(axes[1, 1]) + axes[1, 2].axis("off") # keep layout symmetric + + fig.tight_layout() + return fig + diff --git a/src/asyncflow/queue_theory_analysis/base.py b/src/asyncflow/queue_theory_analysis/base.py new file mode 100644 index 0000000..5de4bbb --- /dev/null +++ b/src/asyncflow/queue_theory_analysis/base.py @@ -0,0 +1,37 @@ +"""Base interfaces for queueing-theory analyzers. + +Each concrete analyzer (e.g. MM1) must: +- declare its compatibility rules against an AsyncFlow payload +- compute closed-form KPIs when assumptions are satisfied +""" + +from __future__ import annotations + +from abc import ABC, abstractmethod +from typing import TYPE_CHECKING + +if TYPE_CHECKING: + from asyncflow.schemas.payload import SimulationPayload + + +class QueueTheoryBase(ABC): + """Abstract base for all queue-theory analyzers.""" + + @abstractmethod + def explain_incompatibilities(self, payload: SimulationPayload) -> list[str]: + """Return a list of human-readable reasons why the payload is incompatible. + Empty list means 'compatible'. + """ + + def is_compatible(self, payload: SimulationPayload) -> bool: + """Shorthand boolean check.""" + return not self.explain_incompatibilities(payload) + + def validate_or_raise(self, payload: SimulationPayload) -> None: + """Raise ValueError with a compact message if incompatible.""" + errs = self.explain_incompatibilities(payload) + if errs: + bullet = "\n - " + msg = "Payload is not compatible with this queueing model:" + bullet + msg += bullet.join(errs) + raise ValueError(msg) diff --git a/src/asyncflow/queue_theory_analysis/mm1.py b/src/asyncflow/queue_theory_analysis/mm1.py new file mode 100644 index 0000000..6c22b64 --- /dev/null +++ b/src/asyncflow/queue_theory_analysis/mm1.py @@ -0,0 +1,423 @@ +""" +Check if asyncflow under the hypothesis of a mm1 queue +reproduce the theory. +""" + +from __future__ import annotations + +import sys +from typing import TYPE_CHECKING, TextIO, TypedDict, cast + +from asyncflow.config.constants import ( + Distribution, + EndpointStepCPU, + LatencyKey, + StepOperation, +) +from asyncflow.queue_theory_analysis.base import QueueTheoryBase +from asyncflow.schemas.common.random_variables import RVConfig + +if TYPE_CHECKING: + from collections.abc import Callable + + from asyncflow.metrics.simulation_analyzer import ResultsAnalyzer + from asyncflow.schemas.payload import SimulationPayload + + +class MM1Results(TypedDict): + """Closed-form KPIs for an M/M/1 queue.""" + + lambda_rate: float # arrival rate (1/s) + mu_rate: float # service rate (1/s) + rho: float # utilization + L: float # mean items in system + Lq: float # mean items in queue + W: float # mean time in system (s) + Wq: float # mean waiting time (s) + + +class KPIRow(TypedDict): + """One formatted row for theory vs observed comparison.""" + + symbol: str + name: str + theory: float | str + observed: float | str + abs_diff: float | str + rel_diff_pct: float | str # percentage (e.g., "3.2" means +3.2%) + + +class MM1(QueueTheoryBase): + """Analyzer for the M/M/1 queue with strict model checks.""" + + # Upper bound for "negligible" deterministic network latency + MAX_EDGE_LATENCY_S: float = 1e-3 # 1 ms + + # ────────────────────────────────────────────────────────────────── + # Compatibility checks split into helpers to keep cyclomatic low + # ────────────────────────────────────────────────────────────────── + def _check_topology(self, payload: SimulationPayload) -> list[str]: + errs: list[str] = [] + nodes = payload.topology_graph.nodes + if len(nodes.servers) != 1: + errs.append("requires exactly one server (no parallel servers).") + if nodes.load_balancer is not None: + errs.append("load balancer must be absent (fan-out not allowed).") + return errs + + def _check_generator(self, payload: SimulationPayload) -> list[str]: + errs: list[str] = [] + gen = payload.rqs_input + if gen.avg_active_users.distribution != Distribution.POISSON: + errs.append("avg_active_users must be Poisson.") + if gen.avg_request_per_minute_per_user.distribution != Distribution.POISSON: + errs.append("avg_request_per_minute_per_user must be Poisson.") + if gen.avg_active_users.mean <= 0: + errs.append("avg_active_users.mean must be > 0.") + if gen.avg_request_per_minute_per_user.mean <= 0: + errs.append("avg_request_per_minute_per_user.mean must be > 0.") + return errs + + def _check_edges(self, payload: SimulationPayload) -> list[str]: + errs: list[str] = [] + for edge in payload.topology_graph.edges: + latency = edge.latency + if isinstance(latency, RVConfig): + errs.append( + f"edge '{edge.id}' latency must be deterministic (<=1ms), " + "not a random variable.", + ) + continue + if float(latency) > self.MAX_EDGE_LATENCY_S: + errs.append( + f"edge '{edge.id}' deterministic latency must be <= 1 ms.", + ) + return errs + + def _check_server_model(self, payload: SimulationPayload) -> list[str]: + errs: list[str] = [] + srv = payload.topology_graph.nodes.servers[0] + if len(srv.endpoints) != 1: + errs.append("server must expose exactly one endpoint.") + return errs + + steps = srv.endpoints[0].steps + if len(steps) != 1: + errs.append("endpoint must contain exactly one step.") + return errs + + step = steps[0] + if not isinstance(step.kind, EndpointStepCPU): + errs.append("the single step must be CPU-bound.") + return errs + + op_key, op_data = next(iter(step.step_operation.items())) + if op_key is not StepOperation.CPU_TIME: + errs.append("CPU step must use CPU_TIME as its operation.") + return errs + + # Must be exponential RV (not deterministic) + if not isinstance(op_data, RVConfig): + errs.append("service time must be an exponential RVConfig.") + return errs + if op_data.distribution != Distribution.EXPONENTIAL: + errs.append("service time distribution must be exponential.") + if op_data.mean <= 0: + errs.append("service time mean must be > 0.") + return errs + + # ------------- Compatibility (public) -------------------------------- + def explain_incompatibilities( + self, payload: SimulationPayload, + ) -> list[str]: + """Collect and return all MM1 assumption violations.""" + errors: list[str] = [] + errors.extend(self._check_topology(payload)) + errors.extend(self._check_generator(payload)) + errors.extend(self._check_edges(payload)) + # Only check server model if we do have servers + if payload.topology_graph.nodes.servers: + errors.extend(self._check_server_model(payload)) + return errors + + # ────────────────────────────────────────────────────────────────── + # Closed forms + # ────────────────────────────────────────────────────────────────── + def _arrival_rate_lambda(self, payload: SimulationPayload) -> float: + """λ = users_mean * rpm_per_user / 60.""" + gen = payload.rqs_input + users = float(gen.avg_active_users.mean) + rpm = float(gen.avg_request_per_minute_per_user.mean) + return users * rpm / 60.0 + + def _service_rate_mu(self, payload: SimulationPayload) -> float: + """μ = 1 / E[S] from the single CPU exponential step.""" + srv = payload.topology_graph.nodes.servers[0] + step = srv.endpoints[0].steps[0] + op_key, op_val = next(iter(step.step_operation.items())) + assert op_key is StepOperation.CPU_TIME + rv = cast("RVConfig", op_val) + assert rv.distribution is Distribution.EXPONENTIAL + return 1.0 / float(rv.mean) + + def _theoretical_kpis(self, payload: SimulationPayload) -> MM1Results: + """Closed-form KPIs. For rho>=1 returns +inf for divergent metrics.""" + self.validate_or_raise(payload) + + lam = self._arrival_rate_lambda(payload) + mu = self._service_rate_mu(payload) + rho = lam / mu + + if rho >= 1.0: + inf = float("inf") + return MM1Results( + lambda_rate=lam, + mu_rate=mu, + rho=rho, + L=inf, + Lq=inf, + W=inf, + Wq=inf, + ) + + l_sys = rho / (1.0 - rho) + lq = (rho * rho) / (1.0 - rho) + w_sys = 1.0 / (mu - lam) + wq = rho / (mu - lam) + + return MM1Results( + lambda_rate=lam, + mu_rate=mu, + rho=rho, + L=l_sys, + Lq=lq, + W=w_sys, + Wq=wq, + ) + + def evaluate(self, payload: SimulationPayload) -> MM1Results: + """Public entry-point: return closed-form KPIs for this payload.""" + return self._theoretical_kpis(payload) + + + # ────────────────────────────────────────────────────────────────── + # Observed KPIs from a run (no private members) + # ────────────────────────────────────────────────────────────────── + def _observed_kpis(self, ra: ResultsAnalyzer) -> MM1Results: + """ + Empirical KPIs from the analyzer: + - lambda_hat: average throughput across windows + - mu_hat: 1 / mean(service_time) + - W_hat: mean end-to-end latency (client) + - Wq_hat: mean waiting_time (server arrays) + - L_hat: lambda_hat * W_hat (Little's law) + - Lq_hat: lambda_hat * Wq_hat + """ + ra.process_all_metrics() + + # λ̂ via throughput series (mean of window RPS) + ts, rps = ra.get_throughput_series() + lambda_hat = (sum(rps) / len(rps)) if rps else 0.0 + + # Ŵ from latency stats + lat_stats = ra.get_latency_stats() + w_hat = float(lat_stats.get(LatencyKey.MEAN, 0.0)) + + # Per-server arrays (first server if present) + server_ids = ra.list_server_ids() + arrays_map = ra.get_server_event_arrays() + arrays = arrays_map.get(server_ids[0]) if server_ids else None + + # mean service time and wait + if arrays and arrays["service_time"]: + s_vals = arrays["service_time"] + s_mean = float(sum(s_vals)) / float(len(s_vals)) + else: + s_mean = 0.0 + mu_hat = (1.0 / s_mean) if s_mean > 0.0 else float("inf") + + if arrays and arrays["waiting_time"]: + wq_vals = arrays["waiting_time"] + wq_hat = float(sum(wq_vals)) / float(len(wq_vals)) + else: + wq_hat = 0.0 + + l_hat = lambda_hat * w_hat + lq_hat = lambda_hat * wq_hat + rho_hat = ( + lambda_hat / mu_hat if mu_hat not in (0.0, float("inf")) else 0.0 + ) + + return MM1Results( + lambda_rate=lambda_hat, + mu_rate=mu_hat, + rho=rho_hat, + L=l_hat, + Lq=lq_hat, + W=w_hat, + Wq=wq_hat, + ) + + # ────────────────────────────────────────────────────────────────── + # Comparison table + # ────────────────────────────────────────────────────────────────── + @staticmethod + def _safe_delta(theory: float, obs: float) -> tuple[str, str, str]: + """Return (theory_str, abs_diff_str, rel_diff_str) with inf-safe logic.""" + def fmt(x: float) -> str: + return "∞" if x == float("inf") else f"{x:.6f}" + + th_s = fmt(theory) + if theory == float("inf"): + return th_s, "—", "—" + + abs_d = obs - theory + rel = (abs_d / theory * 100.0) if theory != 0.0 else float("inf") + rel_s = "∞" if rel == float("inf") else f"{rel:.2f}" + return th_s, f"{abs_d:.6f}", rel_s + + def compare_against_run( + self, + payload: SimulationPayload, + ra: ResultsAnalyzer, + ) -> list[KPIRow]: + """ + Build a table with theory vs observed and absolute/relative deltas. + + Returns + ------- + list[KPIRow] + Rows in a stable order suitable for printing or DataFrame usage. + + """ + self.validate_or_raise(payload) + + th = self._theoretical_kpis(payload) + ob = self._observed_kpis(ra) + + rows: list[KPIRow] = [] + + def add(symbol: str, name: str, getter: Callable[[MM1Results], float]) -> None: + th_v = float(getter(th)) + ob_v = float(getter(ob)) + th_s, abs_s, rel_s = self._safe_delta(th_v, ob_v) + rows.append( + KPIRow( + symbol=symbol, + name=name, + theory=th_s, + observed=f"{ob_v:.6f}", + abs_diff=abs_s, + rel_diff_pct=rel_s, + ), + ) + + add("λ", "Arrival rate (1/s)", lambda m: m["lambda_rate"]) + add("μ", "Service rate (1/s)", lambda m: m["mu_rate"]) + add("rho", "Utilization", lambda m: m["rho"]) + add("L", "Mean items in system", lambda m: m["L"]) + add("Lq", "Mean items in queue", lambda m: m["Lq"]) + add("W", "Mean time in system (s)", lambda m: m["W"]) + add("Wq", "Mean waiting time (s)", lambda m: m["Wq"]) + + return rows + + # ────────────────────────────────────────────────────────────────── + # Pretty printing + # ────────────────────────────────────────────────────────────────── + + @staticmethod + def _format_rows_table(rows: list[KPIRow]) -> str: + """ + Return a compact ASCII table for `compare_against_run(...)` rows. + + The layout is stable, with right-aligned numeric columns and widths + computed from the data for nice alignment in plain-text consoles. + """ + # Extract as strings (observed/theory already formatted in rows). + data: list[tuple[str, str, str, str, str, str]] = [ + ( + r["symbol"], + r["name"], + str(r["theory"]), + str(r["observed"]), + str(r["abs_diff"]), + str(r["rel_diff_pct"]), + ) + for r in rows + ] + + headers = ("sym", "metric", "theory", "observed", "abs", "rel%") + + # Compute column widths. + w_sym = max(len(headers[0]), *(len(d[0]) for d in data)) + w_met = max(len(headers[1]), *(len(d[1]) for d in data)) + w_th = max(len(headers[2]), *(len(d[2]) for d in data)) + w_ob = max(len(headers[3]), *(len(d[3]) for d in data)) + w_abs = max(len(headers[4]), *(len(d[4]) for d in data)) + w_rel = max(len(headers[5]), *(len(d[5]) for d in data)) + + # Title and separators sized to the header length. + header_line = ( + f"{headers[0]:<{w_sym}} {headers[1]:<{w_met}} " + f"{headers[2]:>{w_th}} {headers[3]:>{w_ob}} " + f"{headers[4]:>{w_abs}} {headers[5]:>{w_rel}}" + ) + sep = "-" * len(header_line) + title = "MM1 - Theory vs Observed" + top = "=" * max(len(title), len(header_line)) + + lines: list[str] = [ + top, + title, + sep, + header_line, + sep, + ] + + for sym, met, th, ob, ad, rd in data: + lines.append( + f"{sym:<{w_sym}} {met:<{w_met}} " + f"{th:>{w_th}} {ob:>{w_ob}} {ad:>{w_abs}} {rd:>{w_rel}}", + ) + + lines.append(top) + return "\n".join(lines) + + def compare_and_format( + self, + payload: SimulationPayload, + ra: ResultsAnalyzer, + ) -> str: + """ + Convenience: run `compare_against_run()` and return a formatted table. + + Use this when you want a ready-to-print string for logs/CLI output. + """ + rows = self.compare_against_run(payload, ra) + return self._format_rows_table(rows) + + def print_comparison( + self, + payload: SimulationPayload, + ra: ResultsAnalyzer, + *, + file: TextIO | None = None, + ) -> None: + """ + Print a pretty 'theory vs observed' table to the given stream. + + Parameters + ---------- + payload : SimulationPayload + The validated simulation payload. + ra : ResultsAnalyzer + Results analyzer with processed metrics. + file : TextIO | None + Output stream (defaults to stdout). + + """ + out = self.compare_and_format(payload, ra) + stream: TextIO = sys.stdout if file is None else file + print(out, file=stream) + diff --git a/src/asyncflow/runtime/simulation_runner.py b/src/asyncflow/runner/simulation.py similarity index 97% rename from src/asyncflow/runtime/simulation_runner.py rename to src/asyncflow/runner/simulation.py index 08ae0df..8669266 100644 --- a/src/asyncflow/runtime/simulation_runner.py +++ b/src/asyncflow/runner/simulation.py @@ -12,8 +12,8 @@ import simpy import yaml -from asyncflow.metrics.analyzer import ResultsAnalyzer from asyncflow.metrics.collector import SampledMetricCollector +from asyncflow.metrics.simulation_analyzer import ResultsAnalyzer from asyncflow.resources.registry import ResourcesRuntime from asyncflow.runtime.actors.client import ClientRuntime from asyncflow.runtime.actors.edge import EdgeRuntime @@ -199,9 +199,6 @@ def _build_load_balancer(self) -> None: lb_box=self._make_inbox(), ) - - - def _build_edges(self) -> None: """Initialization of the edges runtime dictionary from the input data""" # We need to merge all previous dictionary for the nodes to assign @@ -397,5 +394,13 @@ def from_yaml( payload = SimulationPayload.model_validate(data) return cls(env=env, simulation_input=payload) + # Method usefull to pass to the sweep class a payload + # directly from a yaml + @classmethod + def payload_from_yaml(cls, yaml_path: str | Path) -> SimulationPayload: + """Helper to return a valid payload""" + data = yaml.safe_load(Path(yaml_path).read_text()) + return SimulationPayload.model_validate(data) + diff --git a/src/asyncflow/runner/sweep.py b/src/asyncflow/runner/sweep.py new file mode 100644 index 0000000..ed87819 --- /dev/null +++ b/src/asyncflow/runner/sweep.py @@ -0,0 +1,129 @@ +""" +class to define method to iterate over some variables of the input +to evaluate how a given scenario with different initial conditions +(for example the number of concurrent users), behave. It is really +useful to find insights and analyze eventual breakpoint on a given +topology. Right now the class will accept only as a varying parameter +the concurrent users, in the future we will extend it to arbitrary +parameters. +""" + + +import simpy + +from asyncflow.metrics.simulation_analyzer import ResultsAnalyzer +from asyncflow.runner.simulation import SimulationRunner +from asyncflow.schemas.payload import SimulationPayload + + +class Sweep: + """ + Class to manage scenario when we want to iterate over a + set of initial data to see for example the impact on a defined + topology varying the initial workload + """ + + def __init__( + self, + *, + # passing the object class not instance of the class + # Why: + # - Each sweep run must be isolated: fresh Environment, fresh state, + # fresh queues. + # - Reusing a single instance would carry state from the previous run + # (SimPy processes, resources, partial metrics, RNG state, etc.) + # → tainted results. + # - By passing the CLASS we can instantiate on demand inside the loop, + # guaranteeing a fresh object for every grid point. + simulation_cls: type[SimulationRunner] = SimulationRunner, + ) -> None: + """ + Instantiation of the sweep class + Args: + simulation_cls (type[SimulationRunner], optional): object of + the SimulationRunner class + """ + self.simulation_cls = simulation_cls + + # to trace the last grid + self._last_users_grid: list[int] = [] + + # --------------------------------------------------- + # Helpers + # --------------------------------------------------- + + @staticmethod + def _default_env_factory() -> simpy.Environment: + """Ritorna un Environment nuovo e pulito per ogni run.""" + return simpy.Environment() + + + + #---------------------------------------------------- + # Method to iterate over the users + # --------------------------------------------------- + + def sweep_on_user( + self, + # we pass a validated payload from yaml or from + # the pythonic builder + payload: SimulationPayload, + user_lower_bound: int, + user_upper_bound: int, + step: int, + ) -> list[tuple[int, ResultsAnalyzer]]: + """ + Function to prepare a list of results analzyer + with all the data necessary to evaluate how the + topology react on a given scenario by varying the + average concurrent users + """ + # Error handling to have a coherent interval + if step <= 0: + msg = "step must be > 0" + raise ValueError(msg) + + if user_lower_bound <= 0 or user_upper_bound <= 0: + msg = "The lower and upper bound must be strictly bigger than 0" + raise ValueError(msg) + + if user_upper_bound < user_lower_bound: + msg = "user_upper_bound must be >= user_lower_bound" + raise ValueError(msg) + + # definition of the grid + users_grid: list[int] = list( + range(user_lower_bound, user_upper_bound + 1, step)) + self._last_users_grid = users_grid.copy() + + # last grid used + self._last_users_grid = users_grid[:] + + results: list[tuple[int, ResultsAnalyzer]] = [] + + # Iteration to populate the list + for users in users_grid: + # 1) payload override + payload = payload.model_copy(deep=True) + payload.rqs_input.avg_active_users = ( + payload.rqs_input.avg_active_users.model_copy( + update={"mean": users}, + ) +) + + # 2) instantiation of the new object for the simulation run + runner = self.simulation_cls( + env=self._default_env_factory(), + simulation_input=payload, + ) + + analyzer = runner.run() + + # 3) Accumulation of the analyzer + results.append((users, analyzer)) + + return results + + + + diff --git a/src/asyncflow/runtime/actors/routing/lb_algorithms.py b/src/asyncflow/runtime/actors/routing/lb_algorithms.py index 47f950d..49763ba 100644 --- a/src/asyncflow/runtime/actors/routing/lb_algorithms.py +++ b/src/asyncflow/runtime/actors/routing/lb_algorithms.py @@ -35,7 +35,6 @@ def round_robin( return value - LB_TABLE: dict[LbAlgorithmsName, Callable[[OrderedDict[str, EdgeRuntime]], EdgeRuntime]] = { LbAlgorithmsName.LEAST_CONNECTIONS: least_connections, diff --git a/src/asyncflow/runtime/actors/server.py b/src/asyncflow/runtime/actors/server.py index 2fae18e..524cab3 100644 --- a/src/asyncflow/runtime/actors/server.py +++ b/src/asyncflow/runtime/actors/server.py @@ -3,8 +3,9 @@ during the simulation """ - -from collections.abc import Generator +from collections import defaultdict +from collections.abc import Generator, Mapping +from types import MappingProxyType from typing import cast import numpy as np @@ -15,12 +16,13 @@ EndpointStepCPU, EndpointStepIO, EndpointStepRAM, + EventMetricName, SampledMetricName, ServerResourceName, StepOperation, SystemNodes, ) -from asyncflow.metrics.server import build_server_metrics +from asyncflow.metrics.server import ServerClock, build_server_metrics from asyncflow.resources.server_containers import ServerContainers from asyncflow.runtime.actors.edge import EdgeRuntime from asyncflow.runtime.rqs_state import RequestState @@ -29,10 +31,34 @@ from asyncflow.schemas.settings.simulation import SimulationSettings from asyncflow.schemas.topology.nodes import Server +# Initialization of the nested dict to collect the metrics +# for the server +MetricValue = ServerClock | float +MetricBucket = dict[EventMetricName, MetricValue] class ServerRuntime: """class to define the server during the simulation""" + @staticmethod + def _new_metric_bucket() -> MetricBucket: + """ + Factory for a per-request metric bucket. + Returns a fresh dict pre-populated with cumulative metrics that + always start at 0.0 (I/O time, waiting time, service time). + Event-specific clocks (e.g. RQS_SERVER_CLOCK) are added later + when the request is actually dispatched. + This function is used as the `default_factory` for the + `_server_rqs_clock` defaultdict, so each new request id gets + its own independent bucket automatically. + """ + return { + EventMetricName.IO_TIME: 0.0, + EventMetricName.WAITING_TIME: 0.0, + EventMetricName.SERVICE_TIME: 0.0, + # RQS_SERVER_CLOCK will be added in the dispatcher + } + + def __init__( # noqa: PLR0913 self, *, @@ -79,6 +105,9 @@ def __init__( # noqa: PLR0913 settings.enabled_sample_metrics, ) + self._server_rqs_clock: defaultdict[int, MetricBucket] + self._server_rqs_clock = defaultdict(self._new_metric_bucket) + # ------------------------------------------------------------------ # HELPERS # ------------------------------------------------------------------ @@ -118,6 +147,46 @@ def _compute_latency_io( # Main function to elaborate a request # ------------------------------------------------------------------- + def _dispatcher(self) -> Generator[simpy.Event, None, None]: + """ + The main dispatcher loop. It pulls requests from the inbox and + spawns a new '_handle_request' process for each one. + """ + # we assume in the current model that there is a one + # to one correspondence between cpu cores and workers + # before entering in the loop in the current implementation + # we reserve the ram necessary to run the processes + if self.server_config.ram_per_process: + processes_ram = ( + self.server_config.ram_per_process * + self.server_config.server_resources.cpu_cores + ) + + yield self.server_resources[ + ServerResourceName.RAM.value + ].get(processes_ram) + + + while True: + # Wait for a request to arrive in the server's inbox + raw_state = yield self.server_box.get() + request_state = cast("RequestState", raw_state) + + # Start the collection of the metric initializing + # the principal key that is the unique id of the + # state elaborated + bucket = self._server_rqs_clock[request_state.id] + bucket[EventMetricName.RQS_SERVER_CLOCK] = ServerClock( + start=self.env.now, + ) + + # Spawn a new, independent process to handle this request + self.env.process(self._handle_request(request_state)) + + def start(self) -> simpy.Process: + """Generate the process to simulate the server inside simpy env""" + return self.env.process(self._dispatcher()) + # right now we disable the warnings but a refactor will be done soon def _handle_request( # noqa: PLR0915, PLR0912, C901 self, @@ -199,6 +268,7 @@ def _handle_request( # noqa: PLR0915, PLR0912, C901 core_locked = False is_in_io_queue = False waiting_cpu = False + wait_start: float | None = None # --- Step Execution: CPU & I/O dynamics --- @@ -251,6 +321,11 @@ def _handle_request( # noqa: PLR0915, PLR0912, C901 is_in_io_queue = False self._el_io_queue_len -= 1 + # core_locked is a local variable just for the single request + # if the request already block the core so we avoid all the if + # conditions and we add the coroutine, if it is not blocked, we + # have to ask for a core, because it might be occupy from another + # request if not core_locked: # simpy create an event and if it can be satisfied is triggered cpu_req = self.server_resources[ServerResourceName.CPU.value].get(1) @@ -258,6 +333,7 @@ def _handle_request( # noqa: PLR0915, PLR0912, C901 # no trigger ready queue without execution if not cpu_req.triggered: waiting_cpu = True + wait_start = self.env.now self._el_ready_queue_len += 1 # at this point wait for the cpu @@ -265,6 +341,18 @@ def _handle_request( # noqa: PLR0915, PLR0912, C901 # here the cpu is free if waiting_cpu: + assert wait_start is not None + bucket = self._server_rqs_clock[state.id] + + # mypy assert + value = bucket[EventMetricName.WAITING_TIME] + assert isinstance(value, float) + + # assign delta + bucket[EventMetricName.WAITING_TIME] = ( + value + (self.env.now - wait_start) + ) + wait_start = None waiting_cpu = False self._el_ready_queue_len -= 1 @@ -273,6 +361,16 @@ def _handle_request( # noqa: PLR0915, PLR0912, C901 cpu_time = self._compute_latency_cpu( step.step_operation[StepOperation.CPU_TIME], ) + + bucket = self._server_rqs_clock[state.id] + + # mypy assertion + value = bucket[EventMetricName.SERVICE_TIME] + assert isinstance(value, float) + + # delta assignment + bucket[EventMetricName.SERVICE_TIME] = value + cpu_time + # Execute the step giving back the control to the simpy env yield self.env.timeout(cpu_time) @@ -300,6 +398,14 @@ def _handle_request( # noqa: PLR0915, PLR0912, C901 is_in_io_queue = True self._el_io_queue_len += 1 + bucket = self._server_rqs_clock[state.id] + + # assert for mypy + value = bucket[EventMetricName.IO_TIME] + assert isinstance(value, float) + + # assign the delta + bucket[EventMetricName.IO_TIME] = value + io_time yield self.env.timeout(io_time) if core_locked: @@ -314,17 +420,19 @@ def _handle_request( # noqa: PLR0915, PLR0912, C901 waiting_cpu = False self._el_ready_queue_len -= 1 - if total_ram: - self._ram_in_use -= total_ram yield self.server_resources[ServerResourceName.RAM.value].put(total_ram) + bucket = self._server_rqs_clock[state.id] + clock = cast("ServerClock", bucket[EventMetricName.RQS_SERVER_CLOCK]) + clock.finish = self.env.now + assert self.out_edge is not None self.out_edge.transport(state) - # we need three accessor because we need to read these private attribute + # we need these accessor because we need to read these private attribute # in the sampled metric collector @property def ready_queue_len(self) -> int: @@ -346,36 +454,28 @@ def enabled_metrics(self) -> dict[SampledMetricName, list[float | int]]: """Read-only access to the metric store.""" return self._server_enabled_metrics - - - def _dispatcher(self) -> Generator[simpy.Event, None, None]: - """ - The main dispatcher loop. It pulls requests from the inbox and - spawns a new '_handle_request' process for each one. + @property + def server_rqs_clock(self) -> Mapping[int, MetricBucket]: """ - # we assume in the current model that there is a one - # to one correspondence between cpu cores and workers - # before entering in the loop in the current implementation - # we reserve the ram necessary to run the processes - if self.server_config.ram_per_process: - processes_ram = ( - self.server_config.ram_per_process * - self.server_config.server_resources.cpu_cores - ) + Read-only snapshot of the per-request server metrics. + + Returns + ------- + Mapping[int, MetricBucket] + A mapping from request id → metric bucket, where each bucket is a + dict[EventMetricName, float | ServerClock]. The top-level mapping is + immutable (cannot add/remove keys) and is created from a shallow copy + to avoid defaultdict autovivification. + + Notes + ----- + This is a *snapshot* of the current state: as the server runs, the + underlying buckets may continue to change. + Buckets themselves are not frozen; **do not mutate them** from callers. + Treat the returned structure as read-only. - yield self.server_resources[ - ServerResourceName.RAM.value - ].get(processes_ram) + """ + return MappingProxyType(dict(self._server_rqs_clock)) - while True: - # Wait for a request to arrive in the server's inbox - raw_state = yield self.server_box.get() - request_state = cast("RequestState", raw_state) - # Spawn a new, independent process to handle this request - self.env.process(self._handle_request(request_state)) - - def start(self) -> simpy.Process: - """Generate the process to simulate the server inside simpy env""" - return self.env.process(self._dispatcher()) diff --git a/src/asyncflow/schemas/settings/simulation.py b/src/asyncflow/schemas/settings/simulation.py index 7f0d145..4dbf5d4 100644 --- a/src/asyncflow/schemas/settings/simulation.py +++ b/src/asyncflow/schemas/settings/simulation.py @@ -32,6 +32,10 @@ class SimulationSettings(BaseModel): enabled_event_metrics: set[EventMetricName] = Field( default_factory=lambda: { EventMetricName.RQS_CLOCK, + EventMetricName.RQS_SERVER_CLOCK, + EventMetricName.SERVICE_TIME, + EventMetricName.IO_TIME, + EventMetricName.WAITING_TIME, }, description="Which per-event KPIs to collect by default.", ) diff --git a/tests/integration/conftest.py b/tests/integration/conftest.py index 2c94d6f..eb148a5 100644 --- a/tests/integration/conftest.py +++ b/tests/integration/conftest.py @@ -7,7 +7,7 @@ import pytest import simpy -from asyncflow.runtime.simulation_runner import SimulationRunner +from asyncflow.runner.simulation import SimulationRunner if TYPE_CHECKING: from collections.abc import Callable diff --git a/tests/integration/event_injection/lb_two_servers.py b/tests/integration/event_injection/lb_two_servers.py index 3c29e95..2a3e86a 100644 --- a/tests/integration/event_injection/lb_two_servers.py +++ b/tests/integration/event_injection/lb_two_servers.py @@ -21,7 +21,7 @@ import simpy from asyncflow.config.constants import Distribution, EventDescription, LatencyKey -from asyncflow.runtime.simulation_runner import SimulationRunner +from asyncflow.runner.simulation import SimulationRunner from asyncflow.schemas.common.random_variables import RVConfig from asyncflow.schemas.events.injection import EventInjection from asyncflow.schemas.payload import SimulationPayload @@ -38,7 +38,7 @@ from asyncflow.schemas.workload.rqs_generator import RqsGenerator if TYPE_CHECKING: - from asyncflow.metrics.analyzer import ResultsAnalyzer + from asyncflow.metrics.simulation_analyzer import ResultsAnalyzer def _server(sid: str) -> Server: diff --git a/tests/integration/event_injection/single_server.py b/tests/integration/event_injection/single_server.py index 4431786..c6fe33a 100644 --- a/tests/integration/event_injection/single_server.py +++ b/tests/integration/event_injection/single_server.py @@ -20,7 +20,7 @@ import simpy from asyncflow.config.constants import Distribution, EventDescription, LatencyKey -from asyncflow.runtime.simulation_runner import SimulationRunner +from asyncflow.runner.simulation import SimulationRunner from asyncflow.schemas.common.random_variables import RVConfig from asyncflow.schemas.events.injection import EventInjection from asyncflow.schemas.payload import SimulationPayload @@ -37,7 +37,7 @@ from asyncflow.schemas.workload.rqs_generator import RqsGenerator if TYPE_CHECKING: - from asyncflow.metrics.analyzer import ResultsAnalyzer + from asyncflow.metrics.simulation_analyzer import ResultsAnalyzer def _server(sid: str) -> Server: diff --git a/tests/integration/load_balancer/test_lb_basic.py b/tests/integration/load_balancer/test_lb_basic.py index 0bcebad..cd21509 100644 --- a/tests/integration/load_balancer/test_lb_basic.py +++ b/tests/integration/load_balancer/test_lb_basic.py @@ -24,7 +24,7 @@ SampledMetricName, StepOperation, ) -from asyncflow.runtime.simulation_runner import SimulationRunner +from asyncflow.runner.simulation import SimulationRunner from asyncflow.schemas.common.random_variables import RVConfig from asyncflow.schemas.payload import SimulationPayload from asyncflow.schemas.settings.simulation import SimulationSettings @@ -44,7 +44,7 @@ from asyncflow.schemas.workload.rqs_generator import RqsGenerator if TYPE_CHECKING: - from asyncflow.metrics.analyzer import ResultsAnalyzer + from asyncflow.metrics.simulation_analyzer import ResultsAnalyzer def _server(server_id: str) -> Server: diff --git a/tests/integration/minimal/conftest.py b/tests/integration/minimal/conftest.py index f29bf49..3c1aebe 100644 --- a/tests/integration/minimal/conftest.py +++ b/tests/integration/minimal/conftest.py @@ -15,7 +15,7 @@ import simpy from asyncflow.config.constants import TimeDefaults -from asyncflow.runtime.simulation_runner import SimulationRunner +from asyncflow.runner.simulation import SimulationRunner from asyncflow.schemas.common.random_variables import RVConfig from asyncflow.schemas.workload.rqs_generator import RqsGenerator diff --git a/tests/integration/minimal/test_minimal.py b/tests/integration/minimal/test_minimal.py index 7ae9507..0688706 100644 --- a/tests/integration/minimal/test_minimal.py +++ b/tests/integration/minimal/test_minimal.py @@ -18,8 +18,8 @@ import pytest import simpy -from asyncflow.metrics.analyzer import ResultsAnalyzer -from asyncflow.runtime.simulation_runner import SimulationRunner +from asyncflow.metrics.simulation_analyzer import ResultsAnalyzer +from asyncflow.runner.simulation import SimulationRunner if TYPE_CHECKING: from asyncflow.schemas.payload import SimulationPayload diff --git a/tests/integration/single_server/conftest.py b/tests/integration/single_server/conftest.py index f45633a..7ecf298 100644 --- a/tests/integration/single_server/conftest.py +++ b/tests/integration/single_server/conftest.py @@ -16,7 +16,7 @@ import simpy if TYPE_CHECKING: # heavy imports only when type-checking - from asyncflow.runtime.simulation_runner import SimulationRunner + from asyncflow.runner.simulation import SimulationRunner # --------------------------------------------------------------------------- # @@ -38,7 +38,7 @@ def runner(env: simpy.Environment) -> SimulationRunner: :pymeth:`SimulationRunner.from_yaml`. """ # import deferred to avoid ruff TC001 - from asyncflow.runtime.simulation_runner import SimulationRunner # noqa: PLC0415 + from asyncflow.runner.simulation import SimulationRunner # noqa: PLC0415 yaml_path: Path = ( Path(__file__).parent / "data" / "single_server.yml" diff --git a/tests/integration/single_server/test_int_single_server.py b/tests/integration/single_server/test_int_single_server.py index efb1ef9..5498611 100644 --- a/tests/integration/single_server/test_int_single_server.py +++ b/tests/integration/single_server/test_int_single_server.py @@ -18,8 +18,8 @@ from asyncflow.config.constants import LatencyKey, SampledMetricName if TYPE_CHECKING: # only needed for type-checking - from asyncflow.metrics.analyzer import ResultsAnalyzer - from asyncflow.runtime.simulation_runner import SimulationRunner + from asyncflow.metrics.simulation_analyzer import ResultsAnalyzer + from asyncflow.runner.simulation import SimulationRunner # --------------------------------------------------------------------------- # diff --git a/tests/system/test_sys_ev_inj_lb_two_servers.py b/tests/system/test_sys_ev_inj_lb_two_servers.py index 15e978b..91ba0e0 100644 --- a/tests/system/test_sys_ev_inj_lb_two_servers.py +++ b/tests/system/test_sys_ev_inj_lb_two_servers.py @@ -33,12 +33,12 @@ from asyncflow import AsyncFlow from asyncflow.components import Client, Edge, Endpoint, LoadBalancer, Server from asyncflow.config.constants import LatencyKey -from asyncflow.runtime.simulation_runner import SimulationRunner +from asyncflow.runner.simulation import SimulationRunner from asyncflow.settings import SimulationSettings from asyncflow.workload import RqsGenerator if TYPE_CHECKING: - from asyncflow.metrics.analyzer import ResultsAnalyzer + from asyncflow.metrics.simulation_analyzer import ResultsAnalyzer from asyncflow.schemas.payload import SimulationPayload pytestmark = [ diff --git a/tests/system/test_sys_ev_inj_single_server.py b/tests/system/test_sys_ev_inj_single_server.py index e1132c3..da5afb7 100644 --- a/tests/system/test_sys_ev_inj_single_server.py +++ b/tests/system/test_sys_ev_inj_single_server.py @@ -36,12 +36,12 @@ from asyncflow import AsyncFlow from asyncflow.components import Client, Edge, Endpoint, Server from asyncflow.config.constants import LatencyKey -from asyncflow.runtime.simulation_runner import SimulationRunner +from asyncflow.runner.simulation import SimulationRunner from asyncflow.settings import SimulationSettings from asyncflow.workload import RqsGenerator if TYPE_CHECKING: - from asyncflow.metrics.analyzer import ResultsAnalyzer + from asyncflow.metrics.simulation_analyzer import ResultsAnalyzer from asyncflow.schemas.payload import SimulationPayload pytestmark = [ diff --git a/tests/system/test_sys_lb_two_servers.py b/tests/system/test_sys_lb_two_servers.py index b273065..47bb0ee 100644 --- a/tests/system/test_sys_lb_two_servers.py +++ b/tests/system/test_sys_lb_two_servers.py @@ -27,13 +27,13 @@ from asyncflow import AsyncFlow from asyncflow.components import Client, Edge, Endpoint, LoadBalancer, Server from asyncflow.config.constants import LatencyKey -from asyncflow.runtime.simulation_runner import SimulationRunner +from asyncflow.runner.simulation import SimulationRunner from asyncflow.settings import SimulationSettings from asyncflow.workload import RqsGenerator if TYPE_CHECKING: # Imported only for type checking (ruff: TC001) - from asyncflow.metrics.analyzer import ResultsAnalyzer + from asyncflow.metrics.simulation_analyzer import ResultsAnalyzer from asyncflow.schemas.payload import SimulationPayload pytestmark = [ diff --git a/tests/system/test_sys_single_server.py b/tests/system/test_sys_single_server.py index ff2cd32..c8d2034 100644 --- a/tests/system/test_sys_single_server.py +++ b/tests/system/test_sys_single_server.py @@ -26,13 +26,13 @@ from asyncflow import AsyncFlow from asyncflow.components import Client, Edge, Endpoint, Server from asyncflow.config.constants import LatencyKey -from asyncflow.runtime.simulation_runner import SimulationRunner +from asyncflow.runner.simulation import SimulationRunner from asyncflow.settings import SimulationSettings from asyncflow.workload import RqsGenerator if TYPE_CHECKING: # Imported only for type checking (ruff: TC001) - from asyncflow.metrics.analyzer import ResultsAnalyzer + from asyncflow.metrics.simulation_analyzer import ResultsAnalyzer from asyncflow.schemas.payload import SimulationPayload pytestmark = [ diff --git a/tests/unit/metrics/test_analyzer.py b/tests/unit/metrics/test_simulation_analyzer.py similarity index 65% rename from tests/unit/metrics/test_analyzer.py rename to tests/unit/metrics/test_simulation_analyzer.py index 901b646..4afc6a8 100644 --- a/tests/unit/metrics/test_analyzer.py +++ b/tests/unit/metrics/test_simulation_analyzer.py @@ -19,7 +19,9 @@ from matplotlib.figure import Figure from asyncflow.analysis import ResultsAnalyzer +from asyncflow.config.constants import EventMetricName from asyncflow.enums import SampledMetricName +from asyncflow.metrics.server import ServerClock if TYPE_CHECKING: from asyncflow.runtime.actors.client import ClientRuntime @@ -73,6 +75,9 @@ def __init__(self, identifier: str, metrics: dict[str, list[float]]) -> None: self.enabled_metrics = { DummyName(name): values for name, values in metrics.items() } + self.server_rqs_clock: dict[ + int, + dict[EventMetricName, float | ServerClock]] = {} class DummyEdgeConfig: @@ -288,3 +293,145 @@ def test_plot_single_server_ram( assert any(lbl.lower().startswith("max") for lbl in labels) assert len(labels) == 3 +# --------------------------------------------------------------- +# Test server event metric +# --------------------------------------------------------------- + +def _mk_bucket( + st: float, io: float, wt: float, start: float, finish: float, +) -> dict[EventMetricName, float | ServerClock]: + """Helper to build one metric bucket like the real server does.""" + return { + EventMetricName.SERVICE_TIME: st, + EventMetricName.IO_TIME: io, + EventMetricName.WAITING_TIME: wt, + EventMetricName.RQS_SERVER_CLOCK: ServerClock(start=start, finish=finish), + } + + +def test_get_server_event_arrays_extracts_fields( + sim_settings: SimulationSettings) -> None: + """Analyzer should extract per-request arrays for a server from its buckets.""" + sim_settings.total_simulation_time = 2 + sim_settings.sample_period_s = 0.5 + + client = DummyClient([]) + + srv = DummyServer("srvA", { + "ready_queue_len": [0, 0], + "event_loop_io_sleep": [0, 1], + "ram_in_use": [128.0, 256.0], + }) + # Populate per-request buckets (two requests) + srv.server_rqs_clock = { + 1: _mk_bucket(0.004, 0.010, 0.001, 0.100, 0.115), # latency 0.015 + 2: _mk_bucket(0.006, 0.020, 0.000, 0.300, 0.326), # latency 0.026 + } + + an = ResultsAnalyzer( + client=cast("ClientRuntime", client), + servers=[cast("ServerRuntime", srv)], + edges=[], + settings=sim_settings, + ) + + arrays = an.get_server_event_arrays() + assert "srvA" in arrays + a = arrays["srvA"] + + # Order of buckets is not relevant; compare sorted values + assert sorted(a["service_time"]) == [0.004, 0.006] + assert sorted(a["io_time"]) == [0.010, 0.020] + assert sorted(a["waiting_time"]) == [0.000, 0.001] + assert pytest.approx(sorted(a["latencies"])) == sorted([0.015, 0.026]) + assert pytest.approx(sorted(a["finish_times"])) == sorted([0.115, 0.326]) + + +def test_get_server_throughput_series_per_server( + sim_settings: SimulationSettings) -> None: + """Throughput per-server should count completions within each fixed window.""" + sim_settings.total_simulation_time = 3 + sim_settings.sample_period_s = 0.5 + client = DummyClient([]) + + srv = DummyServer("srvT", {}) + # Three completions at 0.8s, 1.2s, 2.6s + srv.server_rqs_clock = { + 10: _mk_bucket(0.001, 0.002, 0.000, 0.00, 0.80), + 11: _mk_bucket(0.001, 0.002, 0.000, 0.90, 1.20), + 12: _mk_bucket(0.001, 0.002, 0.000, 2.30, 2.60), + } + + an = ResultsAnalyzer( + client=cast("ClientRuntime", client), + servers=[cast("ServerRuntime", srv)], + edges=[], + settings=sim_settings, + ) + + # 1s windows → boundaries at 1.0, 2.0, 3.0 → counts [1,1,1] + ts1, rps1 = an.get_server_throughput_series("srvT", window_s=1.0) + assert ts1 == [1.0, 2.0, 3.0] + assert rps1 == [1.0, 1.0, 1.0] + + # 0.5s windows → boundaries 0.5,1.0,1.5,2.0,2.5,3.0 + # counts per window [0,1,1,0,0,1] → rates [0,2,2,0,0,2] + ts2, rps2 = an.get_server_throughput_series("srvT", window_s=0.5) + assert ts2[:6] == [0.5, 1.0, 1.5, 2.0, 2.5, 3.0] + assert rps2[:6] == [0.0, 2.0, 2.0, 0.0, 0.0, 2.0] + + +def test_plot_server_event_metrics_dashboard_smoke_and_legends( + sim_settings: SimulationSettings, +) -> None: + """Dashboard (latency/service/io/wait) should set titles and show a legend.""" + sim_settings.total_simulation_time = 1 + client = DummyClient([]) + + srv = DummyServer("srvZ", {}) + srv.server_rqs_clock = { + 1: _mk_bucket(0.003, 0.012, 0.000, 0.10, 0.115), + 2: _mk_bucket(0.007, 0.018, 0.002, 0.20, 0.230), + 3: _mk_bucket(0.005, 0.010, 0.001, 0.30, 0.315), + } + + an = ResultsAnalyzer( + client=cast("ClientRuntime", client), + servers=[cast("ServerRuntime", srv)], + edges=[], + settings=sim_settings, + ) + + fig = Figure() + ax_lat, ax_svc, ax_io, ax_wait = fig.subplots(2, 2).ravel() + an.plot_server_event_metrics_dashboard(ax_lat, ax_svc, ax_io, ax_wait, "srvZ") + + # Titles contain expected labels + assert "Server latency — srvZ" in ax_lat.get_title() + assert "CPU service time — srvZ" in ax_svc.get_title() + assert "I/O time — srvZ" in ax_io.get_title() + assert "CPU waiting time — srvZ" in ax_wait.get_title() + + # Legends exist and contain at least 'mean' (and 'P50' on latency pane) + for ax in (ax_lat, ax_svc, ax_io, ax_wait): + lg = ax.get_legend() + assert lg is not None + labels = [t.get_text().lower() for t in lg.get_texts()] + assert any(lbl.startswith("mean") for lbl in labels) + # Latency pane also shows P50 + lat_labels = [t.get_text() for t in ax_lat.get_legend().get_texts()] + assert any("P50" in s for s in lat_labels) + + +def test_plot_server_timeseries_dashboard_sets_titles( + analyzer_with_metrics: ResultsAnalyzer, +) -> None: + """Time-series dashboard for a server wires the three single-plot helpers.""" + fig = Figure() + ax_ready, ax_io, ax_ram = fig.subplots(1, 3) + analyzer_with_metrics.plot_server_timeseries_dashboard( + ax_ready, ax_io, ax_ram, "srvX") + + assert "Ready Queue" in ax_ready.get_title() + assert "I/O Queue" in ax_io.get_title() + assert "RAM" in ax_ram.get_title() diff --git a/tests/unit/metrics/test_sweep_analyzer.py b/tests/unit/metrics/test_sweep_analyzer.py new file mode 100644 index 0000000..2717f4c --- /dev/null +++ b/tests/unit/metrics/test_sweep_analyzer.py @@ -0,0 +1,261 @@ +"""Unit tests for SweepAnalyzer (global and per-server collections & plots).""" + +from __future__ import annotations + +from typing import TYPE_CHECKING, cast + +import matplotlib as mpl +import matplotlib.pyplot as plt +import pytest + +from asyncflow.config.constants import LatencyKey +from asyncflow.metrics.sweep_analyzer import SweepAnalyzer + +# Headless backend for CI +mpl.use("Agg") + +if TYPE_CHECKING: # pragma: no cover + from collections.abc import Iterable + + from asyncflow.metrics.simulation_analyzer import ResultsAnalyzer + + +# --------------------------------------------------------------------------- +# Fakes +# --------------------------------------------------------------------------- + + +class _FakeResultsAnalyzer: + """Minimal fake of ResultsAnalyzer for SweepAnalyzer tests.""" + + def __init__( + self, + *, + rps_series: list[float], + latency_stats: dict[LatencyKey, float], + server_ids: list[str], + server_arrays: dict[str, dict[str, list[float]]], + ) -> None: + self._rps_series = list(rps_series) + self._latency_stats = dict(latency_stats) + self._server_ids = list(server_ids) + self._server_arrays = { + sid: {k: list(v) for k, v in arrays.items()} + for sid, arrays in server_arrays.items() + } + self.process_calls = 0 + + # Public API mirrored from the real analyzer + + def process_all_metrics(self) -> None: + self.process_calls += 1 + + def get_throughput_series(self) -> tuple[list[float], list[float]]: + """Return (timestamps, rps). We only care about the RPS values.""" + n = len(self._rps_series) + timestamps = [float(i + 1) for i in range(n)] + return timestamps, list(self._rps_series) + + def get_latency_stats(self) -> dict[LatencyKey, float]: + return dict(self._latency_stats) + + def list_server_ids(self) -> list[str]: + return list(self._server_ids) + + def get_server_event_arrays(self) -> dict[str, dict[str, list[float]]]: + return { + sid: {k: list(v) for k, v in arrays.items()} + for sid, arrays in self._server_arrays.items() + } + + +def _cast_pair( + users: int, + fra: _FakeResultsAnalyzer, +) -> tuple[int, ResultsAnalyzer]: + """Cast helper to satisfy mypy on constructor signature.""" + return users, cast("ResultsAnalyzer", fra) + + +# --------------------------------------------------------------------------- +# Tests — Global collection and plots +# --------------------------------------------------------------------------- + + +def test_global_collection_and_plots_match_expected_values() -> None: + """Global throughput mean and mean latency must match the inputs.""" + # Pair 1: mean RPS = 100, mean latency = 0.05 + ra1 = _FakeResultsAnalyzer( + rps_series=[100.0, 110.0, 90.0], + latency_stats={ + LatencyKey.MEAN: 0.05, + LatencyKey.MEDIAN: 0.04, + LatencyKey.P95: 0.10, + LatencyKey.P99: 0.20, + }, + server_ids=["s1"], + server_arrays={ + "s1": { + "service_time": [0.01], + "waiting_time": [0.005], + "finish_times": [0.1, 0.2], + }, + }, + ) + + # Pair 2: mean RPS = 200, mean latency = 0.06 + ra2 = _FakeResultsAnalyzer( + rps_series=[200.0, 190.0, 210.0], + latency_stats={ + LatencyKey.MEAN: 0.06, + LatencyKey.MEDIAN: 0.05, + LatencyKey.P95: 0.12, + LatencyKey.P99: 0.22, + }, + server_ids=["s1"], + server_arrays={ + "s1": { + "service_time": [0.01], + "waiting_time": [0.004], + "finish_times": [0.3, 0.4], + }, + }, + ) + + sa = SweepAnalyzer( + [_cast_pair(10, ra1), _cast_pair(20, ra2)], + ) + + # Global dashboard and line data + fig = sa.plot_global_dashboard() + axes = fig.get_axes() + assert len(axes) == 2 + + # Throughput axis + thr_line = axes[0].lines[0] + x_thr = list(cast("Iterable[float]", thr_line.get_xdata())) + y_thr = list(cast("Iterable[float]", thr_line.get_ydata())) + assert x_thr == [10, 20] + assert pytest.approx(y_thr) == [100.0, 200.0] + + # Latency axis + lat_line = axes[1].lines[0] + x_lat = list(cast("Iterable[float]", lat_line.get_xdata())) + y_lat = list(cast("Iterable[float]", lat_line.get_ydata())) + assert x_lat == [10, 20] + assert pytest.approx(y_lat) == [0.05, 0.06] + + plt.close(fig) + + +# --------------------------------------------------------------------------- +# Tests — Per-server collection and overlays +# --------------------------------------------------------------------------- + + +def test_server_overlays_compute_lambda_mu_rho_and_wq() -> None: + """Per-server metrics must follow completions split and means.""" + # lambda_tot = 100 (mean of [100, 100]) + # completions: s1=60, s2=40 -> lambda1=60, lambda2=40 + # mu1 = 1/0.01 = 100, mu2 = 1/0.02 = 50 + # rho1 = 0.6, rho2 = 0.8 + # wq means from waiting_time arrays + ra = _FakeResultsAnalyzer( + rps_series=[100.0, 100.0], + latency_stats={LatencyKey.MEAN: 0.05}, + server_ids=["s1", "s2"], + server_arrays={ + "s1": { + "service_time": [0.01] * 5, + "waiting_time": [0.005] * 5, + "finish_times": [0.0] * 60, + }, + "s2": { + "service_time": [0.02] * 5, + "waiting_time": [0.004] * 5, + "finish_times": [0.0] * 40, + }, + }, + ) + + sa = SweepAnalyzer([_cast_pair(10, ra)]) + + # Utilization overlay + fig1, ax1 = plt.subplots(1, 1) + sa.plot_server_utilization_overlay(ax1, server_ids=["s1", "s2"]) + lines = {line.get_label(): line for line in ax1.get_lines()} + assert "s1" in lines + assert "s2" in lines + y_rho_s1 = next(iter(cast("Iterable[float]", lines["s1"].get_ydata()))) + y_rho_s2 = next(iter(cast("Iterable[float]", lines["s2"].get_ydata()))) + assert pytest.approx(y_rho_s1) == 0.6 + assert pytest.approx(y_rho_s2) == 0.8 + plt.close(fig1) + + # Service rate overlay + fig2, ax2 = plt.subplots(1, 1) + sa.plot_server_service_rate_overlay(ax2, server_ids=["s1", "s2"]) + lines2 = {line.get_label(): line for line in ax2.get_lines()} + mu_s1 = next(iter(cast("Iterable[float]", lines2["s1"].get_ydata()))) + mu_s2 = next(iter(cast("Iterable[float]", lines2["s2"].get_ydata()))) + assert pytest.approx(mu_s1) == 100.0 + assert pytest.approx(mu_s2) == 50.0 + plt.close(fig2) + + # Waiting time overlay + fig3, ax3 = plt.subplots(1, 1) + sa.plot_server_waiting_time_overlay(ax3, server_ids=["s1", "s2"]) + lines3 = {line.get_label(): line for line in ax3.get_lines()} + wq_s1 = next(iter(cast("Iterable[float]", lines3["s1"].get_ydata()))) + wq_s2 = next(iter(cast("Iterable[float]", lines3["s2"].get_ydata()))) + assert pytest.approx(wq_s1) == 0.005 + assert pytest.approx(wq_s2) == 0.004 + plt.close(fig3) + + # Throughput overlay + fig4, ax4 = plt.subplots(1, 1) + sa.plot_server_throughput_overlay(ax4, server_ids=["s1", "s2"]) + lines4 = {line.get_label(): line for line in ax4.get_lines()} + lam_s1 = next(iter(cast("Iterable[float]", lines4["s1"].get_ydata()))) + lam_s2 = next(iter(cast("Iterable[float]", lines4["s2"].get_ydata()))) + assert pytest.approx(lam_s1) == 60.0 + assert pytest.approx(lam_s2) == 40.0 + plt.close(fig4) + + +# --------------------------------------------------------------------------- +# Tests — Caching behavior +# --------------------------------------------------------------------------- + + +def test_precollect_runs_each_analyzer_once_per_collector() -> None: + """precollect() plus plots should call process_all_metrics exactly twice.""" + # Two pairs to make sure iteration is covered. + ra1 = _FakeResultsAnalyzer( + rps_series=[10.0, 20.0], + latency_stats={LatencyKey.MEAN: 0.1}, + server_ids=["s1"], + server_arrays={"s1": {"service_time": [0.05], "waiting_time": [0.01]}}, + ) + ra2 = _FakeResultsAnalyzer( + rps_series=[30.0, 40.0], + latency_stats={LatencyKey.MEAN: 0.2}, + server_ids=["s2"], + server_arrays={"s2": {"service_time": [0.02], "waiting_time": [0.02]}}, + ) + + sa = SweepAnalyzer([_cast_pair(5, ra1), _cast_pair(15, ra2)]) + + # Warm caches (global + servers) + sa.precollect() + + # Plot both dashboards (should NOT trigger recomputation) + fig_g = sa.plot_global_dashboard() + fig_s = sa.plot_server_dashboard() + plt.close(fig_g) + plt.close(fig_s) + + # Each analyzer should have been processed exactly twice: + # once for global collection + once for server collection. + assert ra1.process_calls == 2 + assert ra2.process_calls == 2 diff --git a/tests/unit/queue_theory_analysis/test_mm1.py b/tests/unit/queue_theory_analysis/test_mm1.py new file mode 100644 index 0000000..0b69dc7 --- /dev/null +++ b/tests/unit/queue_theory_analysis/test_mm1.py @@ -0,0 +1,239 @@ +"""Unit tests for the MM1 queue-theory analyzer.""" + +from __future__ import annotations + +from typing import TYPE_CHECKING, cast + +import pytest + +from asyncflow.config.constants import LatencyKey +from asyncflow.queue_theory_analysis.mm1 import MM1 +from asyncflow.schemas.payload import SimulationPayload + +if TYPE_CHECKING: + from asyncflow.metrics.simulation_analyzer import ResultsAnalyzer + + +# --------------------------------------------------------------------------- +# Helpers +# --------------------------------------------------------------------------- +def _make_mm1_payload( + *, + users_mean: float = 30.0, + rpm_per_user: float = 2.0, + service_mean_s: float = 0.4, + edge_latency_s: float | None = 0.0005, + total_time_s: int = 10, +) -> SimulationPayload: + """Build a minimal payload compatible with MM1 assumptions.""" + step = { + "kind": "cpu_bound_operation", + "step_operation": { + "cpu_time": {"mean": service_mean_s, "distribution": "exponential"}, + }, + } + + payload_dict = { + "rqs_input": { + "id": "gen-1", + "avg_active_users": {"mean": users_mean, "distribution": "poisson"}, + "avg_request_per_minute_per_user": { + "mean": rpm_per_user, + "distribution": "poisson", + }, + "user_sampling_window": 10, + }, + "topology_graph": { + "nodes": { + "client": {"id": "client-1"}, + "servers": [ + { + "id": "srv-1", + "server_resources": {"cpu_cores": 1, "ram_mb": 1024}, + "endpoints": [{"endpoint_name": "echo", "steps": [step]}], + }, + ], + "load_balancer": None, + }, + "edges": [ + { + "id": "gen-cli", + "source": "gen-1", + "target": "client-1", + "latency": 0.0004 if edge_latency_s is None else edge_latency_s, + }, + { + "id": "gen-srv", + "source": "gen-1", + "target": "srv-1", + "latency": 0.0004 if edge_latency_s is None else edge_latency_s, + }, + { + "id": "srv-cli", + "source": "srv-1", + "target": "client-1", + "latency": 0.0004 if edge_latency_s is None else edge_latency_s, + }, + ], + }, + "sim_settings": {"total_simulation_time": total_time_s}, + "events": None, + } + + return SimulationPayload.model_validate(payload_dict) + + +class _FakeResultsAnalyzer: + """Minimal fake ResultsAnalyzer for compare_against_run().""" + + def __init__( + self, + *, + total_time_s: float, + n_completed: int, + latencies_s: list[float], + service_times_s: list[float], + waiting_times_s: list[float], + ) -> None: + self._total_time_s = float(total_time_s) + self._n_completed = int(n_completed) + self._latencies = latencies_s + self._service = service_times_s + self._waiting = waiting_times_s + + def process_all_metrics(self) -> None: + """No-op for the fake analyzer.""" + + def get_throughput_series( + self, + _window_s: float | None = None, + ) -> tuple[list[float], list[float]]: + """Return evenly spaced windows with constant RPS from totals.""" + # Build 1-second windows; constant RPS = n / T. + n = float(self._n_completed) + t = float(self._total_time_s) if self._total_time_s > 0 else 1.0 + rps = n / t + steps = int(t) + timestamps = [float(i + 1) for i in range(steps)] + values = [rps for _ in range(steps)] + return timestamps, values + + def get_latency_stats(self) -> dict[LatencyKey, float]: + """Return only the mean latency (keyed by LatencyKey.MEAN).""" + if not self._latencies: + return {} + mean = float(sum(self._latencies)) / float(len(self._latencies)) + return {LatencyKey.MEAN: mean} + + def list_server_ids(self) -> list[str]: + """Report exactly one server id.""" + return ["srv-1"] + + def get_server_event_arrays(self) -> dict[str, dict[str, list[float]]]: + """Expose arrays with service and waiting times.""" + return { + "srv-1": { + "latencies": [], + "service_time": list(self._service), + "io_time": [], + "waiting_time": list(self._waiting), + "finish_times": [], + }, + } + + +# --------------------------------------------------------------------------- +# Tests +# --------------------------------------------------------------------------- +def test_mm1_is_compatible_and_evaluate_closed_form() -> None: + """A valid MM1 payload should be compatible and produce correct KPIs.""" + # lambda = 30 * 2 / 60 = 1.0; mu = 1/0.4 = 2.5; rho = 0.4 + payload = _make_mm1_payload( + users_mean=30.0, + rpm_per_user=2.0, + service_mean_s=0.4, + total_time_s=10, + ) + mm1 = MM1() + + assert mm1.is_compatible(payload) is True + assert mm1.explain_incompatibilities(payload) == [] + + out = mm1.evaluate(payload) + assert out["lambda_rate"] == pytest.approx(1.0, rel=1e-9, abs=1e-9) + assert out["mu_rate"] == pytest.approx(2.5, rel=1e-9, abs=1e-9) + assert out["rho"] == pytest.approx(0.4, rel=1e-9, abs=1e-9) + # W = 1/(mu-lambda) = 2/3; Wq = rho/(mu-lambda) = 0.2666... + assert out["W"] == pytest.approx(2.0 / 3.0, rel=1e-9, abs=1e-9) + assert out["Wq"] == pytest.approx(0.2666666667, rel=1e-9, abs=1e-9) + # L = lambda*W; Lq = lambda*Wq + assert out["L"] == pytest.approx(1.0 * (2.0 / 3.0), rel=1e-9, abs=1e-9) + assert out["Lq"] == pytest.approx(1.0 * 0.2666666667, rel=1e-9, abs=1e-9) + + +def test_mm1_compare_against_run_produces_rows_with_small_deltas() -> None: + """compare_against_run() should produce rows with tiny diffs for ideal data.""" + payload = _make_mm1_payload( + users_mean=30.0, + rpm_per_user=2.0, + service_mean_s=0.4, + total_time_s=10, + ) + # Theory: lambda=1, mu=2.5, rho=0.4, W=2/3, Wq≈0.2667 + n = 10 + t = 10.0 + w = 2.0 / 3.0 + wq = 0.2666666667 + + ra = _FakeResultsAnalyzer( + total_time_s=t, + n_completed=n, + latencies_s=[w] * n, + service_times_s=[0.4] * n, + waiting_times_s=[wq] * n, + ) + + mm1 = MM1() + rows = mm1.compare_against_run(payload, cast("ResultsAnalyzer", ra)) + + assert len(rows) == 7 + by_sym = {r["symbol"]: r for r in rows} + + lam = by_sym["λ"] + mu = by_sym["μ"] + rho = by_sym["rho"] + w_row = by_sym["W"] + wq_row = by_sym["Wq"] + l_row = by_sym["L"] + lq_row = by_sym["Lq"] + + # Observed equals theory in our synthetic scenario + assert float(lam["abs_diff"]) == pytest.approx(0.0, abs=1e-6) + assert float(mu["abs_diff"]) == pytest.approx(0.0, abs=1e-6) + assert float(rho["abs_diff"]) == pytest.approx(0.0, abs=1e-6) + assert float(w_row["abs_diff"]) == pytest.approx(0.0, abs=1e-6) + assert float(wq_row["abs_diff"]) == pytest.approx(0.0, abs=1e-6) + assert float(l_row["abs_diff"]) == pytest.approx(0.0, abs=1e-6) + assert float(lq_row["abs_diff"]) == pytest.approx(0.0, abs=1e-6) + + +@pytest.mark.parametrize( + ("edge_latency_s", "msg"), + [ + (0.01, "deterministic latency must be < 1 ms"), + (None, ""), + ], +) +def test_mm1_validate_or_raise_incompatibilities( + edge_latency_s: float | None, + msg: str, +) -> None: + """Invalid payloads must raise with a readable message.""" + payload = _make_mm1_payload(edge_latency_s=edge_latency_s) + mm1 = MM1() + + if msg: + with pytest.raises(ValueError, match="Payload is not compatible"): + mm1.validate_or_raise(payload) + else: + mm1.validate_or_raise(payload) diff --git a/tests/unit/runtime/test_simulation_runner.py b/tests/unit/runner/test_simulation.py similarity index 99% rename from tests/unit/runtime/test_simulation_runner.py rename to tests/unit/runner/test_simulation.py index 66c25cb..34f1c44 100644 --- a/tests/unit/runtime/test_simulation_runner.py +++ b/tests/unit/runner/test_simulation.py @@ -16,7 +16,7 @@ from tests.unit.helpers import make_min_ep from asyncflow.config.constants import Distribution, EventDescription -from asyncflow.runtime.simulation_runner import SimulationRunner +from asyncflow.runner.simulation import SimulationRunner from asyncflow.schemas.common.random_variables import RVConfig from asyncflow.schemas.events.injection import EventInjection from asyncflow.schemas.payload import SimulationPayload diff --git a/tests/unit/runner/test_sweep.py b/tests/unit/runner/test_sweep.py new file mode 100644 index 0000000..39fa45a --- /dev/null +++ b/tests/unit/runner/test_sweep.py @@ -0,0 +1,181 @@ +from __future__ import annotations + +from typing import TYPE_CHECKING, ClassVar, cast + +import pytest + +from asyncflow.config.constants import Distribution, TimeDefaults +from asyncflow.runner.sweep import Sweep +from asyncflow.schemas.common.random_variables import RVConfig +from asyncflow.schemas.payload import SimulationPayload +from asyncflow.schemas.settings.simulation import SimulationSettings +from asyncflow.schemas.topology.graph import TopologyGraph +from asyncflow.schemas.topology.nodes import Client, TopologyNodes +from asyncflow.schemas.workload.rqs_generator import RqsGenerator + +if TYPE_CHECKING: + import simpy + + from asyncflow.metrics.simulation_analyzer import ResultsAnalyzer + from asyncflow.runner.simulation import SimulationRunner + + +# --------------------------------------------------------------------------- # +# Helpers # +# --------------------------------------------------------------------------- # +def _make_min_payload( + *, + users_mean: int = 1, + rpm_mean: int = 2, + sim_time: int = TimeDefaults.MIN_SIMULATION_TIME, +) -> SimulationPayload: + """Return a minimal, validated payload (client only, no servers).""" + rqs = RqsGenerator( + id="gen", + avg_active_users=RVConfig( + mean=users_mean, distribution=Distribution.POISSON, + ), + avg_request_per_minute_per_user=RVConfig( + mean=rpm_mean, distribution=Distribution.POISSON, + ), + ) + client = Client(id="cli") + nodes = TopologyNodes(servers=[], client=client, load_balancer=None) + graph = TopologyGraph(nodes=nodes, edges=[]) + settings = SimulationSettings(total_simulation_time=sim_time) + return SimulationPayload( + rqs_input=rqs, topology_graph=graph, sim_settings=settings, + ) + + +class _DummyAnalyzer: + """Trivial object we return as analyzer surrogate in the fake runner.""" + + def __init__(self, tag: int) -> None: + self.tag = tag + + +class FakeSimulationRunner: + """ + Test double for SimulationRunner: + - records every (env, payload) received + - returns a dummy analyzer-like object + """ + + run_calls: ClassVar[list[tuple[simpy.Environment, SimulationPayload]]] = [] + + def __init__( + self, + *, + env: simpy.Environment, + simulation_input: SimulationPayload, + ) -> None: + """Store args for inspection; does not start any real process.""" + self.env = env + self.payload = simulation_input + + def run(self) -> ResultsAnalyzer: + """Record call and return a dummy analyzer marked with users mean.""" + FakeSimulationRunner.run_calls.append((self.env, self.payload)) + tag = int(self.payload.rqs_input.avg_active_users.mean) + return cast("ResultsAnalyzer", _DummyAnalyzer(tag)) + + +@pytest.fixture(autouse=True) +def _reset_fake_runner() -> None: + """Ensure fake runner call log is clean before each test.""" + FakeSimulationRunner.run_calls.clear() + + +# --------------------------------------------------------------------------- # +# Tests # +# --------------------------------------------------------------------------- # +def test_sweep_on_user_inclusive_grid_and_preserves_payload() -> None: + payload = _make_min_payload(users_mean=7) + sweeper = Sweep( + simulation_cls=cast("type[SimulationRunner]", FakeSimulationRunner), + ) + + res = sweeper.sweep_on_user( + payload=payload, user_lower_bound=2, user_upper_bound=6, step=2, + ) + + # Inclusive grid [2, 4, 6] + assert [u for (u, _a) in res] == [2, 4, 6] + assert sweeper._last_users_grid == [2, 4, 6] # noqa: SLF001 + + # Underlying payload not mutated by the sweep + assert payload.rqs_input.avg_active_users.mean == 7 + + # Fake runner saw three runs with the expected users injected + seen = [ + int(p.rqs_input.avg_active_users.mean) + for (_e, p) in FakeSimulationRunner.run_calls + ] + assert seen == [2, 4, 6] + + # Each run got a fresh copy (not the same object) + for (_e, p) in FakeSimulationRunner.run_calls: + assert p is not payload + + +def test_sweep_on_user_creates_fresh_env_per_run() -> None: + payload = _make_min_payload() + sweeper = Sweep( + simulation_cls=cast("type[SimulationRunner]", FakeSimulationRunner), + ) + + res = sweeper.sweep_on_user( + payload=payload, user_lower_bound=1, user_upper_bound=3, step=1, + ) + assert len(res) == 3 + + env_ids = [id(e) for (e, _p) in FakeSimulationRunner.run_calls] + assert len(set(env_ids)) == 3 # all distinct envs + # brand-new SimPy environments start at t=0 + assert all(e.now == 0 for (e, _p) in FakeSimulationRunner.run_calls) + + +@pytest.mark.parametrize( + ("lo", "hi", "step", "msg_substr"), + [ + (1, 5, 0, "step must be > 0"), + (0, 5, 1, "strictly bigger than 0"), + (1, 0, 1, "strictly bigger than 0"), + (5, 1, 1, "user_upper_bound must be >= user_lower_bound"), + ], +) +def test_sweep_on_user_invalid_inputs_raise( + lo: int, hi: int, step: int, msg_substr: str, +) -> None: + payload = _make_min_payload() + sweeper = Sweep( + simulation_cls=cast("type[SimulationRunner]", FakeSimulationRunner), + ) + + with pytest.raises(ValueError, match=msg_substr): + sweeper.sweep_on_user( + payload=payload, + user_lower_bound=lo, + user_upper_bound=hi, + step=step, + ) + + +def test_sweep_on_user_returns_pairs_with_analyzers() -> None: + payload = _make_min_payload() + sweeper = Sweep( + simulation_cls=cast("type[SimulationRunner]", FakeSimulationRunner), + ) + + res = sweeper.sweep_on_user( + payload=payload, user_lower_bound=2, user_upper_bound=4, step=1, + ) + + # Tuple shape: (users, analyzer) + users_list = [u for (u, _a) in res] + assert users_list == [2, 3, 4] + + # Analyzer is the dummy object we returned (check runtime marker) + tags = [getattr(a, "tag", None) for (_u, a) in res] + assert tags == [2, 3, 4] diff --git a/tests/unit/runtime/actors/test_server_rt.py b/tests/unit/runtime/actors/test_server_rt.py index 53da3ef..9714532 100644 --- a/tests/unit/runtime/actors/test_server_rt.py +++ b/tests/unit/runtime/actors/test_server_rt.py @@ -28,9 +28,11 @@ EndpointStepCPU, EndpointStepIO, EndpointStepRAM, + EventMetricName, SampledMetricName, StepOperation, ) +from asyncflow.metrics.server import ServerClock from asyncflow.resources.server_containers import build_containers from asyncflow.runtime.actors import server as server_mod from asyncflow.runtime.actors.server import ServerRuntime @@ -479,3 +481,135 @@ def fake_sampler(cfg: RVConfig, rng: NpGenerator) -> float: # Deterministic int/float paths assert server._compute_latency_cpu(2) == pytest.approx(2.0) # noqa: SLF001 assert server._compute_latency_io(0.5) == pytest.approx(0.5) # noqa: SLF001 + + +def test_server_clock_and_cumulative_metrics_default_pipeline() -> None: + """ + Single request on default pipeline: + - SERVICE_TIME should equal CPU(5ms) + - IO_TIME should equal I/O(20ms) + - WAITING_TIME should be ~0 (2 cores, no contention) + - RQS_SERVER_CLOCK has start/finish with finish > start + """ + env = simpy.Environment() + server, _ = _make_server_runtime(env) # default: 2 cores, default steps + + req_id = 301 + server.server_box.put(RequestState(id=req_id, initial_time=0.0)) + server.start() + env.run() + + bucket = server.server_rqs_clock[req_id] + # Clock present and well-formed + assert EventMetricName.RQS_SERVER_CLOCK in bucket + clock = bucket[EventMetricName.RQS_SERVER_CLOCK] + assert isinstance(clock, ServerClock) + assert clock.finish is not None + assert clock.finish >= clock.start + + # Accumulators + assert bucket[EventMetricName.SERVICE_TIME] == pytest.approx(0.005, abs=1e-9) + assert bucket[EventMetricName.IO_TIME] == pytest.approx(0.020, abs=1e-9) + assert bucket[EventMetricName.WAITING_TIME] == pytest.approx(0.0, abs=1e-12) + + # Server-side elapsed time should be at least the sum (avoid approx on RHS of >=) + elapsed = clock.finish - clock.start + assert elapsed >= (0.005 + 0.020) - 1e-9 + +def test_waiting_time_accumulates_under_contention() -> None: + """ + With 1 core and two overlapping requests on a CPU-only endpoint: + - The second request's WAITING_TIME ~= (first CPU time - overlap). + """ + env = simpy.Environment() + + steps = ( + Step( + kind=EndpointStepRAM.RAM, + step_operation={StepOperation.NECESSARY_RAM: 64}, + ), + Step( + kind=EndpointStepCPU.CPU_BOUND_OPERATION, + step_operation={StepOperation.CPU_TIME: 0.008}, + ), + ) + server, _ = _make_server_runtime(env, steps=steps, cpu_cores=1) + + first_id, second_id = 401, 402 + + # First arrives at t=0.0 + server.server_box.put(RequestState(id=first_id, initial_time=0.0)) + + # Schedule the second to actually arrive at t=0.001 (creates 1ms overlap) + def _arrive_later() -> Generator[simpy.Event, None, None]: + yield env.timeout(0.001) + yield server.server_box.put(RequestState(id=second_id, initial_time=0.001)) + + env.process(_arrive_later()) + + server.start() + env.run() + + b1 = server.server_rqs_clock[first_id] + b2 = server.server_rqs_clock[second_id] + + # First: no waiting, service time = 8ms, no IO + assert b1[EventMetricName.WAITING_TIME] == pytest.approx(0.0, abs=1e-9) + assert b1[EventMetricName.SERVICE_TIME] == pytest.approx(0.008, abs=1e-9) + assert b1[EventMetricName.IO_TIME] == pytest.approx(0.0, abs=1e-12) + + # Second: expected wait ≈ 0.007 (first CPU 8ms - 1ms overlap) + assert b2[EventMetricName.WAITING_TIME] == pytest.approx(0.007, abs=2e-4) + assert b2[EventMetricName.SERVICE_TIME] == pytest.approx(0.008, abs=1e-9) + assert b2[EventMetricName.IO_TIME] == pytest.approx(0.0, abs=1e-12) + + +def test_metrics_follow_rv_samples(monkeypatch: pytest.MonkeyPatch) -> None: + """ + With RVConfig on CPU and IO, SERVICE_TIME and IO_TIME must match + the (patched) sampler outcomes. + """ + # 6ms for CPU sentinel, 13ms for IO sentinel + def fake_sampler(cfg: RVConfig, rng: NpGenerator) -> float: + if cfg.mean == 0.321: + return 0.006 + if cfg.mean == 0.654: + return 0.013 + return 0.0 + + monkeypatch.setattr(server_mod, "general_sampler", fake_sampler) + + env = simpy.Environment() + steps = ( + Step( + kind=EndpointStepRAM.RAM, + step_operation={StepOperation.NECESSARY_RAM: 64}, + ), + Step( + kind=EndpointStepCPU.CPU_BOUND_OPERATION, + step_operation={StepOperation.CPU_TIME: RVConfig(mean=0.321)}, + ), + Step( + kind=EndpointStepIO.DB, + step_operation={StepOperation.IO_WAITING_TIME: RVConfig(mean=0.654)}, + ), + ) + server, _ = _make_server_runtime(env, steps=steps, cpu_cores=1) + + req_id = 501 + server.server_box.put(RequestState(id=req_id, initial_time=0.0)) + server.start() + env.run() + + bucket = server.server_rqs_clock[req_id] + assert bucket[EventMetricName.SERVICE_TIME] == pytest.approx(0.006, abs=1e-9) + assert bucket[EventMetricName.IO_TIME] == pytest.approx(0.013, abs=1e-9) + assert bucket[EventMetricName.WAITING_TIME] == pytest.approx(0.0, abs=1e-12) + + clock = bucket[EventMetricName.RQS_SERVER_CLOCK] + assert isinstance(clock, ServerClock) + assert clock.finish is not None + + # Elapsed server-side time must be at least the sum of CPU+IO + elapsed = clock.finish - clock.start + assert elapsed >= (0.006 + 0.013) - 1e-9