Initial commit

Author: maerteijn

.gitignore

@@ -0,0 +1,29 @@
+# IDE directories
+.idea/
+.vscode/
+
+# OS generated files
+.DS_Store
+
+# Python specific
+__pycache__/
+*.egg-info/
+*.pyc
+
+# Virtualenvs
+venv/
+env/
+.env/
+
+# Project specific
+.env
+.envrc
+.cache
+.ruff_cache
+
+# Database
+*.sqlite3
+
+# Supervisor
+supervisord.log
+supervisord.pid

Makefile

@@ -0,0 +1,43 @@
+.PHONY: bootstrap install lint format locust uwsgi uwsgi-gevent gunicorn gunicorn-gevent uvicorn locust
+
+default: bootstrap install
+
+clean:  ## Remove all build, test, coverage and Python artifacts
+	find . -name '*.pyc' -exec rm -rf {} +
+	find . -name '__pycache__' -exec rm -rf {} +
+	find . -name '*.egg-info' -exec rm -rf {} +
+	find . -name '*.egg' -exec rm -rf {} +
+
+install:
+	pip install -e .
+
+lint:
+	ruff check
+
+format:
+	ruff check --fix
+	ruff format
+
+api:
+	ROOT_URLCONF=django_sync_or_async.urls.api uvicorn django_sync_or_async.asgi:application --port 5000
+
+uwsgi-2-threads:
+	ROOT_URLCONF=django_sync_or_async.urls.sync uwsgi --module django_sync_or_async.wsgi:application --processes 1 --threads 2 --master --die-on-term --http 0.0.0.0:8000 --stats :3030 --stats-http
+
+uwsgi-100-threads:
+	ROOT_URLCONF=django_sync_or_async.urls.sync uwsgi --module django_sync_or_async.wsgi:application --processes 1 --threads 100 --master --die-on-term --http 0.0.0.0:8001 --stats :3031 --stats-http
+
+uwsgi-gevent:
+	ROOT_URLCONF=django_sync_or_async.urls.sync uwsgi --module django_sync_or_async.wsgi:application --processes 1 --gevent 100 --gevent-early-monkey-patch --master --die-on-term --http 0.0.0.0:8002 --stats :3032 --stats-http
+
+gunicorn-100-threads:
+	ROOT_URLCONF=django_sync_or_async.urls.sync gunicorn django_sync_or_async.wsgi --workers=1 --threads 100 --access-logfile '-' --bind 0.0.0.0:8003
+
+gunicorn-gevent:
+	ROOT_URLCONF=django_sync_or_async.urls.sync gunicorn django_sync_or_async.wsgi --workers=1 --worker-class gevent --worker-connections 100 --access-logfile '-' --bind 0.0.0.0:8004
+
+uvicorn:
+	ROOT_URLCONF=django_sync_or_async.urls.async uvicorn django_sync_or_async.asgi:application --port 8005
+
+locust:
+	 locust --users 100 --spawn-rate 10 -t 30s  -f src/django_sync_or_async/locust.py -H $(HOST)

README.md

