#include "hlx/core.h"
#include "helixis_internal.h"

Functions
hlx_group *	hlx_sheduler_find_lighter_group (void)
hlx_task *	hlx_scheduler_init_task (hlx_task_func task_func, void data, hlx_group group, hlx_task_callback callback)
void	hlx_scheduler_schedule (void)
int	hlx_scheduler_schedule_group (hlx_group *)
void	hlx_core_add_task_in_group_callback2 (hlx_task_func task_func, void *data, hlx_group_id group_id, hlx_task_callback callback)
void	hlx_core_add_task_in_group_callback (hlx_task_func task_func, void *data, hlx_group_id group_id, hlx_group_id self_group_id, hlx_task_callback callback)
void	hlx_core_add_task_callback (hlx_task_func task_func, void *data, hlx_group_id self_group_id, hlx_task_callback callback)
void	hlx_sheduler_end_all_threads ()
static void	hlx_scheduler_schedule_group_threaded (hlx_thread thread, void data)
Variables
hlx_api	gl_api
hlx_scheduler	gl_scheduler

Function Documentation

void hlx_core_add_task_callback	(	hlx_task_func	task_func,
		void *	data,
		hlx_group_id	self_group_id,
		hlx_task_callback	callback
	)

Add a task in the lighter group and call a callback when the task finished

Parameters:

task	The task to push.
data	User argument (optionnal).
self_group_id	Current group id.
callback	The callback to call the task finished

See also:: hlx_core_add_task()

Definition at line 84 of file parallel_sched.c.

References hlx_core_add_task_in_group_callback(), hlx_core_add_task_in_group_callback2(), hlx_sheduler_find_lighter_group(), and hlx_group::id.

Referenced by hlx_event_notify().

{
        hlx_group* best;

        best = hlx_sheduler_find_lighter_group();
        if (best->id == self_group_id)
        {
                hlx_core_add_task_in_group_callback2(task_func, data, best->id, callback);
                return;
        }
        hlx_core_add_task_in_group_callback(task_func, data, best->id, self_group_id, callback);
}

void hlx_core_add_task_in_group_callback	(	hlx_task_func	task_func,
		void *	data,
		hlx_group_id	group_id,
		hlx_group_id	self_group_id,
		hlx_task_callback	callback
	)

Add a task in a group and call a callback when the task finished

Parameters:

task	The task to push.
data	User argument (optionnal).
group_id	Group id where the task will be pushed.
self_group_id	Current group id.
callback	The callback to call the task finished

See also:: hlx_core_create_group(); hlx_core_add_task_in_group()

Definition at line 66 of file parallel_sched.c.

References hlx_core_add_task_in_group_callback2(), hlx_group_bufferize_task(), hlx_scheduler_init_task(), hlx_api::thread_api, and hlx_thread_api::thread_resume.

Referenced by hlx_core_add_task(), hlx_core_add_task_callback(), hlx_core_add_task_in_group(), and hlx_event_notify().

{
        hlx_task* task;
        hlx_group* group;

        group = (hlx_group* )group_id;
        if (group_id == self_group_id)
        {
                hlx_core_add_task_in_group_callback2(task_func, data, group_id, callback);
                return ;
        }
        task = hlx_scheduler_init_task(task_func, data, group, callback);
        if (!task)
                return;
        hlx_group_bufferize_task(group, task);
        gl_api.thread_api.thread_resume(&(group->thread));
}

void hlx_core_add_task_in_group_callback2	(	hlx_task_func	task_func,
		void *	data,
		hlx_group_id	group_id,
		hlx_task_callback	callback
	)

Definition at line 97 of file parallel_sched.c.

References hlx_group_add_task(), hlx_group_bufferize_task(), hlx_scheduler_init_task(), hlx_api::thread_api, and hlx_thread_api::thread_resume.

Referenced by hlx_core_add_task_callback(), and hlx_core_add_task_in_group_callback().

{
        hlx_task* task;
        hlx_group* group;

        group = (hlx_group*)group_id;
        task = hlx_scheduler_init_task(task_func, data, group, callback);
        if (!task)
                return;
        if (gl_scheduler.launched)
                hlx_group_bufferize_task(group, task);
        else
                hlx_group_add_task(group, task);
        gl_api.thread_api.thread_resume(&(group->thread));
}

