Concurrent Data Store Allocation via Bitmap Segmentation
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing storage systems face inefficiencies due to contention issues when multiple threads attempt to access the same bitmap, leading to performance degradation and potential errors, and they struggle to distribute workload evenly across storage segments, causing 'hot spots' that reduce performance and device lifetime.
Innovation Solution
Implementing multiple bitmaps, each representing a storage segment, allows threads to operate independently, minimizing contention by assigning each thread a unique bitmap, thereby ensuring concurrent writes can be executed in parallel without shared resource access, and dynamically reallocating threads across bitmaps to distribute workload evenly.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Quantity of substance
If a single bitmap is used to represent data store availability, then memory overhead is minimized, but contention occurs when multiple threads attempt to update the bitmap simultaneously
Solution Approach 1:
The patent divides the single bitmap into multiple separate bitmaps, each representing a different segment of the data store. Each thread is assigned to a specific bitmap, allowing concurrent updates without contention. This segmentation resolves the contradiction by trading increased memory overhead (multiple bitmaps instead of one) for reliable contention-free operation across multiple threads.
2Productivity
If multiple bitmaps are assigned to threads, then contention is reduced and performance improves, but memory overhead increases
Solution Approach 1:
The data store is segmented into multiple regions, each with its own bitmap. Threads are assigned to specific segments/bitmaps based on workload distribution. This allows high concurrent write performance while controlling memory overhead by only creating bitmaps for segments that are actively being written to, rather than pre-creating bitmaps for all possible segments.
Solution Approach 2:
The system dynamically allocates and deallocates bitmaps based on actual usage patterns. Bitmaps are created when segments are activated and removed when segments are no longer in use. This dynamic approach maintains high productivity by ensuring bitmaps are available when needed while minimizing memory overhead by removing unused bitmaps.
3Quantity of substance
If threads share the same bitmap, then memory usage is efficient, but hot spots are created that reduce performance and device lifetime
Solution Approach 1:
The patent segments the data store into multiple regions with separate bitmaps, distributing write operations across different segments. This prevents hot spots by ensuring that concurrent writes are directed to different physical locations on the storage device, thereby extending device lifetime while maintaining efficient memory usage through targeted bitmap allocation.
Solution Approach 2:
Different segments of the data store are assigned different bitmaps, allowing each segment to be managed independently. This local differentiation prevents any single segment from becoming a hot spot, distributing wear and write intensity across the entire storage device, thus extending overall device lifetime.
Data Source
AI summary
Methods, systems, and apparatus, including computer programs encoded on computer storage media, for executing concurrent writes to a data store. One of the systems includes a data store comprising a plurality of storage segments, wherein each storage segment comprises a plurality of blocks; and an allocator system comprising: a plurality of threads, and a plurality of bitmaps each corresponding to a respective storage segment of the data store, wherein the allocator system is configured to perform operations comprising: assigning a respective bitmap to each thread of the plurality of threads; and executing, by each thread of the plurality of threads, one or more write requests to one or more blocks of the storage segment corresponding to the thread using the bitmap assigned to the thread, wherein executing a write request by a thread includes updating the bitmap assigned to the thread.