2005-07-15 Matthias Clasen <mclasen@redhat.com>
+ * tests/Makefile.am (SUBDIRS): Add tests/refcount
+
+ * configure.in: Add tests/refcount
+
+ * tests/refcount/properties.c: Test property changes
+ from multiple threads.
+
+ * tests/refcount/signals.c: Test signal emission from
+ multiple threads.
+
+ * tests/refcount/objects.c: Test refcounting from
+ multiple threads.
+
+ * tests/refcount/objects2.c:
+ * tests/refcount/properties2.c: Tests to measure the
+ overhead of threadsafe refcounting.
+
+ * glib/giochannel.c (g_io_channel_ref, g_io_channel_unref):
+ Use atomic operations to make refcounting
+ threadsafe. (#166020, Wim Taymans)
+
* NEWS: Updates
2005-07-14 Matthias Clasen <mclasen@redhat.com>
2005-07-15 Matthias Clasen <mclasen@redhat.com>
+ * tests/Makefile.am (SUBDIRS): Add tests/refcount
+
+ * configure.in: Add tests/refcount
+
+ * tests/refcount/properties.c: Test property changes
+ from multiple threads.
+
+ * tests/refcount/signals.c: Test signal emission from
+ multiple threads.
+
+ * tests/refcount/objects.c: Test refcounting from
+ multiple threads.
+
+ * tests/refcount/objects2.c:
+ * tests/refcount/properties2.c: Tests to measure the
+ overhead of threadsafe refcounting.
+
+ * glib/giochannel.c (g_io_channel_ref, g_io_channel_unref):
+ Use atomic operations to make refcounting
+ threadsafe. (#166020, Wim Taymans)
+
* NEWS: Updates
2005-07-14 Matthias Clasen <mclasen@redhat.com>
2005-07-15 Matthias Clasen <mclasen@redhat.com>
+ * tests/Makefile.am (SUBDIRS): Add tests/refcount
+
+ * configure.in: Add tests/refcount
+
+ * tests/refcount/properties.c: Test property changes
+ from multiple threads.
+
+ * tests/refcount/signals.c: Test signal emission from
+ multiple threads.
+
+ * tests/refcount/objects.c: Test refcounting from
+ multiple threads.
+
+ * tests/refcount/objects2.c:
+ * tests/refcount/properties2.c: Tests to measure the
+ overhead of threadsafe refcounting.
+
+ * glib/giochannel.c (g_io_channel_ref, g_io_channel_unref):
+ Use atomic operations to make refcounting
+ threadsafe. (#166020, Wim Taymans)
+
* NEWS: Updates
2005-07-14 Matthias Clasen <mclasen@redhat.com>
2005-07-15 Matthias Clasen <mclasen@redhat.com>
+ * tests/Makefile.am (SUBDIRS): Add tests/refcount
+
+ * configure.in: Add tests/refcount
+
+ * tests/refcount/properties.c: Test property changes
+ from multiple threads.
+
+ * tests/refcount/signals.c: Test signal emission from
+ multiple threads.
+
+ * tests/refcount/objects.c: Test refcounting from
+ multiple threads.
+
+ * tests/refcount/objects2.c:
+ * tests/refcount/properties2.c: Tests to measure the
+ overhead of threadsafe refcounting.
+
+ * glib/giochannel.c (g_io_channel_ref, g_io_channel_unref):
+ Use atomic operations to make refcounting
+ threadsafe. (#166020, Wim Taymans)
+
* NEWS: Updates
2005-07-14 Matthias Clasen <mclasen@redhat.com>
docs/reference/gobject/version.xml
tests/Makefile
tests/gobject/Makefile
+tests/refcount/Makefile
m4macros/Makefile
])
{
g_return_val_if_fail (channel != NULL, NULL);
- channel->ref_count++;
+ g_atomic_int_inc (&channel->ref_count);
return channel;
}
void
g_io_channel_unref (GIOChannel *channel)
{
+ gboolean is_zero;
+
g_return_if_fail (channel != NULL);
- channel->ref_count--;
- if (channel->ref_count == 0)
+ is_zero = g_atomic_int_dec_and_test (&channel->ref_count);
+
+ if (G_UNLIKELY (is_zero))
{
if (channel->close_on_unref)
g_io_channel_shutdown (channel, TRUE, NULL);
+2005-07-15 Matthias Clasen <mclasen@redhat.com>
+
+ Make refcounting threadsafe by using atomic
+ operations. (#166020, Wim Taymans)
+
+ * gobject.c: Use a recursive lock to protect the
+ notify queue.
+ (g_object_unref): Get rid of g_object_last_unref and
+ do the last unref handling in g_object_unref.
+ (g_object_ref, g_object_unref): Use atomic operations.
+
+ * gsignal.c (struct _HandlerMatch): Use a full integer
+ for the ref_count field.
+ (handler_ref, handler_unref_R): Use atomic operations.
+
+ * gparam.c (g_param_spec_ref, g_param_spec_unref):
+ Use atomic operations instead of a lock to make the
+ refcounting threadsafe.
+
+ * gclosure.c (g_closure_ref, g_closure_unref): Use atomic
+ operations. This is more complicated here, since the
+ refcount is stored in a bitfield, so we also have
+ to access all other bitfield members atomically.
+
+ * gsignal.c (handlers_find): Read the meta_marshal flag
+ of the closure atomically.
+
2005-07-11 Matthias Clasen <mclasen@redhat.com>
* gobject.h:
#define CLOSURE_N_NOTIFIERS(cl) (CLOSURE_N_MFUNCS (cl) + \
(cl)->n_fnotifiers + \
(cl)->n_inotifiers)
+
+/* union of first int we need to make atomic */
+typedef union {
+ GClosure bits;
+ gint atomic;
+} GAtomicClosureBits;
+
+#define BITS_AS_INT(b) (((GAtomicClosureBits*)(b))->atomic)
+
+#define CLOSURE_READ_BITS(cl,bits) (BITS_AS_INT(bits) = g_atomic_int_get ((gint*)(cl)))
+#define CLOSURE_READ_BITS2(cl,old,new) (BITS_AS_INT(old) = CLOSURE_READ_BITS (cl, new))
+#define CLOSURE_SWAP_BITS(cl,old,new) (g_atomic_int_compare_and_exchange ((gint*)(cl), \
+ BITS_AS_INT(old),BITS_AS_INT(new)))
+
+#define CLOSURE_REF(closure) \
+G_STMT_START { \
+ GClosure old, new; \
+ do { \
+ CLOSURE_READ_BITS2 (closure, &old, &new); \
+ new.ref_count++; \
+ } \
+ while (!CLOSURE_SWAP_BITS (closure, &old, &new)); \
+} G_STMT_END
+
+
+#define CLOSURE_UNREF(closure, is_zero) \
+G_STMT_START { \
+ GClosure old, new; \
+ do { \
+ CLOSURE_READ_BITS2 (closure, &old, &new); \
+ if (old.ref_count == 1) /* last unref, invalidate first */ \
+ g_closure_invalidate ((closure)); \
+ new.ref_count--; \
+ is_zero = (new.ref_count == 0); \
+ } \
+ while (!CLOSURE_SWAP_BITS (closure, &old, &new)); \
+} G_STMT_END
+
enum {
FNOTIFY,
INOTIFY,
closure_invoke_notifiers (GClosure *closure,
guint notify_type)
{
+ GClosure bits, new;
+
/* notifier layout:
* meta_marshal n_guards n_guards n_fnotif. n_inotifiers
* ->[[meta_marshal][pre_guards][post_guards][fnotifiers][inotifiers]]
GClosureNotifyData *ndata;
guint i, offs;
case FNOTIFY:
- while (closure->n_fnotifiers)
+ CLOSURE_READ_BITS (closure, &bits);
+ while (bits.n_fnotifiers)
{
- register guint n = --closure->n_fnotifiers;
+ register guint n = --bits.n_fnotifiers;
- ndata = closure->notifiers + CLOSURE_N_MFUNCS (closure) + n;
+ ndata = closure->notifiers + CLOSURE_N_MFUNCS (&bits) + n;
closure->marshal = (GClosureMarshal) ndata->notify;
closure->data = ndata->data;
ndata->notify (ndata->data, closure);
closure->data = NULL;
break;
case INOTIFY:
- closure->in_inotify = TRUE;
- while (closure->n_inotifiers)
+ do {
+ CLOSURE_READ_BITS2 (closure, &bits, &new);
+ new.in_inotify = TRUE;
+ }
+ while (!CLOSURE_SWAP_BITS (closure, &bits, &new));
+
+ while (bits.n_inotifiers)
{
- register guint n = --closure->n_inotifiers;
+ register guint n = --bits.n_inotifiers;
- ndata = closure->notifiers + CLOSURE_N_MFUNCS (closure) + closure->n_fnotifiers + n;
+ ndata = closure->notifiers + CLOSURE_N_MFUNCS (&bits) + bits.n_fnotifiers + n;
closure->marshal = (GClosureMarshal) ndata->notify;
closure->data = ndata->data;
ndata->notify (ndata->data, closure);
}
closure->marshal = NULL;
closure->data = NULL;
- closure->in_inotify = FALSE;
+ do {
+ CLOSURE_READ_BITS2 (closure, &bits, &new);
+ new.n_inotifiers = 0;
+ new.in_inotify = FALSE;
+ }
+ while (!CLOSURE_SWAP_BITS (closure, &bits, &new));
break;
case PRE_NOTIFY:
- i = closure->n_guards;
- offs = closure->meta_marshal;
+ CLOSURE_READ_BITS (closure, &bits);
+ i = bits.n_guards;
+ offs = bits.meta_marshal;
while (i--)
{
ndata = closure->notifiers + offs + i;
}
break;
case POST_NOTIFY:
- i = closure->n_guards;
- offs = closure->meta_marshal + i;
+ CLOSURE_READ_BITS (closure, &bits);
+ i = bits.n_guards;
+ offs = bits.meta_marshal + i;
while (i--)
{
ndata = closure->notifiers + offs + i;
gpointer marshal_data,
GClosureMarshal meta_marshal)
{
- GClosureNotifyData *notifiers;
+ GClosureNotifyData *old_notifiers, *new_notifiers;
guint n;
+ GClosure old, new;
g_return_if_fail (closure != NULL);
g_return_if_fail (meta_marshal != NULL);
- g_return_if_fail (closure->is_invalid == FALSE);
- g_return_if_fail (closure->in_marshal == FALSE);
- g_return_if_fail (closure->meta_marshal == 0);
-
- n = CLOSURE_N_NOTIFIERS (closure);
- notifiers = closure->notifiers;
- closure->notifiers = g_renew (GClosureNotifyData, NULL, CLOSURE_N_NOTIFIERS (closure) + 1);
- if (notifiers)
+
+retry:
+ CLOSURE_READ_BITS2 (closure, &old, &new);
+
+ g_return_if_fail (old.is_invalid == FALSE);
+ g_return_if_fail (old.in_marshal == FALSE);
+ g_return_if_fail (old.meta_marshal == 0);
+
+ n = CLOSURE_N_NOTIFIERS (&old);
+
+ old_notifiers = closure->notifiers;
+ new_notifiers = g_renew (GClosureNotifyData, NULL, n + 1);
+ if (old_notifiers)
{
/* usually the meta marshal will be setup right after creation, so the
* g_memmove() should be rare-case scenario
*/
- g_memmove (closure->notifiers + 1, notifiers, CLOSURE_N_NOTIFIERS (closure) * sizeof (notifiers[0]));
- g_free (notifiers);
+ g_memmove (new_notifiers + 1, old_notifiers, n * sizeof (old_notifiers[0]));
}
- closure->notifiers[0].data = marshal_data;
- closure->notifiers[0].notify = (GClosureNotify) meta_marshal;
- closure->meta_marshal = 1;
+ new_notifiers[0].data = marshal_data;
+ new_notifiers[0].notify = (GClosureNotify) meta_marshal;
+
+ new.meta_marshal = 1;
+
+ /* this cannot be made atomic, as soon as we switch on the meta_marshal
+ * bit, another thread could use the notifier while we have not yet
+ * copied it. the safest is to install the new_notifiers first and then
+ * switch on the meta_marshal flag. */
+ closure->notifiers = new_notifiers;
+
+ if (!CLOSURE_SWAP_BITS (closure, &old, &new)) {
+ g_free (new_notifiers);
+ goto retry;
+ }
+
+ g_free (old_notifiers);
}
void
GClosureNotify post_marshal_notify)
{
guint i;
+ GClosure old, new;
+ GClosureNotifyData *old_notifiers, *new_notifiers;
g_return_if_fail (closure != NULL);
g_return_if_fail (pre_marshal_notify != NULL);
g_return_if_fail (post_marshal_notify != NULL);
- g_return_if_fail (closure->is_invalid == FALSE);
- g_return_if_fail (closure->in_marshal == FALSE);
- g_return_if_fail (closure->n_guards < CLOSURE_MAX_N_GUARDS);
-
- closure->notifiers = g_renew (GClosureNotifyData, closure->notifiers, CLOSURE_N_NOTIFIERS (closure) + 2);
- if (closure->n_inotifiers)
- closure->notifiers[(CLOSURE_N_MFUNCS (closure) +
- closure->n_fnotifiers +
- closure->n_inotifiers + 1)] = closure->notifiers[(CLOSURE_N_MFUNCS (closure) +
- closure->n_fnotifiers + 0)];
- if (closure->n_inotifiers > 1)
- closure->notifiers[(CLOSURE_N_MFUNCS (closure) +
- closure->n_fnotifiers +
- closure->n_inotifiers)] = closure->notifiers[(CLOSURE_N_MFUNCS (closure) +
- closure->n_fnotifiers + 1)];
- if (closure->n_fnotifiers)
- closure->notifiers[(CLOSURE_N_MFUNCS (closure) +
- closure->n_fnotifiers + 1)] = closure->notifiers[CLOSURE_N_MFUNCS (closure) + 0];
- if (closure->n_fnotifiers > 1)
- closure->notifiers[(CLOSURE_N_MFUNCS (closure) +
- closure->n_fnotifiers)] = closure->notifiers[CLOSURE_N_MFUNCS (closure) + 1];
- if (closure->n_guards)
- closure->notifiers[(closure->meta_marshal +
- closure->n_guards +
- closure->n_guards + 1)] = closure->notifiers[closure->meta_marshal + closure->n_guards];
- i = closure->n_guards++;
- closure->notifiers[closure->meta_marshal + i].data = pre_marshal_data;
- closure->notifiers[closure->meta_marshal + i].notify = pre_marshal_notify;
- closure->notifiers[closure->meta_marshal + i + 1].data = post_marshal_data;
- closure->notifiers[closure->meta_marshal + i + 1].notify = post_marshal_notify;
+
+retry:
+ CLOSURE_READ_BITS2 (closure, &old, &new);
+
+ g_return_if_fail (old.is_invalid == FALSE);
+ g_return_if_fail (old.in_marshal == FALSE);
+ g_return_if_fail (old.n_guards < CLOSURE_MAX_N_GUARDS);
+
+ old_notifiers = closure->notifiers;
+ new_notifiers = g_renew (GClosureNotifyData, old_notifiers, CLOSURE_N_NOTIFIERS (&old) + 2);
+ if (old.n_inotifiers)
+ new_notifiers[(CLOSURE_N_MFUNCS (&old) +
+ old.n_fnotifiers +
+ old.n_inotifiers + 1)] = new_notifiers[(CLOSURE_N_MFUNCS (&old) +
+ old.n_fnotifiers + 0)];
+ if (old.n_inotifiers > 1)
+ new_notifiers[(CLOSURE_N_MFUNCS (&old) +
+ old.n_fnotifiers +
+ old.n_inotifiers)] = new_notifiers[(CLOSURE_N_MFUNCS (&old) +
+ old.n_fnotifiers + 1)];
+ if (old.n_fnotifiers)
+ new_notifiers[(CLOSURE_N_MFUNCS (&old) +
+ old.n_fnotifiers + 1)] = new_notifiers[CLOSURE_N_MFUNCS (&old) + 0];
+ if (old.n_fnotifiers > 1)
+ new_notifiers[(CLOSURE_N_MFUNCS (&old) +
+ old.n_fnotifiers)] = new_notifiers[CLOSURE_N_MFUNCS (&old) + 1];
+ if (old.n_guards)
+ new_notifiers[(old.meta_marshal +
+ old.n_guards +
+ old.n_guards + 1)] = new_notifiers[old.meta_marshal + old.n_guards];
+ i = old.n_guards;
+
+ new.n_guards = i+1;
+
+ new_notifiers[old.meta_marshal + i].data = pre_marshal_data;
+ new_notifiers[old.meta_marshal + i].notify = pre_marshal_notify;
+ new_notifiers[old.meta_marshal + i + 1].data = post_marshal_data;
+ new_notifiers[old.meta_marshal + i + 1].notify = post_marshal_notify;
+
+ /* not really atomic */
+ closure->notifiers = new_notifiers;
+
+ if (!CLOSURE_SWAP_BITS (closure, &old, &new))
+ goto retry;
}
void
GClosureNotify notify_func)
{
guint i;
+ GClosure old, new;
+ GClosureNotifyData *old_notifiers, *new_notifiers;
g_return_if_fail (closure != NULL);
g_return_if_fail (notify_func != NULL);
- g_return_if_fail (closure->n_fnotifiers < CLOSURE_MAX_N_FNOTIFIERS);
-
- closure->notifiers = g_renew (GClosureNotifyData, closure->notifiers, CLOSURE_N_NOTIFIERS (closure) + 1);
- if (closure->n_inotifiers)
- closure->notifiers[(CLOSURE_N_MFUNCS (closure) +
- closure->n_fnotifiers +
- closure->n_inotifiers)] = closure->notifiers[(CLOSURE_N_MFUNCS (closure) +
- closure->n_fnotifiers + 0)];
- i = CLOSURE_N_MFUNCS (closure) + closure->n_fnotifiers++;
- closure->notifiers[i].data = notify_data;
- closure->notifiers[i].notify = notify_func;
+
+retry:
+ CLOSURE_READ_BITS2 (closure, &old, &new);
+
+ g_return_if_fail (old.n_fnotifiers < CLOSURE_MAX_N_FNOTIFIERS);
+
+ old_notifiers = closure->notifiers;
+ new_notifiers = g_renew (GClosureNotifyData, old_notifiers, CLOSURE_N_NOTIFIERS (&old) + 1);
+ if (old.n_inotifiers)
+ new_notifiers[(CLOSURE_N_MFUNCS (&old) +
+ old.n_fnotifiers +
+ old.n_inotifiers)] = new_notifiers[(CLOSURE_N_MFUNCS (&old) +
+ old.n_fnotifiers + 0)];
+ i = CLOSURE_N_MFUNCS (&old) + old.n_fnotifiers;
+ new.n_fnotifiers++;
+
+ new_notifiers[i].data = notify_data;
+ new_notifiers[i].notify = notify_func;
+
+ /* not really atomic */
+ closure->notifiers = new_notifiers;
+
+ while (!CLOSURE_SWAP_BITS (closure, &old, &new))
+ goto retry;
}
void
GClosureNotify notify_func)
{
guint i;
+ GClosure old, new;
+ GClosureNotifyData *old_notifiers, *new_notifiers;
g_return_if_fail (closure != NULL);
g_return_if_fail (notify_func != NULL);
- g_return_if_fail (closure->is_invalid == FALSE);
- g_return_if_fail (closure->n_inotifiers < CLOSURE_MAX_N_INOTIFIERS);
- closure->notifiers = g_renew (GClosureNotifyData, closure->notifiers, CLOSURE_N_NOTIFIERS (closure) + 1);
- i = CLOSURE_N_MFUNCS (closure) + closure->n_fnotifiers + closure->n_inotifiers++;
- closure->notifiers[i].data = notify_data;
- closure->notifiers[i].notify = notify_func;
+retry:
+ CLOSURE_READ_BITS2 (closure, &old, &new);
+
+ g_return_if_fail (old.is_invalid == FALSE);
+ g_return_if_fail (old.n_inotifiers < CLOSURE_MAX_N_INOTIFIERS);
+
+ old_notifiers = closure->notifiers;
+ new_notifiers = g_renew (GClosureNotifyData, old_notifiers, CLOSURE_N_NOTIFIERS (&old) + 1);
+ i = CLOSURE_N_MFUNCS (&old) + old.n_fnotifiers + old.n_inotifiers;
+ new.n_inotifiers++;
+
+ new_notifiers[i].data = notify_data;
+ new_notifiers[i].notify = notify_func;
+
+ /* not really atomic */
+ closure->notifiers = new_notifiers;
+
+ while (!CLOSURE_SWAP_BITS (closure, &old, &new))
+ goto retry;
}
static inline gboolean
GClosureNotify notify_func)
{
GClosureNotifyData *ndata, *nlast;
+ GClosure old, new;
+
+retry:
+ CLOSURE_READ_BITS2 (closure, &old, &new);
- nlast = closure->notifiers + CLOSURE_N_NOTIFIERS (closure) - 1;
- for (ndata = nlast + 1 - closure->n_inotifiers; ndata <= nlast; ndata++)
+ nlast = closure->notifiers + CLOSURE_N_NOTIFIERS (&old) - 1;
+ for (ndata = nlast + 1 - old.n_inotifiers; ndata <= nlast; ndata++)
if (ndata->notify == notify_func && ndata->data == notify_data)
{
- closure->n_inotifiers -= 1;
+ new.n_inotifiers -= 1;
+ if (!CLOSURE_SWAP_BITS (closure, &old, &new))
+ goto retry;
+
if (ndata < nlast)
*ndata = *nlast;
GClosureNotify notify_func)
{
GClosureNotifyData *ndata, *nlast;
+ GClosure old, new;
- nlast = closure->notifiers + CLOSURE_N_NOTIFIERS (closure) - closure->n_inotifiers - 1;
- for (ndata = nlast + 1 - closure->n_fnotifiers; ndata <= nlast; ndata++)
+retry:
+ CLOSURE_READ_BITS2 (closure, &old, &new);
+
+ nlast = closure->notifiers + CLOSURE_N_NOTIFIERS (&old) - old.n_inotifiers - 1;
+ for (ndata = nlast + 1 - old.n_fnotifiers; ndata <= nlast; ndata++)
if (ndata->notify == notify_func && ndata->data == notify_data)
{
- closure->n_fnotifiers -= 1;
+ new.n_fnotifiers -= 1;
+ if (!CLOSURE_SWAP_BITS (closure, &old, &new))
+ goto retry;
+
if (ndata < nlast)
*ndata = *nlast;
- if (closure->n_inotifiers)
- closure->notifiers[(CLOSURE_N_MFUNCS (closure) +
- closure->n_fnotifiers)] = closure->notifiers[(CLOSURE_N_MFUNCS (closure) +
- closure->n_fnotifiers +
- closure->n_inotifiers)];
+
+ if (new.n_inotifiers)
+ closure->notifiers[(CLOSURE_N_MFUNCS (&new) +
+ new.n_fnotifiers)] = closure->notifiers[(CLOSURE_N_MFUNCS (&new) +
+ new.n_fnotifiers +
+ new.n_inotifiers)];
return TRUE;
}
return FALSE;
g_return_val_if_fail (closure->ref_count > 0, NULL);
g_return_val_if_fail (closure->ref_count < CLOSURE_MAX_REF_COUNT, NULL);
- closure->ref_count += 1;
+ CLOSURE_REF (closure);
return closure;
}
void
g_closure_invalidate (GClosure *closure)
{
+ GClosure old, new;
+
g_return_if_fail (closure != NULL);
- if (!closure->is_invalid)
+retry:
+ CLOSURE_READ_BITS2 (closure, &old, &new);
+
+ if (!old.is_invalid)
{
- closure->ref_count += 1; /* preserve floating flag */
- closure->is_invalid = TRUE;
+ new.ref_count++;
+ new.is_invalid = TRUE;
+
+ if (!CLOSURE_SWAP_BITS (closure, &old, &new))
+ goto retry;
+
closure_invoke_notifiers (closure, INOTIFY);
g_closure_unref (closure);
}
void
g_closure_unref (GClosure *closure)
{
+ gboolean is_zero;
+
g_return_if_fail (closure != NULL);
g_return_if_fail (closure->ref_count > 0);
- if (closure->ref_count == 1) /* last unref, invalidate first */
- g_closure_invalidate (closure);
+ CLOSURE_UNREF (closure, is_zero);
- closure->ref_count -= 1;
-
- if (closure->ref_count == 0)
+ if (G_UNLIKELY (is_zero))
{
closure_invoke_notifiers (closure, FNOTIFY);
g_free (closure->notifiers);
void
g_closure_sink (GClosure *closure)
{
+ GClosure old, new;
+
g_return_if_fail (closure != NULL);
g_return_if_fail (closure->ref_count > 0);
* is unowned. with invoking g_closure_sink() code may
* indicate that it takes over that intiial ref_count.
*/
- if (closure->floating)
+retry:
+ CLOSURE_READ_BITS2 (closure, &old, &new);
+
+ if (old.floating)
{
- closure->floating = FALSE;
- if (closure->ref_count > 1)
- closure->ref_count -= 1;
- else
- g_closure_unref (closure);
+ new.floating = FALSE;
+
+ if (!CLOSURE_SWAP_BITS (closure, &old, &new))
+ goto retry;
+
+ g_closure_unref (closure);
}
}
gpointer notify_data,
GClosureNotify notify_func)
{
+ GClosure bits;
+
g_return_if_fail (closure != NULL);
g_return_if_fail (notify_func != NULL);
- if (closure->is_invalid && closure->in_inotify && /* account removal of notify_func() while its called */
+ CLOSURE_READ_BITS (closure, &bits);
+
+ if (bits.is_invalid && bits.in_inotify && /* account removal of notify_func() while its called */
((gpointer) closure->marshal) == ((gpointer) notify_func) && closure->data == notify_data)
closure->marshal = NULL;
else if (!closure_try_remove_inotify (closure, notify_data, notify_func))
gpointer notify_data,
GClosureNotify notify_func)
{
+ GClosure bits;
+
g_return_if_fail (closure != NULL);
g_return_if_fail (notify_func != NULL);
- if (closure->is_invalid && !closure->in_inotify && /* account removal of notify_func() while its called */
+ CLOSURE_READ_BITS (closure, &bits);
+
+ if (bits.is_invalid && !bits.in_inotify && /* account removal of notify_func() while its called */
((gpointer) closure->marshal) == ((gpointer) notify_func) && closure->data == notify_data)
closure->marshal = NULL;
else if (!closure_try_remove_fnotify (closure, notify_data, notify_func))
const GValue *param_values,
gpointer invocation_hint)
{
+ GClosure old, new;
+
g_return_if_fail (closure != NULL);
- if (!closure->is_invalid)
- {
+retry:
+ CLOSURE_READ_BITS2 (closure, &old, &new);
+
+ if (!old.is_invalid)
+ {
GClosureMarshal marshal;
gpointer marshal_data;
- gboolean in_marshal = closure->in_marshal;
+ gboolean in_marshal = old.in_marshal;
+ gboolean meta_marshal = old.meta_marshal;
+
+ g_return_if_fail (closure->marshal || meta_marshal);
- g_return_if_fail (closure->marshal || closure->meta_marshal);
+ new.ref_count++;
+ new.in_marshal = TRUE;
- closure->ref_count += 1; /* preserve floating flag */
- closure->in_marshal = TRUE;
- if (closure->meta_marshal)
+ if (!CLOSURE_SWAP_BITS (closure, &old, &new))
+ goto retry;
+
+ if (meta_marshal)
{
marshal_data = closure->notifiers[0].data;
marshal = (GClosureMarshal) closure->notifiers[0].notify;
}
if (!in_marshal)
closure_invoke_notifiers (closure, PRE_NOTIFY);
+
marshal (closure,
return_value,
n_param_values, param_values,
invocation_hint,
marshal_data);
+
if (!in_marshal)
closure_invoke_notifiers (closure, POST_NOTIFY);
- closure->in_marshal = in_marshal;
- g_closure_unref (closure);
+
+ do {
+ CLOSURE_READ_BITS2 (closure, &old, &new);
+ new.in_marshal = in_marshal;
+ new.ref_count--;
+ }
+ while (!CLOSURE_SWAP_BITS (closure, &old, &new));
}
}
static GObject* g_object_constructor (GType type,
guint n_construct_properties,
GObjectConstructParam *construct_params);
-static void g_object_last_unref (GObject *object);
static void g_object_real_dispose (GObject *object);
static void g_object_finalize (GObject *object);
static void g_object_do_set_property (GObject *object,
G_LOCK_DEFINE_STATIC (construct_objects_lock);
static GSList *construct_objects = NULL;
+static GStaticRecMutex notify_mutex = G_STATIC_REC_MUTEX_INIT;
/* --- functions --- */
#ifdef G_ENABLE_DEBUG
/* yes, temporarily altering the ref_count is hackish, but that
* enforces people not jerking around with weak_ref notifiers
*/
- ref_count = object->ref_count;
+ ref_count = g_atomic_int_get (&object->ref_count);
object->ref_count = 0;
g_datalist_id_set_data (&object->qdata, quark_weak_refs, NULL);
object->ref_count = ref_count;
#endif /* G_ENABLE_DEBUG */
}
-static void
-g_object_last_unref (GObject *object)
-{
- g_return_if_fail (object->ref_count > 0);
-
- if (object->ref_count == 1) /* may have been re-referenced meanwhile */
- G_OBJECT_GET_CLASS (object)->dispose (object);
-
-#ifdef G_ENABLE_DEBUG
- if (g_trap_object_ref == object)
- G_BREAKPOINT ();
-#endif /* G_ENABLE_DEBUG */
-
- object->ref_count -= 1;
-
- if (object->ref_count == 0) /* may have been re-referenced meanwhile */
- {
- g_signal_handlers_destroy (object);
- g_datalist_id_set_data (&object->qdata, quark_weak_refs, NULL);
- G_OBJECT_GET_CLASS (object)->finalize (object);
-#ifdef G_ENABLE_DEBUG
- IF_DEBUG (OBJECTS)
- {
- /* catch objects not chaining finalize handlers */
- G_LOCK (debug_objects);
- g_assert (g_hash_table_lookup (debug_objects_ht, object) == NULL);
- G_UNLOCK (debug_objects);
- }
-#endif /* G_ENABLE_DEBUG */
- g_type_free_instance ((GTypeInstance*) object);
- }
-}
static void
g_object_dispatch_properties_changed (GObject *object,
g_object_freeze_notify (GObject *object)
{
g_return_if_fail (G_IS_OBJECT (object));
- if (!object->ref_count)
+
+ if (g_atomic_int_get (&object->ref_count) == 0)
return;
+ g_static_rec_mutex_lock (¬ify_mutex);
g_object_ref (object);
g_object_notify_queue_freeze (object, &property_notify_context);
g_object_unref (object);
+ g_static_rec_mutex_unlock (¬ify_mutex);
}
void
g_return_if_fail (G_IS_OBJECT (object));
g_return_if_fail (property_name != NULL);
- if (!object->ref_count)
+ if (g_atomic_int_get (&object->ref_count) == 0)
return;
g_object_ref (object);
property_name);
else
{
- GObjectNotifyQueue *nqueue = g_object_notify_queue_freeze (object, &property_notify_context);
-
+ GObjectNotifyQueue *nqueue;
+
+ g_static_rec_mutex_lock (¬ify_mutex);
+ nqueue = g_object_notify_queue_freeze (object, &property_notify_context);
g_object_notify_queue_add (object, nqueue, pspec);
g_object_notify_queue_thaw (object, nqueue);
+ g_static_rec_mutex_unlock (¬ify_mutex);
}
g_object_unref (object);
}
GObjectNotifyQueue *nqueue;
g_return_if_fail (G_IS_OBJECT (object));
- if (!object->ref_count)
+ if (g_atomic_int_get (&object->ref_count) == 0)
return;
g_object_ref (object);
+ g_static_rec_mutex_lock (¬ify_mutex);
nqueue = g_object_notify_queue_from_object (object, &property_notify_context);
if (!nqueue || !nqueue->freeze_count)
g_warning ("%s: property-changed notification for %s(%p) is not frozen",
G_STRFUNC, G_OBJECT_TYPE_NAME (object), object);
else
g_object_notify_queue_thaw (object, nqueue);
+ g_static_rec_mutex_unlock (¬ify_mutex);
g_object_unref (object);
}
else
{
class->set_property (object, param_id, &tmp_value, pspec);
+ g_static_rec_mutex_lock (¬ify_mutex);
g_object_notify_queue_add (object, nqueue, pspec);
+ g_static_rec_mutex_unlock (¬ify_mutex);
}
g_value_unset (&tmp_value);
}
g_return_if_fail (G_IS_OBJECT (object));
+ g_static_rec_mutex_lock (¬ify_mutex);
g_object_ref (object);
nqueue = g_object_notify_queue_freeze (object, &property_notify_context);
g_object_notify_queue_thaw (object, nqueue);
g_object_unref (object);
+ g_static_rec_mutex_unlock (¬ify_mutex);
}
void
g_return_if_fail (property_name != NULL);
g_return_if_fail (G_IS_VALUE (value));
+ g_static_rec_mutex_lock (¬ify_mutex);
g_object_ref (object);
nqueue = g_object_notify_queue_freeze (object, &property_notify_context);
g_object_notify_queue_thaw (object, nqueue);
g_object_unref (object);
+ g_static_rec_mutex_unlock (¬ify_mutex);
}
void
g_object_ref (gpointer _object)
{
GObject *object = _object;
+ gint old_val;
g_return_val_if_fail (G_IS_OBJECT (object), NULL);
g_return_val_if_fail (object->ref_count > 0, NULL);
G_BREAKPOINT ();
#endif /* G_ENABLE_DEBUG */
- object->ref_count += 1;
- if (object->ref_count == 2 && OBJECT_HAS_TOGGLE_REF (object))
+
+ old_val = g_atomic_int_exchange_and_add (&object->ref_count, 1);
+
+ if (old_val == 1 && OBJECT_HAS_TOGGLE_REF (object))
toggle_refs_notify (object, FALSE);
return object;
g_object_unref (gpointer _object)
{
GObject *object = _object;
+ gint old_val;
+ gboolean is_zero;
g_return_if_fail (G_IS_OBJECT (object));
g_return_if_fail (object->ref_count > 0);
G_BREAKPOINT ();
#endif /* G_ENABLE_DEBUG */
- if (object->ref_count > 1)
+retry1:
+ old_val = g_atomic_int_get (&object->ref_count);
+ if (old_val > 1)
{
- object->ref_count -= 1;
- if (object->ref_count == 1 && OBJECT_HAS_TOGGLE_REF (object))
+ if (!g_atomic_int_compare_and_exchange (&object->ref_count, old_val, old_val-1))
+ goto retry1;
+
+ /* if we went from 2->1 we need to notify toggle refs if any */
+ if (old_val == 2 && OBJECT_HAS_TOGGLE_REF (object))
toggle_refs_notify (object, TRUE);
}
else
- g_object_last_unref (object);
+ {
+ /* removing the last ref */
+ G_OBJECT_GET_CLASS (object)->dispose (object);
+
+ /* dispose could have resurected the object */
+retry2:
+ old_val = g_atomic_int_get (&object->ref_count);
+ if (old_val > 1)
+ {
+ if (!g_atomic_int_compare_and_exchange (&object->ref_count, old_val, old_val-1))
+ goto retry2;
+
+ /* if we went from 2->1 we need to notify toggle refs if any */
+ if (old_val == 2 && OBJECT_HAS_TOGGLE_REF (object))
+ toggle_refs_notify (object, TRUE);
+
+ return;
+ }
+
+ /* we are still taking away the last ref */
+ g_signal_handlers_destroy (object);
+ g_datalist_id_set_data (&object->qdata, quark_weak_refs, NULL);
+
+ /* now we really take away the last ref */
+ is_zero = g_atomic_int_dec_and_test (&object->ref_count);
+
+ /* may have been re-referenced meanwhile */
+ if (G_LIKELY (is_zero))
+ {
+ G_OBJECT_GET_CLASS (object)->finalize (object);
+#ifdef G_ENABLE_DEBUG
+ IF_DEBUG (OBJECTS)
+ {
+ /* catch objects not chaining finalize handlers */
+ G_LOCK (debug_objects);
+ g_assert (g_hash_table_lookup (debug_objects_ht, object) == NULL);
+ G_UNLOCK (debug_objects);
+ }
+#endif /* G_ENABLE_DEBUG */
+ g_type_free_instance ((GTypeInstance*) object);
+ }
+ }
}
gpointer
/* --- variables --- */
static GQuark quark_floating = 0;
-G_LOCK_DEFINE_STATIC (pspec_ref_count);
/* --- functions --- */
g_param_spec_ref (GParamSpec *pspec)
{
g_return_val_if_fail (G_IS_PARAM_SPEC (pspec), NULL);
+ g_return_val_if_fail (pspec->ref_count > 0, NULL);
+
+ g_atomic_int_inc (&pspec->ref_count);
- G_LOCK (pspec_ref_count);
- if (pspec->ref_count > 0)
- {
- pspec->ref_count += 1;
- G_UNLOCK (pspec_ref_count);
- }
- else
- {
- G_UNLOCK (pspec_ref_count);
- g_return_val_if_fail (pspec->ref_count > 0, NULL);
- }
-
return pspec;
}
void
g_param_spec_unref (GParamSpec *pspec)
{
+ gboolean is_zero;
+
g_return_if_fail (G_IS_PARAM_SPEC (pspec));
+ g_return_if_fail (pspec->ref_count > 0);
- G_LOCK (pspec_ref_count);
- if (pspec->ref_count > 0)
- {
- gboolean need_finalize;
-
- /* sync with _sink */
- pspec->ref_count -= 1;
- need_finalize = pspec->ref_count == 0;
- G_UNLOCK (pspec_ref_count);
- if (need_finalize)
- G_PARAM_SPEC_GET_CLASS (pspec)->finalize (pspec);
- }
- else
+ is_zero = g_atomic_int_dec_and_test (&pspec->ref_count);
+
+ if (G_UNLIKELY (is_zero))
{
- G_UNLOCK (pspec_ref_count);
- g_return_if_fail (pspec->ref_count > 0);
+ G_PARAM_SPEC_GET_CLASS (pspec)->finalize (pspec);
}
}
g_param_spec_sink (GParamSpec *pspec)
{
g_return_if_fail (G_IS_PARAM_SPEC (pspec));
+ g_return_if_fail (pspec->ref_count > 0);
- G_LOCK (pspec_ref_count);
- if (pspec->ref_count > 0)
- {
- if (g_datalist_id_remove_no_notify (&pspec->qdata, quark_floating))
- {
- /* sync with _unref */
- if (pspec->ref_count > 1)
- pspec->ref_count -= 1;
- else
- {
- G_UNLOCK (pspec_ref_count);
- g_param_spec_unref (pspec);
-
- return;
- }
- }
- G_UNLOCK (pspec_ref_count);
- }
- else
+ if (g_datalist_id_remove_no_notify (&pspec->qdata, quark_floating))
{
- G_UNLOCK (pspec_ref_count);
- g_return_if_fail (pspec->ref_count > 0);
+ g_param_spec_unref (pspec);
}
}
Handler *next;
Handler *prev;
GQuark detail;
- guint ref_count : 16;
-#define HANDLER_MAX_REF_COUNT (1 << 16)
+ guint ref_count; /* ABI change, was 16 bits but since it's internal... */
guint block_count : 12;
#define HANDLER_MAX_BLOCK_COUNT (1 << 12)
guint after : 1;
return next;
}
+/* copy of gclosure.c code here to make the first 32 bits of the closure
+ * atomic. */
+typedef union
+{
+ GClosure bits;
+ gint atomic;
+} GAtomicClosureBits;
+
+#define BITS_AS_INT(b) (((GAtomicClosureBits*)(b))->atomic)
+#define CLOSURE_READ_BITS(cl,bits) (BITS_AS_INT(bits) = g_atomic_int_get ((gint*)(cl)))
+
static HandlerMatch*
handlers_find (gpointer instance,
GSignalMatchType mask,
}
mask = ~mask;
- for (handler = hlist ? hlist->handlers : NULL; handler; handler = handler->next)
- if (handler->sequential_number &&
- ((mask & G_SIGNAL_MATCH_DETAIL) || handler->detail == detail) &&
- ((mask & G_SIGNAL_MATCH_CLOSURE) || handler->closure == closure) &&
- ((mask & G_SIGNAL_MATCH_DATA) || handler->closure->data == data) &&
- ((mask & G_SIGNAL_MATCH_UNBLOCKED) || handler->block_count == 0) &&
- ((mask & G_SIGNAL_MATCH_FUNC) || (handler->closure->marshal == node->c_marshaller &&
- handler->closure->meta_marshal == 0 &&
- ((GCClosure*) handler->closure)->callback == func)))
- {
- mlist = handler_match_prepend (mlist, handler, signal_id);
- if (one_and_only)
- return mlist;
- }
+ for (handler = hlist ? hlist->handlers : NULL; handler; handler = handler->next)
+ {
+ GClosure bits;
+
+ CLOSURE_READ_BITS (handler->closure, &bits);
+
+ if (handler->sequential_number &&
+ ((mask & G_SIGNAL_MATCH_DETAIL) || handler->detail == detail) &&
+ ((mask & G_SIGNAL_MATCH_CLOSURE) || handler->closure == closure) &&
+ ((mask & G_SIGNAL_MATCH_DATA) || handler->closure->data == data) &&
+ ((mask & G_SIGNAL_MATCH_UNBLOCKED) || handler->block_count == 0) &&
+ ((mask & G_SIGNAL_MATCH_FUNC) || (handler->closure->marshal == node->c_marshaller &&
+ bits.meta_marshal == 0 &&
+ ((GCClosure*) handler->closure)->callback == func)))
+ {
+ mlist = handler_match_prepend (mlist, handler, signal_id);
+ if (one_and_only)
+ return mlist;
+ }
+ }
}
else
{
}
for (handler = hlist->handlers; handler; handler = handler->next)
- if (handler->sequential_number &&
- ((mask & G_SIGNAL_MATCH_DETAIL) || handler->detail == detail) &&
- ((mask & G_SIGNAL_MATCH_CLOSURE) || handler->closure == closure) &&
- ((mask & G_SIGNAL_MATCH_DATA) || handler->closure->data == data) &&
- ((mask & G_SIGNAL_MATCH_UNBLOCKED) || handler->block_count == 0) &&
- ((mask & G_SIGNAL_MATCH_FUNC) || (handler->closure->marshal == node->c_marshaller &&
- handler->closure->meta_marshal == 0 &&
- ((GCClosure*) handler->closure)->callback == func)))
- {
- mlist = handler_match_prepend (mlist, handler, hlist->signal_id);
- if (one_and_only)
- return mlist;
- }
+ {
+ GClosure bits;
+
+ CLOSURE_READ_BITS (handler->closure, &bits);
+
+ if (handler->sequential_number &&
+ ((mask & G_SIGNAL_MATCH_DETAIL) || handler->detail == detail) &&
+ ((mask & G_SIGNAL_MATCH_CLOSURE) || handler->closure == closure) &&
+ ((mask & G_SIGNAL_MATCH_DATA) || handler->closure->data == data) &&
+ ((mask & G_SIGNAL_MATCH_UNBLOCKED) || handler->block_count == 0) &&
+ ((mask & G_SIGNAL_MATCH_FUNC) || (handler->closure->marshal == node->c_marshaller &&
+ bits.meta_marshal == 0 &&
+ ((GCClosure*) handler->closure)->callback == func)))
+ {
+ mlist = handler_match_prepend (mlist, handler, hlist->signal_id);
+ if (one_and_only)
+ return mlist;
+ }
+ }
}
}
}
{
g_return_if_fail (handler->ref_count > 0);
-#ifndef G_DISABLE_CHECKS
- if (handler->ref_count >= HANDLER_MAX_REF_COUNT - 1)
- g_error (G_STRLOC ": handler ref_count overflow, %s", REPORT_BUG);
-#endif
-
- handler->ref_count += 1;
+ g_atomic_int_inc (&handler->ref_count);
}
static inline void
gpointer instance,
Handler *handler)
{
+ gboolean is_zero;
+
g_return_if_fail (handler->ref_count > 0);
- handler->ref_count -= 1;
- if (!handler->ref_count)
+ is_zero = g_atomic_int_dec_and_test (&handler->ref_count);
+
+ if (G_UNLIKELY (is_zero))
{
HandlerList *hlist = NULL;
-SUBDIRS=gobject
+SUBDIRS=gobject refcount
INCLUDES = -I$(top_srcdir) -I$(top_srcdir)/glib -I$(top_srcdir)/gmodule $(GLIB_DEBUG_FLAGS)
--- /dev/null
+INCLUDES = \
+ -I$(top_srcdir) \
+ -I$(top_srcdir)/glib \
+ -I$(top_srcdir)/gmodule \
+ $(GLIB_DEBUG_FLAGS)
+
+libglib = $(top_builddir)/glib/libglib-2.0.la
+libgthread = $(top_builddir)/gthread/libgthread-2.0.la
+libgmodule = $(top_builddir)/gmodule/libgmodule-2.0.la
+libgobject = $(top_builddir)/gobject/libgobject-2.0.la
+
+LDADD = $(libgobject) $(libgthread)
+
+test_programs = \
+ signal1 \
+ signal2 \
+ signal3 \
+ objects \
+ objects2 \
+ properties \
+ properties2
+
+signal1_SOURCES = signals.c
+signal1_CFLAGS = -DTESTNUM=1 $(AM_CFLAGS)
+signal2_SOURCES = signals.c
+signal2_CFLAGS = -DTESTNUM=2 $(AM_CFLAGS)
+signal3_SOURCES = signals.c
+signal3_CFLAGS = -DTESTNUM=3 $(AM_CFLAGS)
+
+check_PROGRAMS = $(test_programs)
+
+TESTS = $(test_programs)
+TESTS_ENVIRONMENT = srcdir=$(srcdir) \
+ LIBCHARSET_ALIAS_DIR=$(top_builddir)/glib/libcharset
--- /dev/null
+#include <unistd.h>
+#include <glib.h>
+#include <glib-object.h>
+
+#define G_TYPE_TEST (g_test_get_type ())
+#define G_TEST(test) (G_TYPE_CHECK_INSTANCE_CAST ((test), G_TYPE_TEST, GTest))
+#define G_IS_TEST(test) (G_TYPE_CHECK_INSTANCE_TYPE ((test), G_TYPE_TEST))
+#define G_TEST_CLASS(tclass) (G_TYPE_CHECK_CLASS_CAST ((tclass), G_TYPE_TEST, GTestClass))
+#define G_IS_TEST_CLASS(tclass) (G_TYPE_CHECK_CLASS_TYPE ((tclass), G_TYPE_TEST))
+#define G_TEST_GET_CLASS(test) (G_TYPE_INSTANCE_GET_CLASS ((test), G_TYPE_TEST, GTestClass))
+
+typedef struct _GTest GTest;
+typedef struct _GTestClass GTestClass;
+
+struct _GTest
+{
+ GObject object;
+};
+
+struct _GTestClass
+{
+ GObjectClass parent_class;
+};
+
+static GType g_test_get_type (void);
+static gboolean stopping;
+
+static void g_test_class_init (GTestClass * klass);
+static void g_test_init (GTest * test);
+static void g_test_dispose (GObject * object);
+
+static GObjectClass *parent_class = NULL;
+
+static GType
+g_test_get_type (void)
+{
+ static GType test_type = 0;
+
+ if (!test_type) {
+ static const GTypeInfo test_info = {
+ sizeof (GTestClass),
+ NULL,
+ NULL,
+ (GClassInitFunc) g_test_class_init,
+ NULL,
+ NULL,
+ sizeof (GTest),
+ 0,
+ (GInstanceInitFunc) g_test_init,
+ NULL
+ };
+
+ test_type = g_type_register_static (G_TYPE_OBJECT, "GTest",
+ &test_info, 0);
+ }
+ return test_type;
+}
+
+static void
+g_test_class_init (GTestClass * klass)
+{
+ GObjectClass *gobject_class;
+
+ gobject_class = (GObjectClass *) klass;
+
+ parent_class = g_type_class_ref (G_TYPE_OBJECT);
+
+ gobject_class->dispose = g_test_dispose;
+}
+
+static void
+g_test_init (GTest * test)
+{
+ g_print ("init %p\n", test);
+}
+
+static void
+g_test_dispose (GObject * object)
+{
+ GTest *test;
+
+ test = G_TEST (object);
+
+ g_print ("dispose %p!\n", object);
+
+ G_OBJECT_CLASS (parent_class)->dispose (object);
+}
+
+static void
+g_test_do_refcount (GTest * test)
+{
+ g_object_ref (test);
+ g_object_unref (test);
+}
+
+static gpointer
+run_thread (GTest * test)
+{
+ gint i = 0;
+
+ while (!stopping) {
+ g_test_do_refcount (test);
+ if ((i++ % 100000) == 0) {
+ g_print (".");
+ g_usleep (1); /* context switch */
+ }
+ }
+
+ return NULL;
+}
+
+int
+main (int argc, char **argv)
+{
+ gint i;
+ GTest *test1, *test2;
+ GArray *test_threads;
+
+ g_thread_init (NULL);
+ g_type_init ();
+
+ test1 = g_object_new (G_TYPE_TEST, NULL);
+ test2 = g_object_new (G_TYPE_TEST, NULL);
+
+ test_threads = g_array_new (FALSE, FALSE, sizeof (GThread *));
+
+ stopping = FALSE;
+
+ for (i = 0; i < 20; i++) {
+ GThread *thread;
+
+ thread = g_thread_create ((GThreadFunc) run_thread, test1, TRUE, NULL);
+ g_array_append_val (test_threads, thread);
+
+ thread = g_thread_create ((GThreadFunc) run_thread, test2, TRUE, NULL);
+ g_array_append_val (test_threads, thread);
+ }
+ sleep (5);
+
+ stopping = TRUE;
+
+ g_print ("\nstopping\n");
+
+ /* join all threads */
+ for (i = 0; i < 40; i++) {
+ GThread *thread;
+
+ thread = g_array_index (test_threads, GThread *, i);
+ g_thread_join (thread);
+ }
+
+ g_print ("stopped\n");
+
+ return 0;
+}
--- /dev/null
+#include <unistd.h>
+#include <glib.h>
+#include <glib-object.h>
+
+#define G_TYPE_TEST (g_test_get_type ())
+#define G_TEST(test) (G_TYPE_CHECK_INSTANCE_CAST ((test), G_TYPE_TEST, GTest))
+#define G_IS_TEST(test) (G_TYPE_CHECK_INSTANCE_TYPE ((test), G_TYPE_TEST))
+#define G_TEST_CLASS(tclass) (G_TYPE_CHECK_CLASS_CAST ((tclass), G_TYPE_TEST, GTestClass))
+#define G_IS_TEST_CLASS(tclass) (G_TYPE_CHECK_CLASS_TYPE ((tclass), G_TYPE_TEST))
+#define G_TEST_GET_CLASS(test) (G_TYPE_INSTANCE_GET_CLASS ((test), G_TYPE_TEST, GTestClass))
+
+typedef struct _GTest GTest;
+typedef struct _GTestClass GTestClass;
+
+struct _GTest
+{
+ GObject object;
+};
+
+struct _GTestClass
+{
+ GObjectClass parent_class;
+};
+
+static GType g_test_get_type (void);
+
+static void g_test_class_init (GTestClass * klass);
+static void g_test_init (GTest * test);
+static void g_test_dispose (GObject * object);
+
+static GObjectClass *parent_class = NULL;
+
+static GType
+g_test_get_type (void)
+{
+ static GType test_type = 0;
+
+ if (!test_type) {
+ static const GTypeInfo test_info = {
+ sizeof (GTestClass),
+ NULL,
+ NULL,
+ (GClassInitFunc) g_test_class_init,
+ NULL,
+ NULL,
+ sizeof (GTest),
+ 0,
+ (GInstanceInitFunc) g_test_init,
+ NULL
+ };
+
+ test_type = g_type_register_static (G_TYPE_OBJECT, "GTest",
+ &test_info, 0);
+ }
+ return test_type;
+}
+
+static void
+g_test_class_init (GTestClass * klass)
+{
+ GObjectClass *gobject_class;
+
+ gobject_class = (GObjectClass *) klass;
+
+ parent_class = g_type_class_ref (G_TYPE_OBJECT);
+
+ gobject_class->dispose = g_test_dispose;
+}
+
+static void
+g_test_init (GTest * test)
+{
+ g_print ("init %p\n", test);
+}
+
+static void
+g_test_dispose (GObject * object)
+{
+ GTest *test;
+
+ test = G_TEST (object);
+
+ g_print ("dispose %p!\n", object);
+
+ G_OBJECT_CLASS (parent_class)->dispose (object);
+}
+
+static void
+g_test_do_refcount (GTest * test)
+{
+ g_object_ref (test);
+ g_object_unref (test);
+}
+
+int
+main (int argc, char **argv)
+{
+ gint i;
+ GTest *test;
+
+ g_thread_init (NULL);
+ g_type_init ();
+
+ test = g_object_new (G_TYPE_TEST, NULL);
+
+ for (i=0; i<100000000; i++) {
+ g_test_do_refcount (test);
+ }
+
+ return 0;
+}
--- /dev/null
+#include <unistd.h>
+#include <glib.h>
+#include <glib-object.h>
+
+#define G_TYPE_TEST (g_test_get_type ())
+#define G_TEST(test) (G_TYPE_CHECK_INSTANCE_CAST ((test), G_TYPE_TEST, GTest))
+#define G_IS_TEST(test) (G_TYPE_CHECK_INSTANCE_TYPE ((test), G_TYPE_TEST))
+#define G_TEST_CLASS(tclass) (G_TYPE_CHECK_CLASS_CAST ((tclass), G_TYPE_TEST, GTestClass))
+#define G_IS_TEST_CLASS(tclass) (G_TYPE_CHECK_CLASS_TYPE ((tclass), G_TYPE_TEST))
+#define G_TEST_GET_CLASS(test) (G_TYPE_INSTANCE_GET_CLASS ((test), G_TYPE_TEST, GTestClass))
+
+enum {
+ PROP_0,
+ PROP_DUMMY
+};
+
+typedef struct _GTest GTest;
+typedef struct _GTestClass GTestClass;
+
+struct _GTest
+{
+ GObject object;
+
+ gint dummy;
+
+ gint count;
+};
+
+struct _GTestClass
+{
+ GObjectClass parent_class;
+};
+
+static GType g_test_get_type (void);
+static gboolean stopping;
+
+static void g_test_class_init (GTestClass * klass);
+static void g_test_init (GTest * test);
+static void g_test_dispose (GObject * object);
+static void g_test_get_property (GObject *object,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec);
+static void g_test_set_property (GObject *object,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec);
+
+static GObjectClass *parent_class = NULL;
+
+static GType
+g_test_get_type (void)
+{
+ static GType test_type = 0;
+
+ if (!test_type) {
+ static const GTypeInfo test_info = {
+ sizeof (GTestClass),
+ NULL,
+ NULL,
+ (GClassInitFunc) g_test_class_init,
+ NULL,
+ NULL,
+ sizeof (GTest),
+ 0,
+ (GInstanceInitFunc) g_test_init,
+ NULL
+ };
+
+ test_type = g_type_register_static (G_TYPE_OBJECT, "GTest",
+ &test_info, 0);
+ }
+ return test_type;
+}
+
+static void
+g_test_class_init (GTestClass * klass)
+{
+ GObjectClass *gobject_class;
+
+ gobject_class = (GObjectClass *) klass;
+
+ parent_class = g_type_class_ref (G_TYPE_OBJECT);
+
+ gobject_class->dispose = g_test_dispose;
+ gobject_class->get_property = g_test_get_property;
+ gobject_class->set_property = g_test_set_property;
+
+ g_object_class_install_property (gobject_class,
+ PROP_DUMMY,
+ g_param_spec_int ("dummy",
+ NULL,
+ NULL,
+ 0, G_MAXINT, 0,
+ G_PARAM_READWRITE));
+}
+
+static void
+g_test_init (GTest * test)
+{
+ g_print ("init %p\n", test);
+}
+
+static void
+g_test_dispose (GObject * object)
+{
+ GTest *test;
+
+ test = G_TEST (object);
+
+ g_print ("dispose %p!\n", object);
+
+ G_OBJECT_CLASS (parent_class)->dispose (object);
+}
+
+static void
+g_test_get_property (GObject *object,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ GTest *test;
+
+ test = G_TEST (object);
+
+ switch (prop_id)
+ {
+ case PROP_DUMMY:
+ g_value_set_int (value, test->dummy);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+static void
+g_test_set_property (GObject *object,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec)
+{
+ GTest *test;
+
+ test = G_TEST (object);
+
+ switch (prop_id)
+ {
+ case PROP_DUMMY:
+ test->dummy = g_value_get_int (value);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+static void
+dummy_notify (GObject *object,
+ GParamSpec *pspec)
+{
+ GTest *test;
+
+ test = G_TEST (object);
+
+ test->count++;
+}
+
+static void
+g_test_do_property (GTest * test)
+{
+ gint dummy;
+
+ g_object_get (test, "dummy", &dummy, NULL);
+ g_object_set (test, "dummy", dummy + 1, NULL);
+}
+
+static gpointer
+run_thread (GTest * test)
+{
+ gint i = 0;
+
+ while (!stopping) {
+ g_test_do_property (test);
+ if ((i++ % 100000) == 0) {
+ g_print (".");
+ g_usleep (1); /* context switch */
+ }
+ }
+
+ return NULL;
+}
+
+int
+main (int argc, char **argv)
+{
+ gint i;
+ GArray *test_objects;
+ GArray *test_threads;
+
+ g_thread_init (NULL);
+ g_type_init ();
+
+ test_objects = g_array_new (FALSE, FALSE, sizeof (GTest *));
+
+ for (i = 0; i < 20; i++) {
+ GTest *test;
+
+ test = g_object_new (G_TYPE_TEST, NULL);
+ g_array_append_val (test_objects, test);
+
+ g_assert (test->count == test->dummy);
+ g_signal_connect (test, "notify::dummy", G_CALLBACK (dummy_notify), NULL);
+ }
+
+ test_threads = g_array_new (FALSE, FALSE, sizeof (GThread *));
+
+ stopping = FALSE;
+
+ for (i = 0; i < 20; i++) {
+ GThread *thread;
+ GTest *test;
+
+ test = g_array_index (test_objects, GTest *, i);
+
+ thread = g_thread_create ((GThreadFunc) run_thread, test, TRUE, NULL);
+ g_array_append_val (test_threads, thread);
+ }
+ sleep (5);
+
+ stopping = TRUE;
+
+ g_print ("\nstopping\n");
+
+ /* join all threads */
+ for (i = 0; i < 20; i++) {
+ GThread *thread;
+
+ thread = g_array_index (test_threads, GThread *, i);
+ g_thread_join (thread);
+ }
+
+ g_print ("stopped\n");
+
+ for (i = 0; i < 20; i++) {
+ GTest *test;
+
+ test = g_array_index (test_objects, GTest *, i);
+
+ g_assert (test->count == test->dummy);
+ }
+
+ return 0;
+}
--- /dev/null
+#include <unistd.h>
+#include <glib.h>
+#include <glib-object.h>
+
+#define G_TYPE_TEST (g_test_get_type ())
+#define G_TEST(test) (G_TYPE_CHECK_INSTANCE_CAST ((test), G_TYPE_TEST, GTest))
+#define G_IS_TEST(test) (G_TYPE_CHECK_INSTANCE_TYPE ((test), G_TYPE_TEST))
+#define G_TEST_CLASS(tclass) (G_TYPE_CHECK_CLASS_CAST ((tclass), G_TYPE_TEST, GTestClass))
+#define G_IS_TEST_CLASS(tclass) (G_TYPE_CHECK_CLASS_TYPE ((tclass), G_TYPE_TEST))
+#define G_TEST_GET_CLASS(test) (G_TYPE_INSTANCE_GET_CLASS ((test), G_TYPE_TEST, GTestClass))
+
+enum {
+ PROP_0,
+ PROP_DUMMY
+};
+
+typedef struct _GTest GTest;
+typedef struct _GTestClass GTestClass;
+
+struct _GTest
+{
+ GObject object;
+
+ gint dummy;
+};
+
+struct _GTestClass
+{
+ GObjectClass parent_class;
+};
+
+static GType g_test_get_type (void);
+
+static void g_test_class_init (GTestClass * klass);
+static void g_test_init (GTest * test);
+static void g_test_dispose (GObject * object);
+static void g_test_get_property (GObject *object,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec);
+static void g_test_set_property (GObject *object,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec);
+
+static GObjectClass *parent_class = NULL;
+
+static GType
+g_test_get_type (void)
+{
+ static GType test_type = 0;
+
+ if (!test_type) {
+ static const GTypeInfo test_info = {
+ sizeof (GTestClass),
+ NULL,
+ NULL,
+ (GClassInitFunc) g_test_class_init,
+ NULL,
+ NULL,
+ sizeof (GTest),
+ 0,
+ (GInstanceInitFunc) g_test_init,
+ NULL
+ };
+
+ test_type = g_type_register_static (G_TYPE_OBJECT, "GTest",
+ &test_info, 0);
+ }
+ return test_type;
+}
+
+static void
+g_test_class_init (GTestClass * klass)
+{
+ GObjectClass *gobject_class;
+
+ gobject_class = (GObjectClass *) klass;
+
+ parent_class = g_type_class_ref (G_TYPE_OBJECT);
+
+ gobject_class->dispose = g_test_dispose;
+ gobject_class->get_property = g_test_get_property;
+ gobject_class->set_property = g_test_set_property;
+
+ g_object_class_install_property (gobject_class,
+ PROP_DUMMY,
+ g_param_spec_int ("dummy",
+ NULL,
+ NULL,
+ 0, G_MAXINT, 0,
+ G_PARAM_READWRITE));
+}
+
+static void
+g_test_init (GTest * test)
+{
+ g_print ("init %p\n", test);
+}
+
+static void
+g_test_dispose (GObject * object)
+{
+ GTest *test;
+
+ test = G_TEST (object);
+
+ g_print ("dispose %p!\n", object);
+
+ G_OBJECT_CLASS (parent_class)->dispose (object);
+}
+
+static void
+g_test_get_property (GObject *object,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ GTest *test;
+
+ test = G_TEST (object);
+
+ switch (prop_id)
+ {
+ case PROP_DUMMY:
+ g_value_set_int (value, test->dummy);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+static void
+g_test_set_property (GObject *object,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec)
+{
+ GTest *test;
+
+ test = G_TEST (object);
+
+ switch (prop_id)
+ {
+ case PROP_DUMMY:
+ test->dummy = g_value_get_int (value);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+static gint count = 0;
+
+static void
+dummy_notify (GObject *object,
+ GParamSpec *pspec)
+{
+ count++;
+}
+
+static void
+g_test_do_property (GTest * test)
+{
+ gint dummy;
+
+ g_object_get (test, "dummy", &dummy, NULL);
+ g_object_set (test, "dummy", dummy + 1, NULL);
+}
+
+int
+main (int argc, char **argv)
+{
+ gint i;
+ GTest *test;
+
+ g_thread_init (NULL);
+ g_type_init ();
+
+ test = g_object_new (G_TYPE_TEST, NULL);
+
+ g_signal_connect (test, "notify::dummy", G_CALLBACK (dummy_notify), NULL);
+
+ g_assert (count == test->dummy);
+
+ for (i=0; i<1000000; i++) {
+ g_test_do_property (test);
+ }
+
+ g_assert (count == test->dummy);
+
+ return 0;
+}
--- /dev/null
+#include <unistd.h>
+#include <glib.h>
+#include <glib-object.h>
+
+#define G_TYPE_TEST (g_test_get_type ())
+#define G_TEST(test) (G_TYPE_CHECK_INSTANCE_CAST ((test), G_TYPE_TEST, GTest))
+#define G_IS_TEST(test) (G_TYPE_CHECK_INSTANCE_TYPE ((test), G_TYPE_TEST))
+#define G_TEST_CLASS(tclass) (G_TYPE_CHECK_CLASS_CAST ((tclass), G_TYPE_TEST, GTestClass))
+#define G_IS_TEST_CLASS(tclass) (G_TYPE_CHECK_CLASS_TYPE ((tclass), G_TYPE_TEST))
+#define G_TEST_GET_CLASS(test) (G_TYPE_INSTANCE_GET_CLASS ((test), G_TYPE_TEST, GTestClass))
+
+static GRand *rand;
+
+typedef struct _GTest GTest;
+typedef struct _GTestClass GTestClass;
+
+struct _GTest
+{
+ GObject object;
+
+ gint value;
+};
+
+struct _GTestClass
+{
+ GObjectClass parent_class;
+
+ void (*test_signal1) (GTest * test, gint an_int);
+ void (*test_signal2) (GTest * test, gint an_int);
+};
+
+static GType g_test_get_type (void);
+static gboolean stopping;
+
+/* Element signals and args */
+enum
+{
+ TEST_SIGNAL1,
+ TEST_SIGNAL2,
+ /* add more above */
+ LAST_SIGNAL
+};
+
+enum
+{
+ ARG_0,
+ ARG_TEST_PROP
+};
+
+static void g_test_class_init (GTestClass * klass);
+static void g_test_init (GTest * test);
+static void g_test_dispose (GObject * object);
+
+static void signal2_handler (GTest * test, gint anint);
+
+static void g_test_set_property (GObject * object, guint prop_id,
+ const GValue * value, GParamSpec * pspec);
+static void g_test_get_property (GObject * object, guint prop_id,
+ GValue * value, GParamSpec * pspec);
+
+static GObjectClass *parent_class = NULL;
+
+static guint g_test_signals[LAST_SIGNAL] = { 0 };
+
+static GType
+g_test_get_type (void)
+{
+ static GType test_type = 0;
+
+ if (!test_type) {
+ static const GTypeInfo test_info = {
+ sizeof (GTestClass),
+ NULL,
+ NULL,
+ (GClassInitFunc) g_test_class_init,
+ NULL,
+ NULL,
+ sizeof (GTest),
+ 0,
+ (GInstanceInitFunc) g_test_init,
+ NULL
+ };
+
+ rand = g_rand_new();
+
+ test_type = g_type_register_static (G_TYPE_OBJECT, "GTest",
+ &test_info, 0);
+ }
+ return test_type;
+}
+
+static void
+g_test_class_init (GTestClass * klass)
+{
+ GObjectClass *gobject_class;
+
+ gobject_class = (GObjectClass *) klass;
+
+ parent_class = g_type_class_ref (G_TYPE_OBJECT);
+
+ if (!g_thread_supported ())
+ g_thread_init (NULL);
+
+ gobject_class->dispose = g_test_dispose;
+ gobject_class->set_property = g_test_set_property;
+ gobject_class->get_property = g_test_get_property;
+
+ g_test_signals[TEST_SIGNAL1] =
+ g_signal_new ("test-signal1", G_TYPE_FROM_CLASS (klass),
+ G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GTestClass, test_signal1), NULL,
+ NULL, g_cclosure_marshal_VOID__INT, G_TYPE_NONE, 1, G_TYPE_INT);
+ g_test_signals[TEST_SIGNAL2] =
+ g_signal_new ("test-signal2", G_TYPE_FROM_CLASS (klass),
+ G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GTestClass, test_signal2), NULL,
+ NULL, g_cclosure_marshal_VOID__INT, G_TYPE_NONE, 1, G_TYPE_INT);
+
+ g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_TEST_PROP,
+ g_param_spec_int ("test-prop", "Test Prop", "Test property",
+ 0, 1, 0, G_PARAM_READWRITE));
+
+ klass->test_signal2 = signal2_handler;
+}
+
+static void
+g_test_init (GTest * test)
+{
+ g_print ("init %p\n", test);
+
+ test->value = 0;
+}
+
+static void
+g_test_dispose (GObject * object)
+{
+ GTest *test;
+
+ test = G_TEST (object);
+
+ g_print ("dispose %p!\n", object);
+
+ G_OBJECT_CLASS (parent_class)->dispose (object);
+}
+
+static void
+g_test_set_property (GObject * object, guint prop_id,
+ const GValue * value, GParamSpec * pspec)
+{
+ GTest *test;
+
+ test = G_TEST (object);
+
+ switch (prop_id) {
+ case ARG_TEST_PROP:
+ test->value = g_value_get_int (value);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+static void
+g_test_get_property (GObject * object, guint prop_id,
+ GValue * value, GParamSpec * pspec)
+{
+ GTest *test;
+
+ test = G_TEST (object);
+
+ switch (prop_id) {
+ case ARG_TEST_PROP:
+ g_value_set_int (value, test->value);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+static void
+g_test_do_signal1 (GTest * test)
+{
+ g_signal_emit (G_OBJECT (test), g_test_signals[TEST_SIGNAL1], 0, 0);
+}
+
+static void
+signal2_handler (GTest * test, gint anint)
+{
+}
+
+static void
+g_test_do_signal2 (GTest * test)
+{
+ g_signal_emit (G_OBJECT (test), g_test_signals[TEST_SIGNAL2], 0, 0);
+}
+
+static void
+g_test_do_prop (GTest * test)
+{
+ test->value = g_rand_int (rand);
+ g_object_notify (G_OBJECT (test), "test-prop");
+}
+
+static gpointer
+run_thread (GTest * test)
+{
+ gint i = 0;
+
+ while (!stopping) {
+ if (TESTNUM == 1)
+ g_test_do_signal1 (test);
+ if (TESTNUM == 2)
+ g_test_do_signal2 (test);
+ if (TESTNUM == 3)
+ g_test_do_prop (test);
+ if ((i++ % 100000) == 0) {
+ g_print (".");
+ g_usleep (1); /* context switch */
+ }
+ }
+
+ return NULL;
+}
+
+static void
+notify (GObject *object, GParamSpec *spec, gpointer user_data)
+{
+ gint value;
+
+ g_object_get (object, "test-prop", &value, NULL);
+ //g_print ("+ %d", value);
+}
+
+int
+main (int argc, char **argv)
+{
+ gint i;
+ GTest *test1, *test2;
+ GArray *test_threads;
+
+ g_thread_init (NULL);
+ g_type_init ();
+
+ test1 = g_object_new (G_TYPE_TEST, NULL);
+ test2 = g_object_new (G_TYPE_TEST, NULL);
+
+ g_signal_connect (test1, "notify::test-prop", notify, NULL);
+ g_signal_connect (test1, "test-signal1", notify, NULL);
+ g_signal_connect (test1, "test-signal2", notify, NULL);
+
+ test_threads = g_array_new (FALSE, FALSE, sizeof (GThread *));
+
+ stopping = FALSE;
+
+ for (i = 0; i < 20; i++) {
+ GThread *thread;
+
+ thread = g_thread_create ((GThreadFunc) run_thread, test1, TRUE, NULL);
+ g_array_append_val (test_threads, thread);
+
+ thread = g_thread_create ((GThreadFunc) run_thread, test2, TRUE, NULL);
+ g_array_append_val (test_threads, thread);
+ }
+ sleep (5);
+
+ stopping = TRUE;
+
+ g_print ("\nstopping\n");
+
+ /* join all threads */
+ for (i = 0; i < 40; i++) {
+ GThread *thread;
+
+ thread = g_array_index (test_threads, GThread *, i);
+ g_thread_join (thread);
+ }
+
+ g_print ("stopped\n");
+
+ return 0;
+}
projects / platform / upstream / glib.git / commitdiff