sources/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"

#ifdef __cplusplus
extern "C"      {
#endif

/*
** EXTERNALS
*/

extern hlx_api gl_api;
extern hlx_scheduler    gl_scheduler;

/*
** FUNCTIONS
*/

void hlx_scheduler_construct(void)
{
        unsigned int i;
        hlx_group* group;

        gl_scheduler.loop = 0;
#if defined(HLX_BUILD_WITH_PARALLEL_THREADING)
        gl_scheduler.launched = 0;
#endif
        if (gl_api.get_cpu_count_entry != 0)
     {
       gl_scheduler.cpu_count = gl_api.get_cpu_count_entry(); 
           if (gl_scheduler.cpu_count < 1)
              gl_scheduler.cpu_count = 1;
    }
    else
        gl_scheduler.cpu_count = 1;
        hlx_list_construct(&gl_scheduler.groups);
    gl_scheduler.default_groups_id = gl_api.malloc_entry(gl_scheduler.cpu_count * sizeof(*(gl_scheduler.default_groups_id)));
    if (!gl_scheduler.default_groups_id)
                return;
        for (i = 0; i < gl_scheduler.cpu_count; ++i)
        {
                group = gl_api.malloc_entry(sizeof(*group));
                hlx_group_construct(group);
        hlx_list_push_back(&gl_scheduler.groups, group);
                gl_scheduler.default_groups_id[i] = (hlx_group_id)group;
        }
}

void hlx_scheduler_destruct(void)
{
        hlx_list_node* it;

        for (it = gl_scheduler.groups.first; it != 0; it = it->next)
        {
                hlx_group_destruct(it->data);
                gl_api.free_entry(it->data);
        }
        hlx_list_clear(&gl_scheduler.groups);
        gl_api.free_entry(gl_scheduler.default_groups_id);
        hlx_event_manager_destroy(hlx_event_get_default_manager());
}

hlx_group_id hlx_core_create_group(void)
{
        hlx_group* g;

        if ((g = gl_api.malloc_entry(sizeof(*g))) == 0)
           return ((hlx_group_id)-1);
    hlx_group_construct(g);
        hlx_list_push_back(&gl_scheduler.groups, g);
        return (g->id);
}

hlx_group* hlx_sheduler_find_lighter_group(void)
{
        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);
}

void hlx_core_add_task_in_group(hlx_task_func task_func, void* data, hlx_group_id group_id)
{
        hlx_core_add_task_in_group_callback(task_func, data, group_id, 0, 0);
}

void hlx_core_add_task(hlx_task_func task_func, void* data)
{
        hlx_core_add_task_in_group_callback(task_func, data, hlx_sheduler_find_lighter_group()->id, 0, 0);
}

hlx_task* hlx_scheduler_init_task(hlx_task_func task_func, void* data, hlx_group* group, hlx_task_callback callback)
{
        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);
}

int hlx_scheduler_schedule_group(hlx_group* group)
{
        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);
}

#ifdef __cplusplus
}
#endif

/*
** END OF FILE
*/