Core Snooping Cache with Adjacent Pool Lookup
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Conventional per-core cache systems in multi-core computing environments suffer from excessive memory usage due to data duplication across processing cores, leading to increased latency and inefficient cache hits.
Innovation Solution
Implement a software cache that stores only references to data objects in multiple core pools, allowing processing cores to perform lookups in adjacent core pools when local cache misses occur, and employs a purging mechanism to manage memory usage based on access patterns.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If data is duplicated across all core pools for each processing core, then cache hit rate is improved, but memory consumption increases significantly
Solution Approach 1:
The cache is segmented into multiple core pools, where each pool is associated with specific processing cores. Data is not duplicated across all pools but is strategically placed in subsets of pools, allowing cores to access data through local pools or adjacent pools, thus reducing overall memory consumption while maintaining accessibility.
Solution Approach 2:
The patent introduces a dimensional approach by organizing caches into hierarchical pools (local core pool, adjacent core pools, and remote core pools). This multi-dimensional structure allows the system to balance between local cache hit rates and global memory efficiency by accessing data across different pool dimensions rather than duplicating data universally.
2Quantity of substance
If data is stored in local core pool only, then memory consumption is reduced, but cache hit rate decreases due to cache misses
Solution Approach 1:
Adjacent core pools serve as intermediary structures between local and remote pools. When a core experiences a cache miss in its local pool, the system checks adjacent pools as intermediaries before accessing remote pools or main memory, thereby improving hit rates with minimal additional memory overhead.
Solution Approach 2:
Each core pool serves multiple functions: it acts as a local cache for its associated cores, an adjacent cache for neighboring cores, and potentially a remote cache for other cores. This multi-functionality allows the same data structure to serve multiple access patterns without requiring separate dedicated storage for each access scenario.
3Speed
If data is distributed across many core pools, then access latency is reduced, but system complexity increases
Solution Approach 1:
The system implements local quality by optimizing data placement in adjacent core pools based on access patterns. Frequently accessed data is placed in pools that are geographically or logically closer to the accessing cores, reducing access latency without requiring complex global optimization algorithms across all pools.
Solution Approach 2:
The cache pool associations and data placement strategies are dynamic rather than static. The system can adaptively adjust which pools are considered adjacent or remote based on runtime performance metrics, allowing it to optimize for speed without hardcoding complex access patterns into the system architecture.
Data Source
AI summary
Systems and methods described herein relate to a software cache that implements a processing core snooping mechanism. A reference to a data object is stored in a plurality of core pools of the software cache. Each core pool is uniquely associated with a respective processing core. The storing of the reference enables access to the reference from every core pool. A cache miss occurs with respect to a target reference when a first processing core does not find the target reference in a first core pool that is uniquely associated with the first processing core. In response to the cache miss, the target reference is retrieved from a second core pool that is uniquely associated with a second processing core. The second core pool is reachable from the first core pool. The target reference retrieved from the second core pool is copied to the first core pool.