vheap_task_scheduler.h File Reference

#include <zrtos/types.h>
#include <zrtos/vheap_task.h>
#include <zrtos/vheap.h>

Include dependency graph for vheap_task_scheduler.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	_zrtos_vheap_task_scheduler_t

Macros
#define	ZRTOS_VHEAP_TASK_SCHEDULER__EACH_TASK_BEGIN(thiz, start_offset, pos, chunk, task)
#define	ZRTOS_VHEAP_TASK_SCHEDULER__EACH_TASK_END

Typedefs
typedef struct _zrtos_vheap_task_scheduler_t	zrtos_vheap_task_scheduler_t

Functions
zrtos_vheap_t *	zrtos_vheap_task_scheduler__get_heap (void)
void	zrtos_vheap_task_scheduler__set_heap (zrtos_vheap_t *heap)
zrtos_vheap_task_t *	_zrtos_vheap_task_scheduler__get_active_task (void)
static void	_zrtos_vheap_task_scheduler__restore_task (void)
static void	zrtos_vheap_task_scheduler__page_task_out (void)
static void	zrtos_vheap_task_scheduler__page_task_in (zrtos_vheap_chunk_t *chunk)
static bool	_zrtos_vheap_task_scheduler__set_active_task (zrtos_vheap_chunk_uid_t uid)
bool	zrtos_vheap_task_scheduler__has_enough_stack_space (zrtos_vheap_task_t *task, zrtos_vheap_chunk_t *chunk)
bool	zrtos_vheap_task_scheduler__start (void)
void	_zrtos_vheap_task_scheduler__switch_task (void)
void	_zrtos_vheap_task_scheduler__on_tick (void)
void	zrtos_vheap_task_scheduler__delay_ms (zrtos_vheap_task_delay_t ms)
void	zrtos_vheap_task_scheduler__trampoline_cb (zrtos_vheap_task_t *thiz, void *(*callback)(void *args), void *args)

Variables
volatile zrtos_vheap_task_scheduler_t	zrtos_vheap_task_scheduler = {}

Macro Definition Documentation

ZRTOS_VHEAP_TASK_SCHEDULER__EACH_TASK_BEGIN

#define ZRTOS_VHEAP_TASK_SCHEDULER__EACH_TASK_BEGIN	(		thiz,
			start_offset,
			pos,
			chunk,
			task
	)

Value:

ZRTOS_VHEAP__EACH_EX_BEGIN(                                                  \
         thiz                                                                  \
        ,start_offset                                                          \
        ,pos                                                                   \
        ,ZRTOS_VHEAP_TYPE__TASK_IDLE                                       \
        ,chunk                                                                 \
    ){                                                                         \
        zrtos_vheap_task_t *task = zrtos_types__ptr_subtract(                        \
            zrtos_types__ptr_add(                                              \
                 zrtos_vheap_chunk__get_ptr(chunk)                               \
                ,zrtos_vheap_chunk__get_length(chunk)                            \
            )                                                                  \
            ,sizeof(zrtos_vheap_task_t)                                              \
        );                                                                     \
        {

Definition at line 137 of file vheap_task_scheduler.h.

ZRTOS_VHEAP_TASK_SCHEDULER__EACH_TASK_END

#define ZRTOS_VHEAP_TASK_SCHEDULER__EACH_TASK_END

Value:

}                                   \
     }ZRTOS_VHEAP__EACH_EX_END

Definition at line 154 of file vheap_task_scheduler.h.

Typedef Documentation

zrtos_vheap_task_scheduler_t

typedef struct _zrtos_vheap_task_scheduler_t zrtos_vheap_task_scheduler_t

Function Documentation

_zrtos_vheap_task_scheduler__get_active_task()

zrtos_vheap_task_t* _zrtos_vheap_task_scheduler__get_active_task

(

void

)

Definition at line 38 of file vheap_task_scheduler.h.

                                                                      {
    return zrtos_types__ptr_subtract(
         zrtos_vheap__get_last_address(zrtos_vheap_task_scheduler__get_heap())
        ,sizeof(zrtos_vheap_task_t)
    );
}

Here is the call graph for this function:

Here is the caller graph for this function:

_zrtos_vheap_task_scheduler__on_tick()

void _zrtos_vheap_task_scheduler__on_tick

(

void

)

