vheap.h File Reference

#include <zrtos/debug.h>
#include <zrtos/mem.h>
#include <zrtos/vheap_chunk.h>

Include dependency graph for vheap.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_t

Macros
#define	ZRTOS_VHEAP__INIT(name, heap_size)
#define	ZRTOS_VHEAP__GET(name)   ((zrtos_vheap_t*)&(name.heap[0]))
#define	ZRTOS_VHEAP__EACH_EX_BEGIN(thiz, start_offset, l, type, value)
#define	ZRTOS_VHEAP__EACH_EX_END
#define	ZRTOS_VHEAP__EACH_BEGIN(thiz, type, value)
#define	ZRTOS_VHEAP__EACH_END

Typedefs
typedef struct _zrtos_vheap_t	zrtos_vheap_t

Functions
bool	zrtos_vheap__init (zrtos_vheap_t *thiz, void *heap, size_t heap_size)
void *	zrtos_vheap__get_last_address (zrtos_vheap_t *thiz)
void *	zrtos_vheap__get_stack_ptr (zrtos_vheap_t *thiz)
size_t	_zrtos_vheap__get_free_space_ex (zrtos_vheap_t *thiz, void *stack_ptr)
size_t	_zrtos_vheap__get_free_space (zrtos_vheap_t *thiz)
zrtos_vheap_chunk_t *	zrtos_vheap__get_by_id (zrtos_vheap_t *thiz, zrtos_vheap_chunk_uid_t uid)
zrtos_vheap_chunk_t *	zrtos_vheap__get_by_type (zrtos_vheap_t *thiz, zrtos_vheap_chunk_type_t type)
zrtos_vheap_chunk_t *	zrtos_vheap__get_by_type_ex (zrtos_vheap_t *thiz, zrtos_vheap_type_t type)
static zrtos_vheap_chunk_uid_t	zrtos_vheap__get_next_uid (zrtos_vheap_t *thiz)
size_t	zrtos_vheap__get_chunk_count (zrtos_vheap_t *thiz)
zrtos_vheap_chunk_t *	_zrtos_vheap__malloc (zrtos_vheap_t *thiz, zrtos_vheap_chunk_uid_t parent, zrtos_vheap_type_t type, size_t length)
zrtos_vheap_chunk_uid_t	zrtos_vheap__malloc (zrtos_vheap_t *thiz, zrtos_vheap_chunk_uid_t parent, zrtos_vheap_type_t type, size_t length)
static void	_zrtos_vheap__update_index_ptr (zrtos_vheap_t *thiz, zrtos_vheap_chunk_t *chunk, size_t sizeof_mem_chunk)
zrtos_vheap_chunk_t *	zrtos_vheap__get_child (zrtos_vheap_t *thiz, zrtos_vheap_chunk_t *chunk)
void	zrtos_vheap__free_helper (zrtos_vheap_t *thiz, zrtos_vheap_chunk_t *chunk)
void	_zrtos_vheap__free (zrtos_vheap_t *thiz, zrtos_vheap_chunk_t *chunk)
void	zrtos_vheap__free (zrtos_vheap_t *thiz, zrtos_vheap_chunk_uid_t uid)
static void *	_zrtos_vheap__swap_to_heap_end (void *heap, size_t heap_length, size_t used_length, size_t chunk_offset, size_t chunk_length)
void *	zrtos_vheap__page_in (zrtos_vheap_t *thiz, zrtos_vheap_chunk_t *chunk)
void	zrtos_vheap__page_out (zrtos_vheap_t *thiz, zrtos_vheap_chunk_t *chunk, size_t length)

Macro Definition Documentation

ZRTOS_VHEAP__EACH_BEGIN

#define ZRTOS_VHEAP__EACH_BEGIN	(		thiz,
			type,
			value
	)

Value:

for(size_t l__ = 0,len__=(thiz)->length;l__ < len__;l__++){                \
        zrtos_vheap_chunk_t *value = &((zrtos_vheap_chunk_t*)((thiz)->ptr))[l];    \
        if(zrtos_vheap_chunk__is_type_eq(value,type))

Definition at line 406 of file vheap.h.

ZRTOS_VHEAP__EACH_END

#define ZRTOS_VHEAP__EACH_END

Value:

}                   \
    }

