sources/parallel/parallel_sched.c

Go to the documentation of this file.

/*
** Copyright 2009-2011, helixis.org
** All rights reserved.
**
** Redistribution and use in source and binary forms, with or without modification, are permitted provided
** that the following conditions are met:
**
** Redistributions of source code must retain the above copyright notice, this list of conditions and the
** following disclaimer.
**
** Redistributions in binary form must reproduce the above copyright notice, this list of conditions and
** the following disclaimer in the documentation and/or other materials provided with the distribution.
**
** Neither the name of the helixis.org nor the names of its contributors may be used to endorse or promote
** products derived from this software without specific prior written permission.
**
** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED
** WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
** PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
** ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
** TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
** HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
** NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
** POSSIBILITY OF SUCH DAMAGE.
*/

/*
** INCLUDES
*/

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

#if defined(HLX_BUILD_WITH_PARALLEL_THREADING)

#ifdef __cplusplus
extern "C"      {
#endif

/*
** EXTERNALS
*/

extern hlx_api gl_api;

/*
** GLOBALS
*/

hlx_scheduler   gl_scheduler;

/*
** PROTOTYPES
*/

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

/*
** FUNCTIONS
*/

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)
{
        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_callback(hlx_task_func task_func, void* data, hlx_group_id self_group_id, hlx_task_callback callback)
{
        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_callback2(hlx_task_func task_func, void* data, hlx_group_id group_id, hlx_task_callback 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));
}

void hlx_sheduler_end_all_threads()
{
        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));
        }
}

static void hlx_scheduler_schedule_group_threaded(hlx_thread* thread, void* data)
{
        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_scheduler_schedule(void)
{
        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;
}

#endif /* !HLX_BUILD_WITH_PARALLEL_THREADING */

#ifdef __cplusplus
}
#endif

/*
** END OF FILE
*/