diff options
Diffstat (limited to 'supervisor')
| -rwxr-xr-x | supervisor/memory.h | 8 | ||||
| -rwxr-xr-x | supervisor/shared/memory.c | 112 | ||||
| -rwxr-xr-x | supervisor/shared/stack.c | 4 | ||||
| -rw-r--r-- | supervisor/supervisor.mk | 1 |
4 files changed, 122 insertions, 3 deletions
diff --git a/supervisor/memory.h b/supervisor/memory.h index 1d64c2cde..4f8317a2d 100755 --- a/supervisor/memory.h +++ b/supervisor/memory.h @@ -24,6 +24,10 @@ * THE SOFTWARE. */ +// Basic allocations outside them for areas such as the VM heap and stack. +// supervisor/shared/memory.c has a basic implementation for a continuous chunk of memory. Add it +// to a SRC_ in a Makefile to use it. + #ifndef MICROPY_INCLUDED_SUPERVISOR_MEMORY_H #define MICROPY_INCLUDED_SUPERVISOR_MEMORY_H @@ -38,6 +42,10 @@ typedef struct { void memory_init(void); void free_memory(supervisor_allocation* allocation); supervisor_allocation* allocate_remaining_memory(void); + +// Allocate a piece of a given length in bytes. If high_address is true then it should be allocated +// at a lower address from the top of the stack. Otherwise, addresses will increase starting after +// statically allocated memory. supervisor_allocation* allocate_memory(uint32_t length, bool high_address); #endif // MICROPY_INCLUDED_SUPERVISOR_MEMORY_H diff --git a/supervisor/shared/memory.c b/supervisor/shared/memory.c new file mode 100755 index 000000000..051f55a70 --- /dev/null +++ b/supervisor/shared/memory.c @@ -0,0 +1,112 @@ +/* + * This file is part of the MicroPython project, http://micropython.org/ + * + * The MIT License (MIT) + * + * Copyright (c) 2018 Scott Shawcroft for Adafruit Industries + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +#include "supervisor/memory.h" + +#include <stddef.h> + +#define CIRCUITPY_SUPERVISOR_ALLOC_COUNT 8 + +static supervisor_allocation allocations[CIRCUITPY_SUPERVISOR_ALLOC_COUNT]; +// We use uint32_t* to ensure word (4 byte) alignment. +uint32_t* low_address; +uint32_t* high_address; +extern uint32_t _ebss; +extern uint32_t _estack; + +void memory_init(void) { + low_address = &_ebss; + high_address = &_estack; +} + +void free_memory(supervisor_allocation* allocation) { + uint8_t index = 0; + bool found = false; + for (index = 0; index < CIRCUITPY_SUPERVISOR_ALLOC_COUNT; index++) { + found = allocation == &allocations[index]; + if (found) { + break; + } + } + if (allocation->ptr == high_address) { + high_address += allocation->length / 4; + for (index++; index < CIRCUITPY_SUPERVISOR_ALLOC_COUNT; index++) { + if (allocations[index].ptr != NULL) { + break; + } + high_address += allocations[index].length / 4; + } + } else if (allocation->ptr + allocation->length / 4 == low_address) { + low_address = allocation->ptr; + for (index--; index >= 0; index--) { + if (allocations[index].ptr != NULL) { + break; + } + low_address -= allocations[index].length / 4; + } + } else { + // Freed memory isn't in the middle so skip updating bounds. The memory will be added to the + // middle when the memory to the inside is freed. + } + allocation->ptr = NULL; +} + +supervisor_allocation* allocate_remaining_memory(void) { + if (low_address == high_address) { + return NULL; + } + return allocate_memory((high_address - low_address) * 4, false); +} + +supervisor_allocation* allocate_memory(uint32_t length, bool high) { + if ((high_address - low_address) * 4 < (int32_t) length || length % 4 != 0) { + return NULL; + } + uint8_t index = 0; + int8_t direction = 1; + if (high) { + index = CIRCUITPY_SUPERVISOR_ALLOC_COUNT - 1; + direction = -1; + } + for (; index < CIRCUITPY_SUPERVISOR_ALLOC_COUNT; index += direction) { + if (allocations[index].ptr == NULL) { + break; + } + } + if (index >= CIRCUITPY_SUPERVISOR_ALLOC_COUNT) { + return NULL; + } + supervisor_allocation* alloc = &allocations[index]; + if (high) { + high_address -= length / 4; + alloc->ptr = high_address; + } else { + alloc->ptr = low_address; + low_address += length / 4; + } + alloc->length = length; + return alloc; +} diff --git a/supervisor/shared/stack.c b/supervisor/shared/stack.c index f6c74e6d8..6b74742eb 100755 --- a/supervisor/shared/stack.c +++ b/supervisor/shared/stack.c @@ -52,11 +52,11 @@ void allocate_stack(void) { } } -inline void stack_init(void) { +void stack_init(void) { allocate_stack(); } -inline void stack_resize(void) { +void stack_resize(void) { if (next_stack_size == current_stack_size) { return; } diff --git a/supervisor/supervisor.mk b/supervisor/supervisor.mk index ba5ffb3f3..20de58001 100644 --- a/supervisor/supervisor.mk +++ b/supervisor/supervisor.mk @@ -1,6 +1,5 @@ SRC_SUPERVISOR = \ main.c \ - supervisor/memory.c \ supervisor/port.c \ supervisor/shared/autoreload.c \ supervisor/shared/rgb_led_status.c \ |