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
33 * Schedules asynchronous I/O operations for integration into the main
34 * event loop (#GMainLoop).
41 GIODataFunc cancel_func; /* Runs under job map lock */
43 GDestroyNotify destroy_notify;
46 GCancellable *cancellable;
51 G_LOCK_DEFINE_STATIC(active_jobs);
52 static GSList *active_jobs = NULL;
54 static GThreadPool *job_thread_pool = NULL;
56 static void io_job_thread (gpointer data,
60 g_io_job_free (GIOJob *job)
63 g_object_unref (job->cancellable);
68 g_io_job_compare (gconstpointer a,
75 /* Cancelled jobs are set prio == -1, so that
76 they are executed as quickly as possible */
78 /* Lower value => higher priority */
79 if (aa->io_priority < bb->io_priority)
81 if (aa->io_priority == bb->io_priority)
87 init_scheduler (gpointer arg)
89 if (job_thread_pool == NULL)
91 /* TODO: thread_pool_new can fail */
92 job_thread_pool = g_thread_pool_new (io_job_thread,
97 if (job_thread_pool != NULL)
99 g_thread_pool_set_sort_function (job_thread_pool,
102 /* Its kinda weird that this is a global setting
103 * instead of per threadpool. However, we really
104 * want to cache some threads, but not keep around
105 * those threads forever. */
106 g_thread_pool_set_max_idle_time (15 * 1000);
107 g_thread_pool_set_max_unused_threads (2);
114 remove_active_job (GIOJob *job)
118 gboolean resort_jobs;
120 G_LOCK (active_jobs);
121 active_jobs = g_slist_delete_link (active_jobs, job->active_link);
124 for (l = active_jobs; l != NULL; l = l->next)
127 if (other_job->io_priority >= 0 &&
128 g_cancellable_is_cancelled (other_job->cancellable))
130 other_job->io_priority = -1;
134 G_UNLOCK (active_jobs);
137 job_thread_pool != NULL)
138 g_thread_pool_set_sort_function (job_thread_pool,
145 io_job_thread (gpointer data,
150 if (job->cancellable)
151 g_push_current_cancellable (job->cancellable);
152 job->job_func (job, job->cancellable, job->data);
153 if (job->cancellable)
154 g_pop_current_cancellable (job->cancellable);
156 if (job->destroy_notify)
157 job->destroy_notify (job->data);
159 remove_active_job (job);
165 run_job_at_idle (gpointer data)
169 if (job->cancellable)
170 g_push_current_cancellable (job->cancellable);
172 job->job_func (job, job->cancellable, job->data);
174 if (job->cancellable)
175 g_pop_current_cancellable (job->cancellable);
177 if (job->destroy_notify)
178 job->destroy_notify (job->data);
180 remove_active_job (job);
188 * @job_func: a #GIOJobFunc.
189 * @user_data: a #gpointer.
190 * @notify: a #GDestroyNotify.
191 * @io_priority: the i/o priority of the request. a #gint.
192 * @cancellable: optional #GCancellable object, %NULL to ignore.
194 * Schedules the I/O Job.
198 g_schedule_io_job (GIOJobFunc job_func,
200 GDestroyNotify notify,
202 GCancellable *cancellable)
204 static GOnce once_init = G_ONCE_INIT;
207 g_return_if_fail (job_func != NULL);
209 job = g_new0 (GIOJob, 1);
210 job->job_func = job_func;
211 job->data = user_data;
212 job->destroy_notify = notify;
213 job->io_priority = io_priority;
216 job->cancellable = g_object_ref (cancellable);
218 G_LOCK (active_jobs);
219 active_jobs = g_slist_prepend (active_jobs, job);
220 job->active_link = active_jobs;
221 G_UNLOCK (active_jobs);
223 if (g_thread_supported())
225 g_once (&once_init, init_scheduler, NULL);
226 g_thread_pool_push (job_thread_pool, job, NULL);
230 /* Threads not available, instead do the i/o sync inside a
231 * low prio idle handler
233 job->idle_tag = g_idle_add_full (G_PRIORITY_DEFAULT_IDLE + 1 + io_priority / 10,
240 * g_cancel_all_io_jobs:
242 * Cancels all cancellable I/O Jobs.
245 g_cancel_all_io_jobs (void)
247 GSList *cancellable_list, *l;
249 G_LOCK (active_jobs);
250 cancellable_list = NULL;
251 for (l = active_jobs; l != NULL; l = l->next)
253 GIOJob *job = l->data;
254 if (job->cancellable)
255 cancellable_list = g_slist_prepend (cancellable_list,
256 g_object_ref (job->cancellable));
258 G_UNLOCK (active_jobs);
260 for (l = cancellable_list; l != NULL; l = l->next)
262 GCancellable *c = l->data;
263 g_cancellable_cancel (c);
266 g_slist_free (cancellable_list);
272 GDestroyNotify notify;
275 GCond *ack_condition;
279 mainloop_proxy_func (gpointer data)
281 MainLoopProxy *proxy = data;
283 proxy->func (proxy->data);
287 g_mutex_lock (proxy->ack_lock);
288 g_cond_signal (proxy->ack_condition);
289 g_mutex_unlock (proxy->ack_lock);
296 mainloop_proxy_free (MainLoopProxy *proxy)
300 g_mutex_free (proxy->ack_lock);
301 g_cond_free (proxy->ack_condition);
308 mainloop_proxy_notify (gpointer data)
310 MainLoopProxy *proxy = data;
313 proxy->notify (proxy->data);
315 /* If nonblocking we free here, otherwise we free in io thread */
316 if (proxy->ack_lock == NULL)
317 mainloop_proxy_free (proxy);
321 * g_io_job_send_to_mainloop:
323 * @func: a #GIODataFunc.
324 * @user_data: a #gpointer.
325 * @notify: a #GDestroyNotify.
326 * @block: boolean flag indicating whether or not this job should block.
328 * Sends an I/O job to the application's main loop for processing.
332 g_io_job_send_to_mainloop (GIOJob *job,
335 GDestroyNotify notify,
339 MainLoopProxy *proxy;
342 g_return_if_fail (job != NULL);
343 g_return_if_fail (func != NULL);
347 /* We just immediately re-enter in the case of idles (non-threads)
348 * Anything else would just deadlock. If you can't handle this, enable threads.
354 proxy = g_new0 (MainLoopProxy, 1);
356 proxy->data = user_data;
357 proxy->notify = notify;
361 proxy->ack_lock = g_mutex_new ();
362 proxy->ack_condition = g_cond_new ();
365 source = g_idle_source_new ();
366 g_source_set_priority (source, G_PRIORITY_DEFAULT);
368 g_source_set_callback (source, mainloop_proxy_func, proxy, mainloop_proxy_notify);
371 g_mutex_lock (proxy->ack_lock);
373 id = g_source_attach (source, NULL);
374 g_source_unref (source);
378 g_cond_wait (proxy->ack_condition, proxy->ack_lock);
379 g_mutex_unlock (proxy->ack_lock);
381 /* destroy notify didn't free proxy */
382 mainloop_proxy_free (proxy);
386 #define __G_IO_SCHEDULER_C__
387 #include "gioaliasdef.c"