Definition at line 411 of file vheap.h.

ZRTOS_VHEAP__EACH_EX_BEGIN

#define ZRTOS_VHEAP__EACH_EX_BEGIN	(		thiz,
			start_offset,
			l,
			type,
			value
	)

Value:

for(size_t l = start_offset,len__=(thiz)->length;l < len__;l++){           \
        zrtos_vheap_chunk_t *value = &((zrtos_vheap_chunk_t*)((thiz)->ptr))[l];    \
        if(zrtos_vheap_chunk__is_type_eq(value,type)){

Definition at line 397 of file vheap.h.

ZRTOS_VHEAP__EACH_EX_END

#define ZRTOS_VHEAP__EACH_EX_END

Value:

}                      \
    }

Definition at line 402 of file vheap.h.

ZRTOS_VHEAP__GET

#define ZRTOS_VHEAP__GET

(

name

)

((zrtos_vheap_t*)&(name.heap[0]))

Definition at line 25 of file vheap.h.

ZRTOS_VHEAP__INIT

#define ZRTOS_VHEAP__INIT	(		name,
			heap_size
	)

Value:

static struct{                                        \
        uint8_t heap[heap_size];                          \
    }__attribute__((aligned(ZRTOS_ARCH__BYTE_ALIGNMENT)))name;

Definition at line 19 of file vheap.h.

Typedef Documentation

zrtos_vheap_t

typedef struct _zrtos_vheap_t zrtos_vheap_t

Function Documentation

_zrtos_vheap__free()

void _zrtos_vheap__free	(	zrtos_vheap_t *	thiz,
		zrtos_vheap_chunk_t *	chunk
	)

Definition at line 275 of file vheap.h.

                                                                       {
    while(true){
        zrtos_vheap_chunk_t *node = zrtos_vheap__get_child(thiz,chunk);
        if(node){
            zrtos_vheap_chunk_t *last = node;
            while((node = zrtos_vheap__get_child(thiz,node))){
                last = node;
            }
            _zrtos_vheap__free_helper(thiz,last);
        }else{
            break;
        }
    }
    _zrtos_vheap__free_helper(thiz,chunk);
}

Here is the call graph for this function:

Here is the caller graph for this function:

_zrtos_vheap__get_free_space()

size_t _zrtos_vheap__get_free_space

(

zrtos_vheap_t *

thiz

)

Definition at line 74 of file vheap.h.

                                                        {
    return _zrtos_vheap__get_free_space_ex(
         thiz
        ,zrtos_vheap__get_stack_ptr(thiz)
    );
}

Here is the call graph for this function:

Here is the caller graph for this function:

_zrtos_vheap__get_free_space_ex()

size_t _zrtos_vheap__get_free_space_ex	(	zrtos_vheap_t *	thiz,
		void *	stack_ptr
	)

Definition at line 60 of file vheap.h.

                                                                           {
    return
          thiz->ptr < stack_ptr
        ? zrtos_types__ptr_get_byte_distance(
            ZRTOS_TYPES__MIN(
                 stack_ptr
                ,zrtos_vheap__get_last_address(thiz)
            )
            ,thiz->ptr
        )
        : 0
    ;
}

Here is the call graph for this function:

Here is the caller graph for this function:

_zrtos_vheap__malloc()

zrtos_vheap_chunk_t* _zrtos_vheap__malloc	(	zrtos_vheap_t *	thiz,
		zrtos_vheap_chunk_uid_t	parent,
		zrtos_vheap_type_t	type,
		size_t	length
	)

