Edge Cache Invalidation via Shared Manager
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Current systems face inefficiencies in delivering up-to-date data and metadata across geographically dispersed user locations due to bandwidth and latency issues, particularly in enterprise applications, where traditional synchronous data refresh methods consume significant resources and may not propagate all data changes effectively.
Innovation Solution
The system employs edge caching to store and manage derived data locally near users, using a shared cache manager that monitors core data changes, infers impacts on derived data, and pre-caches updates, allowing for efficient propagation and retrieval of up-to-date data without synchronous requests, thereby reducing latency and bandwidth usage.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If traditional synchronous data refresh methods are used, then data can be kept up-to-date across distributed systems, but significant bandwidth and latency resources are consumed
Solution Approach 1:
The system performs preliminary actions by pre-caching data at edge locations before it is actually needed by users. The shared cache manager proactively identifies and caches data that is likely to be requested, so when users access the data, it is already available locally without requiring synchronous refresh operations.
Solution Approach 2:
The patent introduces a shared cache manager as an intermediary between the data source and edge caches. This mediator coordinates data invalidation and refresh operations across the distributed cache hierarchy, allowing efficient propagation of data changes without requiring each edge cache to independently poll or synchronously refresh from the source.
2Loss of time
If data is cached at edge locations, then page load time is reduced to zero milliseconds, but ensuring data coherence across distributed caches becomes complex
Solution Approach 1:
The system implements feedback mechanisms where the shared cache manager monitors data changes at the source and automatically propagates invalidation signals to edge caches. This feedback loop ensures that when data changes, all distributed caches are notified and updated accordingly, maintaining coherence without requiring complex manual synchronization protocols.
Solution Approach 2:
The patent merges the cache management functionality into a centralized shared cache manager that handles coordination for all edge caches. Instead of each edge cache independently managing its own coherence, the system combines these functions into a single coordinating service that manages invalidation and refresh operations across the entire cache hierarchy.
3Measurement precision
If synchronous calls are made to the originating server for every data access, then data accuracy is maintained, but up to eighty percent of available time is expended on data refreshing
Solution Approach 1:
The system performs preliminary data caching actions at edge locations before users actually need the data. The shared cache manager proactively fetches and caches data that is likely to be requested, so when users access it, the data is already available locally with zero page load time, eliminating the need for synchronous calls at access time.
Solution Approach 2:
The system transitions from synchronous periodic polling to asynchronous periodic refresh operations. The shared cache manager periodically checks for data changes and refreshes edge caches asynchronously, maintaining data accuracy without blocking user operations or consuming synchronous time resources.
Data Source
AI summary
To deliver up-to-date, coherent user data to applications upon request, the disclosed technology includes systems and methods for caching data and metadata after it has been synchronously loaded—for future retrieval with a page load time close to zero milliseconds. To provide this experience, data needs to be stored as locally to a user as possible, in the cache on the local device or in an edge cache located geographically nearby, for use in responding to requests. Applications which maintain caches of API results can be notified of their invalidation, and can detect the invalidation, propagate the invalidation to any further client tiers with the appropriate derivative type mapping, and refresh their cached values so that clients need not synchronously make the API requests again—ensuring that the client has access to the most up-to-date copy of data as inexpensively as possible—in terms of bandwidth and latency.