Surrogate Cache Architecture for Low-Latency Access Decisions
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing systems face challenges in processing real-time access requests efficiently due to the processing-intensive and latency-intensive nature of determining user access, particularly when dealing with large numbers of user accounts, leading to cache misses and significant retrieval and processing delays.
Innovation Solution
Implementing a two-level cache system, comprising a first cache for full user objects and a second surrogate cache with compact user objects, where the compact user objects include a single field indicating whether a request should be granted, derived from full user object fields using offline update logic, allowing rapid access decisions without extensive retrieval and processing.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If a single cache stores full user objects for all users, then comprehensive user data is available, but cache size becomes too large causing frequent cache misses and increased latency
Solution Approach 1:
The patent divides the cache into two distinct levels: a first cache storing compact user objects with only essential access decision fields, and a second cache storing full user objects with complete user data. This segmentation allows the system to quickly serve access decisions from the small first cache while maintaining comprehensive data in the second cache, thereby reducing latency without sacrificing data completeness.
Solution Approach 2:
The patent extracts only the critical fields needed for access decisions (such as service identifiers and allowance status) from the full user objects and places them in the first cache. This extraction enables rapid access decision-making without retrieving entire user objects, significantly reducing processing time while maintaining access decision accuracy.
2Ease of operation
If full user objects are stored in cache for every user, then complete user information is available for processing, but the cache becomes too large to store all user data in memory
Solution Approach 1:
The patent applies different data storage strategies to different parts of the user data hierarchy. The first cache stores only the locally essential compact user objects with minimal fields required for immediate access decisions, while the second cache stores the complete full user objects. This local quality differentiation optimizes memory usage by storing only necessary data in the fast but limited first cache.
Solution Approach 2:
The patent creates simplified copies of user objects for the first cache, containing only the critical fields needed for access decisions. These compact copies are much smaller than full user objects, allowing the system to maintain copies for all users in the first cache without exceeding memory constraints, while full user objects remain in the second cache.
3Reliability
If real-time processing is performed on full user objects for each access request, then accurate access decisions can be made, but processing time and computational resources are excessively consumed
Solution Approach 1:
The patent performs preliminary processing by pre-computing access decision fields in the compact user objects stored in the first cache. These fields are updated in advance based on changes to full user objects, so when an access request arrives, the system can immediately retrieve pre-computed decision information without performing time-consuming real-time calculations on full user objects, thereby increasing processing throughput while maintaining accuracy.
Solution Approach 2:
The compact user objects in the first cache serve as intermediaries between the full user objects in the second cache and the access decision-making process. Instead of directly processing full user objects for each access request, the system uses the compact intermediaries that contain pre-computed decision fields, significantly reducing computational overhead while preserving access control accuracy.
Data Source
Figure 1
Figure 2
Figure 3
AI summary
When a request for accessing a service is received, a user object may be stored in a long-term data store, as well as in a short-term cache. The cache may be divided into a regular cache that stores full versions of the user objects, and a surrogate cache that stores compact versions of the user object. The compact version of the user object may include a field that is derived from the full user object indicating whether a subsequent request for access to a particular service should be granted. After access is granted/denied based on this value in the compact user object, the system can process an update to the full user object offline. This surrogate cache structure may be used to rapidly approve/deny requests, decoupling this procedure from the processing involved with a full user object.