#include <windows.h>
#endif /* G_OS_WIN32 */
+#ifdef HAVE_MACH_MACH_TIME_H
+#include <mach/mach_time.h>
+#endif
+
#include "glib_trace.h"
#include "gmain.h"
gint ref_count;
+ GHashTable *sources; /* guint -> GSource */
+
GPtrArray *pending_dispatches;
gint timeout; /* Timeout for current iteration */
guint next_id;
- GHashTable *overflow_used_source_ids; /* set<guint> */
GList *source_lists;
gint in_check_or_prepare;
GSource *source;
GList *sl_iter;
GSourceList *list;
- gint i;
+ guint i;
g_return_if_fail (context != NULL);
g_return_if_fail (g_atomic_int_get (&context->ref_count) > 0);
}
g_list_free (context->source_lists);
- if (context->overflow_used_source_ids)
- g_hash_table_destroy (context->overflow_used_source_ids);
+ g_hash_table_destroy (context->sources);
g_mutex_clear (&context->mutex);
g_mutex_init (&context->mutex);
g_cond_init (&context->cond);
+ context->sources = g_hash_table_new (NULL, NULL);
context->owner = NULL;
context->waiters = NULL;
context->source_lists = g_list_remove (context->source_lists, source_list);
g_slice_free (GSourceList, source_list);
}
-
- if (context->overflow_used_source_ids)
- g_hash_table_remove (context->overflow_used_source_ids,
- GUINT_TO_POINTER (source->source_id));
-
-}
-
-static void
-assign_source_id_unlocked (GMainContext *context,
- GSource *source)
-{
- guint id;
-
- /* Are we about to overflow back to 0?
- * See https://bugzilla.gnome.org/show_bug.cgi?id=687098
- */
- if (G_UNLIKELY (context->next_id == G_MAXUINT &&
- context->overflow_used_source_ids == NULL))
- {
- GSourceIter iter;
- GSource *source;
-
- context->overflow_used_source_ids = g_hash_table_new (NULL, NULL);
-
- g_source_iter_init (&iter, context, FALSE);
- while (g_source_iter_next (&iter, &source))
- {
- g_hash_table_add (context->overflow_used_source_ids,
- GUINT_TO_POINTER (source->source_id));
- }
- id = G_MAXUINT;
- g_hash_table_add (context->overflow_used_source_ids, GUINT_TO_POINTER (id));
- }
- else if (context->overflow_used_source_ids == NULL)
- {
- id = context->next_id++;
- }
- else
- {
- /*
- * If we overran G_MAXUINT, we fall back to randomly probing the
- * source ids for the current context. This will be slower the more
- * sources there are, but we're mainly concerned right now about
- * correctness and code size. There's time for a more clever solution
- * later.
- */
- do
- id = g_random_int ();
- while (id == 0 ||
- g_hash_table_contains (context->overflow_used_source_ids,
- GUINT_TO_POINTER (id)));
- g_hash_table_add (context->overflow_used_source_ids, GUINT_TO_POINTER (id));
- }
-
- source->source_id = id;
}
static guint
gboolean do_wakeup)
{
GSList *tmp_list;
+ guint id;
+
+ /* The counter may have wrapped, so we must ensure that we do not
+ * reuse the source id of an existing source.
+ */
+ do
+ id = context->next_id++;
+ while (id == 0 || g_hash_table_contains (context->sources, GUINT_TO_POINTER (id)));
source->context = context;
- assign_source_id_unlocked (context, source);
+ source->source_id = id;
source->ref_count++;
+
+ g_hash_table_insert (context->sources, GUINT_TO_POINTER (id), source);
+
source_add_to_context (source, context);
if (!SOURCE_BLOCKED (source))
* the @revents field in the #GPollFD struct and return %TRUE if events need
* to be processed.
*
+ * This API is only intended to be used by implementations of #GSource.
+ * Do not call this API on a #GSource that you did not create.
+ *
* Using this API forces the linear scanning of event sources on each
* main loop iteration. Newly-written event sources should try to use
* g_source_add_unix_fd() instead of this API.
*
* Removes a file descriptor from the set of file descriptors polled for
* this source.
+ *
+ * This API is only intended to be used by implementations of #GSource.
+ * Do not call this API on a #GSource that you did not create.
**/
void
g_source_remove_poll (GSource *source,
* @source will hold a reference on @child_source while @child_source
* is attached to it.
*
+ * This API is only intended to be used by implementations of #GSource.
+ * Do not call this API on a #GSource that you did not create.
+ *
* Since: 2.28
**/
void
*
* Detaches @child_source from @source and destroys it.
*
+ * This API is only intended to be used by implementations of #GSource.
+ * Do not call this API on a #GSource that you did not create.
+ *
* Since: 2.28
**/
void
* source will be dispatched if it is ready to be dispatched and no
* sources at a higher (numerically smaller) priority are ready to be
* dispatched.
+ *
+ * A child source always has the same priority as its parent. It is not
+ * permitted to change the priority of a source once it has been added
+ * as a child of another source.
**/
void
g_source_set_priority (GSource *source,
GMainContext *context;
g_return_if_fail (source != NULL);
+ g_return_if_fail (source->priv->parent_source == NULL);
context = source->context;
* for both sources is reached during the same main context iteration
* then the order of dispatch is undefined.
*
+ * This API is only intended to be used by implementations of #GSource.
+ * Do not call this API on a #GSource that you did not create.
+ *
* Since: 2.36
**/
void
*
* It is permitted to call this function multiple times, but is not
* recommended due to the potential performance impact. For example,
- * one could change the name in the "check" function of a #GSourceFuncs
+ * one could change the name in the "check" function of a #GSourceFuncs
* to include details like the event type in the source name.
*
+ * Use caution if changing the name while another thread may be
+ * accessing it with g_source_get_name(); that function does not copy
+ * the value, and changing the value will free it while the other thread
+ * may be attempting to use it.
+ *
* Since: 2.26
**/
void
g_source_set_name (GSource *source,
const char *name)
{
+ GMainContext *context;
+
g_return_if_fail (source != NULL);
+ context = source->context;
+
+ if (context)
+ LOCK_CONTEXT (context);
+
/* setting back to NULL is allowed, just because it's
* weird if get_name can return NULL but you can't
* set that.
g_free (source->name);
source->name = g_strdup (name);
+
+ if (context)
+ UNLOCK_CONTEXT (context);
}
/**
* g_source_get_name:
* @source: a #GSource
*
- * Gets a name for the source, used in debugging and profiling.
- * The name may be #NULL if it has never been set with
- * g_source_set_name().
+ * Gets a name for the source, used in debugging and profiling. The
+ * name may be #NULL if it has never been set with g_source_set_name().
*
* Returns: the name of the source
+ *
* Since: 2.26
**/
const char *
* This is a convenience utility to set source names from the return
* value of g_idle_add(), g_timeout_add(), etc.
*
+ * It is a programmer error to attempt to set the name of a non-existent
+ * source.
+ *
+ * More specifically: source IDs can be reissued after a source has been
+ * destroyed and therefore it is never valid to use this function with a
+ * source ID which may have already been removed. An example is when
+ * scheduling an idle to run in another thread with g_idle_add(): the
+ * idle may already have run and been removed by the time this function
+ * is called on its (now invalid) source ID. This source ID may have
+ * been reissued, leading to the operation being performed against the
+ * wrong source.
+ *
* Since: 2.26
**/
void
if (!SOURCE_DESTROYED (source))
g_warning (G_STRLOC ": ref_count == 0, but source was still attached to a context!");
source_remove_from_context (source, context);
+
+ g_hash_table_remove (context->sources, GUINT_TO_POINTER (source->source_id));
}
if (source->source_funcs->finalize)
g_slist_free_full (source->priv->fds, g_free);
+ while (source->priv->child_sources)
+ {
+ GSource *child_source = source->priv->child_sources->data;
+
+ source->priv->child_sources =
+ g_slist_remove (source->priv->child_sources, child_source);
+ child_source->priv->parent_source = NULL;
+
+ g_source_unref_internal (child_source, context, have_lock);
+ }
+
g_slice_free (GSourcePrivate, source->priv);
source->priv = NULL;
/**
* g_main_context_find_source_by_id:
* @context: (allow-none): a #GMainContext (if %NULL, the default context will be used)
- * @source_id: the source ID, as returned by g_source_get_id().
- *
+ * @source_id: the source ID, as returned by g_source_get_id().
+ *
* Finds a #GSource given a pair of context and ID.
- *
- * Returns: (transfer none): the #GSource if found, otherwise, %NULL
+ *
+ * It is a programmer error to attempt to lookup a non-existent source.
+ *
+ * More specifically: source IDs can be reissued after a source has been
+ * destroyed and therefore it is never valid to use this function with a
+ * source ID which may have already been removed. An example is when
+ * scheduling an idle to run in another thread with g_idle_add(): the
+ * idle may already have run and been removed by the time this function
+ * is called on its (now invalid) source ID. This source ID may have
+ * been reissued, leading to the operation being performed against the
+ * wrong source.
+ *
+ * Returns: (transfer none): the #GSource
**/
GSource *
g_main_context_find_source_by_id (GMainContext *context,
- guint source_id)
+ guint source_id)
{
- GSourceIter iter;
GSource *source;
-
+
g_return_val_if_fail (source_id > 0, NULL);
if (context == NULL)
context = g_main_context_default ();
-
- LOCK_CONTEXT (context);
-
- g_source_iter_init (&iter, context, FALSE);
- while (g_source_iter_next (&iter, &source))
- {
- if (!SOURCE_DESTROYED (source) &&
- source->source_id == source_id)
- break;
- }
- g_source_iter_clear (&iter);
+ LOCK_CONTEXT (context);
+ source = g_hash_table_lookup (context->sources, GUINT_TO_POINTER (source_id));
UNLOCK_CONTEXT (context);
+ if (source && SOURCE_DESTROYED (source))
+ source = NULL;
+
return source;
}
*
* It is a programmer error to attempt to remove a non-existent source.
*
+ * More specifically: source IDs can be reissued after a source has been
+ * destroyed and therefore it is never valid to use this function with a
+ * source ID which may have already been removed. An example is when
+ * scheduling an idle to run in another thread with g_idle_add(): the
+ * idle may already have run and been removed by the time this function
+ * is called on its (now invalid) source ID. This source ID may have
+ * been reissued, leading to the operation being performed against the
+ * wrong source.
+ *
* Returns: For historical reasons, this function always returns %TRUE
**/
gboolean
* It is not necessary to remove the fd before destroying the source; it
* will be cleaned up automatically.
*
+ * This API is only intended to be used by implementations of #GSource.
+ * Do not call this API on a #GSource that you did not create.
+ *
* As the name suggests, this function is not available on Windows.
*
* Returns: an opaque tag
* If you want to remove a fd, don't set its event mask to zero.
* Instead, call g_source_remove_unix_fd().
*
+ * This API is only intended to be used by implementations of #GSource.
+ * Do not call this API on a #GSource that you did not create.
+ *
* As the name suggests, this function is not available on Windows.
*
* Since: 2.36
* watched while keeping the same source around. In the normal case you
* will just want to destroy the source.
*
+ * This API is only intended to be used by implementations of #GSource.
+ * Do not call this API on a #GSource that you did not create.
+ *
* As the name suggests, this function is not available on Windows.
*
* Since: 2.36
* The return value of this function is only defined when the function
* is called from the check or dispatch functions for @source.
*
+ * This API is only intended to be used by implementations of #GSource.
+ * Do not call this API on a #GSource that you did not create.
+ *
* As the name suggests, this function is not available on Windows.
*
* Returns: the conditions reported on the fd
return (((gint64) tv.tv_sec) * 1000000) + tv.tv_usec;
}
-#ifdef G_OS_WIN32
+/**
+ * g_get_monotonic_time:
+ *
+ * Queries the system monotonic time.
+ *
+ * The monotonic clock will always increase and doesn't suffer
+ * discontinuities when the user (or NTP) changes the system time. It
+ * may or may not continue to tick during times where the machine is
+ * suspended.
+ *
+ * We try to use the clock that corresponds as closely as possible to
+ * the passage of time as measured by system calls such as poll() but it
+ * may not always be possible to do this.
+ *
+ * Returns: the monotonic time, in microseconds
+ *
+ * Since: 2.28
+ **/
+#if defined (G_OS_WIN32)
static ULONGLONG (*g_GetTickCount64) (void) = NULL;
static guint32 g_win32_tick_epoch = 0;
g_GetTickCount64 = (void *) GetProcAddress (kernel32, "GetTickCount64");
g_win32_tick_epoch = ((guint32)GetTickCount()) >> 31;
}
-#endif
-/**
- * g_get_monotonic_time:
- *
- * Queries the system monotonic time, if available.
- *
- * On POSIX systems with clock_gettime() and `CLOCK_MONOTONIC` this call
- * is a very shallow wrapper for that. Otherwise, we make a best effort
- * that probably involves returning the wall clock time (with at least
- * microsecond accuracy, subject to the limitations of the OS kernel).
- *
- * It's important to note that POSIX `CLOCK_MONOTONIC` does
- * not count time spent while the machine is suspended.
- *
- * On Windows, "limitations of the OS kernel" is a rather substantial
- * statement. Depending on the configuration of the system, the wall
- * clock time is updated as infrequently as 64 times a second (which
- * is approximately every 16ms). Also, on XP (but not on Vista or later)
- * the monotonic clock is locally monotonic, but may differ in exact
- * value between processes due to timer wrap handling.
- *
- * Returns: the monotonic time, in microseconds
- *
- * Since: 2.28
- **/
gint64
g_get_monotonic_time (void)
{
-#ifdef HAVE_CLOCK_GETTIME
- /* librt clock_gettime() is our first choice */
- struct timespec ts;
-
-#ifdef CLOCK_MONOTONIC
- clock_gettime (CLOCK_MONOTONIC, &ts);
-#else
- clock_gettime (CLOCK_REALTIME, &ts);
-#endif
-
- /* In theory monotonic time can have any epoch.
- *
- * glib presently assumes the following:
- *
- * 1) The epoch comes some time after the birth of Jesus of Nazareth, but
- * not more than 10000 years later.
- *
- * 2) The current time also falls sometime within this range.
- *
- * These two reasonable assumptions leave us with a maximum deviation from
- * the epoch of 10000 years, or 315569520000000000 seconds.
- *
- * If we restrict ourselves to this range then the number of microseconds
- * will always fit well inside the constraints of a int64 (by a factor of
- * about 29).
- *
- * If you actually hit the following assertion, probably you should file a
- * bug against your operating system for being excessively silly.
- **/
- g_assert (G_GINT64_CONSTANT (-315569520000000000) < ts.tv_sec &&
- ts.tv_sec < G_GINT64_CONSTANT (315569520000000000));
-
- return (((gint64) ts.tv_sec) * 1000000) + (ts.tv_nsec / 1000);
-
-#elif defined (G_OS_WIN32)
guint64 ticks;
guint32 ticks32;
* is to use it to interpolate the lower precision clocks. Firefox does something like
* this:
* https://bugzilla.mozilla.org/show_bug.cgi?id=363258
- *
+ *
* However this seems quite complicated, so we're not doing this right now.
*
* The approach we take instead is to use the TGT timer, extending it to 64bit
* This means that:
* - We have a globally consistent monotonic clock on Vista and later
* - We have a locally monotonic clock on XP
- * - Apps that need higher precision in timeouts and clock reads can call
+ * - Apps that need higher precision in timeouts and clock reads can call
* timeBeginPeriod() to increase it as much as they want
*/
ticks = g_GetTickCount64 ();
ticks32 = timeGetTime();
- /* GTC64 and TGT are sampled at different times, however they
- * have the same base and source (msecs since system boot).
+ /* GTC64 and TGT are sampled at different times, however they
+ * have the same base and source (msecs since system boot).
* They can differ by as much as -16 to +16 msecs.
- * We can't just inject the low bits into the 64bit counter
+ * We can't just inject the low bits into the 64bit counter
* as one of the counters can have wrapped in 32bit space and
* the other not. Instead we calculate the signed difference
* in 32bit space and apply that difference to the 64bit counter.
/* We could do some 2's complement hack, but we play it safe */
if (ticks32 - ticks_as_32bit <= G_MAXINT32)
- ticks += ticks32 - ticks_as_32bit;
+ ticks += ticks32 - ticks_as_32bit;
else
- ticks -= ticks_as_32bit - ticks32;
+ ticks -= ticks_as_32bit - ticks32;
}
else
{
* processes.
*/
if ((ticks32 >> 31) != (epoch & 1))
- {
- epoch++;
- g_atomic_int_set (&g_win32_tick_epoch, epoch);
- }
+ {
+ epoch++;
+ g_atomic_int_set (&g_win32_tick_epoch, epoch);
+ }
ticks = (guint64)ticks32 | ((guint64)epoch) << 31;
}
return ticks * 1000;
+}
+#elif defined(HAVE_MACH_MACH_TIME_H) /* Mac OS */
+gint64
+g_get_monotonic_time (void)
+{
+ static mach_timebase_info_data_t timebase_info;
-#else /* !HAVE_CLOCK_GETTIME && ! G_OS_WIN32*/
+ if (timebase_info.denom == 0)
+ {
+ /* This is a fraction that we must use to scale
+ * mach_absolute_time() by in order to reach nanoseconds.
+ *
+ * We've only ever observed this to be 1/1, but maybe it could be
+ * 1000/1 if mach time is microseconds already, or 1/1000 if
+ * picoseconds. Try to deal nicely with that.
+ */
+ mach_timebase_info (&timebase_info);
- GTimeVal tv;
+ /* We actually want microseconds... */
+ if (timebase_info.numer % 1000 == 0)
+ timebase_info.numer /= 1000;
+ else
+ timebase_info.denom *= 1000;
- g_get_current_time (&tv);
+ /* We want to make the numer 1 to avoid having to multiply... */
+ if (timebase_info.denom % timebase_info.numer == 0)
+ {
+ timebase_info.denom /= timebase_info.numer;
+ timebase_info.numer = 1;
+ }
+ else
+ {
+ /* We could just multiply by timebase_info.numer below, but why
+ * bother for a case that may never actually exist...
+ *
+ * Plus -- performing the multiplication would risk integer
+ * overflow. If we ever actually end up in this situation, we
+ * should more carefully evaluate the correct course of action.
+ */
+ mach_timebase_info (&timebase_info); /* Get a fresh copy for a better message */
+ g_error ("Got weird mach timebase info of %d/%d. Please file a bug against GLib.",
+ timebase_info.numer, timebase_info.denom);
+ }
+ }
- return (((gint64) tv.tv_sec) * 1000000) + tv.tv_usec;
-#endif
+ return mach_absolute_time () / timebase_info.denom;
}
+#else
+gint64
+g_get_monotonic_time (void)
+{
+ struct timespec ts;
+ gint result;
+
+ result = clock_gettime (CLOCK_MONOTONIC, &ts);
+
+ if G_UNLIKELY (result != 0)
+ g_error ("GLib requires working CLOCK_MONOTONIC");
+
+ return (((gint64) ts.tv_sec) * 1000000) + (ts.tv_nsec / 1000);
+}
+#endif
static void
g_main_dispatch_free (gpointer dispatch)
if (context == NULL)
context = g_main_context_default ();
+ if G_UNLIKELY (cond != &context->cond || mutex != &context->mutex)
+ {
+ static gboolean warned;
+
+ if (!warned)
+ {
+ g_critical ("WARNING!! g_main_context_wait() will be removed in a future release. "
+ "If you see this message, please file a bug immediately.");
+ warned = TRUE;
+ }
+ }
+
loop_internal_waiter = (mutex == &context->mutex);
if (!loop_internal_waiter)
* @context: a #GMainContext
* @priority: location to store priority of highest priority
* source already ready.
- *
+ *
* Prepares to poll sources within a main loop. The resulting information
* for polling is determined by calling g_main_context_query ().
- *
+ *
+ * You must have successfully acquired the context with
+ * g_main_context_acquire() before you may call this function.
+ *
* Returns: %TRUE if some source is ready to be dispatched
* prior to polling.
**/
g_main_context_prepare (GMainContext *context,
gint *priority)
{
- gint i;
+ guint i;
gint n_ready = 0;
gint current_priority = G_MAXINT;
GSource *source;
* @fds: (out caller-allocates) (array length=n_fds): location to
* store #GPollFD records that need to be polled.
* @n_fds: length of @fds.
- *
+ *
* Determines information necessary to poll this main loop.
- *
+ *
+ * You must have successfully acquired the context with
+ * g_main_context_acquire() before you may call this function.
+ *
* Returns: the number of records actually stored in @fds,
* or, if more than @n_fds records need to be stored, the number
* of records that need to be stored.
* @fds: (array length=n_fds): array of #GPollFD's that was passed to
* the last call to g_main_context_query()
* @n_fds: return value of g_main_context_query()
- *
+ *
* Passes the results of polling back to the main loop.
- *
+ *
+ * You must have successfully acquired the context with
+ * g_main_context_acquire() before you may call this function.
+ *
* Returns: %TRUE if some sources are ready to be dispatched.
**/
gboolean
/**
* g_main_context_dispatch:
* @context: a #GMainContext
- *
+ *
* Dispatches all pending sources.
+ *
+ * You must have successfully acquired the context with
+ * g_main_context_acquire() before you may call this function.
**/
void
g_main_context_dispatch (GMainContext *context)
if (n_fds || timeout != 0)
{
#ifdef G_MAIN_POLL_DEBUG
+ poll_timer = NULL;
if (_g_main_poll_debug)
{
g_print ("polling context=%p n=%d timeout=%d\n",
projects / platform / upstream / glib.git / blobdiff