Definition at line 145 of file vheap.h.

 {
    zrtos_vheap_chunk_t *chunk = 0;
    size_t free_space = _zrtos_vheap__get_free_space(thiz);
    size_t length_total = sizeof(zrtos_vheap_chunk_t) + length;
    if(free_space >= length_total){
        zrtos_vheap_chunk_t *node;
        size_t index_length = (sizeof(zrtos_vheap_chunk_t) * thiz->length);
        size_t heap_length = thiz->heap_size - index_length;

        uint8_t *src = thiz->ptr + thiz->heap_size;
        uint8_t *dest = src + sizeof(zrtos_vheap_chunk_t);

        thiz->heap_size += length_total;

        zrtos_mem__move_right_overlapping(
             dest - heap_length
            ,src - heap_length
            ,heap_length
        );

        chunk = &((zrtos_vheap_chunk_t*)thiz->ptr)[thiz->length++];
    chunk->first[0] = 0x55;
    chunk->first[1] = 0x55;

        chunk->ptr = thiz->ptr + thiz->heap_size - length;
        chunk->length = length;
        chunk->uid = zrtos_vheap__get_next_uid(thiz);
        chunk->parent = parent;
        chunk->type.type = type;
    chunk->last[0] = 0x66;
    chunk->last[1] = 0x66;

        //update index
        node = &((zrtos_vheap_chunk_t*)thiz->ptr)[0];
        for(;node < chunk;node++){
            node->ptr += sizeof(zrtos_vheap_chunk_t);
        }

        ZRTOS_DEBUG__CODE(
            static uint8_t pattern = 0xE0;
            zrtos_debug__memset(chunk->ptr,(int)(pattern++),chunk->length);
        );
    }
    return chunk;
}

Here is the call graph for this function:

Here is the caller graph for this function:

_zrtos_vheap__swap_to_heap_end()

static void* _zrtos_vheap__swap_to_heap_end ( void *  heap, size_t  heap_length, size_t  used_length, size_t  chunk_offset, size_t  chunk_length  )

static

