gioscheduler.c 8.75 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
/* 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
16
 * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
17 18 19 20
 *
 * Author: Alexander Larsson <alexl@redhat.com>
 */

21
#include "config.h"
22 23

#include "gioscheduler.h"
24
#include "gcancellable.h"
25
#include "gtask.h"
26

27 28 29
/**
 * SECTION:gioscheduler
 * @short_description: I/O Scheduler
Matthias Clasen's avatar
Matthias Clasen committed
30
 * @include: gio/gio.h
31
 * 
32 33
 * As of GLib 2.36, #GIOScheduler is deprecated in favor of
 * #GThreadPool and #GTask.
34
 *
35
 * Schedules asynchronous I/O operations. #GIOScheduler integrates 
36
 * into the main event loop (#GMainLoop) and uses threads.
37
 */
38

39
struct _GIOSchedulerJob {
40
  GList *active_link;
41 42
  GTask *task;

43
  GIOSchedulerJobFunc job_func;
44 45
  gpointer data;
  GDestroyNotify destroy_notify;
46

47
  GCancellable *cancellable;
48
  gulong cancellable_id;
49
  GMainContext *context;
50 51 52
};

G_LOCK_DEFINE_STATIC(active_jobs);
53
static GList *active_jobs = NULL;
54 55

static void
56
g_io_job_free (GIOSchedulerJob *job)
57
{
58 59 60
  if (job->destroy_notify)
    job->destroy_notify (job->data);

61 62 63
  G_LOCK (active_jobs);
  active_jobs = g_list_delete_link (active_jobs, job->active_link);
  G_UNLOCK (active_jobs);
64 65 66 67 68

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

71
static void
72 73 74 75
io_job_thread (GTask         *task,
               gpointer       source_object,
               gpointer       task_data,
               GCancellable  *cancellable)
76
{
77
  GIOSchedulerJob *job = task_data;
78
  gboolean result;
79 80

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

83 84 85 86 87
  do 
    {
      result = job->job_func (job, job->cancellable, job->data);
    }
  while (result);
88

89 90
  if (job->cancellable)
    g_cancellable_pop_current (job->cancellable);
91 92 93
}

/**
94 95
 * g_io_scheduler_push_job:
 * @job_func: a #GIOSchedulerJobFunc.
Matthias Clasen's avatar
Matthias Clasen committed
96
 * @user_data: data to pass to @job_func
97
 * @notify: (nullable): a #GDestroyNotify for @user_data, or %NULL
98
 * @io_priority: the [I/O priority][io-priority]
99
 * of the request.
100 101
 * @cancellable: optional #GCancellable object, %NULL to ignore.
 *
102
 * Schedules the I/O job to run in another thread.
Matthias Clasen's avatar
Matthias Clasen committed
103 104 105
 *
 * @notify will be called on @user_data after @job_func has returned,
 * regardless whether the job was cancelled or has run to completion.
106
 * 
Matthias Clasen's avatar
Matthias Clasen committed
107 108 109
 * 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().
110 111
 *
 * Deprecated: use #GThreadPool or g_task_run_in_thread()
112 113
 **/
void
Matthias Clasen's avatar
Matthias Clasen committed
114 115 116 117 118
g_io_scheduler_push_job (GIOSchedulerJobFunc  job_func,
			 gpointer             user_data,
			 GDestroyNotify       notify,
			 gint                 io_priority,
			 GCancellable        *cancellable)
119
{
120
  GIOSchedulerJob *job;
121
  GTask *task;
122 123 124

  g_return_if_fail (job_func != NULL);

125
  job = g_slice_new0 (GIOSchedulerJob);
126 127 128
  job->job_func = job_func;
  job->data = user_data;
  job->destroy_notify = notify;
129

130
  if (cancellable)
131
    job->cancellable = g_object_ref (cancellable);
132

133
  job->context = g_main_context_ref_thread_default ();
134

135
  G_LOCK (active_jobs);
136
  active_jobs = g_list_prepend (active_jobs, job);
137 138 139
  job->active_link = active_jobs;
  G_UNLOCK (active_jobs);

140
  task = g_task_new (NULL, cancellable, NULL, NULL);
141 142 143
G_GNUC_BEGIN_IGNORE_DEPRECATIONS
  g_task_set_source_tag (task, g_io_scheduler_push_job);
G_GNUC_END_IGNORE_DEPRECATIONS
144 145 146 147
  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);
148 149 150
}

/**
151
 * g_io_scheduler_cancel_all_jobs:
152
 * 
Matthias Clasen's avatar
Matthias Clasen committed
153 154 155 156
 * Cancels all cancellable I/O jobs. 
 *
 * A job is cancellable if a #GCancellable was passed into
 * g_io_scheduler_push_job().
157 158 159 160
 *
 * Deprecated: You should never call this function, since you don't
 * know how other libraries in your program might be making use of
 * gioscheduler.
161 162
 **/
