glib/gio/gioscheduler.c - nest-cam/4320010/glib - Git at Google

 /* GIO - GLib Input, Output and Streaming Library
  *
  * Copyright (C) 2006-2007 Red Hat, Inc.
  *
  * 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 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 <http://www.gnu.org/licenses/>.
  *
  * Author: Alexander Larsson <alexl@redhat.com>
  */

 #include "config.h"

 #include "gioscheduler.h"
 #include "gcancellable.h"
 #include "gtask.h"

 /**
  * SECTION:gioscheduler
  * @short_description: I/O Scheduler
  * @include: gio/gio.h
  *
  * As of GLib 2.36, #GIOScheduler is deprecated in favor of
  * #GThreadPool and #GTask.
  *
  * Schedules asynchronous I/O operations. #GIOScheduler integrates
  * into the main event loop (#GMainLoop) and uses threads.
  */

 struct _GIOSchedulerJob {
   GList *active_link;
   GTask *task;

   GIOSchedulerJobFunc job_func;
   gpointer data;
   GDestroyNotify destroy_notify;

   GCancellable *cancellable;
   gulong cancellable_id;
   GMainContext *context;
 };

 G_LOCK_DEFINE_STATIC(active_jobs);
 static GList *active_jobs = NULL;

 static void
 g_io_job_free (GIOSchedulerJob *job)
 {
   if (job->destroy_notify)
     job->destroy_notify (job->data);

   G_LOCK (active_jobs);
   active_jobs = g_list_delete_link (active_jobs, job->active_link);
   G_UNLOCK (active_jobs);

   if (job->cancellable)
     g_object_unref (job->cancellable);
   g_main_context_unref (job->context);
   g_slice_free (GIOSchedulerJob, job);
 }

 static void
 io_job_thread (GTask         *task,
                gpointer       source_object,
                gpointer       task_data,
                GCancellable  *cancellable)
 {
   GIOSchedulerJob *job = task_data;
   gboolean result;

   if (job->cancellable)
     g_cancellable_push_current (job->cancellable);

   do
     {
       result = job->job_func (job, job->cancellable, job->data);
     }
   while (result);

   if (job->cancellable)
     g_cancellable_pop_current (job->cancellable);
 }

 /**
  * g_io_scheduler_push_job:
  * @job_func: a #GIOSchedulerJobFunc.
  * @user_data: data to pass to @job_func
  * @notify: (allow-none): a #GDestroyNotify for @user_data, or %NULL
  * @io_priority: the [I/O priority][io-priority]
  * of the request.
  * @cancellable: optional #GCancellable object, %NULL to ignore.
  *
  * Schedules the I/O job to run in another thread.
  *
  * @notify will be called on @user_data after @job_func has returned,
  * regardless whether the job was cancelled or has run to completion.
  *
  * If @cancellable is not %NULL, it can be used to cancel the I/O job
  * by calling g_cancellable_cancel() or by calling
  * g_io_scheduler_cancel_all_jobs().
  *
  * Deprecated: use #GThreadPool or g_task_run_in_thread()
  **/
 void
 g_io_scheduler_push_job (GIOSchedulerJobFunc  job_func,
 			 gpointer             user_data,
 			 GDestroyNotify       notify,
 			 gint                 io_priority,
 			 GCancellable        *cancellable)
 {
   GIOSchedulerJob *job;
   GTask *task;

   g_return_if_fail (job_func != NULL);

   job = g_slice_new0 (GIOSchedulerJob);
   job->job_func = job_func;
   job->data = user_data;
   job->destroy_notify = notify;

   if (cancellable)
     job->cancellable = g_object_ref (cancellable);

   job->context = g_main_context_ref_thread_default ();

   G_LOCK (active_jobs);
   active_jobs = g_list_prepend (active_jobs, job);
   job->active_link = active_jobs;
   G_UNLOCK (active_jobs);

   task = g_task_new (NULL, cancellable, NULL, NULL);
 G_GNUC_BEGIN_IGNORE_DEPRECATIONS
   g_task_set_source_tag (task, g_io_scheduler_push_job);
 G_GNUC_END_IGNORE_DEPRECATIONS
   g_task_set_task_data (task, job, (GDestroyNotify)g_io_job_free);
   g_task_set_priority (task, io_priority);
   g_task_run_in_thread (task, io_job_thread);
   g_object_unref (task);
 }

 /**
  * g_io_scheduler_cancel_all_jobs:
  *
  * Cancels all cancellable I/O jobs.
  *
  * A job is cancellable if a #GCancellable was passed into
  * g_io_scheduler_push_job().
  *
  * Deprecated: You should never call this function, since you don't
  * know how other libraries in your program might be making use of
  * gioscheduler.
  **/
 void
 g_io_scheduler_cancel_all_jobs (void)
 {
   GList *cancellable_list, *l;

   G_LOCK (active_jobs);
   cancellable_list = NULL;
   for (l = active_jobs; l != NULL; l = l->next)
     {
       GIOSchedulerJob *job = l->data;
       if (job->cancellable)
 	cancellable_list = g_list_prepend (cancellable_list,
 					   g_object_ref (job->cancellable));
     }
   G_UNLOCK (active_jobs);

   for (l = cancellable_list; l != NULL; l = l->next)
     {
       GCancellable *c = l->data;
       g_cancellable_cancel (c);
       g_object_unref (c);
     }
   g_list_free (cancellable_list);
 }

 typedef struct {
   GSourceFunc func;
   gboolean ret_val;
   gpointer data;
   GDestroyNotify notify;

   GMutex ack_lock;
   GCond ack_condition;
   gboolean ack;
 } MainLoopProxy;

 static gboolean
 mainloop_proxy_func (gpointer data)
 {
   MainLoopProxy *proxy = data;

   proxy->ret_val = proxy->func (proxy->data);

   if (proxy->notify)
     proxy->notify (proxy->data);

   g_mutex_lock (&proxy->ack_lock);
   proxy->ack = TRUE;
   g_cond_signal (&proxy->ack_condition);
   g_mutex_unlock (&proxy->ack_lock);

   return FALSE;
 }

 static void
 mainloop_proxy_free (MainLoopProxy *proxy)
 {
   g_mutex_clear (&proxy->ack_lock);
   g_cond_clear (&proxy->ack_condition);
   g_free (proxy);
 }

 /**
  * g_io_scheduler_job_send_to_mainloop:
  * @job: a #GIOSchedulerJob
  * @func: a #GSourceFunc callback that will be called in the original thread
  * @user_data: data to pass to @func
  * @notify: (allow-none): a #GDestroyNotify for @user_data, or %NULL
  *
  * Used from an I/O job to send a callback to be run in the thread
  * that the job was started from, waiting for the result (and thus
  * blocking the I/O job).
  *
  * Returns: The return value of @func
  *
  * Deprecated: Use g_main_context_invoke().
  **/
 gboolean
 g_io_scheduler_job_send_to_mainloop (GIOSchedulerJob *job,
 				     GSourceFunc      func,
 				     gpointer         user_data,
 				     GDestroyNotify   notify)
 {
   GSource *source;
   MainLoopProxy *proxy;
   gboolean ret_val;

   g_return_val_if_fail (job != NULL, FALSE);
   g_return_val_if_fail (func != NULL, FALSE);

   proxy = g_new0 (MainLoopProxy, 1);
   proxy->func = func;
   proxy->data = user_data;
   proxy->notify = notify;
   g_mutex_init (&proxy->ack_lock);
   g_cond_init (&proxy->ack_condition);
   g_mutex_lock (&proxy->ack_lock);

   source = g_idle_source_new ();
   g_source_set_priority (source, G_PRIORITY_DEFAULT);
   g_source_set_callback (source, mainloop_proxy_func, proxy,
 			 NULL);
   g_source_set_name (source, "[gio] mainloop_proxy_func");

   g_source_attach (source, job->context);
   g_source_unref (source);

   while (!proxy->ack)
     g_cond_wait (&proxy->ack_condition, &proxy->ack_lock);
   g_mutex_unlock (&proxy->ack_lock);

   ret_val = proxy->ret_val;
   mainloop_proxy_free (proxy);

   return ret_val;
 }

 /**
  * g_io_scheduler_job_send_to_mainloop_async:
  * @job: a #GIOSchedulerJob
  * @func: a #GSourceFunc callback that will be called in the original thread
  * @user_data: data to pass to @func
  * @notify: (allow-none): a #GDestroyNotify for @user_data, or %NULL
  *
  * Used from an I/O job to send a callback to be run asynchronously in
  * the thread that the job was started from. The callback will be run
  * when the main loop is available, but at that time the I/O job might
  * have finished. The return value from the callback is ignored.
  *
  * Note that if you are passing the @user_data from g_io_scheduler_push_job()
  * on to this function you have to ensure that it is not freed before
  * @func is called, either by passing %NULL as @notify to
  * g_io_scheduler_push_job() or by using refcounting for @user_data.
  *
  * Deprecated: Use g_main_context_invoke().
  **/
 void
 g_io_scheduler_job_send_to_mainloop_async (GIOSchedulerJob *job,
 					   GSourceFunc      func,
 					   gpointer         user_data,
 					   GDestroyNotify   notify)
 {
   GSource *source;
   MainLoopProxy *proxy;

   g_return_if_fail (job != NULL);
   g_return_if_fail (func != NULL);

   proxy = g_new0 (MainLoopProxy, 1);
   proxy->func = func;
   proxy->data = user_data;
   proxy->notify = notify;
   g_mutex_init (&proxy->ack_lock);
   g_cond_init (&proxy->ack_condition);

   source = g_idle_source_new ();
   g_source_set_priority (source, G_PRIORITY_DEFAULT);
   g_source_set_callback (source, mainloop_proxy_func, proxy,
 			 (GDestroyNotify)mainloop_proxy_free);
   g_source_set_name (source, "[gio] mainloop_proxy_func");

   g_source_attach (source, job->context);
   g_source_unref (source);
 }
	/* GIO - GLib Input, Output and Streaming Library
	*
	* Copyright (C) 2006-2007 Red Hat, Inc.
	*
	* 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 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 <http://www.gnu.org/licenses/>.
	*
	* Author: Alexander Larsson <alexl@redhat.com>
	*/

	#include "config.h"

	#include "gioscheduler.h"
	#include "gcancellable.h"
	#include "gtask.h"

	/**
	* SECTION:gioscheduler
	* @short_description: I/O Scheduler
	* @include: gio/gio.h
	*
	* As of GLib 2.36, #GIOScheduler is deprecated in favor of
	* #GThreadPool and #GTask.
	*
	* Schedules asynchronous I/O operations. #GIOScheduler integrates
	* into the main event loop (#GMainLoop) and uses threads.
	*/

	struct _GIOSchedulerJob {
	GList *active_link;
	GTask *task;

	GIOSchedulerJobFunc job_func;
	gpointer data;
	GDestroyNotify destroy_notify;

	GCancellable *cancellable;
	gulong cancellable_id;
	GMainContext *context;
	};

	G_LOCK_DEFINE_STATIC(active_jobs);
	static GList *active_jobs = NULL;

	static void
	g_io_job_free (GIOSchedulerJob *job)
	{
	if (job->destroy_notify)
	job->destroy_notify (job->data);

	G_LOCK (active_jobs);
	active_jobs = g_list_delete_link (active_jobs, job->active_link);
	G_UNLOCK (active_jobs);

	if (job->cancellable)
	g_object_unref (job->cancellable);
	g_main_context_unref (job->context);
	g_slice_free (GIOSchedulerJob, job);
	}

	static void
	io_job_thread (GTask *task,
	gpointer source_object,
	gpointer task_data,
	GCancellable *cancellable)
	{
	GIOSchedulerJob *job = task_data;
	gboolean result;

	if (job->cancellable)
	g_cancellable_push_current (job->cancellable);

	do
	{
	result = job->job_func (job, job->cancellable, job->data);
	}
	while (result);

	if (job->cancellable)
	g_cancellable_pop_current (job->cancellable);
	}

	/**
	* g_io_scheduler_push_job:
	* @job_func: a #GIOSchedulerJobFunc.
	* @user_data: data to pass to @job_func
	* @notify: (allow-none): a #GDestroyNotify for @user_data, or %NULL
	* @io_priority: the [I/O priority][io-priority]
	* of the request.
	* @cancellable: optional #GCancellable object, %NULL to ignore.
	*
	* Schedules the I/O job to run in another thread.
	*
	* @notify will be called on @user_data after @job_func has returned,
	* regardless whether the job was cancelled or has run to completion.
	*
	* If @cancellable is not %NULL, it can be used to cancel the I/O job
	* by calling g_cancellable_cancel() or by calling
	* g_io_scheduler_cancel_all_jobs().
	*
	* Deprecated: use #GThreadPool or g_task_run_in_thread()
	**/
	void
	g_io_scheduler_push_job (GIOSchedulerJobFunc job_func,
	gpointer user_data,
	GDestroyNotify notify,
	gint io_priority,
	GCancellable *cancellable)
	{
	GIOSchedulerJob *job;
	GTask *task;

	g_return_if_fail (job_func != NULL);

	job = g_slice_new0 (GIOSchedulerJob);
	job->job_func = job_func;
	job->data = user_data;
	job->destroy_notify = notify;

	if (cancellable)
	job->cancellable = g_object_ref (cancellable);

	job->context = g_main_context_ref_thread_default ();

	G_LOCK (active_jobs);
	active_jobs = g_list_prepend (active_jobs, job);
	job->active_link = active_jobs;
	G_UNLOCK (active_jobs);

	task = g_task_new (NULL, cancellable, NULL, NULL);
	G_GNUC_BEGIN_IGNORE_DEPRECATIONS
	g_task_set_source_tag (task, g_io_scheduler_push_job);
	G_GNUC_END_IGNORE_DEPRECATIONS
	g_task_set_task_data (task, job, (GDestroyNotify)g_io_job_free);
	g_task_set_priority (task, io_priority);
	g_task_run_in_thread (task, io_job_thread);
	g_object_unref (task);
	}

	/**
	* g_io_scheduler_cancel_all_jobs:
	*
	* Cancels all cancellable I/O jobs.
	*
	* A job is cancellable if a #GCancellable was passed into
	* g_io_scheduler_push_job().
	*
	* Deprecated: You should never call this function, since you don't
	* know how other libraries in your program might be making use of
	* gioscheduler.
	**/
	void
	g_io_scheduler_cancel_all_jobs (void)
	{
	GList cancellable_list, l;

	G_LOCK (active_jobs);
	cancellable_list = NULL;
	for (l = active_jobs; l != NULL; l = l->next)
	{
	GIOSchedulerJob *job = l->data;
	if (job->cancellable)
	cancellable_list = g_list_prepend (cancellable_list,
	g_object_ref (job->cancellable));
	}
	G_UNLOCK (active_jobs);

	for (l = cancellable_list; l != NULL; l = l->next)
	{
	GCancellable *c = l->data;
	g_cancellable_cancel (c);
	g_object_unref (c);
	}
	g_list_free (cancellable_list);
	}

	typedef struct {
	GSourceFunc func;
	gboolean ret_val;
	gpointer data;
	GDestroyNotify notify;

	GMutex ack_lock;
	GCond ack_condition;
	gboolean ack;
	} MainLoopProxy;

	static gboolean
	mainloop_proxy_func (gpointer data)
	{
	MainLoopProxy *proxy = data;

	proxy->ret_val = proxy->func (proxy->data);

	if (proxy->notify)
	proxy->notify (proxy->data);

	g_mutex_lock (&proxy->ack_lock);
	proxy->ack = TRUE;
	g_cond_signal (&proxy->ack_condition);
	g_mutex_unlock (&proxy->ack_lock);

	return FALSE;
	}

	static void
	mainloop_proxy_free (MainLoopProxy *proxy)
	{
	g_mutex_clear (&proxy->ack_lock);
	g_cond_clear (&proxy->ack_condition);
	g_free (proxy);
	}

	/**
	* g_io_scheduler_job_send_to_mainloop:
	* @job: a #GIOSchedulerJob
	* @func: a #GSourceFunc callback that will be called in the original thread
	* @user_data: data to pass to @func
	* @notify: (allow-none): a #GDestroyNotify for @user_data, or %NULL
	*
	* Used from an I/O job to send a callback to be run in the thread
	* that the job was started from, waiting for the result (and thus
	* blocking the I/O job).
	*
	* Returns: The return value of @func
	*
	* Deprecated: Use g_main_context_invoke().
	**/
	gboolean
	g_io_scheduler_job_send_to_mainloop (GIOSchedulerJob *job,
	GSourceFunc func,
	gpointer user_data,
	GDestroyNotify notify)
	{
	GSource *source;
	MainLoopProxy *proxy;
	gboolean ret_val;

	g_return_val_if_fail (job != NULL, FALSE);
	g_return_val_if_fail (func != NULL, FALSE);

	proxy = g_new0 (MainLoopProxy, 1);
	proxy->func = func;
	proxy->data = user_data;
	proxy->notify = notify;
	g_mutex_init (&proxy->ack_lock);
	g_cond_init (&proxy->ack_condition);
	g_mutex_lock (&proxy->ack_lock);

	source = g_idle_source_new ();
	g_source_set_priority (source, G_PRIORITY_DEFAULT);
	g_source_set_callback (source, mainloop_proxy_func, proxy,
	NULL);
	g_source_set_name (source, "[gio] mainloop_proxy_func");

	g_source_attach (source, job->context);
	g_source_unref (source);

	while (!proxy->ack)
	g_cond_wait (&proxy->ack_condition, &proxy->ack_lock);
	g_mutex_unlock (&proxy->ack_lock);

	ret_val = proxy->ret_val;
	mainloop_proxy_free (proxy);

	return ret_val;
	}

	/**
	* g_io_scheduler_job_send_to_mainloop_async:
	* @job: a #GIOSchedulerJob
	* @func: a #GSourceFunc callback that will be called in the original thread
	* @user_data: data to pass to @func
	* @notify: (allow-none): a #GDestroyNotify for @user_data, or %NULL
	*
	* Used from an I/O job to send a callback to be run asynchronously in
	* the thread that the job was started from. The callback will be run
	* when the main loop is available, but at that time the I/O job might
	* have finished. The return value from the callback is ignored.
	*
	* Note that if you are passing the @user_data from g_io_scheduler_push_job()
	* on to this function you have to ensure that it is not freed before
	* @func is called, either by passing %NULL as @notify to
	* g_io_scheduler_push_job() or by using refcounting for @user_data.
	*
	* Deprecated: Use g_main_context_invoke().
	**/
	void
	g_io_scheduler_job_send_to_mainloop_async (GIOSchedulerJob *job,
	GSourceFunc func,
	gpointer user_data,
	GDestroyNotify notify)
	{
	GSource *source;
	MainLoopProxy *proxy;

	g_return_if_fail (job != NULL);
	g_return_if_fail (func != NULL);

	proxy = g_new0 (MainLoopProxy, 1);
	proxy->func = func;
	proxy->data = user_data;
	proxy->notify = notify;
	g_mutex_init (&proxy->ack_lock);
	g_cond_init (&proxy->ack_condition);

	source = g_idle_source_new ();
	g_source_set_priority (source, G_PRIORITY_DEFAULT);
	g_source_set_callback (source, mainloop_proxy_func, proxy,
	(GDestroyNotify)mainloop_proxy_free);
	g_source_set_name (source, "[gio] mainloop_proxy_func");

	g_source_attach (source, job->context);
	g_source_unref (source);
	}