mirrors
/
micropython
mirror of https://github.com/micropython/micropython.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Created Memory Manager (markdown)

Garrett Berg 2015-03-11 14:03:26 -06:00
parent c0a508be50
commit 285349c7a9
1 changed files with 43 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

43
Memory-Manager.md Normal file

@ -0,0 +1,43 @@
## User Level Functions
The main functions that a user needs are:
`gc_alloc` -- malloc with gc
`gc_free` -- free with gc
These are built on top of a memory structure using Allocation Table Bytes (ATBs)
## Memory Structure
Memory is split up into 4 Allocation Tables. Every Allocation Table has a `ATB` which stands for "Allocation Table Byte". This is a single byte containing 4 sets of the following
```
// 0b00 = FREE -- free block
// 0b01 = HEAD -- head of a chain of blocks
// 0b10 = TAIL -- in the tail of a chain of blocks
// 0b11 = MARK -- marked head block
```
These are known as `ATB_0` through `ATB_3` and have several C methods (i.e. functions and macros) to access their attributes. These include:
BLOCKS_PER_ATB -- The number of ATB's that fit in an Allocation Table
ATB_MASK_0 -- Get the relevant bytes for ATB_0
...
ATB_MASK_3
ATB_0_IS_FREE(a) -- Determine whether table is currently free
...
ATB_3_IS_FREE(a)
**What do these do? Why are they useful???**
BLOCK_SHIFT(block)
ATB_GET_KIND(block)
ATB_ANY_TO_FREE(block)
ATB_FREE_TO_HEAD(block)
ATB_FREE_TO_TAIL(block)
ATB_HEAD_TO_MARK(block)
ATB_MARK_TO_HEAD(block)
BLOCK_FROM_PTR(ptr)
PTR_FROM_BLOCK(block)
ATB_FROM_BLOCK(bl)
## Questions
- Is there documentation for the above methods? I think that would help me understand what they do
- How is the memory structured? How is it gotten? Does python take out an array of data, or does it take out single elements at at time? I am having trouble understanding how this memory manager is supposed to be used.
- How many pointers can the memory manager handle at once (on your reference implementation, I believe 128k of memory)? Does the size of the data being requested matter? How does it deal with fragmentation? For instance, if the system asks for a few 100byte arrays and a few 5byte structs one after another, and then frees the 100byte arrays -- how does it handle the fragmentation? Is there a memory defragmenter?