hlx_task* hlx_scheduler_init_task	(	hlx_task_func	task_func,
		void *	data,
		hlx_group *	group,
		hlx_task_callback	callback
	)

Definition at line 139 of file sched.c.

References hlx_task::callback, hlx_task::ctx, hlx_task::data, hlx_task::group_id, HLX_TASK_STATUS_RUN, hlx_group::id, hlx_api::malloc_entry, hlx_task::stack, hlx_task::status, and hlx_task::task_func.

Referenced by hlx_core_add_task_in_group_callback(), and hlx_core_add_task_in_group_callback2().

{
        hlx_task* task;

        task = gl_api.malloc_entry(sizeof (*task));
        if (!task)
                return (0);
        task->status = HLX_TASK_STATUS_RUN;
        task->task_func = task_func;
        task->data = data;
        task->stack = 0;
        task->group_id = group->id;
        task->callback = callback;
        task->ctx = 0;
        return (task);
}

void hlx_scheduler_schedule ( void )

Definition at line 191 of file parallel_sched.c.

References _hlx_list_node::data, hlx_list::first, hlx_scheduler::groups, hlx_scheduler_schedule_group_threaded(), hlx_scheduler::loop, _hlx_list_node::next, hlx_api::thread_api, hlx_thread_api::thread_execute, and hlx_thread_api::thread_wait_for.

Referenced by hlx_core_start().

{
        hlx_list_node* it;
        hlx_group* g;

        gl_scheduler.loop = 1;
        gl_scheduler.launched = 1;
        for (it = gl_scheduler.groups.first; it != 0; it = it->next)
        {
                g = it->data;
                gl_api.thread_api.thread_execute(&g->thread, hlx_scheduler_schedule_group_threaded, g);
        }
        for (it = gl_scheduler.groups.first; it != 0; it = it->next)
        {
                g = it->data;
                gl_api.thread_api.thread_wait_for(&(g->thread));
        }
        gl_scheduler.launched = 0;
}

int hlx_scheduler_schedule_group ( hlx_group * )

Definition at line 156 of file sched.c.

References hlx_task::callback, hlx_task::ctx, hlx_task::data, _hlx_list_node::data, hlx_list::first, hlx_api::free_entry, hlx_task::group_id, HLX_ENDED, HLX_EXITED, hlx_list_erase(), HLX_MEMORY_EXHAUSTED, HLX_TASK_STATUS_RUN, _hlx_list_node::next, hlx_task::stack, hlx_task::status, hlx_task::task_func, and hlx_group::tasks.

{
        hlx_list_node* it;
        hlx_list_node* tmp;
        hlx_task* task;
        int loop;
        int ret;

        loop = 0;
        it = group->tasks.first;
        while (it)
        {
                task = it->data;
                if (task->status != HLX_TASK_STATUS_RUN)
                {
                        it = it->next;
                        continue;
                }
                if (!task->task_func)
                        ret = HLX_EXITED;
                else
                        ret = task->task_func(&(task->ctx), task->group_id, &(task->stack), task->data);
                if (ret == HLX_ENDED || ret == HLX_EXITED || ret == HLX_MEMORY_EXHAUSTED)
                {
                        if (task->callback != 0)
                                task->callback(task->data, task->group_id, ret);
                        if (task->stack != 0)
                                gl_api.free_entry(task->stack);
                        gl_api.free_entry(task);
                        tmp = it->next;
                        hlx_list_erase(&group->tasks, it);
                        it = tmp;
                }
                else
                {
                        loop = 1;
                        it = it->next;
                }
        }
        return (loop);
}

static void hlx_scheduler_schedule_group_threaded	(	hlx_thread *	thread,
		void *	data
	)		`[static]`

Definition at line 126 of file parallel_sched.c.

