Dynamic Cache Packing with Variable Bitmap Blocks
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Conventional caching techniques for data objects are inefficient as they store objects sequentially without considering individual object sizes, leading to increased memory usage, CPU resources, and frequent cache flushing, which reduces the utility of on-chip memory.
Innovation Solution
A method for dynamic cache packing that determines whether a data object fits within existing free blocks in a memory bitmap, resizing or creating new blocks as necessary, and maintaining a list of free blocks to optimize storage and reduce wasted space.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Ease of manufacture
If objects are stored sequentially without considering individual object size, then the caching mechanism is simple to implement, but memory usage increases and cache capacity is reduced
Solution Approach 1:
The cache is segmented into variable-sized blocks instead of fixed sequential positions. Each block is dynamically sized to fit the specific data object, allowing efficient packing of different sized objects without wasted space. The system maintains a list of free blocks with their respective sizes to facilitate this segmented storage approach.
Solution Approach 2:
The block size parameter is changed from fixed to variable based on the data object size. The system dynamically adjusts block parameters (size, position) to match the stored objects, optimizing memory utilization. This parameter adaptation resolves the contradiction between simple implementation and efficient memory usage.
2Quantity of substance
If larger bitmaps are used to store more drawing objects, then more objects can be cached, but CPU resources and memory bandwidth increase
Solution Approach 1:
The cache is divided into multiple smaller variable-sized blocks rather than using one large bitmap. This segmentation allows the system to store more objects in the same memory space by eliminating gaps between objects of different sizes, increasing cache capacity without requiring additional memory bandwidth or CPU resources.
Solution Approach 2:
Multiple data objects of varying sizes are nested within the cache structure like dolls in a matryoshka, with each object fitting into its own optimized block. This nested packing maximizes the use of available cache space, allowing more objects to be stored without increasing the overall memory footprint or access overhead.
3Manufacturing precision
If fewer drawing objects are stored per bitmap, then each object gets more space, but the cache fills up quickly and requires frequent flushing
Solution Approach 1:
The cache structure is made dynamic with variable-sized blocks that can be allocated and deallocated based on the needs of different data objects. This dynamic allocation allows the cache to adapt to varying object sizes and maintain high utilization without frequent flushing, resolving the contradiction between precise object storage and cache productivity.
Solution Approach 2:
The block size parameter is dynamically changed to match each data object's requirements. By adjusting block parameters rather than using fixed sizes, the system achieves both precise object storage (minimal wasted space) and high cache utility (more objects per cache), eliminating the need for frequent cache flushing.
4Device complexity
If sequential storage without size consideration is used, then implementation is straightforward, but more memory is required to store necessary bitmaps
Solution Approach 1:
The straightforward sequential storage is segmented into variable-sized blocks organized in a list structure. This segmentation allows efficient memory packing while maintaining relatively simple implementation through the use of a free block list that tracks available space, resolving the contradiction between simplicity and memory efficiency.
Solution Approach 2:
The free block list structure serves multiple functions: it tracks available space, manages block allocation, and optimizes memory usage. This universal data structure handles both the simplicity of implementation and the efficiency of memory consumption, allowing the same mechanism to address both requirements.
Data Source
AI summary
A method for storing information may include determining whether a received data object fits inside a particular one of a plurality of free blocks in a memory bitmap. Each of the plurality of free blocks may include a column of the memory bitmap with a top margin, a bottom margin, and a predetermined width. If the received data object fits, the received data object may be stored in the particular one of the plurality of free blocks, starting at the margin of the particular one of the plurality of free blocks. The particular one of the plurality of data blocks may be resized by moving the margin to start below or next to the stored received data object. The determining may include, for each of the plurality of free blocks, a height of the received data object may be compared with a height of each of the free data blocks.