[gjs/ewlsh/implicit-mainloop: 47/50] Implement custom GSource to handle promise queueing




commit d9eeab03e47f368221ca10a9110d61d59412d2a2
Author: Evan Welsh <contact evanwelsh com>
Date:   Sat Sep 4 19:58:31 2021 -0700

    Implement custom GSource to handle promise queueing
    
    (Cleanups and refactoring from Marco and Philip)

 gjs/context-private.h |   4 +-
 gjs/context.cpp       |  46 +++++-----------
 gjs/promise.cpp       | 143 ++++++++++++++++++++++++++++++++++++++++++++++++++
 gjs/promise.h         |  56 ++++++++++++++++++++
 meson.build           |   1 +
 tools/process_iwyu.py |   2 +
 tools/run_iwyu.sh     |   2 +-
 7 files changed, 218 insertions(+), 36 deletions(-)
---
diff --git a/gjs/context-private.h b/gjs/context-private.h
index 75b04bf0..776b919e 100644
--- a/gjs/context-private.h
+++ b/gjs/context-private.h
@@ -37,6 +37,7 @@
 #include "gjs/jsapi-util.h"
 #include "gjs/macros.h"
 #include "gjs/profiler.h"
+#include "gjs/promise.h"
 
 namespace js {
 class SystemAllocPolicy;
@@ -78,7 +79,7 @@ class GjsContextPrivate : public JS::JobQueue {
     std::vector<std::string> m_args;
 
     JobQueueStorage m_job_queue;
-    unsigned m_idle_drain_handler;
+    Gjs::PromiseJobQueueTask m_promise_queue_task;
 
     std::vector<std::pair<DestroyNotify, void*>> m_destroy_notifications;
     std::vector<Gjs::Closure::Ptr> m_async_closures;
@@ -134,7 +135,6 @@ class GjsContextPrivate : public JS::JobQueue {
     class SavedQueue;
     void start_draining_job_queue(void);
     void stop_draining_job_queue(void);
-    static gboolean drain_job_queue_idle_handler(void* data);
 
     uint8_t handle_exit_code(const char* type, const char* identifier,
                              GError** error);
diff --git a/gjs/context.cpp b/gjs/context.cpp
index 734ac68d..461f3a65 100644
--- a/gjs/context.cpp
+++ b/gjs/context.cpp
@@ -81,6 +81,7 @@
 #include "gjs/objectbox.h"
 #include "gjs/profiler-private.h"
 #include "gjs/profiler.h"
+#include "gjs/promise.h"
 #include "gjs/text-encoding.h"
 #include "modules/modules.h"
 #include "util/log.h"
@@ -405,6 +406,8 @@ void GjsContextPrivate::unregister_notifier(DestroyNotify notify_func,
 
 void GjsContextPrivate::dispose(void) {
     if (m_cx) {
+        stop_draining_job_queue();
+
         gjs_debug(GJS_DEBUG_CONTEXT,
                   "Notifying reference holders of GjsContext dispose");
 
@@ -532,8 +535,8 @@ GjsContextPrivate::GjsContextPrivate(JSContext* cx, GjsContext* public_context)
     : m_public_context(public_context),
       m_cx(cx),
       m_owner_thread(std::this_thread::get_id()),
+      m_promise_queue_task(this),
       m_environment_preparer(cx) {
-
     JS_SetGCCallback(
         cx,
         [](JSContext*, JSGCStatus status, JS::GCReason reason, void* data) {
@@ -654,6 +657,8 @@ GjsContextPrivate::GjsContextPrivate(JSContext* cx, GjsContext* public_context)
             cx, "resource:///org/gnome/gjs/modules/esm/_bootstrap/default.js",
             "ESM bootstrap");
     }
+
+    start_draining_job_queue();
 }
 
 void GjsContextPrivate::set_args(std::vector<std::string>&& args) {
@@ -895,32 +900,15 @@ bool GjsContextPrivate::should_exit(uint8_t* exit_code_p) const {
 }
 
 void GjsContextPrivate::start_draining_job_queue(void) {
-    if (!m_idle_drain_handler) {
-        gjs_debug(GJS_DEBUG_CONTEXT, "Starting promise job queue handler");
-        m_idle_drain_handler = g_idle_add_full(
-            G_PRIORITY_DEFAULT, drain_job_queue_idle_handler, this, nullptr);
-    }
+    gjs_debug(GJS_DEBUG_CONTEXT, "Starting promise job queue task");
+    m_promise_queue_task.start();
 }
 
 void GjsContextPrivate::stop_draining_job_queue(void) {
     m_draining_job_queue = false;
-    if (m_idle_drain_handler) {
-        gjs_debug(GJS_DEBUG_CONTEXT, "Stopping promise job queue handler");
-        g_source_remove(m_idle_drain_handler);
-        m_idle_drain_handler = 0;
-    }
-}
 
-gboolean GjsContextPrivate::drain_job_queue_idle_handler(void* data) {
-    gjs_debug(GJS_DEBUG_CONTEXT, "Promise job queue handler");
-    auto* gjs = static_cast<GjsContextPrivate*>(data);
-    gjs->runJobs(gjs->context());
-    /* Uncatchable exceptions are swallowed here - no way to get a handle on
-     * the main loop to exit it from this idle handler */
-    gjs_debug(GJS_DEBUG_CONTEXT, "Promise job queue handler finished");
-    g_assert(gjs->empty() && gjs->m_idle_drain_handler == 0 &&
-             "GjsContextPrivate::runJobs() should have emptied queue");
-    return G_SOURCE_REMOVE;
+    gjs_debug(GJS_DEBUG_CONTEXT, "Stopping promise job queue task");
+    m_promise_queue_task.stop();
 }
 
 JSObject* GjsContextPrivate::getIncumbentGlobal(JSContext* cx) {
@@ -943,18 +931,13 @@ bool GjsContextPrivate::enqueuePromiseJob(JSContext* cx [[maybe_unused]],
               gjs_debug_object(job).c_str(), gjs_debug_object(promise).c_str(),
               gjs_debug_object(allocation_site).c_str());
 
-    if (m_idle_drain_handler)
-        g_assert(!empty());
-    else
-        g_assert(empty());
-
     if (!m_job_queue.append(job)) {
         JS_ReportOutOfMemory(m_cx);
         return false;
     }
 
     JS::JobQueueMayNotBeEmpty(m_cx);
-    start_draining_job_queue();
+    m_promise_queue_task.start();
     return true;
 }
 
@@ -1032,8 +1015,8 @@ bool GjsContextPrivate::run_jobs_fallible(void) {
         }
     }
 
+    m_draining_job_queue = false;
     m_job_queue.clear();
-    stop_draining_job_queue();
     JS::JobQueueIsEmpty(m_cx);
     return retval;
 }
@@ -1042,14 +1025,12 @@ class GjsContextPrivate::SavedQueue : public JS::JobQueue::SavedJobQueue {
  private:
     GjsContextPrivate* m_gjs;
     JS::PersistentRooted<JobQueueStorage> m_queue;
-    bool m_idle_was_pending : 1;
     bool m_was_draining : 1;
 
  public:
     explicit SavedQueue(GjsContextPrivate* gjs)
         : m_gjs(gjs),
           m_queue(gjs->m_cx, std::move(gjs->m_job_queue)),
-          m_idle_was_pending(gjs->m_idle_drain_handler != 0),
           m_was_draining(gjs->m_draining_job_queue) {
         gjs_debug(GJS_DEBUG_CONTEXT, "Pausing job queue");
         gjs->stop_draining_job_queue();
@@ -1059,8 +1040,7 @@ class GjsContextPrivate::SavedQueue : public JS::JobQueue::SavedJobQueue {
         gjs_debug(GJS_DEBUG_CONTEXT, "Unpausing job queue");
         m_gjs->m_job_queue = std::move(m_queue.get());
         m_gjs->m_draining_job_queue = m_was_draining;
-        if (m_idle_was_pending)
-            m_gjs->start_draining_job_queue();
+        m_gjs->start_draining_job_queue();
     }
 };
 
diff --git a/gjs/promise.cpp b/gjs/promise.cpp
new file mode 100644
index 00000000..f5c59d19
--- /dev/null
+++ b/gjs/promise.cpp
@@ -0,0 +1,143 @@
+// SPDX-License-Identifier: MIT OR LGPL-2.0-or-later
+// SPDX-FileCopyrightText: 2021 Evan Welsh <contact evanwelsh com>
+// SPDX-FileCopyrightText: 2021 Marco Trevisan <mail 3v1n0 net>
+
+#include <config.h>
+
+#include <stddef.h>  // for size_t
+
+#include <gio/gio.h>
+#include <glib-object.h>
+
+#include <js/CallArgs.h>
+#include <js/PropertySpec.h>
+#include <js/RootingAPI.h>
+#include <js/TypeDecls.h>
+#include <jsapi.h>
+
+#include "gjs/context-private.h"
+#include "gjs/jsapi-util.h"
+#include "gjs/macros.h"
+#include "gjs/promise.h"
+
+namespace Gjs {
+
+/**
+ * @brief a custom GSource which handles draining our job queue.
+ */
+class PromiseJobQueueTask::Source : public GSource {
+    // The private GJS context this source runs within.
+    GjsContextPrivate* m_gjs;
+    // The main context this source attaches to.
+    GjsAutoMainContext m_main_context;
+    // The cancellable that stops this source.
+    GjsAutoUnref<GCancellable> m_cancellable;
+
+    // G_PRIORITY_HIGH is -100, we set -1000 to ensure our source
+    // always has the greatest priority. This means our prepare will
+    // be called before other sources, and prepare will determine whether
+    // we dispatch.
+    static constexpr int PRIORITY = -1000;
+
+    // GSource custom functions
+    static GSourceFuncs source_funcs;
+
+    // Called to determine whether the source should run (dispatch) in the
+    // next event loop iteration. If the job queue is not empty we return true
+    // to schedule a dispatch.
+    gboolean prepare(int* timeout [[maybe_unused]]) { return !m_gjs->empty(); }
+
+    gboolean dispatch() {
+        if (g_cancellable_is_cancelled(m_cancellable))
+            return G_SOURCE_REMOVE;
+
+        // The ready time is sometimes set to 0 to kick us out of polling,
+        // we need to reset the value here or this source will always be the
+        // next one to execute. (it will starve the other sources)
+        g_source_set_ready_time(this, -1);
+
+        // Drain the job queue.
+        m_gjs->runJobs(m_gjs->context());
+
+        return G_SOURCE_CONTINUE;
+    }
+
+ public:
+    /**
+     * @brief Constructs a new GjsPromiseJobQueueSource GSource and adds a
+     * reference to the associated main context.
+     *
+     * @param cx the current JSContext
+     * @param cancellable an optional cancellable
+     */
+    Source(GjsContextPrivate* gjs, GMainContext* main_context)
+        : m_gjs(gjs),
+          m_main_context(main_context, GjsAutoTakeOwnership()),
+          m_cancellable(g_cancellable_new()) {
+        g_source_set_priority(this, PRIORITY);
+#if GLIB_CHECK_VERSION(2, 70, 0)
+        g_source_set_static_name(this, "GjsPromiseJobQueueSource");
+#else
+        g_source_set_name(this, "GjsPromiseJobQueueSource");
+#endif
+
+        GSource* cancellable_source = g_cancellable_source_new(m_cancellable);
+        g_source_add_child_source(this, cancellable_source);
+        g_source_set_dummy_callback(cancellable_source);
+        g_source_unref(cancellable_source);
+    }
+
+    void* operator new(size_t size) {
+        return g_source_new(&source_funcs, size);
+    }
+    void operator delete(void* p) { g_source_unref(static_cast<GSource*>(p)); }
+
+    /**
+     * @brief Trigger the cancellable, detaching our source.
+     */
+    void cancel() { g_cancellable_cancel(m_cancellable); }
+    /**
+     * @brief Reset the cancellable
+     */
+    void reset() { g_cancellable_reset(m_cancellable); }
+};
+
+GSourceFuncs PromiseJobQueueTask::Source::source_funcs = {
+    [](GSource* source, int* timeout) {
+        return static_cast<Source*>(source)->prepare(timeout);
+    },
+    nullptr,  // check
+    [](GSource* source, GSourceFunc, void*) {
+        return static_cast<Source*>(source)->dispatch();
+    },
+    [](GSource* source) { static_cast<Source*>(source)->~Source(); },
+};
+
+PromiseJobQueueTask::PromiseJobQueueTask(GjsContextPrivate* gjs)
+    // Acquire a guaranteed reference to this thread's default main context
+    : m_main_context(g_main_context_ref_thread_default()),
+      // Create and reference our custom GSource
+      m_source(std::make_unique<Source>(gjs, m_main_context)) {}
+
+PromiseJobQueueTask::~PromiseJobQueueTask() {
+    g_source_destroy(m_source.get());
+}
+
+bool PromiseJobQueueTask::is_running() {
+    return !!g_source_get_context(m_source.get());
+}
+
+void PromiseJobQueueTask::start() {
+    // Reset the cancellable
+    m_source->reset();
+
+    // Don't re-attach if the task is already running
+    if (is_running())
+        return;
+
+    g_source_attach(m_source.get(), m_main_context);
+}
+
+void PromiseJobQueueTask::stop() { m_source->cancel(); }
+
+};  // namespace Gjs
diff --git a/gjs/promise.h b/gjs/promise.h
new file mode 100644
index 00000000..133822ca
--- /dev/null
+++ b/gjs/promise.h
@@ -0,0 +1,56 @@
+// SPDX-License-Identifier: MIT OR LGPL-2.0-or-later
+// SPDX-FileCopyrightText: 2021 Evan Welsh <contact evanwelsh com>
+
+#pragma once
+
+#include <config.h>
+
+#include <memory>
+
+#include <glib.h>
+
+#include <js/TypeDecls.h>
+
+#include "gjs/jsapi-util.h"
+
+class GjsContextPrivate;
+
+using GjsAutoMainContext =
+    GjsAutoPointer<GMainContext, GMainContext, g_main_context_unref,
+                   g_main_context_ref>;
+
+namespace Gjs {
+
+/**
+ * @brief A class which wraps a custom GSource and handles
+ * associating it with a main context. All memory is handled,
+ * so this class is safe to use without raw pointers.
+ */
+class PromiseJobQueueTask {
+    class Source;
+    // The thread-default GMainContext
+    GjsAutoMainContext m_main_context;
+    // The custom source.
+    std::unique_ptr<Source> m_source;
+
+ public:
+    explicit PromiseJobQueueTask(GjsContextPrivate*);
+    ~PromiseJobQueueTask();
+
+    /**
+     * @brief Start (or restart) the task
+     */
+    void start();
+
+    /**
+     * @brief Stop the task
+     */
+    void stop();
+
+    /**
+     * @brief whether the task is currently running in the associated context
+     */
+    bool is_running();
+};
+
+};  // namespace Gjs
diff --git a/meson.build b/meson.build
index 78bfc8a6..437b3fd3 100644
--- a/meson.build
+++ b/meson.build
@@ -424,6 +424,7 @@ libgjs_sources = [
     'gjs/objectbox.cpp', 'gjs/objectbox.h',
     'gjs/profiler.cpp', 'gjs/profiler-private.h',
     'gjs/text-encoding.cpp', 'gjs/text-encoding.h',
+    'gjs/promise.cpp', 'gjs/promise.h',
     'gjs/stack.cpp',
     'modules/console.cpp', 'modules/console.h',
     'modules/modules.cpp', 'modules/modules.h',
diff --git a/tools/process_iwyu.py b/tools/process_iwyu.py
index 718349b2..2cc32e62 100755
--- a/tools/process_iwyu.py
+++ b/tools/process_iwyu.py
@@ -106,6 +106,8 @@ FALSE_POSITIVES = (
      'for remove_reference<>::type'),
     ('gjs/profiler.cpp', '#include <type_traits>',
      'for remove_reference<>::type'),
+    ('gjs/promise.cpp', '#include <type_traits>',
+     'for remove_reference<>::type'),
     ('test/gjs-test-jsapi-utils.cpp', '#include <type_traits>',
      'for remove_reference<>::type'),
 
diff --git a/tools/run_iwyu.sh b/tools/run_iwyu.sh
index 319da33e..7e1db246 100755
--- a/tools/run_iwyu.sh
+++ b/tools/run_iwyu.sh
@@ -71,7 +71,7 @@ for FILE in $SRCDIR/gi/*.cpp $SRCDIR/gjs/atoms.cpp $SRCDIR/gjs/byteArray.cpp \
     $SRCDIR/gjs/deprecation.cpp $SRCDIR/gjs/error-types.cpp \
     $SRCDIR/gjs/engine.cpp $SRCDIR/gjs/global.cpp $SRCDIR/gjs/importer.cpp \
     $SRCDIR/gjs/jsapi-util*.cpp $SRCDIR/gjs/module.cpp $SRCDIR/gjs/native.cpp \
-    $SRCDIR/gjs/objectbox.cpp $SRCDIR/gjs/stack.cpp \
+    $SRCDIR/gjs/objectbox.cpp $SRCDIR/gjs/promise.cpp $SRCDIR/gjs/stack.cpp \
     $SRCDIR/modules/cairo-*.cpp $SRCDIR/modules/console.cpp \
     $SRCDIR/modules/print.cpp $SRCDIR/modules/system.cpp $SRCDIR/test/*.cpp \
     $SRCDIR/util/*.cpp $SRCDIR/libgjs-private/*.c


[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]