malloc.h File Reference

#include <zrtos/assert.h>
#include <zrtos/types.h>
#include <zrtos/cast.h>
#include <zrtos/debug.h>

Include dependency graph for malloc.h:

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

Go to the source code of this file.

Data Structures
struct	_zrtos_malloc_t
struct	_zrtos_malloc_heap_chunk_t
struct	_zrtos_malloc_internal_t

Macros
#define	ZRTOS_MALLOC__BYTE_ALIGNMENT   ZRTOS_TYPES__BYTE_ALIGNMENT
#define	ZRTOS_MALLOC__GET_REQUIRED_SIZE(type, count)
#define	ZRTOS_MALLOC__GLOBAL_HEAP_INIT(name)
#define	ZRTOS_MALLOC__GLOBAL_HEAP(name, len)
#define	ZRTOS_MALLOC__INIT(name, len)

Typedefs
typedef struct _zrtos_malloc_t	zrtos_malloc_t
typedef struct _zrtos_malloc_heap_chunk_t	zrtos_malloc_heap_chunk_t
typedef struct _zrtos_malloc_internal_t	zrtos_malloc_internal_t

Functions
bool	zrtos_malloc__init (zrtos_malloc_t *thiz, size_t length)
static zrtos_malloc_heap_chunk_t *	zrtos_malloc__get_free_chunk (zrtos_malloc_t *thiz, size_t length)
void *	zrtos_malloc__malloc (zrtos_malloc_t *thiz, size_t length)
size_t	zrtos_malloc__get_length (void *ptr)
void	zrtos_malloc__free (void *ptr)

Macro Definition Documentation

ZRTOS_MALLOC__BYTE_ALIGNMENT

#define ZRTOS_MALLOC__BYTE_ALIGNMENT   ZRTOS_TYPES__BYTE_ALIGNMENT

Definition at line 21 of file malloc.h.

ZRTOS_MALLOC__GET_REQUIRED_SIZE

#define ZRTOS_MALLOC__GET_REQUIRED_SIZE	(		type,
			count
	)

Value:

( sizeof(zrtos_malloc_internal_t)                                   \
    +   (                                                               \
            (                                                           \
                  sizeof(zrtos_malloc_heap_chunk_t)                     \
                + zrtos_types__ceil_size_to_alignment(sizeof(type))     \
            )                                                           \
            * (count)                                                   \
        )                                                               \
    )

Definition at line 39 of file malloc.h.

ZRTOS_MALLOC__GLOBAL_HEAP

#define ZRTOS_MALLOC__GLOBAL_HEAP	(		name,
			len
	)

Value:

zrtos_malloc_t name[                                          \
        (len)                                                     \
    ] __attribute__((aligned(ZRTOS_MALLOC__BYTE_ALIGNMENT)));      \
                                                                  \
    ZRTOS_ASSERT__STATIC(len >= sizeof(zrtos_malloc_internal_t)); \
                                                                  \
    void *kmalloc(size_t length){                                  \
        return zrtos_malloc__malloc(                              \
             name                                                 \
            ,length                                               \
        );                                                        \
    }                                                             \
                                                                  \
    void kfree(void *ptr){                                         \
        zrtos_malloc__free(ptr);                                  \
    }

Definition at line 65 of file malloc.h.

ZRTOS_MALLOC__GLOBAL_HEAP_INIT

#define ZRTOS_MALLOC__GLOBAL_HEAP_INIT

(

name

)

Value:

zrtos_malloc__init(                                                 \
         name                                                           \
        ,sizeof(name) / sizeof(name[0])                                 \
    );                                                                  \
                                                                        \
    ZRTOS_DEBUG__CODE({                                                 \
        zrtos_debug__memset(                                            \
             zrtos_types__ptr_add(name,sizeof(zrtos_malloc_internal_t)) \
            ,0xFF                                                       \
            ,(sizeof(name) / sizeof(name[0]))                           \
            -sizeof(zrtos_malloc_internal_t)                            \
        );                                                              \
    });

Definition at line 50 of file malloc.h.

ZRTOS_MALLOC__INIT

#define ZRTOS_MALLOC__INIT	(		name,
			len
	)

Value:

zrtos_malloc_t name[                                          \
        (len)                                                     \
    ] __attribute__((aligned(ZRTOS_MALLOC__BYTE_ALIGNMENT)));      \
                                                                  \
    ZRTOS_ASSERT__STATIC(len >= sizeof(zrtos_malloc_internal_t)); \
                                                                  \
    zrtos_malloc__init(                                           \
         name                                                     \
        ,sizeof(name) / sizeof(name[0])                           \
    )

Definition at line 83 of file malloc.h.

Typedef Documentation

zrtos_malloc_heap_chunk_t

typedef struct _zrtos_malloc_heap_chunk_t zrtos_malloc_heap_chunk_t

zrtos_malloc_internal_t

typedef struct _zrtos_malloc_internal_t zrtos_malloc_internal_t

zrtos_malloc_t

typedef struct _zrtos_malloc_t zrtos_malloc_t

Function Documentation

zrtos_malloc__free()