Definition at line 299 of file vheap.h.

 {
    uint8_t *buffer = heap;
    void *ret = buffer + heap_length - chunk_length;
    zrtos_mem__left_rotate(
         buffer + chunk_offset
        ,chunk_length
        ,used_length - chunk_offset
    );
    zrtos_mem__move_right_overlapping(
         ret//buffer + heap_length - chunk_length
        ,buffer + used_length - chunk_length
        ,chunk_length
    );
    return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

_zrtos_vheap__update_index_ptr()

static void _zrtos_vheap__update_index_ptr ( zrtos_vheap_t *  thiz, zrtos_vheap_chunk_t *  chunk, size_t  sizeof_mem_chunk  )

static

Definition at line 214 of file vheap.h.

 {
    size_t length = chunk->length;
    zrtos_vheap_chunk_t *node = &((zrtos_vheap_chunk_t*)thiz->ptr)[0];
    zrtos_vheap_chunk_t *sentinel = &((zrtos_vheap_chunk_t*)thiz->ptr)[thiz->length];
    for(;node < sentinel;node++){
        node->ptr -= sizeof_mem_chunk/*sizeof(zrtos_vheap_chunk_t)*/ + (node > chunk ? length : 0);
    }
}

Here is the caller graph for this function:

zrtos_vheap__free()

void zrtos_vheap__free	(	zrtos_vheap_t *	thiz,
		zrtos_vheap_chunk_uid_t	uid
	)

Definition at line 291 of file vheap.h.

                                                                       {
    zrtos_vheap_chunk_t *chunk = zrtos_vheap__get_by_id(
         thiz
        ,uid
    );
    _zrtos_vheap__free(thiz,chunk);
}

Here is the call graph for this function:

zrtos_vheap__free_helper()

void zrtos_vheap__free_helper	(	zrtos_vheap_t *	thiz,
		zrtos_vheap_chunk_t *	chunk
	)

Todo:

cancel running task...

Definition at line 240 of file vheap.h.

                                                                             {
    /// @todo cancel running task...
    uint8_t *dest = (uint8_t*)chunk;
    uint8_t *src = dest + sizeof(zrtos_vheap_chunk_t);
    zrtos_vheap_chunk_t *sentinel;
    size_t length = chunk->length;
    size_t length_total = sizeof(zrtos_vheap_chunk_t) + length;
    int lp = 1;
    void *chunk_ptr = chunk->ptr;

    //update index
    _zrtos_vheap__update_index_ptr(thiz,chunk,sizeof(zrtos_vheap_chunk_t));

    //1st loop delete index, 2nd loop delete element
    sentinel = chunk_ptr;//zrtos_types__ptr_add(chunk->ptr,sizeof(zrtos_vheap_chunk_t));
    do{
        while(src < ((uint8_t*)sentinel)){
            *dest++ = *src++;
        }
        src += length;
        sentinel = zrtos_types__ptr_add(thiz->ptr,thiz->heap_size);
    }while(lp--);

    thiz->length--;
    thiz->heap_size -= length_total;

    ZRTOS_DEBUG__CODE(
        zrtos_debug__memset(
             zrtos_types__ptr_add(thiz->ptr,thiz->heap_size)
            ,0xEE
            ,length_total
        );
    );
}

Here is the call graph for this function:

zrtos_vheap__get_by_id()

zrtos_vheap_chunk_t* zrtos_vheap__get_by_id	(	zrtos_vheap_t *	thiz,
		zrtos_vheap_chunk_uid_t	uid
	)

Definition at line 81 of file vheap.h.

 {
    zrtos_vheap_chunk_t *node = thiz->ptr;
    for(size_t l = thiz->length;l--;node++){
        if(node->uid.uid == uid.uid){
            return node;
        }
    }
    return 0;
}

Here is the caller graph for this function:

zrtos_vheap__get_by_type()

zrtos_vheap_chunk_t* zrtos_vheap__get_by_type	(	zrtos_vheap_t *	thiz,
		zrtos_vheap_chunk_type_t	type
	)

Definition at line 94 of file vheap.h.

 {
    zrtos_vheap_chunk_t *node = thiz->ptr;
    for(size_t l = thiz->length;l--;node++){
        if(node->type.type == type.type){
            return node;
        }
    }
    return 0;
}

Here is the caller graph for this function:

zrtos_vheap__get_by_type_ex()

zrtos_vheap_chunk_t* zrtos_vheap__get_by_type_ex	(	zrtos_vheap_t *	thiz,
		zrtos_vheap_type_t	type
	)

Definition at line 107 of file vheap.h.

 {
    zrtos_vheap_chunk_type_t tmp;
    zrtos_vheap_chunk_type__init(&tmp,type);
    return zrtos_vheap__get_by_type(
         thiz
        ,tmp
    );
}

Here is the call graph for this function:

Here is the caller graph for this function:

zrtos_vheap__get_child()

zrtos_vheap_chunk_t* zrtos_vheap__get_child	(	zrtos_vheap_t *	thiz,
		zrtos_vheap_chunk_t *	chunk
	)

Definition at line 227 of file vheap.h.

                                                                                           {
    zrtos_vheap_chunk_t *node = &((zrtos_vheap_chunk_t*)thiz->ptr)[0];
    zrtos_vheap_chunk_t *sentinel = &((zrtos_vheap_chunk_t*)thiz->ptr)[thiz->length];
    zrtos_vheap_chunk_t *ret = 0;
    for(;node < sentinel;node++){
        if(zrtos_vheap_chunk_uid__cmp(&chunk->uid,&node->parent)){
            ret = node;
            break;
        }
    }
    return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

zrtos_vheap__get_chunk_count()

size_t zrtos_vheap__get_chunk_count

(

zrtos_vheap_t *

thiz

)

Definition at line 139 of file vheap.h.

 {
    return thiz->length / sizeof(zrtos_vheap_chunk_t);
}

zrtos_vheap__get_last_address()

void* zrtos_vheap__get_last_address

(

zrtos_vheap_t *

thiz

)

Definition at line 52 of file vheap.h.

                                                        {
    return zrtos_types__ptr_add(thiz->ptr,thiz->total_size);
}

Here is the call graph for this function:

Here is the caller graph for this function:

zrtos_vheap__get_next_uid()

static zrtos_vheap_chunk_uid_t zrtos_vheap__get_next_uid ( zrtos_vheap_t *  thiz )

static

Definition at line 119 of file vheap.h.

 {
    static zrtos_vheap_chunk_uid_t uid = {
        .uid = 1
    };
    zrtos_vheap_chunk_uid_t ret = {
        .uid = uid.uid++
    };

    while(ret.uid == 0 || zrtos_vheap__get_by_id(
         thiz
        ,ret
    )){
        ret.uid++;
    }

    return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

zrtos_vheap__get_stack_ptr()

void* zrtos_vheap__get_stack_ptr

(

zrtos_vheap_t *

thiz

)

Definition at line 56 of file vheap.h.

                                                     {
    return ZRTOS_ARCH__GET_STACK_PTR();
}

Here is the caller graph for this function:

zrtos_vheap__init()

bool zrtos_vheap__init	(	zrtos_vheap_t *	thiz,
		void *	heap,
		size_t	heap_size
	)

Definition at line 35 of file vheap.h.

 {
    ZRTOS_DEBUG__CODE(
        zrtos_debug__memset(heap,0xEE,heap_size);
    );

    thiz->ptr = heap;
    thiz->length = 0;
    thiz->heap_size = 0;
    thiz->total_size = heap_size;

    return true;
}

zrtos_vheap__malloc()

zrtos_vheap_chunk_uid_t zrtos_vheap__malloc	(	zrtos_vheap_t *	thiz,
		zrtos_vheap_chunk_uid_t	parent,
		zrtos_vheap_type_t	type,
		size_t	length
	)

Definition at line 196 of file vheap.h.

 {
    zrtos_vheap_chunk_t *chunk = _zrtos_vheap__malloc(
         thiz
        ,parent
        ,type
        ,length
    );
    if(chunk){
        return chunk->uid;
    }
    return zrtos_vheap_chunk_uid__error();
}

Here is the call graph for this function:

zrtos_vheap__page_in()

void* zrtos_vheap__page_in	(	zrtos_vheap_t *	thiz,
		zrtos_vheap_chunk_t *	chunk
	)

Definition at line 321 of file vheap.h.

 {
    size_t index_length = (sizeof(zrtos_vheap_chunk_t) * thiz->length);
    void *ptr_index = zrtos_types__ptr_add(thiz->ptr,index_length);
    void *chunk_ptr = chunk->ptr;
    void *ret;

    //update index
    _zrtos_vheap__update_index_ptr(thiz,chunk,0);

    ret = _zrtos_vheap__swap_to_heap_end(
         ptr_index
        ,thiz->total_size - index_length
        ,thiz->heap_size - index_length
        ,zrtos_types__ptr_get_byte_distance(chunk_ptr,ptr_index)
        ,chunk->length
    );

    thiz->heap_size -= chunk->length;
    //chunk->ptr = 0;
    chunk->length = 0;
    zrtos_vheap_chunk__set_type(chunk,ZRTOS_VHEAP_TYPE__TASK_ACTIVE);

    return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

zrtos_vheap__page_out()

void zrtos_vheap__page_out	(	zrtos_vheap_t *	thiz,
		zrtos_vheap_chunk_t *	chunk,
		size_t	length
	)

Definition at line 349 of file vheap.h.

 {
    uint8_t *heap_end_ptr = zrtos_types__ptr_add(thiz->ptr,thiz->heap_size);
    zrtos_mem__move_left_overlapping(
         heap_end_ptr
        ,zrtos_types__ptr_add(thiz->ptr,thiz->total_size - length)
        ,length
    );

    thiz->heap_size += length;

    chunk->ptr = heap_end_ptr;
    chunk->length = length;
    zrtos_vheap_chunk__set_type(
         chunk
        ,(
              chunk->type.type == ZRTOS_VHEAP_TYPE__TASK_ACTIVE
            ? ZRTOS_VHEAP_TYPE__TASK_IDLE
            : chunk->type.type
        )
    );

    //move chunk to end of index
    size_t index_length = (sizeof(zrtos_vheap_chunk_t) * thiz->length);
    zrtos_mem__left_rotate(
         chunk
        ,sizeof(zrtos_vheap_chunk_t)
        ,zrtos_types__ptr_get_byte_distance(
            zrtos_types__ptr_add(
                 thiz->ptr
                ,index_length
            )
            ,chunk
        )
    );

    ZRTOS_DEBUG__CODE(
        zrtos_debug__memset(
             zrtos_types__ptr_add(heap_end_ptr,length)
            ,0xEE
            ,thiz->total_size - thiz->heap_size
        );
    );
}

Here is the call graph for this function:

Here is the caller graph for this function: