Import Upstream version 2.72.4

gobject/tests/threadtests.c

@@ -0,0 +1,525 @@
+/* GLib testing framework examples and tests
+ * Copyright (C) 2008 Imendio AB
+ * Authors: Tim Janik
+ *
+ * This work is provided "as is"; redistribution and modification
+ * in whole or in part, in any medium, physical or electronic is
+ * permitted without restriction.
+ *
+ * This work is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * In no event shall the authors or contributors be liable for any
+ * direct, indirect, incidental, special, exemplary, or consequential
+ * damages (including, but not limited to, procurement of substitute
+ * goods or services; loss of use, data, or profits; or business
+ * interruption) however caused and on any theory of liability, whether
+ * in contract, strict liability, or tort (including negligence or
+ * otherwise) arising in any way out of the use of this software, even
+ * if advised of the possibility of such damage.
+ */
+
+#ifndef GLIB_DISABLE_DEPRECATION_WARNINGS
+#define GLIB_DISABLE_DEPRECATION_WARNINGS
+#endif
+
+#include <glib.h>
+#include <glib-object.h>
+
+static int mtsafe_call_counter = 0; /* multi thread safe call counter, must be accessed atomically */
+static int unsafe_call_counter = 0; /* single-threaded call counter */
+static GCond sync_cond;
+static GMutex sync_mutex;
+
+#define NUM_COUNTER_INCREMENTS 100000
+
+static void
+call_counter_init (gpointer tclass)
+{
+  int i;
+  for (i = 0; i < NUM_COUNTER_INCREMENTS; i++)
+    {
+      int saved_unsafe_call_counter = unsafe_call_counter;
+      g_atomic_int_add (&mtsafe_call_counter, 1); /* real call count update */
+      g_thread_yield(); /* let concurrent threads corrupt the unsafe_call_counter state */
+      unsafe_call_counter = 1 + saved_unsafe_call_counter; /* non-atomic counter update */
+    }
+}
+
+static void interface_per_class_init (void) { call_counter_init (NULL); }
+
+/* define 3 test interfaces */
+typedef GTypeInterface MyFace0Interface;
+static GType my_face0_get_type (void);
+G_DEFINE_INTERFACE (MyFace0, my_face0, G_TYPE_OBJECT)
+static void my_face0_default_init (MyFace0Interface *iface) { call_counter_init (iface); }
+typedef GTypeInterface MyFace1Interface;
+static GType my_face1_get_type (void);
+G_DEFINE_INTERFACE (MyFace1, my_face1, G_TYPE_OBJECT)
+static void my_face1_default_init (MyFace1Interface *iface) { call_counter_init (iface); }
+
+/* define 3 test objects, adding interfaces 0 & 1, and adding interface 2 after class initialization */
+typedef GObject         MyTester0;
+typedef GObjectClass    MyTester0Class;
+static GType my_tester0_get_type (void);
+G_DEFINE_TYPE_WITH_CODE (MyTester0, my_tester0, G_TYPE_OBJECT,
+                         G_IMPLEMENT_INTERFACE (my_face0_get_type(), interface_per_class_init)
+                         G_IMPLEMENT_INTERFACE (my_face1_get_type(), interface_per_class_init))
+static void my_tester0_init (MyTester0*t) {}
+static void my_tester0_class_init (MyTester0Class*c) { call_counter_init (c); }
+typedef GObject         MyTester1;
+typedef GObjectClass    MyTester1Class;
+
+/* Disabled for now (see https://bugzilla.gnome.org/show_bug.cgi?id=687659) */
+#if 0
+typedef GTypeInterface MyFace2Interface;
+static GType my_face2_get_type (void);
+G_DEFINE_INTERFACE (MyFace2, my_face2, G_TYPE_OBJECT)
+static void my_face2_default_init (MyFace2Interface *iface) { call_counter_init (iface); }
+
+static GType my_tester1_get_type (void);
+G_DEFINE_TYPE_WITH_CODE (MyTester1, my_tester1, G_TYPE_OBJECT,
+                         G_IMPLEMENT_INTERFACE (my_face0_get_type(), interface_per_class_init)
+                         G_IMPLEMENT_INTERFACE (my_face1_get_type(), interface_per_class_init))
+static void my_tester1_init (MyTester1*t) {}
+static void my_tester1_class_init (MyTester1Class*c) { call_counter_init (c); }
+typedef GObject         MyTester2;
+typedef GObjectClass    MyTester2Class;
+static GType my_tester2_get_type (void);
+G_DEFINE_TYPE_WITH_CODE (MyTester2, my_tester2, G_TYPE_OBJECT,
+                         G_IMPLEMENT_INTERFACE (my_face0_get_type(), interface_per_class_init)
+                         G_IMPLEMENT_INTERFACE (my_face1_get_type(), interface_per_class_init))
+static void my_tester2_init (MyTester2*t) {}
+static void my_tester2_class_init (MyTester2Class*c) { call_counter_init (c); }
+
+static gpointer
+tester_init_thread (gpointer data)
+{
+  const GInterfaceInfo face2_interface_info = { (GInterfaceInitFunc) interface_per_class_init, NULL, NULL };
+  gpointer klass;
+  /* first, synchronize with other threads,
+   * then run interface and class initializers,
+   * using unsafe_call_counter concurrently
+   */
+  g_mutex_lock (&sync_mutex);
+  g_mutex_unlock (&sync_mutex);
+  /* test default interface initialization for face0 */
+  g_type_default_interface_unref (g_type_default_interface_ref (my_face0_get_type()));
+  /* test class initialization, face0 per-class initializer, face1 default and per-class initializer */
+  klass = g_type_class_ref ((GType) data);
+  /* test face2 default and per-class initializer, after class_init */
+  g_type_add_interface_static (G_TYPE_FROM_CLASS (klass), my_face2_get_type(), &face2_interface_info);
+  /* cleanups */
+  g_type_class_unref (klass);
+  return NULL;
+}
+
+static void
+test_threaded_class_init (void)
+{
+  GThread *t1, *t2, *t3;
+
+  /* pause newly created threads */
+  g_mutex_lock (&sync_mutex);
+
+  /* create threads */
+  t1 = g_thread_create (tester_init_thread, (gpointer) my_tester0_get_type(), TRUE, NULL);
+  t2 = g_thread_create (tester_init_thread, (gpointer) my_tester1_get_type(), TRUE, NULL);
+  t3 = g_thread_create (tester_init_thread, (gpointer) my_tester2_get_type(), TRUE, NULL);
+
+  /* execute threads */
+  g_mutex_unlock (&sync_mutex);
+  while (g_atomic_int_get (&mtsafe_call_counter) < (3 + 3 + 3 * 3) * NUM_COUNTER_INCREMENTS)
+    {
+      if (g_test_verbose())
+        g_printerr ("Initializers counted: %u\n", g_atomic_int_get (&mtsafe_call_counter));
+      g_usleep (50 * 1000); /* wait for threads to complete */
+    }
+  if (g_test_verbose())
+    g_printerr ("Total initializers: %u\n", g_atomic_int_get (&mtsafe_call_counter));
+  /* ensure non-corrupted counter updates */
+  g_assert_cmpint (g_atomic_int_get (&mtsafe_call_counter), ==, unsafe_call_counter);
+
+  g_thread_join (t1);
+  g_thread_join (t2);
+  g_thread_join (t3);
+}
+#endif
+
+typedef struct {
+  GObject parent;
+  char   *name;
+} PropTester;
+typedef GObjectClass    PropTesterClass;
+static GType prop_tester_get_type (void);
+G_DEFINE_TYPE (PropTester, prop_tester, G_TYPE_OBJECT)
+#define PROP_NAME 1
+static void
+prop_tester_init (PropTester* t)
+{
+  if (t->name == NULL)
+    { } /* needs unit test framework initialization: g_test_bug ("race initializing properties"); */
+}
+static void
+prop_tester_set_property (GObject        *object,
+                          guint           property_id,
+                          const GValue   *value,
+                          GParamSpec     *pspec)
+{}
+static void
+prop_tester_class_init (PropTesterClass *c)
+{
+  int i;
+  GParamSpec *param;
+  GObjectClass *gobject_class = G_OBJECT_CLASS (c);
+
+  gobject_class->set_property = prop_tester_set_property; /* silence GObject checks */
+
+  g_mutex_lock (&sync_mutex);
+  g_cond_signal (&sync_cond);
+  g_mutex_unlock (&sync_mutex);
+
+  for (i = 0; i < 100; i++) /* wait a bit. */
+    g_thread_yield();
+
+  call_counter_init (c);
+  param = g_param_spec_string ("name", "name_i18n",
+			       "yet-more-wasteful-i18n",
+			       NULL,
+			       G_PARAM_CONSTRUCT_ONLY | G_PARAM_WRITABLE |
+			       G_PARAM_STATIC_NAME | G_PARAM_STATIC_BLURB |
+			       G_PARAM_STATIC_NICK);
+  g_object_class_install_property (gobject_class, PROP_NAME, param);
+}
+
+static gpointer
+object_create (gpointer data)
+{
+  GObject *obj = g_object_new (prop_tester_get_type(), "name", "fish", NULL);
+  g_object_unref (obj);
+  return NULL;
+}
+
+static void
+test_threaded_object_init (void)
+{
+  GThread *creator;
+  g_mutex_lock (&sync_mutex);
+
+  creator = g_thread_create (object_create, NULL, TRUE, NULL);
+  /* really provoke the race */
+  g_cond_wait (&sync_cond, &sync_mutex);
+
+  object_create (NULL);
+  g_mutex_unlock (&sync_mutex);
+
+  g_thread_join (creator);
+}
+
+typedef struct {
+    MyTester0 *strong;
+    guint unref_delay;
+} UnrefInThreadData;
+
+static gpointer
+unref_in_thread (gpointer p)
+{
+  UnrefInThreadData *data = p;
+
+  g_usleep (data->unref_delay);
+  g_object_unref (data->strong);
+
+  return NULL;
+}
+
+/* undefine to see this test fail without GWeakRef */
+#define HAVE_G_WEAK_REF
+
+#define SLEEP_MIN_USEC 1
+#define SLEEP_MAX_USEC 10
+
+static void
+test_threaded_weak_ref (void)
+{
+  guint i;
+  guint get_wins = 0, unref_wins = 0;
+  guint n;
+
+  if (g_test_thorough ())
+    n = NUM_COUNTER_INCREMENTS;
+  else
+    n = NUM_COUNTER_INCREMENTS / 20;
+
+#ifdef G_OS_WIN32
+  /* On Windows usleep has millisecond resolution and gets rounded up
+   * leading to the test running for a long time. */
+  n /= 10;
+#endif
+
+  for (i = 0; i < n; i++)
+    {
+      UnrefInThreadData data;
+#ifdef HAVE_G_WEAK_REF
+      /* GWeakRef<MyTester0> in C++ terms */
+      GWeakRef weak;
+#else
+      gpointer weak;
+#endif
+      MyTester0 *strengthened;
+      guint get_delay;
+      GThread *thread;
+      GError *error = NULL;
+
+      if (g_test_verbose () && (i % (n/20)) == 0)
+        g_printerr ("%u%%\n", ((i * 100) / n));
+
+      /* Have an object and a weak ref to it */
+      data.strong = g_object_new (my_tester0_get_type (), NULL);
+
+#ifdef HAVE_G_WEAK_REF
+      g_weak_ref_init (&weak, data.strong);
+#else
+      weak = data.strong;
+      g_object_add_weak_pointer ((GObject *) weak, &weak);
+#endif
+
+      /* Delay for a random time on each side of the race, to perturb the
+       * timing. Ideally, we want each side to win half the races; on
+       * smcv's laptop, these timings are about right.
+       */
+      data.unref_delay = g_random_int_range (SLEEP_MIN_USEC / 2, SLEEP_MAX_USEC / 2);
+      get_delay = g_random_int_range (SLEEP_MIN_USEC, SLEEP_MAX_USEC);
+
+      /* One half of the race is to unref the shared object */
+      thread = g_thread_create (unref_in_thread, &data, TRUE, &error);
+      g_assert_no_error (error);
+
+      /* The other half of the race is to get the object from the "global
+       * singleton"
+       */
+      g_usleep (get_delay);
+
+#ifdef HAVE_G_WEAK_REF
+      strengthened = g_weak_ref_get (&weak);
+#else
+      /* Spot the unsafe pointer access! In GDBusConnection this is rather
+       * better-hidden, but ends up with essentially the same thing, albeit
+       * cleared in dispose() rather than by a traditional weak pointer
+       */
+      strengthened = weak;
+
+      if (strengthened != NULL)
+        g_object_ref (strengthened);
+#endif
+
+      if (strengthened != NULL)
+        g_assert (G_IS_OBJECT (strengthened));
+
+      /* Wait for the thread to run */
+      g_thread_join (thread);
+
+      if (strengthened != NULL)
+        {
+          get_wins++;
+          g_assert (G_IS_OBJECT (strengthened));
+          g_object_unref (strengthened);
+        }
+      else
+        {
+          unref_wins++;
+        }
+
+#ifdef HAVE_G_WEAK_REF
+      g_weak_ref_clear (&weak);
+#else
+      if (weak != NULL)
+        g_object_remove_weak_pointer (weak, &weak);
+#endif
+    }
+
+  if (g_test_verbose ())
+    g_printerr ("Race won by get %u times, unref %u times\n",
+             get_wins, unref_wins);
+}
+
+typedef struct
+{
+  GObject *object;
+  GWeakRef *weak;
+  gint started; /* (atomic) */
+  gint finished; /* (atomic) */
+  gint disposing; /* (atomic) */
+} ThreadedWeakRefData;
+
+static void
+on_weak_ref_disposed (gpointer data,
+                      GObject *gobj)
+{
+  ThreadedWeakRefData *thread_data = data;
+
+  /* Wait until the thread has started */
+  while (!g_atomic_int_get (&thread_data->started))
+    continue;
+
+  g_atomic_int_set (&thread_data->disposing, 1);
+
+  /* Wait for the thread to act, so that the object is still valid */
+  while (!g_atomic_int_get (&thread_data->finished))
+    continue;
+
+  g_atomic_int_set (&thread_data->disposing, 0);
+}
+
+static gpointer
+on_other_thread_weak_ref (gpointer user_data)
+{
+  ThreadedWeakRefData *thread_data = user_data;
+  GObject *object = thread_data->object;
+
+  g_atomic_int_set (&thread_data->started, 1);
+
+  /* Ensure we've started disposal */
+  while (!g_atomic_int_get (&thread_data->disposing))
+    continue;
+
+  g_object_ref (object);
+  g_weak_ref_set (thread_data->weak, object);
+  g_object_unref (object);
+
+  g_assert_cmpint (thread_data->disposing, ==, 1);
+  g_atomic_int_set (&thread_data->finished, 1);
+
+  return NULL;
+}
+
+static void
+test_threaded_weak_ref_finalization (void)
+{
+  GObject *obj = g_object_new (G_TYPE_OBJECT, NULL);
+  GWeakRef weak = { { GUINT_TO_POINTER (0xDEADBEEFU) } };
+  ThreadedWeakRefData thread_data = {
+    .object = obj, .weak = &weak, .started = 0, .finished = 0
+  };
+
+  g_test_bug ("https://gitlab.gnome.org/GNOME/glib/-/issues/2390");
+  g_test_summary ("Test that a weak ref added by another thread during dispose "
+                  "of a GObject is cleared during finalisation. "
+                  "Use on_weak_ref_disposed() to synchronize the other thread "
+                  "with the dispose vfunc.");
+
+  g_weak_ref_init (&weak, NULL);
+  g_object_weak_ref (obj, on_weak_ref_disposed, &thread_data);
+
+  g_assert_cmpint (obj->ref_count, ==, 1);
+  g_thread_unref (g_thread_new ("on_other_thread",
+                                on_other_thread_weak_ref,
+                                &thread_data));
+  g_object_unref (obj);
+
+  /* This is what this test is about: at this point the weak reference
+   * should have been unset (and not point to a dead object either). */
+  g_assert_null (g_weak_ref_get (&weak));
+}
+
+typedef struct
+{
+  GObject *object;
+  int done;    /* (atomic) */
+  int toggles; /* (atomic) */
+} ToggleNotifyThreadData;
+
+static gpointer
+on_reffer_thread (gpointer user_data)
+{
+  ToggleNotifyThreadData *thread_data = user_data;
+
+  while (!g_atomic_int_get (&thread_data->done))
+    {
+      g_object_ref (thread_data->object);
+      g_object_unref (thread_data->object);
+    }
+
+  return NULL;
+}
+
+static void
+on_toggle_notify (gpointer data,
+                  GObject *object,
+                  gboolean is_last_ref)
+{
+  /* Anything could be put here, but we don't care for this test.
+   * Actually having this empty made the bug to happen more frequently (being
+   * timing related).
+   */
+}
+
+static gpointer
+on_toggler_thread (gpointer user_data)
+{
+  ToggleNotifyThreadData *thread_data = user_data;
+
+  while (!g_atomic_int_get (&thread_data->done))
+    {
+      g_object_ref (thread_data->object);
+      g_object_remove_toggle_ref (thread_data->object, on_toggle_notify, thread_data);
+      g_object_add_toggle_ref (thread_data->object, on_toggle_notify, thread_data);
+      g_object_unref (thread_data->object);
+      g_atomic_int_add (&thread_data->toggles, 1);
+    }
+
+  return NULL;
+}
+
+static void
+test_threaded_toggle_notify (void)
+{
+  GObject *object = g_object_new (G_TYPE_OBJECT, NULL);
+  ToggleNotifyThreadData data = { object, FALSE, 0 };
+  GThread *threads[3];
+  gsize i;
+
+  g_test_bug ("https://gitlab.gnome.org/GNOME/glib/issues/2394");
+  g_test_summary ("Test that toggle reference notifications can be changed "
+                  "safely from another (the main) thread without causing the "
+                  "notifying thread to abort");
+
+  g_object_add_toggle_ref (object, on_toggle_notify, &data);
+  g_object_unref (object);
+
+  g_assert_cmpint (object->ref_count, ==, 1);
+  threads[0] = g_thread_new ("on_reffer_thread", on_reffer_thread, &data);
+  threads[1] = g_thread_new ("on_another_reffer_thread", on_reffer_thread, &data);
+  threads[2] = g_thread_new ("on_main_toggler_thread", on_toggler_thread, &data);
+
+  /* We need to wait here for the threads to run for a bit in order to make the
+   * race to happen, so we wait for an high number of toggle changes to be met
+   * so that we can be consistent on each platform.
+   */
+  while (g_atomic_int_get (&data.toggles) < 1000000)
+    ;
+  g_atomic_int_set (&data.done, TRUE);
+
+  for (i = 0; i < G_N_ELEMENTS (threads); i++)
+    g_thread_join (threads[i]);
+
+  g_assert_cmpint (object->ref_count, ==, 1);
+  g_clear_object (&object);
+}
+
+int
+main (int   argc,
+      char *argv[])
+{
+  g_test_init (&argc, &argv, NULL);
+
+  /* g_test_add_func ("/GObject/threaded-class-init", test_threaded_class_init); */
+  g_test_add_func ("/GObject/threaded-object-init", test_threaded_object_init);
+  g_test_add_func ("/GObject/threaded-weak-ref", test_threaded_weak_ref);
+  g_test_add_func ("/GObject/threaded-weak-ref/on-finalization",
+                   test_threaded_weak_ref_finalization);
+  g_test_add_func ("/GObject/threaded-toggle-notify",
+                   test_threaded_toggle_notify);
+
+  return g_test_run();
+}