Definition at line 206 of file vheap_task_scheduler.h.

                                               {
    ZRTOS_ARCH__SAVE_CPU_STATE_EX(zrtos_vheap_task_scheduler.tmp_stack_ptr);

    ZRTOS_DEBUG__CODE({
        zrtos_debug__memset(
             (void*)zrtos_vheap_task_scheduler.ctx_switch_task_stack
            ,0xbb
            ,ZRTOS_TYPES__GET_STATIC_ARRAY_LENGTH(
                zrtos_vheap_task_scheduler.ctx_switch_task_stack
            )*sizeof(zrtos_vheap_task_scheduler.ctx_switch_task_stack[0])
        );
    });

    ZRTOS_ARCH__SET_STACK_PTR(
          zrtos_vheap_task_scheduler.ctx_switch_task_stack
        + ZRTOS_TYPES__GET_STATIC_ARRAY_LENGTH(
            zrtos_vheap_task_scheduler.ctx_switch_task_stack
        )
    );

    _zrtos_vheap_task_scheduler__switch_task();
}

Here is the call graph for this function:

Here is the caller graph for this function:

_zrtos_vheap_task_scheduler__restore_task()

static void _zrtos_vheap_task_scheduler__restore_task ( void  )

static

Definition at line 47 of file vheap_task_scheduler.h.

                                                           {
    ZRTOS_ARCH__LOAD_CPU_STATE_EX(zrtos_vheap_task_scheduler.tmp_stack_ptr);
    ZRTOS_ARCH__RETURN_FROM_INTERRUPT();
}

Here is the caller graph for this function:

_zrtos_vheap_task_scheduler__set_active_task()

static bool _zrtos_vheap_task_scheduler__set_active_task ( zrtos_vheap_chunk_uid_t  uid )

static

