Cache Manager Reference Counting for Image Sharing
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Conventional systems face inefficiencies in managing image storage and retrieval, particularly in graphical user interfaces, where storing and accessing images of varying sizes leads to processing overhead due to timestamp management and repeated requests for larger image versions, resulting in increased storage and processing costs.
Innovation Solution
The Cache Manager system allows multiple active views to share locally stored images by using reference counters to track instances of image display, enabling efficient reuse of larger-sized images without the need for repeated requests from the image repository, while delaying the removal of images from cache to optimize storage usage.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Speed
If conventional systems store images at small sizes for quick access and display, then image rendering speed is improved, but image quality deteriorates when larger sizes are needed
Solution Approach 1:
The system segments image storage into multiple size versions (small thumbnails and large original images). Small images are stored in cache for quick display during scrolling, while large images are stored separately in the image repository. When users need to view images in larger size, the system retrieves the appropriate large version without requiring re-fetching or re-computation, thus resolving the contradiction between fast rendering and high quality.
2Quantity of substance
If conventional systems store maximum image data in memory, then image availability is improved, but processing overhead increases due to timestamp management
Solution Approach 1:
The system extracts the timestamp management complexity from the core cache management process. Instead of continuously monitoring and sorting all cached images by timestamp, the system only tracks reference counts for images that have been displayed. This extraction of the timing-based management complexity reduces processing overhead while maintaining effective cache utilization.
Solution Approach 2:
The cache management system uses reference counts to automatically determine which images to retain or remove. Each cached image maintains a reference count that increments when displayed and decrements when no longer needed. When the reference count reaches zero, the image is automatically removed from cache. This self-service mechanism eliminates the need for continuous timestamp monitoring and sorting algorithms.
3Measurement precision
If conventional systems continuously monitor and manage image time stamps, then image eviction accuracy is improved, but processing overhead increases
Solution Approach 1:
The system implements self-service cache management through reference counting. Each image in the cache maintains a reference count that automatically tracks how many active views are displaying it. When an image is no longer referenced (count reaches zero), it is automatically evicted from cache. This eliminates the need for continuous timestamp monitoring and sorting algorithms, significantly reducing processing overhead while maintaining accurate eviction decisions.
4Reliability
If multiple active views request the same larger-sized image independently, then image availability is improved, but storage costs increase due to redundant requests
Solution Approach 1:
The system merges multiple independent image requests into a single cache-shared resource. When one active view requests a large-sized image, it is fetched from the image repository and stored in the cache with a reference count. Subsequent requests from other active views for the same image are served from the cache without triggering additional repository requests. The reference count ensures the image remains in cache as long as any view needs it, eliminating redundant storage and network operations.
Data Source
AI summary
Methods and apparatus provide for a Cache Manager to display a scaled image in an active view. The scaled image comprises the same content as an image from a stored collection of images, which is accessible by a plurality of active views in a user interface. The Cache Manager refreshes the active view to replace the displayed scaled image with a larger-sized image, which comprises the same content as the displayed scaled image. A reference counter associated with the larger-sized image is maintained to keep track of instances of display of the larger-sized image by any of the plurality of active views. The Cache Manager allows any other active view to use the larger-sized image while a current value of the reference counter is greater than zero.