Add _erlang_sleep for ASGI fast path and erlang_asyncio module

- Add sync_sleep fields to erlang_event_loop_t (id, complete flag, cond var)
- Add py_erlang_sleep() Python function that blocks on Erlang timer
- Add nif_dispatch_sleep_complete() to signal sleep completion
- Handle {sleep_wait, DelayMs, SleepId} in py_event_worker.erl
- Add erlang_asyncio module with full asyncio-compatible API:
  * sleep(), run(), gather(), wait(), wait_for()
  * create_task(), ensure_future(), shield()
  * get_event_loop(), new_event_loop(), set_event_loop()
  * TimeoutError, CancelledError exceptions
  * ALL_COMPLETED, FIRST_COMPLETED, FIRST_EXCEPTION constants
- Add py_erlang_sleep_SUITE with 8 tests

Usage:
    import erlang_asyncio

    async def main():
        await erlang_asyncio.sleep(0.001)
        results = await erlang_asyncio.gather(task1(), task2())

    erlang_asyncio.run(main())

Author: benoitc

c_src/py_event_loop.c

@@ -193,9 +193,12 @@ void event_loop_destructor(ErlNifEnv *env, void *obj) {
     /* Signal shutdown */
     loop->shutdown = true;
 
-    /* Wake up any waiting threads */
+    /* Wake up any waiting threads (including sync sleep waiters) */
     pthread_mutex_lock(&loop->mutex);
     pthread_cond_broadcast(&loop->event_cond);
+    if (loop->sync_sleep_cond_initialized) {
+        pthread_cond_broadcast(&loop->sync_sleep_cond);
+    }
     pthread_mutex_unlock(&loop->mutex);
 
     /* Clear pending events (returns them to freelist) */
@@ -220,6 +223,9 @@ void event_loop_destructor(ErlNifEnv *env, void *obj) {
     /* Destroy synchronization primitives */
     pthread_mutex_destroy(&loop->mutex);
     pthread_cond_destroy(&loop->event_cond);
+    if (loop->sync_sleep_cond_initialized) {
+        pthread_cond_destroy(&loop->sync_sleep_cond);
+    }
 }
 
 /**
@@ -441,8 +447,19 @@ ERL_NIF_TERM nif_event_loop_new(ErlNifEnv *env, int argc,
         return make_error(env, "cond_init_failed");
     }
 
+    if (pthread_cond_init(&loop->sync_sleep_cond, NULL) != 0) {
+        pthread_cond_destroy(&loop->event_cond);
+        pthread_mutex_destroy(&loop->mutex);
+        enif_release_resource(loop);
+        return make_error(env, "sleep_cond_init_failed");
+    }
+    loop->sync_sleep_cond_initialized = true;
+    atomic_store(&loop->sync_sleep_id, 0);
+    atomic_store(&loop->sync_sleep_complete, false);
+
     loop->msg_env = enif_alloc_env();
     if (loop->msg_env == NULL) {
+        pthread_cond_destroy(&loop->sync_sleep_cond);
         pthread_cond_destroy(&loop->event_cond);
         pthread_mutex_destroy(&loop->mutex);
         enif_release_resource(loop);
@@ -1094,6 +1111,38 @@ ERL_NIF_TERM nif_dispatch_timer(ErlNifEnv *env, int argc,
     return ATOM_OK;
 }
 
+/**
+ * dispatch_sleep_complete(LoopRef, SleepId) -> ok
+ *
+ * Called from Erlang when a synchronous sleep timer expires.
+ * Signals the waiting Python thread to wake up.
+ */
+ERL_NIF_TERM nif_dispatch_sleep_complete(ErlNifEnv *env, int argc,
+                                          const ERL_NIF_TERM argv[]) {
+    (void)argc;
+
+    erlang_event_loop_t *loop;
+    if (!enif_get_resource(env, argv[0], EVENT_LOOP_RESOURCE_TYPE,
+                           (void **)&loop)) {
+        return make_error(env, "invalid_loop");
+    }
+
+    ErlNifUInt64 sleep_id;
+    if (!enif_get_uint64(env, argv[1], &sleep_id)) {
+        return make_error(env, "invalid_sleep_id");
+    }
+
+    /* Only signal if this is the sleep we're waiting for */
+    pthread_mutex_lock(&loop->mutex);
+    if (atomic_load(&loop->sync_sleep_id) == sleep_id) {
+        atomic_store(&loop->sync_sleep_complete, true);
+        pthread_cond_broadcast(&loop->sync_sleep_cond);
+    }
+    pthread_mutex_unlock(&loop->mutex);
+
+    return ATOM_OK;
+}
+
 /**
  * handle_fd_event(FdRes, Type) -> ok | {error, Reason}
  *
@@ -3611,6 +3660,89 @@ static PyObject *py_get_pending_for(PyObject *self, PyObject *args) {
     return list;
 }
 
+/**
+ * Python function: _erlang_sleep(delay_ms) -> None
+ *
+ * Synchronous sleep that uses Erlang's timer system instead of asyncio.
+ * Sends {sleep_wait, DelayMs, SleepId} to the worker, then blocks waiting
+ * for the sleep completion signal.
+ *
+ * This is called from the ASGI fast path when asyncio.sleep() is detected,
+ * avoiding the need to create a full event loop.
+ */
+static PyObject *py_erlang_sleep(PyObject *self, PyObject *args) {
+    (void)self;
+    int delay_ms;
+
+    if (!PyArg_ParseTuple(args, "i", &delay_ms)) {
+        return NULL;
+    }
+
+    /* For zero or negative delay, return immediately */
+    if (delay_ms <= 0) {
+        Py_RETURN_NONE;
+    }
+
+    erlang_event_loop_t *loop = get_interpreter_event_loop();
+    if (loop == NULL || loop->shutdown) {
+        PyErr_SetString(PyExc_RuntimeError, "Event loop not initialized");
+        return NULL;
+    }
+
+    /* Check if we have a worker to send to */
+    if (!loop->has_worker && !loop->has_router) {
+        PyErr_SetString(PyExc_RuntimeError, "No worker or router configured");
+        return NULL;
+    }
+
+    /* Generate a unique sleep ID */
+    uint64_t sleep_id = atomic_fetch_add(&loop->next_callback_id, 1);
+
+    /* Send {sleep_wait, DelayMs, SleepId} to worker */
+    ErlNifEnv *msg_env = enif_alloc_env();
+    if (msg_env == NULL) {
+        PyErr_SetString(PyExc_MemoryError, "Failed to allocate message environment");
+        return NULL;
+    }
+
+    ERL_NIF_TERM msg = enif_make_tuple3(
+        msg_env,
+        enif_make_atom(msg_env, "sleep_wait"),
+        enif_make_int(msg_env, delay_ms),
+        enif_make_uint64(msg_env, sleep_id)
+    );
+
+    /* Use worker_pid when available, otherwise fall back to router_pid */
+    ErlNifPid *target_pid = loop->has_worker ? &loop->worker_pid : &loop->router_pid;
+    if (!enif_send(NULL, target_pid, msg_env, msg)) {
+        enif_free_env(msg_env);
+        PyErr_SetString(PyExc_RuntimeError, "Failed to send sleep message");
+        return NULL;
+    }
+    enif_free_env(msg_env);
+
+    /* Set up for waiting on this sleep */
+    pthread_mutex_lock(&loop->mutex);
+    atomic_store(&loop->sync_sleep_id, sleep_id);
+    atomic_store(&loop->sync_sleep_complete, false);
+
+    /* Release GIL and wait for completion */
+    Py_BEGIN_ALLOW_THREADS
+    while (!atomic_load(&loop->sync_sleep_complete) && !loop->shutdown) {
+        pthread_cond_wait(&loop->sync_sleep_cond, &loop->mutex);
+    }
+    Py_END_ALLOW_THREADS
+
+    pthread_mutex_unlock(&loop->mutex);
+
+    if (loop->shutdown) {
+        PyErr_SetString(PyExc_RuntimeError, "Event loop shutdown during sleep");
+        return NULL;
+    }
+
+    Py_RETURN_NONE;
+}
+
 /* Module method definitions */
 static PyMethodDef PyEventLoopMethods[] = {
     /* Legacy API (uses global event loop) */
@@ -3640,6 +3772,8 @@ static PyMethodDef PyEventLoopMethods[] = {
     {"_remove_writer_for", py_remove_writer_for, METH_VARARGS, "Stop monitoring fd for writes on specific loop"},
     {"_schedule_timer_for", py_schedule_timer_for, METH_VARARGS, "Schedule timer on specific loop"},
     {"_cancel_timer_for", py_cancel_timer_for, METH_VARARGS, "Cancel timer on specific loop"},
+    /* Synchronous sleep (for ASGI fast path) */
+    {"_erlang_sleep", py_erlang_sleep, METH_VARARGS, "Synchronous sleep using Erlang timer"},
     {NULL, NULL, 0, NULL}
 };
 
@@ -3714,8 +3848,19 @@ int create_default_event_loop(ErlNifEnv *env) {
         return -1;
     }
 
+    if (pthread_cond_init(&loop->sync_sleep_cond, NULL) != 0) {
+        pthread_cond_destroy(&loop->event_cond);
+        pthread_mutex_destroy(&loop->mutex);
+        enif_release_resource(loop);
+        return -1;
+    }
+    loop->sync_sleep_cond_initialized = true;
+    atomic_store(&loop->sync_sleep_id, 0);
+    atomic_store(&loop->sync_sleep_complete, false);
+
     loop->msg_env = enif_alloc_env();
     if (loop->msg_env == NULL) {
+        pthread_cond_destroy(&loop->sync_sleep_cond);
         pthread_cond_destroy(&loop->event_cond);
         pthread_mutex_destroy(&loop->mutex);
         enif_release_resource(loop);

c_src/py_event_loop.h

@@ -239,6 +239,20 @@ typedef struct erlang_event_loop {
 
     /** @brief Count of occupied slots in hash set */
     int pending_hash_count;
+
+    /* ========== Synchronous Sleep Support ========== */
+
+    /** @brief Current synchronous sleep ID being waited on */
+    _Atomic uint64_t sync_sleep_id;
+
+    /** @brief Flag indicating sleep has completed */
+    _Atomic bool sync_sleep_complete;
+
+    /** @brief Condition variable for sleep completion notification */
+    pthread_cond_t sync_sleep_cond;
+
+    /** @brief Whether sync_sleep_cond has been initialized */
+    bool sync_sleep_cond_initialized;
 } erlang_event_loop_t;
 
 /* ============================================================================
@@ -441,6 +455,16 @@ ERL_NIF_TERM nif_dispatch_timer(ErlNifEnv *env, int argc,
 ERL_NIF_TERM nif_event_loop_wakeup(ErlNifEnv *env, int argc,
                                    const ERL_NIF_TERM argv[]);
 
+/**
+ * @brief Signal that a synchronous sleep has completed
+ *
+ * Called from Erlang when a sleep timer expires.
+ *
+ * NIF: dispatch_sleep_complete(LoopRef, SleepId) -> ok
+ */
+ERL_NIF_TERM nif_dispatch_sleep_complete(ErlNifEnv *env, int argc,
+                                          const ERL_NIF_TERM argv[]);
+
 /* ============================================================================
  * Internal Helper Functions
  * ============================================================================ */

c_src/py_nif.c

@@ -1895,6 +1895,7 @@ static ErlNifFunc nif_funcs[] = {
     {"get_pending", 1, nif_get_pending, 0},
     {"dispatch_callback", 3, nif_dispatch_callback, 0},
     {"dispatch_timer", 2, nif_dispatch_timer, 0},
+    {"dispatch_sleep_complete", 2, nif_dispatch_sleep_complete, 0},
     {"get_fd_callback_id", 2, nif_get_fd_callback_id, 0},
     {"reselect_reader", 2, nif_reselect_reader, 0},
     {"reselect_writer", 2, nif_reselect_writer, 0},