1 /* GIO - GLib Input, Output and Streaming Library
3 * Copyright (C) 2006-2007 Red Hat, Inc.
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2 of the License, or (at your option) any later version.
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
15 * You should have received a copy of the GNU Lesser General
16 * Public License along with this library; if not, write to the
17 * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
18 * Boston, MA 02111-1307, USA.
20 * Author: Alexander Larsson <alexl@redhat.com>
25 #include "gioscheduler.h"
30 * SECTION:gioscheduler
31 * @short_description: I/O Scheduler
34 * Schedules asynchronous I/O operations. #GIOScheduler integrates
35 * into the main event loop (#GMainLoop) and may use threads if they
38 * <para id="io-priority"><indexterm><primary>I/O priority</primary></indexterm>
39 * Each I/O operation has a priority, and the scheduler uses the priorities
40 * to determine the order in which operations are executed. They are
41 * <emphasis>not</emphasis> used to determine system-wide I/O scheduling.
42 * Priorities are integers, with lower numbers indicating higher priority.
43 * It is recommended to choose priorities between %G_PRIORITY_LOW and
44 * %G_PRIORITY_HIGH, with %G_PRIORITY_DEFAULT as a default.
48 struct _GIOSchedulerJob {
50 GIOSchedulerJobFunc job_func;
51 GSourceFunc cancel_func; /* Runs under job map lock */
53 GDestroyNotify destroy_notify;
56 GCancellable *cancellable;
61 G_LOCK_DEFINE_STATIC(active_jobs);
62 static GSList *active_jobs = NULL;
64 static GThreadPool *job_thread_pool = NULL;
66 static void io_job_thread (gpointer data,
70 g_io_job_free (GIOSchedulerJob *job)
73 g_object_unref (job->cancellable);
78 g_io_job_compare (gconstpointer a,
82 const GIOSchedulerJob *aa = a;
83 const GIOSchedulerJob *bb = b;
85 /* Cancelled jobs are set prio == -1, so that
86 they are executed as quickly as possible */
88 /* Lower value => higher priority */
89 if (aa->io_priority < bb->io_priority)
91 if (aa->io_priority == bb->io_priority)
97 init_scheduler (gpointer arg)
99 if (job_thread_pool == NULL)
101 /* TODO: thread_pool_new can fail */
102 job_thread_pool = g_thread_pool_new (io_job_thread,
107 if (job_thread_pool != NULL)
109 g_thread_pool_set_sort_function (job_thread_pool,
112 /* Its kinda weird that this is a global setting
113 * instead of per threadpool. However, we really
114 * want to cache some threads, but not keep around
115 * those threads forever. */
116 g_thread_pool_set_max_idle_time (15 * 1000);
117 g_thread_pool_set_max_unused_threads (2);
124 remove_active_job (GIOSchedulerJob *job)
126 GIOSchedulerJob *other_job;
128 gboolean resort_jobs;
130 G_LOCK (active_jobs);
131 active_jobs = g_slist_delete_link (active_jobs, job->active_link);
134 for (l = active_jobs; l != NULL; l = l->next)
137 if (other_job->io_priority >= 0 &&
138 g_cancellable_is_cancelled (other_job->cancellable))
140 other_job->io_priority = -1;
144 G_UNLOCK (active_jobs);
147 job_thread_pool != NULL)
148 g_thread_pool_set_sort_function (job_thread_pool,
155 io_job_thread (gpointer data,
158 GIOSchedulerJob *job = data;
160 if (job->cancellable)
161 g_cancellable_push_current (job->cancellable);
162 job->job_func (job, job->cancellable, job->data);
163 if (job->cancellable)
164 g_cancellable_pop_current (job->cancellable);
166 if (job->destroy_notify)
167 job->destroy_notify (job->data);
169 remove_active_job (job);
175 run_job_at_idle (gpointer data)
177 GIOSchedulerJob *job = data;
179 if (job->cancellable)
180 g_cancellable_push_current (job->cancellable);
182 job->job_func (job, job->cancellable, job->data);
184 if (job->cancellable)
185 g_cancellable_pop_current (job->cancellable);
187 if (job->destroy_notify)
188 job->destroy_notify (job->data);
190 remove_active_job (job);
197 * g_io_scheduler_push_job:
198 * @job_func: a #GIOSchedulerJobFunc.
199 * @user_data: data to pass to @job_func
200 * @notify: a #GDestroyNotify for @user_data, or %NULL
201 * @io_priority: the <link linkend="gioscheduler">I/O priority</link>
203 * @cancellable: optional #GCancellable object, %NULL to ignore.
205 * Schedules the I/O job to run.
207 * @notify will be called on @user_data after @job_func has returned,
208 * regardless whether the job was cancelled or has run to completion.
210 * If @cancellable is not %NULL, it can be used to cancel the I/O job
211 * by calling g_cancellable_cancel() or by calling
212 * g_io_scheduler_cancel_all_jobs().
215 g_io_scheduler_push_job (GIOSchedulerJobFunc job_func,
217 GDestroyNotify notify,
219 GCancellable *cancellable)
221 static GOnce once_init = G_ONCE_INIT;
222 GIOSchedulerJob *job;
224 g_return_if_fail (job_func != NULL);
226 job = g_new0 (GIOSchedulerJob, 1);
227 job->job_func = job_func;
228 job->data = user_data;
229 job->destroy_notify = notify;
230 job->io_priority = io_priority;
233 job->cancellable = g_object_ref (cancellable);
235 G_LOCK (active_jobs);
236 active_jobs = g_slist_prepend (active_jobs, job);
237 job->active_link = active_jobs;
238 G_UNLOCK (active_jobs);
240 if (g_thread_supported())
242 g_once (&once_init, init_scheduler, NULL);
243 g_thread_pool_push (job_thread_pool, job, NULL);
247 /* Threads not available, instead do the i/o sync inside a
248 * low prio idle handler
250 job->idle_tag = g_idle_add_full (G_PRIORITY_DEFAULT_IDLE + 1 + io_priority / 10,
257 * g_io_scheduler_cancel_all_jobs:
259 * Cancels all cancellable I/O jobs.
261 * A job is cancellable if a #GCancellable was passed into
262 * g_io_scheduler_push_job().
265 g_io_scheduler_cancel_all_jobs (void)
267 GSList *cancellable_list, *l;
269 G_LOCK (active_jobs);
270 cancellable_list = NULL;
271 for (l = active_jobs; l != NULL; l = l->next)
273 GIOSchedulerJob *job = l->data;
274 if (job->cancellable)
275 cancellable_list = g_slist_prepend (cancellable_list,
276 g_object_ref (job->cancellable));
278 G_UNLOCK (active_jobs);
280 for (l = cancellable_list; l != NULL; l = l->next)
282 GCancellable *c = l->data;
283 g_cancellable_cancel (c);
286 g_slist_free (cancellable_list);
293 GDestroyNotify notify;
296 GCond *ack_condition;
300 mainloop_proxy_func (gpointer data)
302 MainLoopProxy *proxy = data;
304 proxy->ret_val = proxy->func (proxy->data);
307 proxy->notify (proxy->data);
311 g_mutex_lock (proxy->ack_lock);
312 g_cond_signal (proxy->ack_condition);
313 g_mutex_unlock (proxy->ack_lock);
320 mainloop_proxy_free (MainLoopProxy *proxy)
324 g_mutex_free (proxy->ack_lock);
325 g_cond_free (proxy->ack_condition);
332 * g_io_scheduler_job_send_to_mainloop:
333 * @job: a #GIOSchedulerJob
334 * @func: a #GSourceFunc callback that will be called in the main thread
335 * @user_data: data to pass to @func
336 * @notify: a #GDestroyNotify for @user_data, or %NULL
338 * Used from an I/O job to send a callback to be run in the
339 * main loop (main thread), waiting for the result (and thus
340 * blocking the I/O job).
342 * Returns: The return value of @func
345 g_io_scheduler_job_send_to_mainloop (GIOSchedulerJob *job,
348 GDestroyNotify notify)
351 MainLoopProxy *proxy;
355 g_return_val_if_fail (job != NULL, FALSE);
356 g_return_val_if_fail (func != NULL, FALSE);
360 /* We just immediately re-enter in the case of idles (non-threads)
361 * Anything else would just deadlock. If you can't handle this, enable threads.
363 ret_val = func (user_data);
369 proxy = g_new0 (MainLoopProxy, 1);
371 proxy->data = user_data;
372 proxy->notify = notify;
373 proxy->ack_lock = g_mutex_new ();
374 proxy->ack_condition = g_cond_new ();
375 g_mutex_lock (proxy->ack_lock);
377 source = g_idle_source_new ();
378 g_source_set_priority (source, G_PRIORITY_DEFAULT);
379 g_source_set_callback (source, mainloop_proxy_func, proxy,
382 id = g_source_attach (source, NULL);
383 g_source_unref (source);
385 g_cond_wait (proxy->ack_condition, proxy->ack_lock);
386 g_mutex_unlock (proxy->ack_lock);
388 ret_val = proxy->ret_val;
389 mainloop_proxy_free (proxy);
395 * g_io_scheduler_job_send_to_mainloop_async:
396 * @job: a #GIOSchedulerJob
397 * @func: a #GSourceFunc callback that will be called in the main thread
398 * @user_data: data to pass to @func
399 * @notify: a #GDestroyNotify for @user_data, or %NULL
401 * Used from an I/O job to send a callback to be run asynchronously
402 * in the main loop (main thread). The callback will be run when the
403 * main loop is available, but at that time the I/O job might have
404 * finished. The return value from the callback is ignored.
406 * Note that if you are passing the @user_data from g_io_scheduler_push_job()
407 * on to this function you have to ensure that it is not freed before
408 * @func is called, either by passing %NULL as @notify to
409 * g_io_scheduler_push_job() or by using refcounting for @user_data.
412 g_io_scheduler_job_send_to_mainloop_async (GIOSchedulerJob *job,
415 GDestroyNotify notify)
418 MainLoopProxy *proxy;
421 g_return_if_fail (job != NULL);
422 g_return_if_fail (func != NULL);
426 /* We just immediately re-enter in the case of idles (non-threads)
427 * Anything else would just deadlock. If you can't handle this, enable threads.
435 proxy = g_new0 (MainLoopProxy, 1);
437 proxy->data = user_data;
438 proxy->notify = notify;
440 source = g_idle_source_new ();
441 g_source_set_priority (source, G_PRIORITY_DEFAULT);
442 g_source_set_callback (source, mainloop_proxy_func, proxy,
443 (GDestroyNotify)mainloop_proxy_free);
445 id = g_source_attach (source, NULL);
446 g_source_unref (source);
450 #define __G_IO_SCHEDULER_C__
451 #include "gioaliasdef.c"