Unexpected Performance Degradation with uvloop in FastAPI + MySQL Benchmark

[M1-Elmasry]

I was benchmarking the performance of fastapi and noticed something unexpected, when i install uvloop (which becomes the eventloop used due to --loop auto setting) performance degrades.

Setup

• Python version: 3.12.3
• Framework: FastAPI
• Database: MySQL 8.0.11 (Docker container, local)
• Python DB Driver: aiomysql
• Load Testing Tool: Grafana k6
• Seeded Data: 50,000 employee records

installed packages, click to expand

aiomysql==0.2.0
annotated-types==0.7.0
anyio==4.9.0
cffi==1.17.1
click==8.1.8
contourpy==1.3.1
cryptography==44.0.2
cycler==0.12.1
fastapi==0.115.12
fonttools==4.56.0
gunicorn==23.0.0
h11==0.14.0
httptools==0.6.4
idna==3.10
kiwisolver==1.4.8
matplotlib==3.10.1
mysql-connector-python==9.2.0
numpy==2.2.4
packaging==24.2
pandas==2.2.3
pillow==11.1.0
pycparser==2.22
pydantic==2.11.1
pydantic-core==2.33.0
pymysql==1.1.1
pyparsing==3.2.3
python-dateutil==2.9.0.post0
pytz==2025.2
scipy==1.15.2
seaborn==0.13.2
six==1.17.0
sniffio==1.3.1
starlette==0.46.1
typing-extensions==4.13.0
typing-inspection==0.4.0
tzdata==2025.2
uvicorn==0.34.0
uvloop==0.21.0

run command

uvicorn <server-module>:app --host 127.0.0.1 --port 3000

---

Server Code

Click to expand

from typing import Coroutine
from fastapi import FastAPI
from aiomysql import create_pool, DictCursor
from pydantic import BaseModel

class Employee(BaseModel):
    id: int
    username: str
    password: str
    email: str
    salary: int
    years_of_experience: int # between 10 and 20

class dbClient:
    def __init__(self):
        self.pool = None

    async def init_db(self, **kargs):
        self.pool = await create_pool(**kargs)

    async def fetch_one(self, query: str, params: tuple):
        async with self.pool.acquire() as conn:
            async with conn.cursor() as cur:
                await cur.execute(query, params)
                return await cur.fetchone()

    async def close(self):
        if self.pool:
            self.pool.close()
            await self.pool.wait_closed()

app = FastAPI()
db_client = dbClient()

@app.on_event("startup")
async def startup():
    await db_client.init_db(
        host="127.0.0.1",
        port=3306,
        user="root",
        password="ROOT",
        db="test",
        cursorclass=DictCursor,
        minsize=5,
        maxsize=30,
    )

@app.on_event("shutdown")
async def shutdown():
    await db_client.close()

@app.get("/")
async def root():
    return {"message": "server is up !"}

#io-bound endpoint
@app.get("/employees/{employee_id}")
async def get_employee(employee_id: int):
    emp = await db_client.fetch_one(
        "SELECT * FROM employees WHERE id = %s LIMIT 1", (str(employee_id),)
    )
    return emp or {"message": "employee not found"}


#cpu-bound endpoint
@app.get("/calculate-factorial/{n}")
async def calculate_factorial(n: int):
    result = 1
    for i in range(1, n + 1):
        result *= i
    return {"result": result}

#io-cpu-bound endpoint
@app.get("/employee-exp-factorial/{employee_id}")
async def get_employee_exp_factorial(employee_id: int):
    emp = await db_client.fetch_one(
        "SELECT * FROM employees WHERE id = %s LIMIT 1", (str(employee_id),)
    )
    if not emp:
        return {"message": "employee not found"}
    result = 1
    for i in range(1, emp["years_of_experience"]):
        result *= i
    return {"result": result}

---

k6 Test Scripts

All tests use a load pattern of:

stages: [
  { duration: "1m", target: 400 },
  { duration: "5m", target: 400 },
  { duration: "1m", target: 0 },
]

---

Benchmark Results (Before and After uvloop Installation)

IO-Bound (/employees/{employee_id})