References hlx_api::atomic_decr_entry, hlx_task::callback, hlx_task::ctx, hlx_task::data, _hlx_list_node::data, hlx_list::first, hlx_api::free_entry, hlx_task::group_id, hlx_scheduler::groups, HLX_ENDED, HLX_EXITED, hlx_group_flush_task_buffer(), hlx_list_erase(), HLX_MEMORY_EXHAUSTED, hlx_sheduler_end_all_threads(), HLX_TASK_STATUS_RUN, HLX_THREAD_LOCKED, HLX_THREAD_RUNNING, hlx_scheduler::loop, _hlx_list_node::next, hlx_task::stack, hlx_task::status, _hlx_thread::status, hlx_task::task_func, hlx_group::tasks, hlx_api::thread_api, hlx_thread_api::thread_pause_if_needed, and hlx_thread_api::thread_suspend.

Referenced by hlx_scheduler_schedule().

{
        int ret;
        hlx_list_node* it;
        hlx_list_node* tmp;
        hlx_task* task;
        hlx_group* group;
        hlx_group* tmp_group;

        group = (hlx_group*)data;
        tmp_group = (hlx_group*)data;
        while (gl_scheduler.loop == 1)
        {
                thread->status = HLX_THREAD_LOCKED;
                hlx_group_flush_task_buffer(group);
                if (!group->active_count)
                {
                        ret = 0;
                        for (it = gl_scheduler.groups.first; it; it = it->next)
                        {
                                tmp_group = it->data;
                                if (tmp_group != group && tmp_group->active_count)
                                {
                                        ret = 1;
                                        break;
                                }
                        }
                        if (ret)
                                gl_api.thread_api.thread_suspend(thread);
                        else if (thread->status == HLX_THREAD_LOCKED)
                        {
                                hlx_sheduler_end_all_threads();
                                return;
                        }
                }
                gl_api.thread_api.thread_pause_if_needed(thread);
                thread->status = HLX_THREAD_RUNNING;
                it = group->tasks.first;
                while (it)
                {
                        task = it->data;
                        if (task->status != HLX_TASK_STATUS_RUN)
                        {
                                it = it->next;
                                continue;
                        }
                        ret = task->task_func(&(task->ctx), task->group_id, &(task->stack), task->data);
                        if (ret == HLX_ENDED || ret == HLX_EXITED || ret == HLX_MEMORY_EXHAUSTED)
                        {
                                if (task->callback != 0)
                                        task->callback(task->data, task->group_id, ret);
                                gl_api.atomic_decr_entry(&group->active_count);
                                if (task->stack != 0)
                                        gl_api.free_entry(task->stack);
                                gl_api.free_entry(task);
                                tmp = it->next;
                                hlx_list_erase(&group->tasks, it);
                                it = tmp;
                        }
                        else
                                it = it->next;
                }
        }
}

void hlx_sheduler_end_all_threads ( void )

Definition at line 113 of file parallel_sched.c.

References _hlx_list_node::data, hlx_list::first, hlx_scheduler::groups, hlx_scheduler::loop, _hlx_list_node::next, hlx_api::thread_api, and hlx_thread_api::thread_resume.

Referenced by hlx_core_stop(), and hlx_scheduler_schedule_group_threaded().

{
        hlx_list_node* it;
        hlx_group* group;

        gl_scheduler.loop = 0;
        for (it = gl_scheduler.groups.first; it; it = it->next)
        {
                group = it->data;
                gl_api.thread_api.thread_resume(&(group->thread));
        }
}

hlx_group* hlx_sheduler_find_lighter_group ( void )

Definition at line 104 of file sched.c.

References hlx_scheduler::cpu_count, hlx_scheduler::default_groups_id, and hlx_group_get_size().

Referenced by hlx_core_add_task(), and hlx_core_add_task_callback().

{
        unsigned int i;
        unsigned int best_size;
        unsigned int group_size;
        hlx_group* best;
        hlx_group* group;

    best_size = 0;
    group_size = 0;
    best = 0;
    group = 0;
    for (i = 0; i < gl_scheduler.cpu_count; ++i)
    {
        group = (hlx_group*)(gl_scheduler.default_groups_id[i]);
        group_size = hlx_group_get_size(group);
        if (best == 0 || best_size > group_size)
        {
                best = group;
                best_size = group_size;
        }
    }
    return (group);
}

Variable Documentation

hlx_api gl_api

Definition at line 42 of file api.c.

hlx_scheduler gl_scheduler

Definition at line 50 of file parallel_sched.c.

Functions

Variables

Function Documentation

Variable Documentation