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; }