void zrtos_malloc__free

(

void *

ptr

)

Definition at line 220 of file malloc.h.

                                  {
#ifndef ZRTOS_MALLOC__CFG_DISABLE_FREE
    zrtos_malloc_heap_chunk_t *chunk = ZRTOS_CAST(
         zrtos_malloc_heap_chunk_t*
        ,ptr
    );
    --chunk;
    chunk->length &= ~((size_t)1);

    ZRTOS_DEBUG__CODE({
        zrtos_debug__memset(ptr,0xFF,(chunk->length >> 1));
    });
#endif
}

Here is the caller graph for this function:

zrtos_malloc__get_free_chunk()

static zrtos_malloc_heap_chunk_t* zrtos_malloc__get_free_chunk ( zrtos_malloc_t *  thiz, size_t  length  )

static

Definition at line 112 of file malloc.h.

 {
    zrtos_malloc_internal_t *thiz_ = (zrtos_malloc_internal_t *)thiz;
    zrtos_malloc_heap_chunk_t *chunk = (zrtos_malloc_heap_chunk_t *)(thiz_+1);
    zrtos_malloc_heap_chunk_t *last = (zrtos_malloc_heap_chunk_t *)thiz_->ptr;
    length <<= 1;

    while(chunk != last){
        if((chunk->length & 1) == 0
        && (chunk->length >> 1) == length){
            return chunk;
        }
        chunk = (zrtos_malloc_heap_chunk_t *)zrtos_types__ptr_add(
             chunk
            ,sizeof(zrtos_malloc_heap_chunk_t) + (chunk->length>>1)
        );
    }

    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

zrtos_malloc__get_length()

size_t zrtos_malloc__get_length

(

void *

ptr

)

Definition at line 205 of file malloc.h.

                                          {
    zrtos_malloc_heap_chunk_t *chunk = ZRTOS_CAST(
         zrtos_malloc_heap_chunk_t*
        ,ptr
    );
    --chunk;
    return (chunk->length >> 1);
}

Here is the caller graph for this function:

zrtos_malloc__init()

bool zrtos_malloc__init	(	zrtos_malloc_t *	thiz,
		size_t	length
	)

Definition at line 95 of file malloc.h.

                                                           {
    zrtos_malloc_internal_t *thiz_ = (zrtos_malloc_internal_t *)thiz;
    bool ret = false;
    if(length >= sizeof(zrtos_malloc_internal_t)){
        thiz_->ptr = (uint8_t*)zrtos_types__ptr_add(thiz,sizeof(zrtos_malloc_internal_t));
        thiz_->length = length - sizeof(zrtos_malloc_internal_t);

        ZRTOS_DEBUG__CODE({
            zrtos_debug__memset(thiz_->ptr,0xFF,length);
        });

        ret = true;
    }
    return ret;
}

Here is the call graph for this function:

zrtos_malloc__malloc()

void* zrtos_malloc__malloc	(	zrtos_malloc_t *	thiz,
		size_t	length
	)

Definition at line 142 of file malloc.h.

                                                              {
#ifndef ZRTOS_MALLOC__CFG_DISABLE_FREE
    zrtos_malloc_internal_t *thiz_ = (zrtos_malloc_internal_t *)thiz;
    zrtos_malloc_heap_chunk_t *chunk = 0;
    size_t aligned_length = zrtos_types__ceil_size_to_alignment(length);
    size_t total_length = sizeof(zrtos_malloc_heap_chunk_t) + aligned_length;
    bool has_free_space = (thiz_->length
                        - zrtos_types__ptr_get_byte_distance(
                             thiz_->ptr
                            ,(thiz_ + 1)
                        ))
                        >= total_length
    ;

    if(aligned_length > (SIZE_MAX>>1)){
        //out of bounds
        goto L_OUT;
    }else if((chunk = zrtos_malloc__get_free_chunk(thiz,aligned_length))){
        chunk->length |= 1;
    }else if(has_free_space){
        chunk = (zrtos_malloc_heap_chunk_t*)thiz_->ptr;
        chunk->length = (aligned_length << 1) | 1;
        thiz_->ptr += total_length;
    }else{
        goto L_OUT;
    }

    chunk++;

    ZRTOS_DEBUG__CODE({
        static uint8_t pattern = 0x20;
        zrtos_debug__memset(chunk,pattern++,aligned_length);
    });

L_OUT:
    return chunk;
#else
    zrtos_malloc_internal_t *thiz_ = (zrtos_malloc_internal_t *)thiz;
    void *ret = 0;
    size_t aligned_length = zrtos_types__ceil_size_to_alignment(length);
    bool has_free_space = (thiz_->length
                        - zrtos_types__ptr_get_byte_distance(
                             thiz_->ptr
                            ,thiz_
                        ))
                        >= aligned_length
    ;

    if(has_free_space){
        ret = thiz_->ptr;
        thiz_->ptr += aligned_length;
    }

    ZRTOS_DEBUG__CODE({
        static uint8_t pattern = 0x20;
        zrtos_debug__memset(ret,pattern++,aligned_length);
    });

    return ret;
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function: