static void
remove_active_job (GIOSchedulerJob *job)
{
GIOSchedulerJob *other_job;
GSList *l;
gboolean resort_jobs;
G_LOCK (active_jobs);
active_jobs = g_slist_delete_link (active_jobs, job->active_link);
resort_jobs = FALSE;
for (l = active_jobs; l != NULL; l = l->next)
{
other_job = l->data;
if (other_job->io_priority >= 0 &&
g_cancellable_is_cancelled (other_job->cancellable))
{
other_job->io_priority = -1;
resort_jobs = TRUE;
}
}
G_UNLOCK (active_jobs);
if (resort_jobs &&
job_thread_pool != NULL)
g_thread_pool_set_sort_function (job_thread_pool,
g_io_job_compare,
NULL);
}
static gpointer
init_scheduler (gpointer arg)
{
if (job_thread_pool == NULL)
{
/* TODO: thread_pool_new can fail */
job_thread_pool = g_thread_pool_new (io_job_thread,
NULL,
10,
FALSE,
NULL);
if (job_thread_pool != NULL)
{
g_thread_pool_set_sort_function (job_thread_pool,
g_io_job_compare,
NULL);
/* It's kinda weird that this is a global setting
* instead of per threadpool. However, we really
* want to cache some threads, but not keep around
* those threads forever. */
g_thread_pool_set_max_idle_time (15 * 1000);
g_thread_pool_set_max_unused_threads (2);
}
}
return NULL;
}
static void
test_thread_sort (gboolean sort)
{
GThreadPool *pool;
guint limit;
guint max_threads;
gint i;
limit = MAX_THREADS * 10;
if (sort) {
max_threads = 1;
} else {
max_threads = MAX_THREADS;
}
/* It is important that we only have a maximum of 1 thread for this
* test since the results can not be guranteed to be sorted if > 1.
*
* Threads are scheduled by the operating system and are executed at
* random. It cannot be assumed that threads are executed in the
* order they are created. This was discussed in bug #334943.
*/
pool = g_thread_pool_new (test_thread_sort_entry_func,
GINT_TO_POINTER (sort),
max_threads,
FALSE,
NULL);
g_thread_pool_set_max_unused_threads (MAX_UNUSED_THREADS);
if (sort) {
g_thread_pool_set_sort_function (pool,
test_thread_sort_compare_func,
GUINT_TO_POINTER (69));
}
for (i = 0; i < limit; i++) {
guint id;
id = g_random_int_range (1, limit) + 1;
g_thread_pool_push (pool, GUINT_TO_POINTER (id), NULL);
DEBUG_MSG (("%s ===> pushed new thread with id:%d, number "
"of threads:%d, unprocessed:%d",
sort ? "[ sorted]" : "[unsorted]",
id,
g_thread_pool_get_num_threads (pool),
g_thread_pool_unprocessed (pool)));
}
g_assert (g_thread_pool_get_max_threads (pool) == max_threads);
g_assert (g_thread_pool_get_num_threads (pool) == g_thread_pool_get_max_threads (pool));
}
void
_mate_vfs_job_queue_init (void)
{
GError *err = NULL;
thread_pool = g_thread_pool_new (thread_entry_point,
NULL,
DEFAULT_THREAD_COUNT_LIMIT,
FALSE,
&err);
if (G_UNLIKELY (thread_pool == NULL)) {
g_error ("Could not create threadpool: %s",
err->message);
}
g_thread_pool_set_sort_function (thread_pool,
prioritize_threads,
NULL);
}
render_thread_t*
render_init(zathura_t* zathura)
{
render_thread_t* render_thread = g_malloc0(sizeof(render_thread_t));
/* setup */
render_thread->pool = g_thread_pool_new(render_job, zathura, 1, TRUE, NULL);
if (render_thread->pool == NULL) {
goto error_free;
}
render_thread->about_to_close = false;
g_thread_pool_set_sort_function(render_thread->pool, render_thread_sort, zathura);
g_mutex_init(&render_thread->mutex);
return render_thread;
error_free:
render_free(render_thread);
return NULL;
}