Metric	Before uvloop	After uvloop	Difference
Avg latency	10.38 ms	29.51 ms	+19.13 ms (+184%)
P90 latency	15.48 ms	61.02 ms	+45.54 ms (+294%)
Total requests	142,602 reqs	139,928 reqs	-2,674 reqs (-2%)
Throughput	338 req/s	332 req/s	-6 req/s (-2%)
Failures	0%	0%	No change

CPU-Bound (/calculate-factorial/{n})

Metric	Before uvloop	After uvloop	Difference
Avg response time	2.48 ms	4.56 ms	+2.08 ms (+84%)
P90 latency	4.02 ms	9.47 ms	+5.45 ms (+136%)
Total requests	143,738 reqs	143,443 reqs	-295 reqs (-0.2%)
Throughput	341.67 req/s	341.09 req/s	≈ No change
Failures	0%	0%	No change

IO + CPU (/employee-exp-factorial/{id})

Metric	Before uvloop	After uvloop	Difference
Avg response time	11.69 ms	31.15 ms	+19.46 ms (+166%)
P90 latency	14.72 ms	62.18 ms	+47.46 ms (+322%)
Total requests	142,437 reqs	139,711 reqs	-2,726 reqs (-2%)
Throughput	338 req/s	332 req/s	-6 req/s (-2%)
Failures	0%	0%	No change

---

Notes

• Removing uvloop restores performance
• MySQL server is local, no network latency involved

---

Questions

• Is this expected behavior for uvloop, and why ?
• Are there cases where the default event loop performs better than uvloop ?

[nggit]

My hypothesis is that the latest CPython is getting faster even in common cases, and it's becoming harder to optimize with custom loops/uvloops. I have sensed this as well. Feel free to try with different/old versions of CPython.

[M1-Elmasry]

Good point, i will try to run the tests again with python3.9 and share the results.

[nggit]

Looking at your “run command”, I would suggest disabling any logs when benchmarking, e.g. with --log-level critical. Because that can also make a difference.

[M1-Elmasry]

i don't just aim for better performance in general, i pick a specific optimization method and compare performance before and after applying it. right now, I'm testing uvloop and httptools. anyway, thanks for the advice i will try it later.

[M1-Elmasry]

I ran the tests again, this time with Python 3.9, and used a DigitalOcean droplet (2vCPU, 4GB RAM) to avoid any local environment issues or inaccurate results.

and here is the results

IO + CPU (/employee-exp-factorial/{id})

Metric	Before uvloop	After uvloop	Difference
Avg response time	10.83 ms	19.59 ms	+8.76 ms (+80.9%)
P90 latency	22.71 ms	42.28 ms	+19.57 ms (+86.2%)
Total requests	142,539 reqs	141,298 reqs	-1,241 reqs (-0.87%)
Throughput	338.71 req/s	335.89 req/s	-2.82 req/s (-0.83%)
Failures	0%	0%	No change

IO-Bound (/employees/{employee_id})

Metric	Before uvloop	After uvloop	Difference
Avg latency	9.98 ms	19.88 ms	+9.90 ms (+99%)
P90 latency	21.58 ms	44.39 ms	+22.81 ms (+106%)
Total requests	142,657 reqs	141,267 reqs	-1,390 reqs (-0.97%)
Throughput	339 req/s	336 req/s	-3 req/s (-0.9%)
Failures	0%	0%	No change

CPU-Bound (/calculate-factorial/{n})

Metric	Before uvloop	After uvloop	Difference
Avg response time	2.90 ms	3.54 ms	+0.64 ms (+22%)
P90 latency	5.31 ms	6.41 ms	+1.10 ms (+20.7%)
Total requests	143,717 reqs	143,602 reqs	-115 reqs (-0.08%)
Throughput	341.74 req/s	341.35 req/s	-0.39 req/s (≈ No change)
Failures	0%	0%	No change

[nggit]

Then there's something I don't understand here.

But the fact I found now is that uvloop doesn't give significant performance, at least on my only device with Alpine Linux / musl.

Back then when using python 3.7 on GNU, I definitely saw a significant difference.