void
163
g_io_scheduler_cancel_all_jobs (void)
164
{
165
  GList *cancellable_list, *l;
166 167 168 169 170
  
  G_LOCK (active_jobs);
  cancellable_list = NULL;
  for (l = active_jobs; l != NULL; l = l->next)
    {
171
      GIOSchedulerJob *job = l->data;
172
      if (job->cancellable)
173 174
	cancellable_list = g_list_prepend (cancellable_list,
					   g_object_ref (job->cancellable));
175 176 177 178 179 180 181 182 183
    }
  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);
    }
184
  g_list_free (cancellable_list);
185 186 187
}

typedef struct {
188 189 190
  GSourceFunc func;
  gboolean ret_val;
  gpointer data;
191 192
  GDestroyNotify notify;

193 194
  GMutex ack_lock;
  GCond ack_condition;
195
  gboolean ack;
196 197 198 199 200 201 202
} MainLoopProxy;

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

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

205 206
  if (proxy->notify)
    proxy->notify (proxy->data);
207 208

  g_mutex_lock (&proxy->ack_lock);
209
  proxy->ack = TRUE;
210 211 212
  g_cond_signal (&proxy->ack_condition);
  g_mutex_unlock (&proxy->ack_lock);

213 214 215 216 217 218
  return FALSE;
}

static void
mainloop_proxy_free (MainLoopProxy *proxy)
{
219 220
  g_mutex_clear (&proxy->ack_lock);
  g_cond_clear (&proxy->ack_condition);
221 222 223 224
  g_free (proxy);
}

/**
225
 * g_io_scheduler_job_send_to_mainloop:
Matthias Clasen's avatar
Matthias Clasen committed
226
 * @job: a #GIOSchedulerJob
227
 * @func: a #GSourceFunc callback that will be called in the original thread
Matthias Clasen's avatar
Matthias Clasen committed
228
 * @user_data: data to pass to @func
229
 * @notify: (nullable): a #GDestroyNotify for @user_data, or %NULL
230
 * 
231 232
 * 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
Matthias Clasen's avatar
Matthias Clasen committed
233
 * blocking the I/O job).
234 235
 *
 * Returns: The return value of @func
236 237
 *
 * Deprecated: Use g_main_context_invoke().
238 239 240
 **/
gboolean
g_io_scheduler_job_send_to_mainloop (GIOSchedulerJob *job,
Matthias Clasen's avatar
Matthias Clasen committed
241 242 243
				     GSourceFunc      func,
				     gpointer         user_data,
				     GDestroyNotify   notify)
244 245 246 247 248 249 250 251 252 253 254 255
{
  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;
256 257 258 259
  g_mutex_init (&proxy->ack_lock);
  g_cond_init (&proxy->ack_condition);
  g_mutex_lock (&proxy->ack_lock);

260 261 262 263
  source = g_idle_source_new ();
  g_source_set_priority (source, G_PRIORITY_DEFAULT);
  g_source_set_callback (source, mainloop_proxy_func, proxy,
			 NULL);
264
  g_source_set_name (source, "[gio] mainloop_proxy_func");
265

266
  g_source_attach (source, job->context);
267 268
  g_source_unref (source);

269 270
  while (!proxy->ack)
    g_cond_wait (&proxy->ack_condition, &proxy->ack_lock);
271
  g_mutex_unlock (&proxy->ack_lock);
272 273 274 275 276 277 278 279

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

/**
Matthias Clasen's avatar
Matthias Clasen committed
280
 * g_io_scheduler_job_send_to_mainloop_async:
Matthias Clasen's avatar
Matthias Clasen committed
281
 * @job: a #GIOSchedulerJob
282
 * @func: a #GSourceFunc callback that will be called in the original thread
Matthias Clasen's avatar
Matthias Clasen committed
283
 * @user_data: data to pass to @func
284
 * @notify: (nullable): a #GDestroyNotify for @user_data, or %NULL
285
 * 
286 287 288 289
 * 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.
Matthias Clasen's avatar
Matthias Clasen committed
290 291 292 293 294
 *
 * 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.
295 296
 *
 * Deprecated: Use g_main_context_invoke().
297 298
 **/
void
299
g_io_scheduler_job_send_to_mainloop_async (GIOSchedulerJob *job,
Matthias Clasen's avatar
Matthias Clasen committed
300 301 302
					   GSourceFunc      func,
					   gpointer         user_data,
					   GDestroyNotify   notify)
303 304 305 306 307 308 309 310 311 312 313
{
  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;
314 315 316
  g_mutex_init (&proxy->ack_lock);
  g_cond_init (&proxy->ack_condition);

317 318
  source = g_idle_source_new ();
  g_source_set_priority (source, G_PRIORITY_DEFAULT);
319
  g_source_set_callback (source, mainloop_proxy_func, proxy,
320
			 (GDestroyNotify)mainloop_proxy_free);
321
  g_source_set_name (source, "[gio] mainloop_proxy_func");
322

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