luc14n0/glib
1
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/glib.git synced 2025-01-28 06:56:16 +01:00
Code Issues Packages Projects Releases Wiki Activity
a91d2f81c2
glib/glib/gbitlock.h

110 lines
4.3 KiB
C
Raw Normal View History

Bug 548967 - 1 bit mutex lock Add support for a mutex lock that consumes only one bit of storage inside of an integer on systems that support futexes. Futex is emulated (at a higher cost) on systems that don't have it -- but only in the contended case.
2010-01-28 17:32:07 +01:00
/*
* Copyright © 2008 Ryan Lortie
* Copyright © 2010 Codethink Limited
*
glib: Add SPDX license headers automatically Add SPDX license (but not copyright) headers to all files which follow a certain pattern in their existing non-machine-readable header comment. This commit was entirely generated using the command: ``` git ls-files glib/*.[ch] | xargs perl -0777 -pi -e 's/\n \*\n \* This library is free software; you can redistribute it and\/or\n \* modify it under the terms of the GNU Lesser General Public/\n \*\n \* SPDX-License-Identifier: LGPL-2.1-or-later\n \*\n \* This library is free software; you can redistribute it and\/or\n \* modify it under the terms of the GNU Lesser General Public/igs' ``` Signed-off-by: Philip Withnall <pwithnall@endlessos.org> Helps: #1415
2022-05-18 10:15:38 +02:00
* SPDX-License-Identifier: LGPL-2.1-or-later
*
Bug 548967 - 1 bit mutex lock Add support for a mutex lock that consumes only one bit of storage inside of an integer on systems that support futexes. Futex is emulated (at a higher cost) on systems that don't have it -- but only in the contended case.
2010-01-28 17:32:07 +01:00
* 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
glib/: LGPLv2+ -> LGPLv2.1+ All glib/*.{c,h} files have been processed, as well as gtester-report. 12 of those files are not licensed under LGPL: gbsearcharray.h gconstructor.h glibintl.h gmirroringtable.h gscripttable.h gtranslit-data.h gunibreak.h gunichartables.h gunicomp.h gunidecomp.h valgrind.h win_iconv.c Some of them are generated files, some are licensed under a BSD-style license and win_iconv.c is in the public domain. Sub-directories inside glib/: deprecated/: processed in a previous commit glib-mirroring-tab/: already LGPLv2.1+ gnulib/: not modified, the code is copied from gnulib libcharset/: a copy pcre/: a copy tests/: processed in a previous commit https://bugzilla.gnome.org/show_bug.cgi?id=776504
2017-01-05 12:47:07 +01:00
* version 2.1 of the License, or (at your option) any later version.
Bug 548967 - 1 bit mutex lock Add support for a mutex lock that consumes only one bit of storage inside of an integer on systems that support futexes. Futex is emulated (at a higher cost) on systems that don't have it -- but only in the contended case.
2010-01-28 17:32:07 +01:00
*
* 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
Updated FSF's address
2014-01-23 12:58:29 +01:00
* License along with this library; if not, see <http://www.gnu.org/licenses/>.
Bug 548967 - 1 bit mutex lock Add support for a mutex lock that consumes only one bit of storage inside of an integer on systems that support futexes. Futex is emulated (at a higher cost) on systems that don't have it -- but only in the contended case.
2010-01-28 17:32:07 +01:00
*
* Author: Ryan Lortie <desrt@desrt.ca>
*/
#ifndef __G_BITLOCK_H__
#define __G_BITLOCK_H__
#include <glib/gtypes.h>
Make single includes mandatory This has been the official line since 2.17, which seems plenty long enough for a transition phase.
2011-10-12 06:24:46 +02:00
#if !defined (__GLIB_H_INSIDE__) && !defined (GLIB_COMPILATION)
Bug 548967 - 1 bit mutex lock Add support for a mutex lock that consumes only one bit of storage inside of an integer on systems that support futexes. Futex is emulated (at a higher cost) on systems that don't have it -- but only in the contended case.
2010-01-28 17:32:07 +01:00
#error "Only <glib.h> can be included directly."
#endif
G_BEGIN_DECLS
various: add GLIB_AVAILABLE_IN_ALL everywhere else Add the GLIB_AVAILABLE_IN_ALL annotation to all old functions (that haven't already been annotated with the GLIB_AVAILABLE_IN_* macros or a deprecation macro). If we discover in the future that we cannot use only one macro on Windows, it will be an easy sed patch to fix that. https://bugzilla.gnome.org/show_bug.cgi?id=688681
2012-12-06 20:04:59 +01:00
GLIB_AVAILABLE_IN_ALL
gbitlock: fix gtkdoc brokenness
2010-01-30 18:13:50 +01:00
void g_bit_lock (volatile gint *address,
Bug 548967 - 1 bit mutex lock Add support for a mutex lock that consumes only one bit of storage inside of an integer on systems that support futexes. Futex is emulated (at a higher cost) on systems that don't have it -- but only in the contended case.
2010-01-28 17:32:07 +01:00
gint lock_bit);
various: add GLIB_AVAILABLE_IN_ALL everywhere else Add the GLIB_AVAILABLE_IN_ALL annotation to all old functions (that haven't already been annotated with the GLIB_AVAILABLE_IN_* macros or a deprecation macro). If we discover in the future that we cannot use only one macro on Windows, it will be an easy sed patch to fix that. https://bugzilla.gnome.org/show_bug.cgi?id=688681
2012-12-06 20:04:59 +01:00
GLIB_AVAILABLE_IN_ALL
gbitlock: fix gtkdoc brokenness
2010-01-30 18:13:50 +01:00
gboolean g_bit_trylock (volatile gint *address,
Bug 548967 - 1 bit mutex lock Add support for a mutex lock that consumes only one bit of storage inside of an integer on systems that support futexes. Futex is emulated (at a higher cost) on systems that don't have it -- but only in the contended case.
2010-01-28 17:32:07 +01:00
gint lock_bit);
various: add GLIB_AVAILABLE_IN_ALL everywhere else Add the GLIB_AVAILABLE_IN_ALL annotation to all old functions (that haven't already been annotated with the GLIB_AVAILABLE_IN_* macros or a deprecation macro). If we discover in the future that we cannot use only one macro on Windows, it will be an easy sed patch to fix that. https://bugzilla.gnome.org/show_bug.cgi?id=688681
2012-12-06 20:04:59 +01:00
GLIB_AVAILABLE_IN_ALL
gbitlock: fix gtkdoc brokenness
2010-01-30 18:13:50 +01:00
void g_bit_unlock (volatile gint *address,
Bug 548967 - 1 bit mutex lock Add support for a mutex lock that consumes only one bit of storage inside of an integer on systems that support futexes. Futex is emulated (at a higher cost) on systems that don't have it -- but only in the contended case.
2010-01-28 17:32:07 +01:00
gint lock_bit);
various: add GLIB_AVAILABLE_IN_ALL everywhere else Add the GLIB_AVAILABLE_IN_ALL annotation to all old functions (that haven't already been annotated with the GLIB_AVAILABLE_IN_* macros or a deprecation macro). If we discover in the future that we cannot use only one macro on Windows, it will be an easy sed patch to fix that. https://bugzilla.gnome.org/show_bug.cgi?id=688681
2012-12-06 20:04:59 +01:00
GLIB_AVAILABLE_IN_ALL
Implement pointer sized bitlocks Based on a patch from Alexander Larsson. https://bugzilla.gnome.org/show_bug.cgi?id=651467
2011-05-25 11:08:20 +02:00
void g_pointer_bit_lock (volatile void *address,
gint lock_bit);
gbitlock: add g_pointer_bit_lock_and_get() Usually, after g_pointer_bit_lock() we want to read the pointer that we have. In many cases, when we g_pointer_bit_lock() a pointer, we can access it afterwards without atomic, as nobody is going to modify the pointer then. However, gdataset also supports g_datalist_set_flags(), so the pointer may change at any time and we must always use atomics to read it. For that reason, g_datalist_lock_and_get() does an atomic read right after g_pointer_bit_lock(). g_pointer_bit_lock() can easily access the value that it just set. Add g_pointer_bit_lock_and_get() which can return the value that gets set afterwards. Aside from saving the second atomic-get in certain scenarios, the returned value is also atomically the one that we just set.
2024-01-05 14:05:58 +01:00
GLIB_AVAILABLE_IN_2_80
void g_pointer_bit_lock_and_get (gpointer address,
guint lock_bit,
guintptr *out_ptr);
various: add GLIB_AVAILABLE_IN_ALL everywhere else Add the GLIB_AVAILABLE_IN_ALL annotation to all old functions (that haven't already been annotated with the GLIB_AVAILABLE_IN_* macros or a deprecation macro). If we discover in the future that we cannot use only one macro on Windows, it will be an easy sed patch to fix that. https://bugzilla.gnome.org/show_bug.cgi?id=688681
2012-12-06 20:04:59 +01:00
GLIB_AVAILABLE_IN_ALL
Implement pointer sized bitlocks Based on a patch from Alexander Larsson. https://bugzilla.gnome.org/show_bug.cgi?id=651467
2011-05-25 11:08:20 +02:00
gboolean g_pointer_bit_trylock (volatile void *address,
gint lock_bit);
various: add GLIB_AVAILABLE_IN_ALL everywhere else Add the GLIB_AVAILABLE_IN_ALL annotation to all old functions (that haven't already been annotated with the GLIB_AVAILABLE_IN_* macros or a deprecation macro). If we discover in the future that we cannot use only one macro on Windows, it will be an easy sed patch to fix that. https://bugzilla.gnome.org/show_bug.cgi?id=688681
2012-12-06 20:04:59 +01:00
GLIB_AVAILABLE_IN_ALL
Implement pointer sized bitlocks Based on a patch from Alexander Larsson. https://bugzilla.gnome.org/show_bug.cgi?id=651467
2011-05-25 11:08:20 +02:00
void g_pointer_bit_unlock (volatile void *address,
gint lock_bit);
gbitlock: add g_pointer_bit_unlock_and_set() and g_pointer_bit_lock_mask_ptr() The existing g_pointer_bit_lock() and g_pointer_bit_unlock() API requires the user to understand/reimplement how bits of the pointer get mangled. Add helper functions for that. The useful thing to do with g_pointer_bit_lock() API is to get/set pointers while having it locked. For example, to set the pointer a user can do: g_pointer_bit_lock (&lockptr, lock_bit); ptr2 = set_bit_pointer_as_if_locked(ptr, lock_bit); g_atomic_pointer_set (&lockptr, ptr2); g_pointer_bit_unlock (&lockptr, lock_bit); That has several problems: - it requires one extra atomic operations (3 instead of 2, in the non-contended case). - the first g_atomic_pointer_set() already wakes blocked threads, which find themselves still being locked and needs to go back to sleep. - the user needs to re-implement how bit-locking mangles the pointer so that it looks as if it were locked. - while the user tries to re-implement what glib does to mangle the pointer for bitlocking, there is no immediate guarantee that they get it right. Now we can do instead: g_pointer_bit_lock(&lockptr, lock_bit); g_pointer_bit_unlock_and_set(&lockptr, lock_bit, ptr, 0); This will also emit a critical if @ptr has the locked bit set. g_pointer_bit_lock() really only works with pointers that have a certain alignment, and the lowest bits unset. Otherwise, there is no space to encode both the locking and all pointer values. The new assertion helps to catch such bugs. Also, g_pointer_bit_lock_mask_ptr() is here, so we can do: g_pointer_bit_lock(&lockptr, lock_bit); /* set a pointer separately, when g_pointer_bit_unlock_and_set() is unsuitable. */ g_atomic_pointer_set(&lockptr, g_pointer_bit_lock_mask_ptr(ptr, lock_bit, TRUE, 0, NULL)); ... g_pointer_bit_unlock(&lockptr, lock_bit); and: g_pointer_bit_lock(&lockptr, lock_bit); /* read the real pointer after getting the lock. */ ptr = g_pointer_bit_lock_mask_ptr(lockptr, lock_bit, FALSE, 0, NULL)); ... g_pointer_bit_unlock(&lockptr, lock_bit);
2023-12-23 21:43:47 +01:00
GLIB_AVAILABLE_IN_2_80
gpointer g_pointer_bit_lock_mask_ptr (gpointer ptr,
guint lock_bit,
gboolean set,
guintptr preserve_mask,
gpointer preserve_ptr);
GLIB_AVAILABLE_IN_2_80
void g_pointer_bit_unlock_and_set (void *address,
guint lock_bit,
gpointer ptr,
guintptr preserve_mask);
Implement pointer sized bitlocks Based on a patch from Alexander Larsson. https://bugzilla.gnome.org/show_bug.cgi?id=651467
2011-05-25 11:08:20 +02:00
#ifdef __GNUC__
#define g_pointer_bit_lock(address, lock_bit) \
(G_GNUC_EXTENSION ({ \
G_STATIC_ASSERT (sizeof *(address) == sizeof (gpointer)); \
g_pointer_bit_lock ((address), (lock_bit)); \
}))
gbitlock: add g_pointer_bit_lock_and_get() Usually, after g_pointer_bit_lock() we want to read the pointer that we have. In many cases, when we g_pointer_bit_lock() a pointer, we can access it afterwards without atomic, as nobody is going to modify the pointer then. However, gdataset also supports g_datalist_set_flags(), so the pointer may change at any time and we must always use atomics to read it. For that reason, g_datalist_lock_and_get() does an atomic read right after g_pointer_bit_lock(). g_pointer_bit_lock() can easily access the value that it just set. Add g_pointer_bit_lock_and_get() which can return the value that gets set afterwards. Aside from saving the second atomic-get in certain scenarios, the returned value is also atomically the one that we just set.
2024-01-05 14:05:58 +01:00
#define g_pointer_bit_lock_and_get(address, lock_bit, out_ptr) \
(G_GNUC_EXTENSION ({ \
G_STATIC_ASSERT (sizeof *(address) == sizeof (gpointer)); \
g_pointer_bit_lock_and_get ((address), (lock_bit), (out_ptr)); \
}))
Implement pointer sized bitlocks Based on a patch from Alexander Larsson. https://bugzilla.gnome.org/show_bug.cgi?id=651467
2011-05-25 11:08:20 +02:00
#define g_pointer_bit_trylock(address, lock_bit) \
(G_GNUC_EXTENSION ({ \
G_STATIC_ASSERT (sizeof *(address) == sizeof (gpointer)); \
g_pointer_bit_trylock ((address), (lock_bit)); \
}))
#define g_pointer_bit_unlock(address, lock_bit) \
(G_GNUC_EXTENSION ({ \
G_STATIC_ASSERT (sizeof *(address) == sizeof (gpointer)); \
g_pointer_bit_unlock ((address), (lock_bit)); \
}))
gbitlock: add g_pointer_bit_unlock_and_set() and g_pointer_bit_lock_mask_ptr() The existing g_pointer_bit_lock() and g_pointer_bit_unlock() API requires the user to understand/reimplement how bits of the pointer get mangled. Add helper functions for that. The useful thing to do with g_pointer_bit_lock() API is to get/set pointers while having it locked. For example, to set the pointer a user can do: g_pointer_bit_lock (&lockptr, lock_bit); ptr2 = set_bit_pointer_as_if_locked(ptr, lock_bit); g_atomic_pointer_set (&lockptr, ptr2); g_pointer_bit_unlock (&lockptr, lock_bit); That has several problems: - it requires one extra atomic operations (3 instead of 2, in the non-contended case). - the first g_atomic_pointer_set() already wakes blocked threads, which find themselves still being locked and needs to go back to sleep. - the user needs to re-implement how bit-locking mangles the pointer so that it looks as if it were locked. - while the user tries to re-implement what glib does to mangle the pointer for bitlocking, there is no immediate guarantee that they get it right. Now we can do instead: g_pointer_bit_lock(&lockptr, lock_bit); g_pointer_bit_unlock_and_set(&lockptr, lock_bit, ptr, 0); This will also emit a critical if @ptr has the locked bit set. g_pointer_bit_lock() really only works with pointers that have a certain alignment, and the lowest bits unset. Otherwise, there is no space to encode both the locking and all pointer values. The new assertion helps to catch such bugs. Also, g_pointer_bit_lock_mask_ptr() is here, so we can do: g_pointer_bit_lock(&lockptr, lock_bit); /* set a pointer separately, when g_pointer_bit_unlock_and_set() is unsuitable. */ g_atomic_pointer_set(&lockptr, g_pointer_bit_lock_mask_ptr(ptr, lock_bit, TRUE, 0, NULL)); ... g_pointer_bit_unlock(&lockptr, lock_bit); and: g_pointer_bit_lock(&lockptr, lock_bit); /* read the real pointer after getting the lock. */ ptr = g_pointer_bit_lock_mask_ptr(lockptr, lock_bit, FALSE, 0, NULL)); ... g_pointer_bit_unlock(&lockptr, lock_bit);
2023-12-23 21:43:47 +01:00
#define g_pointer_bit_unlock_and_set(address, lock_bit, ptr, preserve_mask) \
(G_GNUC_EXTENSION ({ \
G_STATIC_ASSERT (sizeof *(address) == sizeof (gpointer)); \
g_pointer_bit_unlock_and_set ((address), (lock_bit), (ptr), (preserve_mask)); \
}))
Implement pointer sized bitlocks Based on a patch from Alexander Larsson. https://bugzilla.gnome.org/show_bug.cgi?id=651467
2011-05-25 11:08:20 +02:00
#endif
Bug 548967 - 1 bit mutex lock Add support for a mutex lock that consumes only one bit of storage inside of an integer on systems that support futexes. Futex is emulated (at a higher cost) on systems that don't have it -- but only in the contended case.
2010-01-28 17:32:07 +01:00
G_END_DECLS
#endif /* __G_BITLOCK_H_ */
Reference in New Issue Copy Permalink