@@ -0,0 +1,124 @@
+# Django sync or async, that's the question
+
+Test the performance and concurrency processing of a Django view calling an "external" API with the following servers:
+
+- uWSGI (WSGI)
+- uWSGI with Gevent (WSGI)
+- Gunicorn (gthread) (WSGI)
+- Gunicorn with Gevent (WSGI)
+- Uvicorn (ASGI)
+
+
+## View calling an "external" API
+
+We are testing a Django view which will call an "external" API several times.
+
+We'll use the [httpx](https://www.python-httpx.org/) package for this, as it provides both a sync and async API.
+
+The "external" API, which runs locally with `uvicorn` using `asyncio.sleep` to simulate latency selects a random country from a predefined list:
+
+https://github.com/maerteijn/django-sync-or-async/blob/1c5a6e4738f111c3b09e173af2f3d0c02ca0f8b0/src/django_sync_or_async/views.py#L14-L22
+
+
+## Overview
+
+We will test the performance implications with the following configurations:
+
+```
+
+                         ┌─────────────────────────────┐
+    ┌────────────────────┤ uwsgi-2-threads (:8000)     │
+    │                    │ (1 process, 2 threads)      │
+    │                    └─────────────────────────────┘
+    │                    ┌─────────────────────────────┐
+    │  ┌─────────────────┤ uwsgi-100-threads (:8001)   │
+    │  │                 │ (1 process, 100 threads)    │
+    │  │                 └─────────────────────────────┘
+    │  │                 ┌─────────────────────────────┐
+    ▼  ▼                 │ uwsgi-gevent (:8002)        │
+ ┌───────────┐   ┌───────┤ (1 process, 100 "workers")  │
+ │API (:5000)│◄──┘       └─────────────────────────────┘
+ │ (uvicorn) │◄──┐       ┌─────────────────────────────┐
+ └───────────┘   └───────┤ gunicorn-100-threads (:8003)│
+    ▲   ▲                │ (1 process, 100 threads)    │
+    │   │                └─────────────────────────────┘
+    │   │                ┌─────────────────────────────┐
+    │   └────────────────┤ gunicorn-gevent (:8004)     │
+    │                    │(1 process, 100 "workers")   │
+    │                    └─────────────────────────────┘
+    │                    ┌─────────────────────────────┐
+    └────────────────────┤ uvicorn (:8005)             │
+                         │ (1 process)                 │
+                         └─────────────────────────────┘
+
+```
+### Concurrency
+
+The view which will be benchmarked calls our "really slow" external API three times so we can also test these calls are done in parallel instead of sequential. The slowest response time is around 600ms, so this is about the longest time it takes the API should generate a response because the API calls should be executed in parallel. To achieve this we use a `ThreadPoolExecutor` for the sync view:
+
+https://github.com/maerteijn/django-sync-or-async/blob/1c5a6e4738f111c3b09e173af2f3d0c02ca0f8b0/src/django_sync_or_async/views.py#L25-L38
+
+> [!NOTE]
+> The standard `ThreadPoolExecutor` with actual system threads is used when using the `uwsgi-2-threads`, ` uwsgi-100-threads`  and `gunicorn-100-threads` configurations. When using gevent, [threads are monkey patched to be cooperative](https://www.gevent.org/api/gevent.monkey.html), so new greenlets will be spawned when using the `ThreadPoolExecutor`.
+
+For the `uvicorn` version (ASGI), the parallel calls are implemented with `asyncio.gather`:
+
+https://github.com/maerteijn/django-sync-or-async/blob/1c5a6e4738f111c3b09e173af2f3d0c02ca0f8b0/src/django_sync_or_async/views.py#L41-L56
+
+
+## Installation
+
+### Requirements
+
+- Python 3.12 (minimum)
+- virtualenv (recommended)
+
+
+### Install the packages
+
+First create a virtualenv in your preferred way, then install all packages with:
+```bash
+make install
+```
+
+## Running the services
+
+Make sure you are allowed to have many file descriptions open:
+```bash
+ulimit -n 32768
+```
+
+Now run the supervisor daemon which will start all services:
+```bash
+$ supervisord
+```
+
+This will start the API and all the different uwsgi / asgi services. Press `ctrl+c` to stop it.
+
+
+## Run the benchmarks
+
+You can run the benchmarks for each individual server by selecting the relevant port number so comparison can be made after running them:
+
+For `uwsgi`:
+```bash
+make locust HOST=http://localhost:8000
+```
+
+This will start a locust interface, accessible via http://localhost:8089
+
+For `uwsgi-100-threads`:
+```bash
+make locust HOST=http://localhost:8001
+```
+
+Etcetera, see the [port numbers in the overview](#overview).
+
+### uwsgitop
+
+You can see detailed information during the benchmarks for the uWSGI processes using `uwsgitop`:
+```bash
+uwsgitop http://localhost:3030  # <-- for the 1 process 2 threads variant
+uwsgitop http://localhost:3031  # <-- for the 1 process 100 threads variant
+uwsgitop http://localhost:3032  # <-- for the 1 process gevent variant
+```

pyproject.toml

@@ -0,0 +1,53 @@
+[build-system]
+requires = ["setuptools >= 64.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "django-sync-or-async"
+description = "Django sync or async, that's the question"
+version = "0.0.1"
+license = { text = "Proprietary" }
+requires-python = ">=3.12"
+authors = [{name = "Martijn Jacobs", email = "[email protected]"}]
+classifiers = [
+    "Environment :: Web Environment",
+    "Framework :: Django",
+    "Framework :: Django :: 5.1",
+    "License :: Other/Proprietary License",
+    "Programming Language :: Python :: 3.12",
+]
+dependencies = [
+  "Django ~= 5.1",
+  "uWSGI == 2.0.28",
+  "uwsgitop == 0.12",
+  "uvicorn ==0.34",
+  "ruff == 0.8.5",
+  "httpx == 0.28.1",
+  "locust == 2.32.5",
+  "gunicorn == 23.0.0",
+  "gevent == 24.11.1",
+  "supervisor == 4.2.5"
+]
+
+[project.scripts]
+"manage.py" =  "django_sync_or_async.manage:main"
+
+
+[tool.ruff]
+target-version = "py312"  # minimum target version
+
+# E501: Line too long
+# C408: Unnecessary `dict` call
+# F405: Star imports
+lint.ignore = ["E501", "C408", "F405"]
+
+lint.select = [
+    "E", # pycodestyle errors
+    "F", # pyflakes
+    "I", # isort
+    "T20", # flake8-print
+    "BLE", # flake8-blind-except
+    "C4", # flake8-comprehensions
+    "UP", # pyupgrade
+]
+

src/django_sync_or_async/__init__.py

@@ -0,0 +1,16 @@
+"""
+ASGI config for django_sync_or_async project.
+
+It exposes the ASGI callable as a module-level variable named ``application``.
+
+For more information on this file, see
+https://docs.djangoproject.com/en/5.1/howto/deployment/asgi/
+"""
+
+import os
+
+from django.core.asgi import get_asgi_application
+
+os.environ.setdefault("DJANGO_SETTINGS_MODULE", "django_sync_or_async.settings")
+
+application = get_asgi_application()