Definition at line 84 of file vheap_task_scheduler.h.

 {
    zrtos_vheap_t *heap = zrtos_vheap_task_scheduler__get_heap();
    zrtos_vheap_chunk_t *chunk;
    zrtos_vheap_task_scheduler__page_task_out();
    chunk = zrtos_vheap__get_by_id(
         heap
        ,uid
    );
    zrtos_vheap_task_scheduler__page_task_in(/*task,*/chunk);

    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

_zrtos_vheap_task_scheduler__switch_task()

void _zrtos_vheap_task_scheduler__switch_task

(

void

)

Definition at line 158 of file vheap_task_scheduler.h.

                                                   {
    uint8_t tmp = 1;
    size_t offset = 0;
    do{
        ZRTOS_VHEAP_TASK_SCHEDULER__EACH_TASK_BEGIN(
             zrtos_vheap_task_scheduler__get_heap()
            ,offset
            ,pos
            ,chunk
            ,task
        ){
            if(tmp){
                zrtos_vheap_task__on_tick(task);
            }else{
                if(!zrtos_vheap_task__is_idle(task)
                && zrtos_vheap_task_scheduler__has_enough_stack_space(
                     task
                    ,chunk
                )
                ){
                    /*size_t chunk_count = zrtos_vheap__get_chunk_count(
                        zrtos_vheap_task_scheduler__get_heap()
                    );

                    zrtos_vheap_task_scheduler.start_offset = pos+1;
                    zrtos_vheap_task_scheduler.start_offset = zrtos_vheap_task_scheduler.start_offset < chunk_count
                                ? zrtos_vheap_task_scheduler.start_offset
                                : 0
                    ;*/

                    _zrtos_vheap_task_scheduler__set_active_task(
                         /*task
                        ,*/zrtos_vheap_chunk__get_uid(chunk)
                    );
                    goto L_OUT;
                }
            }
        }ZRTOS_VHEAP_TASK_SCHEDULER__EACH_TASK_END;

        //offset = zrtos_vheap_task_scheduler.start_offset;
    }while(tmp--);

L_OUT:
    _zrtos_vheap_task_scheduler__restore_task();
}

Here is the call graph for this function:

Here is the caller graph for this function:

zrtos_vheap_task_scheduler__delay_ms()

void zrtos_vheap_task_scheduler__delay_ms

(

zrtos_vheap_task_delay_t

ms

)

Definition at line 230 of file vheap_task_scheduler.h.

                                                                      {
    zrtos_vheap_task__set_delay_ms(
         _zrtos_vheap_task_scheduler__get_active_task()
        ,ms
    );
    _zrtos_vheap_task_scheduler__on_tick();
}

Here is the call graph for this function:

Here is the caller graph for this function:

zrtos_vheap_task_scheduler__get_heap()

zrtos_vheap_t* zrtos_vheap_task_scheduler__get_heap

(

void

)

Definition at line 30 of file vheap_task_scheduler.h.

                                                         {
    return zrtos_vheap_task_scheduler.heap;
}

Here is the caller graph for this function:

zrtos_vheap_task_scheduler__has_enough_stack_space()

bool zrtos_vheap_task_scheduler__has_enough_stack_space	(	zrtos_vheap_task_t *	task,
		zrtos_vheap_chunk_t *	chunk
	)

Definition at line 101 of file vheap_task_scheduler.h.

 {
    zrtos_vheap_t *mem = zrtos_vheap_task_scheduler__get_heap();
    //@todo stack_size_min
    //size_t stack_size_min = zrtos_vheap_task__get_stack_size_min(task);
    if(_zrtos_vheap__get_free_space_ex(
         mem
        ,zrtos_vheap_task_scheduler.tmp_stack_ptr
    )
    <=  ZRTOS_TYPES__MAX(
         zrtos_vheap_task__get_stack_size_min(task)
        ,zrtos_vheap_chunk__get_length(chunk)
    ) - zrtos_vheap_chunk__get_length(chunk)){
        ZRTOS_ARCH__FATAL();
        return false;
    }
    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

zrtos_vheap_task_scheduler__page_task_in()

static void zrtos_vheap_task_scheduler__page_task_in ( zrtos_vheap_chunk_t *  chunk )

static

Definition at line 69 of file vheap_task_scheduler.h.

 {
    zrtos_vheap_task_t *task;
    zrtos_vheap_t *heap = zrtos_vheap_task_scheduler__get_heap();
    zrtos_vheap__page_in(
         heap
        ,chunk
    );
    task = _zrtos_vheap_task_scheduler__get_active_task();
    zrtos_vheap_task_scheduler.tmp_stack_ptr = zrtos_vheap_task__get_stack_ptr(task);
    errno = zrtos_vheap_task__get_errno(_zrtos_vheap_task_scheduler__get_active_task());
}

Here is the call graph for this function:

Here is the caller graph for this function:

zrtos_vheap_task_scheduler__page_task_out()

static void zrtos_vheap_task_scheduler__page_task_out ( void  )

static

Definition at line 53 of file vheap_task_scheduler.h.

                                                           {
    zrtos_vheap_t *heap = zrtos_vheap_task_scheduler__get_heap();
    zrtos_vheap_task_t *task = _zrtos_vheap_task_scheduler__get_active_task();

    zrtos_vheap_task__set_stack_ptr(task,zrtos_vheap_task_scheduler.tmp_stack_ptr);
    zrtos_vheap_task__set_errno(task,errno);
    zrtos_vheap__page_out(
         heap
        ,zrtos_vheap__get_by_type_ex(heap,ZRTOS_VHEAP_TYPE__TASK_ACTIVE)
        ,zrtos_types__ptr_get_byte_distance(
             zrtos_vheap__get_last_address(heap)
            ,zrtos_vheap_task_scheduler.tmp_stack_ptr
        )
    );
}

Here is the call graph for this function:

Here is the caller graph for this function:

zrtos_vheap_task_scheduler__set_heap()

void zrtos_vheap_task_scheduler__set_heap

(

zrtos_vheap_t *

heap

)

Definition at line 34 of file vheap_task_scheduler.h.

                                                              {
    zrtos_vheap_task_scheduler.heap = heap;
}

zrtos_vheap_task_scheduler__start()

bool zrtos_vheap_task_scheduler__start

(

void

)

Definition at line 122 of file vheap_task_scheduler.h.

                                            { 
    zrtos_vheap_t *heap = zrtos_vheap_task_scheduler__get_heap();
    zrtos_vheap_chunk_t *chunk = zrtos_vheap__get_by_type_ex(
         heap
        ,ZRTOS_VHEAP_TYPE__TASK_IDLE
    );
    if(chunk){
        zrtos_vheap_task_scheduler__page_task_in(chunk);
        _zrtos_vheap_task_scheduler__restore_task();
        while(true){}
        return true;
    }
    return false;
}

Here is the call graph for this function:

zrtos_vheap_task_scheduler__trampoline_cb()

void zrtos_vheap_task_scheduler__trampoline_cb	(	zrtos_vheap_task_t *	thiz,
		void *(*)(void *args)	callback,
		void *	args
	)

Definition at line 238 of file vheap_task_scheduler.h.

 {
    void *ret = callback(args);
    zrtos_vheap_chunk_t *chunk = zrtos_vheap__get_by_type_ex(
         zrtos_vheap_task_scheduler__get_heap()
        ,ZRTOS_VHEAP_TYPE__TASK_ACTIVE
    );
    zrtos_vheap_task__set_return_value(thiz,ret);
    zrtos_vheap_chunk__set_type(chunk,ZRTOS_VHEAP_TYPE__TASK_DONE);

    _zrtos_vheap_task_scheduler__on_tick();

    __builtin_unreachable();
    while(1){
        //should not return
    }
}

Here is the call graph for this function:

Variable Documentation

zrtos_vheap_task_scheduler

volatile zrtos_vheap_task_scheduler_t zrtos_vheap_task_scheduler = {}

Definition at line 27 of file vheap_task_scheduler.h.