[aiohttp] - use lcg as random generator

Author: Reskov

frameworks/Python/aiohttp/aiohttp.dockerfile

@@ -4,7 +4,9 @@ ADD ./ /aiohttp
 
 WORKDIR /aiohttp
 
-RUN pip3 install -r /aiohttp/requirements-cpython.txt
+RUN pip3 install -r /aiohttp/requirements-cpython.txt && \
+    pip3 install cython==3.1.2 setuptools==80.9.0 && \
+    python3 setup.py build_ext --inplace
 
 ENV CONNECTION=RAW
 

frameworks/Python/aiohttp/app/main.py

@@ -39,7 +39,7 @@ def pg_dsn(dialect=None) -> str:
     url = URL.create(
         database='hello_world',
         password=os.getenv('PGPASS', 'benchmarkdbpass'),
-        host='tfb-database',
+        host=os.getenv('PGHOST','tfb-database'),
         port='5432',
         username=os.getenv('PGUSER', 'benchmarkdbuser'),
         drivername='postgresql+{}'.format(dialect) if dialect else 'postgresql',

frameworks/Python/aiohttp/app/random_utils.py

@@ -0,0 +1,33 @@
+from random import randint
+
+# Constants
+# https://statmath.wu.ac.at/software/src/prng-3.0.2/doc/prng.html/Table_LCG.html
+MAX_VALUE = 10000
+MODULOS = 134217689
+LCG_MULTIPLIER = 3162696
+RANDOM_THRESHOLD = MODULOS - (MODULOS % (MAX_VALUE))
+
+seed = randint(0, MAX_VALUE)
+
+def random_id():
+    """Generate a pseudo-random number based on a linear congruential generator"""
+    global seed
+
+    # Regenerate if we're above the threshold to avoid distribution bias
+    while True:
+        seed = (LCG_MULTIPLIER * seed) % MODULOS
+        if seed < RANDOM_THRESHOLD:
+            break
+
+    return 1 + seed % MAX_VALUE
+
+def random_unique_ids(n):
+    """Generate n unique random IDs"""
+    generated_ids = {random_id() for _ in range(n)}
+
+    while len(generated_ids) < n:
+        id_ = random_id()
+        if id_ not in generated_ids:
+            generated_ids.add(id_)
+
+    return list(generated_ids)

frameworks/Python/aiohttp/app/random_utils.pyx

@@ -0,0 +1,78 @@
+# cython: boundscheck=False
+# cython: wraparound=False
+# cython: initializedcheck=False
+
+from libc.stdlib cimport rand, srand, calloc, free
+from libc.time cimport time
+
+import cython
+
+# Constants
+cdef unsigned int MAX_VALUE = 10000
+# https://statmath.wu.ac.at/software/src/prng-3.0.2/doc/prng.html/Table_LCG.html
+cdef unsigned int MODULOS = 134217689
+cdef unsigned int RANDOM_THRESHOLD = MODULOS - (MODULOS % MAX_VALUE)
+cdef unsigned int LCG_MULTIPLIER = 3162696
+cdef bint* seen = <bint*>calloc(MAX_VALUE + 1, sizeof(bint))  # Bit array simulation
+
+cdef unsigned long seed = 0
+
+cdef void _init_seed():
+    global seed
+    srand(<unsigned long>time(NULL))
+    seed = rand() % MAX_VALUE
+
+    if seed == 0:
+        seed = 1  # Ensure seed is never zero to avoid low number cycle
+
+_init_seed()
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+cdef inline unsigned int _next_random() noexcept nogil:
+    """Generate a pseudo-random number based on a linear congruential generator"""
+    global seed
+
+    cdef unsigned long next_val = (<unsigned long>LCG_MULTIPLIER * seed) % MODULOS
+
+    while next_val >= RANDOM_THRESHOLD:
+        next_val = (next_val * LCG_MULTIPLIER) % MODULOS
+
+    seed = next_val
+    return seed
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+cpdef unsigned int random_id() noexcept nogil:
+    """Generate a pseudo-random number in range [1, MAX_VALUE]"""
+    return 1 + (_next_random() % MAX_VALUE)
+
+@cython.boundscheck(False) 
+@cython.wraparound(False)
+cpdef list[unsigned int] random_unique_ids(int n):
+    """Generate n unique random IDs in range[1, 10001]"""
+    cdef list[int] result = [0] * n
+    cdef int candidate, count = 0
+
+    try:
+        while count < n:
+            candidate = random_id()
+
+            if seen[candidate] == 0:  # Not seen before
+                seen[candidate] = 1
+                result[count] = candidate
+                count += 1
+    finally:
+        for i in result:
+            seen[i] = 0
+
+    return result
+
+def _cleanup():
+    global seen
+    if seen != NULL:
+        free(seen)
+        seen = NULL
+
+import atexit
+atexit.register(_cleanup)

frameworks/Python/aiohttp/app/views.py

@@ -1,14 +1,14 @@
 import platform
 from operator import attrgetter, itemgetter
 from pathlib import Path
-from random import randint, sample
 
 import jinja2
 from aiohttp.web import Response
 from sqlalchemy import bindparam, select
 from sqlalchemy.orm.attributes import flag_modified
 
 from .models import Fortune, World
+from .random_utils import random_id, random_unique_ids
 
 if platform.python_implementation() == "PyPy":
     from aiohttp.web import json_response
@@ -23,6 +23,7 @@ def json_response(payload):
 
 ADDITIONAL_FORTUNE_ORM = Fortune(id=0, message='Additional fortune added at request time.')
 ADDITIONAL_FORTUNE_ROW = {'id': 0, 'message': 'Additional fortune added at request time.'}
+JSON_MESSAGE = {'message': 'Hello, World!'}
 READ_ROW_SQL = 'SELECT "randomnumber", "id" FROM "world" WHERE id = $1'
 READ_SELECT_ORM = select(World.randomnumber).where(World.id == bindparam("id"))
 READ_FORTUNES_ORM = select(Fortune.id, Fortune.message)
@@ -34,6 +35,7 @@ def json_response(payload):
 sort_fortunes_orm = attrgetter('message')
 sort_fortunes_raw = itemgetter('message')
 
+db_query_id_params = [(i,) for i in range(0, 10002)]
 
 def get_num_queries(request):
     try:
@@ -51,14 +53,14 @@ async def json(request):
     """
     Test 1
     """
-    return json_response({'message': 'Hello, World!'})
+    return json_response(JSON_MESSAGE)
 
 
 async def single_database_query_orm(request):
     """
     Test 2 ORM
     """
-    id_ = randint(1, 10000)
+    id_ = random_id()
     async with request.app['db_session']() as sess:
         num = await sess.scalar(READ_SELECT_ORM, {"id": id_})
     return json_response({'id': id_, 'randomNumber': num})
@@ -68,7 +70,7 @@ async def single_database_query_raw(request):
     """
     Test 2 RAW
     """
-    id_ = randint(1, 10000)
+    id_ = random_id()
 
     async with request.app['pg'].acquire() as conn:
         r = await conn.fetchval(READ_ROW_SQL, id_)
@@ -81,7 +83,7 @@ async def multiple_database_queries_orm(request):
     """
     num_queries = get_num_queries(request)
 
-    ids = [randint(1, 10000) for _ in range(num_queries)]
+    ids = random_unique_ids(num_queries)
 
     result = []
     async with request.app['db_session']() as sess:
@@ -96,12 +98,13 @@ async def multiple_database_queries_raw(request):
     Test 3 RAW
     """
     num_queries = get_num_queries(request)
-
-    ids = [(randint(1, 10000), ) for _ in range(num_queries)]
+    ids = random_unique_ids(num_queries)
+    id_params = [db_query_id_params[id_] for id_ in ids]
 
     async with request.app['pg'].acquire() as conn:
-        rows = await conn.fetchmany(READ_ROW_SQL, ids)
-        result = [{'id': id_[0], 'randomNumber': row[0]} for id_, row in zip(ids, rows)]
+        rows = await conn.fetchmany(READ_ROW_SQL, id_params)
+
+    result = [{'id': id_, 'randomNumber': row[0]} for id_, row in zip(ids, rows)]
     return json_response(result)
 
 
@@ -135,9 +138,10 @@ async def updates(request):
     Test 5 ORM
     """
     num_queries = get_num_queries(request)
-    update_ids = sample(range(1, 10001), num_queries)
+    update_ids = random_unique_ids(num_queries)
     update_ids.sort()
-    updates = tuple(zip(update_ids, sample(range(1, 10001), num_queries)))
+
+    updates = [*zip(update_ids, random_unique_ids(num_queries))]
     worlds = [{'id': row_id, 'randomNumber': number} for row_id, number in updates]
 
     async with request.app['db_session'].begin() as sess:
@@ -154,13 +158,14 @@ async def updates_raw(request):
     Test 5 RAW
     """
     num_queries = get_num_queries(request)
-    update_ids = sample(range(1, 10001), num_queries)
+    update_ids = random_unique_ids(num_queries)
     update_ids.sort()
 
-    numbers = sample(range(1, 10001), num_queries)
-    fetch_params = [(i,) for i in update_ids]
+    numbers = random_unique_ids(num_queries)
     row_updates = [*zip(update_ids, numbers)]
 
+    fetch_params = [db_query_id_params[i] for i in update_ids]
+
     async with request.app['pg'].acquire() as conn:
         # the result of this is the int previous random number which we don't actually use
         await conn.executemany(READ_ROW_SQL, fetch_params)

frameworks/Python/aiohttp/setup.py

@@ -0,0 +1,12 @@
+from setuptools import setup, Extension
+from Cython.Build import cythonize
+
+setup(
+    ext_modules=cythonize([
+        Extension(
+            "app.random_utils",
+            ["app/random_utils.pyx"],
+            extra_compile_args=["-O3"]
+        ),
+    ])
+)