[glib/wip/notify-performance: 2/11] [notify] merge gobjectnotifyqueue.c into gobject.c

[Ryan Lortie <ryanl src gnome org>]

commit 52c30ac51dc7ecfa838eecbbf4b9a8ac2c77c420
Author: Ryan Lortie <desrt desrt ca>
Date:   Wed Nov 16 15:31:58 2011 +0000

    [notify] merge gobjectnotifyqueue.c into gobject.c
    
    This was done as a separate file before, and #include brought it into
    gobject.c.  That's a bit mad, so stop doing that.
    
    Unfortunately, the insanity steps up a level: gobjectnotifyqueue.c is
    installed in the public include dir, so we can't just get rid of it
    entirely.

 gobject/gobject.c |  162 ++++++++++++++++++++++++++++++++++++++++++++++++++++-
 1 files changed, 160 insertions(+), 2 deletions(-)
---
diff --git a/gobject/gobject.c b/gobject/gobject.c
index 22ae133..f4a29c1 100644
--- a/gobject/gobject.c
+++ b/gobject/gobject.c
@@ -34,8 +34,6 @@
 #include "gvaluetypes.h"
 #include "gobject_trace.h"
 
-#include "gobjectnotifyqueue.c"
-
 /**
  * SECTION:objects
  * @short_description: The base object type
@@ -179,6 +177,28 @@ static guint               object_floating_flag_handler (GObject        *object,
 static void object_interface_check_properties           (gpointer        func_data,
 							 gpointer        g_iface);
 
+/* --- typedefs --- */
+typedef struct _GObjectNotifyContext          GObjectNotifyContext;
+typedef struct _GObjectNotifyQueue            GObjectNotifyQueue;
+typedef void (*GObjectNotifyQueueDispatcher) (GObject     *object,
+					      guint        n_pspecs,
+					      GParamSpec **pspecs);
+
+
+/* --- structures --- */
+struct _GObjectNotifyContext
+{
+  GQuark                       quark_notify_queue;
+  GObjectNotifyQueueDispatcher dispatcher;
+  GTrashStack                 *_nqueue_trash; /* unused */
+};
+struct _GObjectNotifyQueue
+{
+  GObjectNotifyContext *context;
+  GSList               *pspecs;
+  guint16               n_pspecs;
+  guint16               freeze_count;
+};
 
 /* --- variables --- */
 G_LOCK_DEFINE_STATIC (closure_array_mutex);
@@ -202,6 +222,144 @@ static volatile GObject *g_trap_object_ref = NULL;
 static guint		 debug_objects_count = 0;
 static GHashTable	*debug_objects_ht = NULL;
 
+G_LOCK_DEFINE_STATIC(notify_lock);
+
+/* --- functions --- */
+static void
+g_object_notify_queue_free (gpointer data)
+{
+  GObjectNotifyQueue *nqueue = data;
+
+  g_slist_free (nqueue->pspecs);
+  g_slice_free (GObjectNotifyQueue, nqueue);
+}
+
+static inline GObjectNotifyQueue*
+g_object_notify_queue_freeze (GObject              *object,
+                              GObjectNotifyContext *context)
+{
+  GObjectNotifyQueue *nqueue;
+
+  G_LOCK(notify_lock);
+  nqueue = g_datalist_id_get_data (&object->qdata, context->quark_notify_queue);
+  if (!nqueue)
+    {
+      nqueue = g_slice_new0 (GObjectNotifyQueue);
+      nqueue->context = context;
+      g_datalist_id_set_data_full (&object->qdata, context->quark_notify_queue,
+                                   nqueue, g_object_notify_queue_free);
+    }
+
+  if (nqueue->freeze_count >= 65535)
+    g_critical("Free queue for %s (%p) is larger than 65535,"
+               " called g_object_freeze_notify() too often."
+               " Forgot to call g_object_thaw_notify() or infinite loop",
+               G_OBJECT_TYPE_NAME (object), object);
+  else
+    nqueue->freeze_count++;
+  G_UNLOCK(notify_lock);
+
+  return nqueue;
+}
+
+static inline void
+g_object_notify_queue_thaw (GObject            *object,
+                            GObjectNotifyQueue *nqueue)
+{
+  GObjectNotifyContext *context = nqueue->context;
+  GParamSpec *pspecs_mem[16], **pspecs, **free_me = NULL;
+  GSList *slist;
+  guint n_pspecs = 0;
+
+  g_return_if_fail (nqueue->freeze_count > 0);
+  g_return_if_fail (g_atomic_int_get(&object->ref_count) > 0);
+
+  G_LOCK(notify_lock);
+
+  /* Just make sure we never get into some nasty race condition */
+  if (G_UNLIKELY(nqueue->freeze_count == 0)) {
+    G_UNLOCK(notify_lock);
+    g_warning ("%s: property-changed notification for %s(%p) is not frozen",
+               G_STRFUNC, G_OBJECT_TYPE_NAME (object), object);
+    return;
+  }
+
+  nqueue->freeze_count--;
+  if (nqueue->freeze_count) {
+    G_UNLOCK(notify_lock);
+    return;
+  }
+
+  pspecs = nqueue->n_pspecs > 16 ? free_me = g_new (GParamSpec*, nqueue->n_pspecs) : pspecs_mem;
+
+  for (slist = nqueue->pspecs; slist; slist = slist->next)
+    {
+      pspecs[n_pspecs++] = slist->data;
+    }
+  g_datalist_id_set_data (&object->qdata, context->quark_notify_queue, NULL);
+
+  G_UNLOCK(notify_lock);
+
+  if (n_pspecs)
+    context->dispatcher (object, n_pspecs, pspecs);
+  g_free (free_me);
+}
+
+static inline void
+g_object_notify_queue_clear (GObject            *object,
+                             GObjectNotifyQueue *nqueue)
+{
+  g_return_if_fail (nqueue->freeze_count > 0);
+
+  G_LOCK(notify_lock);
+
+  g_slist_free (nqueue->pspecs);
+  nqueue->pspecs = NULL;
+  nqueue->n_pspecs = 0;
+
+  G_UNLOCK(notify_lock);
+}
+
+static inline void
+g_object_notify_queue_add (GObject            *object,
+                           GObjectNotifyQueue *nqueue,
+                           GParamSpec         *pspec)
+{
+  if (pspec->flags & G_PARAM_READABLE)
+    {
+      GParamSpec *redirect;
+
+      G_LOCK(notify_lock);
+
+      g_return_if_fail (nqueue->n_pspecs < 65535);
+
+      redirect = g_param_spec_get_redirect_target (pspec);
+      if (redirect)
+        pspec = redirect;
+
+      /* we do the deduping in _thaw */
+      if (g_slist_find (nqueue->pspecs, pspec) == NULL)
+        {
+          nqueue->pspecs = g_slist_prepend (nqueue->pspecs, pspec);
+          nqueue->n_pspecs++;
+        }
+
+      G_UNLOCK(notify_lock);
+    }
+}
+
+/* NB: This function is not threadsafe, do not ever use it if
+ * you need a threadsafe notify queue.
+ * Use g_object_notify_queue_freeze() to acquire the queue and
+ * g_object_notify_queue_thaw() after you are done instead.
+ */
+static inline GObjectNotifyQueue*
+g_object_notify_queue_from_object (GObject              *object,
+                                   GObjectNotifyContext *context)
+{
+  return g_datalist_id_get_data (&object->qdata, context->quark_notify_queue);
+}
+
 static void
 debug_objects_foreach (gpointer key,
 		       gpointer value,