void dp_deep_evaluate_step(DpDeepInfo*hdeepinfo)
{
GMainContext *gcontext = g_main_context_default();
int individ_id;
gboolean immediate_stop = FALSE;
gboolean wait_finish = TRUE;
DpPopulation*population = hdeepinfo->population;
DpPopulation*trial = hdeepinfo->trial;
GError *gerror = NULL;
gulong microseconds = G_USEC_PER_SEC / 1000;
if ( hdeepinfo->max_threads > 0 ) {
for ( individ_id = population->slice_a; individ_id < population->slice_b; individ_id++ ) {
g_thread_pool_push (hdeepinfo->gthreadpool, GINT_TO_POINTER(individ_id + 1), &gerror);
if ( gerror != NULL ) {
g_error("%s", gerror->message);
}
}
while(g_thread_pool_unprocessed (hdeepinfo->gthreadpool) > 0) {
g_main_context_iteration(gcontext, FALSE);
g_usleep (microseconds);
}
} else {
for ( individ_id = population->slice_a; individ_id < population->slice_b; individ_id++ ) {
dp_deep_evaluate_func (GINT_TO_POINTER(individ_id + 1), (gpointer) hdeepinfo);
}
}
}
static void
test_thread_idle_time ()
{
guint limit = 50;
guint interval = 10000;
gint i;
idle_pool = g_thread_pool_new (test_thread_idle_time_entry_func,
NULL,
MAX_THREADS,
FALSE,
NULL);
g_thread_pool_set_max_unused_threads (MAX_UNUSED_THREADS);
g_thread_pool_set_max_idle_time (interval);
g_assert (g_thread_pool_get_max_unused_threads () == MAX_UNUSED_THREADS);
g_assert (g_thread_pool_get_max_idle_time () == interval);
for (i = 0; i < limit; i++) {
g_thread_pool_push (idle_pool, GUINT_TO_POINTER (i + 1), NULL);
DEBUG_MSG (("[idle] ===> pushed new thread with id:%d, "
"number of threads:%d, unprocessed:%d",
i,
g_thread_pool_get_num_threads (idle_pool),
g_thread_pool_unprocessed (idle_pool)));
}
g_timeout_add ((interval - 1000),
test_thread_idle_timeout,
GUINT_TO_POINTER (interval));
}
static void
_gck_call_base_finalize (GckCallClass *klass)
{
GMainContext *context;
GSource *src;
if (klass->thread_pool) {
g_assert (g_thread_pool_unprocessed (klass->thread_pool) == 0);
g_thread_pool_free (klass->thread_pool, FALSE, TRUE);
klass->thread_pool = NULL;
}
if (klass->completed_id) {
context = g_main_context_default ();
g_return_if_fail (context);
src = g_main_context_find_source_by_id (context, klass->completed_id);
g_assert (src);
g_source_destroy (src);
klass->completed_id = 0;
}
if (klass->completed_queue) {
g_assert (g_async_queue_length (klass->completed_queue));
g_async_queue_unref (klass->completed_queue);
klass->completed_queue = NULL;
}
}
DpPopulation*dp_evaluation_population_init(DpEvaluationCtrl*hevalctrl, int size, double noglobal_eps)
{
DpPopulation*pop;
int i, istart = 0;
//gboolean immediate_stop = FALSE;
gboolean immediate_stop = TRUE;
//gboolean wait_finish = TRUE;
gboolean wait_finish = FALSE;
GError *gerror = NULL;
GMainContext *gcontext = g_main_context_default();
gulong microseconds = G_USEC_PER_SEC / 1000;
pop = dp_population_new(size, hevalctrl->eval->size, hevalctrl->eval_target->size, hevalctrl->eval_target->precond_size, hevalctrl->seed);
if ( noglobal_eps == 0 ) {
dp_evaluation_individ_set(hevalctrl, pop->individ[0]);
pop->individ[0]->user_data = dp_target_eval_get_user_data(hevalctrl->eval_target);
istart = 1;
pop->individ[0]->cost = G_MAXDOUBLE;
}
for ( i = istart; i < size; i++) {
dp_evaluation_individ_scramble(hevalctrl, pop->individ[i], noglobal_eps);
pop->individ[i]->user_data = dp_target_eval_get_user_data(hevalctrl->eval_target);
pop->individ[i]->cost = G_MAXDOUBLE;
}
#ifdef MPIZE
/* MPI initialization steps */
int world_id = 0, world_count = 1;
MPI_Comm_size(MPI_COMM_WORLD, &world_count);
MPI_Comm_rank(MPI_COMM_WORLD, &world_id);
int ind_per_node = (int)ceil(pop->size / world_count);
int ind_per_last_node = pop->size - ind_per_node * (world_count - 1);
dp_population_mpi_distribute(pop, world_id, world_count);
#endif
if ( hevalctrl->eval_max_threads > 0 ) {
hevalctrl->gthreadpool = g_thread_pool_new ((GFunc) dp_evaluation_population_init_func, (gpointer) hevalctrl, hevalctrl->eval_max_threads, hevalctrl->exclusive, &gerror);
if ( gerror != NULL ) {
g_error("%s", gerror->message);
}
for ( i = pop->slice_a; i < pop->slice_b; i++) {
g_thread_pool_push (hevalctrl->gthreadpool, (gpointer)(pop->individ[i]), &gerror);
if ( gerror != NULL ) {
g_error("%s", gerror->message);
}
}
while(g_thread_pool_unprocessed (hevalctrl->gthreadpool) > 0) {
g_main_context_iteration(gcontext, FALSE);
g_usleep (microseconds);
}
g_thread_pool_free (hevalctrl->gthreadpool, immediate_stop, wait_finish);
} else {
for ( i = pop->slice_a; i < pop->slice_b; i++) {
dp_evaluation_population_init_func ((gpointer)(pop->individ[i]), (gpointer) hevalctrl);
}
}
#ifdef MPIZE
dp_population_mpi_gather(pop, world_id, world_count);
#endif
dp_population_update(pop, 0, pop->size);
return pop;
}
/*
* wait one thread pool
*/
void wait_thread_pool(const char *name, GThreadPool *pool)
{
gint count = 1;
while (count) {
count = g_thread_pool_unprocessed(pool);
usleep(10000);
}
log_message(DEBUG, DEBUG_AREA_MAIN,
"thread pool '%s' free", name);
}
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));
}
push_int_t push_vm_num_queued(push_vm_t *vm) {
push_int_t num;
g_return_val_if_null(vm, 0);
g_mutex_lock(vm->mutex);
num = g_thread_pool_unprocessed(vm->threads);
g_mutex_unlock(vm->mutex);
return num;
}
int
main (int argc, char **argv)
{
midgard_init ();
MidgardConfig *config = midgard_config_new ();
midgard_config_read_file_at_path (config, "/tmp/test_SQLITE.conf", NULL);
MidgardConnection *mgd = midgard_connection_new ();
midgard_connection_open_config (mgd, config);
GThreadPool *pool = g_thread_pool_new (pool_func, (gpointer) mgd, 10, TRUE, NULL);
//midgard_storage_create_base_storage (mgd);
//midgard_storage_create (mgd,"midgard_snippetdir");
g_print ("START OPERATIONS \n");
MidgardObject *obj = midgard_object_new (mgd, "midgard_snippetdir", NULL);
g_thread_pool_push (pool, (gpointer) obj, NULL);
MidgardObject *obja = midgard_object_new (mgd, "midgard_snippetdir", NULL);
g_thread_pool_push (pool, (gpointer) obja, NULL);
MidgardObject *objb = midgard_object_new (mgd, "midgard_snippetdir", NULL);
g_thread_pool_push (pool, (gpointer) objb, NULL);
MidgardObject *objc = midgard_object_new (mgd, "midgard_snippetdir", NULL);
g_thread_pool_push (pool, (gpointer) objc, NULL);
MidgardObject *objd = midgard_object_new (mgd, "midgard_snippetdir", NULL);
g_thread_pool_push (pool, (gpointer) objd, NULL);
g_print ("END OPERATIONS \n");
g_print ("THREADS REMAIN (%d) \n", g_thread_pool_unprocessed (pool));
g_thread_pool_free (pool, FALSE, TRUE);
return 0;
}
static gboolean
test_thread_idle_timeout (gpointer data)
{
guint interval;
gint i;
interval = GPOINTER_TO_UINT (data);
for (i = 0; i < 2; i++) {
g_thread_pool_push (idle_pool, GUINT_TO_POINTER (100 + i), NULL);
DEBUG_MSG (("[idle] ===> pushed new thread with id:%d, number "
"of threads:%d, unprocessed:%d",
100 + i,
g_thread_pool_get_num_threads (idle_pool),
g_thread_pool_unprocessed (idle_pool)));
}
return FALSE;
}
static void
camel_session_finalise (CamelObject *o)
{
CamelSession *session = (CamelSession *)o;
GThreadPool *thread_pool = session->priv->thread_pool;
g_hash_table_destroy(session->priv->thread_active);
if (thread_pool != NULL) {
/* there should be no unprocessed tasks */
g_assert(g_thread_pool_unprocessed (thread_pool) == 0);
g_thread_pool_free(thread_pool, FALSE, FALSE);
}
g_free(session->storage_path);
g_mutex_free(session->priv->lock);
g_mutex_free(session->priv->thread_lock);
if (session->priv->junk_headers) {
g_hash_table_remove_all (session->priv->junk_headers);
g_hash_table_destroy (session->priv->junk_headers);
}
g_free(session->priv);
}
/**
* Function called every second to cleanup things:
* - remove old connections
* - refresh ACL cache
* - refresh localid auth cache
* - refresh limited connection
*/
void main_cleanup()
{
struct cache_message *cmessage;
struct internal_message *int_message;
/* remove old connections */
clean_connections_list();
/* info message about thread pools */
if (DEBUG_OR_NOT(DEBUG_LEVEL_INFO, DEBUG_AREA_MAIN)) {
if (g_thread_pool_unprocessed(nuauthdatas->user_workers)
|| g_thread_pool_unprocessed(nuauthdatas->
acl_checkers)
|| g_thread_pool_unprocessed(nuauthdatas->
user_loggers)) {
g_message
("%u user/%u acl/%u log unassigned task(s), %d "
"connection(s)",
g_thread_pool_unprocessed(nuauthdatas->
user_workers),
g_thread_pool_unprocessed(nuauthdatas->
acl_checkers),
g_thread_pool_unprocessed(nuauthdatas->
user_loggers),
g_hash_table_size(conn_list)
);
}
}
act_on_loggers_processing();
if (nuauthconf->acl_cache) {
/* send refresh message to acl cache thread */
cmessage = g_new0(struct cache_message, 1);
cmessage->type = REFRESH_MESSAGE;
g_async_queue_push(nuauthdatas->acl_cache->queue,
cmessage);
}
static gboolean
test_check_start_and_stop (gpointer user_data)
{
static guint test_number = 0;
static gboolean run_next = FALSE;
gboolean continue_timeout = TRUE;
gboolean quit = TRUE;
if (test_number == 0) {
run_next = TRUE;
DEBUG_MSG (("***** RUNNING TEST %2.2d *****", test_number));
}
if (run_next) {
test_number++;
switch (test_number) {
case 1:
test_thread_functions ();
break;
case 2:
test_thread_stop_unused ();
break;
case 3:
test_thread_pools ();
break;
case 4:
test_thread_sort (FALSE);
break;
case 5:
test_thread_sort (TRUE);
break;
case 6:
test_thread_idle_time ();
break;
default:
DEBUG_MSG (("***** END OF TESTS *****"));
g_main_loop_quit (main_loop);
continue_timeout = FALSE;
break;
}
run_next = FALSE;
return TRUE;
}
if (test_number == 3) {
G_LOCK (thread_counter_pools);
quit &= running_thread_counter <= 0;
DEBUG_MSG (("***** POOL RUNNING THREAD COUNT:%ld",
running_thread_counter));
G_UNLOCK (thread_counter_pools);
}
if (test_number == 4 || test_number == 5) {
G_LOCK (thread_counter_sort);
quit &= sort_thread_counter <= 0;
DEBUG_MSG (("***** POOL SORT THREAD COUNT:%ld",
sort_thread_counter));
G_UNLOCK (thread_counter_sort);
}
if (test_number == 6) {
guint idle;
idle = g_thread_pool_get_num_unused_threads ();
quit &= idle < 1;
DEBUG_MSG (("***** POOL IDLE THREAD COUNT:%d, UNPROCESSED JOBS:%d",
idle, g_thread_pool_unprocessed (idle_pool)));
}
if (quit) {
run_next = TRUE;
}
return continue_timeout;
}