89 lines
2.8 KiB
C++
89 lines
2.8 KiB
C++
/**
|
|
* A simple 32 bit block based memory allocator. This allows one or more memory segments to
|
|
* be designated as heap storage, and is designed to run in a static memory area or inside the standard C
|
|
* heap for use by the micro:bit runtime. This is required for several reasons:
|
|
*
|
|
* 1) It reduces memory fragmentation due to the high churn sometime placed on the heap
|
|
* by ManagedTypes, fibers and user code. Underlying heap implentations are often have very simplistic
|
|
* allocation pilicies and suffer from fragmentation in prolonged use - which can cause programs to
|
|
* stop working after a period of time. The algorithm implemented here is simple, but highly tolerant to
|
|
* large amounts of churn.
|
|
*
|
|
* 2) It allows us to reuse the 8K of SRAM set aside for SoftDevice as additional heap storage
|
|
* when BLE is not in use.
|
|
*
|
|
* 3) It gives a simple example of how memory allocation works! :-)
|
|
*
|
|
* N.B. The need for this should be reviewed in the future, should a different memory allocator be
|
|
* made availiable in the mbed platform.
|
|
*
|
|
* P.S. This is a very simple allocator, therefore not without its weaknesses. Why don't you consider
|
|
* what these are, and consider the tradeoffs against simplicity...
|
|
*
|
|
* TODO: Consider caching recently freed blocks to improve allocation time.
|
|
*/
|
|
|
|
#ifndef MICROBIT_HEAP_ALLOCTOR_H
|
|
#define MICROBIT_HEAP_ALLOCTOR_H
|
|
|
|
#include "mbed.h"
|
|
#include <new>
|
|
|
|
// The number of heap segments created.
|
|
#define MICROBIT_HEAP_COUNT 2
|
|
|
|
// Flag to indicate that a given block is FREE/USED
|
|
#define MICROBIT_HEAP_BLOCK_FREE 0x80000000
|
|
|
|
int microbit_heap_init();
|
|
void *microbit_malloc(size_t size);
|
|
void microbit_free(void *mem);
|
|
|
|
/*
|
|
* Wrapper function to ensure we have an explicit handle on the heap allocator provided
|
|
* by our underlying platform.
|
|
*
|
|
* @param size The amount of memory to allocate.
|
|
* @return A pointer to the memory allocated. NULL if no memory is available.
|
|
*/
|
|
inline void *native_malloc(size_t size)
|
|
{
|
|
return malloc(size);
|
|
}
|
|
|
|
/*
|
|
* Wrapper function to ensure we have an explicit handle on the heap allocator provided
|
|
* by our underlying platform.
|
|
*
|
|
* @param p Pointer to the memory to be freed.
|
|
*/
|
|
inline void native_free(void *p)
|
|
{
|
|
free(p);
|
|
}
|
|
|
|
/**
|
|
* Overrides the 'new' operator globally, and redirects calls to the micro:bit theap allocator.
|
|
*/
|
|
inline void* operator new(size_t size) throw(std::bad_alloc)
|
|
{
|
|
return microbit_malloc(size);
|
|
}
|
|
|
|
/**
|
|
* Overrides the 'delete' operator globally, and redirects calls to the micro:bit theap allocator.
|
|
*/
|
|
inline void operator delete(void *ptr) throw()
|
|
{
|
|
microbit_free(ptr);
|
|
}
|
|
|
|
|
|
// Macros to override overrides the 'malloc' and 'delete' functions globally, and redirects calls
|
|
// to the micro:bit theap allocator.
|
|
|
|
#define malloc(X) microbit_malloc( X )
|
|
#define free(X) microbit_free( X )
|
|
|
|
#endif
|