From 9e5a53d576765819d1c7c233515b9f6e5d77eb61 Mon Sep 17 00:00:00 2001 From: Emmanuele Bassi Date: Wed, 17 Jan 2018 16:38:45 +0000 Subject: [PATCH] Add reference counting types We have a common pattern for reference counting in GLib, but we always implement it with ad hoc code. This is a good chance at trying to standardise the implementation and make it public, so that other code using GLib can take advantage of shared behaviour and semantics. Instead of simply taking an integer variable, we should create type aliases, to immediately distinguish the reference counting semantics of the code; we can handle mixing atomic reference counting with a non-atomic type (and vice versa) by using differently signed values for the atomic and non-atomic cases. The gatomicrefcount type is modelled on the Linux kernel refcount_t type; the grefcount type is added to let single-threaded code bases to avoid paying the price of atomic memory barriers on reference counting operations. --- docs/reference/glib/glib-docs.xml | 1 + docs/reference/glib/glib-sections.txt | 15 ++ glib/Makefile.am | 2 + glib/glib.h | 1 + glib/grefcount.c | 285 ++++++++++++++++++++++++++ glib/grefcount.h | 52 +++++ glib/gtypes.h | 3 + glib/meson.build | 2 + 8 files changed, 361 insertions(+) create mode 100644 glib/grefcount.c create mode 100644 glib/grefcount.h diff --git a/docs/reference/glib/glib-docs.xml b/docs/reference/glib/glib-docs.xml index a0716c1727..26cdafb67b 100644 --- a/docs/reference/glib/glib-docs.xml +++ b/docs/reference/glib/glib-docs.xml @@ -119,6 +119,7 @@ + diff --git a/docs/reference/glib/glib-sections.txt b/docs/reference/glib/glib-sections.txt index 0183b0898a..331d92c75f 100644 --- a/docs/reference/glib/glib-sections.txt +++ b/docs/reference/glib/glib-sections.txt @@ -3449,3 +3449,18 @@ g_hostname_is_ip_address g_uuid_string_is_valid g_uuid_string_random + +
+refcount +grefcount +g_ref_count_init +g_ref_count_inc +g_ref_count_dec +g_ref_count_compare + +gatomicrefcount +g_atomic_ref_count_init +g_atomic_ref_count_inc +g_atomic_ref_count_dec +g_atomic_ref_count_compare +
diff --git a/glib/Makefile.am b/glib/Makefile.am index 0497061265..4d04e09daa 100644 --- a/glib/Makefile.am +++ b/glib/Makefile.am @@ -149,6 +149,7 @@ libglib_2_0_la_SOURCES = \ gquark.c \ gqueue.c \ grand.c \ + grefcount.c \ gregex.c \ gscanner.c \ gscripttable.h \ @@ -284,6 +285,7 @@ glibsubinclude_HEADERS = \ gquark.h \ gqueue.h \ grand.h \ + grefcount.h \ gregex.h \ gscanner.h \ gsequence.h \ diff --git a/glib/glib.h b/glib/glib.h index 4f5a7f702f..84299c4f90 100644 --- a/glib/glib.h +++ b/glib/glib.h @@ -69,6 +69,7 @@ #include #include #include +#include #include #include #include diff --git a/glib/grefcount.c b/glib/grefcount.c new file mode 100644 index 0000000000..10e35a217d --- /dev/null +++ b/glib/grefcount.c @@ -0,0 +1,285 @@ +/* grefcount.c: Reference counting + * + * Copyright 2018 Emmanuele Bassi + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see . + */ + +/** + * SECTION:refcount + * @Title: Reference counting + * @Short_description: Reference counting types and functions + * + * Reference counting is a garbage collection mechanism that is based on + * assigning a counter to a data type, or any memory area; the counter is + * increased whenever a new reference to that data type is acquired, and + * decreased whenever the reference is released. Once the last reference + * is released, the resources associated to that data type are freed. + * + * GLib uses reference counting in many of its data types, and provides + * the #grefcount and #gatomicrefcount types to implement safe and atomic + * reference counting semantics in new data types. + * + * It is important to note that #grefcount and #gatomicrefcount should be + * considered completely opaque types; you should always use the provided + * API to increase and decrease the counters, and you should never check + * their content directly, or compare their content with other values. + * + * Since: 2.58 + */ + +#include "config.h" + +#include "grefcount.h" + +#include "gatomic.h" +#include "gmessages.h" + +/** + * grefcount: + * + * A type for implementing non-atomic reference count semantics. + * + * Use g_ref_count_init() to initialize it; g_ref_count_inc() to + * increase the counter, and g_ref_count_dec() to decrease it. + * + * It is safe to use #grefcount only if you're expecting to operate + * on the reference counter from a single thread. It is entirely up + * to you to ensure that all reference count changes happen in the + * same thread. + * + * See also: #gatomicrefcount + * + * Since: 2.58 + */ + +/** + * gatomicrefcount: + * + * A type for implementing atomic reference count semantics. + * + * Use g_atomic_ref_count_init() to initialize it; g_atomic_ref_count_inc() + * to increase the counter, and g_atomic_ref_count_dec() to decrease it. + * + * It is safe to use #gatomicrefcount if you're expecting to operate on the + * reference counter from multiple threads. + * + * See also: #grefcount + * + * Since: 2.58 + */ + +/** + * g_ref_count_init: + * @rc: the address of a reference count variable + * + * Initializes a reference count variable. + * + * Since: 2.58 + */ +void +g_ref_count_init (grefcount *rc) +{ + g_return_if_fail (rc != NULL); + + /* Non-atomic refcounting is implemented using the negative range + * of signed integers: + * + * G_MININT Z¯< 0 > Z⁺ G_MAXINT + * |----------------------------|----------------------------| + * + * Acquiring a reference moves us towards MININT, and releasing a + * reference moves us towards 0. + */ + *rc = -1; +} + +/** + * g_ref_count_inc: + * @rc: the address of a reference count variable + * + * Increases the reference count. + * + * Since: 2.58 + */ +void +g_ref_count_inc (grefcount *rc) +{ + grefcount rrc; + + g_return_if_fail (rc != NULL); + + rrc = *rc; + + g_return_if_fail (rrc < 0); + + /* Check for saturation */ + if (rrc == G_MININT) + { + g_critical ("Reference count %p has reached saturation", rc); + return; + } + + rrc -= 1; + + *rc = rrc; +} + +/** + * g_ref_count_dec: + * @rc: the address of a reference count variable + * + * Decreases the reference count. + * + * Returns: %TRUE if the reference count reached 0, and %FALSE otherwise + * + * Since: 2.58 + */ +gboolean +g_ref_count_dec (grefcount *rc) +{ + grefcount rrc; + + g_return_val_if_fail (rc != NULL, FALSE); + + rrc = *rc; + + g_return_val_if_fail (rrc < 0, FALSE); + + rrc += 1; + if (rrc == 0) + return TRUE; + + *rc = rrc; + + return FALSE; +} + +/** + * g_ref_count_compare: + * @rc: the address of a reference count variable + * @val: the value to compare + * + * Compares the current value of @rc with @val. + * + * Returns: %TRUE if the reference count is the same + * as the given value + * + * Since: 2.58 + */ +gboolean +g_ref_count_compare (grefcount *rc, + gint val) +{ + grefcount rrc; + + g_return_val_if_fail (rc != NULL, FALSE); + g_return_val_if_fail (val >= 0, FALSE); + + rrc = *rc; + + if (val == G_MAXINT) + return rrc == G_MININT; + + return rrc == -val; +} + +/** + * g_atomic_ref_count_init: + * @arc: the address of an atomic reference count variable + * + * Atomically initializes a reference count variable. + * + * Since: 2.58 + */ +void +g_atomic_ref_count_init (gatomicrefcount *arc) +{ + g_return_if_fail (arc != NULL); + + /* Atomic refcounting is implemented using the positive range + * of signed integers: + * + * G_MININT Z¯< 0 > Z⁺ G_MAXINT + * |----------------------------|----------------------------| + * + * Acquiring a reference moves us towards MAXINT, and releasing a + * reference moves us towards 0. + */ + g_atomic_int_set (arc, 1); +} + +/** + * g_atomic_ref_count_inc: + * @arc: the address of an atomic reference count variable + * + * Atomically increases the reference count. + * + * Since: 2.58 + */ +void +g_atomic_ref_count_inc (gatomicrefcount *arc) +{ + g_return_if_fail (arc != NULL); + g_return_if_fail (g_atomic_int_get (arc) > 0); + + if (g_atomic_int_get (arc) == G_MAXINT) + { + g_critical ("Reference count has reached saturation"); + return; + } + + g_atomic_int_inc (arc); +} + +/** + * g_atomic_ref_count_dec: + * @arc: the address of an atomic reference count variable + * + * Atomically decreases the reference count. + * + * Returns: %TRUE if the reference count reached 0, and %FALSE otherwise + * + * Since: 2.58 + */ +gboolean +g_atomic_ref_count_dec (gatomicrefcount *arc) +{ + g_return_val_if_fail (arc != NULL, FALSE); + g_return_val_if_fail (g_atomic_int_get (arc) > 0, FALSE); + + return g_atomic_int_dec_and_test (arc); +} + +/** + * g_atomic_ref_count_compare: + * @arc: the address of an atomic reference count variable + * @val: the value to compare + * + * Atomically compares the current value of @arc with @val. + * + * Returns: %TRUE if the reference count is the same + * as the given value + * + * Since: 2.58 + */ +gboolean +g_atomic_ref_count_compare (gatomicrefcount *arc, + gint val) +{ + g_return_val_if_fail (arc != NULL, FALSE); + g_return_val_if_fail (val >= 0, FALSE); + + return g_atomic_int_get (arc) == val; +} diff --git a/glib/grefcount.h b/glib/grefcount.h new file mode 100644 index 0000000000..b24c71e8cb --- /dev/null +++ b/glib/grefcount.h @@ -0,0 +1,52 @@ +/* grefcount.h: Reference counting + * + * Copyright 2018 Emmanuele Bassi + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see . + */ + +#ifndef __GREFCOUNT_H__ +#define __GREFCOUNT_H__ + +#if !defined (__GLIB_H_INSIDE__) && !defined (GLIB_COMPILATION) +#error "Only can be included directly." +#endif + +#include + +G_BEGIN_DECLS + +GLIB_AVAILABLE_IN_2_56 +void g_ref_count_init (grefcount *rc); +GLIB_AVAILABLE_IN_2_56 +void g_ref_count_inc (grefcount *rc); +GLIB_AVAILABLE_IN_2_56 +gboolean g_ref_count_dec (grefcount *rc); +GLIB_AVAILABLE_IN_2_56 +gboolean g_ref_count_compare (grefcount *rc, + gint val); + +GLIB_AVAILABLE_IN_2_56 +void g_atomic_ref_count_init (gatomicrefcount *arc); +GLIB_AVAILABLE_IN_2_56 +void g_atomic_ref_count_inc (gatomicrefcount *arc); +GLIB_AVAILABLE_IN_2_56 +gboolean g_atomic_ref_count_dec (gatomicrefcount *arc); +GLIB_AVAILABLE_IN_2_56 +gboolean g_atomic_ref_count_compare (gatomicrefcount *arc, + gint val); + +G_END_DECLS + +#endif /* __GREFCOUNT_H__ */ diff --git a/glib/gtypes.h b/glib/gtypes.h index 09d9bd1456..67adb7f1f8 100644 --- a/glib/gtypes.h +++ b/glib/gtypes.h @@ -510,6 +510,9 @@ struct _GTimeVal glong tv_usec; }; +typedef gint grefcount; +typedef volatile gint gatomicrefcount; + G_END_DECLS /* We prefix variable declarations so they can diff --git a/glib/meson.build b/glib/meson.build index 036d1f4d60..76d354c2a7 100644 --- a/glib/meson.build +++ b/glib/meson.build @@ -76,6 +76,7 @@ glib_sub_headers = files( 'gquark.h', 'gqueue.h', 'grand.h', + 'grefcount.h', 'gregex.h', 'gscanner.h', 'gsequence.h', @@ -159,6 +160,7 @@ glib_sources = files( 'gquark.c', 'gqueue.c', 'grand.c', + 'grefcount.c', 'gregex.c', 'gscanner.c', 'gsequence.c', -- GitLab From 827c208cbf9cc0ef17b8c4531a40aafe1edc3f01 Mon Sep 17 00:00:00 2001 From: Emmanuele Bassi Date: Mon, 4 Jun 2018 11:38:40 +0100 Subject: [PATCH] Use macros for refcount types API If we're using GCC we can use __extension__ to inline the grefcount and gatomicrefcount API, and avoid the function call. These macros are only enabled if G_DISABLE_CHECKS is defined, as they remove critical warnings when the reference counters achieve saturation. --- glib/grefcount.c | 20 +++++++------- glib/grefcount.h | 70 ++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 80 insertions(+), 10 deletions(-) diff --git a/glib/grefcount.c b/glib/grefcount.c index 10e35a217d..37085316b9 100644 --- a/glib/grefcount.c +++ b/glib/grefcount.c @@ -89,7 +89,7 @@ * Since: 2.58 */ void -g_ref_count_init (grefcount *rc) +(g_ref_count_init) (grefcount *rc) { g_return_if_fail (rc != NULL); @@ -114,7 +114,7 @@ g_ref_count_init (grefcount *rc) * Since: 2.58 */ void -g_ref_count_inc (grefcount *rc) +(g_ref_count_inc) (grefcount *rc) { grefcount rrc; @@ -147,7 +147,7 @@ g_ref_count_inc (grefcount *rc) * Since: 2.58 */ gboolean -g_ref_count_dec (grefcount *rc) +(g_ref_count_dec) (grefcount *rc) { grefcount rrc; @@ -179,8 +179,8 @@ g_ref_count_dec (grefcount *rc) * Since: 2.58 */ gboolean -g_ref_count_compare (grefcount *rc, - gint val) +(g_ref_count_compare) (grefcount *rc, + gint val) { grefcount rrc; @@ -204,7 +204,7 @@ g_ref_count_compare (grefcount *rc, * Since: 2.58 */ void -g_atomic_ref_count_init (gatomicrefcount *arc) +(g_atomic_ref_count_init) (gatomicrefcount *arc) { g_return_if_fail (arc != NULL); @@ -229,7 +229,7 @@ g_atomic_ref_count_init (gatomicrefcount *arc) * Since: 2.58 */ void -g_atomic_ref_count_inc (gatomicrefcount *arc) +(g_atomic_ref_count_inc) (gatomicrefcount *arc) { g_return_if_fail (arc != NULL); g_return_if_fail (g_atomic_int_get (arc) > 0); @@ -254,7 +254,7 @@ g_atomic_ref_count_inc (gatomicrefcount *arc) * Since: 2.58 */ gboolean -g_atomic_ref_count_dec (gatomicrefcount *arc) +(g_atomic_ref_count_dec) (gatomicrefcount *arc) { g_return_val_if_fail (arc != NULL, FALSE); g_return_val_if_fail (g_atomic_int_get (arc) > 0, FALSE); @@ -275,8 +275,8 @@ g_atomic_ref_count_dec (gatomicrefcount *arc) * Since: 2.58 */ gboolean -g_atomic_ref_count_compare (gatomicrefcount *arc, - gint val) +(g_atomic_ref_count_compare) (gatomicrefcount *arc, + gint val) { g_return_val_if_fail (arc != NULL, FALSE); g_return_val_if_fail (val >= 0, FALSE); diff --git a/glib/grefcount.h b/glib/grefcount.h index b24c71e8cb..dec9a5ffb8 100644 --- a/glib/grefcount.h +++ b/glib/grefcount.h @@ -47,6 +47,76 @@ GLIB_AVAILABLE_IN_2_58 gboolean g_atomic_ref_count_compare (gatomicrefcount *arc, gint val); +/* On GCC we can use __extension__ to inline the API without using + * ancillary functions; we only do this when disabling checks, as + * it disables warnings when saturating the reference counters + */ +#if defined(__GNUC__) && defined(G_DISABLE_CHECKS) + +# define g_ref_count_init(rc) \ + (G_GNUC_EXTENSION ({ \ + G_STATIC_ASSERT (sizeof *(rc) == sizeof (grefcount)); \ + (void) (0 ? *(rc) ^ *(rc) : 1); \ + *(rc) = -1; \ + })) + +# define g_ref_count_inc(rc) \ + (G_GNUC_EXTENSION ({ \ + G_STATIC_ASSERT (sizeof *(rc) == sizeof (grefcount)); \ + (void) (0 ? *(rc) ^ *(rc) : 1); \ + if (*(rc) == G_MININT) ; else { \ + *(rc) -= 1; \ + } \ + })) + +# define g_ref_count_dec(rc) \ + (G_GNUC_EXTENSION ({ \ + G_STATIC_ASSERT (sizeof *(rc) == sizeof (grefcount)); \ + grefcount __rc = *(rc); \ + __rc += 1; \ + if (__rc == 0) ; else { \ + *(rc) = __rc; \ + } \ + (gboolean) (__rc == 0); \ + })) + +# define g_ref_count_compare(rc,val) \ + (G_GNUC_EXTENSION ({ \ + G_STATIC_ASSERT (sizeof *(rc) == sizeof (grefcount)); \ + (void) (0 ? *(rc) ^ (val) : 1); \ + (gboolean) (*(rc) == -(val)); \ + })) + +# define g_atomic_ref_count_init(rc) \ + (G_GNUC_EXTENSION ({ \ + G_STATIC_ASSERT (sizeof *(rc) == sizeof (gatomicrefcount)); \ + (void) (0 ? *(rc) ^ *(rc) : 1); \ + g_atomic_int_set ((rc), 1); \ + })) + +# define g_atomic_ref_count_inc(rc) \ + (G_GNUC_EXTENSION ({ \ + G_STATIC_ASSERT (sizeof *(rc) == sizeof (gatomicrefcount)); \ + (void) (0 ? *(rc) ^ *(rc) : 1); \ + (void) (g_atomic_int_get (rc) == G_MAXINT ? 0 : g_atomic_int_inc ((rc))); \ + })) + +# define g_atomic_ref_count_dec(rc) \ + (G_GNUC_EXTENSION ({ \ + G_STATIC_ASSERT (sizeof *(rc) == sizeof (gatomicrefcount)); \ + (void) (0 ? *(rc) ^ *(rc) : 1); \ + g_atomic_int_dec_and_test ((rc)); \ + })) + +# define g_atomic_ref_count_compare(rc,val) \ + (G_GNUC_EXTENSION ({ \ + G_STATIC_ASSERT (sizeof *(rc) == sizeof (gatomicrefcount)); \ + (void) (0 ? *(rc) ^ (val) : 1); \ + (gboolean) (g_atomic_int_get (rc) == (val)); \ + })) + +#endif /* __GNUC__ && G_DISABLE_CHECKS */ + G_END_DECLS #endif /* __GREFCOUNT_H__ */ -- GitLab From 09c149453ac969dedb1cb2d15d489d1dd81412bf Mon Sep 17 00:00:00 2001 From: Fabrice Fontaine Date: Sat, 13 Oct 2018 23:10:33 +0200 Subject: [PATCH] grefcount: add missing gatomic.h MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Without gatomic.h, build fails on: In file included from garcbox.c:24:0: garcbox.c: In function ‘g_atomic_rc_box_acquire’: grefcount.h:101:13: error: implicit declaration of function ‘g_atomic_int_get’; did you mean ‘__atomic_store’? [-Werror=implicit-function-declaration] (void) (g_atomic_int_get (rc) == G_MAXINT ? 0 : g_atomic_int_inc ((rc))); \ ^ garcbox.c:292:3: note: in expansion of macro ‘g_atomic_ref_count_inc’ g_atomic_ref_count_inc (&real_box->ref_count); Signed-off-by: Fabrice Fontaine --- glib/grefcount.h | 1 + 1 file changed, 1 insertion(+) diff --git a/glib/grefcount.h b/glib/grefcount.h index dec9a5ffb8..b6eced1b7d 100644 --- a/glib/grefcount.h +++ b/glib/grefcount.h @@ -23,6 +23,7 @@ #error "Only can be included directly." #endif +#include #include G_BEGIN_DECLS -- GitLab