Header-less Dynamic Memory Allocation for Mobile Devices
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing dynamic memory allocation schemes are inefficient for mobile devices, particularly when allocating small blocks of memory, leading to high overhead and reduced memory usage efficiency due to header-based allocation methods and inefficiencies in re-allocation schemes, resulting in low memory usage and potential system crashes from memory exhaustion.
Innovation Solution
A header-less dynamic memory allocation architecture that manages memory by maintaining a freelist of fixed-size blocks, allowing for efficient re-use of previously allocated blocks and minimizing fragmentation, thereby maximizing memory utilization.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If header-based dynamic memory allocation is used, then memory can be dynamically requested and released, but significant overhead is incurred reducing effective memory available for data storage
Solution Approach 1:
The patent extracts and removes the header from the memory block structure. Instead of having each memory block contain a header with size information, the system maintains a separate freelist that tracks free blocks and their sizes. This extraction eliminates the overhead that was consuming valuable memory space in small blocks.
Solution Approach 2:
The patent introduces a freelist as an intermediary data structure that mediates between the memory manager and the actual memory blocks. The freelist stores information about free blocks, allowing the system to track and manage memory without embedding overhead in each block itself. This intermediary approach separates the metadata storage from the data storage.
2Adaptability or versatility
If heap-based allocation scheme is used to search for freed blocks, then memory can be re-allocated, but the scheme is processor intensive negatively impacting system performance
Solution Approach 1:
The patent performs preliminary action by maintaining the freelist in advance, organizing free blocks before they are needed for allocation. When a block is freed, it is immediately added to the freelist with its size and location information already prepared. This eliminates the need for processor-intensive searching at allocation time, as the system can simply select from the pre-organized freelist.
3Adaptability or versatility
If buddy block scheme is used to maintain linked list of free blocks, then memory can be re-allocated, but the scheme is memory intensive as the number of buddy blocks grows
Solution Approach 1:
The patent makes the freelist entries multi-functional. Each freelist entry serves multiple purposes: it identifies a free block, stores its size, indicates its location, and can be used for both allocation and coalescing operations. This universality reduces the overall memory overhead compared to separate data structures for each function.
4Adaptability or versatility
If standard memory allocation schemes are used, then memory blocks can be allocated and released, but internal fragmentation occurs resulting in wasted space
Solution Approach 1:
The patent changes the parameter of block size tracking from embedded headers to external freelist entries. By storing size information in the freelist rather than in each block's header, the system can more efficiently track and utilize variable-sized blocks without the fixed overhead that causes internal fragmentation. This parameter change allows for more flexible and efficient memory utilization.
Data Source
AI summary
A method for managing the allocation of memory to one or more applications. The method includes allocating a variety of fixed size memory blocks to a requesting application, each of the fixed size memory blocks being free of header information to maximize memory usage. Free, or unused blocks of data of the same fixed size are maintained in a freelist having a number of block roots corresponding to the number of differently fixed size memory blocks. Each block root stores a root pointer to an unused memory block previously allocated to the application. To conserve memory, each unused memory block will store branch pointers to other identically sized unused memory blocks, thereby forming a sequential chain of unused memory blocks with the block root. Therefore, applications requesting the same sized memory block can re-use previously allocated fixed size memory blocks.