malloc_threadx.c File Reference

#include <assert.h>
#include <malloc.h>
#include <stdbool.h>
#include <stdint.h>
#include <threadx/tx_api.h>

Include dependency graph for malloc_threadx.c:

Go to the source code of this file.

Functions
	__attribute__ ((weak))
void	malloc_addblock (void *addr, size_t size)
	Assign blocks of memory for use by malloc(). More...
void *	malloc (size_t size)
void	free (void *ptr)

Variables
static TX_BYTE_POOL	malloc_pool_
	ThreadX internal memory pool stucture. More...
static volatile bool	initialized_ = false

Function Documentation

__attribute__()

__attribute__

(

(weak)

)

Definition at line 25 of file malloc_threadx.c.

{
    // Unused here, override to specify your own init functin
    // Which includes malloc_addblock calls
}

free()

void free

(

void *

ptr

)

free should NEVER be called before malloc is init'd

Definition at line 79 of file malloc_threadx.c.

{
    assert(initialized_);

    if(ptr)
    {
        // We simply wrap the threadX call into a standard form
        unsigned r = tx_byte_release(ptr);
        assert(r == TX_SUCCESS);
    }
}

References initialized_.

malloc()

void* malloc

(

size_t

size

)

In the ThreadX implementaiton, we make sure the ThreadX pool has been created before we try to allocate memory, or there will be an error. We sleep our threads until memory has been added.

Definition at line 53 of file malloc_threadx.c.

{
    void* ptr = NULL;

    while(!initialized_)
    {
        tx_thread_sleep(1);
    }

    if(size > 0)
    {
        // We simply wrap the threadX call into a standard form
        unsigned r = tx_byte_allocate(&malloc_pool_, &ptr, size, TX_WAIT_FOREVER);

        // I add the string to provide a more helpful error output.  It's value is always true.
        assert(r == TX_SUCCESS && "malloc failed");
    } // else NULL if there was an error

    return ptr;
}

References initialized_, and malloc_pool_.

malloc_addblock()

void malloc_addblock	(	void *	addr,
		size_t	size
	)

Assign blocks of memory for use by malloc().

malloc_addblock must be called before memory allocation calls are made. In this ThreadX implementation, malloc() calls will block until memory has been allocated

Definition at line 36 of file malloc_threadx.c.

{
    assert(addr && (size > 0));

    unsigned r;

    /*
     * tx_byte_pool_create is ThreadX's API to create a byte pool using a memory block.
     * We are essentially just wrapping ThreadX APIs into a simpler form
     */
    r = tx_byte_pool_create(&malloc_pool_, "Heap Memory Pool", addr, size);
    assert(r == TX_SUCCESS);

    // Signal to any threads waiting on do_malloc that we are done
    initialized_ = true;
}

References initialized_, and malloc_pool_.

Variable Documentation

initialized_

volatile bool initialized_ = false

static

Flag that is used in malloc() to cause competing threads to wait until initialization is completed before allocating memory.

Definition at line 21 of file malloc_threadx.c.

Referenced by free(), malloc(), and malloc_addblock().

malloc_pool_

TX_BYTE_POOL malloc_pool_

static

ThreadX internal memory pool stucture.

Definition at line 15 of file malloc_threadx.c.

Referenced by malloc(), and malloc_addblock().