libview/ev-job-scheduler.c

   1 /* ev-job-scheduler.c
   2  *  this file is part of evince, a gnome document viewer
   3  *
   4  * Copyright (C) 2008 Carlos Garcia Campos <carlosgc@gnome.org>
   5  *
   6  * Evince is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * Evince is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  19  */
  20
  21 #include "ev-debug.h"
  22 #include "ev-job-scheduler.h"
  23
  24 typedef struct _EvSchedulerJob {
  25         EvJob         *job;
  26         EvJobPriority  priority;
  27         GSList        *job_link;
  28 } EvSchedulerJob;
  29
  30 G_LOCK_DEFINE_STATIC(job_list);
  31 static GSList *job_list = NULL;
  32
  33 static gpointer ev_job_thread_proxy               (gpointer        data);
  34 static void     ev_scheduler_thread_job_cancelled (EvSchedulerJob *job,
  35                                                    GCancellable   *cancellable);
  36
  37 /* EvJobQueue */
  38 static GQueue queue_urgent = G_QUEUE_INIT;
  39 static GQueue queue_high = G_QUEUE_INIT;
  40 static GQueue queue_low = G_QUEUE_INIT;
  41 static GQueue queue_none = G_QUEUE_INIT;
  42
  43 static GCond *job_queue_cond = NULL;
  44 static GMutex *job_queue_mutex = NULL;
  45 static GQueue *job_queue[EV_JOB_N_PRIORITIES] = {
  46         &queue_urgent,
  47         &queue_high,
  48         &queue_low,
  49         &queue_none
  50 };
  51
  52 static void
  53 ev_job_queue_push (EvSchedulerJob *job,
  54                    EvJobPriority   priority)
  55 {
  56         ev_debug_message (DEBUG_JOBS, "%s priority %d", EV_GET_TYPE_NAME (job->job), priority);
  57
  58         g_mutex_lock (job_queue_mutex);
  59
  60         g_queue_push_tail (job_queue[priority], job);
  61         g_cond_broadcast (job_queue_cond);
  62
  63         g_mutex_unlock (job_queue_mutex);
  64 }
  65
  66 static EvSchedulerJob *
  67 ev_job_queue_get_next_unlocked (void)
  68 {
  69         gint i;
  70         EvSchedulerJob *job = NULL;
  71
  72         for (i = EV_JOB_PRIORITY_URGENT; i < EV_JOB_N_PRIORITIES; i++) {
  73                 job = (EvSchedulerJob *) g_queue_pop_head (job_queue[i]);
  74                 if (job)
  75                         break;
  76         }
  77
  78         ev_debug_message (DEBUG_JOBS, "%s", job ? EV_GET_TYPE_NAME (job->job) : "No jobs in queue");
  79
  80         return job;
  81 }
  82
  83 static gpointer
  84 ev_job_scheduler_init (gpointer data)
  85 {
  86         job_queue_cond = g_cond_new ();
  87         job_queue_mutex = g_mutex_new ();
  88         g_thread_create (ev_job_thread_proxy, NULL, FALSE, NULL);
  89
  90         return NULL;
  91 }
  92
  93 static void
  94 ev_scheduler_job_list_add (EvSchedulerJob *job)
  95 {
  96         ev_debug_message (DEBUG_JOBS, "%s", EV_GET_TYPE_NAME (job->job));
  97
  98         G_LOCK (job_list);
  99
 100         job_list = g_slist_prepend (job_list, job);
 101         job->job_link = job_list;
 102
 103         G_UNLOCK (job_list);
 104 }
 105
 106 static void
 107 ev_scheduler_job_list_remove (EvSchedulerJob *job)
 108 {
 109         ev_debug_message (DEBUG_JOBS, "%s", EV_GET_TYPE_NAME (job->job));
 110
 111         G_LOCK (job_list);
 112
 113         job_list = g_slist_delete_link (job_list, job->job_link);
 114
 115         G_UNLOCK (job_list);
 116 }
 117
 118 static void
 119 ev_scheduler_job_free (EvSchedulerJob *job)
 120 {
 121         if (!job)
 122                 return;
 123
 124         g_object_unref (job->job);
 125         g_free (job);
 126 }
 127
 128 static void
 129 ev_scheduler_job_destroy (EvSchedulerJob *job)
 130 {
 131         ev_debug_message (DEBUG_JOBS, "%s", EV_GET_TYPE_NAME (job->job));
 132
 133         if (job->job->run_mode == EV_JOB_RUN_MAIN_LOOP) {
 134                 g_signal_handlers_disconnect_by_func (job->job,
 135                                                       G_CALLBACK (ev_scheduler_job_destroy),
 136                                                       job);
 137         } else {
 138                 g_signal_handlers_disconnect_by_func (job->job->cancellable,
 139                                                       G_CALLBACK (ev_scheduler_thread_job_cancelled),
 140                                                       job);
 141         }
 142
 143         ev_scheduler_job_list_remove (job);
 144         ev_scheduler_job_free (job);
 145 }
 146
 147 static void
 148 ev_scheduler_thread_job_cancelled (EvSchedulerJob *job,
 149                                    GCancellable   *cancellable)
 150 {
 151         GList   *list;
 152
 153         ev_debug_message (DEBUG_JOBS, "%s", EV_GET_TYPE_NAME (job->job));
 154
 155         g_mutex_lock (job_queue_mutex);
 156
 157         /* If the job is not still running,
 158          * remove it from the job queue and job list.
 159          * If the job is currently running, it will be
 160          * destroyed as soon as it finishes.
 161          */
 162         list = g_queue_find (job_queue[job->priority], job);
 163         if (list) {
 164                 g_queue_delete_link (job_queue[job->priority], list);
 165                 g_mutex_unlock (job_queue_mutex);
 166                 ev_scheduler_job_destroy (job);
 167         } else {
 168                 g_mutex_unlock (job_queue_mutex);
 169         }
 170 }
 171
 172 static void
 173 ev_job_thread (EvJob *job)
 174 {
 175         gboolean result;
 176
 177         ev_debug_message (DEBUG_JOBS, "%s", EV_GET_TYPE_NAME (job));
 178
 179         do {
 180                 if (g_cancellable_is_cancelled (job->cancellable))
 181                         result = FALSE;
 182                 else
 183                         result = ev_job_run (job);
 184         } while (result);
 185 }
 186
 187 static gboolean
 188 ev_job_idle (EvJob *job)
 189 {
 190         ev_debug_message (DEBUG_JOBS, "%s", EV_GET_TYPE_NAME (job));
 191
 192         if (g_cancellable_is_cancelled (job->cancellable))
 193                 return FALSE;
 194
 195         return ev_job_run (job);
 196 }
 197
 198 static gpointer
 199 ev_job_thread_proxy (gpointer data)
 200 {
 201         while (TRUE) {
 202                 EvSchedulerJob *job;
 203
 204                 g_mutex_lock (job_queue_mutex);
 205                 job = ev_job_queue_get_next_unlocked ();
 206                 if (!job) {
 207                         g_cond_wait (job_queue_cond, job_queue_mutex);
 208                         g_mutex_unlock (job_queue_mutex);
 209                         continue;
 210                 }
 211                 g_mutex_unlock (job_queue_mutex);
 212
 213                 ev_job_thread (job->job);
 214                 ev_scheduler_job_destroy (job);
 215         }
 216
 217         return NULL;
 218 }
 219
 220 void
 221 ev_job_scheduler_push_job (EvJob         *job,
 222                            EvJobPriority  priority)
 223 {
 224         static GOnce once_init = G_ONCE_INIT;
 225         EvSchedulerJob *s_job;
 226
 227         g_once (&once_init, ev_job_scheduler_init, NULL);
 228
 229         ev_debug_message (DEBUG_JOBS, "%s pirority %d", EV_GET_TYPE_NAME (job), priority);
 230
 231         s_job = g_new0 (EvSchedulerJob, 1);
 232         s_job->job = g_object_ref (job);
 233         s_job->priority = priority;
 234
 235         ev_scheduler_job_list_add (s_job);
 236
 237         switch (ev_job_get_run_mode (job)) {
 238         case EV_JOB_RUN_THREAD:
 239                 g_signal_connect_swapped (job->cancellable, "cancelled",
 240                                           G_CALLBACK (ev_scheduler_thread_job_cancelled),
 241                                           s_job);
 242                 ev_job_queue_push (s_job, priority);
 243                 break;
 244         case EV_JOB_RUN_MAIN_LOOP:
 245                 g_signal_connect_swapped (job, "finished",
 246                                           G_CALLBACK (ev_scheduler_job_destroy),
 247                                           s_job);
 248                 g_signal_connect_swapped (job, "cancelled",
 249                                           G_CALLBACK (ev_scheduler_job_destroy),
 250                                           s_job);
 251                 g_idle_add_full (G_PRIORITY_DEFAULT_IDLE,
 252                                  (GSourceFunc)ev_job_idle,
 253                                  g_object_ref (job),
 254                                  (GDestroyNotify)g_object_unref);
 255                 break;
 256         default:
 257                 g_assert_not_reached ();
 258         }
 259 }
 260
 261 void
 262 ev_job_scheduler_update_job (EvJob         *job,
 263                              EvJobPriority  priority)
 264 {
 265         GSList         *l;
 266         EvSchedulerJob *s_job = NULL;
 267         gboolean        need_resort = FALSE;
 268
 269         /* Main loop jobs are scheduled inmediately */
 270         if (ev_job_get_run_mode (job) == EV_JOB_RUN_MAIN_LOOP)
 271                 return;
 272
 273         ev_debug_message (DEBUG_JOBS, "%s pirority %d", EV_GET_TYPE_NAME (job), priority);
 274
 275         G_LOCK (job_list);
 276
 277         for (l = job_list; l; l = l->next) {
 278                 s_job = (EvSchedulerJob *)l->data;
 279
 280                 if (s_job->job == job) {
 281                         need_resort = (s_job->priority != priority);
 282                         break;
 283                 }
 284         }
 285
 286         G_UNLOCK (job_list);
 287
 288         if (need_resort) {
 289                 GList *list;
 290
 291                 g_mutex_lock (job_queue_mutex);
 292
 293                 list = g_queue_find (job_queue[s_job->priority], s_job);
 294                 if (list) {
 295                         ev_debug_message (DEBUG_JOBS, "Moving job %s from pirority %d to %d",
 296                                           EV_GET_TYPE_NAME (job), s_job->priority, priority);
 297                         g_queue_delete_link (job_queue[s_job->priority], list);
 298                         g_queue_push_tail (job_queue[priority], s_job);
 299                         g_cond_broadcast (job_queue_cond);
 300                 }
 301
 302                 g_mutex_unlock (job_queue_mutex);
 303         }
 304 }
 305